import {
  __commonJS,
  __esm,
  __export,
  __require,
  __toCommonJS
} from "./chunk-S5KM4IGW.js";

// node_modules/url/node_modules/punycode/punycode.js
var require_punycode = __commonJS({
  "node_modules/url/node_modules/punycode/punycode.js"(exports2, module2) {
    (function(root) {
      var freeExports = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2;
      var freeModule = typeof module2 == "object" && module2 && !module2.nodeType && module2;
      var freeGlobal = typeof global == "object" && global;
      if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
        root = freeGlobal;
      }
      var punycode2, maxInt = 2147483647, base = 36, tMin = 1, tMax = 26, skew = 38, damp = 700, initialBias = 72, initialN = 128, delimiter = "-", regexPunycode = /^xn--/, regexNonASCII = /[^\x20-\x7E]/, regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, errors = {
        "overflow": "Overflow: input needs wider integers to process",
        "not-basic": "Illegal input >= 0x80 (not a basic code point)",
        "invalid-input": "Invalid input"
      }, baseMinusTMin = base - tMin, floor = Math.floor, stringFromCharCode = String.fromCharCode, key;
      function error(type) {
        throw RangeError(errors[type]);
      }
      function map(array, fn) {
        var length3 = array.length;
        var result = [];
        while (length3--) {
          result[length3] = fn(array[length3]);
        }
        return result;
      }
      function mapDomain(string, fn) {
        var parts = string.split("@");
        var result = "";
        if (parts.length > 1) {
          result = parts[0] + "@";
          string = parts[1];
        }
        string = string.replace(regexSeparators, ".");
        var labels = string.split(".");
        var encoded = map(labels, fn).join(".");
        return result + encoded;
      }
      function ucs2decode(string) {
        var output = [], counter = 0, length3 = string.length, value, extra;
        while (counter < length3) {
          value = string.charCodeAt(counter++);
          if (value >= 55296 && value <= 56319 && counter < length3) {
            extra = string.charCodeAt(counter++);
            if ((extra & 64512) == 56320) {
              output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
            } else {
              output.push(value);
              counter--;
            }
          } else {
            output.push(value);
          }
        }
        return output;
      }
      function ucs2encode(array) {
        return map(array, function(value) {
          var output = "";
          if (value > 65535) {
            value -= 65536;
            output += stringFromCharCode(value >>> 10 & 1023 | 55296);
            value = 56320 | value & 1023;
          }
          output += stringFromCharCode(value);
          return output;
        }).join("");
      }
      function basicToDigit(codePoint) {
        if (codePoint - 48 < 10) {
          return codePoint - 22;
        }
        if (codePoint - 65 < 26) {
          return codePoint - 65;
        }
        if (codePoint - 97 < 26) {
          return codePoint - 97;
        }
        return base;
      }
      function digitToBasic(digit, flag) {
        return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
      }
      function adapt(delta, numPoints, firstTime) {
        var k = 0;
        delta = firstTime ? floor(delta / damp) : delta >> 1;
        delta += floor(delta / numPoints);
        for (; delta > baseMinusTMin * tMax >> 1; k += base) {
          delta = floor(delta / baseMinusTMin);
        }
        return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
      }
      function decode(input) {
        var output = [], inputLength = input.length, out, i2 = 0, n2 = initialN, bias = initialBias, basic, j, index2, oldi, w, k, digit, t, baseMinusT;
        basic = input.lastIndexOf(delimiter);
        if (basic < 0) {
          basic = 0;
        }
        for (j = 0; j < basic; ++j) {
          if (input.charCodeAt(j) >= 128) {
            error("not-basic");
          }
          output.push(input.charCodeAt(j));
        }
        for (index2 = basic > 0 ? basic + 1 : 0; index2 < inputLength; ) {
          for (oldi = i2, w = 1, k = base; ; k += base) {
            if (index2 >= inputLength) {
              error("invalid-input");
            }
            digit = basicToDigit(input.charCodeAt(index2++));
            if (digit >= base || digit > floor((maxInt - i2) / w)) {
              error("overflow");
            }
            i2 += digit * w;
            t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
            if (digit < t) {
              break;
            }
            baseMinusT = base - t;
            if (w > floor(maxInt / baseMinusT)) {
              error("overflow");
            }
            w *= baseMinusT;
          }
          out = output.length + 1;
          bias = adapt(i2 - oldi, out, oldi == 0);
          if (floor(i2 / out) > maxInt - n2) {
            error("overflow");
          }
          n2 += floor(i2 / out);
          i2 %= out;
          output.splice(i2++, 0, n2);
        }
        return ucs2encode(output);
      }
      function encode(input) {
        var n2, delta, handledCPCount, basicLength, bias, j, m, q, k, t, currentValue, output = [], inputLength, handledCPCountPlusOne, baseMinusT, qMinusT;
        input = ucs2decode(input);
        inputLength = input.length;
        n2 = initialN;
        delta = 0;
        bias = initialBias;
        for (j = 0; j < inputLength; ++j) {
          currentValue = input[j];
          if (currentValue < 128) {
            output.push(stringFromCharCode(currentValue));
          }
        }
        handledCPCount = basicLength = output.length;
        if (basicLength) {
          output.push(delimiter);
        }
        while (handledCPCount < inputLength) {
          for (m = maxInt, j = 0; j < inputLength; ++j) {
            currentValue = input[j];
            if (currentValue >= n2 && currentValue < m) {
              m = currentValue;
            }
          }
          handledCPCountPlusOne = handledCPCount + 1;
          if (m - n2 > floor((maxInt - delta) / handledCPCountPlusOne)) {
            error("overflow");
          }
          delta += (m - n2) * handledCPCountPlusOne;
          n2 = m;
          for (j = 0; j < inputLength; ++j) {
            currentValue = input[j];
            if (currentValue < n2 && ++delta > maxInt) {
              error("overflow");
            }
            if (currentValue == n2) {
              for (q = delta, k = base; ; k += base) {
                t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
                if (q < t) {
                  break;
                }
                qMinusT = q - t;
                baseMinusT = base - t;
                output.push(
                  stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
                );
                q = floor(qMinusT / baseMinusT);
              }
              output.push(stringFromCharCode(digitToBasic(q, 0)));
              bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
              delta = 0;
              ++handledCPCount;
            }
          }
          ++delta;
          ++n2;
        }
        return output.join("");
      }
      function toUnicode(input) {
        return mapDomain(input, function(string) {
          return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
        });
      }
      function toASCII(input) {
        return mapDomain(input, function(string) {
          return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
        });
      }
      punycode2 = {
        "version": "1.3.2",
        "ucs2": {
          "decode": ucs2decode,
          "encode": ucs2encode
        },
        "decode": decode,
        "encode": encode,
        "toASCII": toASCII,
        "toUnicode": toUnicode
      };
      if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
        define("punycode", function() {
          return punycode2;
        });
      } else if (freeExports && freeModule) {
        if (module2.exports == freeExports) {
          freeModule.exports = punycode2;
        } else {
          for (key in punycode2) {
            punycode2.hasOwnProperty(key) && (freeExports[key] = punycode2[key]);
          }
        }
      } else {
        root.punycode = punycode2;
      }
    })(exports2);
  }
});

// node_modules/url/util.js
var require_util = __commonJS({
  "node_modules/url/util.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      isString: function(arg) {
        return typeof arg === "string";
      },
      isObject: function(arg) {
        return typeof arg === "object" && arg !== null;
      },
      isNull: function(arg) {
        return arg === null;
      },
      isNullOrUndefined: function(arg) {
        return arg == null;
      }
    };
  }
});

// node_modules/querystring/decode.js
var require_decode = __commonJS({
  "node_modules/querystring/decode.js"(exports2, module2) {
    "use strict";
    function hasOwnProperty2(obj, prop) {
      return Object.prototype.hasOwnProperty.call(obj, prop);
    }
    module2.exports = function(qs, sep, eq, options) {
      sep = sep || "&";
      eq = eq || "=";
      var obj = {};
      if (typeof qs !== "string" || qs.length === 0) {
        return obj;
      }
      var regexp = /\+/g;
      qs = qs.split(sep);
      var maxKeys = 1e3;
      if (options && typeof options.maxKeys === "number") {
        maxKeys = options.maxKeys;
      }
      var len = qs.length;
      if (maxKeys > 0 && len > maxKeys) {
        len = maxKeys;
      }
      for (var i2 = 0; i2 < len; ++i2) {
        var x = qs[i2].replace(regexp, "%20"), idx = x.indexOf(eq), kstr, vstr, k, v7;
        if (idx >= 0) {
          kstr = x.substr(0, idx);
          vstr = x.substr(idx + 1);
        } else {
          kstr = x;
          vstr = "";
        }
        k = decodeURIComponent(kstr);
        v7 = decodeURIComponent(vstr);
        if (!hasOwnProperty2(obj, k)) {
          obj[k] = v7;
        } else if (Array.isArray(obj[k])) {
          obj[k].push(v7);
        } else {
          obj[k] = [obj[k], v7];
        }
      }
      return obj;
    };
  }
});

// node_modules/querystring/encode.js
var require_encode = __commonJS({
  "node_modules/querystring/encode.js"(exports2, module2) {
    "use strict";
    var stringifyPrimitive = function(v7) {
      switch (typeof v7) {
        case "string":
          return v7;
        case "boolean":
          return v7 ? "true" : "false";
        case "number":
          return isFinite(v7) ? v7 : "";
        default:
          return "";
      }
    };
    module2.exports = function(obj, sep, eq, name) {
      sep = sep || "&";
      eq = eq || "=";
      if (obj === null) {
        obj = void 0;
      }
      if (typeof obj === "object") {
        return Object.keys(obj).map(function(k) {
          var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
          if (Array.isArray(obj[k])) {
            return obj[k].map(function(v7) {
              return ks + encodeURIComponent(stringifyPrimitive(v7));
            }).join(sep);
          } else {
            return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
          }
        }).join(sep);
      }
      if (!name)
        return "";
      return encodeURIComponent(stringifyPrimitive(name)) + eq + encodeURIComponent(stringifyPrimitive(obj));
    };
  }
});

// node_modules/querystring/index.js
var require_querystring = __commonJS({
  "node_modules/querystring/index.js"(exports2) {
    "use strict";
    exports2.decode = exports2.parse = require_decode();
    exports2.encode = exports2.stringify = require_encode();
  }
});

// node_modules/url/url.js
var require_url = __commonJS({
  "node_modules/url/url.js"(exports2) {
    "use strict";
    var punycode2 = require_punycode();
    var util = require_util();
    exports2.parse = urlParse;
    exports2.resolve = urlResolve;
    exports2.resolveObject = urlResolveObject;
    exports2.format = urlFormat;
    exports2.Url = Url;
    function Url() {
      this.protocol = null;
      this.slashes = null;
      this.auth = null;
      this.host = null;
      this.port = null;
      this.hostname = null;
      this.hash = null;
      this.search = null;
      this.query = null;
      this.pathname = null;
      this.path = null;
      this.href = null;
    }
    var protocolPattern = /^([a-z0-9.+-]+:)/i;
    var portPattern = /:[0-9]*$/;
    var simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
    var delims = ["<", ">", '"', "`", " ", "\r", "\n", "	"];
    var unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims);
    var autoEscape = ["'"].concat(unwise);
    var nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape);
    var hostEndingChars = ["/", "?", "#"];
    var hostnameMaxLen = 255;
    var hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
    var hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
    var unsafeProtocol = {
      "javascript": true,
      "javascript:": true
    };
    var hostlessProtocol = {
      "javascript": true,
      "javascript:": true
    };
    var slashedProtocol = {
      "http": true,
      "https": true,
      "ftp": true,
      "gopher": true,
      "file": true,
      "http:": true,
      "https:": true,
      "ftp:": true,
      "gopher:": true,
      "file:": true
    };
    var querystring = require_querystring();
    function urlParse(url2, parseQueryString, slashesDenoteHost) {
      if (url2 && util.isObject(url2) && url2 instanceof Url)
        return url2;
      var u3 = new Url();
      u3.parse(url2, parseQueryString, slashesDenoteHost);
      return u3;
    }
    Url.prototype.parse = function(url2, parseQueryString, slashesDenoteHost) {
      if (!util.isString(url2)) {
        throw new TypeError("Parameter 'url' must be a string, not " + typeof url2);
      }
      var queryIndex = url2.indexOf("?"), splitter2 = queryIndex !== -1 && queryIndex < url2.indexOf("#") ? "?" : "#", uSplit = url2.split(splitter2), slashRegex = /\\/g;
      uSplit[0] = uSplit[0].replace(slashRegex, "/");
      url2 = uSplit.join(splitter2);
      var rest = url2;
      rest = rest.trim();
      if (!slashesDenoteHost && url2.split("#").length === 1) {
        var simplePath = simplePathPattern.exec(rest);
        if (simplePath) {
          this.path = rest;
          this.href = rest;
          this.pathname = simplePath[1];
          if (simplePath[2]) {
            this.search = simplePath[2];
            if (parseQueryString) {
              this.query = querystring.parse(this.search.substr(1));
            } else {
              this.query = this.search.substr(1);
            }
          } else if (parseQueryString) {
            this.search = "";
            this.query = {};
          }
          return this;
        }
      }
      var proto = protocolPattern.exec(rest);
      if (proto) {
        proto = proto[0];
        var lowerProto = proto.toLowerCase();
        this.protocol = lowerProto;
        rest = rest.substr(proto.length);
      }
      if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
        var slashes = rest.substr(0, 2) === "//";
        if (slashes && !(proto && hostlessProtocol[proto])) {
          rest = rest.substr(2);
          this.slashes = true;
        }
      }
      if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
        var hostEnd = -1;
        for (var i2 = 0; i2 < hostEndingChars.length; i2++) {
          var hec = rest.indexOf(hostEndingChars[i2]);
          if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
            hostEnd = hec;
        }
        var auth, atSign;
        if (hostEnd === -1) {
          atSign = rest.lastIndexOf("@");
        } else {
          atSign = rest.lastIndexOf("@", hostEnd);
        }
        if (atSign !== -1) {
          auth = rest.slice(0, atSign);
          rest = rest.slice(atSign + 1);
          this.auth = decodeURIComponent(auth);
        }
        hostEnd = -1;
        for (var i2 = 0; i2 < nonHostChars.length; i2++) {
          var hec = rest.indexOf(nonHostChars[i2]);
          if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
            hostEnd = hec;
        }
        if (hostEnd === -1)
          hostEnd = rest.length;
        this.host = rest.slice(0, hostEnd);
        rest = rest.slice(hostEnd);
        this.parseHost();
        this.hostname = this.hostname || "";
        var ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
        if (!ipv6Hostname) {
          var hostparts = this.hostname.split(/\./);
          for (var i2 = 0, l2 = hostparts.length; i2 < l2; i2++) {
            var part = hostparts[i2];
            if (!part)
              continue;
            if (!part.match(hostnamePartPattern)) {
              var newpart = "";
              for (var j = 0, k = part.length; j < k; j++) {
                if (part.charCodeAt(j) > 127) {
                  newpart += "x";
                } else {
                  newpart += part[j];
                }
              }
              if (!newpart.match(hostnamePartPattern)) {
                var validParts = hostparts.slice(0, i2);
                var notHost = hostparts.slice(i2 + 1);
                var bit = part.match(hostnamePartStart);
                if (bit) {
                  validParts.push(bit[1]);
                  notHost.unshift(bit[2]);
                }
                if (notHost.length) {
                  rest = "/" + notHost.join(".") + rest;
                }
                this.hostname = validParts.join(".");
                break;
              }
            }
          }
        }
        if (this.hostname.length > hostnameMaxLen) {
          this.hostname = "";
        } else {
          this.hostname = this.hostname.toLowerCase();
        }
        if (!ipv6Hostname) {
          this.hostname = punycode2.toASCII(this.hostname);
        }
        var p2 = this.port ? ":" + this.port : "";
        var h = this.hostname || "";
        this.host = h + p2;
        this.href += this.host;
        if (ipv6Hostname) {
          this.hostname = this.hostname.substr(1, this.hostname.length - 2);
          if (rest[0] !== "/") {
            rest = "/" + rest;
          }
        }
      }
      if (!unsafeProtocol[lowerProto]) {
        for (var i2 = 0, l2 = autoEscape.length; i2 < l2; i2++) {
          var ae = autoEscape[i2];
          if (rest.indexOf(ae) === -1)
            continue;
          var esc = encodeURIComponent(ae);
          if (esc === ae) {
            esc = escape(ae);
          }
          rest = rest.split(ae).join(esc);
        }
      }
      var hash2 = rest.indexOf("#");
      if (hash2 !== -1) {
        this.hash = rest.substr(hash2);
        rest = rest.slice(0, hash2);
      }
      var qm = rest.indexOf("?");
      if (qm !== -1) {
        this.search = rest.substr(qm);
        this.query = rest.substr(qm + 1);
        if (parseQueryString) {
          this.query = querystring.parse(this.query);
        }
        rest = rest.slice(0, qm);
      } else if (parseQueryString) {
        this.search = "";
        this.query = {};
      }
      if (rest)
        this.pathname = rest;
      if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
        this.pathname = "/";
      }
      if (this.pathname || this.search) {
        var p2 = this.pathname || "";
        var s2 = this.search || "";
        this.path = p2 + s2;
      }
      this.href = this.format();
      return this;
    };
    function urlFormat(obj) {
      if (util.isString(obj))
        obj = urlParse(obj);
      if (!(obj instanceof Url))
        return Url.prototype.format.call(obj);
      return obj.format();
    }
    Url.prototype.format = function() {
      var auth = this.auth || "";
      if (auth) {
        auth = encodeURIComponent(auth);
        auth = auth.replace(/%3A/i, ":");
        auth += "@";
      }
      var protocol = this.protocol || "", pathname = this.pathname || "", hash2 = this.hash || "", host = false, query = "";
      if (this.host) {
        host = auth + this.host;
      } else if (this.hostname) {
        host = auth + (this.hostname.indexOf(":") === -1 ? this.hostname : "[" + this.hostname + "]");
        if (this.port) {
          host += ":" + this.port;
        }
      }
      if (this.query && util.isObject(this.query) && Object.keys(this.query).length) {
        query = querystring.stringify(this.query);
      }
      var search = this.search || query && "?" + query || "";
      if (protocol && protocol.substr(-1) !== ":")
        protocol += ":";
      if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {
        host = "//" + (host || "");
        if (pathname && pathname.charAt(0) !== "/")
          pathname = "/" + pathname;
      } else if (!host) {
        host = "";
      }
      if (hash2 && hash2.charAt(0) !== "#")
        hash2 = "#" + hash2;
      if (search && search.charAt(0) !== "?")
        search = "?" + search;
      pathname = pathname.replace(/[?#]/g, function(match) {
        return encodeURIComponent(match);
      });
      search = search.replace("#", "%23");
      return protocol + host + pathname + search + hash2;
    };
    function urlResolve(source, relative) {
      return urlParse(source, false, true).resolve(relative);
    }
    Url.prototype.resolve = function(relative) {
      return this.resolveObject(urlParse(relative, false, true)).format();
    };
    function urlResolveObject(source, relative) {
      if (!source)
        return relative;
      return urlParse(source, false, true).resolveObject(relative);
    }
    Url.prototype.resolveObject = function(relative) {
      if (util.isString(relative)) {
        var rel = new Url();
        rel.parse(relative, false, true);
        relative = rel;
      }
      var result = new Url();
      var tkeys = Object.keys(this);
      for (var tk = 0; tk < tkeys.length; tk++) {
        var tkey = tkeys[tk];
        result[tkey] = this[tkey];
      }
      result.hash = relative.hash;
      if (relative.href === "") {
        result.href = result.format();
        return result;
      }
      if (relative.slashes && !relative.protocol) {
        var rkeys = Object.keys(relative);
        for (var rk = 0; rk < rkeys.length; rk++) {
          var rkey = rkeys[rk];
          if (rkey !== "protocol")
            result[rkey] = relative[rkey];
        }
        if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) {
          result.path = result.pathname = "/";
        }
        result.href = result.format();
        return result;
      }
      if (relative.protocol && relative.protocol !== result.protocol) {
        if (!slashedProtocol[relative.protocol]) {
          var keys = Object.keys(relative);
          for (var v7 = 0; v7 < keys.length; v7++) {
            var k = keys[v7];
            result[k] = relative[k];
          }
          result.href = result.format();
          return result;
        }
        result.protocol = relative.protocol;
        if (!relative.host && !hostlessProtocol[relative.protocol]) {
          var relPath = (relative.pathname || "").split("/");
          while (relPath.length && !(relative.host = relPath.shift()))
            ;
          if (!relative.host)
            relative.host = "";
          if (!relative.hostname)
            relative.hostname = "";
          if (relPath[0] !== "")
            relPath.unshift("");
          if (relPath.length < 2)
            relPath.unshift("");
          result.pathname = relPath.join("/");
        } else {
          result.pathname = relative.pathname;
        }
        result.search = relative.search;
        result.query = relative.query;
        result.host = relative.host || "";
        result.auth = relative.auth;
        result.hostname = relative.hostname || relative.host;
        result.port = relative.port;
        if (result.pathname || result.search) {
          var p2 = result.pathname || "";
          var s2 = result.search || "";
          result.path = p2 + s2;
        }
        result.slashes = result.slashes || relative.slashes;
        result.href = result.format();
        return result;
      }
      var isSourceAbs = result.pathname && result.pathname.charAt(0) === "/", isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === "/", mustEndAbs = isRelAbs || isSourceAbs || result.host && relative.pathname, removeAllDots = mustEndAbs, srcPath = result.pathname && result.pathname.split("/") || [], relPath = relative.pathname && relative.pathname.split("/") || [], psychotic = result.protocol && !slashedProtocol[result.protocol];
      if (psychotic) {
        result.hostname = "";
        result.port = null;
        if (result.host) {
          if (srcPath[0] === "")
            srcPath[0] = result.host;
          else
            srcPath.unshift(result.host);
        }
        result.host = "";
        if (relative.protocol) {
          relative.hostname = null;
          relative.port = null;
          if (relative.host) {
            if (relPath[0] === "")
              relPath[0] = relative.host;
            else
              relPath.unshift(relative.host);
          }
          relative.host = null;
        }
        mustEndAbs = mustEndAbs && (relPath[0] === "" || srcPath[0] === "");
      }
      if (isRelAbs) {
        result.host = relative.host || relative.host === "" ? relative.host : result.host;
        result.hostname = relative.hostname || relative.hostname === "" ? relative.hostname : result.hostname;
        result.search = relative.search;
        result.query = relative.query;
        srcPath = relPath;
      } else if (relPath.length) {
        if (!srcPath)
          srcPath = [];
        srcPath.pop();
        srcPath = srcPath.concat(relPath);
        result.search = relative.search;
        result.query = relative.query;
      } else if (!util.isNullOrUndefined(relative.search)) {
        if (psychotic) {
          result.hostname = result.host = srcPath.shift();
          var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
          if (authInHost) {
            result.auth = authInHost.shift();
            result.host = result.hostname = authInHost.shift();
          }
        }
        result.search = relative.search;
        result.query = relative.query;
        if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
          result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
        }
        result.href = result.format();
        return result;
      }
      if (!srcPath.length) {
        result.pathname = null;
        if (result.search) {
          result.path = "/" + result.search;
        } else {
          result.path = null;
        }
        result.href = result.format();
        return result;
      }
      var last = srcPath.slice(-1)[0];
      var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === "." || last === "..") || last === "";
      var up = 0;
      for (var i2 = srcPath.length; i2 >= 0; i2--) {
        last = srcPath[i2];
        if (last === ".") {
          srcPath.splice(i2, 1);
        } else if (last === "..") {
          srcPath.splice(i2, 1);
          up++;
        } else if (up) {
          srcPath.splice(i2, 1);
          up--;
        }
      }
      if (!mustEndAbs && !removeAllDots) {
        for (; up--; up) {
          srcPath.unshift("..");
        }
      }
      if (mustEndAbs && srcPath[0] !== "" && (!srcPath[0] || srcPath[0].charAt(0) !== "/")) {
        srcPath.unshift("");
      }
      if (hasTrailingSlash && srcPath.join("/").substr(-1) !== "/") {
        srcPath.push("");
      }
      var isAbsolute = srcPath[0] === "" || srcPath[0] && srcPath[0].charAt(0) === "/";
      if (psychotic) {
        result.hostname = result.host = isAbsolute ? "" : srcPath.length ? srcPath.shift() : "";
        var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
        if (authInHost) {
          result.auth = authInHost.shift();
          result.host = result.hostname = authInHost.shift();
        }
      }
      mustEndAbs = mustEndAbs || result.host && srcPath.length;
      if (mustEndAbs && !isAbsolute) {
        srcPath.unshift("");
      }
      if (!srcPath.length) {
        result.pathname = null;
        result.path = null;
      } else {
        result.pathname = srcPath.join("/");
      }
      if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
        result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
      }
      result.auth = relative.auth || result.auth;
      result.slashes = result.slashes || relative.slashes;
      result.href = result.format();
      return result;
    };
    Url.prototype.parseHost = function() {
      var host = this.host;
      var port = portPattern.exec(host);
      if (port) {
        port = port[0];
        if (port !== ":") {
          this.port = port.substr(1);
        }
        host = host.substr(0, host.length - port.length);
      }
      if (host)
        this.hostname = host;
    };
  }
});

// browser-external:https
var https_exports = {};
__export(https_exports, {
  default: () => https_default
});
var https_default;
var init_https = __esm({
  "browser-external:https"() {
    https_default = new Proxy({}, {
      get() {
        throw new Error('Module "https" has been externalized for browser compatibility and cannot be accessed in client code.');
      }
    });
  }
});

// browser-external:http
var http_exports = {};
__export(http_exports, {
  default: () => http_default
});
var http_default;
var init_http = __esm({
  "browser-external:http"() {
    http_default = new Proxy({}, {
      get() {
        throw new Error('Module "http" has been externalized for browser compatibility and cannot be accessed in client code.');
      }
    });
  }
});

// browser-external:zlib
var zlib_exports = {};
__export(zlib_exports, {
  default: () => zlib_default
});
var zlib_default;
var init_zlib = __esm({
  "browser-external:zlib"() {
    zlib_default = new Proxy({}, {
      get() {
        throw new Error('Module "zlib" has been externalized for browser compatibility and cannot be accessed in client code.');
      }
    });
  }
});

// node_modules/cesium/Source/Core/defined.js
function defined(value) {
  return value !== void 0 && value !== null;
}
var defined_default = defined;

// node_modules/cesium/Source/Core/DeveloperError.js
function DeveloperError(message) {
  this.name = "DeveloperError";
  this.message = message;
  let stack;
  try {
    throw new Error();
  } catch (e2) {
    stack = e2.stack;
  }
  this.stack = stack;
}
if (defined_default(Object.create)) {
  DeveloperError.prototype = Object.create(Error.prototype);
  DeveloperError.prototype.constructor = DeveloperError;
}
DeveloperError.prototype.toString = function() {
  let str = `${this.name}: ${this.message}`;
  if (defined_default(this.stack)) {
    str += `
${this.stack.toString()}`;
  }
  return str;
};
DeveloperError.throwInstantiationError = function() {
  throw new DeveloperError(
    "This function defines an interface and should not be called directly."
  );
};
var DeveloperError_default = DeveloperError;

// node_modules/cesium/Source/Core/Check.js
var Check = {};
Check.typeOf = {};
function getUndefinedErrorMessage(name) {
  return `${name} is required, actual value was undefined`;
}
function getFailedTypeErrorMessage(actual, expected, name) {
  return `Expected ${name} to be typeof ${expected}, actual typeof was ${actual}`;
}
Check.defined = function(name, test) {
  if (!defined_default(test)) {
    throw new DeveloperError_default(getUndefinedErrorMessage(name));
  }
};
Check.typeOf.func = function(name, test) {
  if (typeof test !== "function") {
    throw new DeveloperError_default(
      getFailedTypeErrorMessage(typeof test, "function", name)
    );
  }
};
Check.typeOf.string = function(name, test) {
  if (typeof test !== "string") {
    throw new DeveloperError_default(
      getFailedTypeErrorMessage(typeof test, "string", name)
    );
  }
};
Check.typeOf.number = function(name, test) {
  if (typeof test !== "number") {
    throw new DeveloperError_default(
      getFailedTypeErrorMessage(typeof test, "number", name)
    );
  }
};
Check.typeOf.number.lessThan = function(name, test, limit) {
  Check.typeOf.number(name, test);
  if (test >= limit) {
    throw new DeveloperError_default(
      `Expected ${name} to be less than ${limit}, actual value was ${test}`
    );
  }
};
Check.typeOf.number.lessThanOrEquals = function(name, test, limit) {
  Check.typeOf.number(name, test);
  if (test > limit) {
    throw new DeveloperError_default(
      `Expected ${name} to be less than or equal to ${limit}, actual value was ${test}`
    );
  }
};
Check.typeOf.number.greaterThan = function(name, test, limit) {
  Check.typeOf.number(name, test);
  if (test <= limit) {
    throw new DeveloperError_default(
      `Expected ${name} to be greater than ${limit}, actual value was ${test}`
    );
  }
};
Check.typeOf.number.greaterThanOrEquals = function(name, test, limit) {
  Check.typeOf.number(name, test);
  if (test < limit) {
    throw new DeveloperError_default(
      `Expected ${name} to be greater than or equal to ${limit}, actual value was ${test}`
    );
  }
};
Check.typeOf.object = function(name, test) {
  if (typeof test !== "object") {
    throw new DeveloperError_default(
      getFailedTypeErrorMessage(typeof test, "object", name)
    );
  }
};
Check.typeOf.bool = function(name, test) {
  if (typeof test !== "boolean") {
    throw new DeveloperError_default(
      getFailedTypeErrorMessage(typeof test, "boolean", name)
    );
  }
};
Check.typeOf.bigint = function(name, test) {
  if (typeof test !== "bigint") {
    throw new DeveloperError_default(
      getFailedTypeErrorMessage(typeof test, "bigint", name)
    );
  }
};
Check.typeOf.number.equals = function(name1, name2, test1, test2) {
  Check.typeOf.number(name1, test1);
  Check.typeOf.number(name2, test2);
  if (test1 !== test2) {
    throw new DeveloperError_default(
      `${name1} must be equal to ${name2}, the actual values are ${test1} and ${test2}`
    );
  }
};
var Check_default = Check;

// node_modules/cesium/Source/Core/defaultValue.js
function defaultValue(a4, b) {
  if (a4 !== void 0 && a4 !== null) {
    return a4;
  }
  return b;
}
defaultValue.EMPTY_OBJECT = Object.freeze({});
var defaultValue_default = defaultValue;

// node_modules/cesium/Source/ThirdParty/mersenne-twister.js
var MersenneTwister = function(seed) {
  if (seed == void 0) {
    seed = new Date().getTime();
  }
  this.N = 624;
  this.M = 397;
  this.MATRIX_A = 2567483615;
  this.UPPER_MASK = 2147483648;
  this.LOWER_MASK = 2147483647;
  this.mt = new Array(this.N);
  this.mti = this.N + 1;
  if (seed.constructor == Array) {
    this.init_by_array(seed, seed.length);
  } else {
    this.init_seed(seed);
  }
};
MersenneTwister.prototype.init_seed = function(s2) {
  this.mt[0] = s2 >>> 0;
  for (this.mti = 1; this.mti < this.N; this.mti++) {
    var s2 = this.mt[this.mti - 1] ^ this.mt[this.mti - 1] >>> 30;
    this.mt[this.mti] = (((s2 & 4294901760) >>> 16) * 1812433253 << 16) + (s2 & 65535) * 1812433253 + this.mti;
    this.mt[this.mti] >>>= 0;
  }
};
MersenneTwister.prototype.init_by_array = function(init_key, key_length) {
  var i2, j, k;
  this.init_seed(19650218);
  i2 = 1;
  j = 0;
  k = this.N > key_length ? this.N : key_length;
  for (; k; k--) {
    var s2 = this.mt[i2 - 1] ^ this.mt[i2 - 1] >>> 30;
    this.mt[i2] = (this.mt[i2] ^ (((s2 & 4294901760) >>> 16) * 1664525 << 16) + (s2 & 65535) * 1664525) + init_key[j] + j;
    this.mt[i2] >>>= 0;
    i2++;
    j++;
    if (i2 >= this.N) {
      this.mt[0] = this.mt[this.N - 1];
      i2 = 1;
    }
    if (j >= key_length)
      j = 0;
  }
  for (k = this.N - 1; k; k--) {
    var s2 = this.mt[i2 - 1] ^ this.mt[i2 - 1] >>> 30;
    this.mt[i2] = (this.mt[i2] ^ (((s2 & 4294901760) >>> 16) * 1566083941 << 16) + (s2 & 65535) * 1566083941) - i2;
    this.mt[i2] >>>= 0;
    i2++;
    if (i2 >= this.N) {
      this.mt[0] = this.mt[this.N - 1];
      i2 = 1;
    }
  }
  this.mt[0] = 2147483648;
};
MersenneTwister.prototype.random_int = function() {
  var y;
  var mag01 = new Array(0, this.MATRIX_A);
  if (this.mti >= this.N) {
    var kk;
    if (this.mti == this.N + 1)
      this.init_seed(5489);
    for (kk = 0; kk < this.N - this.M; kk++) {
      y = this.mt[kk] & this.UPPER_MASK | this.mt[kk + 1] & this.LOWER_MASK;
      this.mt[kk] = this.mt[kk + this.M] ^ y >>> 1 ^ mag01[y & 1];
    }
    for (; kk < this.N - 1; kk++) {
      y = this.mt[kk] & this.UPPER_MASK | this.mt[kk + 1] & this.LOWER_MASK;
      this.mt[kk] = this.mt[kk + (this.M - this.N)] ^ y >>> 1 ^ mag01[y & 1];
    }
    y = this.mt[this.N - 1] & this.UPPER_MASK | this.mt[0] & this.LOWER_MASK;
    this.mt[this.N - 1] = this.mt[this.M - 1] ^ y >>> 1 ^ mag01[y & 1];
    this.mti = 0;
  }
  y = this.mt[this.mti++];
  y ^= y >>> 11;
  y ^= y << 7 & 2636928640;
  y ^= y << 15 & 4022730752;
  y ^= y >>> 18;
  return y >>> 0;
};
MersenneTwister.prototype.random_int31 = function() {
  return this.random_int() >>> 1;
};
MersenneTwister.prototype.random_incl = function() {
  return this.random_int() * (1 / 4294967295);
};
MersenneTwister.prototype.random = function() {
  return this.random_int() * (1 / 4294967296);
};
MersenneTwister.prototype.random_excl = function() {
  return (this.random_int() + 0.5) * (1 / 4294967296);
};
MersenneTwister.prototype.random_long = function() {
  var a4 = this.random_int() >>> 5, b = this.random_int() >>> 6;
  return (a4 * 67108864 + b) * (1 / 9007199254740992);
};
var mersenneTwister = MersenneTwister;

// node_modules/cesium/Source/Core/Math.js
var CesiumMath = {};
CesiumMath.EPSILON1 = 0.1;
CesiumMath.EPSILON2 = 0.01;
CesiumMath.EPSILON3 = 1e-3;
CesiumMath.EPSILON4 = 1e-4;
CesiumMath.EPSILON5 = 1e-5;
CesiumMath.EPSILON6 = 1e-6;
CesiumMath.EPSILON7 = 1e-7;
CesiumMath.EPSILON8 = 1e-8;
CesiumMath.EPSILON9 = 1e-9;
CesiumMath.EPSILON10 = 1e-10;
CesiumMath.EPSILON11 = 1e-11;
CesiumMath.EPSILON12 = 1e-12;
CesiumMath.EPSILON13 = 1e-13;
CesiumMath.EPSILON14 = 1e-14;
CesiumMath.EPSILON15 = 1e-15;
CesiumMath.EPSILON16 = 1e-16;
CesiumMath.EPSILON17 = 1e-17;
CesiumMath.EPSILON18 = 1e-18;
CesiumMath.EPSILON19 = 1e-19;
CesiumMath.EPSILON20 = 1e-20;
CesiumMath.EPSILON21 = 1e-21;
CesiumMath.GRAVITATIONALPARAMETER = 3986004418e5;
CesiumMath.SOLAR_RADIUS = 6955e5;
CesiumMath.LUNAR_RADIUS = 1737400;
CesiumMath.SIXTY_FOUR_KILOBYTES = 64 * 1024;
CesiumMath.FOUR_GIGABYTES = 4 * 1024 * 1024 * 1024;
CesiumMath.sign = defaultValue_default(Math.sign, function sign(value) {
  value = +value;
  if (value === 0 || value !== value) {
    return value;
  }
  return value > 0 ? 1 : -1;
});
CesiumMath.signNotZero = function(value) {
  return value < 0 ? -1 : 1;
};
CesiumMath.toSNorm = function(value, rangeMaximum) {
  rangeMaximum = defaultValue_default(rangeMaximum, 255);
  return Math.round(
    (CesiumMath.clamp(value, -1, 1) * 0.5 + 0.5) * rangeMaximum
  );
};
CesiumMath.fromSNorm = function(value, rangeMaximum) {
  rangeMaximum = defaultValue_default(rangeMaximum, 255);
  return CesiumMath.clamp(value, 0, rangeMaximum) / rangeMaximum * 2 - 1;
};
CesiumMath.normalize = function(value, rangeMinimum, rangeMaximum) {
  rangeMaximum = Math.max(rangeMaximum - rangeMinimum, 0);
  return rangeMaximum === 0 ? 0 : CesiumMath.clamp((value - rangeMinimum) / rangeMaximum, 0, 1);
};
CesiumMath.sinh = defaultValue_default(Math.sinh, function sinh(value) {
  return (Math.exp(value) - Math.exp(-value)) / 2;
});
CesiumMath.cosh = defaultValue_default(Math.cosh, function cosh(value) {
  return (Math.exp(value) + Math.exp(-value)) / 2;
});
CesiumMath.lerp = function(p2, q, time) {
  return (1 - time) * p2 + time * q;
};
CesiumMath.PI = Math.PI;
CesiumMath.ONE_OVER_PI = 1 / Math.PI;
CesiumMath.PI_OVER_TWO = Math.PI / 2;
CesiumMath.PI_OVER_THREE = Math.PI / 3;
CesiumMath.PI_OVER_FOUR = Math.PI / 4;
CesiumMath.PI_OVER_SIX = Math.PI / 6;
CesiumMath.THREE_PI_OVER_TWO = 3 * Math.PI / 2;
CesiumMath.TWO_PI = 2 * Math.PI;
CesiumMath.ONE_OVER_TWO_PI = 1 / (2 * Math.PI);
CesiumMath.RADIANS_PER_DEGREE = Math.PI / 180;
CesiumMath.DEGREES_PER_RADIAN = 180 / Math.PI;
CesiumMath.RADIANS_PER_ARCSECOND = CesiumMath.RADIANS_PER_DEGREE / 3600;
CesiumMath.toRadians = function(degrees) {
  if (!defined_default(degrees)) {
    throw new DeveloperError_default("degrees is required.");
  }
  return degrees * CesiumMath.RADIANS_PER_DEGREE;
};
CesiumMath.toDegrees = function(radians) {
  if (!defined_default(radians)) {
    throw new DeveloperError_default("radians is required.");
  }
  return radians * CesiumMath.DEGREES_PER_RADIAN;
};
CesiumMath.convertLongitudeRange = function(angle) {
  if (!defined_default(angle)) {
    throw new DeveloperError_default("angle is required.");
  }
  const twoPi = CesiumMath.TWO_PI;
  const simplified = angle - Math.floor(angle / twoPi) * twoPi;
  if (simplified < -Math.PI) {
    return simplified + twoPi;
  }
  if (simplified >= Math.PI) {
    return simplified - twoPi;
  }
  return simplified;
};
CesiumMath.clampToLatitudeRange = function(angle) {
  if (!defined_default(angle)) {
    throw new DeveloperError_default("angle is required.");
  }
  return CesiumMath.clamp(
    angle,
    -1 * CesiumMath.PI_OVER_TWO,
    CesiumMath.PI_OVER_TWO
  );
};
CesiumMath.negativePiToPi = function(angle) {
  if (!defined_default(angle)) {
    throw new DeveloperError_default("angle is required.");
  }
  if (angle >= -CesiumMath.PI && angle <= CesiumMath.PI) {
    return angle;
  }
  return CesiumMath.zeroToTwoPi(angle + CesiumMath.PI) - CesiumMath.PI;
};
CesiumMath.zeroToTwoPi = function(angle) {
  if (!defined_default(angle)) {
    throw new DeveloperError_default("angle is required.");
  }
  if (angle >= 0 && angle <= CesiumMath.TWO_PI) {
    return angle;
  }
  const mod2 = CesiumMath.mod(angle, CesiumMath.TWO_PI);
  if (Math.abs(mod2) < CesiumMath.EPSILON14 && Math.abs(angle) > CesiumMath.EPSILON14) {
    return CesiumMath.TWO_PI;
  }
  return mod2;
};
CesiumMath.mod = function(m, n2) {
  if (!defined_default(m)) {
    throw new DeveloperError_default("m is required.");
  }
  if (!defined_default(n2)) {
    throw new DeveloperError_default("n is required.");
  }
  if (n2 === 0) {
    throw new DeveloperError_default("divisor cannot be 0.");
  }
  if (CesiumMath.sign(m) === CesiumMath.sign(n2) && Math.abs(m) < Math.abs(n2)) {
    return m;
  }
  return (m % n2 + n2) % n2;
};
CesiumMath.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
  if (!defined_default(left)) {
    throw new DeveloperError_default("left is required.");
  }
  if (!defined_default(right)) {
    throw new DeveloperError_default("right is required.");
  }
  relativeEpsilon = defaultValue_default(relativeEpsilon, 0);
  absoluteEpsilon = defaultValue_default(absoluteEpsilon, relativeEpsilon);
  const absDiff = Math.abs(left - right);
  return absDiff <= absoluteEpsilon || absDiff <= relativeEpsilon * Math.max(Math.abs(left), Math.abs(right));
};
CesiumMath.lessThan = function(left, right, absoluteEpsilon) {
  if (!defined_default(left)) {
    throw new DeveloperError_default("first is required.");
  }
  if (!defined_default(right)) {
    throw new DeveloperError_default("second is required.");
  }
  if (!defined_default(absoluteEpsilon)) {
    throw new DeveloperError_default("absoluteEpsilon is required.");
  }
  return left - right < -absoluteEpsilon;
};
CesiumMath.lessThanOrEquals = function(left, right, absoluteEpsilon) {
  if (!defined_default(left)) {
    throw new DeveloperError_default("first is required.");
  }
  if (!defined_default(right)) {
    throw new DeveloperError_default("second is required.");
  }
  if (!defined_default(absoluteEpsilon)) {
    throw new DeveloperError_default("absoluteEpsilon is required.");
  }
  return left - right < absoluteEpsilon;
};
CesiumMath.greaterThan = function(left, right, absoluteEpsilon) {
  if (!defined_default(left)) {
    throw new DeveloperError_default("first is required.");
  }
  if (!defined_default(right)) {
    throw new DeveloperError_default("second is required.");
  }
  if (!defined_default(absoluteEpsilon)) {
    throw new DeveloperError_default("absoluteEpsilon is required.");
  }
  return left - right > absoluteEpsilon;
};
CesiumMath.greaterThanOrEquals = function(left, right, absoluteEpsilon) {
  if (!defined_default(left)) {
    throw new DeveloperError_default("first is required.");
  }
  if (!defined_default(right)) {
    throw new DeveloperError_default("second is required.");
  }
  if (!defined_default(absoluteEpsilon)) {
    throw new DeveloperError_default("absoluteEpsilon is required.");
  }
  return left - right > -absoluteEpsilon;
};
var factorials = [1];
CesiumMath.factorial = function(n2) {
  if (typeof n2 !== "number" || n2 < 0) {
    throw new DeveloperError_default(
      "A number greater than or equal to 0 is required."
    );
  }
  const length3 = factorials.length;
  if (n2 >= length3) {
    let sum = factorials[length3 - 1];
    for (let i2 = length3; i2 <= n2; i2++) {
      const next = sum * i2;
      factorials.push(next);
      sum = next;
    }
  }
  return factorials[n2];
};
CesiumMath.incrementWrap = function(n2, maximumValue, minimumValue) {
  minimumValue = defaultValue_default(minimumValue, 0);
  if (!defined_default(n2)) {
    throw new DeveloperError_default("n is required.");
  }
  if (maximumValue <= minimumValue) {
    throw new DeveloperError_default("maximumValue must be greater than minimumValue.");
  }
  ++n2;
  if (n2 > maximumValue) {
    n2 = minimumValue;
  }
  return n2;
};
CesiumMath.isPowerOfTwo = function(n2) {
  if (typeof n2 !== "number" || n2 < 0 || n2 > 4294967295) {
    throw new DeveloperError_default("A number between 0 and (2^32)-1 is required.");
  }
  return n2 !== 0 && (n2 & n2 - 1) === 0;
};
CesiumMath.nextPowerOfTwo = function(n2) {
  if (typeof n2 !== "number" || n2 < 0 || n2 > 2147483648) {
    throw new DeveloperError_default("A number between 0 and 2^31 is required.");
  }
  --n2;
  n2 |= n2 >> 1;
  n2 |= n2 >> 2;
  n2 |= n2 >> 4;
  n2 |= n2 >> 8;
  n2 |= n2 >> 16;
  ++n2;
  return n2;
};
CesiumMath.previousPowerOfTwo = function(n2) {
  if (typeof n2 !== "number" || n2 < 0 || n2 > 4294967295) {
    throw new DeveloperError_default("A number between 0 and (2^32)-1 is required.");
  }
  n2 |= n2 >> 1;
  n2 |= n2 >> 2;
  n2 |= n2 >> 4;
  n2 |= n2 >> 8;
  n2 |= n2 >> 16;
  n2 |= n2 >> 32;
  n2 = (n2 >>> 0) - (n2 >>> 1);
  return n2;
};
CesiumMath.clamp = function(value, min3, max3) {
  Check_default.typeOf.number("value", value);
  Check_default.typeOf.number("min", min3);
  Check_default.typeOf.number("max", max3);
  return value < min3 ? min3 : value > max3 ? max3 : value;
};
var randomNumberGenerator = new mersenneTwister();
CesiumMath.setRandomNumberSeed = function(seed) {
  if (!defined_default(seed)) {
    throw new DeveloperError_default("seed is required.");
  }
  randomNumberGenerator = new mersenneTwister(seed);
};
CesiumMath.nextRandomNumber = function() {
  return randomNumberGenerator.random();
};
CesiumMath.randomBetween = function(min3, max3) {
  return CesiumMath.nextRandomNumber() * (max3 - min3) + min3;
};
CesiumMath.acosClamped = function(value) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required.");
  }
  return Math.acos(CesiumMath.clamp(value, -1, 1));
};
CesiumMath.asinClamped = function(value) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required.");
  }
  return Math.asin(CesiumMath.clamp(value, -1, 1));
};
CesiumMath.chordLength = function(angle, radius) {
  if (!defined_default(angle)) {
    throw new DeveloperError_default("angle is required.");
  }
  if (!defined_default(radius)) {
    throw new DeveloperError_default("radius is required.");
  }
  return 2 * radius * Math.sin(angle * 0.5);
};
CesiumMath.logBase = function(number, base) {
  if (!defined_default(number)) {
    throw new DeveloperError_default("number is required.");
  }
  if (!defined_default(base)) {
    throw new DeveloperError_default("base is required.");
  }
  return Math.log(number) / Math.log(base);
};
CesiumMath.cbrt = defaultValue_default(Math.cbrt, function cbrt(number) {
  const result = Math.pow(Math.abs(number), 1 / 3);
  return number < 0 ? -result : result;
});
CesiumMath.log2 = defaultValue_default(Math.log2, function log2(number) {
  return Math.log(number) * Math.LOG2E;
});
CesiumMath.fog = function(distanceToCamera, density) {
  const scalar = distanceToCamera * density;
  return 1 - Math.exp(-(scalar * scalar));
};
CesiumMath.fastApproximateAtan = function(x) {
  Check_default.typeOf.number("x", x);
  return x * (-0.1784 * Math.abs(x) - 0.0663 * x * x + 1.0301);
};
CesiumMath.fastApproximateAtan2 = function(x, y) {
  Check_default.typeOf.number("x", x);
  Check_default.typeOf.number("y", y);
  let opposite;
  let t = Math.abs(x);
  opposite = Math.abs(y);
  const adjacent = Math.max(t, opposite);
  opposite = Math.min(t, opposite);
  const oppositeOverAdjacent = opposite / adjacent;
  if (isNaN(oppositeOverAdjacent)) {
    throw new DeveloperError_default("either x or y must be nonzero");
  }
  t = CesiumMath.fastApproximateAtan(oppositeOverAdjacent);
  t = Math.abs(y) > Math.abs(x) ? CesiumMath.PI_OVER_TWO - t : t;
  t = x < 0 ? CesiumMath.PI - t : t;
  t = y < 0 ? -t : t;
  return t;
};
var Math_default = CesiumMath;

// node_modules/cesium/Source/Core/Cartesian3.js
function Cartesian3(x, y, z) {
  this.x = defaultValue_default(x, 0);
  this.y = defaultValue_default(y, 0);
  this.z = defaultValue_default(z, 0);
}
Cartesian3.fromSpherical = function(spherical, result) {
  Check_default.typeOf.object("spherical", spherical);
  if (!defined_default(result)) {
    result = new Cartesian3();
  }
  const clock = spherical.clock;
  const cone = spherical.cone;
  const magnitude = defaultValue_default(spherical.magnitude, 1);
  const radial = magnitude * Math.sin(cone);
  result.x = radial * Math.cos(clock);
  result.y = radial * Math.sin(clock);
  result.z = magnitude * Math.cos(cone);
  return result;
};
Cartesian3.fromElements = function(x, y, z, result) {
  if (!defined_default(result)) {
    return new Cartesian3(x, y, z);
  }
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
Cartesian3.clone = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Cartesian3(cartesian11.x, cartesian11.y, cartesian11.z);
  }
  result.x = cartesian11.x;
  result.y = cartesian11.y;
  result.z = cartesian11.z;
  return result;
};
Cartesian3.fromCartesian4 = Cartesian3.clone;
Cartesian3.packedLength = 3;
Cartesian3.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.x;
  array[startingIndex++] = value.y;
  array[startingIndex] = value.z;
  return array;
};
Cartesian3.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new Cartesian3();
  }
  result.x = array[startingIndex++];
  result.y = array[startingIndex++];
  result.z = array[startingIndex];
  return result;
};
Cartesian3.packArray = function(array, result) {
  Check_default.defined("array", array);
  const length3 = array.length;
  const resultLength = length3 * 3;
  if (!defined_default(result)) {
    result = new Array(resultLength);
  } else if (!Array.isArray(result) && result.length !== resultLength) {
    throw new DeveloperError_default(
      "If result is a typed array, it must have exactly array.length * 3 elements"
    );
  } else if (result.length !== resultLength) {
    result.length = resultLength;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    Cartesian3.pack(array[i2], result, i2 * 3);
  }
  return result;
};
Cartesian3.unpackArray = function(array, result) {
  Check_default.defined("array", array);
  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 3);
  if (array.length % 3 !== 0) {
    throw new DeveloperError_default("array length must be a multiple of 3.");
  }
  const length3 = array.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 3);
  } else {
    result.length = length3 / 3;
  }
  for (let i2 = 0; i2 < length3; i2 += 3) {
    const index2 = i2 / 3;
    result[index2] = Cartesian3.unpack(array, i2, result[index2]);
  }
  return result;
};
Cartesian3.fromArray = Cartesian3.unpack;
Cartesian3.maximumComponent = function(cartesian11) {
  Check_default.typeOf.object("cartesian", cartesian11);
  return Math.max(cartesian11.x, cartesian11.y, cartesian11.z);
};
Cartesian3.minimumComponent = function(cartesian11) {
  Check_default.typeOf.object("cartesian", cartesian11);
  return Math.min(cartesian11.x, cartesian11.y, cartesian11.z);
};
Cartesian3.minimumByComponent = function(first, second, result) {
  Check_default.typeOf.object("first", first);
  Check_default.typeOf.object("second", second);
  Check_default.typeOf.object("result", result);
  result.x = Math.min(first.x, second.x);
  result.y = Math.min(first.y, second.y);
  result.z = Math.min(first.z, second.z);
  return result;
};
Cartesian3.maximumByComponent = function(first, second, result) {
  Check_default.typeOf.object("first", first);
  Check_default.typeOf.object("second", second);
  Check_default.typeOf.object("result", result);
  result.x = Math.max(first.x, second.x);
  result.y = Math.max(first.y, second.y);
  result.z = Math.max(first.z, second.z);
  return result;
};
Cartesian3.clamp = function(value, min3, max3, result) {
  Check_default.typeOf.object("value", value);
  Check_default.typeOf.object("min", min3);
  Check_default.typeOf.object("max", max3);
  Check_default.typeOf.object("result", result);
  const x = Math_default.clamp(value.x, min3.x, max3.x);
  const y = Math_default.clamp(value.y, min3.y, max3.y);
  const z = Math_default.clamp(value.z, min3.z, max3.z);
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
Cartesian3.magnitudeSquared = function(cartesian11) {
  Check_default.typeOf.object("cartesian", cartesian11);
  return cartesian11.x * cartesian11.x + cartesian11.y * cartesian11.y + cartesian11.z * cartesian11.z;
};
Cartesian3.magnitude = function(cartesian11) {
  return Math.sqrt(Cartesian3.magnitudeSquared(cartesian11));
};
var distanceScratch = new Cartesian3();
Cartesian3.distance = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Cartesian3.subtract(left, right, distanceScratch);
  return Cartesian3.magnitude(distanceScratch);
};
Cartesian3.distanceSquared = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Cartesian3.subtract(left, right, distanceScratch);
  return Cartesian3.magnitudeSquared(distanceScratch);
};
Cartesian3.normalize = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const magnitude = Cartesian3.magnitude(cartesian11);
  result.x = cartesian11.x / magnitude;
  result.y = cartesian11.y / magnitude;
  result.z = cartesian11.z / magnitude;
  if (isNaN(result.x) || isNaN(result.y) || isNaN(result.z)) {
    throw new DeveloperError_default("normalized result is not a number");
  }
  return result;
};
Cartesian3.dot = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  return left.x * right.x + left.y * right.y + left.z * right.z;
};
Cartesian3.multiplyComponents = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x * right.x;
  result.y = left.y * right.y;
  result.z = left.z * right.z;
  return result;
};
Cartesian3.divideComponents = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x / right.x;
  result.y = left.y / right.y;
  result.z = left.z / right.z;
  return result;
};
Cartesian3.add = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x + right.x;
  result.y = left.y + right.y;
  result.z = left.z + right.z;
  return result;
};
Cartesian3.subtract = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x - right.x;
  result.y = left.y - right.y;
  result.z = left.z - right.z;
  return result;
};
Cartesian3.multiplyByScalar = function(cartesian11, scalar, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.x = cartesian11.x * scalar;
  result.y = cartesian11.y * scalar;
  result.z = cartesian11.z * scalar;
  return result;
};
Cartesian3.divideByScalar = function(cartesian11, scalar, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.x = cartesian11.x / scalar;
  result.y = cartesian11.y / scalar;
  result.z = cartesian11.z / scalar;
  return result;
};
Cartesian3.negate = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result.x = -cartesian11.x;
  result.y = -cartesian11.y;
  result.z = -cartesian11.z;
  return result;
};
Cartesian3.abs = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result.x = Math.abs(cartesian11.x);
  result.y = Math.abs(cartesian11.y);
  result.z = Math.abs(cartesian11.z);
  return result;
};
var lerpScratch = new Cartesian3();
Cartesian3.lerp = function(start, end, t, result) {
  Check_default.typeOf.object("start", start);
  Check_default.typeOf.object("end", end);
  Check_default.typeOf.number("t", t);
  Check_default.typeOf.object("result", result);
  Cartesian3.multiplyByScalar(end, t, lerpScratch);
  result = Cartesian3.multiplyByScalar(start, 1 - t, result);
  return Cartesian3.add(lerpScratch, result, result);
};
var angleBetweenScratch = new Cartesian3();
var angleBetweenScratch2 = new Cartesian3();
Cartesian3.angleBetween = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Cartesian3.normalize(left, angleBetweenScratch);
  Cartesian3.normalize(right, angleBetweenScratch2);
  const cosine = Cartesian3.dot(angleBetweenScratch, angleBetweenScratch2);
  const sine = Cartesian3.magnitude(
    Cartesian3.cross(
      angleBetweenScratch,
      angleBetweenScratch2,
      angleBetweenScratch
    )
  );
  return Math.atan2(sine, cosine);
};
var mostOrthogonalAxisScratch = new Cartesian3();
Cartesian3.mostOrthogonalAxis = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const f2 = Cartesian3.normalize(cartesian11, mostOrthogonalAxisScratch);
  Cartesian3.abs(f2, f2);
  if (f2.x <= f2.y) {
    if (f2.x <= f2.z) {
      result = Cartesian3.clone(Cartesian3.UNIT_X, result);
    } else {
      result = Cartesian3.clone(Cartesian3.UNIT_Z, result);
    }
  } else if (f2.y <= f2.z) {
    result = Cartesian3.clone(Cartesian3.UNIT_Y, result);
  } else {
    result = Cartesian3.clone(Cartesian3.UNIT_Z, result);
  }
  return result;
};
Cartesian3.projectVector = function(a4, b, result) {
  Check_default.defined("a", a4);
  Check_default.defined("b", b);
  Check_default.defined("result", result);
  const scalar = Cartesian3.dot(a4, b) / Cartesian3.dot(b, b);
  return Cartesian3.multiplyByScalar(b, scalar, result);
};
Cartesian3.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y && left.z === right.z;
};
Cartesian3.equalsArray = function(cartesian11, array, offset2) {
  return cartesian11.x === array[offset2] && cartesian11.y === array[offset2 + 1] && cartesian11.z === array[offset2 + 2];
};
Cartesian3.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
  return left === right || defined_default(left) && defined_default(right) && Math_default.equalsEpsilon(
    left.x,
    right.x,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    left.y,
    right.y,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    left.z,
    right.z,
    relativeEpsilon,
    absoluteEpsilon
  );
};
Cartesian3.cross = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  const leftX = left.x;
  const leftY = left.y;
  const leftZ = left.z;
  const rightX = right.x;
  const rightY = right.y;
  const rightZ = right.z;
  const x = leftY * rightZ - leftZ * rightY;
  const y = leftZ * rightX - leftX * rightZ;
  const z = leftX * rightY - leftY * rightX;
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
Cartesian3.midpoint = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = (left.x + right.x) * 0.5;
  result.y = (left.y + right.y) * 0.5;
  result.z = (left.z + right.z) * 0.5;
  return result;
};
Cartesian3.fromDegrees = function(longitude, latitude, height, ellipsoid, result) {
  Check_default.typeOf.number("longitude", longitude);
  Check_default.typeOf.number("latitude", latitude);
  longitude = Math_default.toRadians(longitude);
  latitude = Math_default.toRadians(latitude);
  return Cartesian3.fromRadians(longitude, latitude, height, ellipsoid, result);
};
var scratchN = new Cartesian3();
var scratchK = new Cartesian3();
var wgs84RadiiSquared = new Cartesian3(
  6378137 * 6378137,
  6378137 * 6378137,
  6356752314245179e-9 * 6356752314245179e-9
);
Cartesian3.fromRadians = function(longitude, latitude, height, ellipsoid, result) {
  Check_default.typeOf.number("longitude", longitude);
  Check_default.typeOf.number("latitude", latitude);
  height = defaultValue_default(height, 0);
  const radiiSquared = defined_default(ellipsoid) ? ellipsoid.radiiSquared : wgs84RadiiSquared;
  const cosLatitude = Math.cos(latitude);
  scratchN.x = cosLatitude * Math.cos(longitude);
  scratchN.y = cosLatitude * Math.sin(longitude);
  scratchN.z = Math.sin(latitude);
  scratchN = Cartesian3.normalize(scratchN, scratchN);
  Cartesian3.multiplyComponents(radiiSquared, scratchN, scratchK);
  const gamma = Math.sqrt(Cartesian3.dot(scratchN, scratchK));
  scratchK = Cartesian3.divideByScalar(scratchK, gamma, scratchK);
  scratchN = Cartesian3.multiplyByScalar(scratchN, height, scratchN);
  if (!defined_default(result)) {
    result = new Cartesian3();
  }
  return Cartesian3.add(scratchK, scratchN, result);
};
Cartesian3.fromDegreesArray = function(coordinates, ellipsoid, result) {
  Check_default.defined("coordinates", coordinates);
  if (coordinates.length < 2 || coordinates.length % 2 !== 0) {
    throw new DeveloperError_default(
      "the number of coordinates must be a multiple of 2 and at least 2"
    );
  }
  const length3 = coordinates.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 2);
  } else {
    result.length = length3 / 2;
  }
  for (let i2 = 0; i2 < length3; i2 += 2) {
    const longitude = coordinates[i2];
    const latitude = coordinates[i2 + 1];
    const index2 = i2 / 2;
    result[index2] = Cartesian3.fromDegrees(
      longitude,
      latitude,
      0,
      ellipsoid,
      result[index2]
    );
  }
  return result;
};
Cartesian3.fromRadiansArray = function(coordinates, ellipsoid, result) {
  Check_default.defined("coordinates", coordinates);
  if (coordinates.length < 2 || coordinates.length % 2 !== 0) {
    throw new DeveloperError_default(
      "the number of coordinates must be a multiple of 2 and at least 2"
    );
  }
  const length3 = coordinates.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 2);
  } else {
    result.length = length3 / 2;
  }
  for (let i2 = 0; i2 < length3; i2 += 2) {
    const longitude = coordinates[i2];
    const latitude = coordinates[i2 + 1];
    const index2 = i2 / 2;
    result[index2] = Cartesian3.fromRadians(
      longitude,
      latitude,
      0,
      ellipsoid,
      result[index2]
    );
  }
  return result;
};
Cartesian3.fromDegreesArrayHeights = function(coordinates, ellipsoid, result) {
  Check_default.defined("coordinates", coordinates);
  if (coordinates.length < 3 || coordinates.length % 3 !== 0) {
    throw new DeveloperError_default(
      "the number of coordinates must be a multiple of 3 and at least 3"
    );
  }
  const length3 = coordinates.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 3);
  } else {
    result.length = length3 / 3;
  }
  for (let i2 = 0; i2 < length3; i2 += 3) {
    const longitude = coordinates[i2];
    const latitude = coordinates[i2 + 1];
    const height = coordinates[i2 + 2];
    const index2 = i2 / 3;
    result[index2] = Cartesian3.fromDegrees(
      longitude,
      latitude,
      height,
      ellipsoid,
      result[index2]
    );
  }
  return result;
};
Cartesian3.fromRadiansArrayHeights = function(coordinates, ellipsoid, result) {
  Check_default.defined("coordinates", coordinates);
  if (coordinates.length < 3 || coordinates.length % 3 !== 0) {
    throw new DeveloperError_default(
      "the number of coordinates must be a multiple of 3 and at least 3"
    );
  }
  const length3 = coordinates.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 3);
  } else {
    result.length = length3 / 3;
  }
  for (let i2 = 0; i2 < length3; i2 += 3) {
    const longitude = coordinates[i2];
    const latitude = coordinates[i2 + 1];
    const height = coordinates[i2 + 2];
    const index2 = i2 / 3;
    result[index2] = Cartesian3.fromRadians(
      longitude,
      latitude,
      height,
      ellipsoid,
      result[index2]
    );
  }
  return result;
};
Cartesian3.ZERO = Object.freeze(new Cartesian3(0, 0, 0));
Cartesian3.ONE = Object.freeze(new Cartesian3(1, 1, 1));
Cartesian3.UNIT_X = Object.freeze(new Cartesian3(1, 0, 0));
Cartesian3.UNIT_Y = Object.freeze(new Cartesian3(0, 1, 0));
Cartesian3.UNIT_Z = Object.freeze(new Cartesian3(0, 0, 1));
Cartesian3.prototype.clone = function(result) {
  return Cartesian3.clone(this, result);
};
Cartesian3.prototype.equals = function(right) {
  return Cartesian3.equals(this, right);
};
Cartesian3.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
  return Cartesian3.equalsEpsilon(
    this,
    right,
    relativeEpsilon,
    absoluteEpsilon
  );
};
Cartesian3.prototype.toString = function() {
  return `(${this.x}, ${this.y}, ${this.z})`;
};
var Cartesian3_default = Cartesian3;

// node_modules/cesium/Source/Core/scaleToGeodeticSurface.js
var scaleToGeodeticSurfaceIntersection = new Cartesian3_default();
var scaleToGeodeticSurfaceGradient = new Cartesian3_default();
function scaleToGeodeticSurface(cartesian11, oneOverRadii, oneOverRadiiSquared, centerToleranceSquared, result) {
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required.");
  }
  if (!defined_default(oneOverRadii)) {
    throw new DeveloperError_default("oneOverRadii is required.");
  }
  if (!defined_default(oneOverRadiiSquared)) {
    throw new DeveloperError_default("oneOverRadiiSquared is required.");
  }
  if (!defined_default(centerToleranceSquared)) {
    throw new DeveloperError_default("centerToleranceSquared is required.");
  }
  const positionX = cartesian11.x;
  const positionY = cartesian11.y;
  const positionZ = cartesian11.z;
  const oneOverRadiiX = oneOverRadii.x;
  const oneOverRadiiY = oneOverRadii.y;
  const oneOverRadiiZ = oneOverRadii.z;
  const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
  const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
  const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
  const squaredNorm = x2 + y2 + z2;
  const ratio = Math.sqrt(1 / squaredNorm);
  const intersection = Cartesian3_default.multiplyByScalar(
    cartesian11,
    ratio,
    scaleToGeodeticSurfaceIntersection
  );
  if (squaredNorm < centerToleranceSquared) {
    return !isFinite(ratio) ? void 0 : Cartesian3_default.clone(intersection, result);
  }
  const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
  const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
  const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
  const gradient = scaleToGeodeticSurfaceGradient;
  gradient.x = intersection.x * oneOverRadiiSquaredX * 2;
  gradient.y = intersection.y * oneOverRadiiSquaredY * 2;
  gradient.z = intersection.z * oneOverRadiiSquaredZ * 2;
  let lambda = (1 - ratio) * Cartesian3_default.magnitude(cartesian11) / (0.5 * Cartesian3_default.magnitude(gradient));
  let correction = 0;
  let func;
  let denominator;
  let xMultiplier;
  let yMultiplier;
  let zMultiplier;
  let xMultiplier2;
  let yMultiplier2;
  let zMultiplier2;
  let xMultiplier3;
  let yMultiplier3;
  let zMultiplier3;
  do {
    lambda -= correction;
    xMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredX);
    yMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredY);
    zMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredZ);
    xMultiplier2 = xMultiplier * xMultiplier;
    yMultiplier2 = yMultiplier * yMultiplier;
    zMultiplier2 = zMultiplier * zMultiplier;
    xMultiplier3 = xMultiplier2 * xMultiplier;
    yMultiplier3 = yMultiplier2 * yMultiplier;
    zMultiplier3 = zMultiplier2 * zMultiplier;
    func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1;
    denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
    const derivative = -2 * denominator;
    correction = func / derivative;
  } while (Math.abs(func) > Math_default.EPSILON12);
  if (!defined_default(result)) {
    return new Cartesian3_default(
      positionX * xMultiplier,
      positionY * yMultiplier,
      positionZ * zMultiplier
    );
  }
  result.x = positionX * xMultiplier;
  result.y = positionY * yMultiplier;
  result.z = positionZ * zMultiplier;
  return result;
}
var scaleToGeodeticSurface_default = scaleToGeodeticSurface;

// node_modules/cesium/Source/Core/Cartographic.js
function Cartographic(longitude, latitude, height) {
  this.longitude = defaultValue_default(longitude, 0);
  this.latitude = defaultValue_default(latitude, 0);
  this.height = defaultValue_default(height, 0);
}
Cartographic.fromRadians = function(longitude, latitude, height, result) {
  Check_default.typeOf.number("longitude", longitude);
  Check_default.typeOf.number("latitude", latitude);
  height = defaultValue_default(height, 0);
  if (!defined_default(result)) {
    return new Cartographic(longitude, latitude, height);
  }
  result.longitude = longitude;
  result.latitude = latitude;
  result.height = height;
  return result;
};
Cartographic.fromDegrees = function(longitude, latitude, height, result) {
  Check_default.typeOf.number("longitude", longitude);
  Check_default.typeOf.number("latitude", latitude);
  longitude = Math_default.toRadians(longitude);
  latitude = Math_default.toRadians(latitude);
  return Cartographic.fromRadians(longitude, latitude, height, result);
};
var cartesianToCartographicN = new Cartesian3_default();
var cartesianToCartographicP = new Cartesian3_default();
var cartesianToCartographicH = new Cartesian3_default();
var wgs84OneOverRadii = new Cartesian3_default(
  1 / 6378137,
  1 / 6378137,
  1 / 6356752314245179e-9
);
var wgs84OneOverRadiiSquared = new Cartesian3_default(
  1 / (6378137 * 6378137),
  1 / (6378137 * 6378137),
  1 / (6356752314245179e-9 * 6356752314245179e-9)
);
var wgs84CenterToleranceSquared = Math_default.EPSILON1;
Cartographic.fromCartesian = function(cartesian11, ellipsoid, result) {
  const oneOverRadii = defined_default(ellipsoid) ? ellipsoid.oneOverRadii : wgs84OneOverRadii;
  const oneOverRadiiSquared = defined_default(ellipsoid) ? ellipsoid.oneOverRadiiSquared : wgs84OneOverRadiiSquared;
  const centerToleranceSquared = defined_default(ellipsoid) ? ellipsoid._centerToleranceSquared : wgs84CenterToleranceSquared;
  const p2 = scaleToGeodeticSurface_default(
    cartesian11,
    oneOverRadii,
    oneOverRadiiSquared,
    centerToleranceSquared,
    cartesianToCartographicP
  );
  if (!defined_default(p2)) {
    return void 0;
  }
  let n2 = Cartesian3_default.multiplyComponents(
    p2,
    oneOverRadiiSquared,
    cartesianToCartographicN
  );
  n2 = Cartesian3_default.normalize(n2, n2);
  const h = Cartesian3_default.subtract(cartesian11, p2, cartesianToCartographicH);
  const longitude = Math.atan2(n2.y, n2.x);
  const latitude = Math.asin(n2.z);
  const height = Math_default.sign(Cartesian3_default.dot(h, cartesian11)) * Cartesian3_default.magnitude(h);
  if (!defined_default(result)) {
    return new Cartographic(longitude, latitude, height);
  }
  result.longitude = longitude;
  result.latitude = latitude;
  result.height = height;
  return result;
};
Cartographic.toCartesian = function(cartographic2, ellipsoid, result) {
  Check_default.defined("cartographic", cartographic2);
  return Cartesian3_default.fromRadians(
    cartographic2.longitude,
    cartographic2.latitude,
    cartographic2.height,
    ellipsoid,
    result
  );
};
Cartographic.clone = function(cartographic2, result) {
  if (!defined_default(cartographic2)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Cartographic(
      cartographic2.longitude,
      cartographic2.latitude,
      cartographic2.height
    );
  }
  result.longitude = cartographic2.longitude;
  result.latitude = cartographic2.latitude;
  result.height = cartographic2.height;
  return result;
};
Cartographic.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.longitude === right.longitude && left.latitude === right.latitude && left.height === right.height;
};
Cartographic.equalsEpsilon = function(left, right, epsilon) {
  epsilon = defaultValue_default(epsilon, 0);
  return left === right || defined_default(left) && defined_default(right) && Math.abs(left.longitude - right.longitude) <= epsilon && Math.abs(left.latitude - right.latitude) <= epsilon && Math.abs(left.height - right.height) <= epsilon;
};
Cartographic.ZERO = Object.freeze(new Cartographic(0, 0, 0));
Cartographic.prototype.clone = function(result) {
  return Cartographic.clone(this, result);
};
Cartographic.prototype.equals = function(right) {
  return Cartographic.equals(this, right);
};
Cartographic.prototype.equalsEpsilon = function(right, epsilon) {
  return Cartographic.equalsEpsilon(this, right, epsilon);
};
Cartographic.prototype.toString = function() {
  return `(${this.longitude}, ${this.latitude}, ${this.height})`;
};
var Cartographic_default = Cartographic;

// node_modules/cesium/Source/Core/Ellipsoid.js
function initialize(ellipsoid, x, y, z) {
  x = defaultValue_default(x, 0);
  y = defaultValue_default(y, 0);
  z = defaultValue_default(z, 0);
  Check_default.typeOf.number.greaterThanOrEquals("x", x, 0);
  Check_default.typeOf.number.greaterThanOrEquals("y", y, 0);
  Check_default.typeOf.number.greaterThanOrEquals("z", z, 0);
  ellipsoid._radii = new Cartesian3_default(x, y, z);
  ellipsoid._radiiSquared = new Cartesian3_default(x * x, y * y, z * z);
  ellipsoid._radiiToTheFourth = new Cartesian3_default(
    x * x * x * x,
    y * y * y * y,
    z * z * z * z
  );
  ellipsoid._oneOverRadii = new Cartesian3_default(
    x === 0 ? 0 : 1 / x,
    y === 0 ? 0 : 1 / y,
    z === 0 ? 0 : 1 / z
  );
  ellipsoid._oneOverRadiiSquared = new Cartesian3_default(
    x === 0 ? 0 : 1 / (x * x),
    y === 0 ? 0 : 1 / (y * y),
    z === 0 ? 0 : 1 / (z * z)
  );
  ellipsoid._minimumRadius = Math.min(x, y, z);
  ellipsoid._maximumRadius = Math.max(x, y, z);
  ellipsoid._centerToleranceSquared = Math_default.EPSILON1;
  if (ellipsoid._radiiSquared.z !== 0) {
    ellipsoid._squaredXOverSquaredZ = ellipsoid._radiiSquared.x / ellipsoid._radiiSquared.z;
  }
}
function Ellipsoid(x, y, z) {
  this._radii = void 0;
  this._radiiSquared = void 0;
  this._radiiToTheFourth = void 0;
  this._oneOverRadii = void 0;
  this._oneOverRadiiSquared = void 0;
  this._minimumRadius = void 0;
  this._maximumRadius = void 0;
  this._centerToleranceSquared = void 0;
  this._squaredXOverSquaredZ = void 0;
  initialize(this, x, y, z);
}
Object.defineProperties(Ellipsoid.prototype, {
  radii: {
    get: function() {
      return this._radii;
    }
  },
  radiiSquared: {
    get: function() {
      return this._radiiSquared;
    }
  },
  radiiToTheFourth: {
    get: function() {
      return this._radiiToTheFourth;
    }
  },
  oneOverRadii: {
    get: function() {
      return this._oneOverRadii;
    }
  },
  oneOverRadiiSquared: {
    get: function() {
      return this._oneOverRadiiSquared;
    }
  },
  minimumRadius: {
    get: function() {
      return this._minimumRadius;
    }
  },
  maximumRadius: {
    get: function() {
      return this._maximumRadius;
    }
  }
});
Ellipsoid.clone = function(ellipsoid, result) {
  if (!defined_default(ellipsoid)) {
    return void 0;
  }
  const radii = ellipsoid._radii;
  if (!defined_default(result)) {
    return new Ellipsoid(radii.x, radii.y, radii.z);
  }
  Cartesian3_default.clone(radii, result._radii);
  Cartesian3_default.clone(ellipsoid._radiiSquared, result._radiiSquared);
  Cartesian3_default.clone(ellipsoid._radiiToTheFourth, result._radiiToTheFourth);
  Cartesian3_default.clone(ellipsoid._oneOverRadii, result._oneOverRadii);
  Cartesian3_default.clone(ellipsoid._oneOverRadiiSquared, result._oneOverRadiiSquared);
  result._minimumRadius = ellipsoid._minimumRadius;
  result._maximumRadius = ellipsoid._maximumRadius;
  result._centerToleranceSquared = ellipsoid._centerToleranceSquared;
  return result;
};
Ellipsoid.fromCartesian3 = function(cartesian11, result) {
  if (!defined_default(result)) {
    result = new Ellipsoid();
  }
  if (!defined_default(cartesian11)) {
    return result;
  }
  initialize(result, cartesian11.x, cartesian11.y, cartesian11.z);
  return result;
};
Ellipsoid.WGS84 = Object.freeze(
  new Ellipsoid(6378137, 6378137, 6356752314245179e-9)
);
Ellipsoid.UNIT_SPHERE = Object.freeze(new Ellipsoid(1, 1, 1));
Ellipsoid.MOON = Object.freeze(
  new Ellipsoid(
    Math_default.LUNAR_RADIUS,
    Math_default.LUNAR_RADIUS,
    Math_default.LUNAR_RADIUS
  )
);
Ellipsoid.prototype.clone = function(result) {
  return Ellipsoid.clone(this, result);
};
Ellipsoid.packedLength = Cartesian3_default.packedLength;
Ellipsoid.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  Cartesian3_default.pack(value._radii, array, startingIndex);
  return array;
};
Ellipsoid.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const radii = Cartesian3_default.unpack(array, startingIndex);
  return Ellipsoid.fromCartesian3(radii, result);
};
Ellipsoid.prototype.geocentricSurfaceNormal = Cartesian3_default.normalize;
Ellipsoid.prototype.geodeticSurfaceNormalCartographic = function(cartographic2, result) {
  Check_default.typeOf.object("cartographic", cartographic2);
  const longitude = cartographic2.longitude;
  const latitude = cartographic2.latitude;
  const cosLatitude = Math.cos(latitude);
  const x = cosLatitude * Math.cos(longitude);
  const y = cosLatitude * Math.sin(longitude);
  const z = Math.sin(latitude);
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  result.x = x;
  result.y = y;
  result.z = z;
  return Cartesian3_default.normalize(result, result);
};
Ellipsoid.prototype.geodeticSurfaceNormal = function(cartesian11, result) {
  if (Cartesian3_default.equalsEpsilon(cartesian11, Cartesian3_default.ZERO, Math_default.EPSILON14)) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  result = Cartesian3_default.multiplyComponents(
    cartesian11,
    this._oneOverRadiiSquared,
    result
  );
  return Cartesian3_default.normalize(result, result);
};
var cartographicToCartesianNormal = new Cartesian3_default();
var cartographicToCartesianK = new Cartesian3_default();
Ellipsoid.prototype.cartographicToCartesian = function(cartographic2, result) {
  const n2 = cartographicToCartesianNormal;
  const k = cartographicToCartesianK;
  this.geodeticSurfaceNormalCartographic(cartographic2, n2);
  Cartesian3_default.multiplyComponents(this._radiiSquared, n2, k);
  const gamma = Math.sqrt(Cartesian3_default.dot(n2, k));
  Cartesian3_default.divideByScalar(k, gamma, k);
  Cartesian3_default.multiplyByScalar(n2, cartographic2.height, n2);
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  return Cartesian3_default.add(k, n2, result);
};
Ellipsoid.prototype.cartographicArrayToCartesianArray = function(cartographics, result) {
  Check_default.defined("cartographics", cartographics);
  const length3 = cartographics.length;
  if (!defined_default(result)) {
    result = new Array(length3);
  } else {
    result.length = length3;
  }
  for (let i2 = 0; i2 < length3; i2++) {
    result[i2] = this.cartographicToCartesian(cartographics[i2], result[i2]);
  }
  return result;
};
var cartesianToCartographicN2 = new Cartesian3_default();
var cartesianToCartographicP2 = new Cartesian3_default();
var cartesianToCartographicH2 = new Cartesian3_default();
Ellipsoid.prototype.cartesianToCartographic = function(cartesian11, result) {
  const p2 = this.scaleToGeodeticSurface(cartesian11, cartesianToCartographicP2);
  if (!defined_default(p2)) {
    return void 0;
  }
  const n2 = this.geodeticSurfaceNormal(p2, cartesianToCartographicN2);
  const h = Cartesian3_default.subtract(cartesian11, p2, cartesianToCartographicH2);
  const longitude = Math.atan2(n2.y, n2.x);
  const latitude = Math.asin(n2.z);
  const height = Math_default.sign(Cartesian3_default.dot(h, cartesian11)) * Cartesian3_default.magnitude(h);
  if (!defined_default(result)) {
    return new Cartographic_default(longitude, latitude, height);
  }
  result.longitude = longitude;
  result.latitude = latitude;
  result.height = height;
  return result;
};
Ellipsoid.prototype.cartesianArrayToCartographicArray = function(cartesians, result) {
  Check_default.defined("cartesians", cartesians);
  const length3 = cartesians.length;
  if (!defined_default(result)) {
    result = new Array(length3);
  } else {
    result.length = length3;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    result[i2] = this.cartesianToCartographic(cartesians[i2], result[i2]);
  }
  return result;
};
Ellipsoid.prototype.scaleToGeodeticSurface = function(cartesian11, result) {
  return scaleToGeodeticSurface_default(
    cartesian11,
    this._oneOverRadii,
    this._oneOverRadiiSquared,
    this._centerToleranceSquared,
    result
  );
};
Ellipsoid.prototype.scaleToGeocentricSurface = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  const positionX = cartesian11.x;
  const positionY = cartesian11.y;
  const positionZ = cartesian11.z;
  const oneOverRadiiSquared = this._oneOverRadiiSquared;
  const beta = 1 / Math.sqrt(
    positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z
  );
  return Cartesian3_default.multiplyByScalar(cartesian11, beta, result);
};
Ellipsoid.prototype.transformPositionToScaledSpace = function(position, result) {
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  return Cartesian3_default.multiplyComponents(position, this._oneOverRadii, result);
};
Ellipsoid.prototype.transformPositionFromScaledSpace = function(position, result) {
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  return Cartesian3_default.multiplyComponents(position, this._radii, result);
};
Ellipsoid.prototype.equals = function(right) {
  return this === right || defined_default(right) && Cartesian3_default.equals(this._radii, right._radii);
};
Ellipsoid.prototype.toString = function() {
  return this._radii.toString();
};
Ellipsoid.prototype.getSurfaceNormalIntersectionWithZAxis = function(position, buffer, result) {
  Check_default.typeOf.object("position", position);
  if (!Math_default.equalsEpsilon(
    this._radii.x,
    this._radii.y,
    Math_default.EPSILON15
  )) {
    throw new DeveloperError_default(
      "Ellipsoid must be an ellipsoid of revolution (radii.x == radii.y)"
    );
  }
  Check_default.typeOf.number.greaterThan("Ellipsoid.radii.z", this._radii.z, 0);
  buffer = defaultValue_default(buffer, 0);
  const squaredXOverSquaredZ = this._squaredXOverSquaredZ;
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  result.x = 0;
  result.y = 0;
  result.z = position.z * (1 - squaredXOverSquaredZ);
  if (Math.abs(result.z) >= this._radii.z - buffer) {
    return void 0;
  }
  return result;
};
var abscissas = [
  0.14887433898163,
  0.43339539412925,
  0.67940956829902,
  0.86506336668898,
  0.97390652851717,
  0
];
var weights = [
  0.29552422471475,
  0.26926671930999,
  0.21908636251598,
  0.14945134915058,
  0.066671344308684,
  0
];
function gaussLegendreQuadrature(a4, b, func) {
  Check_default.typeOf.number("a", a4);
  Check_default.typeOf.number("b", b);
  Check_default.typeOf.func("func", func);
  const xMean = 0.5 * (b + a4);
  const xRange = 0.5 * (b - a4);
  let sum = 0;
  for (let i2 = 0; i2 < 5; i2++) {
    const dx = xRange * abscissas[i2];
    sum += weights[i2] * (func(xMean + dx) + func(xMean - dx));
  }
  sum *= xRange;
  return sum;
}
Ellipsoid.prototype.surfaceArea = function(rectangle) {
  Check_default.typeOf.object("rectangle", rectangle);
  const minLongitude = rectangle.west;
  let maxLongitude = rectangle.east;
  const minLatitude = rectangle.south;
  const maxLatitude = rectangle.north;
  while (maxLongitude < minLongitude) {
    maxLongitude += Math_default.TWO_PI;
  }
  const radiiSquared = this._radiiSquared;
  const a22 = radiiSquared.x;
  const b2 = radiiSquared.y;
  const c22 = radiiSquared.z;
  const a2b2 = a22 * b2;
  return gaussLegendreQuadrature(minLatitude, maxLatitude, function(lat) {
    const sinPhi = Math.cos(lat);
    const cosPhi = Math.sin(lat);
    return Math.cos(lat) * gaussLegendreQuadrature(minLongitude, maxLongitude, function(lon) {
      const cosTheta = Math.cos(lon);
      const sinTheta = Math.sin(lon);
      return Math.sqrt(
        a2b2 * cosPhi * cosPhi + c22 * (b2 * cosTheta * cosTheta + a22 * sinTheta * sinTheta) * sinPhi * sinPhi
      );
    });
  });
};
var Ellipsoid_default = Ellipsoid;

// node_modules/cesium/Source/Core/GeographicProjection.js
function GeographicProjection(ellipsoid) {
  this._ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  this._semimajorAxis = this._ellipsoid.maximumRadius;
  this._oneOverSemimajorAxis = 1 / this._semimajorAxis;
}
Object.defineProperties(GeographicProjection.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  }
});
GeographicProjection.prototype.project = function(cartographic2, result) {
  const semimajorAxis = this._semimajorAxis;
  const x = cartographic2.longitude * semimajorAxis;
  const y = cartographic2.latitude * semimajorAxis;
  const z = cartographic2.height;
  if (!defined_default(result)) {
    return new Cartesian3_default(x, y, z);
  }
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
GeographicProjection.prototype.unproject = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required");
  }
  const oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
  const longitude = cartesian11.x * oneOverEarthSemimajorAxis;
  const latitude = cartesian11.y * oneOverEarthSemimajorAxis;
  const height = cartesian11.z;
  if (!defined_default(result)) {
    return new Cartographic_default(longitude, latitude, height);
  }
  result.longitude = longitude;
  result.latitude = latitude;
  result.height = height;
  return result;
};
var GeographicProjection_default = GeographicProjection;

// node_modules/cesium/Source/Core/Intersect.js
var Intersect = {
  OUTSIDE: -1,
  INTERSECTING: 0,
  INSIDE: 1
};
var Intersect_default = Object.freeze(Intersect);

// node_modules/cesium/Source/Core/Interval.js
function Interval(start, stop2) {
  this.start = defaultValue_default(start, 0);
  this.stop = defaultValue_default(stop2, 0);
}
var Interval_default = Interval;

// node_modules/cesium/Source/Core/Matrix3.js
function Matrix3(column0Row0, column1Row0, column2Row0, column0Row1, column1Row1, column2Row1, column0Row2, column1Row2, column2Row2) {
  this[0] = defaultValue_default(column0Row0, 0);
  this[1] = defaultValue_default(column0Row1, 0);
  this[2] = defaultValue_default(column0Row2, 0);
  this[3] = defaultValue_default(column1Row0, 0);
  this[4] = defaultValue_default(column1Row1, 0);
  this[5] = defaultValue_default(column1Row2, 0);
  this[6] = defaultValue_default(column2Row0, 0);
  this[7] = defaultValue_default(column2Row1, 0);
  this[8] = defaultValue_default(column2Row2, 0);
}
Matrix3.packedLength = 9;
Matrix3.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value[0];
  array[startingIndex++] = value[1];
  array[startingIndex++] = value[2];
  array[startingIndex++] = value[3];
  array[startingIndex++] = value[4];
  array[startingIndex++] = value[5];
  array[startingIndex++] = value[6];
  array[startingIndex++] = value[7];
  array[startingIndex++] = value[8];
  return array;
};
Matrix3.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new Matrix3();
  }
  result[0] = array[startingIndex++];
  result[1] = array[startingIndex++];
  result[2] = array[startingIndex++];
  result[3] = array[startingIndex++];
  result[4] = array[startingIndex++];
  result[5] = array[startingIndex++];
  result[6] = array[startingIndex++];
  result[7] = array[startingIndex++];
  result[8] = array[startingIndex++];
  return result;
};
Matrix3.packArray = function(array, result) {
  Check_default.defined("array", array);
  const length3 = array.length;
  const resultLength = length3 * 9;
  if (!defined_default(result)) {
    result = new Array(resultLength);
  } else if (!Array.isArray(result) && result.length !== resultLength) {
    throw new DeveloperError_default(
      "If result is a typed array, it must have exactly array.length * 9 elements"
    );
  } else if (result.length !== resultLength) {
    result.length = resultLength;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    Matrix3.pack(array[i2], result, i2 * 9);
  }
  return result;
};
Matrix3.unpackArray = function(array, result) {
  Check_default.defined("array", array);
  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 9);
  if (array.length % 9 !== 0) {
    throw new DeveloperError_default("array length must be a multiple of 9.");
  }
  const length3 = array.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 9);
  } else {
    result.length = length3 / 9;
  }
  for (let i2 = 0; i2 < length3; i2 += 9) {
    const index2 = i2 / 9;
    result[index2] = Matrix3.unpack(array, i2, result[index2]);
  }
  return result;
};
Matrix3.clone = function(matrix, result) {
  if (!defined_default(matrix)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Matrix3(
      matrix[0],
      matrix[3],
      matrix[6],
      matrix[1],
      matrix[4],
      matrix[7],
      matrix[2],
      matrix[5],
      matrix[8]
    );
  }
  result[0] = matrix[0];
  result[1] = matrix[1];
  result[2] = matrix[2];
  result[3] = matrix[3];
  result[4] = matrix[4];
  result[5] = matrix[5];
  result[6] = matrix[6];
  result[7] = matrix[7];
  result[8] = matrix[8];
  return result;
};
Matrix3.fromArray = Matrix3.unpack;
Matrix3.fromColumnMajorArray = function(values, result) {
  Check_default.defined("values", values);
  return Matrix3.clone(values, result);
};
Matrix3.fromRowMajorArray = function(values, result) {
  Check_default.defined("values", values);
  if (!defined_default(result)) {
    return new Matrix3(
      values[0],
      values[1],
      values[2],
      values[3],
      values[4],
      values[5],
      values[6],
      values[7],
      values[8]
    );
  }
  result[0] = values[0];
  result[1] = values[3];
  result[2] = values[6];
  result[3] = values[1];
  result[4] = values[4];
  result[5] = values[7];
  result[6] = values[2];
  result[7] = values[5];
  result[8] = values[8];
  return result;
};
Matrix3.fromQuaternion = function(quaternion, result) {
  Check_default.typeOf.object("quaternion", quaternion);
  const x2 = quaternion.x * quaternion.x;
  const xy = quaternion.x * quaternion.y;
  const xz = quaternion.x * quaternion.z;
  const xw = quaternion.x * quaternion.w;
  const y2 = quaternion.y * quaternion.y;
  const yz = quaternion.y * quaternion.z;
  const yw = quaternion.y * quaternion.w;
  const z2 = quaternion.z * quaternion.z;
  const zw = quaternion.z * quaternion.w;
  const w2 = quaternion.w * quaternion.w;
  const m00 = x2 - y2 - z2 + w2;
  const m01 = 2 * (xy - zw);
  const m02 = 2 * (xz + yw);
  const m10 = 2 * (xy + zw);
  const m11 = -x2 + y2 - z2 + w2;
  const m12 = 2 * (yz - xw);
  const m20 = 2 * (xz - yw);
  const m21 = 2 * (yz + xw);
  const m22 = -x2 - y2 + z2 + w2;
  if (!defined_default(result)) {
    return new Matrix3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
  }
  result[0] = m00;
  result[1] = m10;
  result[2] = m20;
  result[3] = m01;
  result[4] = m11;
  result[5] = m21;
  result[6] = m02;
  result[7] = m12;
  result[8] = m22;
  return result;
};
Matrix3.fromHeadingPitchRoll = function(headingPitchRoll, result) {
  Check_default.typeOf.object("headingPitchRoll", headingPitchRoll);
  const cosTheta = Math.cos(-headingPitchRoll.pitch);
  const cosPsi = Math.cos(-headingPitchRoll.heading);
  const cosPhi = Math.cos(headingPitchRoll.roll);
  const sinTheta = Math.sin(-headingPitchRoll.pitch);
  const sinPsi = Math.sin(-headingPitchRoll.heading);
  const sinPhi = Math.sin(headingPitchRoll.roll);
  const m00 = cosTheta * cosPsi;
  const m01 = -cosPhi * sinPsi + sinPhi * sinTheta * cosPsi;
  const m02 = sinPhi * sinPsi + cosPhi * sinTheta * cosPsi;
  const m10 = cosTheta * sinPsi;
  const m11 = cosPhi * cosPsi + sinPhi * sinTheta * sinPsi;
  const m12 = -sinPhi * cosPsi + cosPhi * sinTheta * sinPsi;
  const m20 = -sinTheta;
  const m21 = sinPhi * cosTheta;
  const m22 = cosPhi * cosTheta;
  if (!defined_default(result)) {
    return new Matrix3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
  }
  result[0] = m00;
  result[1] = m10;
  result[2] = m20;
  result[3] = m01;
  result[4] = m11;
  result[5] = m21;
  result[6] = m02;
  result[7] = m12;
  result[8] = m22;
  return result;
};
Matrix3.fromScale = function(scale, result) {
  Check_default.typeOf.object("scale", scale);
  if (!defined_default(result)) {
    return new Matrix3(scale.x, 0, 0, 0, scale.y, 0, 0, 0, scale.z);
  }
  result[0] = scale.x;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = scale.y;
  result[5] = 0;
  result[6] = 0;
  result[7] = 0;
  result[8] = scale.z;
  return result;
};
Matrix3.fromUniformScale = function(scale, result) {
  Check_default.typeOf.number("scale", scale);
  if (!defined_default(result)) {
    return new Matrix3(scale, 0, 0, 0, scale, 0, 0, 0, scale);
  }
  result[0] = scale;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = scale;
  result[5] = 0;
  result[6] = 0;
  result[7] = 0;
  result[8] = scale;
  return result;
};
Matrix3.fromCrossProduct = function(vector, result) {
  Check_default.typeOf.object("vector", vector);
  if (!defined_default(result)) {
    return new Matrix3(
      0,
      -vector.z,
      vector.y,
      vector.z,
      0,
      -vector.x,
      -vector.y,
      vector.x,
      0
    );
  }
  result[0] = 0;
  result[1] = vector.z;
  result[2] = -vector.y;
  result[3] = -vector.z;
  result[4] = 0;
  result[5] = vector.x;
  result[6] = vector.y;
  result[7] = -vector.x;
  result[8] = 0;
  return result;
};
Matrix3.fromRotationX = function(angle, result) {
  Check_default.typeOf.number("angle", angle);
  const cosAngle = Math.cos(angle);
  const sinAngle = Math.sin(angle);
  if (!defined_default(result)) {
    return new Matrix3(
      1,
      0,
      0,
      0,
      cosAngle,
      -sinAngle,
      0,
      sinAngle,
      cosAngle
    );
  }
  result[0] = 1;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = cosAngle;
  result[5] = sinAngle;
  result[6] = 0;
  result[7] = -sinAngle;
  result[8] = cosAngle;
  return result;
};
Matrix3.fromRotationY = function(angle, result) {
  Check_default.typeOf.number("angle", angle);
  const cosAngle = Math.cos(angle);
  const sinAngle = Math.sin(angle);
  if (!defined_default(result)) {
    return new Matrix3(
      cosAngle,
      0,
      sinAngle,
      0,
      1,
      0,
      -sinAngle,
      0,
      cosAngle
    );
  }
  result[0] = cosAngle;
  result[1] = 0;
  result[2] = -sinAngle;
  result[3] = 0;
  result[4] = 1;
  result[5] = 0;
  result[6] = sinAngle;
  result[7] = 0;
  result[8] = cosAngle;
  return result;
};
Matrix3.fromRotationZ = function(angle, result) {
  Check_default.typeOf.number("angle", angle);
  const cosAngle = Math.cos(angle);
  const sinAngle = Math.sin(angle);
  if (!defined_default(result)) {
    return new Matrix3(
      cosAngle,
      -sinAngle,
      0,
      sinAngle,
      cosAngle,
      0,
      0,
      0,
      1
    );
  }
  result[0] = cosAngle;
  result[1] = sinAngle;
  result[2] = 0;
  result[3] = -sinAngle;
  result[4] = cosAngle;
  result[5] = 0;
  result[6] = 0;
  result[7] = 0;
  result[8] = 1;
  return result;
};
Matrix3.toArray = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  if (!defined_default(result)) {
    return [
      matrix[0],
      matrix[1],
      matrix[2],
      matrix[3],
      matrix[4],
      matrix[5],
      matrix[6],
      matrix[7],
      matrix[8]
    ];
  }
  result[0] = matrix[0];
  result[1] = matrix[1];
  result[2] = matrix[2];
  result[3] = matrix[3];
  result[4] = matrix[4];
  result[5] = matrix[5];
  result[6] = matrix[6];
  result[7] = matrix[7];
  result[8] = matrix[8];
  return result;
};
Matrix3.getElementIndex = function(column, row) {
  Check_default.typeOf.number.greaterThanOrEquals("row", row, 0);
  Check_default.typeOf.number.lessThanOrEquals("row", row, 2);
  Check_default.typeOf.number.greaterThanOrEquals("column", column, 0);
  Check_default.typeOf.number.lessThanOrEquals("column", column, 2);
  return column * 3 + row;
};
Matrix3.getColumn = function(matrix, index2, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 2);
  Check_default.typeOf.object("result", result);
  const startIndex = index2 * 3;
  const x = matrix[startIndex];
  const y = matrix[startIndex + 1];
  const z = matrix[startIndex + 2];
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
Matrix3.setColumn = function(matrix, index2, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 2);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result = Matrix3.clone(matrix, result);
  const startIndex = index2 * 3;
  result[startIndex] = cartesian11.x;
  result[startIndex + 1] = cartesian11.y;
  result[startIndex + 2] = cartesian11.z;
  return result;
};
Matrix3.getRow = function(matrix, index2, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 2);
  Check_default.typeOf.object("result", result);
  const x = matrix[index2];
  const y = matrix[index2 + 3];
  const z = matrix[index2 + 6];
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
Matrix3.setRow = function(matrix, index2, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 2);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result = Matrix3.clone(matrix, result);
  result[index2] = cartesian11.x;
  result[index2 + 3] = cartesian11.y;
  result[index2 + 6] = cartesian11.z;
  return result;
};
var scaleScratch1 = new Cartesian3_default();
Matrix3.setScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("scale", scale);
  Check_default.typeOf.object("result", result);
  const existingScale = Matrix3.getScale(matrix, scaleScratch1);
  const scaleRatioX = scale.x / existingScale.x;
  const scaleRatioY = scale.y / existingScale.y;
  const scaleRatioZ = scale.z / existingScale.z;
  result[0] = matrix[0] * scaleRatioX;
  result[1] = matrix[1] * scaleRatioX;
  result[2] = matrix[2] * scaleRatioX;
  result[3] = matrix[3] * scaleRatioY;
  result[4] = matrix[4] * scaleRatioY;
  result[5] = matrix[5] * scaleRatioY;
  result[6] = matrix[6] * scaleRatioZ;
  result[7] = matrix[7] * scaleRatioZ;
  result[8] = matrix[8] * scaleRatioZ;
  return result;
};
var scaleScratch2 = new Cartesian3_default();
Matrix3.setUniformScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number("scale", scale);
  Check_default.typeOf.object("result", result);
  const existingScale = Matrix3.getScale(matrix, scaleScratch2);
  const scaleRatioX = scale / existingScale.x;
  const scaleRatioY = scale / existingScale.y;
  const scaleRatioZ = scale / existingScale.z;
  result[0] = matrix[0] * scaleRatioX;
  result[1] = matrix[1] * scaleRatioX;
  result[2] = matrix[2] * scaleRatioX;
  result[3] = matrix[3] * scaleRatioY;
  result[4] = matrix[4] * scaleRatioY;
  result[5] = matrix[5] * scaleRatioY;
  result[6] = matrix[6] * scaleRatioZ;
  result[7] = matrix[7] * scaleRatioZ;
  result[8] = matrix[8] * scaleRatioZ;
  return result;
};
var scratchColumn = new Cartesian3_default();
Matrix3.getScale = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result.x = Cartesian3_default.magnitude(
    Cartesian3_default.fromElements(matrix[0], matrix[1], matrix[2], scratchColumn)
  );
  result.y = Cartesian3_default.magnitude(
    Cartesian3_default.fromElements(matrix[3], matrix[4], matrix[5], scratchColumn)
  );
  result.z = Cartesian3_default.magnitude(
    Cartesian3_default.fromElements(matrix[6], matrix[7], matrix[8], scratchColumn)
  );
  return result;
};
var scaleScratch3 = new Cartesian3_default();
Matrix3.getMaximumScale = function(matrix) {
  Matrix3.getScale(matrix, scaleScratch3);
  return Cartesian3_default.maximumComponent(scaleScratch3);
};
var scaleScratch4 = new Cartesian3_default();
Matrix3.setRotation = function(matrix, rotation, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const scale = Matrix3.getScale(matrix, scaleScratch4);
  result[0] = rotation[0] * scale.x;
  result[1] = rotation[1] * scale.x;
  result[2] = rotation[2] * scale.x;
  result[3] = rotation[3] * scale.y;
  result[4] = rotation[4] * scale.y;
  result[5] = rotation[5] * scale.y;
  result[6] = rotation[6] * scale.z;
  result[7] = rotation[7] * scale.z;
  result[8] = rotation[8] * scale.z;
  return result;
};
var scaleScratch5 = new Cartesian3_default();
Matrix3.getRotation = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const scale = Matrix3.getScale(matrix, scaleScratch5);
  result[0] = matrix[0] / scale.x;
  result[1] = matrix[1] / scale.x;
  result[2] = matrix[2] / scale.x;
  result[3] = matrix[3] / scale.y;
  result[4] = matrix[4] / scale.y;
  result[5] = matrix[5] / scale.y;
  result[6] = matrix[6] / scale.z;
  result[7] = matrix[7] / scale.z;
  result[8] = matrix[8] / scale.z;
  return result;
};
Matrix3.multiply = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  const column0Row0 = left[0] * right[0] + left[3] * right[1] + left[6] * right[2];
  const column0Row1 = left[1] * right[0] + left[4] * right[1] + left[7] * right[2];
  const column0Row2 = left[2] * right[0] + left[5] * right[1] + left[8] * right[2];
  const column1Row0 = left[0] * right[3] + left[3] * right[4] + left[6] * right[5];
  const column1Row1 = left[1] * right[3] + left[4] * right[4] + left[7] * right[5];
  const column1Row2 = left[2] * right[3] + left[5] * right[4] + left[8] * right[5];
  const column2Row0 = left[0] * right[6] + left[3] * right[7] + left[6] * right[8];
  const column2Row1 = left[1] * right[6] + left[4] * right[7] + left[7] * right[8];
  const column2Row2 = left[2] * right[6] + left[5] * right[7] + left[8] * right[8];
  result[0] = column0Row0;
  result[1] = column0Row1;
  result[2] = column0Row2;
  result[3] = column1Row0;
  result[4] = column1Row1;
  result[5] = column1Row2;
  result[6] = column2Row0;
  result[7] = column2Row1;
  result[8] = column2Row2;
  return result;
};
Matrix3.add = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result[0] = left[0] + right[0];
  result[1] = left[1] + right[1];
  result[2] = left[2] + right[2];
  result[3] = left[3] + right[3];
  result[4] = left[4] + right[4];
  result[5] = left[5] + right[5];
  result[6] = left[6] + right[6];
  result[7] = left[7] + right[7];
  result[8] = left[8] + right[8];
  return result;
};
Matrix3.subtract = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result[0] = left[0] - right[0];
  result[1] = left[1] - right[1];
  result[2] = left[2] - right[2];
  result[3] = left[3] - right[3];
  result[4] = left[4] - right[4];
  result[5] = left[5] - right[5];
  result[6] = left[6] - right[6];
  result[7] = left[7] - right[7];
  result[8] = left[8] - right[8];
  return result;
};
Matrix3.multiplyByVector = function(matrix, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const vX = cartesian11.x;
  const vY = cartesian11.y;
  const vZ = cartesian11.z;
  const x = matrix[0] * vX + matrix[3] * vY + matrix[6] * vZ;
  const y = matrix[1] * vX + matrix[4] * vY + matrix[7] * vZ;
  const z = matrix[2] * vX + matrix[5] * vY + matrix[8] * vZ;
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
Matrix3.multiplyByScalar = function(matrix, scalar, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0] * scalar;
  result[1] = matrix[1] * scalar;
  result[2] = matrix[2] * scalar;
  result[3] = matrix[3] * scalar;
  result[4] = matrix[4] * scalar;
  result[5] = matrix[5] * scalar;
  result[6] = matrix[6] * scalar;
  result[7] = matrix[7] * scalar;
  result[8] = matrix[8] * scalar;
  return result;
};
Matrix3.multiplyByScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("scale", scale);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0] * scale.x;
  result[1] = matrix[1] * scale.x;
  result[2] = matrix[2] * scale.x;
  result[3] = matrix[3] * scale.y;
  result[4] = matrix[4] * scale.y;
  result[5] = matrix[5] * scale.y;
  result[6] = matrix[6] * scale.z;
  result[7] = matrix[7] * scale.z;
  result[8] = matrix[8] * scale.z;
  return result;
};
Matrix3.multiplyByUniformScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number("scale", scale);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0] * scale;
  result[1] = matrix[1] * scale;
  result[2] = matrix[2] * scale;
  result[3] = matrix[3] * scale;
  result[4] = matrix[4] * scale;
  result[5] = matrix[5] * scale;
  result[6] = matrix[6] * scale;
  result[7] = matrix[7] * scale;
  result[8] = matrix[8] * scale;
  return result;
};
Matrix3.negate = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result[0] = -matrix[0];
  result[1] = -matrix[1];
  result[2] = -matrix[2];
  result[3] = -matrix[3];
  result[4] = -matrix[4];
  result[5] = -matrix[5];
  result[6] = -matrix[6];
  result[7] = -matrix[7];
  result[8] = -matrix[8];
  return result;
};
Matrix3.transpose = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const column0Row0 = matrix[0];
  const column0Row1 = matrix[3];
  const column0Row2 = matrix[6];
  const column1Row0 = matrix[1];
  const column1Row1 = matrix[4];
  const column1Row2 = matrix[7];
  const column2Row0 = matrix[2];
  const column2Row1 = matrix[5];
  const column2Row2 = matrix[8];
  result[0] = column0Row0;
  result[1] = column0Row1;
  result[2] = column0Row2;
  result[3] = column1Row0;
  result[4] = column1Row1;
  result[5] = column1Row2;
  result[6] = column2Row0;
  result[7] = column2Row1;
  result[8] = column2Row2;
  return result;
};
function computeFrobeniusNorm(matrix) {
  let norm = 0;
  for (let i2 = 0; i2 < 9; ++i2) {
    const temp = matrix[i2];
    norm += temp * temp;
  }
  return Math.sqrt(norm);
}
var rowVal = [1, 0, 0];
var colVal = [2, 2, 1];
function offDiagonalFrobeniusNorm(matrix) {
  let norm = 0;
  for (let i2 = 0; i2 < 3; ++i2) {
    const temp = matrix[Matrix3.getElementIndex(colVal[i2], rowVal[i2])];
    norm += 2 * temp * temp;
  }
  return Math.sqrt(norm);
}
function shurDecomposition(matrix, result) {
  const tolerance = Math_default.EPSILON15;
  let maxDiagonal = 0;
  let rotAxis2 = 1;
  for (let i2 = 0; i2 < 3; ++i2) {
    const temp = Math.abs(
      matrix[Matrix3.getElementIndex(colVal[i2], rowVal[i2])]
    );
    if (temp > maxDiagonal) {
      rotAxis2 = i2;
      maxDiagonal = temp;
    }
  }
  let c14 = 1;
  let s2 = 0;
  const p2 = rowVal[rotAxis2];
  const q = colVal[rotAxis2];
  if (Math.abs(matrix[Matrix3.getElementIndex(q, p2)]) > tolerance) {
    const qq = matrix[Matrix3.getElementIndex(q, q)];
    const pp = matrix[Matrix3.getElementIndex(p2, p2)];
    const qp = matrix[Matrix3.getElementIndex(q, p2)];
    const tau = (qq - pp) / 2 / qp;
    let t;
    if (tau < 0) {
      t = -1 / (-tau + Math.sqrt(1 + tau * tau));
    } else {
      t = 1 / (tau + Math.sqrt(1 + tau * tau));
    }
    c14 = 1 / Math.sqrt(1 + t * t);
    s2 = t * c14;
  }
  result = Matrix3.clone(Matrix3.IDENTITY, result);
  result[Matrix3.getElementIndex(p2, p2)] = result[Matrix3.getElementIndex(q, q)] = c14;
  result[Matrix3.getElementIndex(q, p2)] = s2;
  result[Matrix3.getElementIndex(p2, q)] = -s2;
  return result;
}
var jMatrix = new Matrix3();
var jMatrixTranspose = new Matrix3();
Matrix3.computeEigenDecomposition = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  const tolerance = Math_default.EPSILON20;
  const maxSweeps = 10;
  let count = 0;
  let sweep = 0;
  if (!defined_default(result)) {
    result = {};
  }
  const unitaryMatrix = result.unitary = Matrix3.clone(
    Matrix3.IDENTITY,
    result.unitary
  );
  const diagMatrix = result.diagonal = Matrix3.clone(matrix, result.diagonal);
  const epsilon = tolerance * computeFrobeniusNorm(diagMatrix);
  while (sweep < maxSweeps && offDiagonalFrobeniusNorm(diagMatrix) > epsilon) {
    shurDecomposition(diagMatrix, jMatrix);
    Matrix3.transpose(jMatrix, jMatrixTranspose);
    Matrix3.multiply(diagMatrix, jMatrix, diagMatrix);
    Matrix3.multiply(jMatrixTranspose, diagMatrix, diagMatrix);
    Matrix3.multiply(unitaryMatrix, jMatrix, unitaryMatrix);
    if (++count > 2) {
      ++sweep;
      count = 0;
    }
  }
  return result;
};
Matrix3.abs = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result[0] = Math.abs(matrix[0]);
  result[1] = Math.abs(matrix[1]);
  result[2] = Math.abs(matrix[2]);
  result[3] = Math.abs(matrix[3]);
  result[4] = Math.abs(matrix[4]);
  result[5] = Math.abs(matrix[5]);
  result[6] = Math.abs(matrix[6]);
  result[7] = Math.abs(matrix[7]);
  result[8] = Math.abs(matrix[8]);
  return result;
};
Matrix3.determinant = function(matrix) {
  Check_default.typeOf.object("matrix", matrix);
  const m11 = matrix[0];
  const m21 = matrix[3];
  const m31 = matrix[6];
  const m12 = matrix[1];
  const m22 = matrix[4];
  const m32 = matrix[7];
  const m13 = matrix[2];
  const m23 = matrix[5];
  const m33 = matrix[8];
  return m11 * (m22 * m33 - m23 * m32) + m12 * (m23 * m31 - m21 * m33) + m13 * (m21 * m32 - m22 * m31);
};
Matrix3.inverse = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const m11 = matrix[0];
  const m21 = matrix[1];
  const m31 = matrix[2];
  const m12 = matrix[3];
  const m22 = matrix[4];
  const m32 = matrix[5];
  const m13 = matrix[6];
  const m23 = matrix[7];
  const m33 = matrix[8];
  const determinant = Matrix3.determinant(matrix);
  if (Math.abs(determinant) <= Math_default.EPSILON15) {
    throw new DeveloperError_default("matrix is not invertible");
  }
  result[0] = m22 * m33 - m23 * m32;
  result[1] = m23 * m31 - m21 * m33;
  result[2] = m21 * m32 - m22 * m31;
  result[3] = m13 * m32 - m12 * m33;
  result[4] = m11 * m33 - m13 * m31;
  result[5] = m12 * m31 - m11 * m32;
  result[6] = m12 * m23 - m13 * m22;
  result[7] = m13 * m21 - m11 * m23;
  result[8] = m11 * m22 - m12 * m21;
  const scale = 1 / determinant;
  return Matrix3.multiplyByScalar(result, scale, result);
};
var scratchTransposeMatrix = new Matrix3();
Matrix3.inverseTranspose = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  return Matrix3.inverse(
    Matrix3.transpose(matrix, scratchTransposeMatrix),
    result
  );
};
Matrix3.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left[0] === right[0] && left[1] === right[1] && left[2] === right[2] && left[3] === right[3] && left[4] === right[4] && left[5] === right[5] && left[6] === right[6] && left[7] === right[7] && left[8] === right[8];
};
Matrix3.equalsEpsilon = function(left, right, epsilon) {
  epsilon = defaultValue_default(epsilon, 0);
  return left === right || defined_default(left) && defined_default(right) && Math.abs(left[0] - right[0]) <= epsilon && Math.abs(left[1] - right[1]) <= epsilon && Math.abs(left[2] - right[2]) <= epsilon && Math.abs(left[3] - right[3]) <= epsilon && Math.abs(left[4] - right[4]) <= epsilon && Math.abs(left[5] - right[5]) <= epsilon && Math.abs(left[6] - right[6]) <= epsilon && Math.abs(left[7] - right[7]) <= epsilon && Math.abs(left[8] - right[8]) <= epsilon;
};
Matrix3.IDENTITY = Object.freeze(
  new Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1)
);
Matrix3.ZERO = Object.freeze(
  new Matrix3(0, 0, 0, 0, 0, 0, 0, 0, 0)
);
Matrix3.COLUMN0ROW0 = 0;
Matrix3.COLUMN0ROW1 = 1;
Matrix3.COLUMN0ROW2 = 2;
Matrix3.COLUMN1ROW0 = 3;
Matrix3.COLUMN1ROW1 = 4;
Matrix3.COLUMN1ROW2 = 5;
Matrix3.COLUMN2ROW0 = 6;
Matrix3.COLUMN2ROW1 = 7;
Matrix3.COLUMN2ROW2 = 8;
Object.defineProperties(Matrix3.prototype, {
  length: {
    get: function() {
      return Matrix3.packedLength;
    }
  }
});
Matrix3.prototype.clone = function(result) {
  return Matrix3.clone(this, result);
};
Matrix3.prototype.equals = function(right) {
  return Matrix3.equals(this, right);
};
Matrix3.equalsArray = function(matrix, array, offset2) {
  return matrix[0] === array[offset2] && matrix[1] === array[offset2 + 1] && matrix[2] === array[offset2 + 2] && matrix[3] === array[offset2 + 3] && matrix[4] === array[offset2 + 4] && matrix[5] === array[offset2 + 5] && matrix[6] === array[offset2 + 6] && matrix[7] === array[offset2 + 7] && matrix[8] === array[offset2 + 8];
};
Matrix3.prototype.equalsEpsilon = function(right, epsilon) {
  return Matrix3.equalsEpsilon(this, right, epsilon);
};
Matrix3.prototype.toString = function() {
  return `(${this[0]}, ${this[3]}, ${this[6]})
(${this[1]}, ${this[4]}, ${this[7]})
(${this[2]}, ${this[5]}, ${this[8]})`;
};
var Matrix3_default = Matrix3;

// node_modules/cesium/Source/Core/Cartesian4.js
function Cartesian4(x, y, z, w) {
  this.x = defaultValue_default(x, 0);
  this.y = defaultValue_default(y, 0);
  this.z = defaultValue_default(z, 0);
  this.w = defaultValue_default(w, 0);
}
Cartesian4.fromElements = function(x, y, z, w, result) {
  if (!defined_default(result)) {
    return new Cartesian4(x, y, z, w);
  }
  result.x = x;
  result.y = y;
  result.z = z;
  result.w = w;
  return result;
};
Cartesian4.fromColor = function(color, result) {
  Check_default.typeOf.object("color", color);
  if (!defined_default(result)) {
    return new Cartesian4(color.red, color.green, color.blue, color.alpha);
  }
  result.x = color.red;
  result.y = color.green;
  result.z = color.blue;
  result.w = color.alpha;
  return result;
};
Cartesian4.clone = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Cartesian4(cartesian11.x, cartesian11.y, cartesian11.z, cartesian11.w);
  }
  result.x = cartesian11.x;
  result.y = cartesian11.y;
  result.z = cartesian11.z;
  result.w = cartesian11.w;
  return result;
};
Cartesian4.packedLength = 4;
Cartesian4.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.x;
  array[startingIndex++] = value.y;
  array[startingIndex++] = value.z;
  array[startingIndex] = value.w;
  return array;
};
Cartesian4.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new Cartesian4();
  }
  result.x = array[startingIndex++];
  result.y = array[startingIndex++];
  result.z = array[startingIndex++];
  result.w = array[startingIndex];
  return result;
};
Cartesian4.packArray = function(array, result) {
  Check_default.defined("array", array);
  const length3 = array.length;
  const resultLength = length3 * 4;
  if (!defined_default(result)) {
    result = new Array(resultLength);
  } else if (!Array.isArray(result) && result.length !== resultLength) {
    throw new DeveloperError_default(
      "If result is a typed array, it must have exactly array.length * 4 elements"
    );
  } else if (result.length !== resultLength) {
    result.length = resultLength;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    Cartesian4.pack(array[i2], result, i2 * 4);
  }
  return result;
};
Cartesian4.unpackArray = function(array, result) {
  Check_default.defined("array", array);
  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 4);
  if (array.length % 4 !== 0) {
    throw new DeveloperError_default("array length must be a multiple of 4.");
  }
  const length3 = array.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 4);
  } else {
    result.length = length3 / 4;
  }
  for (let i2 = 0; i2 < length3; i2 += 4) {
    const index2 = i2 / 4;
    result[index2] = Cartesian4.unpack(array, i2, result[index2]);
  }
  return result;
};
Cartesian4.fromArray = Cartesian4.unpack;
Cartesian4.maximumComponent = function(cartesian11) {
  Check_default.typeOf.object("cartesian", cartesian11);
  return Math.max(cartesian11.x, cartesian11.y, cartesian11.z, cartesian11.w);
};
Cartesian4.minimumComponent = function(cartesian11) {
  Check_default.typeOf.object("cartesian", cartesian11);
  return Math.min(cartesian11.x, cartesian11.y, cartesian11.z, cartesian11.w);
};
Cartesian4.minimumByComponent = function(first, second, result) {
  Check_default.typeOf.object("first", first);
  Check_default.typeOf.object("second", second);
  Check_default.typeOf.object("result", result);
  result.x = Math.min(first.x, second.x);
  result.y = Math.min(first.y, second.y);
  result.z = Math.min(first.z, second.z);
  result.w = Math.min(first.w, second.w);
  return result;
};
Cartesian4.maximumByComponent = function(first, second, result) {
  Check_default.typeOf.object("first", first);
  Check_default.typeOf.object("second", second);
  Check_default.typeOf.object("result", result);
  result.x = Math.max(first.x, second.x);
  result.y = Math.max(first.y, second.y);
  result.z = Math.max(first.z, second.z);
  result.w = Math.max(first.w, second.w);
  return result;
};
Cartesian4.clamp = function(value, min3, max3, result) {
  Check_default.typeOf.object("value", value);
  Check_default.typeOf.object("min", min3);
  Check_default.typeOf.object("max", max3);
  Check_default.typeOf.object("result", result);
  const x = Math_default.clamp(value.x, min3.x, max3.x);
  const y = Math_default.clamp(value.y, min3.y, max3.y);
  const z = Math_default.clamp(value.z, min3.z, max3.z);
  const w = Math_default.clamp(value.w, min3.w, max3.w);
  result.x = x;
  result.y = y;
  result.z = z;
  result.w = w;
  return result;
};
Cartesian4.magnitudeSquared = function(cartesian11) {
  Check_default.typeOf.object("cartesian", cartesian11);
  return cartesian11.x * cartesian11.x + cartesian11.y * cartesian11.y + cartesian11.z * cartesian11.z + cartesian11.w * cartesian11.w;
};
Cartesian4.magnitude = function(cartesian11) {
  return Math.sqrt(Cartesian4.magnitudeSquared(cartesian11));
};
var distanceScratch2 = new Cartesian4();
Cartesian4.distance = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Cartesian4.subtract(left, right, distanceScratch2);
  return Cartesian4.magnitude(distanceScratch2);
};
Cartesian4.distanceSquared = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Cartesian4.subtract(left, right, distanceScratch2);
  return Cartesian4.magnitudeSquared(distanceScratch2);
};
Cartesian4.normalize = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const magnitude = Cartesian4.magnitude(cartesian11);
  result.x = cartesian11.x / magnitude;
  result.y = cartesian11.y / magnitude;
  result.z = cartesian11.z / magnitude;
  result.w = cartesian11.w / magnitude;
  if (isNaN(result.x) || isNaN(result.y) || isNaN(result.z) || isNaN(result.w)) {
    throw new DeveloperError_default("normalized result is not a number");
  }
  return result;
};
Cartesian4.dot = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  return left.x * right.x + left.y * right.y + left.z * right.z + left.w * right.w;
};
Cartesian4.multiplyComponents = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x * right.x;
  result.y = left.y * right.y;
  result.z = left.z * right.z;
  result.w = left.w * right.w;
  return result;
};
Cartesian4.divideComponents = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x / right.x;
  result.y = left.y / right.y;
  result.z = left.z / right.z;
  result.w = left.w / right.w;
  return result;
};
Cartesian4.add = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x + right.x;
  result.y = left.y + right.y;
  result.z = left.z + right.z;
  result.w = left.w + right.w;
  return result;
};
Cartesian4.subtract = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x - right.x;
  result.y = left.y - right.y;
  result.z = left.z - right.z;
  result.w = left.w - right.w;
  return result;
};
Cartesian4.multiplyByScalar = function(cartesian11, scalar, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.x = cartesian11.x * scalar;
  result.y = cartesian11.y * scalar;
  result.z = cartesian11.z * scalar;
  result.w = cartesian11.w * scalar;
  return result;
};
Cartesian4.divideByScalar = function(cartesian11, scalar, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.x = cartesian11.x / scalar;
  result.y = cartesian11.y / scalar;
  result.z = cartesian11.z / scalar;
  result.w = cartesian11.w / scalar;
  return result;
};
Cartesian4.negate = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result.x = -cartesian11.x;
  result.y = -cartesian11.y;
  result.z = -cartesian11.z;
  result.w = -cartesian11.w;
  return result;
};
Cartesian4.abs = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result.x = Math.abs(cartesian11.x);
  result.y = Math.abs(cartesian11.y);
  result.z = Math.abs(cartesian11.z);
  result.w = Math.abs(cartesian11.w);
  return result;
};
var lerpScratch2 = new Cartesian4();
Cartesian4.lerp = function(start, end, t, result) {
  Check_default.typeOf.object("start", start);
  Check_default.typeOf.object("end", end);
  Check_default.typeOf.number("t", t);
  Check_default.typeOf.object("result", result);
  Cartesian4.multiplyByScalar(end, t, lerpScratch2);
  result = Cartesian4.multiplyByScalar(start, 1 - t, result);
  return Cartesian4.add(lerpScratch2, result, result);
};
var mostOrthogonalAxisScratch2 = new Cartesian4();
Cartesian4.mostOrthogonalAxis = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const f2 = Cartesian4.normalize(cartesian11, mostOrthogonalAxisScratch2);
  Cartesian4.abs(f2, f2);
  if (f2.x <= f2.y) {
    if (f2.x <= f2.z) {
      if (f2.x <= f2.w) {
        result = Cartesian4.clone(Cartesian4.UNIT_X, result);
      } else {
        result = Cartesian4.clone(Cartesian4.UNIT_W, result);
      }
    } else if (f2.z <= f2.w) {
      result = Cartesian4.clone(Cartesian4.UNIT_Z, result);
    } else {
      result = Cartesian4.clone(Cartesian4.UNIT_W, result);
    }
  } else if (f2.y <= f2.z) {
    if (f2.y <= f2.w) {
      result = Cartesian4.clone(Cartesian4.UNIT_Y, result);
    } else {
      result = Cartesian4.clone(Cartesian4.UNIT_W, result);
    }
  } else if (f2.z <= f2.w) {
    result = Cartesian4.clone(Cartesian4.UNIT_Z, result);
  } else {
    result = Cartesian4.clone(Cartesian4.UNIT_W, result);
  }
  return result;
};
Cartesian4.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y && left.z === right.z && left.w === right.w;
};
Cartesian4.equalsArray = function(cartesian11, array, offset2) {
  return cartesian11.x === array[offset2] && cartesian11.y === array[offset2 + 1] && cartesian11.z === array[offset2 + 2] && cartesian11.w === array[offset2 + 3];
};
Cartesian4.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
  return left === right || defined_default(left) && defined_default(right) && Math_default.equalsEpsilon(
    left.x,
    right.x,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    left.y,
    right.y,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    left.z,
    right.z,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    left.w,
    right.w,
    relativeEpsilon,
    absoluteEpsilon
  );
};
Cartesian4.ZERO = Object.freeze(new Cartesian4(0, 0, 0, 0));
Cartesian4.ONE = Object.freeze(new Cartesian4(1, 1, 1, 1));
Cartesian4.UNIT_X = Object.freeze(new Cartesian4(1, 0, 0, 0));
Cartesian4.UNIT_Y = Object.freeze(new Cartesian4(0, 1, 0, 0));
Cartesian4.UNIT_Z = Object.freeze(new Cartesian4(0, 0, 1, 0));
Cartesian4.UNIT_W = Object.freeze(new Cartesian4(0, 0, 0, 1));
Cartesian4.prototype.clone = function(result) {
  return Cartesian4.clone(this, result);
};
Cartesian4.prototype.equals = function(right) {
  return Cartesian4.equals(this, right);
};
Cartesian4.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
  return Cartesian4.equalsEpsilon(
    this,
    right,
    relativeEpsilon,
    absoluteEpsilon
  );
};
Cartesian4.prototype.toString = function() {
  return `(${this.x}, ${this.y}, ${this.z}, ${this.w})`;
};
var scratchF32Array = new Float32Array(1);
var scratchU8Array = new Uint8Array(scratchF32Array.buffer);
var testU32 = new Uint32Array([287454020]);
var testU8 = new Uint8Array(testU32.buffer);
var littleEndian = testU8[0] === 68;
Cartesian4.packFloat = function(value, result) {
  Check_default.typeOf.number("value", value);
  if (!defined_default(result)) {
    result = new Cartesian4();
  }
  scratchF32Array[0] = value;
  if (littleEndian) {
    result.x = scratchU8Array[0];
    result.y = scratchU8Array[1];
    result.z = scratchU8Array[2];
    result.w = scratchU8Array[3];
  } else {
    result.x = scratchU8Array[3];
    result.y = scratchU8Array[2];
    result.z = scratchU8Array[1];
    result.w = scratchU8Array[0];
  }
  return result;
};
Cartesian4.unpackFloat = function(packedFloat) {
  Check_default.typeOf.object("packedFloat", packedFloat);
  if (littleEndian) {
    scratchU8Array[0] = packedFloat.x;
    scratchU8Array[1] = packedFloat.y;
    scratchU8Array[2] = packedFloat.z;
    scratchU8Array[3] = packedFloat.w;
  } else {
    scratchU8Array[0] = packedFloat.w;
    scratchU8Array[1] = packedFloat.z;
    scratchU8Array[2] = packedFloat.y;
    scratchU8Array[3] = packedFloat.x;
  }
  return scratchF32Array[0];
};
var Cartesian4_default = Cartesian4;

// node_modules/cesium/Source/Core/RuntimeError.js
function RuntimeError(message) {
  this.name = "RuntimeError";
  this.message = message;
  let stack;
  try {
    throw new Error();
  } catch (e2) {
    stack = e2.stack;
  }
  this.stack = stack;
}
if (defined_default(Object.create)) {
  RuntimeError.prototype = Object.create(Error.prototype);
  RuntimeError.prototype.constructor = RuntimeError;
}
RuntimeError.prototype.toString = function() {
  let str = `${this.name}: ${this.message}`;
  if (defined_default(this.stack)) {
    str += `
${this.stack.toString()}`;
  }
  return str;
};
var RuntimeError_default = RuntimeError;

// node_modules/cesium/Source/Core/Matrix4.js
function Matrix4(column0Row0, column1Row0, column2Row0, column3Row0, column0Row1, column1Row1, column2Row1, column3Row1, column0Row2, column1Row2, column2Row2, column3Row2, column0Row3, column1Row3, column2Row3, column3Row3) {
  this[0] = defaultValue_default(column0Row0, 0);
  this[1] = defaultValue_default(column0Row1, 0);
  this[2] = defaultValue_default(column0Row2, 0);
  this[3] = defaultValue_default(column0Row3, 0);
  this[4] = defaultValue_default(column1Row0, 0);
  this[5] = defaultValue_default(column1Row1, 0);
  this[6] = defaultValue_default(column1Row2, 0);
  this[7] = defaultValue_default(column1Row3, 0);
  this[8] = defaultValue_default(column2Row0, 0);
  this[9] = defaultValue_default(column2Row1, 0);
  this[10] = defaultValue_default(column2Row2, 0);
  this[11] = defaultValue_default(column2Row3, 0);
  this[12] = defaultValue_default(column3Row0, 0);
  this[13] = defaultValue_default(column3Row1, 0);
  this[14] = defaultValue_default(column3Row2, 0);
  this[15] = defaultValue_default(column3Row3, 0);
}
Matrix4.packedLength = 16;
Matrix4.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value[0];
  array[startingIndex++] = value[1];
  array[startingIndex++] = value[2];
  array[startingIndex++] = value[3];
  array[startingIndex++] = value[4];
  array[startingIndex++] = value[5];
  array[startingIndex++] = value[6];
  array[startingIndex++] = value[7];
  array[startingIndex++] = value[8];
  array[startingIndex++] = value[9];
  array[startingIndex++] = value[10];
  array[startingIndex++] = value[11];
  array[startingIndex++] = value[12];
  array[startingIndex++] = value[13];
  array[startingIndex++] = value[14];
  array[startingIndex] = value[15];
  return array;
};
Matrix4.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new Matrix4();
  }
  result[0] = array[startingIndex++];
  result[1] = array[startingIndex++];
  result[2] = array[startingIndex++];
  result[3] = array[startingIndex++];
  result[4] = array[startingIndex++];
  result[5] = array[startingIndex++];
  result[6] = array[startingIndex++];
  result[7] = array[startingIndex++];
  result[8] = array[startingIndex++];
  result[9] = array[startingIndex++];
  result[10] = array[startingIndex++];
  result[11] = array[startingIndex++];
  result[12] = array[startingIndex++];
  result[13] = array[startingIndex++];
  result[14] = array[startingIndex++];
  result[15] = array[startingIndex];
  return result;
};
Matrix4.packArray = function(array, result) {
  Check_default.defined("array", array);
  const length3 = array.length;
  const resultLength = length3 * 16;
  if (!defined_default(result)) {
    result = new Array(resultLength);
  } else if (!Array.isArray(result) && result.length !== resultLength) {
    throw new DeveloperError_default(
      "If result is a typed array, it must have exactly array.length * 16 elements"
    );
  } else if (result.length !== resultLength) {
    result.length = resultLength;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    Matrix4.pack(array[i2], result, i2 * 16);
  }
  return result;
};
Matrix4.unpackArray = function(array, result) {
  Check_default.defined("array", array);
  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 16);
  if (array.length % 16 !== 0) {
    throw new DeveloperError_default("array length must be a multiple of 16.");
  }
  const length3 = array.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 16);
  } else {
    result.length = length3 / 16;
  }
  for (let i2 = 0; i2 < length3; i2 += 16) {
    const index2 = i2 / 16;
    result[index2] = Matrix4.unpack(array, i2, result[index2]);
  }
  return result;
};
Matrix4.clone = function(matrix, result) {
  if (!defined_default(matrix)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Matrix4(
      matrix[0],
      matrix[4],
      matrix[8],
      matrix[12],
      matrix[1],
      matrix[5],
      matrix[9],
      matrix[13],
      matrix[2],
      matrix[6],
      matrix[10],
      matrix[14],
      matrix[3],
      matrix[7],
      matrix[11],
      matrix[15]
    );
  }
  result[0] = matrix[0];
  result[1] = matrix[1];
  result[2] = matrix[2];
  result[3] = matrix[3];
  result[4] = matrix[4];
  result[5] = matrix[5];
  result[6] = matrix[6];
  result[7] = matrix[7];
  result[8] = matrix[8];
  result[9] = matrix[9];
  result[10] = matrix[10];
  result[11] = matrix[11];
  result[12] = matrix[12];
  result[13] = matrix[13];
  result[14] = matrix[14];
  result[15] = matrix[15];
  return result;
};
Matrix4.fromArray = Matrix4.unpack;
Matrix4.fromColumnMajorArray = function(values, result) {
  Check_default.defined("values", values);
  return Matrix4.clone(values, result);
};
Matrix4.fromRowMajorArray = function(values, result) {
  Check_default.defined("values", values);
  if (!defined_default(result)) {
    return new Matrix4(
      values[0],
      values[1],
      values[2],
      values[3],
      values[4],
      values[5],
      values[6],
      values[7],
      values[8],
      values[9],
      values[10],
      values[11],
      values[12],
      values[13],
      values[14],
      values[15]
    );
  }
  result[0] = values[0];
  result[1] = values[4];
  result[2] = values[8];
  result[3] = values[12];
  result[4] = values[1];
  result[5] = values[5];
  result[6] = values[9];
  result[7] = values[13];
  result[8] = values[2];
  result[9] = values[6];
  result[10] = values[10];
  result[11] = values[14];
  result[12] = values[3];
  result[13] = values[7];
  result[14] = values[11];
  result[15] = values[15];
  return result;
};
Matrix4.fromRotationTranslation = function(rotation, translation3, result) {
  Check_default.typeOf.object("rotation", rotation);
  translation3 = defaultValue_default(translation3, Cartesian3_default.ZERO);
  if (!defined_default(result)) {
    return new Matrix4(
      rotation[0],
      rotation[3],
      rotation[6],
      translation3.x,
      rotation[1],
      rotation[4],
      rotation[7],
      translation3.y,
      rotation[2],
      rotation[5],
      rotation[8],
      translation3.z,
      0,
      0,
      0,
      1
    );
  }
  result[0] = rotation[0];
  result[1] = rotation[1];
  result[2] = rotation[2];
  result[3] = 0;
  result[4] = rotation[3];
  result[5] = rotation[4];
  result[6] = rotation[5];
  result[7] = 0;
  result[8] = rotation[6];
  result[9] = rotation[7];
  result[10] = rotation[8];
  result[11] = 0;
  result[12] = translation3.x;
  result[13] = translation3.y;
  result[14] = translation3.z;
  result[15] = 1;
  return result;
};
Matrix4.fromTranslationQuaternionRotationScale = function(translation3, rotation, scale, result) {
  Check_default.typeOf.object("translation", translation3);
  Check_default.typeOf.object("rotation", rotation);
  Check_default.typeOf.object("scale", scale);
  if (!defined_default(result)) {
    result = new Matrix4();
  }
  const scaleX = scale.x;
  const scaleY = scale.y;
  const scaleZ = scale.z;
  const x2 = rotation.x * rotation.x;
  const xy = rotation.x * rotation.y;
  const xz = rotation.x * rotation.z;
  const xw = rotation.x * rotation.w;
  const y2 = rotation.y * rotation.y;
  const yz = rotation.y * rotation.z;
  const yw = rotation.y * rotation.w;
  const z2 = rotation.z * rotation.z;
  const zw = rotation.z * rotation.w;
  const w2 = rotation.w * rotation.w;
  const m00 = x2 - y2 - z2 + w2;
  const m01 = 2 * (xy - zw);
  const m02 = 2 * (xz + yw);
  const m10 = 2 * (xy + zw);
  const m11 = -x2 + y2 - z2 + w2;
  const m12 = 2 * (yz - xw);
  const m20 = 2 * (xz - yw);
  const m21 = 2 * (yz + xw);
  const m22 = -x2 - y2 + z2 + w2;
  result[0] = m00 * scaleX;
  result[1] = m10 * scaleX;
  result[2] = m20 * scaleX;
  result[3] = 0;
  result[4] = m01 * scaleY;
  result[5] = m11 * scaleY;
  result[6] = m21 * scaleY;
  result[7] = 0;
  result[8] = m02 * scaleZ;
  result[9] = m12 * scaleZ;
  result[10] = m22 * scaleZ;
  result[11] = 0;
  result[12] = translation3.x;
  result[13] = translation3.y;
  result[14] = translation3.z;
  result[15] = 1;
  return result;
};
Matrix4.fromTranslationRotationScale = function(translationRotationScale, result) {
  Check_default.typeOf.object("translationRotationScale", translationRotationScale);
  return Matrix4.fromTranslationQuaternionRotationScale(
    translationRotationScale.translation,
    translationRotationScale.rotation,
    translationRotationScale.scale,
    result
  );
};
Matrix4.fromTranslation = function(translation3, result) {
  Check_default.typeOf.object("translation", translation3);
  return Matrix4.fromRotationTranslation(Matrix3_default.IDENTITY, translation3, result);
};
Matrix4.fromScale = function(scale, result) {
  Check_default.typeOf.object("scale", scale);
  if (!defined_default(result)) {
    return new Matrix4(
      scale.x,
      0,
      0,
      0,
      0,
      scale.y,
      0,
      0,
      0,
      0,
      scale.z,
      0,
      0,
      0,
      0,
      1
    );
  }
  result[0] = scale.x;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = 0;
  result[5] = scale.y;
  result[6] = 0;
  result[7] = 0;
  result[8] = 0;
  result[9] = 0;
  result[10] = scale.z;
  result[11] = 0;
  result[12] = 0;
  result[13] = 0;
  result[14] = 0;
  result[15] = 1;
  return result;
};
Matrix4.fromUniformScale = function(scale, result) {
  Check_default.typeOf.number("scale", scale);
  if (!defined_default(result)) {
    return new Matrix4(
      scale,
      0,
      0,
      0,
      0,
      scale,
      0,
      0,
      0,
      0,
      scale,
      0,
      0,
      0,
      0,
      1
    );
  }
  result[0] = scale;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = 0;
  result[5] = scale;
  result[6] = 0;
  result[7] = 0;
  result[8] = 0;
  result[9] = 0;
  result[10] = scale;
  result[11] = 0;
  result[12] = 0;
  result[13] = 0;
  result[14] = 0;
  result[15] = 1;
  return result;
};
Matrix4.fromRotation = function(rotation, result) {
  Check_default.typeOf.object("rotation", rotation);
  if (!defined_default(result)) {
    result = new Matrix4();
  }
  result[0] = rotation[0];
  result[1] = rotation[1];
  result[2] = rotation[2];
  result[3] = 0;
  result[4] = rotation[3];
  result[5] = rotation[4];
  result[6] = rotation[5];
  result[7] = 0;
  result[8] = rotation[6];
  result[9] = rotation[7];
  result[10] = rotation[8];
  result[11] = 0;
  result[12] = 0;
  result[13] = 0;
  result[14] = 0;
  result[15] = 1;
  return result;
};
var fromCameraF = new Cartesian3_default();
var fromCameraR = new Cartesian3_default();
var fromCameraU = new Cartesian3_default();
Matrix4.fromCamera = function(camera, result) {
  Check_default.typeOf.object("camera", camera);
  const position = camera.position;
  const direction2 = camera.direction;
  const up = camera.up;
  Check_default.typeOf.object("camera.position", position);
  Check_default.typeOf.object("camera.direction", direction2);
  Check_default.typeOf.object("camera.up", up);
  Cartesian3_default.normalize(direction2, fromCameraF);
  Cartesian3_default.normalize(
    Cartesian3_default.cross(fromCameraF, up, fromCameraR),
    fromCameraR
  );
  Cartesian3_default.normalize(
    Cartesian3_default.cross(fromCameraR, fromCameraF, fromCameraU),
    fromCameraU
  );
  const sX = fromCameraR.x;
  const sY = fromCameraR.y;
  const sZ = fromCameraR.z;
  const fX = fromCameraF.x;
  const fY = fromCameraF.y;
  const fZ = fromCameraF.z;
  const uX = fromCameraU.x;
  const uY = fromCameraU.y;
  const uZ = fromCameraU.z;
  const positionX = position.x;
  const positionY = position.y;
  const positionZ = position.z;
  const t0 = sX * -positionX + sY * -positionY + sZ * -positionZ;
  const t1 = uX * -positionX + uY * -positionY + uZ * -positionZ;
  const t2 = fX * positionX + fY * positionY + fZ * positionZ;
  if (!defined_default(result)) {
    return new Matrix4(
      sX,
      sY,
      sZ,
      t0,
      uX,
      uY,
      uZ,
      t1,
      -fX,
      -fY,
      -fZ,
      t2,
      0,
      0,
      0,
      1
    );
  }
  result[0] = sX;
  result[1] = uX;
  result[2] = -fX;
  result[3] = 0;
  result[4] = sY;
  result[5] = uY;
  result[6] = -fY;
  result[7] = 0;
  result[8] = sZ;
  result[9] = uZ;
  result[10] = -fZ;
  result[11] = 0;
  result[12] = t0;
  result[13] = t1;
  result[14] = t2;
  result[15] = 1;
  return result;
};
Matrix4.computePerspectiveFieldOfView = function(fovY, aspectRatio, near, far, result) {
  Check_default.typeOf.number.greaterThan("fovY", fovY, 0);
  Check_default.typeOf.number.lessThan("fovY", fovY, Math.PI);
  Check_default.typeOf.number.greaterThan("near", near, 0);
  Check_default.typeOf.number.greaterThan("far", far, 0);
  Check_default.typeOf.object("result", result);
  const bottom = Math.tan(fovY * 0.5);
  const column1Row1 = 1 / bottom;
  const column0Row0 = column1Row1 / aspectRatio;
  const column2Row2 = (far + near) / (near - far);
  const column3Row2 = 2 * far * near / (near - far);
  result[0] = column0Row0;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = 0;
  result[5] = column1Row1;
  result[6] = 0;
  result[7] = 0;
  result[8] = 0;
  result[9] = 0;
  result[10] = column2Row2;
  result[11] = -1;
  result[12] = 0;
  result[13] = 0;
  result[14] = column3Row2;
  result[15] = 0;
  return result;
};
Matrix4.computeOrthographicOffCenter = function(left, right, bottom, top, near, far, result) {
  Check_default.typeOf.number("left", left);
  Check_default.typeOf.number("right", right);
  Check_default.typeOf.number("bottom", bottom);
  Check_default.typeOf.number("top", top);
  Check_default.typeOf.number("near", near);
  Check_default.typeOf.number("far", far);
  Check_default.typeOf.object("result", result);
  let a4 = 1 / (right - left);
  let b = 1 / (top - bottom);
  let c14 = 1 / (far - near);
  const tx = -(right + left) * a4;
  const ty = -(top + bottom) * b;
  const tz = -(far + near) * c14;
  a4 *= 2;
  b *= 2;
  c14 *= -2;
  result[0] = a4;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = 0;
  result[5] = b;
  result[6] = 0;
  result[7] = 0;
  result[8] = 0;
  result[9] = 0;
  result[10] = c14;
  result[11] = 0;
  result[12] = tx;
  result[13] = ty;
  result[14] = tz;
  result[15] = 1;
  return result;
};
Matrix4.computePerspectiveOffCenter = function(left, right, bottom, top, near, far, result) {
  Check_default.typeOf.number("left", left);
  Check_default.typeOf.number("right", right);
  Check_default.typeOf.number("bottom", bottom);
  Check_default.typeOf.number("top", top);
  Check_default.typeOf.number("near", near);
  Check_default.typeOf.number("far", far);
  Check_default.typeOf.object("result", result);
  const column0Row0 = 2 * near / (right - left);
  const column1Row1 = 2 * near / (top - bottom);
  const column2Row0 = (right + left) / (right - left);
  const column2Row1 = (top + bottom) / (top - bottom);
  const column2Row2 = -(far + near) / (far - near);
  const column2Row3 = -1;
  const column3Row2 = -2 * far * near / (far - near);
  result[0] = column0Row0;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = 0;
  result[5] = column1Row1;
  result[6] = 0;
  result[7] = 0;
  result[8] = column2Row0;
  result[9] = column2Row1;
  result[10] = column2Row2;
  result[11] = column2Row3;
  result[12] = 0;
  result[13] = 0;
  result[14] = column3Row2;
  result[15] = 0;
  return result;
};
Matrix4.computeInfinitePerspectiveOffCenter = function(left, right, bottom, top, near, result) {
  Check_default.typeOf.number("left", left);
  Check_default.typeOf.number("right", right);
  Check_default.typeOf.number("bottom", bottom);
  Check_default.typeOf.number("top", top);
  Check_default.typeOf.number("near", near);
  Check_default.typeOf.object("result", result);
  const column0Row0 = 2 * near / (right - left);
  const column1Row1 = 2 * near / (top - bottom);
  const column2Row0 = (right + left) / (right - left);
  const column2Row1 = (top + bottom) / (top - bottom);
  const column2Row2 = -1;
  const column2Row3 = -1;
  const column3Row2 = -2 * near;
  result[0] = column0Row0;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = 0;
  result[5] = column1Row1;
  result[6] = 0;
  result[7] = 0;
  result[8] = column2Row0;
  result[9] = column2Row1;
  result[10] = column2Row2;
  result[11] = column2Row3;
  result[12] = 0;
  result[13] = 0;
  result[14] = column3Row2;
  result[15] = 0;
  return result;
};
Matrix4.computeViewportTransformation = function(viewport, nearDepthRange, farDepthRange, result) {
  if (!defined_default(result)) {
    result = new Matrix4();
  }
  viewport = defaultValue_default(viewport, defaultValue_default.EMPTY_OBJECT);
  const x = defaultValue_default(viewport.x, 0);
  const y = defaultValue_default(viewport.y, 0);
  const width = defaultValue_default(viewport.width, 0);
  const height = defaultValue_default(viewport.height, 0);
  nearDepthRange = defaultValue_default(nearDepthRange, 0);
  farDepthRange = defaultValue_default(farDepthRange, 1);
  const halfWidth = width * 0.5;
  const halfHeight = height * 0.5;
  const halfDepth = (farDepthRange - nearDepthRange) * 0.5;
  const column0Row0 = halfWidth;
  const column1Row1 = halfHeight;
  const column2Row2 = halfDepth;
  const column3Row0 = x + halfWidth;
  const column3Row1 = y + halfHeight;
  const column3Row2 = nearDepthRange + halfDepth;
  const column3Row3 = 1;
  result[0] = column0Row0;
  result[1] = 0;
  result[2] = 0;
  result[3] = 0;
  result[4] = 0;
  result[5] = column1Row1;
  result[6] = 0;
  result[7] = 0;
  result[8] = 0;
  result[9] = 0;
  result[10] = column2Row2;
  result[11] = 0;
  result[12] = column3Row0;
  result[13] = column3Row1;
  result[14] = column3Row2;
  result[15] = column3Row3;
  return result;
};
Matrix4.computeView = function(position, direction2, up, right, result) {
  Check_default.typeOf.object("position", position);
  Check_default.typeOf.object("direction", direction2);
  Check_default.typeOf.object("up", up);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result[0] = right.x;
  result[1] = up.x;
  result[2] = -direction2.x;
  result[3] = 0;
  result[4] = right.y;
  result[5] = up.y;
  result[6] = -direction2.y;
  result[7] = 0;
  result[8] = right.z;
  result[9] = up.z;
  result[10] = -direction2.z;
  result[11] = 0;
  result[12] = -Cartesian3_default.dot(right, position);
  result[13] = -Cartesian3_default.dot(up, position);
  result[14] = Cartesian3_default.dot(direction2, position);
  result[15] = 1;
  return result;
};
Matrix4.toArray = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  if (!defined_default(result)) {
    return [
      matrix[0],
      matrix[1],
      matrix[2],
      matrix[3],
      matrix[4],
      matrix[5],
      matrix[6],
      matrix[7],
      matrix[8],
      matrix[9],
      matrix[10],
      matrix[11],
      matrix[12],
      matrix[13],
      matrix[14],
      matrix[15]
    ];
  }
  result[0] = matrix[0];
  result[1] = matrix[1];
  result[2] = matrix[2];
  result[3] = matrix[3];
  result[4] = matrix[4];
  result[5] = matrix[5];
  result[6] = matrix[6];
  result[7] = matrix[7];
  result[8] = matrix[8];
  result[9] = matrix[9];
  result[10] = matrix[10];
  result[11] = matrix[11];
  result[12] = matrix[12];
  result[13] = matrix[13];
  result[14] = matrix[14];
  result[15] = matrix[15];
  return result;
};
Matrix4.getElementIndex = function(column, row) {
  Check_default.typeOf.number.greaterThanOrEquals("row", row, 0);
  Check_default.typeOf.number.lessThanOrEquals("row", row, 3);
  Check_default.typeOf.number.greaterThanOrEquals("column", column, 0);
  Check_default.typeOf.number.lessThanOrEquals("column", column, 3);
  return column * 4 + row;
};
Matrix4.getColumn = function(matrix, index2, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 3);
  Check_default.typeOf.object("result", result);
  const startIndex = index2 * 4;
  const x = matrix[startIndex];
  const y = matrix[startIndex + 1];
  const z = matrix[startIndex + 2];
  const w = matrix[startIndex + 3];
  result.x = x;
  result.y = y;
  result.z = z;
  result.w = w;
  return result;
};
Matrix4.setColumn = function(matrix, index2, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 3);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result = Matrix4.clone(matrix, result);
  const startIndex = index2 * 4;
  result[startIndex] = cartesian11.x;
  result[startIndex + 1] = cartesian11.y;
  result[startIndex + 2] = cartesian11.z;
  result[startIndex + 3] = cartesian11.w;
  return result;
};
Matrix4.getRow = function(matrix, index2, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 3);
  Check_default.typeOf.object("result", result);
  const x = matrix[index2];
  const y = matrix[index2 + 4];
  const z = matrix[index2 + 8];
  const w = matrix[index2 + 12];
  result.x = x;
  result.y = y;
  result.z = z;
  result.w = w;
  return result;
};
Matrix4.setRow = function(matrix, index2, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 3);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result = Matrix4.clone(matrix, result);
  result[index2] = cartesian11.x;
  result[index2 + 4] = cartesian11.y;
  result[index2 + 8] = cartesian11.z;
  result[index2 + 12] = cartesian11.w;
  return result;
};
Matrix4.setTranslation = function(matrix, translation3, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("translation", translation3);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0];
  result[1] = matrix[1];
  result[2] = matrix[2];
  result[3] = matrix[3];
  result[4] = matrix[4];
  result[5] = matrix[5];
  result[6] = matrix[6];
  result[7] = matrix[7];
  result[8] = matrix[8];
  result[9] = matrix[9];
  result[10] = matrix[10];
  result[11] = matrix[11];
  result[12] = translation3.x;
  result[13] = translation3.y;
  result[14] = translation3.z;
  result[15] = matrix[15];
  return result;
};
var scaleScratch12 = new Cartesian3_default();
Matrix4.setScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("scale", scale);
  Check_default.typeOf.object("result", result);
  const existingScale = Matrix4.getScale(matrix, scaleScratch12);
  const scaleRatioX = scale.x / existingScale.x;
  const scaleRatioY = scale.y / existingScale.y;
  const scaleRatioZ = scale.z / existingScale.z;
  result[0] = matrix[0] * scaleRatioX;
  result[1] = matrix[1] * scaleRatioX;
  result[2] = matrix[2] * scaleRatioX;
  result[3] = matrix[3];
  result[4] = matrix[4] * scaleRatioY;
  result[5] = matrix[5] * scaleRatioY;
  result[6] = matrix[6] * scaleRatioY;
  result[7] = matrix[7];
  result[8] = matrix[8] * scaleRatioZ;
  result[9] = matrix[9] * scaleRatioZ;
  result[10] = matrix[10] * scaleRatioZ;
  result[11] = matrix[11];
  result[12] = matrix[12];
  result[13] = matrix[13];
  result[14] = matrix[14];
  result[15] = matrix[15];
  return result;
};
var scaleScratch22 = new Cartesian3_default();
Matrix4.setUniformScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number("scale", scale);
  Check_default.typeOf.object("result", result);
  const existingScale = Matrix4.getScale(matrix, scaleScratch22);
  const scaleRatioX = scale / existingScale.x;
  const scaleRatioY = scale / existingScale.y;
  const scaleRatioZ = scale / existingScale.z;
  result[0] = matrix[0] * scaleRatioX;
  result[1] = matrix[1] * scaleRatioX;
  result[2] = matrix[2] * scaleRatioX;
  result[3] = matrix[3];
  result[4] = matrix[4] * scaleRatioY;
  result[5] = matrix[5] * scaleRatioY;
  result[6] = matrix[6] * scaleRatioY;
  result[7] = matrix[7];
  result[8] = matrix[8] * scaleRatioZ;
  result[9] = matrix[9] * scaleRatioZ;
  result[10] = matrix[10] * scaleRatioZ;
  result[11] = matrix[11];
  result[12] = matrix[12];
  result[13] = matrix[13];
  result[14] = matrix[14];
  result[15] = matrix[15];
  return result;
};
var scratchColumn2 = new Cartesian3_default();
Matrix4.getScale = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result.x = Cartesian3_default.magnitude(
    Cartesian3_default.fromElements(matrix[0], matrix[1], matrix[2], scratchColumn2)
  );
  result.y = Cartesian3_default.magnitude(
    Cartesian3_default.fromElements(matrix[4], matrix[5], matrix[6], scratchColumn2)
  );
  result.z = Cartesian3_default.magnitude(
    Cartesian3_default.fromElements(matrix[8], matrix[9], matrix[10], scratchColumn2)
  );
  return result;
};
var scaleScratch32 = new Cartesian3_default();
Matrix4.getMaximumScale = function(matrix) {
  Matrix4.getScale(matrix, scaleScratch32);
  return Cartesian3_default.maximumComponent(scaleScratch32);
};
var scaleScratch42 = new Cartesian3_default();
Matrix4.setRotation = function(matrix, rotation, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const scale = Matrix4.getScale(matrix, scaleScratch42);
  result[0] = rotation[0] * scale.x;
  result[1] = rotation[1] * scale.x;
  result[2] = rotation[2] * scale.x;
  result[3] = matrix[3];
  result[4] = rotation[3] * scale.y;
  result[5] = rotation[4] * scale.y;
  result[6] = rotation[5] * scale.y;
  result[7] = matrix[7];
  result[8] = rotation[6] * scale.z;
  result[9] = rotation[7] * scale.z;
  result[10] = rotation[8] * scale.z;
  result[11] = matrix[11];
  result[12] = matrix[12];
  result[13] = matrix[13];
  result[14] = matrix[14];
  result[15] = matrix[15];
  return result;
};
var scaleScratch52 = new Cartesian3_default();
Matrix4.getRotation = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const scale = Matrix4.getScale(matrix, scaleScratch52);
  result[0] = matrix[0] / scale.x;
  result[1] = matrix[1] / scale.x;
  result[2] = matrix[2] / scale.x;
  result[3] = matrix[4] / scale.y;
  result[4] = matrix[5] / scale.y;
  result[5] = matrix[6] / scale.y;
  result[6] = matrix[8] / scale.z;
  result[7] = matrix[9] / scale.z;
  result[8] = matrix[10] / scale.z;
  return result;
};
Matrix4.multiply = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  const left0 = left[0];
  const left1 = left[1];
  const left2 = left[2];
  const left3 = left[3];
  const left4 = left[4];
  const left5 = left[5];
  const left6 = left[6];
  const left7 = left[7];
  const left8 = left[8];
  const left9 = left[9];
  const left10 = left[10];
  const left11 = left[11];
  const left12 = left[12];
  const left13 = left[13];
  const left14 = left[14];
  const left15 = left[15];
  const right0 = right[0];
  const right1 = right[1];
  const right2 = right[2];
  const right3 = right[3];
  const right4 = right[4];
  const right5 = right[5];
  const right6 = right[6];
  const right7 = right[7];
  const right8 = right[8];
  const right9 = right[9];
  const right10 = right[10];
  const right11 = right[11];
  const right12 = right[12];
  const right13 = right[13];
  const right14 = right[14];
  const right15 = right[15];
  const column0Row0 = left0 * right0 + left4 * right1 + left8 * right2 + left12 * right3;
  const column0Row1 = left1 * right0 + left5 * right1 + left9 * right2 + left13 * right3;
  const column0Row2 = left2 * right0 + left6 * right1 + left10 * right2 + left14 * right3;
  const column0Row3 = left3 * right0 + left7 * right1 + left11 * right2 + left15 * right3;
  const column1Row0 = left0 * right4 + left4 * right5 + left8 * right6 + left12 * right7;
  const column1Row1 = left1 * right4 + left5 * right5 + left9 * right6 + left13 * right7;
  const column1Row2 = left2 * right4 + left6 * right5 + left10 * right6 + left14 * right7;
  const column1Row3 = left3 * right4 + left7 * right5 + left11 * right6 + left15 * right7;
  const column2Row0 = left0 * right8 + left4 * right9 + left8 * right10 + left12 * right11;
  const column2Row1 = left1 * right8 + left5 * right9 + left9 * right10 + left13 * right11;
  const column2Row2 = left2 * right8 + left6 * right9 + left10 * right10 + left14 * right11;
  const column2Row3 = left3 * right8 + left7 * right9 + left11 * right10 + left15 * right11;
  const column3Row0 = left0 * right12 + left4 * right13 + left8 * right14 + left12 * right15;
  const column3Row1 = left1 * right12 + left5 * right13 + left9 * right14 + left13 * right15;
  const column3Row2 = left2 * right12 + left6 * right13 + left10 * right14 + left14 * right15;
  const column3Row3 = left3 * right12 + left7 * right13 + left11 * right14 + left15 * right15;
  result[0] = column0Row0;
  result[1] = column0Row1;
  result[2] = column0Row2;
  result[3] = column0Row3;
  result[4] = column1Row0;
  result[5] = column1Row1;
  result[6] = column1Row2;
  result[7] = column1Row3;
  result[8] = column2Row0;
  result[9] = column2Row1;
  result[10] = column2Row2;
  result[11] = column2Row3;
  result[12] = column3Row0;
  result[13] = column3Row1;
  result[14] = column3Row2;
  result[15] = column3Row3;
  return result;
};
Matrix4.add = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result[0] = left[0] + right[0];
  result[1] = left[1] + right[1];
  result[2] = left[2] + right[2];
  result[3] = left[3] + right[3];
  result[4] = left[4] + right[4];
  result[5] = left[5] + right[5];
  result[6] = left[6] + right[6];
  result[7] = left[7] + right[7];
  result[8] = left[8] + right[8];
  result[9] = left[9] + right[9];
  result[10] = left[10] + right[10];
  result[11] = left[11] + right[11];
  result[12] = left[12] + right[12];
  result[13] = left[13] + right[13];
  result[14] = left[14] + right[14];
  result[15] = left[15] + right[15];
  return result;
};
Matrix4.subtract = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result[0] = left[0] - right[0];
  result[1] = left[1] - right[1];
  result[2] = left[2] - right[2];
  result[3] = left[3] - right[3];
  result[4] = left[4] - right[4];
  result[5] = left[5] - right[5];
  result[6] = left[6] - right[6];
  result[7] = left[7] - right[7];
  result[8] = left[8] - right[8];
  result[9] = left[9] - right[9];
  result[10] = left[10] - right[10];
  result[11] = left[11] - right[11];
  result[12] = left[12] - right[12];
  result[13] = left[13] - right[13];
  result[14] = left[14] - right[14];
  result[15] = left[15] - right[15];
  return result;
};
Matrix4.multiplyTransformation = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  const left0 = left[0];
  const left1 = left[1];
  const left2 = left[2];
  const left4 = left[4];
  const left5 = left[5];
  const left6 = left[6];
  const left8 = left[8];
  const left9 = left[9];
  const left10 = left[10];
  const left12 = left[12];
  const left13 = left[13];
  const left14 = left[14];
  const right0 = right[0];
  const right1 = right[1];
  const right2 = right[2];
  const right4 = right[4];
  const right5 = right[5];
  const right6 = right[6];
  const right8 = right[8];
  const right9 = right[9];
  const right10 = right[10];
  const right12 = right[12];
  const right13 = right[13];
  const right14 = right[14];
  const column0Row0 = left0 * right0 + left4 * right1 + left8 * right2;
  const column0Row1 = left1 * right0 + left5 * right1 + left9 * right2;
  const column0Row2 = left2 * right0 + left6 * right1 + left10 * right2;
  const column1Row0 = left0 * right4 + left4 * right5 + left8 * right6;
  const column1Row1 = left1 * right4 + left5 * right5 + left9 * right6;
  const column1Row2 = left2 * right4 + left6 * right5 + left10 * right6;
  const column2Row0 = left0 * right8 + left4 * right9 + left8 * right10;
  const column2Row1 = left1 * right8 + left5 * right9 + left9 * right10;
  const column2Row2 = left2 * right8 + left6 * right9 + left10 * right10;
  const column3Row0 = left0 * right12 + left4 * right13 + left8 * right14 + left12;
  const column3Row1 = left1 * right12 + left5 * right13 + left9 * right14 + left13;
  const column3Row2 = left2 * right12 + left6 * right13 + left10 * right14 + left14;
  result[0] = column0Row0;
  result[1] = column0Row1;
  result[2] = column0Row2;
  result[3] = 0;
  result[4] = column1Row0;
  result[5] = column1Row1;
  result[6] = column1Row2;
  result[7] = 0;
  result[8] = column2Row0;
  result[9] = column2Row1;
  result[10] = column2Row2;
  result[11] = 0;
  result[12] = column3Row0;
  result[13] = column3Row1;
  result[14] = column3Row2;
  result[15] = 1;
  return result;
};
Matrix4.multiplyByMatrix3 = function(matrix, rotation, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("rotation", rotation);
  Check_default.typeOf.object("result", result);
  const left0 = matrix[0];
  const left1 = matrix[1];
  const left2 = matrix[2];
  const left4 = matrix[4];
  const left5 = matrix[5];
  const left6 = matrix[6];
  const left8 = matrix[8];
  const left9 = matrix[9];
  const left10 = matrix[10];
  const right0 = rotation[0];
  const right1 = rotation[1];
  const right2 = rotation[2];
  const right4 = rotation[3];
  const right5 = rotation[4];
  const right6 = rotation[5];
  const right8 = rotation[6];
  const right9 = rotation[7];
  const right10 = rotation[8];
  const column0Row0 = left0 * right0 + left4 * right1 + left8 * right2;
  const column0Row1 = left1 * right0 + left5 * right1 + left9 * right2;
  const column0Row2 = left2 * right0 + left6 * right1 + left10 * right2;
  const column1Row0 = left0 * right4 + left4 * right5 + left8 * right6;
  const column1Row1 = left1 * right4 + left5 * right5 + left9 * right6;
  const column1Row2 = left2 * right4 + left6 * right5 + left10 * right6;
  const column2Row0 = left0 * right8 + left4 * right9 + left8 * right10;
  const column2Row1 = left1 * right8 + left5 * right9 + left9 * right10;
  const column2Row2 = left2 * right8 + left6 * right9 + left10 * right10;
  result[0] = column0Row0;
  result[1] = column0Row1;
  result[2] = column0Row2;
  result[3] = 0;
  result[4] = column1Row0;
  result[5] = column1Row1;
  result[6] = column1Row2;
  result[7] = 0;
  result[8] = column2Row0;
  result[9] = column2Row1;
  result[10] = column2Row2;
  result[11] = 0;
  result[12] = matrix[12];
  result[13] = matrix[13];
  result[14] = matrix[14];
  result[15] = matrix[15];
  return result;
};
Matrix4.multiplyByTranslation = function(matrix, translation3, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("translation", translation3);
  Check_default.typeOf.object("result", result);
  const x = translation3.x;
  const y = translation3.y;
  const z = translation3.z;
  const tx = x * matrix[0] + y * matrix[4] + z * matrix[8] + matrix[12];
  const ty = x * matrix[1] + y * matrix[5] + z * matrix[9] + matrix[13];
  const tz = x * matrix[2] + y * matrix[6] + z * matrix[10] + matrix[14];
  result[0] = matrix[0];
  result[1] = matrix[1];
  result[2] = matrix[2];
  result[3] = matrix[3];
  result[4] = matrix[4];
  result[5] = matrix[5];
  result[6] = matrix[6];
  result[7] = matrix[7];
  result[8] = matrix[8];
  result[9] = matrix[9];
  result[10] = matrix[10];
  result[11] = matrix[11];
  result[12] = tx;
  result[13] = ty;
  result[14] = tz;
  result[15] = matrix[15];
  return result;
};
Matrix4.multiplyByScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("scale", scale);
  Check_default.typeOf.object("result", result);
  const scaleX = scale.x;
  const scaleY = scale.y;
  const scaleZ = scale.z;
  if (scaleX === 1 && scaleY === 1 && scaleZ === 1) {
    return Matrix4.clone(matrix, result);
  }
  result[0] = scaleX * matrix[0];
  result[1] = scaleX * matrix[1];
  result[2] = scaleX * matrix[2];
  result[3] = matrix[3];
  result[4] = scaleY * matrix[4];
  result[5] = scaleY * matrix[5];
  result[6] = scaleY * matrix[6];
  result[7] = matrix[7];
  result[8] = scaleZ * matrix[8];
  result[9] = scaleZ * matrix[9];
  result[10] = scaleZ * matrix[10];
  result[11] = matrix[11];
  result[12] = matrix[12];
  result[13] = matrix[13];
  result[14] = matrix[14];
  result[15] = matrix[15];
  return result;
};
Matrix4.multiplyByUniformScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number("scale", scale);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0] * scale;
  result[1] = matrix[1] * scale;
  result[2] = matrix[2] * scale;
  result[3] = matrix[3];
  result[4] = matrix[4] * scale;
  result[5] = matrix[5] * scale;
  result[6] = matrix[6] * scale;
  result[7] = matrix[7];
  result[8] = matrix[8] * scale;
  result[9] = matrix[9] * scale;
  result[10] = matrix[10] * scale;
  result[11] = matrix[11];
  result[12] = matrix[12];
  result[13] = matrix[13];
  result[14] = matrix[14];
  result[15] = matrix[15];
  return result;
};
Matrix4.multiplyByVector = function(matrix, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const vX = cartesian11.x;
  const vY = cartesian11.y;
  const vZ = cartesian11.z;
  const vW = cartesian11.w;
  const x = matrix[0] * vX + matrix[4] * vY + matrix[8] * vZ + matrix[12] * vW;
  const y = matrix[1] * vX + matrix[5] * vY + matrix[9] * vZ + matrix[13] * vW;
  const z = matrix[2] * vX + matrix[6] * vY + matrix[10] * vZ + matrix[14] * vW;
  const w = matrix[3] * vX + matrix[7] * vY + matrix[11] * vZ + matrix[15] * vW;
  result.x = x;
  result.y = y;
  result.z = z;
  result.w = w;
  return result;
};
Matrix4.multiplyByPointAsVector = function(matrix, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const vX = cartesian11.x;
  const vY = cartesian11.y;
  const vZ = cartesian11.z;
  const x = matrix[0] * vX + matrix[4] * vY + matrix[8] * vZ;
  const y = matrix[1] * vX + matrix[5] * vY + matrix[9] * vZ;
  const z = matrix[2] * vX + matrix[6] * vY + matrix[10] * vZ;
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
Matrix4.multiplyByPoint = function(matrix, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const vX = cartesian11.x;
  const vY = cartesian11.y;
  const vZ = cartesian11.z;
  const x = matrix[0] * vX + matrix[4] * vY + matrix[8] * vZ + matrix[12];
  const y = matrix[1] * vX + matrix[5] * vY + matrix[9] * vZ + matrix[13];
  const z = matrix[2] * vX + matrix[6] * vY + matrix[10] * vZ + matrix[14];
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
Matrix4.multiplyByScalar = function(matrix, scalar, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0] * scalar;
  result[1] = matrix[1] * scalar;
  result[2] = matrix[2] * scalar;
  result[3] = matrix[3] * scalar;
  result[4] = matrix[4] * scalar;
  result[5] = matrix[5] * scalar;
  result[6] = matrix[6] * scalar;
  result[7] = matrix[7] * scalar;
  result[8] = matrix[8] * scalar;
  result[9] = matrix[9] * scalar;
  result[10] = matrix[10] * scalar;
  result[11] = matrix[11] * scalar;
  result[12] = matrix[12] * scalar;
  result[13] = matrix[13] * scalar;
  result[14] = matrix[14] * scalar;
  result[15] = matrix[15] * scalar;
  return result;
};
Matrix4.negate = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result[0] = -matrix[0];
  result[1] = -matrix[1];
  result[2] = -matrix[2];
  result[3] = -matrix[3];
  result[4] = -matrix[4];
  result[5] = -matrix[5];
  result[6] = -matrix[6];
  result[7] = -matrix[7];
  result[8] = -matrix[8];
  result[9] = -matrix[9];
  result[10] = -matrix[10];
  result[11] = -matrix[11];
  result[12] = -matrix[12];
  result[13] = -matrix[13];
  result[14] = -matrix[14];
  result[15] = -matrix[15];
  return result;
};
Matrix4.transpose = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const matrix1 = matrix[1];
  const matrix2 = matrix[2];
  const matrix3 = matrix[3];
  const matrix6 = matrix[6];
  const matrix7 = matrix[7];
  const matrix11 = matrix[11];
  result[0] = matrix[0];
  result[1] = matrix[4];
  result[2] = matrix[8];
  result[3] = matrix[12];
  result[4] = matrix1;
  result[5] = matrix[5];
  result[6] = matrix[9];
  result[7] = matrix[13];
  result[8] = matrix2;
  result[9] = matrix6;
  result[10] = matrix[10];
  result[11] = matrix[14];
  result[12] = matrix3;
  result[13] = matrix7;
  result[14] = matrix11;
  result[15] = matrix[15];
  return result;
};
Matrix4.abs = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result[0] = Math.abs(matrix[0]);
  result[1] = Math.abs(matrix[1]);
  result[2] = Math.abs(matrix[2]);
  result[3] = Math.abs(matrix[3]);
  result[4] = Math.abs(matrix[4]);
  result[5] = Math.abs(matrix[5]);
  result[6] = Math.abs(matrix[6]);
  result[7] = Math.abs(matrix[7]);
  result[8] = Math.abs(matrix[8]);
  result[9] = Math.abs(matrix[9]);
  result[10] = Math.abs(matrix[10]);
  result[11] = Math.abs(matrix[11]);
  result[12] = Math.abs(matrix[12]);
  result[13] = Math.abs(matrix[13]);
  result[14] = Math.abs(matrix[14]);
  result[15] = Math.abs(matrix[15]);
  return result;
};
Matrix4.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left[12] === right[12] && left[13] === right[13] && left[14] === right[14] && left[0] === right[0] && left[1] === right[1] && left[2] === right[2] && left[4] === right[4] && left[5] === right[5] && left[6] === right[6] && left[8] === right[8] && left[9] === right[9] && left[10] === right[10] && left[3] === right[3] && left[7] === right[7] && left[11] === right[11] && left[15] === right[15];
};
Matrix4.equalsEpsilon = function(left, right, epsilon) {
  epsilon = defaultValue_default(epsilon, 0);
  return left === right || defined_default(left) && defined_default(right) && Math.abs(left[0] - right[0]) <= epsilon && Math.abs(left[1] - right[1]) <= epsilon && Math.abs(left[2] - right[2]) <= epsilon && Math.abs(left[3] - right[3]) <= epsilon && Math.abs(left[4] - right[4]) <= epsilon && Math.abs(left[5] - right[5]) <= epsilon && Math.abs(left[6] - right[6]) <= epsilon && Math.abs(left[7] - right[7]) <= epsilon && Math.abs(left[8] - right[8]) <= epsilon && Math.abs(left[9] - right[9]) <= epsilon && Math.abs(left[10] - right[10]) <= epsilon && Math.abs(left[11] - right[11]) <= epsilon && Math.abs(left[12] - right[12]) <= epsilon && Math.abs(left[13] - right[13]) <= epsilon && Math.abs(left[14] - right[14]) <= epsilon && Math.abs(left[15] - right[15]) <= epsilon;
};
Matrix4.getTranslation = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result.x = matrix[12];
  result.y = matrix[13];
  result.z = matrix[14];
  return result;
};
Matrix4.getMatrix3 = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0];
  result[1] = matrix[1];
  result[2] = matrix[2];
  result[3] = matrix[4];
  result[4] = matrix[5];
  result[5] = matrix[6];
  result[6] = matrix[8];
  result[7] = matrix[9];
  result[8] = matrix[10];
  return result;
};
var scratchInverseRotation = new Matrix3_default();
var scratchMatrix3Zero = new Matrix3_default();
var scratchBottomRow = new Cartesian4_default();
var scratchExpectedBottomRow = new Cartesian4_default(0, 0, 0, 1);
Matrix4.inverse = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const src0 = matrix[0];
  const src1 = matrix[4];
  const src2 = matrix[8];
  const src3 = matrix[12];
  const src4 = matrix[1];
  const src5 = matrix[5];
  const src6 = matrix[9];
  const src7 = matrix[13];
  const src8 = matrix[2];
  const src9 = matrix[6];
  const src10 = matrix[10];
  const src11 = matrix[14];
  const src12 = matrix[3];
  const src13 = matrix[7];
  const src14 = matrix[11];
  const src15 = matrix[15];
  let tmp0 = src10 * src15;
  let tmp1 = src11 * src14;
  let tmp2 = src9 * src15;
  let tmp3 = src11 * src13;
  let tmp4 = src9 * src14;
  let tmp5 = src10 * src13;
  let tmp6 = src8 * src15;
  let tmp7 = src11 * src12;
  let tmp8 = src8 * src14;
  let tmp9 = src10 * src12;
  let tmp10 = src8 * src13;
  let tmp11 = src9 * src12;
  const dst0 = tmp0 * src5 + tmp3 * src6 + tmp4 * src7 - (tmp1 * src5 + tmp2 * src6 + tmp5 * src7);
  const dst1 = tmp1 * src4 + tmp6 * src6 + tmp9 * src7 - (tmp0 * src4 + tmp7 * src6 + tmp8 * src7);
  const dst2 = tmp2 * src4 + tmp7 * src5 + tmp10 * src7 - (tmp3 * src4 + tmp6 * src5 + tmp11 * src7);
  const dst3 = tmp5 * src4 + tmp8 * src5 + tmp11 * src6 - (tmp4 * src4 + tmp9 * src5 + tmp10 * src6);
  const dst4 = tmp1 * src1 + tmp2 * src2 + tmp5 * src3 - (tmp0 * src1 + tmp3 * src2 + tmp4 * src3);
  const dst5 = tmp0 * src0 + tmp7 * src2 + tmp8 * src3 - (tmp1 * src0 + tmp6 * src2 + tmp9 * src3);
  const dst6 = tmp3 * src0 + tmp6 * src1 + tmp11 * src3 - (tmp2 * src0 + tmp7 * src1 + tmp10 * src3);
  const dst7 = tmp4 * src0 + tmp9 * src1 + tmp10 * src2 - (tmp5 * src0 + tmp8 * src1 + tmp11 * src2);
  tmp0 = src2 * src7;
  tmp1 = src3 * src6;
  tmp2 = src1 * src7;
  tmp3 = src3 * src5;
  tmp4 = src1 * src6;
  tmp5 = src2 * src5;
  tmp6 = src0 * src7;
  tmp7 = src3 * src4;
  tmp8 = src0 * src6;
  tmp9 = src2 * src4;
  tmp10 = src0 * src5;
  tmp11 = src1 * src4;
  const dst8 = tmp0 * src13 + tmp3 * src14 + tmp4 * src15 - (tmp1 * src13 + tmp2 * src14 + tmp5 * src15);
  const dst9 = tmp1 * src12 + tmp6 * src14 + tmp9 * src15 - (tmp0 * src12 + tmp7 * src14 + tmp8 * src15);
  const dst10 = tmp2 * src12 + tmp7 * src13 + tmp10 * src15 - (tmp3 * src12 + tmp6 * src13 + tmp11 * src15);
  const dst11 = tmp5 * src12 + tmp8 * src13 + tmp11 * src14 - (tmp4 * src12 + tmp9 * src13 + tmp10 * src14);
  const dst12 = tmp2 * src10 + tmp5 * src11 + tmp1 * src9 - (tmp4 * src11 + tmp0 * src9 + tmp3 * src10);
  const dst13 = tmp8 * src11 + tmp0 * src8 + tmp7 * src10 - (tmp6 * src10 + tmp9 * src11 + tmp1 * src8);
  const dst14 = tmp6 * src9 + tmp11 * src11 + tmp3 * src8 - (tmp10 * src11 + tmp2 * src8 + tmp7 * src9);
  const dst15 = tmp10 * src10 + tmp4 * src8 + tmp9 * src9 - (tmp8 * src9 + tmp11 * src10 + tmp5 * src8);
  let det = src0 * dst0 + src1 * dst1 + src2 * dst2 + src3 * dst3;
  if (Math.abs(det) < Math_default.EPSILON21) {
    if (Matrix3_default.equalsEpsilon(
      Matrix4.getMatrix3(matrix, scratchInverseRotation),
      scratchMatrix3Zero,
      Math_default.EPSILON7
    ) && Cartesian4_default.equals(
      Matrix4.getRow(matrix, 3, scratchBottomRow),
      scratchExpectedBottomRow
    )) {
      result[0] = 0;
      result[1] = 0;
      result[2] = 0;
      result[3] = 0;
      result[4] = 0;
      result[5] = 0;
      result[6] = 0;
      result[7] = 0;
      result[8] = 0;
      result[9] = 0;
      result[10] = 0;
      result[11] = 0;
      result[12] = -matrix[12];
      result[13] = -matrix[13];
      result[14] = -matrix[14];
      result[15] = 1;
      return result;
    }
    throw new RuntimeError_default(
      "matrix is not invertible because its determinate is zero."
    );
  }
  det = 1 / det;
  result[0] = dst0 * det;
  result[1] = dst1 * det;
  result[2] = dst2 * det;
  result[3] = dst3 * det;
  result[4] = dst4 * det;
  result[5] = dst5 * det;
  result[6] = dst6 * det;
  result[7] = dst7 * det;
  result[8] = dst8 * det;
  result[9] = dst9 * det;
  result[10] = dst10 * det;
  result[11] = dst11 * det;
  result[12] = dst12 * det;
  result[13] = dst13 * det;
  result[14] = dst14 * det;
  result[15] = dst15 * det;
  return result;
};
Matrix4.inverseTransformation = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const matrix0 = matrix[0];
  const matrix1 = matrix[1];
  const matrix2 = matrix[2];
  const matrix4 = matrix[4];
  const matrix5 = matrix[5];
  const matrix6 = matrix[6];
  const matrix8 = matrix[8];
  const matrix9 = matrix[9];
  const matrix10 = matrix[10];
  const vX = matrix[12];
  const vY = matrix[13];
  const vZ = matrix[14];
  const x = -matrix0 * vX - matrix1 * vY - matrix2 * vZ;
  const y = -matrix4 * vX - matrix5 * vY - matrix6 * vZ;
  const z = -matrix8 * vX - matrix9 * vY - matrix10 * vZ;
  result[0] = matrix0;
  result[1] = matrix4;
  result[2] = matrix8;
  result[3] = 0;
  result[4] = matrix1;
  result[5] = matrix5;
  result[6] = matrix9;
  result[7] = 0;
  result[8] = matrix2;
  result[9] = matrix6;
  result[10] = matrix10;
  result[11] = 0;
  result[12] = x;
  result[13] = y;
  result[14] = z;
  result[15] = 1;
  return result;
};
var scratchTransposeMatrix2 = new Matrix4();
Matrix4.inverseTranspose = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  return Matrix4.inverse(
    Matrix4.transpose(matrix, scratchTransposeMatrix2),
    result
  );
};
Matrix4.IDENTITY = Object.freeze(
  new Matrix4(
    1,
    0,
    0,
    0,
    0,
    1,
    0,
    0,
    0,
    0,
    1,
    0,
    0,
    0,
    0,
    1
  )
);
Matrix4.ZERO = Object.freeze(
  new Matrix4(
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0
  )
);
Matrix4.COLUMN0ROW0 = 0;
Matrix4.COLUMN0ROW1 = 1;
Matrix4.COLUMN0ROW2 = 2;
Matrix4.COLUMN0ROW3 = 3;
Matrix4.COLUMN1ROW0 = 4;
Matrix4.COLUMN1ROW1 = 5;
Matrix4.COLUMN1ROW2 = 6;
Matrix4.COLUMN1ROW3 = 7;
Matrix4.COLUMN2ROW0 = 8;
Matrix4.COLUMN2ROW1 = 9;
Matrix4.COLUMN2ROW2 = 10;
Matrix4.COLUMN2ROW3 = 11;
Matrix4.COLUMN3ROW0 = 12;
Matrix4.COLUMN3ROW1 = 13;
Matrix4.COLUMN3ROW2 = 14;
Matrix4.COLUMN3ROW3 = 15;
Object.defineProperties(Matrix4.prototype, {
  length: {
    get: function() {
      return Matrix4.packedLength;
    }
  }
});
Matrix4.prototype.clone = function(result) {
  return Matrix4.clone(this, result);
};
Matrix4.prototype.equals = function(right) {
  return Matrix4.equals(this, right);
};
Matrix4.equalsArray = function(matrix, array, offset2) {
  return matrix[0] === array[offset2] && matrix[1] === array[offset2 + 1] && matrix[2] === array[offset2 + 2] && matrix[3] === array[offset2 + 3] && matrix[4] === array[offset2 + 4] && matrix[5] === array[offset2 + 5] && matrix[6] === array[offset2 + 6] && matrix[7] === array[offset2 + 7] && matrix[8] === array[offset2 + 8] && matrix[9] === array[offset2 + 9] && matrix[10] === array[offset2 + 10] && matrix[11] === array[offset2 + 11] && matrix[12] === array[offset2 + 12] && matrix[13] === array[offset2 + 13] && matrix[14] === array[offset2 + 14] && matrix[15] === array[offset2 + 15];
};
Matrix4.prototype.equalsEpsilon = function(right, epsilon) {
  return Matrix4.equalsEpsilon(this, right, epsilon);
};
Matrix4.prototype.toString = function() {
  return `(${this[0]}, ${this[4]}, ${this[8]}, ${this[12]})
(${this[1]}, ${this[5]}, ${this[9]}, ${this[13]})
(${this[2]}, ${this[6]}, ${this[10]}, ${this[14]})
(${this[3]}, ${this[7]}, ${this[11]}, ${this[15]})`;
};
var Matrix4_default = Matrix4;

// node_modules/cesium/Source/Core/Rectangle.js
function Rectangle(west, south, east, north) {
  this.west = defaultValue_default(west, 0);
  this.south = defaultValue_default(south, 0);
  this.east = defaultValue_default(east, 0);
  this.north = defaultValue_default(north, 0);
}
Object.defineProperties(Rectangle.prototype, {
  width: {
    get: function() {
      return Rectangle.computeWidth(this);
    }
  },
  height: {
    get: function() {
      return Rectangle.computeHeight(this);
    }
  }
});
Rectangle.packedLength = 4;
Rectangle.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.west;
  array[startingIndex++] = value.south;
  array[startingIndex++] = value.east;
  array[startingIndex] = value.north;
  return array;
};
Rectangle.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new Rectangle();
  }
  result.west = array[startingIndex++];
  result.south = array[startingIndex++];
  result.east = array[startingIndex++];
  result.north = array[startingIndex];
  return result;
};
Rectangle.computeWidth = function(rectangle) {
  Check_default.typeOf.object("rectangle", rectangle);
  let east = rectangle.east;
  const west = rectangle.west;
  if (east < west) {
    east += Math_default.TWO_PI;
  }
  return east - west;
};
Rectangle.computeHeight = function(rectangle) {
  Check_default.typeOf.object("rectangle", rectangle);
  return rectangle.north - rectangle.south;
};
Rectangle.fromDegrees = function(west, south, east, north, result) {
  west = Math_default.toRadians(defaultValue_default(west, 0));
  south = Math_default.toRadians(defaultValue_default(south, 0));
  east = Math_default.toRadians(defaultValue_default(east, 0));
  north = Math_default.toRadians(defaultValue_default(north, 0));
  if (!defined_default(result)) {
    return new Rectangle(west, south, east, north);
  }
  result.west = west;
  result.south = south;
  result.east = east;
  result.north = north;
  return result;
};
Rectangle.fromRadians = function(west, south, east, north, result) {
  if (!defined_default(result)) {
    return new Rectangle(west, south, east, north);
  }
  result.west = defaultValue_default(west, 0);
  result.south = defaultValue_default(south, 0);
  result.east = defaultValue_default(east, 0);
  result.north = defaultValue_default(north, 0);
  return result;
};
Rectangle.fromCartographicArray = function(cartographics, result) {
  Check_default.defined("cartographics", cartographics);
  let west = Number.MAX_VALUE;
  let east = -Number.MAX_VALUE;
  let westOverIDL = Number.MAX_VALUE;
  let eastOverIDL = -Number.MAX_VALUE;
  let south = Number.MAX_VALUE;
  let north = -Number.MAX_VALUE;
  for (let i2 = 0, len = cartographics.length; i2 < len; i2++) {
    const position = cartographics[i2];
    west = Math.min(west, position.longitude);
    east = Math.max(east, position.longitude);
    south = Math.min(south, position.latitude);
    north = Math.max(north, position.latitude);
    const lonAdjusted = position.longitude >= 0 ? position.longitude : position.longitude + Math_default.TWO_PI;
    westOverIDL = Math.min(westOverIDL, lonAdjusted);
    eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
  }
  if (east - west > eastOverIDL - westOverIDL) {
    west = westOverIDL;
    east = eastOverIDL;
    if (east > Math_default.PI) {
      east = east - Math_default.TWO_PI;
    }
    if (west > Math_default.PI) {
      west = west - Math_default.TWO_PI;
    }
  }
  if (!defined_default(result)) {
    return new Rectangle(west, south, east, north);
  }
  result.west = west;
  result.south = south;
  result.east = east;
  result.north = north;
  return result;
};
Rectangle.fromCartesianArray = function(cartesians, ellipsoid, result) {
  Check_default.defined("cartesians", cartesians);
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  let west = Number.MAX_VALUE;
  let east = -Number.MAX_VALUE;
  let westOverIDL = Number.MAX_VALUE;
  let eastOverIDL = -Number.MAX_VALUE;
  let south = Number.MAX_VALUE;
  let north = -Number.MAX_VALUE;
  for (let i2 = 0, len = cartesians.length; i2 < len; i2++) {
    const position = ellipsoid.cartesianToCartographic(cartesians[i2]);
    west = Math.min(west, position.longitude);
    east = Math.max(east, position.longitude);
    south = Math.min(south, position.latitude);
    north = Math.max(north, position.latitude);
    const lonAdjusted = position.longitude >= 0 ? position.longitude : position.longitude + Math_default.TWO_PI;
    westOverIDL = Math.min(westOverIDL, lonAdjusted);
    eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
  }
  if (east - west > eastOverIDL - westOverIDL) {
    west = westOverIDL;
    east = eastOverIDL;
    if (east > Math_default.PI) {
      east = east - Math_default.TWO_PI;
    }
    if (west > Math_default.PI) {
      west = west - Math_default.TWO_PI;
    }
  }
  if (!defined_default(result)) {
    return new Rectangle(west, south, east, north);
  }
  result.west = west;
  result.south = south;
  result.east = east;
  result.north = north;
  return result;
};
Rectangle.clone = function(rectangle, result) {
  if (!defined_default(rectangle)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Rectangle(
      rectangle.west,
      rectangle.south,
      rectangle.east,
      rectangle.north
    );
  }
  result.west = rectangle.west;
  result.south = rectangle.south;
  result.east = rectangle.east;
  result.north = rectangle.north;
  return result;
};
Rectangle.equalsEpsilon = function(left, right, absoluteEpsilon) {
  absoluteEpsilon = defaultValue_default(absoluteEpsilon, 0);
  return left === right || defined_default(left) && defined_default(right) && Math.abs(left.west - right.west) <= absoluteEpsilon && Math.abs(left.south - right.south) <= absoluteEpsilon && Math.abs(left.east - right.east) <= absoluteEpsilon && Math.abs(left.north - right.north) <= absoluteEpsilon;
};
Rectangle.prototype.clone = function(result) {
  return Rectangle.clone(this, result);
};
Rectangle.prototype.equals = function(other) {
  return Rectangle.equals(this, other);
};
Rectangle.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.west === right.west && left.south === right.south && left.east === right.east && left.north === right.north;
};
Rectangle.prototype.equalsEpsilon = function(other, epsilon) {
  return Rectangle.equalsEpsilon(this, other, epsilon);
};
Rectangle.validate = function(rectangle) {
  Check_default.typeOf.object("rectangle", rectangle);
  const north = rectangle.north;
  Check_default.typeOf.number.greaterThanOrEquals(
    "north",
    north,
    -Math_default.PI_OVER_TWO
  );
  Check_default.typeOf.number.lessThanOrEquals("north", north, Math_default.PI_OVER_TWO);
  const south = rectangle.south;
  Check_default.typeOf.number.greaterThanOrEquals(
    "south",
    south,
    -Math_default.PI_OVER_TWO
  );
  Check_default.typeOf.number.lessThanOrEquals("south", south, Math_default.PI_OVER_TWO);
  const west = rectangle.west;
  Check_default.typeOf.number.greaterThanOrEquals("west", west, -Math.PI);
  Check_default.typeOf.number.lessThanOrEquals("west", west, Math.PI);
  const east = rectangle.east;
  Check_default.typeOf.number.greaterThanOrEquals("east", east, -Math.PI);
  Check_default.typeOf.number.lessThanOrEquals("east", east, Math.PI);
};
Rectangle.southwest = function(rectangle, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  if (!defined_default(result)) {
    return new Cartographic_default(rectangle.west, rectangle.south);
  }
  result.longitude = rectangle.west;
  result.latitude = rectangle.south;
  result.height = 0;
  return result;
};
Rectangle.northwest = function(rectangle, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  if (!defined_default(result)) {
    return new Cartographic_default(rectangle.west, rectangle.north);
  }
  result.longitude = rectangle.west;
  result.latitude = rectangle.north;
  result.height = 0;
  return result;
};
Rectangle.northeast = function(rectangle, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  if (!defined_default(result)) {
    return new Cartographic_default(rectangle.east, rectangle.north);
  }
  result.longitude = rectangle.east;
  result.latitude = rectangle.north;
  result.height = 0;
  return result;
};
Rectangle.southeast = function(rectangle, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  if (!defined_default(result)) {
    return new Cartographic_default(rectangle.east, rectangle.south);
  }
  result.longitude = rectangle.east;
  result.latitude = rectangle.south;
  result.height = 0;
  return result;
};
Rectangle.center = function(rectangle, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  let east = rectangle.east;
  const west = rectangle.west;
  if (east < west) {
    east += Math_default.TWO_PI;
  }
  const longitude = Math_default.negativePiToPi((west + east) * 0.5);
  const latitude = (rectangle.south + rectangle.north) * 0.5;
  if (!defined_default(result)) {
    return new Cartographic_default(longitude, latitude);
  }
  result.longitude = longitude;
  result.latitude = latitude;
  result.height = 0;
  return result;
};
Rectangle.intersection = function(rectangle, otherRectangle, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  Check_default.typeOf.object("otherRectangle", otherRectangle);
  let rectangleEast = rectangle.east;
  let rectangleWest = rectangle.west;
  let otherRectangleEast = otherRectangle.east;
  let otherRectangleWest = otherRectangle.west;
  if (rectangleEast < rectangleWest && otherRectangleEast > 0) {
    rectangleEast += Math_default.TWO_PI;
  } else if (otherRectangleEast < otherRectangleWest && rectangleEast > 0) {
    otherRectangleEast += Math_default.TWO_PI;
  }
  if (rectangleEast < rectangleWest && otherRectangleWest < 0) {
    otherRectangleWest += Math_default.TWO_PI;
  } else if (otherRectangleEast < otherRectangleWest && rectangleWest < 0) {
    rectangleWest += Math_default.TWO_PI;
  }
  const west = Math_default.negativePiToPi(
    Math.max(rectangleWest, otherRectangleWest)
  );
  const east = Math_default.negativePiToPi(
    Math.min(rectangleEast, otherRectangleEast)
  );
  if ((rectangle.west < rectangle.east || otherRectangle.west < otherRectangle.east) && east <= west) {
    return void 0;
  }
  const south = Math.max(rectangle.south, otherRectangle.south);
  const north = Math.min(rectangle.north, otherRectangle.north);
  if (south >= north) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Rectangle(west, south, east, north);
  }
  result.west = west;
  result.south = south;
  result.east = east;
  result.north = north;
  return result;
};
Rectangle.simpleIntersection = function(rectangle, otherRectangle, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  Check_default.typeOf.object("otherRectangle", otherRectangle);
  const west = Math.max(rectangle.west, otherRectangle.west);
  const south = Math.max(rectangle.south, otherRectangle.south);
  const east = Math.min(rectangle.east, otherRectangle.east);
  const north = Math.min(rectangle.north, otherRectangle.north);
  if (south >= north || west >= east) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Rectangle(west, south, east, north);
  }
  result.west = west;
  result.south = south;
  result.east = east;
  result.north = north;
  return result;
};
Rectangle.union = function(rectangle, otherRectangle, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  Check_default.typeOf.object("otherRectangle", otherRectangle);
  if (!defined_default(result)) {
    result = new Rectangle();
  }
  let rectangleEast = rectangle.east;
  let rectangleWest = rectangle.west;
  let otherRectangleEast = otherRectangle.east;
  let otherRectangleWest = otherRectangle.west;
  if (rectangleEast < rectangleWest && otherRectangleEast > 0) {
    rectangleEast += Math_default.TWO_PI;
  } else if (otherRectangleEast < otherRectangleWest && rectangleEast > 0) {
    otherRectangleEast += Math_default.TWO_PI;
  }
  if (rectangleEast < rectangleWest && otherRectangleWest < 0) {
    otherRectangleWest += Math_default.TWO_PI;
  } else if (otherRectangleEast < otherRectangleWest && rectangleWest < 0) {
    rectangleWest += Math_default.TWO_PI;
  }
  const west = Math_default.negativePiToPi(
    Math.min(rectangleWest, otherRectangleWest)
  );
  const east = Math_default.negativePiToPi(
    Math.max(rectangleEast, otherRectangleEast)
  );
  result.west = west;
  result.south = Math.min(rectangle.south, otherRectangle.south);
  result.east = east;
  result.north = Math.max(rectangle.north, otherRectangle.north);
  return result;
};
Rectangle.expand = function(rectangle, cartographic2, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  Check_default.typeOf.object("cartographic", cartographic2);
  if (!defined_default(result)) {
    result = new Rectangle();
  }
  result.west = Math.min(rectangle.west, cartographic2.longitude);
  result.south = Math.min(rectangle.south, cartographic2.latitude);
  result.east = Math.max(rectangle.east, cartographic2.longitude);
  result.north = Math.max(rectangle.north, cartographic2.latitude);
  return result;
};
Rectangle.contains = function(rectangle, cartographic2) {
  Check_default.typeOf.object("rectangle", rectangle);
  Check_default.typeOf.object("cartographic", cartographic2);
  let longitude = cartographic2.longitude;
  const latitude = cartographic2.latitude;
  const west = rectangle.west;
  let east = rectangle.east;
  if (east < west) {
    east += Math_default.TWO_PI;
    if (longitude < 0) {
      longitude += Math_default.TWO_PI;
    }
  }
  return (longitude > west || Math_default.equalsEpsilon(longitude, west, Math_default.EPSILON14)) && (longitude < east || Math_default.equalsEpsilon(longitude, east, Math_default.EPSILON14)) && latitude >= rectangle.south && latitude <= rectangle.north;
};
var subsampleLlaScratch = new Cartographic_default();
Rectangle.subsample = function(rectangle, ellipsoid, surfaceHeight, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  surfaceHeight = defaultValue_default(surfaceHeight, 0);
  if (!defined_default(result)) {
    result = [];
  }
  let length3 = 0;
  const north = rectangle.north;
  const south = rectangle.south;
  const east = rectangle.east;
  const west = rectangle.west;
  const lla = subsampleLlaScratch;
  lla.height = surfaceHeight;
  lla.longitude = west;
  lla.latitude = north;
  result[length3] = ellipsoid.cartographicToCartesian(lla, result[length3]);
  length3++;
  lla.longitude = east;
  result[length3] = ellipsoid.cartographicToCartesian(lla, result[length3]);
  length3++;
  lla.latitude = south;
  result[length3] = ellipsoid.cartographicToCartesian(lla, result[length3]);
  length3++;
  lla.longitude = west;
  result[length3] = ellipsoid.cartographicToCartesian(lla, result[length3]);
  length3++;
  if (north < 0) {
    lla.latitude = north;
  } else if (south > 0) {
    lla.latitude = south;
  } else {
    lla.latitude = 0;
  }
  for (let i2 = 1; i2 < 8; ++i2) {
    lla.longitude = -Math.PI + i2 * Math_default.PI_OVER_TWO;
    if (Rectangle.contains(rectangle, lla)) {
      result[length3] = ellipsoid.cartographicToCartesian(lla, result[length3]);
      length3++;
    }
  }
  if (lla.latitude === 0) {
    lla.longitude = west;
    result[length3] = ellipsoid.cartographicToCartesian(lla, result[length3]);
    length3++;
    lla.longitude = east;
    result[length3] = ellipsoid.cartographicToCartesian(lla, result[length3]);
    length3++;
  }
  result.length = length3;
  return result;
};
Rectangle.subsection = function(rectangle, westLerp, southLerp, eastLerp, northLerp, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  Check_default.typeOf.number.greaterThanOrEquals("westLerp", westLerp, 0);
  Check_default.typeOf.number.lessThanOrEquals("westLerp", westLerp, 1);
  Check_default.typeOf.number.greaterThanOrEquals("southLerp", southLerp, 0);
  Check_default.typeOf.number.lessThanOrEquals("southLerp", southLerp, 1);
  Check_default.typeOf.number.greaterThanOrEquals("eastLerp", eastLerp, 0);
  Check_default.typeOf.number.lessThanOrEquals("eastLerp", eastLerp, 1);
  Check_default.typeOf.number.greaterThanOrEquals("northLerp", northLerp, 0);
  Check_default.typeOf.number.lessThanOrEquals("northLerp", northLerp, 1);
  Check_default.typeOf.number.lessThanOrEquals("westLerp", westLerp, eastLerp);
  Check_default.typeOf.number.lessThanOrEquals("southLerp", southLerp, northLerp);
  if (!defined_default(result)) {
    result = new Rectangle();
  }
  if (rectangle.west <= rectangle.east) {
    const width = rectangle.east - rectangle.west;
    result.west = rectangle.west + westLerp * width;
    result.east = rectangle.west + eastLerp * width;
  } else {
    const width = Math_default.TWO_PI + rectangle.east - rectangle.west;
    result.west = Math_default.negativePiToPi(rectangle.west + westLerp * width);
    result.east = Math_default.negativePiToPi(rectangle.west + eastLerp * width);
  }
  const height = rectangle.north - rectangle.south;
  result.south = rectangle.south + southLerp * height;
  result.north = rectangle.south + northLerp * height;
  if (westLerp === 1) {
    result.west = rectangle.east;
  }
  if (eastLerp === 1) {
    result.east = rectangle.east;
  }
  if (southLerp === 1) {
    result.south = rectangle.north;
  }
  if (northLerp === 1) {
    result.north = rectangle.north;
  }
  return result;
};
Rectangle.MAX_VALUE = Object.freeze(
  new Rectangle(
    -Math.PI,
    -Math_default.PI_OVER_TWO,
    Math.PI,
    Math_default.PI_OVER_TWO
  )
);
var Rectangle_default = Rectangle;

// node_modules/cesium/Source/Core/BoundingSphere.js
function BoundingSphere(center, radius) {
  this.center = Cartesian3_default.clone(defaultValue_default(center, Cartesian3_default.ZERO));
  this.radius = defaultValue_default(radius, 0);
}
var fromPointsXMin = new Cartesian3_default();
var fromPointsYMin = new Cartesian3_default();
var fromPointsZMin = new Cartesian3_default();
var fromPointsXMax = new Cartesian3_default();
var fromPointsYMax = new Cartesian3_default();
var fromPointsZMax = new Cartesian3_default();
var fromPointsCurrentPos = new Cartesian3_default();
var fromPointsScratch = new Cartesian3_default();
var fromPointsRitterCenter = new Cartesian3_default();
var fromPointsMinBoxPt = new Cartesian3_default();
var fromPointsMaxBoxPt = new Cartesian3_default();
var fromPointsNaiveCenterScratch = new Cartesian3_default();
var volumeConstant = 4 / 3 * Math_default.PI;
BoundingSphere.fromPoints = function(positions, result) {
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  if (!defined_default(positions) || positions.length === 0) {
    result.center = Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
    result.radius = 0;
    return result;
  }
  const currentPos = Cartesian3_default.clone(positions[0], fromPointsCurrentPos);
  const xMin = Cartesian3_default.clone(currentPos, fromPointsXMin);
  const yMin = Cartesian3_default.clone(currentPos, fromPointsYMin);
  const zMin = Cartesian3_default.clone(currentPos, fromPointsZMin);
  const xMax = Cartesian3_default.clone(currentPos, fromPointsXMax);
  const yMax = Cartesian3_default.clone(currentPos, fromPointsYMax);
  const zMax = Cartesian3_default.clone(currentPos, fromPointsZMax);
  const numPositions = positions.length;
  let i2;
  for (i2 = 1; i2 < numPositions; i2++) {
    Cartesian3_default.clone(positions[i2], currentPos);
    const x = currentPos.x;
    const y = currentPos.y;
    const z = currentPos.z;
    if (x < xMin.x) {
      Cartesian3_default.clone(currentPos, xMin);
    }
    if (x > xMax.x) {
      Cartesian3_default.clone(currentPos, xMax);
    }
    if (y < yMin.y) {
      Cartesian3_default.clone(currentPos, yMin);
    }
    if (y > yMax.y) {
      Cartesian3_default.clone(currentPos, yMax);
    }
    if (z < zMin.z) {
      Cartesian3_default.clone(currentPos, zMin);
    }
    if (z > zMax.z) {
      Cartesian3_default.clone(currentPos, zMax);
    }
  }
  const xSpan = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(xMax, xMin, fromPointsScratch)
  );
  const ySpan = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(yMax, yMin, fromPointsScratch)
  );
  const zSpan = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(zMax, zMin, fromPointsScratch)
  );
  let diameter1 = xMin;
  let diameter2 = xMax;
  let maxSpan = xSpan;
  if (ySpan > maxSpan) {
    maxSpan = ySpan;
    diameter1 = yMin;
    diameter2 = yMax;
  }
  if (zSpan > maxSpan) {
    maxSpan = zSpan;
    diameter1 = zMin;
    diameter2 = zMax;
  }
  const ritterCenter = fromPointsRitterCenter;
  ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;
  ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;
  ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;
  let radiusSquared = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(diameter2, ritterCenter, fromPointsScratch)
  );
  let ritterRadius = Math.sqrt(radiusSquared);
  const minBoxPt = fromPointsMinBoxPt;
  minBoxPt.x = xMin.x;
  minBoxPt.y = yMin.y;
  minBoxPt.z = zMin.z;
  const maxBoxPt = fromPointsMaxBoxPt;
  maxBoxPt.x = xMax.x;
  maxBoxPt.y = yMax.y;
  maxBoxPt.z = zMax.z;
  const naiveCenter = Cartesian3_default.midpoint(
    minBoxPt,
    maxBoxPt,
    fromPointsNaiveCenterScratch
  );
  let naiveRadius = 0;
  for (i2 = 0; i2 < numPositions; i2++) {
    Cartesian3_default.clone(positions[i2], currentPos);
    const r2 = Cartesian3_default.magnitude(
      Cartesian3_default.subtract(currentPos, naiveCenter, fromPointsScratch)
    );
    if (r2 > naiveRadius) {
      naiveRadius = r2;
    }
    const oldCenterToPointSquared = Cartesian3_default.magnitudeSquared(
      Cartesian3_default.subtract(currentPos, ritterCenter, fromPointsScratch)
    );
    if (oldCenterToPointSquared > radiusSquared) {
      const oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);
      ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;
      radiusSquared = ritterRadius * ritterRadius;
      const oldToNew = oldCenterToPoint - ritterRadius;
      ritterCenter.x = (ritterRadius * ritterCenter.x + oldToNew * currentPos.x) / oldCenterToPoint;
      ritterCenter.y = (ritterRadius * ritterCenter.y + oldToNew * currentPos.y) / oldCenterToPoint;
      ritterCenter.z = (ritterRadius * ritterCenter.z + oldToNew * currentPos.z) / oldCenterToPoint;
    }
  }
  if (ritterRadius < naiveRadius) {
    Cartesian3_default.clone(ritterCenter, result.center);
    result.radius = ritterRadius;
  } else {
    Cartesian3_default.clone(naiveCenter, result.center);
    result.radius = naiveRadius;
  }
  return result;
};
var defaultProjection = new GeographicProjection_default();
var fromRectangle2DLowerLeft = new Cartesian3_default();
var fromRectangle2DUpperRight = new Cartesian3_default();
var fromRectangle2DSouthwest = new Cartographic_default();
var fromRectangle2DNortheast = new Cartographic_default();
BoundingSphere.fromRectangle2D = function(rectangle, projection, result) {
  return BoundingSphere.fromRectangleWithHeights2D(
    rectangle,
    projection,
    0,
    0,
    result
  );
};
BoundingSphere.fromRectangleWithHeights2D = function(rectangle, projection, minimumHeight, maximumHeight, result) {
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  if (!defined_default(rectangle)) {
    result.center = Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
    result.radius = 0;
    return result;
  }
  projection = defaultValue_default(projection, defaultProjection);
  Rectangle_default.southwest(rectangle, fromRectangle2DSouthwest);
  fromRectangle2DSouthwest.height = minimumHeight;
  Rectangle_default.northeast(rectangle, fromRectangle2DNortheast);
  fromRectangle2DNortheast.height = maximumHeight;
  const lowerLeft = projection.project(
    fromRectangle2DSouthwest,
    fromRectangle2DLowerLeft
  );
  const upperRight = projection.project(
    fromRectangle2DNortheast,
    fromRectangle2DUpperRight
  );
  const width = upperRight.x - lowerLeft.x;
  const height = upperRight.y - lowerLeft.y;
  const elevation = upperRight.z - lowerLeft.z;
  result.radius = Math.sqrt(width * width + height * height + elevation * elevation) * 0.5;
  const center = result.center;
  center.x = lowerLeft.x + width * 0.5;
  center.y = lowerLeft.y + height * 0.5;
  center.z = lowerLeft.z + elevation * 0.5;
  return result;
};
var fromRectangle3DScratch = [];
BoundingSphere.fromRectangle3D = function(rectangle, ellipsoid, surfaceHeight, result) {
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  surfaceHeight = defaultValue_default(surfaceHeight, 0);
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  if (!defined_default(rectangle)) {
    result.center = Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
    result.radius = 0;
    return result;
  }
  const positions = Rectangle_default.subsample(
    rectangle,
    ellipsoid,
    surfaceHeight,
    fromRectangle3DScratch
  );
  return BoundingSphere.fromPoints(positions, result);
};
BoundingSphere.fromVertices = function(positions, center, stride, result) {
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  if (!defined_default(positions) || positions.length === 0) {
    result.center = Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
    result.radius = 0;
    return result;
  }
  center = defaultValue_default(center, Cartesian3_default.ZERO);
  stride = defaultValue_default(stride, 3);
  Check_default.typeOf.number.greaterThanOrEquals("stride", stride, 3);
  const currentPos = fromPointsCurrentPos;
  currentPos.x = positions[0] + center.x;
  currentPos.y = positions[1] + center.y;
  currentPos.z = positions[2] + center.z;
  const xMin = Cartesian3_default.clone(currentPos, fromPointsXMin);
  const yMin = Cartesian3_default.clone(currentPos, fromPointsYMin);
  const zMin = Cartesian3_default.clone(currentPos, fromPointsZMin);
  const xMax = Cartesian3_default.clone(currentPos, fromPointsXMax);
  const yMax = Cartesian3_default.clone(currentPos, fromPointsYMax);
  const zMax = Cartesian3_default.clone(currentPos, fromPointsZMax);
  const numElements = positions.length;
  let i2;
  for (i2 = 0; i2 < numElements; i2 += stride) {
    const x = positions[i2] + center.x;
    const y = positions[i2 + 1] + center.y;
    const z = positions[i2 + 2] + center.z;
    currentPos.x = x;
    currentPos.y = y;
    currentPos.z = z;
    if (x < xMin.x) {
      Cartesian3_default.clone(currentPos, xMin);
    }
    if (x > xMax.x) {
      Cartesian3_default.clone(currentPos, xMax);
    }
    if (y < yMin.y) {
      Cartesian3_default.clone(currentPos, yMin);
    }
    if (y > yMax.y) {
      Cartesian3_default.clone(currentPos, yMax);
    }
    if (z < zMin.z) {
      Cartesian3_default.clone(currentPos, zMin);
    }
    if (z > zMax.z) {
      Cartesian3_default.clone(currentPos, zMax);
    }
  }
  const xSpan = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(xMax, xMin, fromPointsScratch)
  );
  const ySpan = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(yMax, yMin, fromPointsScratch)
  );
  const zSpan = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(zMax, zMin, fromPointsScratch)
  );
  let diameter1 = xMin;
  let diameter2 = xMax;
  let maxSpan = xSpan;
  if (ySpan > maxSpan) {
    maxSpan = ySpan;
    diameter1 = yMin;
    diameter2 = yMax;
  }
  if (zSpan > maxSpan) {
    maxSpan = zSpan;
    diameter1 = zMin;
    diameter2 = zMax;
  }
  const ritterCenter = fromPointsRitterCenter;
  ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;
  ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;
  ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;
  let radiusSquared = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(diameter2, ritterCenter, fromPointsScratch)
  );
  let ritterRadius = Math.sqrt(radiusSquared);
  const minBoxPt = fromPointsMinBoxPt;
  minBoxPt.x = xMin.x;
  minBoxPt.y = yMin.y;
  minBoxPt.z = zMin.z;
  const maxBoxPt = fromPointsMaxBoxPt;
  maxBoxPt.x = xMax.x;
  maxBoxPt.y = yMax.y;
  maxBoxPt.z = zMax.z;
  const naiveCenter = Cartesian3_default.midpoint(
    minBoxPt,
    maxBoxPt,
    fromPointsNaiveCenterScratch
  );
  let naiveRadius = 0;
  for (i2 = 0; i2 < numElements; i2 += stride) {
    currentPos.x = positions[i2] + center.x;
    currentPos.y = positions[i2 + 1] + center.y;
    currentPos.z = positions[i2 + 2] + center.z;
    const r2 = Cartesian3_default.magnitude(
      Cartesian3_default.subtract(currentPos, naiveCenter, fromPointsScratch)
    );
    if (r2 > naiveRadius) {
      naiveRadius = r2;
    }
    const oldCenterToPointSquared = Cartesian3_default.magnitudeSquared(
      Cartesian3_default.subtract(currentPos, ritterCenter, fromPointsScratch)
    );
    if (oldCenterToPointSquared > radiusSquared) {
      const oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);
      ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;
      radiusSquared = ritterRadius * ritterRadius;
      const oldToNew = oldCenterToPoint - ritterRadius;
      ritterCenter.x = (ritterRadius * ritterCenter.x + oldToNew * currentPos.x) / oldCenterToPoint;
      ritterCenter.y = (ritterRadius * ritterCenter.y + oldToNew * currentPos.y) / oldCenterToPoint;
      ritterCenter.z = (ritterRadius * ritterCenter.z + oldToNew * currentPos.z) / oldCenterToPoint;
    }
  }
  if (ritterRadius < naiveRadius) {
    Cartesian3_default.clone(ritterCenter, result.center);
    result.radius = ritterRadius;
  } else {
    Cartesian3_default.clone(naiveCenter, result.center);
    result.radius = naiveRadius;
  }
  return result;
};
BoundingSphere.fromEncodedCartesianVertices = function(positionsHigh, positionsLow, result) {
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  if (!defined_default(positionsHigh) || !defined_default(positionsLow) || positionsHigh.length !== positionsLow.length || positionsHigh.length === 0) {
    result.center = Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
    result.radius = 0;
    return result;
  }
  const currentPos = fromPointsCurrentPos;
  currentPos.x = positionsHigh[0] + positionsLow[0];
  currentPos.y = positionsHigh[1] + positionsLow[1];
  currentPos.z = positionsHigh[2] + positionsLow[2];
  const xMin = Cartesian3_default.clone(currentPos, fromPointsXMin);
  const yMin = Cartesian3_default.clone(currentPos, fromPointsYMin);
  const zMin = Cartesian3_default.clone(currentPos, fromPointsZMin);
  const xMax = Cartesian3_default.clone(currentPos, fromPointsXMax);
  const yMax = Cartesian3_default.clone(currentPos, fromPointsYMax);
  const zMax = Cartesian3_default.clone(currentPos, fromPointsZMax);
  const numElements = positionsHigh.length;
  let i2;
  for (i2 = 0; i2 < numElements; i2 += 3) {
    const x = positionsHigh[i2] + positionsLow[i2];
    const y = positionsHigh[i2 + 1] + positionsLow[i2 + 1];
    const z = positionsHigh[i2 + 2] + positionsLow[i2 + 2];
    currentPos.x = x;
    currentPos.y = y;
    currentPos.z = z;
    if (x < xMin.x) {
      Cartesian3_default.clone(currentPos, xMin);
    }
    if (x > xMax.x) {
      Cartesian3_default.clone(currentPos, xMax);
    }
    if (y < yMin.y) {
      Cartesian3_default.clone(currentPos, yMin);
    }
    if (y > yMax.y) {
      Cartesian3_default.clone(currentPos, yMax);
    }
    if (z < zMin.z) {
      Cartesian3_default.clone(currentPos, zMin);
    }
    if (z > zMax.z) {
      Cartesian3_default.clone(currentPos, zMax);
    }
  }
  const xSpan = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(xMax, xMin, fromPointsScratch)
  );
  const ySpan = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(yMax, yMin, fromPointsScratch)
  );
  const zSpan = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(zMax, zMin, fromPointsScratch)
  );
  let diameter1 = xMin;
  let diameter2 = xMax;
  let maxSpan = xSpan;
  if (ySpan > maxSpan) {
    maxSpan = ySpan;
    diameter1 = yMin;
    diameter2 = yMax;
  }
  if (zSpan > maxSpan) {
    maxSpan = zSpan;
    diameter1 = zMin;
    diameter2 = zMax;
  }
  const ritterCenter = fromPointsRitterCenter;
  ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;
  ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;
  ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;
  let radiusSquared = Cartesian3_default.magnitudeSquared(
    Cartesian3_default.subtract(diameter2, ritterCenter, fromPointsScratch)
  );
  let ritterRadius = Math.sqrt(radiusSquared);
  const minBoxPt = fromPointsMinBoxPt;
  minBoxPt.x = xMin.x;
  minBoxPt.y = yMin.y;
  minBoxPt.z = zMin.z;
  const maxBoxPt = fromPointsMaxBoxPt;
  maxBoxPt.x = xMax.x;
  maxBoxPt.y = yMax.y;
  maxBoxPt.z = zMax.z;
  const naiveCenter = Cartesian3_default.midpoint(
    minBoxPt,
    maxBoxPt,
    fromPointsNaiveCenterScratch
  );
  let naiveRadius = 0;
  for (i2 = 0; i2 < numElements; i2 += 3) {
    currentPos.x = positionsHigh[i2] + positionsLow[i2];
    currentPos.y = positionsHigh[i2 + 1] + positionsLow[i2 + 1];
    currentPos.z = positionsHigh[i2 + 2] + positionsLow[i2 + 2];
    const r2 = Cartesian3_default.magnitude(
      Cartesian3_default.subtract(currentPos, naiveCenter, fromPointsScratch)
    );
    if (r2 > naiveRadius) {
      naiveRadius = r2;
    }
    const oldCenterToPointSquared = Cartesian3_default.magnitudeSquared(
      Cartesian3_default.subtract(currentPos, ritterCenter, fromPointsScratch)
    );
    if (oldCenterToPointSquared > radiusSquared) {
      const oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);
      ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;
      radiusSquared = ritterRadius * ritterRadius;
      const oldToNew = oldCenterToPoint - ritterRadius;
      ritterCenter.x = (ritterRadius * ritterCenter.x + oldToNew * currentPos.x) / oldCenterToPoint;
      ritterCenter.y = (ritterRadius * ritterCenter.y + oldToNew * currentPos.y) / oldCenterToPoint;
      ritterCenter.z = (ritterRadius * ritterCenter.z + oldToNew * currentPos.z) / oldCenterToPoint;
    }
  }
  if (ritterRadius < naiveRadius) {
    Cartesian3_default.clone(ritterCenter, result.center);
    result.radius = ritterRadius;
  } else {
    Cartesian3_default.clone(naiveCenter, result.center);
    result.radius = naiveRadius;
  }
  return result;
};
BoundingSphere.fromCornerPoints = function(corner, oppositeCorner, result) {
  Check_default.typeOf.object("corner", corner);
  Check_default.typeOf.object("oppositeCorner", oppositeCorner);
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  const center = Cartesian3_default.midpoint(corner, oppositeCorner, result.center);
  result.radius = Cartesian3_default.distance(center, oppositeCorner);
  return result;
};
BoundingSphere.fromEllipsoid = function(ellipsoid, result) {
  Check_default.typeOf.object("ellipsoid", ellipsoid);
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
  result.radius = ellipsoid.maximumRadius;
  return result;
};
var fromBoundingSpheresScratch = new Cartesian3_default();
BoundingSphere.fromBoundingSpheres = function(boundingSpheres, result) {
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  if (!defined_default(boundingSpheres) || boundingSpheres.length === 0) {
    result.center = Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
    result.radius = 0;
    return result;
  }
  const length3 = boundingSpheres.length;
  if (length3 === 1) {
    return BoundingSphere.clone(boundingSpheres[0], result);
  }
  if (length3 === 2) {
    return BoundingSphere.union(boundingSpheres[0], boundingSpheres[1], result);
  }
  const positions = [];
  let i2;
  for (i2 = 0; i2 < length3; i2++) {
    positions.push(boundingSpheres[i2].center);
  }
  result = BoundingSphere.fromPoints(positions, result);
  const center = result.center;
  let radius = result.radius;
  for (i2 = 0; i2 < length3; i2++) {
    const tmp2 = boundingSpheres[i2];
    radius = Math.max(
      radius,
      Cartesian3_default.distance(center, tmp2.center, fromBoundingSpheresScratch) + tmp2.radius
    );
  }
  result.radius = radius;
  return result;
};
var fromOrientedBoundingBoxScratchU = new Cartesian3_default();
var fromOrientedBoundingBoxScratchV = new Cartesian3_default();
var fromOrientedBoundingBoxScratchW = new Cartesian3_default();
BoundingSphere.fromOrientedBoundingBox = function(orientedBoundingBox, result) {
  Check_default.defined("orientedBoundingBox", orientedBoundingBox);
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  const halfAxes = orientedBoundingBox.halfAxes;
  const u3 = Matrix3_default.getColumn(halfAxes, 0, fromOrientedBoundingBoxScratchU);
  const v7 = Matrix3_default.getColumn(halfAxes, 1, fromOrientedBoundingBoxScratchV);
  const w = Matrix3_default.getColumn(halfAxes, 2, fromOrientedBoundingBoxScratchW);
  Cartesian3_default.add(u3, v7, u3);
  Cartesian3_default.add(u3, w, u3);
  result.center = Cartesian3_default.clone(orientedBoundingBox.center, result.center);
  result.radius = Cartesian3_default.magnitude(u3);
  return result;
};
var scratchFromTransformationCenter = new Cartesian3_default();
var scratchFromTransformationScale = new Cartesian3_default();
BoundingSphere.fromTransformation = function(transformation, result) {
  Check_default.typeOf.object("transformation", transformation);
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  const center = Matrix4_default.getTranslation(
    transformation,
    scratchFromTransformationCenter
  );
  const scale = Matrix4_default.getScale(
    transformation,
    scratchFromTransformationScale
  );
  const radius = 0.5 * Cartesian3_default.magnitude(scale);
  result.center = Cartesian3_default.clone(center, result.center);
  result.radius = radius;
  return result;
};
BoundingSphere.clone = function(sphere, result) {
  if (!defined_default(sphere)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new BoundingSphere(sphere.center, sphere.radius);
  }
  result.center = Cartesian3_default.clone(sphere.center, result.center);
  result.radius = sphere.radius;
  return result;
};
BoundingSphere.packedLength = 4;
BoundingSphere.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const center = value.center;
  array[startingIndex++] = center.x;
  array[startingIndex++] = center.y;
  array[startingIndex++] = center.z;
  array[startingIndex] = value.radius;
  return array;
};
BoundingSphere.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  const center = result.center;
  center.x = array[startingIndex++];
  center.y = array[startingIndex++];
  center.z = array[startingIndex++];
  result.radius = array[startingIndex];
  return result;
};
var unionScratch = new Cartesian3_default();
var unionScratchCenter = new Cartesian3_default();
BoundingSphere.union = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  const leftCenter = left.center;
  const leftRadius = left.radius;
  const rightCenter = right.center;
  const rightRadius = right.radius;
  const toRightCenter = Cartesian3_default.subtract(
    rightCenter,
    leftCenter,
    unionScratch
  );
  const centerSeparation = Cartesian3_default.magnitude(toRightCenter);
  if (leftRadius >= centerSeparation + rightRadius) {
    left.clone(result);
    return result;
  }
  if (rightRadius >= centerSeparation + leftRadius) {
    right.clone(result);
    return result;
  }
  const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5;
  const center = Cartesian3_default.multiplyByScalar(
    toRightCenter,
    (-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation,
    unionScratchCenter
  );
  Cartesian3_default.add(center, leftCenter, center);
  Cartesian3_default.clone(center, result.center);
  result.radius = halfDistanceBetweenTangentPoints;
  return result;
};
var expandScratch = new Cartesian3_default();
BoundingSphere.expand = function(sphere, point, result) {
  Check_default.typeOf.object("sphere", sphere);
  Check_default.typeOf.object("point", point);
  result = BoundingSphere.clone(sphere, result);
  const radius = Cartesian3_default.magnitude(
    Cartesian3_default.subtract(point, result.center, expandScratch)
  );
  if (radius > result.radius) {
    result.radius = radius;
  }
  return result;
};
BoundingSphere.intersectPlane = function(sphere, plane) {
  Check_default.typeOf.object("sphere", sphere);
  Check_default.typeOf.object("plane", plane);
  const center = sphere.center;
  const radius = sphere.radius;
  const normal2 = plane.normal;
  const distanceToPlane = Cartesian3_default.dot(normal2, center) + plane.distance;
  if (distanceToPlane < -radius) {
    return Intersect_default.OUTSIDE;
  } else if (distanceToPlane < radius) {
    return Intersect_default.INTERSECTING;
  }
  return Intersect_default.INSIDE;
};
BoundingSphere.transform = function(sphere, transform4, result) {
  Check_default.typeOf.object("sphere", sphere);
  Check_default.typeOf.object("transform", transform4);
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  result.center = Matrix4_default.multiplyByPoint(
    transform4,
    sphere.center,
    result.center
  );
  result.radius = Matrix4_default.getMaximumScale(transform4) * sphere.radius;
  return result;
};
var distanceSquaredToScratch = new Cartesian3_default();
BoundingSphere.distanceSquaredTo = function(sphere, cartesian11) {
  Check_default.typeOf.object("sphere", sphere);
  Check_default.typeOf.object("cartesian", cartesian11);
  const diff = Cartesian3_default.subtract(
    sphere.center,
    cartesian11,
    distanceSquaredToScratch
  );
  const distance2 = Cartesian3_default.magnitude(diff) - sphere.radius;
  if (distance2 <= 0) {
    return 0;
  }
  return distance2 * distance2;
};
BoundingSphere.transformWithoutScale = function(sphere, transform4, result) {
  Check_default.typeOf.object("sphere", sphere);
  Check_default.typeOf.object("transform", transform4);
  if (!defined_default(result)) {
    result = new BoundingSphere();
  }
  result.center = Matrix4_default.multiplyByPoint(
    transform4,
    sphere.center,
    result.center
  );
  result.radius = sphere.radius;
  return result;
};
var scratchCartesian3 = new Cartesian3_default();
BoundingSphere.computePlaneDistances = function(sphere, position, direction2, result) {
  Check_default.typeOf.object("sphere", sphere);
  Check_default.typeOf.object("position", position);
  Check_default.typeOf.object("direction", direction2);
  if (!defined_default(result)) {
    result = new Interval_default();
  }
  const toCenter = Cartesian3_default.subtract(
    sphere.center,
    position,
    scratchCartesian3
  );
  const mag = Cartesian3_default.dot(direction2, toCenter);
  result.start = mag - sphere.radius;
  result.stop = mag + sphere.radius;
  return result;
};
var projectTo2DNormalScratch = new Cartesian3_default();
var projectTo2DEastScratch = new Cartesian3_default();
var projectTo2DNorthScratch = new Cartesian3_default();
var projectTo2DWestScratch = new Cartesian3_default();
var projectTo2DSouthScratch = new Cartesian3_default();
var projectTo2DCartographicScratch = new Cartographic_default();
var projectTo2DPositionsScratch = new Array(8);
for (let n2 = 0; n2 < 8; ++n2) {
  projectTo2DPositionsScratch[n2] = new Cartesian3_default();
}
var projectTo2DProjection = new GeographicProjection_default();
BoundingSphere.projectTo2D = function(sphere, projection, result) {
  Check_default.typeOf.object("sphere", sphere);
  projection = defaultValue_default(projection, projectTo2DProjection);
  const ellipsoid = projection.ellipsoid;
  let center = sphere.center;
  const radius = sphere.radius;
  let normal2;
  if (Cartesian3_default.equals(center, Cartesian3_default.ZERO)) {
    normal2 = Cartesian3_default.clone(Cartesian3_default.UNIT_X, projectTo2DNormalScratch);
  } else {
    normal2 = ellipsoid.geodeticSurfaceNormal(center, projectTo2DNormalScratch);
  }
  const east = Cartesian3_default.cross(
    Cartesian3_default.UNIT_Z,
    normal2,
    projectTo2DEastScratch
  );
  Cartesian3_default.normalize(east, east);
  const north = Cartesian3_default.cross(normal2, east, projectTo2DNorthScratch);
  Cartesian3_default.normalize(north, north);
  Cartesian3_default.multiplyByScalar(normal2, radius, normal2);
  Cartesian3_default.multiplyByScalar(north, radius, north);
  Cartesian3_default.multiplyByScalar(east, radius, east);
  const south = Cartesian3_default.negate(north, projectTo2DSouthScratch);
  const west = Cartesian3_default.negate(east, projectTo2DWestScratch);
  const positions = projectTo2DPositionsScratch;
  let corner = positions[0];
  Cartesian3_default.add(normal2, north, corner);
  Cartesian3_default.add(corner, east, corner);
  corner = positions[1];
  Cartesian3_default.add(normal2, north, corner);
  Cartesian3_default.add(corner, west, corner);
  corner = positions[2];
  Cartesian3_default.add(normal2, south, corner);
  Cartesian3_default.add(corner, west, corner);
  corner = positions[3];
  Cartesian3_default.add(normal2, south, corner);
  Cartesian3_default.add(corner, east, corner);
  Cartesian3_default.negate(normal2, normal2);
  corner = positions[4];
  Cartesian3_default.add(normal2, north, corner);
  Cartesian3_default.add(corner, east, corner);
  corner = positions[5];
  Cartesian3_default.add(normal2, north, corner);
  Cartesian3_default.add(corner, west, corner);
  corner = positions[6];
  Cartesian3_default.add(normal2, south, corner);
  Cartesian3_default.add(corner, west, corner);
  corner = positions[7];
  Cartesian3_default.add(normal2, south, corner);
  Cartesian3_default.add(corner, east, corner);
  const length3 = positions.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const position = positions[i2];
    Cartesian3_default.add(center, position, position);
    const cartographic2 = ellipsoid.cartesianToCartographic(
      position,
      projectTo2DCartographicScratch
    );
    projection.project(cartographic2, position);
  }
  result = BoundingSphere.fromPoints(positions, result);
  center = result.center;
  const x = center.x;
  const y = center.y;
  const z = center.z;
  center.x = z;
  center.y = x;
  center.z = y;
  return result;
};
BoundingSphere.isOccluded = function(sphere, occluder) {
  Check_default.typeOf.object("sphere", sphere);
  Check_default.typeOf.object("occluder", occluder);
  return !occluder.isBoundingSphereVisible(sphere);
};
BoundingSphere.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && Cartesian3_default.equals(left.center, right.center) && left.radius === right.radius;
};
BoundingSphere.prototype.intersectPlane = function(plane) {
  return BoundingSphere.intersectPlane(this, plane);
};
BoundingSphere.prototype.distanceSquaredTo = function(cartesian11) {
  return BoundingSphere.distanceSquaredTo(this, cartesian11);
};
BoundingSphere.prototype.computePlaneDistances = function(position, direction2, result) {
  return BoundingSphere.computePlaneDistances(
    this,
    position,
    direction2,
    result
  );
};
BoundingSphere.prototype.isOccluded = function(occluder) {
  return BoundingSphere.isOccluded(this, occluder);
};
BoundingSphere.prototype.equals = function(right) {
  return BoundingSphere.equals(this, right);
};
BoundingSphere.prototype.clone = function(result) {
  return BoundingSphere.clone(this, result);
};
BoundingSphere.prototype.volume = function() {
  const radius = this.radius;
  return volumeConstant * radius * radius * radius;
};
var BoundingSphere_default = BoundingSphere;

// node_modules/cesium/Source/ThirdParty/_commonjsHelpers-3aae1032.js
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function createCommonjsModule(fn, basedir, module2) {
  return module2 = {
    path: basedir,
    exports: {},
    require: function(path, base) {
      return commonjsRequire(path, base === void 0 || base === null ? module2.path : base);
    }
  }, fn(module2, module2.exports), module2.exports;
}
function commonjsRequire() {
  throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs");
}

// node_modules/cesium/Source/ThirdParty/Uri.js
var punycode = createCommonjsModule(function(module2, exports2) {
  (function(root) {
    var freeExports = exports2 && !exports2.nodeType && exports2;
    var freeModule = module2 && !module2.nodeType && module2;
    var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal;
    if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
      root = freeGlobal;
    }
    var punycode2, maxInt = 2147483647, base = 36, tMin = 1, tMax = 26, skew = 38, damp = 700, initialBias = 72, initialN = 128, delimiter = "-", regexPunycode = /^xn--/, regexNonASCII = /[^\x20-\x7E]/, regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, errors = {
      "overflow": "Overflow: input needs wider integers to process",
      "not-basic": "Illegal input >= 0x80 (not a basic code point)",
      "invalid-input": "Invalid input"
    }, baseMinusTMin = base - tMin, floor = Math.floor, stringFromCharCode = String.fromCharCode, key;
    function error(type) {
      throw new RangeError(errors[type]);
    }
    function map(array, fn) {
      var length3 = array.length;
      var result = [];
      while (length3--) {
        result[length3] = fn(array[length3]);
      }
      return result;
    }
    function mapDomain(string, fn) {
      var parts = string.split("@");
      var result = "";
      if (parts.length > 1) {
        result = parts[0] + "@";
        string = parts[1];
      }
      string = string.replace(regexSeparators, ".");
      var labels = string.split(".");
      var encoded = map(labels, fn).join(".");
      return result + encoded;
    }
    function ucs2decode(string) {
      var output = [], counter = 0, length3 = string.length, value, extra;
      while (counter < length3) {
        value = string.charCodeAt(counter++);
        if (value >= 55296 && value <= 56319 && counter < length3) {
          extra = string.charCodeAt(counter++);
          if ((extra & 64512) == 56320) {
            output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
          } else {
            output.push(value);
            counter--;
          }
        } else {
          output.push(value);
        }
      }
      return output;
    }
    function ucs2encode(array) {
      return map(array, function(value) {
        var output = "";
        if (value > 65535) {
          value -= 65536;
          output += stringFromCharCode(value >>> 10 & 1023 | 55296);
          value = 56320 | value & 1023;
        }
        output += stringFromCharCode(value);
        return output;
      }).join("");
    }
    function basicToDigit(codePoint) {
      if (codePoint - 48 < 10) {
        return codePoint - 22;
      }
      if (codePoint - 65 < 26) {
        return codePoint - 65;
      }
      if (codePoint - 97 < 26) {
        return codePoint - 97;
      }
      return base;
    }
    function digitToBasic(digit, flag) {
      return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
    }
    function adapt(delta, numPoints, firstTime) {
      var k = 0;
      delta = firstTime ? floor(delta / damp) : delta >> 1;
      delta += floor(delta / numPoints);
      for (; delta > baseMinusTMin * tMax >> 1; k += base) {
        delta = floor(delta / baseMinusTMin);
      }
      return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
    }
    function decode(input) {
      var output = [], inputLength = input.length, out, i2 = 0, n2 = initialN, bias = initialBias, basic, j, index2, oldi, w, k, digit, t, baseMinusT;
      basic = input.lastIndexOf(delimiter);
      if (basic < 0) {
        basic = 0;
      }
      for (j = 0; j < basic; ++j) {
        if (input.charCodeAt(j) >= 128) {
          error("not-basic");
        }
        output.push(input.charCodeAt(j));
      }
      for (index2 = basic > 0 ? basic + 1 : 0; index2 < inputLength; ) {
        for (oldi = i2, w = 1, k = base; ; k += base) {
          if (index2 >= inputLength) {
            error("invalid-input");
          }
          digit = basicToDigit(input.charCodeAt(index2++));
          if (digit >= base || digit > floor((maxInt - i2) / w)) {
            error("overflow");
          }
          i2 += digit * w;
          t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
          if (digit < t) {
            break;
          }
          baseMinusT = base - t;
          if (w > floor(maxInt / baseMinusT)) {
            error("overflow");
          }
          w *= baseMinusT;
        }
        out = output.length + 1;
        bias = adapt(i2 - oldi, out, oldi == 0);
        if (floor(i2 / out) > maxInt - n2) {
          error("overflow");
        }
        n2 += floor(i2 / out);
        i2 %= out;
        output.splice(i2++, 0, n2);
      }
      return ucs2encode(output);
    }
    function encode(input) {
      var n2, delta, handledCPCount, basicLength, bias, j, m, q, k, t, currentValue, output = [], inputLength, handledCPCountPlusOne, baseMinusT, qMinusT;
      input = ucs2decode(input);
      inputLength = input.length;
      n2 = initialN;
      delta = 0;
      bias = initialBias;
      for (j = 0; j < inputLength; ++j) {
        currentValue = input[j];
        if (currentValue < 128) {
          output.push(stringFromCharCode(currentValue));
        }
      }
      handledCPCount = basicLength = output.length;
      if (basicLength) {
        output.push(delimiter);
      }
      while (handledCPCount < inputLength) {
        for (m = maxInt, j = 0; j < inputLength; ++j) {
          currentValue = input[j];
          if (currentValue >= n2 && currentValue < m) {
            m = currentValue;
          }
        }
        handledCPCountPlusOne = handledCPCount + 1;
        if (m - n2 > floor((maxInt - delta) / handledCPCountPlusOne)) {
          error("overflow");
        }
        delta += (m - n2) * handledCPCountPlusOne;
        n2 = m;
        for (j = 0; j < inputLength; ++j) {
          currentValue = input[j];
          if (currentValue < n2 && ++delta > maxInt) {
            error("overflow");
          }
          if (currentValue == n2) {
            for (q = delta, k = base; ; k += base) {
              t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
              if (q < t) {
                break;
              }
              qMinusT = q - t;
              baseMinusT = base - t;
              output.push(
                stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
              );
              q = floor(qMinusT / baseMinusT);
            }
            output.push(stringFromCharCode(digitToBasic(q, 0)));
            bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
            delta = 0;
            ++handledCPCount;
          }
        }
        ++delta;
        ++n2;
      }
      return output.join("");
    }
    function toUnicode(input) {
      return mapDomain(input, function(string) {
        return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
      });
    }
    function toASCII(input) {
      return mapDomain(input, function(string) {
        return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
      });
    }
    punycode2 = {
      "version": "1.3.2",
      "ucs2": {
        "decode": ucs2decode,
        "encode": ucs2encode
      },
      "decode": decode,
      "encode": encode,
      "toASCII": toASCII,
      "toUnicode": toUnicode
    };
    if (freeExports && freeModule) {
      if (module2.exports == freeExports) {
        freeModule.exports = punycode2;
      } else {
        for (key in punycode2) {
          punycode2.hasOwnProperty(key) && (freeExports[key] = punycode2[key]);
        }
      }
    } else {
      root.punycode = punycode2;
    }
  })(commonjsGlobal);
});
var IPv6 = createCommonjsModule(function(module2) {
  (function(root, factory) {
    if (module2.exports) {
      module2.exports = factory();
    } else {
      root.IPv6 = factory(root);
    }
  })(commonjsGlobal, function(root) {
    var _IPv6 = root && root.IPv6;
    function bestPresentation(address) {
      var _address = address.toLowerCase();
      var segments = _address.split(":");
      var length3 = segments.length;
      var total = 8;
      if (segments[0] === "" && segments[1] === "" && segments[2] === "") {
        segments.shift();
        segments.shift();
      } else if (segments[0] === "" && segments[1] === "") {
        segments.shift();
      } else if (segments[length3 - 1] === "" && segments[length3 - 2] === "") {
        segments.pop();
      }
      length3 = segments.length;
      if (segments[length3 - 1].indexOf(".") !== -1) {
        total = 7;
      }
      var pos;
      for (pos = 0; pos < length3; pos++) {
        if (segments[pos] === "") {
          break;
        }
      }
      if (pos < total) {
        segments.splice(pos, 1, "0000");
        while (segments.length < total) {
          segments.splice(pos, 0, "0000");
        }
      }
      var _segments;
      for (var i2 = 0; i2 < total; i2++) {
        _segments = segments[i2].split("");
        for (var j = 0; j < 3; j++) {
          if (_segments[0] === "0" && _segments.length > 1) {
            _segments.splice(0, 1);
          } else {
            break;
          }
        }
        segments[i2] = _segments.join("");
      }
      var best = -1;
      var _best = 0;
      var _current = 0;
      var current = -1;
      var inzeroes = false;
      for (i2 = 0; i2 < total; i2++) {
        if (inzeroes) {
          if (segments[i2] === "0") {
            _current += 1;
          } else {
            inzeroes = false;
            if (_current > _best) {
              best = current;
              _best = _current;
            }
          }
        } else {
          if (segments[i2] === "0") {
            inzeroes = true;
            current = i2;
            _current = 1;
          }
        }
      }
      if (_current > _best) {
        best = current;
        _best = _current;
      }
      if (_best > 1) {
        segments.splice(best, _best, "");
      }
      length3 = segments.length;
      var result = "";
      if (segments[0] === "") {
        result = ":";
      }
      for (i2 = 0; i2 < length3; i2++) {
        result += segments[i2];
        if (i2 === length3 - 1) {
          break;
        }
        result += ":";
      }
      if (segments[length3 - 1] === "") {
        result += ":";
      }
      return result;
    }
    function noConflict() {
      if (root.IPv6 === this) {
        root.IPv6 = _IPv6;
      }
      return this;
    }
    return {
      best: bestPresentation,
      noConflict
    };
  });
});
var SecondLevelDomains = createCommonjsModule(function(module2) {
  (function(root, factory) {
    if (module2.exports) {
      module2.exports = factory();
    } else {
      root.SecondLevelDomains = factory(root);
    }
  })(commonjsGlobal, function(root) {
    var _SecondLevelDomains = root && root.SecondLevelDomains;
    var SLD = {
      list: {
        "ac": " com gov mil net org ",
        "ae": " ac co gov mil name net org pro sch ",
        "af": " com edu gov net org ",
        "al": " com edu gov mil net org ",
        "ao": " co ed gv it og pb ",
        "ar": " com edu gob gov int mil net org tur ",
        "at": " ac co gv or ",
        "au": " asn com csiro edu gov id net org ",
        "ba": " co com edu gov mil net org rs unbi unmo unsa untz unze ",
        "bb": " biz co com edu gov info net org store tv ",
        "bh": " biz cc com edu gov info net org ",
        "bn": " com edu gov net org ",
        "bo": " com edu gob gov int mil net org tv ",
        "br": " adm adv agr am arq art ato b bio blog bmd cim cng cnt com coop ecn edu eng esp etc eti far flog fm fnd fot fst g12 ggf gov imb ind inf jor jus lel mat med mil mus net nom not ntr odo org ppg pro psc psi qsl rec slg srv tmp trd tur tv vet vlog wiki zlg ",
        "bs": " com edu gov net org ",
        "bz": " du et om ov rg ",
        "ca": " ab bc mb nb nf nl ns nt nu on pe qc sk yk ",
        "ck": " biz co edu gen gov info net org ",
        "cn": " ac ah bj com cq edu fj gd gov gs gx gz ha hb he hi hl hn jl js jx ln mil net nm nx org qh sc sd sh sn sx tj tw xj xz yn zj ",
        "co": " com edu gov mil net nom org ",
        "cr": " ac c co ed fi go or sa ",
        "cy": " ac biz com ekloges gov ltd name net org parliament press pro tm ",
        "do": " art com edu gob gov mil net org sld web ",
        "dz": " art asso com edu gov net org pol ",
        "ec": " com edu fin gov info med mil net org pro ",
        "eg": " com edu eun gov mil name net org sci ",
        "er": " com edu gov ind mil net org rochest w ",
        "es": " com edu gob nom org ",
        "et": " biz com edu gov info name net org ",
        "fj": " ac biz com info mil name net org pro ",
        "fk": " ac co gov net nom org ",
        "fr": " asso com f gouv nom prd presse tm ",
        "gg": " co net org ",
        "gh": " com edu gov mil org ",
        "gn": " ac com gov net org ",
        "gr": " com edu gov mil net org ",
        "gt": " com edu gob ind mil net org ",
        "gu": " com edu gov net org ",
        "hk": " com edu gov idv net org ",
        "hu": " 2000 agrar bolt casino city co erotica erotika film forum games hotel info ingatlan jogasz konyvelo lakas media news org priv reklam sex shop sport suli szex tm tozsde utazas video ",
        "id": " ac co go mil net or sch web ",
        "il": " ac co gov idf k12 muni net org ",
        "in": " ac co edu ernet firm gen gov i ind mil net nic org res ",
        "iq": " com edu gov i mil net org ",
        "ir": " ac co dnssec gov i id net org sch ",
        "it": " edu gov ",
        "je": " co net org ",
        "jo": " com edu gov mil name net org sch ",
        "jp": " ac ad co ed go gr lg ne or ",
        "ke": " ac co go info me mobi ne or sc ",
        "kh": " com edu gov mil net org per ",
        "ki": " biz com de edu gov info mob net org tel ",
        "km": " asso com coop edu gouv k medecin mil nom notaires pharmaciens presse tm veterinaire ",
        "kn": " edu gov net org ",
        "kr": " ac busan chungbuk chungnam co daegu daejeon es gangwon go gwangju gyeongbuk gyeonggi gyeongnam hs incheon jeju jeonbuk jeonnam k kg mil ms ne or pe re sc seoul ulsan ",
        "kw": " com edu gov net org ",
        "ky": " com edu gov net org ",
        "kz": " com edu gov mil net org ",
        "lb": " com edu gov net org ",
        "lk": " assn com edu gov grp hotel int ltd net ngo org sch soc web ",
        "lr": " com edu gov net org ",
        "lv": " asn com conf edu gov id mil net org ",
        "ly": " com edu gov id med net org plc sch ",
        "ma": " ac co gov m net org press ",
        "mc": " asso tm ",
        "me": " ac co edu gov its net org priv ",
        "mg": " com edu gov mil nom org prd tm ",
        "mk": " com edu gov inf name net org pro ",
        "ml": " com edu gov net org presse ",
        "mn": " edu gov org ",
        "mo": " com edu gov net org ",
        "mt": " com edu gov net org ",
        "mv": " aero biz com coop edu gov info int mil museum name net org pro ",
        "mw": " ac co com coop edu gov int museum net org ",
        "mx": " com edu gob net org ",
        "my": " com edu gov mil name net org sch ",
        "nf": " arts com firm info net other per rec store web ",
        "ng": " biz com edu gov mil mobi name net org sch ",
        "ni": " ac co com edu gob mil net nom org ",
        "np": " com edu gov mil net org ",
        "nr": " biz com edu gov info net org ",
        "om": " ac biz co com edu gov med mil museum net org pro sch ",
        "pe": " com edu gob mil net nom org sld ",
        "ph": " com edu gov i mil net ngo org ",
        "pk": " biz com edu fam gob gok gon gop gos gov net org web ",
        "pl": " art bialystok biz com edu gda gdansk gorzow gov info katowice krakow lodz lublin mil net ngo olsztyn org poznan pwr radom slupsk szczecin torun warszawa waw wroc wroclaw zgora ",
        "pr": " ac biz com edu est gov info isla name net org pro prof ",
        "ps": " com edu gov net org plo sec ",
        "pw": " belau co ed go ne or ",
        "ro": " arts com firm info nom nt org rec store tm www ",
        "rs": " ac co edu gov in org ",
        "sb": " com edu gov net org ",
        "sc": " com edu gov net org ",
        "sh": " co com edu gov net nom org ",
        "sl": " com edu gov net org ",
        "st": " co com consulado edu embaixada gov mil net org principe saotome store ",
        "sv": " com edu gob org red ",
        "sz": " ac co org ",
        "tr": " av bbs bel biz com dr edu gen gov info k12 name net org pol tel tsk tv web ",
        "tt": " aero biz cat co com coop edu gov info int jobs mil mobi museum name net org pro tel travel ",
        "tw": " club com ebiz edu game gov idv mil net org ",
        "mu": " ac co com gov net or org ",
        "mz": " ac co edu gov org ",
        "na": " co com ",
        "nz": " ac co cri geek gen govt health iwi maori mil net org parliament school ",
        "pa": " abo ac com edu gob ing med net nom org sld ",
        "pt": " com edu gov int net nome org publ ",
        "py": " com edu gov mil net org ",
        "qa": " com edu gov mil net org ",
        "re": " asso com nom ",
        "ru": " ac adygeya altai amur arkhangelsk astrakhan bashkiria belgorod bir bryansk buryatia cbg chel chelyabinsk chita chukotka chuvashia com dagestan e-burg edu gov grozny int irkutsk ivanovo izhevsk jar joshkar-ola kalmykia kaluga kamchatka karelia kazan kchr kemerovo khabarovsk khakassia khv kirov koenig komi kostroma kranoyarsk kuban kurgan kursk lipetsk magadan mari mari-el marine mil mordovia mosreg msk murmansk nalchik net nnov nov novosibirsk nsk omsk orenburg org oryol penza perm pp pskov ptz rnd ryazan sakhalin samara saratov simbirsk smolensk spb stavropol stv surgut tambov tatarstan tom tomsk tsaritsyn tsk tula tuva tver tyumen udm udmurtia ulan-ude vladikavkaz vladimir vladivostok volgograd vologda voronezh vrn vyatka yakutia yamal yekaterinburg yuzhno-sakhalinsk ",
        "rw": " ac co com edu gouv gov int mil net ",
        "sa": " com edu gov med net org pub sch ",
        "sd": " com edu gov info med net org tv ",
        "se": " a ac b bd c d e f g h i k l m n o org p parti pp press r s t tm u w x y z ",
        "sg": " com edu gov idn net org per ",
        "sn": " art com edu gouv org perso univ ",
        "sy": " com edu gov mil net news org ",
        "th": " ac co go in mi net or ",
        "tj": " ac biz co com edu go gov info int mil name net nic org test web ",
        "tn": " agrinet com defense edunet ens fin gov ind info intl mincom nat net org perso rnrt rns rnu tourism ",
        "tz": " ac co go ne or ",
        "ua": " biz cherkassy chernigov chernovtsy ck cn co com crimea cv dn dnepropetrovsk donetsk dp edu gov if in ivano-frankivsk kh kharkov kherson khmelnitskiy kiev kirovograd km kr ks kv lg lugansk lutsk lviv me mk net nikolaev od odessa org pl poltava pp rovno rv sebastopol sumy te ternopil uzhgorod vinnica vn zaporizhzhe zhitomir zp zt ",
        "ug": " ac co go ne or org sc ",
        "uk": " ac bl british-library co cym gov govt icnet jet lea ltd me mil mod national-library-scotland nel net nhs nic nls org orgn parliament plc police sch scot soc ",
        "us": " dni fed isa kids nsn ",
        "uy": " com edu gub mil net org ",
        "ve": " co com edu gob info mil net org web ",
        "vi": " co com k12 net org ",
        "vn": " ac biz com edu gov health info int name net org pro ",
        "ye": " co com gov ltd me net org plc ",
        "yu": " ac co edu gov org ",
        "za": " ac agric alt bourse city co cybernet db edu gov grondar iaccess imt inca landesign law mil net ngo nis nom olivetti org pix school tm web ",
        "zm": " ac co com edu gov net org sch ",
        "com": "ar br cn de eu gb gr hu jpn kr no qc ru sa se uk us uy za ",
        "net": "gb jp se uk ",
        "org": "ae",
        "de": "com "
      },
      has: function(domain) {
        var tldOffset = domain.lastIndexOf(".");
        if (tldOffset <= 0 || tldOffset >= domain.length - 1) {
          return false;
        }
        var sldOffset = domain.lastIndexOf(".", tldOffset - 1);
        if (sldOffset <= 0 || sldOffset >= tldOffset - 1) {
          return false;
        }
        var sldList = SLD.list[domain.slice(tldOffset + 1)];
        if (!sldList) {
          return false;
        }
        return sldList.indexOf(" " + domain.slice(sldOffset + 1, tldOffset) + " ") >= 0;
      },
      is: function(domain) {
        var tldOffset = domain.lastIndexOf(".");
        if (tldOffset <= 0 || tldOffset >= domain.length - 1) {
          return false;
        }
        var sldOffset = domain.lastIndexOf(".", tldOffset - 1);
        if (sldOffset >= 0) {
          return false;
        }
        var sldList = SLD.list[domain.slice(tldOffset + 1)];
        if (!sldList) {
          return false;
        }
        return sldList.indexOf(" " + domain.slice(0, tldOffset) + " ") >= 0;
      },
      get: function(domain) {
        var tldOffset = domain.lastIndexOf(".");
        if (tldOffset <= 0 || tldOffset >= domain.length - 1) {
          return null;
        }
        var sldOffset = domain.lastIndexOf(".", tldOffset - 1);
        if (sldOffset <= 0 || sldOffset >= tldOffset - 1) {
          return null;
        }
        var sldList = SLD.list[domain.slice(tldOffset + 1)];
        if (!sldList) {
          return null;
        }
        if (sldList.indexOf(" " + domain.slice(sldOffset + 1, tldOffset) + " ") < 0) {
          return null;
        }
        return domain.slice(sldOffset + 1);
      },
      noConflict: function() {
        if (root.SecondLevelDomains === this) {
          root.SecondLevelDomains = _SecondLevelDomains;
        }
        return this;
      }
    };
    return SLD;
  });
});
var URI = createCommonjsModule(function(module2) {
  (function(root, factory) {
    if (module2.exports) {
      module2.exports = factory(punycode, IPv6, SecondLevelDomains);
    } else {
      root.URI = factory(root.punycode, root.IPv6, root.SecondLevelDomains, root);
    }
  })(commonjsGlobal, function(punycode2, IPv62, SLD, root) {
    var _URI = root && root.URI;
    function URI2(url2, base) {
      var _urlSupplied = arguments.length >= 1;
      var _baseSupplied = arguments.length >= 2;
      if (!(this instanceof URI2)) {
        if (_urlSupplied) {
          if (_baseSupplied) {
            return new URI2(url2, base);
          }
          return new URI2(url2);
        }
        return new URI2();
      }
      if (url2 === void 0) {
        if (_urlSupplied) {
          throw new TypeError("undefined is not a valid argument for URI");
        }
        if (typeof location !== "undefined") {
          url2 = location.href + "";
        } else {
          url2 = "";
        }
      }
      if (url2 === null) {
        if (_urlSupplied) {
          throw new TypeError("null is not a valid argument for URI");
        }
      }
      this.href(url2);
      if (base !== void 0) {
        return this.absoluteTo(base);
      }
      return this;
    }
    function isInteger(value) {
      return /^[0-9]+$/.test(value);
    }
    URI2.version = "1.19.11";
    var p2 = URI2.prototype;
    var hasOwn = Object.prototype.hasOwnProperty;
    function escapeRegEx(string) {
      return string.replace(/([.*+?^=!:${}()|[\]\/\\])/g, "\\$1");
    }
    function getType(value) {
      if (value === void 0) {
        return "Undefined";
      }
      return String(Object.prototype.toString.call(value)).slice(8, -1);
    }
    function isArray(obj) {
      return getType(obj) === "Array";
    }
    function filterArrayValues(data, value) {
      var lookup = {};
      var i2, length3;
      if (getType(value) === "RegExp") {
        lookup = null;
      } else if (isArray(value)) {
        for (i2 = 0, length3 = value.length; i2 < length3; i2++) {
          lookup[value[i2]] = true;
        }
      } else {
        lookup[value] = true;
      }
      for (i2 = 0, length3 = data.length; i2 < length3; i2++) {
        var _match = lookup && lookup[data[i2]] !== void 0 || !lookup && value.test(data[i2]);
        if (_match) {
          data.splice(i2, 1);
          length3--;
          i2--;
        }
      }
      return data;
    }
    function arrayContains(list, value) {
      var i2, length3;
      if (isArray(value)) {
        for (i2 = 0, length3 = value.length; i2 < length3; i2++) {
          if (!arrayContains(list, value[i2])) {
            return false;
          }
        }
        return true;
      }
      var _type = getType(value);
      for (i2 = 0, length3 = list.length; i2 < length3; i2++) {
        if (_type === "RegExp") {
          if (typeof list[i2] === "string" && list[i2].match(value)) {
            return true;
          }
        } else if (list[i2] === value) {
          return true;
        }
      }
      return false;
    }
    function arraysEqual(one, two) {
      if (!isArray(one) || !isArray(two)) {
        return false;
      }
      if (one.length !== two.length) {
        return false;
      }
      one.sort();
      two.sort();
      for (var i2 = 0, l2 = one.length; i2 < l2; i2++) {
        if (one[i2] !== two[i2]) {
          return false;
        }
      }
      return true;
    }
    function trimSlashes(text2) {
      var trim_expression = /^\/+|\/+$/g;
      return text2.replace(trim_expression, "");
    }
    URI2._parts = function() {
      return {
        protocol: null,
        username: null,
        password: null,
        hostname: null,
        urn: null,
        port: null,
        path: null,
        query: null,
        fragment: null,
        preventInvalidHostname: URI2.preventInvalidHostname,
        duplicateQueryParameters: URI2.duplicateQueryParameters,
        escapeQuerySpace: URI2.escapeQuerySpace
      };
    };
    URI2.preventInvalidHostname = false;
    URI2.duplicateQueryParameters = false;
    URI2.escapeQuerySpace = true;
    URI2.protocol_expression = /^[a-z][a-z0-9.+-]*$/i;
    URI2.idn_expression = /[^a-z0-9\._-]/i;
    URI2.punycode_expression = /(xn--)/i;
    URI2.ip4_expression = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
    URI2.ip6_expression = /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/;
    URI2.find_uri_expression = /\b((?:[a-z][\w-]+:(?:\/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’]))/ig;
    URI2.findUri = {
      start: /\b(?:([a-z][a-z0-9.+-]*:\/\/)|www\.)/gi,
      end: /[\s\r\n]|$/,
      trim: /[`!()\[\]{};:'".,<>?«»“”„‘’]+$/,
      parens: /(\([^\)]*\)|\[[^\]]*\]|\{[^}]*\}|<[^>]*>)/g
    };
    URI2.leading_whitespace_expression = /^[\x00-\x20\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/;
    URI2.ascii_tab_whitespace = /[\u0009\u000A\u000D]+/g;
    URI2.defaultPorts = {
      http: "80",
      https: "443",
      ftp: "21",
      gopher: "70",
      ws: "80",
      wss: "443"
    };
    URI2.hostProtocols = [
      "http",
      "https"
    ];
    URI2.invalid_hostname_characters = /[^a-zA-Z0-9\.\-:_]/;
    URI2.domAttributes = {
      "a": "href",
      "blockquote": "cite",
      "link": "href",
      "base": "href",
      "script": "src",
      "form": "action",
      "img": "src",
      "area": "href",
      "iframe": "src",
      "embed": "src",
      "source": "src",
      "track": "src",
      "input": "src",
      "audio": "src",
      "video": "src"
    };
    URI2.getDomAttribute = function(node) {
      if (!node || !node.nodeName) {
        return void 0;
      }
      var nodeName = node.nodeName.toLowerCase();
      if (nodeName === "input" && node.type !== "image") {
        return void 0;
      }
      return URI2.domAttributes[nodeName];
    };
    function escapeForDumbFirefox36(value) {
      return escape(value);
    }
    function strictEncodeURIComponent(string) {
      return encodeURIComponent(string).replace(/[!'()*]/g, escapeForDumbFirefox36).replace(/\*/g, "%2A");
    }
    URI2.encode = strictEncodeURIComponent;
    URI2.decode = decodeURIComponent;
    URI2.iso8859 = function() {
      URI2.encode = escape;
      URI2.decode = unescape;
    };
    URI2.unicode = function() {
      URI2.encode = strictEncodeURIComponent;
      URI2.decode = decodeURIComponent;
    };
    URI2.characters = {
      pathname: {
        encode: {
          expression: /%(24|26|2B|2C|3B|3D|3A|40)/ig,
          map: {
            "%24": "$",
            "%26": "&",
            "%2B": "+",
            "%2C": ",",
            "%3B": ";",
            "%3D": "=",
            "%3A": ":",
            "%40": "@"
          }
        },
        decode: {
          expression: /[\/\?#]/g,
          map: {
            "/": "%2F",
            "?": "%3F",
            "#": "%23"
          }
        }
      },
      reserved: {
        encode: {
          expression: /%(21|23|24|26|27|28|29|2A|2B|2C|2F|3A|3B|3D|3F|40|5B|5D)/ig,
          map: {
            "%3A": ":",
            "%2F": "/",
            "%3F": "?",
            "%23": "#",
            "%5B": "[",
            "%5D": "]",
            "%40": "@",
            "%21": "!",
            "%24": "$",
            "%26": "&",
            "%27": "'",
            "%28": "(",
            "%29": ")",
            "%2A": "*",
            "%2B": "+",
            "%2C": ",",
            "%3B": ";",
            "%3D": "="
          }
        }
      },
      urnpath: {
        encode: {
          expression: /%(21|24|27|28|29|2A|2B|2C|3B|3D|40)/ig,
          map: {
            "%21": "!",
            "%24": "$",
            "%27": "'",
            "%28": "(",
            "%29": ")",
            "%2A": "*",
            "%2B": "+",
            "%2C": ",",
            "%3B": ";",
            "%3D": "=",
            "%40": "@"
          }
        },
        decode: {
          expression: /[\/\?#:]/g,
          map: {
            "/": "%2F",
            "?": "%3F",
            "#": "%23",
            ":": "%3A"
          }
        }
      }
    };
    URI2.encodeQuery = function(string, escapeQuerySpace) {
      var escaped = URI2.encode(string + "");
      if (escapeQuerySpace === void 0) {
        escapeQuerySpace = URI2.escapeQuerySpace;
      }
      return escapeQuerySpace ? escaped.replace(/%20/g, "+") : escaped;
    };
    URI2.decodeQuery = function(string, escapeQuerySpace) {
      string += "";
      if (escapeQuerySpace === void 0) {
        escapeQuerySpace = URI2.escapeQuerySpace;
      }
      try {
        return URI2.decode(escapeQuerySpace ? string.replace(/\+/g, "%20") : string);
      } catch (e2) {
        return string;
      }
    };
    var _parts = { "encode": "encode", "decode": "decode" };
    var _part;
    var generateAccessor = function(_group, _part2) {
      return function(string) {
        try {
          return URI2[_part2](string + "").replace(URI2.characters[_group][_part2].expression, function(c14) {
            return URI2.characters[_group][_part2].map[c14];
          });
        } catch (e2) {
          return string;
        }
      };
    };
    for (_part in _parts) {
      URI2[_part + "PathSegment"] = generateAccessor("pathname", _parts[_part]);
      URI2[_part + "UrnPathSegment"] = generateAccessor("urnpath", _parts[_part]);
    }
    var generateSegmentedPathFunction = function(_sep, _codingFuncName, _innerCodingFuncName) {
      return function(string) {
        var actualCodingFunc;
        if (!_innerCodingFuncName) {
          actualCodingFunc = URI2[_codingFuncName];
        } else {
          actualCodingFunc = function(string2) {
            return URI2[_codingFuncName](URI2[_innerCodingFuncName](string2));
          };
        }
        var segments = (string + "").split(_sep);
        for (var i2 = 0, length3 = segments.length; i2 < length3; i2++) {
          segments[i2] = actualCodingFunc(segments[i2]);
        }
        return segments.join(_sep);
      };
    };
    URI2.decodePath = generateSegmentedPathFunction("/", "decodePathSegment");
    URI2.decodeUrnPath = generateSegmentedPathFunction(":", "decodeUrnPathSegment");
    URI2.recodePath = generateSegmentedPathFunction("/", "encodePathSegment", "decode");
    URI2.recodeUrnPath = generateSegmentedPathFunction(":", "encodeUrnPathSegment", "decode");
    URI2.encodeReserved = generateAccessor("reserved", "encode");
    URI2.parse = function(string, parts) {
      var pos;
      if (!parts) {
        parts = {
          preventInvalidHostname: URI2.preventInvalidHostname
        };
      }
      string = string.replace(URI2.leading_whitespace_expression, "");
      string = string.replace(URI2.ascii_tab_whitespace, "");
      pos = string.indexOf("#");
      if (pos > -1) {
        parts.fragment = string.substring(pos + 1) || null;
        string = string.substring(0, pos);
      }
      pos = string.indexOf("?");
      if (pos > -1) {
        parts.query = string.substring(pos + 1) || null;
        string = string.substring(0, pos);
      }
      string = string.replace(/^(https?|ftp|wss?)?:+[/\\]*/i, "$1://");
      string = string.replace(/^[/\\]{2,}/i, "//");
      if (string.substring(0, 2) === "//") {
        parts.protocol = null;
        string = string.substring(2);
        string = URI2.parseAuthority(string, parts);
      } else {
        pos = string.indexOf(":");
        if (pos > -1) {
          parts.protocol = string.substring(0, pos) || null;
          if (parts.protocol && !parts.protocol.match(URI2.protocol_expression)) {
            parts.protocol = void 0;
          } else if (string.substring(pos + 1, pos + 3).replace(/\\/g, "/") === "//") {
            string = string.substring(pos + 3);
            string = URI2.parseAuthority(string, parts);
          } else {
            string = string.substring(pos + 1);
            parts.urn = true;
          }
        }
      }
      parts.path = string;
      return parts;
    };
    URI2.parseHost = function(string, parts) {
      if (!string) {
        string = "";
      }
      string = string.replace(/\\/g, "/");
      var pos = string.indexOf("/");
      var bracketPos;
      var t;
      if (pos === -1) {
        pos = string.length;
      }
      if (string.charAt(0) === "[") {
        bracketPos = string.indexOf("]");
        parts.hostname = string.substring(1, bracketPos) || null;
        parts.port = string.substring(bracketPos + 2, pos) || null;
        if (parts.port === "/") {
          parts.port = null;
        }
      } else {
        var firstColon = string.indexOf(":");
        var firstSlash = string.indexOf("/");
        var nextColon = string.indexOf(":", firstColon + 1);
        if (nextColon !== -1 && (firstSlash === -1 || nextColon < firstSlash)) {
          parts.hostname = string.substring(0, pos) || null;
          parts.port = null;
        } else {
          t = string.substring(0, pos).split(":");
          parts.hostname = t[0] || null;
          parts.port = t[1] || null;
        }
      }
      if (parts.hostname && string.substring(pos).charAt(0) !== "/") {
        pos++;
        string = "/" + string;
      }
      if (parts.preventInvalidHostname) {
        URI2.ensureValidHostname(parts.hostname, parts.protocol);
      }
      if (parts.port) {
        URI2.ensureValidPort(parts.port);
      }
      return string.substring(pos) || "/";
    };
    URI2.parseAuthority = function(string, parts) {
      string = URI2.parseUserinfo(string, parts);
      return URI2.parseHost(string, parts);
    };
    URI2.parseUserinfo = function(string, parts) {
      var _string = string;
      var firstBackSlash = string.indexOf("\\");
      if (firstBackSlash !== -1) {
        string = string.replace(/\\/g, "/");
      }
      var firstSlash = string.indexOf("/");
      var pos = string.lastIndexOf("@", firstSlash > -1 ? firstSlash : string.length - 1);
      var t;
      if (pos > -1 && (firstSlash === -1 || pos < firstSlash)) {
        t = string.substring(0, pos).split(":");
        parts.username = t[0] ? URI2.decode(t[0]) : null;
        t.shift();
        parts.password = t[0] ? URI2.decode(t.join(":")) : null;
        string = _string.substring(pos + 1);
      } else {
        parts.username = null;
        parts.password = null;
      }
      return string;
    };
    URI2.parseQuery = function(string, escapeQuerySpace) {
      if (!string) {
        return {};
      }
      string = string.replace(/&+/g, "&").replace(/^\?*&*|&+$/g, "");
      if (!string) {
        return {};
      }
      var items = {};
      var splits = string.split("&");
      var length3 = splits.length;
      var v7, name, value;
      for (var i2 = 0; i2 < length3; i2++) {
        v7 = splits[i2].split("=");
        name = URI2.decodeQuery(v7.shift(), escapeQuerySpace);
        value = v7.length ? URI2.decodeQuery(v7.join("="), escapeQuerySpace) : null;
        if (name === "__proto__") {
          continue;
        } else if (hasOwn.call(items, name)) {
          if (typeof items[name] === "string" || items[name] === null) {
            items[name] = [items[name]];
          }
          items[name].push(value);
        } else {
          items[name] = value;
        }
      }
      return items;
    };
    URI2.build = function(parts) {
      var t = "";
      var requireAbsolutePath = false;
      if (parts.protocol) {
        t += parts.protocol + ":";
      }
      if (!parts.urn && (t || parts.hostname)) {
        t += "//";
        requireAbsolutePath = true;
      }
      t += URI2.buildAuthority(parts) || "";
      if (typeof parts.path === "string") {
        if (parts.path.charAt(0) !== "/" && requireAbsolutePath) {
          t += "/";
        }
        t += parts.path;
      }
      if (typeof parts.query === "string" && parts.query) {
        t += "?" + parts.query;
      }
      if (typeof parts.fragment === "string" && parts.fragment) {
        t += "#" + parts.fragment;
      }
      return t;
    };
    URI2.buildHost = function(parts) {
      var t = "";
      if (!parts.hostname) {
        return "";
      } else if (URI2.ip6_expression.test(parts.hostname)) {
        t += "[" + parts.hostname + "]";
      } else {
        t += parts.hostname;
      }
      if (parts.port) {
        t += ":" + parts.port;
      }
      return t;
    };
    URI2.buildAuthority = function(parts) {
      return URI2.buildUserinfo(parts) + URI2.buildHost(parts);
    };
    URI2.buildUserinfo = function(parts) {
      var t = "";
      if (parts.username) {
        t += URI2.encode(parts.username);
      }
      if (parts.password) {
        t += ":" + URI2.encode(parts.password);
      }
      if (t) {
        t += "@";
      }
      return t;
    };
    URI2.buildQuery = function(data, duplicateQueryParameters, escapeQuerySpace) {
      var t = "";
      var unique, key, i2, length3;
      for (key in data) {
        if (key === "__proto__") {
          continue;
        } else if (hasOwn.call(data, key)) {
          if (isArray(data[key])) {
            unique = {};
            for (i2 = 0, length3 = data[key].length; i2 < length3; i2++) {
              if (data[key][i2] !== void 0 && unique[data[key][i2] + ""] === void 0) {
                t += "&" + URI2.buildQueryParameter(key, data[key][i2], escapeQuerySpace);
                if (duplicateQueryParameters !== true) {
                  unique[data[key][i2] + ""] = true;
                }
              }
            }
          } else if (data[key] !== void 0) {
            t += "&" + URI2.buildQueryParameter(key, data[key], escapeQuerySpace);
          }
        }
      }
      return t.substring(1);
    };
    URI2.buildQueryParameter = function(name, value, escapeQuerySpace) {
      return URI2.encodeQuery(name, escapeQuerySpace) + (value !== null ? "=" + URI2.encodeQuery(value, escapeQuerySpace) : "");
    };
    URI2.addQuery = function(data, name, value) {
      if (typeof name === "object") {
        for (var key in name) {
          if (hasOwn.call(name, key)) {
            URI2.addQuery(data, key, name[key]);
          }
        }
      } else if (typeof name === "string") {
        if (data[name] === void 0) {
          data[name] = value;
          return;
        } else if (typeof data[name] === "string") {
          data[name] = [data[name]];
        }
        if (!isArray(value)) {
          value = [value];
        }
        data[name] = (data[name] || []).concat(value);
      } else {
        throw new TypeError("URI.addQuery() accepts an object, string as the name parameter");
      }
    };
    URI2.setQuery = function(data, name, value) {
      if (typeof name === "object") {
        for (var key in name) {
          if (hasOwn.call(name, key)) {
            URI2.setQuery(data, key, name[key]);
          }
        }
      } else if (typeof name === "string") {
        data[name] = value === void 0 ? null : value;
      } else {
        throw new TypeError("URI.setQuery() accepts an object, string as the name parameter");
      }
    };
    URI2.removeQuery = function(data, name, value) {
      var i2, length3, key;
      if (isArray(name)) {
        for (i2 = 0, length3 = name.length; i2 < length3; i2++) {
          data[name[i2]] = void 0;
        }
      } else if (getType(name) === "RegExp") {
        for (key in data) {
          if (name.test(key)) {
            data[key] = void 0;
          }
        }
      } else if (typeof name === "object") {
        for (key in name) {
          if (hasOwn.call(name, key)) {
            URI2.removeQuery(data, key, name[key]);
          }
        }
      } else if (typeof name === "string") {
        if (value !== void 0) {
          if (getType(value) === "RegExp") {
            if (!isArray(data[name]) && value.test(data[name])) {
              data[name] = void 0;
            } else {
              data[name] = filterArrayValues(data[name], value);
            }
          } else if (data[name] === String(value) && (!isArray(value) || value.length === 1)) {
            data[name] = void 0;
          } else if (isArray(data[name])) {
            data[name] = filterArrayValues(data[name], value);
          }
        } else {
          data[name] = void 0;
        }
      } else {
        throw new TypeError("URI.removeQuery() accepts an object, string, RegExp as the first parameter");
      }
    };
    URI2.hasQuery = function(data, name, value, withinArray) {
      switch (getType(name)) {
        case "String":
          break;
        case "RegExp":
          for (var key in data) {
            if (hasOwn.call(data, key)) {
              if (name.test(key) && (value === void 0 || URI2.hasQuery(data, key, value))) {
                return true;
              }
            }
          }
          return false;
        case "Object":
          for (var _key in name) {
            if (hasOwn.call(name, _key)) {
              if (!URI2.hasQuery(data, _key, name[_key])) {
                return false;
              }
            }
          }
          return true;
        default:
          throw new TypeError("URI.hasQuery() accepts a string, regular expression or object as the name parameter");
      }
      switch (getType(value)) {
        case "Undefined":
          return name in data;
        case "Boolean":
          var _booly = Boolean(isArray(data[name]) ? data[name].length : data[name]);
          return value === _booly;
        case "Function":
          return !!value(data[name], name, data);
        case "Array":
          if (!isArray(data[name])) {
            return false;
          }
          var op = withinArray ? arrayContains : arraysEqual;
          return op(data[name], value);
        case "RegExp":
          if (!isArray(data[name])) {
            return Boolean(data[name] && data[name].match(value));
          }
          if (!withinArray) {
            return false;
          }
          return arrayContains(data[name], value);
        case "Number":
          value = String(value);
        case "String":
          if (!isArray(data[name])) {
            return data[name] === value;
          }
          if (!withinArray) {
            return false;
          }
          return arrayContains(data[name], value);
        default:
          throw new TypeError("URI.hasQuery() accepts undefined, boolean, string, number, RegExp, Function as the value parameter");
      }
    };
    URI2.joinPaths = function() {
      var input = [];
      var segments = [];
      var nonEmptySegments = 0;
      for (var i2 = 0; i2 < arguments.length; i2++) {
        var url2 = new URI2(arguments[i2]);
        input.push(url2);
        var _segments = url2.segment();
        for (var s2 = 0; s2 < _segments.length; s2++) {
          if (typeof _segments[s2] === "string") {
            segments.push(_segments[s2]);
          }
          if (_segments[s2]) {
            nonEmptySegments++;
          }
        }
      }
      if (!segments.length || !nonEmptySegments) {
        return new URI2("");
      }
      var uri = new URI2("").segment(segments);
      if (input[0].path() === "" || input[0].path().slice(0, 1) === "/") {
        uri.path("/" + uri.path());
      }
      return uri.normalize();
    };
    URI2.commonPath = function(one, two) {
      var length3 = Math.min(one.length, two.length);
      var pos;
      for (pos = 0; pos < length3; pos++) {
        if (one.charAt(pos) !== two.charAt(pos)) {
          pos--;
          break;
        }
      }
      if (pos < 1) {
        return one.charAt(0) === two.charAt(0) && one.charAt(0) === "/" ? "/" : "";
      }
      if (one.charAt(pos) !== "/" || two.charAt(pos) !== "/") {
        pos = one.substring(0, pos).lastIndexOf("/");
      }
      return one.substring(0, pos + 1);
    };
    URI2.withinString = function(string, callback, options) {
      options || (options = {});
      var _start = options.start || URI2.findUri.start;
      var _end = options.end || URI2.findUri.end;
      var _trim = options.trim || URI2.findUri.trim;
      var _parens = options.parens || URI2.findUri.parens;
      var _attributeOpen = /[a-z0-9-]=["']?$/i;
      _start.lastIndex = 0;
      while (true) {
        var match = _start.exec(string);
        if (!match) {
          break;
        }
        var start = match.index;
        if (options.ignoreHtml) {
          var attributeOpen = string.slice(Math.max(start - 3, 0), start);
          if (attributeOpen && _attributeOpen.test(attributeOpen)) {
            continue;
          }
        }
        var end = start + string.slice(start).search(_end);
        var slice = string.slice(start, end);
        var parensEnd = -1;
        while (true) {
          var parensMatch = _parens.exec(slice);
          if (!parensMatch) {
            break;
          }
          var parensMatchEnd = parensMatch.index + parensMatch[0].length;
          parensEnd = Math.max(parensEnd, parensMatchEnd);
        }
        if (parensEnd > -1) {
          slice = slice.slice(0, parensEnd) + slice.slice(parensEnd).replace(_trim, "");
        } else {
          slice = slice.replace(_trim, "");
        }
        if (slice.length <= match[0].length) {
          continue;
        }
        if (options.ignore && options.ignore.test(slice)) {
          continue;
        }
        end = start + slice.length;
        var result = callback(slice, start, end, string);
        if (result === void 0) {
          _start.lastIndex = end;
          continue;
        }
        result = String(result);
        string = string.slice(0, start) + result + string.slice(end);
        _start.lastIndex = start + result.length;
      }
      _start.lastIndex = 0;
      return string;
    };
    URI2.ensureValidHostname = function(v7, protocol) {
      var hasHostname = !!v7;
      var hasProtocol = !!protocol;
      var rejectEmptyHostname = false;
      if (hasProtocol) {
        rejectEmptyHostname = arrayContains(URI2.hostProtocols, protocol);
      }
      if (rejectEmptyHostname && !hasHostname) {
        throw new TypeError("Hostname cannot be empty, if protocol is " + protocol);
      } else if (v7 && v7.match(URI2.invalid_hostname_characters)) {
        if (!punycode2) {
          throw new TypeError('Hostname "' + v7 + '" contains characters other than [A-Z0-9.-:_] and Punycode.js is not available');
        }
        if (punycode2.toASCII(v7).match(URI2.invalid_hostname_characters)) {
          throw new TypeError('Hostname "' + v7 + '" contains characters other than [A-Z0-9.-:_]');
        }
      }
    };
    URI2.ensureValidPort = function(v7) {
      if (!v7) {
        return;
      }
      var port = Number(v7);
      if (isInteger(port) && port > 0 && port < 65536) {
        return;
      }
      throw new TypeError('Port "' + v7 + '" is not a valid port');
    };
    URI2.noConflict = function(removeAll) {
      if (removeAll) {
        var unconflicted = {
          URI: this.noConflict()
        };
        if (root.URITemplate && typeof root.URITemplate.noConflict === "function") {
          unconflicted.URITemplate = root.URITemplate.noConflict();
        }
        if (root.IPv6 && typeof root.IPv6.noConflict === "function") {
          unconflicted.IPv6 = root.IPv6.noConflict();
        }
        if (root.SecondLevelDomains && typeof root.SecondLevelDomains.noConflict === "function") {
          unconflicted.SecondLevelDomains = root.SecondLevelDomains.noConflict();
        }
        return unconflicted;
      } else if (root.URI === this) {
        root.URI = _URI;
      }
      return this;
    };
    p2.build = function(deferBuild) {
      if (deferBuild === true) {
        this._deferred_build = true;
      } else if (deferBuild === void 0 || this._deferred_build) {
        this._string = URI2.build(this._parts);
        this._deferred_build = false;
      }
      return this;
    };
    p2.clone = function() {
      return new URI2(this);
    };
    p2.valueOf = p2.toString = function() {
      return this.build(false)._string;
    };
    function generateSimpleAccessor(_part2) {
      return function(v7, build) {
        if (v7 === void 0) {
          return this._parts[_part2] || "";
        } else {
          this._parts[_part2] = v7 || null;
          this.build(!build);
          return this;
        }
      };
    }
    function generatePrefixAccessor(_part2, _key) {
      return function(v7, build) {
        if (v7 === void 0) {
          return this._parts[_part2] || "";
        } else {
          if (v7 !== null) {
            v7 = v7 + "";
            if (v7.charAt(0) === _key) {
              v7 = v7.substring(1);
            }
          }
          this._parts[_part2] = v7;
          this.build(!build);
          return this;
        }
      };
    }
    p2.protocol = generateSimpleAccessor("protocol");
    p2.username = generateSimpleAccessor("username");
    p2.password = generateSimpleAccessor("password");
    p2.hostname = generateSimpleAccessor("hostname");
    p2.port = generateSimpleAccessor("port");
    p2.query = generatePrefixAccessor("query", "?");
    p2.fragment = generatePrefixAccessor("fragment", "#");
    p2.search = function(v7, build) {
      var t = this.query(v7, build);
      return typeof t === "string" && t.length ? "?" + t : t;
    };
    p2.hash = function(v7, build) {
      var t = this.fragment(v7, build);
      return typeof t === "string" && t.length ? "#" + t : t;
    };
    p2.pathname = function(v7, build) {
      if (v7 === void 0 || v7 === true) {
        var res = this._parts.path || (this._parts.hostname ? "/" : "");
        return v7 ? (this._parts.urn ? URI2.decodeUrnPath : URI2.decodePath)(res) : res;
      } else {
        if (this._parts.urn) {
          this._parts.path = v7 ? URI2.recodeUrnPath(v7) : "";
        } else {
          this._parts.path = v7 ? URI2.recodePath(v7) : "/";
        }
        this.build(!build);
        return this;
      }
    };
    p2.path = p2.pathname;
    p2.href = function(href, build) {
      var key;
      if (href === void 0) {
        return this.toString();
      }
      this._string = "";
      this._parts = URI2._parts();
      var _URI2 = href instanceof URI2;
      var _object = typeof href === "object" && (href.hostname || href.path || href.pathname);
      if (href.nodeName) {
        var attribute = URI2.getDomAttribute(href);
        href = href[attribute] || "";
        _object = false;
      }
      if (!_URI2 && _object && href.pathname !== void 0) {
        href = href.toString();
      }
      if (typeof href === "string" || href instanceof String) {
        this._parts = URI2.parse(String(href), this._parts);
      } else if (_URI2 || _object) {
        var src2 = _URI2 ? href._parts : href;
        for (key in src2) {
          if (key === "query") {
            continue;
          }
          if (hasOwn.call(this._parts, key)) {
            this._parts[key] = src2[key];
          }
        }
        if (src2.query) {
          this.query(src2.query, false);
        }
      } else {
        throw new TypeError("invalid input");
      }
      this.build(!build);
      return this;
    };
    p2.is = function(what) {
      var ip = false;
      var ip4 = false;
      var ip6 = false;
      var name = false;
      var sld = false;
      var idn = false;
      var punycode3 = false;
      var relative = !this._parts.urn;
      if (this._parts.hostname) {
        relative = false;
        ip4 = URI2.ip4_expression.test(this._parts.hostname);
        ip6 = URI2.ip6_expression.test(this._parts.hostname);
        ip = ip4 || ip6;
        name = !ip;
        sld = name && SLD && SLD.has(this._parts.hostname);
        idn = name && URI2.idn_expression.test(this._parts.hostname);
        punycode3 = name && URI2.punycode_expression.test(this._parts.hostname);
      }
      switch (what.toLowerCase()) {
        case "relative":
          return relative;
        case "absolute":
          return !relative;
        case "domain":
        case "name":
          return name;
        case "sld":
          return sld;
        case "ip":
          return ip;
        case "ip4":
        case "ipv4":
        case "inet4":
          return ip4;
        case "ip6":
        case "ipv6":
        case "inet6":
          return ip6;
        case "idn":
          return idn;
        case "url":
          return !this._parts.urn;
        case "urn":
          return !!this._parts.urn;
        case "punycode":
          return punycode3;
      }
      return null;
    };
    var _protocol = p2.protocol;
    var _port = p2.port;
    var _hostname = p2.hostname;
    p2.protocol = function(v7, build) {
      if (v7) {
        v7 = v7.replace(/:(\/\/)?$/, "");
        if (!v7.match(URI2.protocol_expression)) {
          throw new TypeError('Protocol "' + v7 + `" contains characters other than [A-Z0-9.+-] or doesn't start with [A-Z]`);
        }
      }
      return _protocol.call(this, v7, build);
    };
    p2.scheme = p2.protocol;
    p2.port = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (v7 !== void 0) {
        if (v7 === 0) {
          v7 = null;
        }
        if (v7) {
          v7 += "";
          if (v7.charAt(0) === ":") {
            v7 = v7.substring(1);
          }
          URI2.ensureValidPort(v7);
        }
      }
      return _port.call(this, v7, build);
    };
    p2.hostname = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (v7 !== void 0) {
        var x = { preventInvalidHostname: this._parts.preventInvalidHostname };
        var res = URI2.parseHost(v7, x);
        if (res !== "/") {
          throw new TypeError('Hostname "' + v7 + '" contains characters other than [A-Z0-9.-]');
        }
        v7 = x.hostname;
        if (this._parts.preventInvalidHostname) {
          URI2.ensureValidHostname(v7, this._parts.protocol);
        }
      }
      return _hostname.call(this, v7, build);
    };
    p2.origin = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (v7 === void 0) {
        var protocol = this.protocol();
        var authority = this.authority();
        if (!authority) {
          return "";
        }
        return (protocol ? protocol + "://" : "") + this.authority();
      } else {
        var origin = URI2(v7);
        this.protocol(origin.protocol()).authority(origin.authority()).build(!build);
        return this;
      }
    };
    p2.host = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (v7 === void 0) {
        return this._parts.hostname ? URI2.buildHost(this._parts) : "";
      } else {
        var res = URI2.parseHost(v7, this._parts);
        if (res !== "/") {
          throw new TypeError('Hostname "' + v7 + '" contains characters other than [A-Z0-9.-]');
        }
        this.build(!build);
        return this;
      }
    };
    p2.authority = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (v7 === void 0) {
        return this._parts.hostname ? URI2.buildAuthority(this._parts) : "";
      } else {
        var res = URI2.parseAuthority(v7, this._parts);
        if (res !== "/") {
          throw new TypeError('Hostname "' + v7 + '" contains characters other than [A-Z0-9.-]');
        }
        this.build(!build);
        return this;
      }
    };
    p2.userinfo = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (v7 === void 0) {
        var t = URI2.buildUserinfo(this._parts);
        return t ? t.substring(0, t.length - 1) : t;
      } else {
        if (v7[v7.length - 1] !== "@") {
          v7 += "@";
        }
        URI2.parseUserinfo(v7, this._parts);
        this.build(!build);
        return this;
      }
    };
    p2.resource = function(v7, build) {
      var parts;
      if (v7 === void 0) {
        return this.path() + this.search() + this.hash();
      }
      parts = URI2.parse(v7);
      this._parts.path = parts.path;
      this._parts.query = parts.query;
      this._parts.fragment = parts.fragment;
      this.build(!build);
      return this;
    };
    p2.subdomain = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (v7 === void 0) {
        if (!this._parts.hostname || this.is("IP")) {
          return "";
        }
        var end = this._parts.hostname.length - this.domain().length - 1;
        return this._parts.hostname.substring(0, end) || "";
      } else {
        var e2 = this._parts.hostname.length - this.domain().length;
        var sub = this._parts.hostname.substring(0, e2);
        var replace = new RegExp("^" + escapeRegEx(sub));
        if (v7 && v7.charAt(v7.length - 1) !== ".") {
          v7 += ".";
        }
        if (v7.indexOf(":") !== -1) {
          throw new TypeError("Domains cannot contain colons");
        }
        if (v7) {
          URI2.ensureValidHostname(v7, this._parts.protocol);
        }
        this._parts.hostname = this._parts.hostname.replace(replace, v7);
        this.build(!build);
        return this;
      }
    };
    p2.domain = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (typeof v7 === "boolean") {
        build = v7;
        v7 = void 0;
      }
      if (v7 === void 0) {
        if (!this._parts.hostname || this.is("IP")) {
          return "";
        }
        var t = this._parts.hostname.match(/\./g);
        if (t && t.length < 2) {
          return this._parts.hostname;
        }
        var end = this._parts.hostname.length - this.tld(build).length - 1;
        end = this._parts.hostname.lastIndexOf(".", end - 1) + 1;
        return this._parts.hostname.substring(end) || "";
      } else {
        if (!v7) {
          throw new TypeError("cannot set domain empty");
        }
        if (v7.indexOf(":") !== -1) {
          throw new TypeError("Domains cannot contain colons");
        }
        URI2.ensureValidHostname(v7, this._parts.protocol);
        if (!this._parts.hostname || this.is("IP")) {
          this._parts.hostname = v7;
        } else {
          var replace = new RegExp(escapeRegEx(this.domain()) + "$");
          this._parts.hostname = this._parts.hostname.replace(replace, v7);
        }
        this.build(!build);
        return this;
      }
    };
    p2.tld = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (typeof v7 === "boolean") {
        build = v7;
        v7 = void 0;
      }
      if (v7 === void 0) {
        if (!this._parts.hostname || this.is("IP")) {
          return "";
        }
        var pos = this._parts.hostname.lastIndexOf(".");
        var tld = this._parts.hostname.substring(pos + 1);
        if (build !== true && SLD && SLD.list[tld.toLowerCase()]) {
          return SLD.get(this._parts.hostname) || tld;
        }
        return tld;
      } else {
        var replace;
        if (!v7) {
          throw new TypeError("cannot set TLD empty");
        } else if (v7.match(/[^a-zA-Z0-9-]/)) {
          if (SLD && SLD.is(v7)) {
            replace = new RegExp(escapeRegEx(this.tld()) + "$");
            this._parts.hostname = this._parts.hostname.replace(replace, v7);
          } else {
            throw new TypeError('TLD "' + v7 + '" contains characters other than [A-Z0-9]');
          }
        } else if (!this._parts.hostname || this.is("IP")) {
          throw new ReferenceError("cannot set TLD on non-domain host");
        } else {
          replace = new RegExp(escapeRegEx(this.tld()) + "$");
          this._parts.hostname = this._parts.hostname.replace(replace, v7);
        }
        this.build(!build);
        return this;
      }
    };
    p2.directory = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (v7 === void 0 || v7 === true) {
        if (!this._parts.path && !this._parts.hostname) {
          return "";
        }
        if (this._parts.path === "/") {
          return "/";
        }
        var end = this._parts.path.length - this.filename().length - 1;
        var res = this._parts.path.substring(0, end) || (this._parts.hostname ? "/" : "");
        return v7 ? URI2.decodePath(res) : res;
      } else {
        var e2 = this._parts.path.length - this.filename().length;
        var directory = this._parts.path.substring(0, e2);
        var replace = new RegExp("^" + escapeRegEx(directory));
        if (!this.is("relative")) {
          if (!v7) {
            v7 = "/";
          }
          if (v7.charAt(0) !== "/") {
            v7 = "/" + v7;
          }
        }
        if (v7 && v7.charAt(v7.length - 1) !== "/") {
          v7 += "/";
        }
        v7 = URI2.recodePath(v7);
        this._parts.path = this._parts.path.replace(replace, v7);
        this.build(!build);
        return this;
      }
    };
    p2.filename = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (typeof v7 !== "string") {
        if (!this._parts.path || this._parts.path === "/") {
          return "";
        }
        var pos = this._parts.path.lastIndexOf("/");
        var res = this._parts.path.substring(pos + 1);
        return v7 ? URI2.decodePathSegment(res) : res;
      } else {
        var mutatedDirectory = false;
        if (v7.charAt(0) === "/") {
          v7 = v7.substring(1);
        }
        if (v7.match(/\.?\//)) {
          mutatedDirectory = true;
        }
        var replace = new RegExp(escapeRegEx(this.filename()) + "$");
        v7 = URI2.recodePath(v7);
        this._parts.path = this._parts.path.replace(replace, v7);
        if (mutatedDirectory) {
          this.normalizePath(build);
        } else {
          this.build(!build);
        }
        return this;
      }
    };
    p2.suffix = function(v7, build) {
      if (this._parts.urn) {
        return v7 === void 0 ? "" : this;
      }
      if (v7 === void 0 || v7 === true) {
        if (!this._parts.path || this._parts.path === "/") {
          return "";
        }
        var filename = this.filename();
        var pos = filename.lastIndexOf(".");
        var s2, res;
        if (pos === -1) {
          return "";
        }
        s2 = filename.substring(pos + 1);
        res = /^[a-z0-9%]+$/i.test(s2) ? s2 : "";
        return v7 ? URI2.decodePathSegment(res) : res;
      } else {
        if (v7.charAt(0) === ".") {
          v7 = v7.substring(1);
        }
        var suffix = this.suffix();
        var replace;
        if (!suffix) {
          if (!v7) {
            return this;
          }
          this._parts.path += "." + URI2.recodePath(v7);
        } else if (!v7) {
          replace = new RegExp(escapeRegEx("." + suffix) + "$");
        } else {
          replace = new RegExp(escapeRegEx(suffix) + "$");
        }
        if (replace) {
          v7 = URI2.recodePath(v7);
          this._parts.path = this._parts.path.replace(replace, v7);
        }
        this.build(!build);
        return this;
      }
    };
    p2.segment = function(segment, v7, build) {
      var separator = this._parts.urn ? ":" : "/";
      var path = this.path();
      var absolute = path.substring(0, 1) === "/";
      var segments = path.split(separator);
      if (segment !== void 0 && typeof segment !== "number") {
        build = v7;
        v7 = segment;
        segment = void 0;
      }
      if (segment !== void 0 && typeof segment !== "number") {
        throw new Error('Bad segment "' + segment + '", must be 0-based integer');
      }
      if (absolute) {
        segments.shift();
      }
      if (segment < 0) {
        segment = Math.max(segments.length + segment, 0);
      }
      if (v7 === void 0) {
        return segment === void 0 ? segments : segments[segment];
      } else if (segment === null || segments[segment] === void 0) {
        if (isArray(v7)) {
          segments = [];
          for (var i2 = 0, l2 = v7.length; i2 < l2; i2++) {
            if (!v7[i2].length && (!segments.length || !segments[segments.length - 1].length)) {
              continue;
            }
            if (segments.length && !segments[segments.length - 1].length) {
              segments.pop();
            }
            segments.push(trimSlashes(v7[i2]));
          }
        } else if (v7 || typeof v7 === "string") {
          v7 = trimSlashes(v7);
          if (segments[segments.length - 1] === "") {
            segments[segments.length - 1] = v7;
          } else {
            segments.push(v7);
          }
        }
      } else {
        if (v7) {
          segments[segment] = trimSlashes(v7);
        } else {
          segments.splice(segment, 1);
        }
      }
      if (absolute) {
        segments.unshift("");
      }
      return this.path(segments.join(separator), build);
    };
    p2.segmentCoded = function(segment, v7, build) {
      var segments, i2, l2;
      if (typeof segment !== "number") {
        build = v7;
        v7 = segment;
        segment = void 0;
      }
      if (v7 === void 0) {
        segments = this.segment(segment, v7, build);
        if (!isArray(segments)) {
          segments = segments !== void 0 ? URI2.decode(segments) : void 0;
        } else {
          for (i2 = 0, l2 = segments.length; i2 < l2; i2++) {
            segments[i2] = URI2.decode(segments[i2]);
          }
        }
        return segments;
      }
      if (!isArray(v7)) {
        v7 = typeof v7 === "string" || v7 instanceof String ? URI2.encode(v7) : v7;
      } else {
        for (i2 = 0, l2 = v7.length; i2 < l2; i2++) {
          v7[i2] = URI2.encode(v7[i2]);
        }
      }
      return this.segment(segment, v7, build);
    };
    var q = p2.query;
    p2.query = function(v7, build) {
      if (v7 === true) {
        return URI2.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
      } else if (typeof v7 === "function") {
        var data = URI2.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
        var result = v7.call(this, data);
        this._parts.query = URI2.buildQuery(result || data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
        this.build(!build);
        return this;
      } else if (v7 !== void 0 && typeof v7 !== "string") {
        this._parts.query = URI2.buildQuery(v7, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
        this.build(!build);
        return this;
      } else {
        return q.call(this, v7, build);
      }
    };
    p2.setQuery = function(name, value, build) {
      var data = URI2.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
      if (typeof name === "string" || name instanceof String) {
        data[name] = value !== void 0 ? value : null;
      } else if (typeof name === "object") {
        for (var key in name) {
          if (hasOwn.call(name, key)) {
            data[key] = name[key];
          }
        }
      } else {
        throw new TypeError("URI.addQuery() accepts an object, string as the name parameter");
      }
      this._parts.query = URI2.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
      if (typeof name !== "string") {
        build = value;
      }
      this.build(!build);
      return this;
    };
    p2.addQuery = function(name, value, build) {
      var data = URI2.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
      URI2.addQuery(data, name, value === void 0 ? null : value);
      this._parts.query = URI2.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
      if (typeof name !== "string") {
        build = value;
      }
      this.build(!build);
      return this;
    };
    p2.removeQuery = function(name, value, build) {
      var data = URI2.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
      URI2.removeQuery(data, name, value);
      this._parts.query = URI2.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);
      if (typeof name !== "string") {
        build = value;
      }
      this.build(!build);
      return this;
    };
    p2.hasQuery = function(name, value, withinArray) {
      var data = URI2.parseQuery(this._parts.query, this._parts.escapeQuerySpace);
      return URI2.hasQuery(data, name, value, withinArray);
    };
    p2.setSearch = p2.setQuery;
    p2.addSearch = p2.addQuery;
    p2.removeSearch = p2.removeQuery;
    p2.hasSearch = p2.hasQuery;
    p2.normalize = function() {
      if (this._parts.urn) {
        return this.normalizeProtocol(false).normalizePath(false).normalizeQuery(false).normalizeFragment(false).build();
      }
      return this.normalizeProtocol(false).normalizeHostname(false).normalizePort(false).normalizePath(false).normalizeQuery(false).normalizeFragment(false).build();
    };
    p2.normalizeProtocol = function(build) {
      if (typeof this._parts.protocol === "string") {
        this._parts.protocol = this._parts.protocol.toLowerCase();
        this.build(!build);
      }
      return this;
    };
    p2.normalizeHostname = function(build) {
      if (this._parts.hostname) {
        if (this.is("IDN") && punycode2) {
          this._parts.hostname = punycode2.toASCII(this._parts.hostname);
        } else if (this.is("IPv6") && IPv62) {
          this._parts.hostname = IPv62.best(this._parts.hostname);
        }
        this._parts.hostname = this._parts.hostname.toLowerCase();
        this.build(!build);
      }
      return this;
    };
    p2.normalizePort = function(build) {
      if (typeof this._parts.protocol === "string" && this._parts.port === URI2.defaultPorts[this._parts.protocol]) {
        this._parts.port = null;
        this.build(!build);
      }
      return this;
    };
    p2.normalizePath = function(build) {
      var _path = this._parts.path;
      if (!_path) {
        return this;
      }
      if (this._parts.urn) {
        this._parts.path = URI2.recodeUrnPath(this._parts.path);
        this.build(!build);
        return this;
      }
      if (this._parts.path === "/") {
        return this;
      }
      _path = URI2.recodePath(_path);
      var _was_relative;
      var _leadingParents = "";
      var _parent, _pos;
      if (_path.charAt(0) !== "/") {
        _was_relative = true;
        _path = "/" + _path;
      }
      if (_path.slice(-3) === "/.." || _path.slice(-2) === "/.") {
        _path += "/";
      }
      _path = _path.replace(/(\/(\.\/)+)|(\/\.$)/g, "/").replace(/\/{2,}/g, "/");
      if (_was_relative) {
        _leadingParents = _path.substring(1).match(/^(\.\.\/)+/) || "";
        if (_leadingParents) {
          _leadingParents = _leadingParents[0];
        }
      }
      while (true) {
        _parent = _path.search(/\/\.\.(\/|$)/);
        if (_parent === -1) {
          break;
        } else if (_parent === 0) {
          _path = _path.substring(3);
          continue;
        }
        _pos = _path.substring(0, _parent).lastIndexOf("/");
        if (_pos === -1) {
          _pos = _parent;
        }
        _path = _path.substring(0, _pos) + _path.substring(_parent + 3);
      }
      if (_was_relative && this.is("relative")) {
        _path = _leadingParents + _path.substring(1);
      }
      this._parts.path = _path;
      this.build(!build);
      return this;
    };
    p2.normalizePathname = p2.normalizePath;
    p2.normalizeQuery = function(build) {
      if (typeof this._parts.query === "string") {
        if (!this._parts.query.length) {
          this._parts.query = null;
        } else {
          this.query(URI2.parseQuery(this._parts.query, this._parts.escapeQuerySpace));
        }
        this.build(!build);
      }
      return this;
    };
    p2.normalizeFragment = function(build) {
      if (!this._parts.fragment) {
        this._parts.fragment = null;
        this.build(!build);
      }
      return this;
    };
    p2.normalizeSearch = p2.normalizeQuery;
    p2.normalizeHash = p2.normalizeFragment;
    p2.iso8859 = function() {
      var e2 = URI2.encode;
      var d = URI2.decode;
      URI2.encode = escape;
      URI2.decode = decodeURIComponent;
      try {
        this.normalize();
      } finally {
        URI2.encode = e2;
        URI2.decode = d;
      }
      return this;
    };
    p2.unicode = function() {
      var e2 = URI2.encode;
      var d = URI2.decode;
      URI2.encode = strictEncodeURIComponent;
      URI2.decode = unescape;
      try {
        this.normalize();
      } finally {
        URI2.encode = e2;
        URI2.decode = d;
      }
      return this;
    };
    p2.readable = function() {
      var uri = this.clone();
      uri.username("").password("").normalize();
      var t = "";
      if (uri._parts.protocol) {
        t += uri._parts.protocol + "://";
      }
      if (uri._parts.hostname) {
        if (uri.is("punycode") && punycode2) {
          t += punycode2.toUnicode(uri._parts.hostname);
          if (uri._parts.port) {
            t += ":" + uri._parts.port;
          }
        } else {
          t += uri.host();
        }
      }
      if (uri._parts.hostname && uri._parts.path && uri._parts.path.charAt(0) !== "/") {
        t += "/";
      }
      t += uri.path(true);
      if (uri._parts.query) {
        var q3 = "";
        for (var i2 = 0, qp = uri._parts.query.split("&"), l2 = qp.length; i2 < l2; i2++) {
          var kv = (qp[i2] || "").split("=");
          q3 += "&" + URI2.decodeQuery(kv[0], this._parts.escapeQuerySpace).replace(/&/g, "%26");
          if (kv[1] !== void 0) {
            q3 += "=" + URI2.decodeQuery(kv[1], this._parts.escapeQuerySpace).replace(/&/g, "%26");
          }
        }
        t += "?" + q3.substring(1);
      }
      t += URI2.decodeQuery(uri.hash(), true);
      return t;
    };
    p2.absoluteTo = function(base) {
      var resolved = this.clone();
      var properties = ["protocol", "username", "password", "hostname", "port"];
      var basedir, i2, p3;
      if (this._parts.urn) {
        throw new Error("URNs do not have any generally defined hierarchical components");
      }
      if (!(base instanceof URI2)) {
        base = new URI2(base);
      }
      if (resolved._parts.protocol) {
        return resolved;
      } else {
        resolved._parts.protocol = base._parts.protocol;
      }
      if (this._parts.hostname) {
        return resolved;
      }
      for (i2 = 0; p3 = properties[i2]; i2++) {
        resolved._parts[p3] = base._parts[p3];
      }
      if (!resolved._parts.path) {
        resolved._parts.path = base._parts.path;
        if (!resolved._parts.query) {
          resolved._parts.query = base._parts.query;
        }
      } else {
        if (resolved._parts.path.substring(-2) === "..") {
          resolved._parts.path += "/";
        }
        if (resolved.path().charAt(0) !== "/") {
          basedir = base.directory();
          basedir = basedir ? basedir : base.path().indexOf("/") === 0 ? "/" : "";
          resolved._parts.path = (basedir ? basedir + "/" : "") + resolved._parts.path;
          resolved.normalizePath();
        }
      }
      resolved.build();
      return resolved;
    };
    p2.relativeTo = function(base) {
      var relative = this.clone().normalize();
      var relativeParts, baseParts, common2, relativePath, basePath;
      if (relative._parts.urn) {
        throw new Error("URNs do not have any generally defined hierarchical components");
      }
      base = new URI2(base).normalize();
      relativeParts = relative._parts;
      baseParts = base._parts;
      relativePath = relative.path();
      basePath = base.path();
      if (relativePath.charAt(0) !== "/") {
        throw new Error("URI is already relative");
      }
      if (basePath.charAt(0) !== "/") {
        throw new Error("Cannot calculate a URI relative to another relative URI");
      }
      if (relativeParts.protocol === baseParts.protocol) {
        relativeParts.protocol = null;
      }
      if (relativeParts.username !== baseParts.username || relativeParts.password !== baseParts.password) {
        return relative.build();
      }
      if (relativeParts.protocol !== null || relativeParts.username !== null || relativeParts.password !== null) {
        return relative.build();
      }
      if (relativeParts.hostname === baseParts.hostname && relativeParts.port === baseParts.port) {
        relativeParts.hostname = null;
        relativeParts.port = null;
      } else {
        return relative.build();
      }
      if (relativePath === basePath) {
        relativeParts.path = "";
        return relative.build();
      }
      common2 = URI2.commonPath(relativePath, basePath);
      if (!common2) {
        return relative.build();
      }
      var parents = baseParts.path.substring(common2.length).replace(/[^\/]*$/, "").replace(/.*?\//g, "../");
      relativeParts.path = parents + relativeParts.path.substring(common2.length) || "./";
      return relative.build();
    };
    p2.equals = function(uri) {
      var one = this.clone();
      var two = new URI2(uri);
      var one_map = {};
      var two_map = {};
      var checked = {};
      var one_query, two_query, key;
      one.normalize();
      two.normalize();
      if (one.toString() === two.toString()) {
        return true;
      }
      one_query = one.query();
      two_query = two.query();
      one.query("");
      two.query("");
      if (one.toString() !== two.toString()) {
        return false;
      }
      if (one_query.length !== two_query.length) {
        return false;
      }
      one_map = URI2.parseQuery(one_query, this._parts.escapeQuerySpace);
      two_map = URI2.parseQuery(two_query, this._parts.escapeQuerySpace);
      for (key in one_map) {
        if (hasOwn.call(one_map, key)) {
          if (!isArray(one_map[key])) {
            if (one_map[key] !== two_map[key]) {
              return false;
            }
          } else if (!arraysEqual(one_map[key], two_map[key])) {
            return false;
          }
          checked[key] = true;
        }
      }
      for (key in two_map) {
        if (hasOwn.call(two_map, key)) {
          if (!checked[key]) {
            return false;
          }
        }
      }
      return true;
    };
    p2.preventInvalidHostname = function(v7) {
      this._parts.preventInvalidHostname = !!v7;
      return this;
    };
    p2.duplicateQueryParameters = function(v7) {
      this._parts.duplicateQueryParameters = !!v7;
      return this;
    };
    p2.escapeQuerySpace = function(v7) {
      this._parts.escapeQuerySpace = !!v7;
      return this;
    };
    return URI2;
  });
});

// node_modules/cesium/Source/Core/getAbsoluteUri.js
function getAbsoluteUri(relative, base) {
  let documentObject;
  if (typeof document !== "undefined") {
    documentObject = document;
  }
  return getAbsoluteUri._implementation(relative, base, documentObject);
}
getAbsoluteUri._implementation = function(relative, base, documentObject) {
  if (!defined_default(relative)) {
    throw new DeveloperError_default("relative uri is required.");
  }
  if (!defined_default(base)) {
    if (typeof documentObject === "undefined") {
      return relative;
    }
    base = defaultValue_default(documentObject.baseURI, documentObject.location.href);
  }
  const relativeUri = new URI(relative);
  if (relativeUri.scheme() !== "") {
    return relativeUri.toString();
  }
  return relativeUri.absoluteTo(base).toString();
};
var getAbsoluteUri_default = getAbsoluteUri;

// node_modules/cesium/Source/Core/appendForwardSlash.js
function appendForwardSlash(url2) {
  if (url2.length === 0 || url2[url2.length - 1] !== "/") {
    url2 = `${url2}/`;
  }
  return url2;
}
var appendForwardSlash_default = appendForwardSlash;

// node_modules/cesium/Source/Core/clone.js
function clone(object2, deep) {
  if (object2 === null || typeof object2 !== "object") {
    return object2;
  }
  deep = defaultValue_default(deep, false);
  const result = new object2.constructor();
  for (const propertyName in object2) {
    if (object2.hasOwnProperty(propertyName)) {
      let value = object2[propertyName];
      if (deep) {
        value = clone(value, deep);
      }
      result[propertyName] = value;
    }
  }
  return result;
}
var clone_default = clone;

// node_modules/cesium/Source/Core/combine.js
function combine(object1, object2, deep) {
  deep = defaultValue_default(deep, false);
  const result = {};
  const object1Defined = defined_default(object1);
  const object2Defined = defined_default(object2);
  let property;
  let object1Value;
  let object2Value;
  if (object1Defined) {
    for (property in object1) {
      if (object1.hasOwnProperty(property)) {
        object1Value = object1[property];
        if (object2Defined && deep && typeof object1Value === "object" && object2.hasOwnProperty(property)) {
          object2Value = object2[property];
          if (typeof object2Value === "object") {
            result[property] = combine(object1Value, object2Value, deep);
          } else {
            result[property] = object1Value;
          }
        } else {
          result[property] = object1Value;
        }
      }
    }
  }
  if (object2Defined) {
    for (property in object2) {
      if (object2.hasOwnProperty(property) && !result.hasOwnProperty(property)) {
        object2Value = object2[property];
        result[property] = object2Value;
      }
    }
  }
  return result;
}
var combine_default = combine;

// node_modules/cesium/Source/Core/defer.js
function defer() {
  let resolve2;
  let reject;
  const promise = new Promise(function(res, rej) {
    resolve2 = res;
    reject = rej;
  });
  return {
    resolve: resolve2,
    reject,
    promise
  };
}
var defer_default = defer;

// node_modules/cesium/Source/Core/getBaseUri.js
function getBaseUri(uri, includeQuery) {
  if (!defined_default(uri)) {
    throw new DeveloperError_default("uri is required.");
  }
  let basePath = "";
  const i2 = uri.lastIndexOf("/");
  if (i2 !== -1) {
    basePath = uri.substring(0, i2 + 1);
  }
  if (!includeQuery) {
    return basePath;
  }
  uri = new URI(uri);
  if (uri.query().length !== 0) {
    basePath += `?${uri.query()}`;
  }
  if (uri.fragment().length !== 0) {
    basePath += `#${uri.fragment()}`;
  }
  return basePath;
}
var getBaseUri_default = getBaseUri;

// node_modules/cesium/Source/Core/getExtensionFromUri.js
function getExtensionFromUri(uri) {
  if (!defined_default(uri)) {
    throw new DeveloperError_default("uri is required.");
  }
  const uriObject = new URI(uri);
  uriObject.normalize();
  let path = uriObject.path();
  let index2 = path.lastIndexOf("/");
  if (index2 !== -1) {
    path = path.substr(index2 + 1);
  }
  index2 = path.lastIndexOf(".");
  if (index2 === -1) {
    path = "";
  } else {
    path = path.substr(index2 + 1);
  }
  return path;
}
var getExtensionFromUri_default = getExtensionFromUri;

// node_modules/cesium/Source/Core/getImagePixels.js
var context2DsByWidthAndHeight = {};
function getImagePixels(image, width, height) {
  if (!defined_default(width)) {
    width = image.width;
  }
  if (!defined_default(height)) {
    height = image.height;
  }
  let context2DsByHeight = context2DsByWidthAndHeight[width];
  if (!defined_default(context2DsByHeight)) {
    context2DsByHeight = {};
    context2DsByWidthAndHeight[width] = context2DsByHeight;
  }
  let context2d = context2DsByHeight[height];
  if (!defined_default(context2d)) {
    const canvas = document.createElement("canvas");
    canvas.width = width;
    canvas.height = height;
    context2d = canvas.getContext("2d");
    context2d.globalCompositeOperation = "copy";
    context2DsByHeight[height] = context2d;
  }
  context2d.drawImage(image, 0, 0, width, height);
  return context2d.getImageData(0, 0, width, height).data;
}
var getImagePixels_default = getImagePixels;

// node_modules/cesium/Source/Core/isBlobUri.js
var blobUriRegex = /^blob:/i;
function isBlobUri(uri) {
  Check_default.typeOf.string("uri", uri);
  return blobUriRegex.test(uri);
}
var isBlobUri_default = isBlobUri;

// node_modules/cesium/Source/Core/isCrossOriginUrl.js
var a;
function isCrossOriginUrl(url2) {
  if (!defined_default(a)) {
    a = document.createElement("a");
  }
  a.href = window.location.href;
  const host = a.host;
  const protocol = a.protocol;
  a.href = url2;
  a.href = a.href;
  return protocol !== a.protocol || host !== a.host;
}
var isCrossOriginUrl_default = isCrossOriginUrl;

// node_modules/cesium/Source/Core/isDataUri.js
var dataUriRegex = /^data:/i;
function isDataUri(uri) {
  Check_default.typeOf.string("uri", uri);
  return dataUriRegex.test(uri);
}
var isDataUri_default = isDataUri;

// node_modules/cesium/Source/Core/loadAndExecuteScript.js
function loadAndExecuteScript(url2) {
  const deferred = defer_default();
  const script = document.createElement("script");
  script.async = true;
  script.src = url2;
  const head = document.getElementsByTagName("head")[0];
  script.onload = function() {
    script.onload = void 0;
    head.removeChild(script);
    deferred.resolve();
  };
  script.onerror = function(e2) {
    deferred.reject(e2);
  };
  head.appendChild(script);
  return deferred.promise;
}
var loadAndExecuteScript_default = loadAndExecuteScript;

// node_modules/cesium/Source/Core/objectToQuery.js
function objectToQuery(obj) {
  if (!defined_default(obj)) {
    throw new DeveloperError_default("obj is required.");
  }
  let result = "";
  for (const propName in obj) {
    if (obj.hasOwnProperty(propName)) {
      const value = obj[propName];
      const part = `${encodeURIComponent(propName)}=`;
      if (Array.isArray(value)) {
        for (let i2 = 0, len = value.length; i2 < len; ++i2) {
          result += `${part + encodeURIComponent(value[i2])}&`;
        }
      } else {
        result += `${part + encodeURIComponent(value)}&`;
      }
    }
  }
  result = result.slice(0, -1);
  return result;
}
var objectToQuery_default = objectToQuery;

// node_modules/cesium/Source/Core/queryToObject.js
function queryToObject(queryString) {
  if (!defined_default(queryString)) {
    throw new DeveloperError_default("queryString is required.");
  }
  const result = {};
  if (queryString === "") {
    return result;
  }
  const parts = queryString.replace(/\+/g, "%20").split(/[&;]/);
  for (let i2 = 0, len = parts.length; i2 < len; ++i2) {
    const subparts = parts[i2].split("=");
    const name = decodeURIComponent(subparts[0]);
    let value = subparts[1];
    if (defined_default(value)) {
      value = decodeURIComponent(value);
    } else {
      value = "";
    }
    const resultValue = result[name];
    if (typeof resultValue === "string") {
      result[name] = [resultValue, value];
    } else if (Array.isArray(resultValue)) {
      resultValue.push(value);
    } else {
      result[name] = value;
    }
  }
  return result;
}
var queryToObject_default = queryToObject;

// node_modules/cesium/Source/Core/RequestState.js
var RequestState = {
  UNISSUED: 0,
  ISSUED: 1,
  ACTIVE: 2,
  RECEIVED: 3,
  CANCELLED: 4,
  FAILED: 5
};
var RequestState_default = Object.freeze(RequestState);

// node_modules/cesium/Source/Core/RequestType.js
var RequestType = {
  TERRAIN: 0,
  IMAGERY: 1,
  TILES3D: 2,
  OTHER: 3
};
var RequestType_default = Object.freeze(RequestType);

// node_modules/cesium/Source/Core/Request.js
function Request(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const throttleByServer = defaultValue_default(options.throttleByServer, false);
  const throttle = defaultValue_default(options.throttle, false);
  this.url = options.url;
  this.requestFunction = options.requestFunction;
  this.cancelFunction = options.cancelFunction;
  this.priorityFunction = options.priorityFunction;
  this.priority = defaultValue_default(options.priority, 0);
  this.throttle = throttle;
  this.throttleByServer = throttleByServer;
  this.type = defaultValue_default(options.type, RequestType_default.OTHER);
  this.serverKey = void 0;
  this.state = RequestState_default.UNISSUED;
  this.deferred = void 0;
  this.cancelled = false;
}
Request.prototype.cancel = function() {
  this.cancelled = true;
};
Request.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new Request(this);
  }
  result.url = this.url;
  result.requestFunction = this.requestFunction;
  result.cancelFunction = this.cancelFunction;
  result.priorityFunction = this.priorityFunction;
  result.priority = this.priority;
  result.throttle = this.throttle;
  result.throttleByServer = this.throttleByServer;
  result.type = this.type;
  result.serverKey = this.serverKey;
  result.state = this.RequestState.UNISSUED;
  result.deferred = void 0;
  result.cancelled = false;
  return result;
};
var Request_default = Request;

// node_modules/cesium/Source/Core/parseResponseHeaders.js
function parseResponseHeaders(headerString) {
  const headers = {};
  if (!headerString) {
    return headers;
  }
  const headerPairs = headerString.split("\r\n");
  for (let i2 = 0; i2 < headerPairs.length; ++i2) {
    const headerPair = headerPairs[i2];
    const index2 = headerPair.indexOf(": ");
    if (index2 > 0) {
      const key = headerPair.substring(0, index2);
      const val = headerPair.substring(index2 + 2);
      headers[key] = val;
    }
  }
  return headers;
}
var parseResponseHeaders_default = parseResponseHeaders;

// node_modules/cesium/Source/Core/RequestErrorEvent.js
function RequestErrorEvent(statusCode, response, responseHeaders) {
  this.statusCode = statusCode;
  this.response = response;
  this.responseHeaders = responseHeaders;
  if (typeof this.responseHeaders === "string") {
    this.responseHeaders = parseResponseHeaders_default(this.responseHeaders);
  }
}
RequestErrorEvent.prototype.toString = function() {
  let str = "Request has failed.";
  if (defined_default(this.statusCode)) {
    str += ` Status Code: ${this.statusCode}`;
  }
  return str;
};
var RequestErrorEvent_default = RequestErrorEvent;

// node_modules/cesium/Source/Core/Event.js
function Event() {
  this._listeners = [];
  this._scopes = [];
  this._toRemove = [];
  this._insideRaiseEvent = false;
}
Object.defineProperties(Event.prototype, {
  numberOfListeners: {
    get: function() {
      return this._listeners.length - this._toRemove.length;
    }
  }
});
Event.prototype.addEventListener = function(listener, scope) {
  Check_default.typeOf.func("listener", listener);
  this._listeners.push(listener);
  this._scopes.push(scope);
  const event = this;
  return function() {
    event.removeEventListener(listener, scope);
  };
};
Event.prototype.removeEventListener = function(listener, scope) {
  Check_default.typeOf.func("listener", listener);
  const listeners = this._listeners;
  const scopes = this._scopes;
  let index2 = -1;
  for (let i2 = 0; i2 < listeners.length; i2++) {
    if (listeners[i2] === listener && scopes[i2] === scope) {
      index2 = i2;
      break;
    }
  }
  if (index2 !== -1) {
    if (this._insideRaiseEvent) {
      this._toRemove.push(index2);
      listeners[index2] = void 0;
      scopes[index2] = void 0;
    } else {
      listeners.splice(index2, 1);
      scopes.splice(index2, 1);
    }
    return true;
  }
  return false;
};
function compareNumber(a4, b) {
  return b - a4;
}
Event.prototype.raiseEvent = function() {
  this._insideRaiseEvent = true;
  let i2;
  const listeners = this._listeners;
  const scopes = this._scopes;
  let length3 = listeners.length;
  for (i2 = 0; i2 < length3; i2++) {
    const listener = listeners[i2];
    if (defined_default(listener)) {
      listeners[i2].apply(scopes[i2], arguments);
    }
  }
  const toRemove = this._toRemove;
  length3 = toRemove.length;
  if (length3 > 0) {
    toRemove.sort(compareNumber);
    for (i2 = 0; i2 < length3; i2++) {
      const index2 = toRemove[i2];
      listeners.splice(index2, 1);
      scopes.splice(index2, 1);
    }
    toRemove.length = 0;
  }
  this._insideRaiseEvent = false;
};
var Event_default = Event;

// node_modules/cesium/Source/Core/Heap.js
function Heap(options) {
  Check_default.typeOf.object("options", options);
  Check_default.defined("options.comparator", options.comparator);
  this._comparator = options.comparator;
  this._array = [];
  this._length = 0;
  this._maximumLength = void 0;
}
Object.defineProperties(Heap.prototype, {
  length: {
    get: function() {
      return this._length;
    }
  },
  internalArray: {
    get: function() {
      return this._array;
    }
  },
  maximumLength: {
    get: function() {
      return this._maximumLength;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("maximumLength", value, 0);
      const originalLength = this._length;
      if (value < originalLength) {
        const array = this._array;
        for (let i2 = value; i2 < originalLength; ++i2) {
          array[i2] = void 0;
        }
        this._length = value;
        array.length = value;
      }
      this._maximumLength = value;
    }
  },
  comparator: {
    get: function() {
      return this._comparator;
    }
  }
});
function swap(array, a4, b) {
  const temp = array[a4];
  array[a4] = array[b];
  array[b] = temp;
}
Heap.prototype.reserve = function(length3) {
  length3 = defaultValue_default(length3, this._length);
  this._array.length = length3;
};
Heap.prototype.heapify = function(index2) {
  index2 = defaultValue_default(index2, 0);
  const length3 = this._length;
  const comparator = this._comparator;
  const array = this._array;
  let candidate = -1;
  let inserting = true;
  while (inserting) {
    const right = 2 * (index2 + 1);
    const left = right - 1;
    if (left < length3 && comparator(array[left], array[index2]) < 0) {
      candidate = left;
    } else {
      candidate = index2;
    }
    if (right < length3 && comparator(array[right], array[candidate]) < 0) {
      candidate = right;
    }
    if (candidate !== index2) {
      swap(array, candidate, index2);
      index2 = candidate;
    } else {
      inserting = false;
    }
  }
};
Heap.prototype.resort = function() {
  const length3 = this._length;
  for (let i2 = Math.ceil(length3 / 2); i2 >= 0; --i2) {
    this.heapify(i2);
  }
};
Heap.prototype.insert = function(element) {
  Check_default.defined("element", element);
  const array = this._array;
  const comparator = this._comparator;
  const maximumLength = this._maximumLength;
  let index2 = this._length++;
  if (index2 < array.length) {
    array[index2] = element;
  } else {
    array.push(element);
  }
  while (index2 !== 0) {
    const parent = Math.floor((index2 - 1) / 2);
    if (comparator(array[index2], array[parent]) < 0) {
      swap(array, index2, parent);
      index2 = parent;
    } else {
      break;
    }
  }
  let removedElement;
  if (defined_default(maximumLength) && this._length > maximumLength) {
    removedElement = array[maximumLength];
    this._length = maximumLength;
  }
  return removedElement;
};
Heap.prototype.pop = function(index2) {
  index2 = defaultValue_default(index2, 0);
  if (this._length === 0) {
    return void 0;
  }
  Check_default.typeOf.number.lessThan("index", index2, this._length);
  const array = this._array;
  const root = array[index2];
  swap(array, index2, --this._length);
  this.heapify(index2);
  array[this._length] = void 0;
  return root;
};
var Heap_default = Heap;

// node_modules/cesium/Source/Core/RequestScheduler.js
function sortRequests(a4, b) {
  return a4.priority - b.priority;
}
var statistics = {
  numberOfAttemptedRequests: 0,
  numberOfActiveRequests: 0,
  numberOfCancelledRequests: 0,
  numberOfCancelledActiveRequests: 0,
  numberOfFailedRequests: 0,
  numberOfActiveRequestsEver: 0,
  lastNumberOfActiveRequests: 0
};
var priorityHeapLength = 20;
var requestHeap = new Heap_default({
  comparator: sortRequests
});
requestHeap.maximumLength = priorityHeapLength;
requestHeap.reserve(priorityHeapLength);
var activeRequests = [];
var numberOfActiveRequestsByServer = {};
var pageUri = typeof document !== "undefined" ? new URI(document.location.href) : new URI();
var requestCompletedEvent = new Event_default();
function RequestScheduler() {
}
RequestScheduler.maximumRequests = 50;
RequestScheduler.maximumRequestsPerServer = 6;
RequestScheduler.requestsByServer = {
  "api.cesium.com:443": 18,
  "assets.cesium.com:443": 18
};
RequestScheduler.throttleRequests = true;
RequestScheduler.debugShowStatistics = false;
RequestScheduler.requestCompletedEvent = requestCompletedEvent;
Object.defineProperties(RequestScheduler, {
  statistics: {
    get: function() {
      return statistics;
    }
  },
  priorityHeapLength: {
    get: function() {
      return priorityHeapLength;
    },
    set: function(value) {
      if (value < priorityHeapLength) {
        while (requestHeap.length > value) {
          const request = requestHeap.pop();
          cancelRequest(request);
        }
      }
      priorityHeapLength = value;
      requestHeap.maximumLength = value;
      requestHeap.reserve(value);
    }
  }
});
function updatePriority(request) {
  if (defined_default(request.priorityFunction)) {
    request.priority = request.priorityFunction();
  }
}
RequestScheduler.serverHasOpenSlots = function(serverKey, desiredRequests) {
  desiredRequests = defaultValue_default(desiredRequests, 1);
  const maxRequests = defaultValue_default(
    RequestScheduler.requestsByServer[serverKey],
    RequestScheduler.maximumRequestsPerServer
  );
  const hasOpenSlotsServer = numberOfActiveRequestsByServer[serverKey] + desiredRequests <= maxRequests;
  return hasOpenSlotsServer;
};
RequestScheduler.heapHasOpenSlots = function(desiredRequests) {
  const hasOpenSlotsHeap = requestHeap.length + desiredRequests <= priorityHeapLength;
  return hasOpenSlotsHeap;
};
function issueRequest(request) {
  if (request.state === RequestState_default.UNISSUED) {
    request.state = RequestState_default.ISSUED;
    request.deferred = defer_default();
  }
  return request.deferred.promise;
}
function getRequestReceivedFunction(request) {
  return function(results) {
    if (request.state === RequestState_default.CANCELLED) {
      return;
    }
    const deferred = request.deferred;
    --statistics.numberOfActiveRequests;
    --numberOfActiveRequestsByServer[request.serverKey];
    requestCompletedEvent.raiseEvent();
    request.state = RequestState_default.RECEIVED;
    request.deferred = void 0;
    deferred.resolve(results);
  };
}
function getRequestFailedFunction(request) {
  return function(error) {
    if (request.state === RequestState_default.CANCELLED) {
      return;
    }
    ++statistics.numberOfFailedRequests;
    --statistics.numberOfActiveRequests;
    --numberOfActiveRequestsByServer[request.serverKey];
    requestCompletedEvent.raiseEvent(error);
    request.state = RequestState_default.FAILED;
    request.deferred.reject(error);
  };
}
function startRequest(request) {
  const promise = issueRequest(request);
  request.state = RequestState_default.ACTIVE;
  activeRequests.push(request);
  ++statistics.numberOfActiveRequests;
  ++statistics.numberOfActiveRequestsEver;
  ++numberOfActiveRequestsByServer[request.serverKey];
  request.requestFunction().then(getRequestReceivedFunction(request)).catch(getRequestFailedFunction(request));
  return promise;
}
function cancelRequest(request) {
  const active = request.state === RequestState_default.ACTIVE;
  request.state = RequestState_default.CANCELLED;
  ++statistics.numberOfCancelledRequests;
  if (defined_default(request.deferred)) {
    const deferred = request.deferred;
    request.deferred = void 0;
    deferred.reject();
  }
  if (active) {
    --statistics.numberOfActiveRequests;
    --numberOfActiveRequestsByServer[request.serverKey];
    ++statistics.numberOfCancelledActiveRequests;
  }
  if (defined_default(request.cancelFunction)) {
    request.cancelFunction();
  }
}
RequestScheduler.update = function() {
  let i2;
  let request;
  let removeCount = 0;
  const activeLength = activeRequests.length;
  for (i2 = 0; i2 < activeLength; ++i2) {
    request = activeRequests[i2];
    if (request.cancelled) {
      cancelRequest(request);
    }
    if (request.state !== RequestState_default.ACTIVE) {
      ++removeCount;
      continue;
    }
    if (removeCount > 0) {
      activeRequests[i2 - removeCount] = request;
    }
  }
  activeRequests.length -= removeCount;
  const issuedRequests = requestHeap.internalArray;
  const issuedLength = requestHeap.length;
  for (i2 = 0; i2 < issuedLength; ++i2) {
    updatePriority(issuedRequests[i2]);
  }
  requestHeap.resort();
  const openSlots = Math.max(
    RequestScheduler.maximumRequests - activeRequests.length,
    0
  );
  let filledSlots = 0;
  while (filledSlots < openSlots && requestHeap.length > 0) {
    request = requestHeap.pop();
    if (request.cancelled) {
      cancelRequest(request);
      continue;
    }
    if (request.throttleByServer && !RequestScheduler.serverHasOpenSlots(request.serverKey)) {
      cancelRequest(request);
      continue;
    }
    startRequest(request);
    ++filledSlots;
  }
  updateStatistics();
};
RequestScheduler.getServerKey = function(url2) {
  Check_default.typeOf.string("url", url2);
  let uri = new URI(url2);
  if (uri.scheme() === "") {
    uri = new URI(url2).absoluteTo(pageUri);
    uri.normalize();
  }
  let serverKey = uri.authority();
  if (!/:/.test(serverKey)) {
    serverKey = `${serverKey}:${uri.scheme() === "https" ? "443" : "80"}`;
  }
  const length3 = numberOfActiveRequestsByServer[serverKey];
  if (!defined_default(length3)) {
    numberOfActiveRequestsByServer[serverKey] = 0;
  }
  return serverKey;
};
RequestScheduler.request = function(request) {
  Check_default.typeOf.object("request", request);
  Check_default.typeOf.string("request.url", request.url);
  Check_default.typeOf.func("request.requestFunction", request.requestFunction);
  if (isDataUri_default(request.url) || isBlobUri_default(request.url)) {
    requestCompletedEvent.raiseEvent();
    request.state = RequestState_default.RECEIVED;
    return request.requestFunction();
  }
  ++statistics.numberOfAttemptedRequests;
  if (!defined_default(request.serverKey)) {
    request.serverKey = RequestScheduler.getServerKey(request.url);
  }
  if (RequestScheduler.throttleRequests && request.throttleByServer && !RequestScheduler.serverHasOpenSlots(request.serverKey)) {
    return void 0;
  }
  if (!RequestScheduler.throttleRequests || !request.throttle) {
    return startRequest(request);
  }
  if (activeRequests.length >= RequestScheduler.maximumRequests) {
    return void 0;
  }
  updatePriority(request);
  const removedRequest = requestHeap.insert(request);
  if (defined_default(removedRequest)) {
    if (removedRequest === request) {
      return void 0;
    }
    cancelRequest(removedRequest);
  }
  return issueRequest(request);
};
function updateStatistics() {
  if (!RequestScheduler.debugShowStatistics) {
    return;
  }
  if (statistics.numberOfActiveRequests === 0 && statistics.lastNumberOfActiveRequests > 0) {
    if (statistics.numberOfAttemptedRequests > 0) {
      console.log(
        `Number of attempted requests: ${statistics.numberOfAttemptedRequests}`
      );
      statistics.numberOfAttemptedRequests = 0;
    }
    if (statistics.numberOfCancelledRequests > 0) {
      console.log(
        `Number of cancelled requests: ${statistics.numberOfCancelledRequests}`
      );
      statistics.numberOfCancelledRequests = 0;
    }
    if (statistics.numberOfCancelledActiveRequests > 0) {
      console.log(
        `Number of cancelled active requests: ${statistics.numberOfCancelledActiveRequests}`
      );
      statistics.numberOfCancelledActiveRequests = 0;
    }
    if (statistics.numberOfFailedRequests > 0) {
      console.log(
        `Number of failed requests: ${statistics.numberOfFailedRequests}`
      );
      statistics.numberOfFailedRequests = 0;
    }
  }
  statistics.lastNumberOfActiveRequests = statistics.numberOfActiveRequests;
}
RequestScheduler.clearForSpecs = function() {
  while (requestHeap.length > 0) {
    const request = requestHeap.pop();
    cancelRequest(request);
  }
  const length3 = activeRequests.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    cancelRequest(activeRequests[i2]);
  }
  activeRequests.length = 0;
  numberOfActiveRequestsByServer = {};
  statistics.numberOfAttemptedRequests = 0;
  statistics.numberOfActiveRequests = 0;
  statistics.numberOfCancelledRequests = 0;
  statistics.numberOfCancelledActiveRequests = 0;
  statistics.numberOfFailedRequests = 0;
  statistics.numberOfActiveRequestsEver = 0;
  statistics.lastNumberOfActiveRequests = 0;
};
RequestScheduler.numberOfActiveRequestsByServer = function(serverKey) {
  return numberOfActiveRequestsByServer[serverKey];
};
RequestScheduler.requestHeap = requestHeap;
var RequestScheduler_default = RequestScheduler;

// node_modules/cesium/Source/Core/TrustedServers.js
var TrustedServers = {};
var _servers = {};
TrustedServers.add = function(host, port) {
  if (!defined_default(host)) {
    throw new DeveloperError_default("host is required.");
  }
  if (!defined_default(port) || port <= 0) {
    throw new DeveloperError_default("port is required to be greater than 0.");
  }
  const authority = `${host.toLowerCase()}:${port}`;
  if (!defined_default(_servers[authority])) {
    _servers[authority] = true;
  }
};
TrustedServers.remove = function(host, port) {
  if (!defined_default(host)) {
    throw new DeveloperError_default("host is required.");
  }
  if (!defined_default(port) || port <= 0) {
    throw new DeveloperError_default("port is required to be greater than 0.");
  }
  const authority = `${host.toLowerCase()}:${port}`;
  if (defined_default(_servers[authority])) {
    delete _servers[authority];
  }
};
function getAuthority(url2) {
  const uri = new URI(url2);
  uri.normalize();
  let authority = uri.authority();
  if (authority.length === 0) {
    return void 0;
  }
  uri.authority(authority);
  if (authority.indexOf("@") !== -1) {
    const parts = authority.split("@");
    authority = parts[1];
  }
  if (authority.indexOf(":") === -1) {
    let scheme = uri.scheme();
    if (scheme.length === 0) {
      scheme = window.location.protocol;
      scheme = scheme.substring(0, scheme.length - 1);
    }
    if (scheme === "http") {
      authority += ":80";
    } else if (scheme === "https") {
      authority += ":443";
    } else {
      return void 0;
    }
  }
  return authority;
}
TrustedServers.contains = function(url2) {
  if (!defined_default(url2)) {
    throw new DeveloperError_default("url is required.");
  }
  const authority = getAuthority(url2);
  if (defined_default(authority) && defined_default(_servers[authority])) {
    return true;
  }
  return false;
};
TrustedServers.clear = function() {
  _servers = {};
};
var TrustedServers_default = TrustedServers;

// node_modules/cesium/Source/Core/Resource.js
var xhrBlobSupported = function() {
  try {
    const xhr = new XMLHttpRequest();
    xhr.open("GET", "#", true);
    xhr.responseType = "blob";
    return xhr.responseType === "blob";
  } catch (e2) {
    return false;
  }
}();
function parseQuery(uri, resource, merge3, preserveQueryParameters) {
  const queryString = uri.query();
  if (queryString.length === 0) {
    return {};
  }
  let query;
  if (queryString.indexOf("=") === -1) {
    const result = {};
    result[queryString] = void 0;
    query = result;
  } else {
    query = queryToObject_default(queryString);
  }
  if (merge3) {
    resource._queryParameters = combineQueryParameters(
      query,
      resource._queryParameters,
      preserveQueryParameters
    );
  } else {
    resource._queryParameters = query;
  }
  uri.search("");
}
function stringifyQuery(uri, resource) {
  const queryObject = resource._queryParameters;
  const keys = Object.keys(queryObject);
  if (keys.length === 1 && !defined_default(queryObject[keys[0]])) {
    uri.search(keys[0]);
  } else {
    uri.search(objectToQuery_default(queryObject));
  }
}
function defaultClone(val, defaultVal) {
  if (!defined_default(val)) {
    return defaultVal;
  }
  return defined_default(val.clone) ? val.clone() : clone_default(val);
}
function checkAndResetRequest(request) {
  if (request.state === RequestState_default.ISSUED || request.state === RequestState_default.ACTIVE) {
    throw new RuntimeError_default("The Resource is already being fetched.");
  }
  request.state = RequestState_default.UNISSUED;
  request.deferred = void 0;
}
function combineQueryParameters(q12, q22, preserveQueryParameters) {
  if (!preserveQueryParameters) {
    return combine_default(q12, q22);
  }
  const result = clone_default(q12, true);
  for (const param in q22) {
    if (q22.hasOwnProperty(param)) {
      let value = result[param];
      const q2Value = q22[param];
      if (defined_default(value)) {
        if (!Array.isArray(value)) {
          value = result[param] = [value];
        }
        result[param] = value.concat(q2Value);
      } else {
        result[param] = Array.isArray(q2Value) ? q2Value.slice() : q2Value;
      }
    }
  }
  return result;
}
function Resource(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (typeof options === "string") {
    options = {
      url: options
    };
  }
  Check_default.typeOf.string("options.url", options.url);
  this._url = void 0;
  this._templateValues = defaultClone(options.templateValues, {});
  this._queryParameters = defaultClone(options.queryParameters, {});
  this.headers = defaultClone(options.headers, {});
  this.request = defaultValue_default(options.request, new Request_default());
  this.proxy = options.proxy;
  this.retryCallback = options.retryCallback;
  this.retryAttempts = defaultValue_default(options.retryAttempts, 0);
  this._retryCount = 0;
  const uri = new URI(options.url);
  parseQuery(uri, this, true, true);
  uri.fragment("");
  this._url = uri.toString();
}
Resource.createIfNeeded = function(resource) {
  if (resource instanceof Resource) {
    return resource.getDerivedResource({
      request: resource.request
    });
  }
  if (typeof resource !== "string") {
    return resource;
  }
  return new Resource({
    url: resource
  });
};
var supportsImageBitmapOptionsPromise;
Resource.supportsImageBitmapOptions = function() {
  if (defined_default(supportsImageBitmapOptionsPromise)) {
    return supportsImageBitmapOptionsPromise;
  }
  if (typeof createImageBitmap !== "function") {
    supportsImageBitmapOptionsPromise = Promise.resolve(false);
    return supportsImageBitmapOptionsPromise;
  }
  const imageDataUri = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAABGdBTUEAAE4g3rEiDgAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADElEQVQI12Ng6GAAAAEUAIngE3ZiAAAAAElFTkSuQmCC";
  supportsImageBitmapOptionsPromise = Resource.fetchBlob({
    url: imageDataUri
  }).then(function(blob) {
    const imageBitmapOptions = {
      imageOrientation: "flipY",
      premultiplyAlpha: "none",
      colorSpaceConversion: "none"
    };
    return Promise.all([
      createImageBitmap(blob, imageBitmapOptions),
      createImageBitmap(blob)
    ]);
  }).then(function(imageBitmaps) {
    const colorWithOptions = getImagePixels_default(imageBitmaps[0]);
    const colorWithDefaults = getImagePixels_default(imageBitmaps[1]);
    return colorWithOptions[1] !== colorWithDefaults[1];
  }).catch(function() {
    return false;
  });
  return supportsImageBitmapOptionsPromise;
};
Object.defineProperties(Resource, {
  isBlobSupported: {
    get: function() {
      return xhrBlobSupported;
    }
  }
});
Object.defineProperties(Resource.prototype, {
  queryParameters: {
    get: function() {
      return this._queryParameters;
    }
  },
  templateValues: {
    get: function() {
      return this._templateValues;
    }
  },
  url: {
    get: function() {
      return this.getUrlComponent(true, true);
    },
    set: function(value) {
      const uri = new URI(value);
      parseQuery(uri, this, false);
      uri.fragment("");
      this._url = uri.toString();
    }
  },
  extension: {
    get: function() {
      return getExtensionFromUri_default(this._url);
    }
  },
  isDataUri: {
    get: function() {
      return isDataUri_default(this._url);
    }
  },
  isBlobUri: {
    get: function() {
      return isBlobUri_default(this._url);
    }
  },
  isCrossOriginUrl: {
    get: function() {
      return isCrossOriginUrl_default(this._url);
    }
  },
  hasHeaders: {
    get: function() {
      return Object.keys(this.headers).length > 0;
    }
  }
});
Resource.prototype.toString = function() {
  return this.getUrlComponent(true, true);
};
Resource.prototype.getUrlComponent = function(query, proxy) {
  if (this.isDataUri) {
    return this._url;
  }
  const uri = new URI(this._url);
  if (query) {
    stringifyQuery(uri, this);
  }
  let url2 = uri.toString().replace(/%7B/g, "{").replace(/%7D/g, "}");
  const templateValues = this._templateValues;
  url2 = url2.replace(/{(.*?)}/g, function(match, key) {
    const replacement = templateValues[key];
    if (defined_default(replacement)) {
      return encodeURIComponent(replacement);
    }
    return match;
  });
  if (proxy && defined_default(this.proxy)) {
    url2 = this.proxy.getURL(url2);
  }
  return url2;
};
Resource.prototype.setQueryParameters = function(params, useAsDefault) {
  if (useAsDefault) {
    this._queryParameters = combineQueryParameters(
      this._queryParameters,
      params,
      false
    );
  } else {
    this._queryParameters = combineQueryParameters(
      params,
      this._queryParameters,
      false
    );
  }
};
Resource.prototype.appendQueryParameters = function(params) {
  this._queryParameters = combineQueryParameters(
    params,
    this._queryParameters,
    true
  );
};
Resource.prototype.setTemplateValues = function(template, useAsDefault) {
  if (useAsDefault) {
    this._templateValues = combine_default(this._templateValues, template);
  } else {
    this._templateValues = combine_default(template, this._templateValues);
  }
};
Resource.prototype.getDerivedResource = function(options) {
  const resource = this.clone();
  resource._retryCount = 0;
  if (defined_default(options.url)) {
    const uri = new URI(options.url);
    const preserveQueryParameters = defaultValue_default(
      options.preserveQueryParameters,
      false
    );
    parseQuery(uri, resource, true, preserveQueryParameters);
    uri.fragment("");
    if (uri.scheme() !== "") {
      resource._url = uri.toString();
    } else {
      resource._url = uri.absoluteTo(new URI(getAbsoluteUri_default(this._url))).toString();
    }
  }
  if (defined_default(options.queryParameters)) {
    resource._queryParameters = combine_default(
      options.queryParameters,
      resource._queryParameters
    );
  }
  if (defined_default(options.templateValues)) {
    resource._templateValues = combine_default(
      options.templateValues,
      resource.templateValues
    );
  }
  if (defined_default(options.headers)) {
    resource.headers = combine_default(options.headers, resource.headers);
  }
  if (defined_default(options.proxy)) {
    resource.proxy = options.proxy;
  }
  if (defined_default(options.request)) {
    resource.request = options.request;
  }
  if (defined_default(options.retryCallback)) {
    resource.retryCallback = options.retryCallback;
  }
  if (defined_default(options.retryAttempts)) {
    resource.retryAttempts = options.retryAttempts;
  }
  return resource;
};
Resource.prototype.retryOnError = function(error) {
  const retryCallback2 = this.retryCallback;
  if (typeof retryCallback2 !== "function" || this._retryCount >= this.retryAttempts) {
    return Promise.resolve(false);
  }
  const that = this;
  return Promise.resolve(retryCallback2(this, error)).then(function(result) {
    ++that._retryCount;
    return result;
  });
};
Resource.prototype.clone = function(result) {
  if (!defined_default(result)) {
    result = new Resource({
      url: this._url
    });
  }
  result._url = this._url;
  result._queryParameters = clone_default(this._queryParameters);
  result._templateValues = clone_default(this._templateValues);
  result.headers = clone_default(this.headers);
  result.proxy = this.proxy;
  result.retryCallback = this.retryCallback;
  result.retryAttempts = this.retryAttempts;
  result._retryCount = 0;
  result.request = this.request.clone();
  return result;
};
Resource.prototype.getBaseUri = function(includeQuery) {
  return getBaseUri_default(this.getUrlComponent(includeQuery), includeQuery);
};
Resource.prototype.appendForwardSlash = function() {
  this._url = appendForwardSlash_default(this._url);
};
Resource.prototype.fetchArrayBuffer = function() {
  return this.fetch({
    responseType: "arraybuffer"
  });
};
Resource.fetchArrayBuffer = function(options) {
  const resource = new Resource(options);
  return resource.fetchArrayBuffer();
};
Resource.prototype.fetchBlob = function() {
  return this.fetch({
    responseType: "blob"
  });
};
Resource.fetchBlob = function(options) {
  const resource = new Resource(options);
  return resource.fetchBlob();
};
Resource.prototype.fetchImage = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const preferImageBitmap = defaultValue_default(options.preferImageBitmap, false);
  const preferBlob = defaultValue_default(options.preferBlob, false);
  const flipY = defaultValue_default(options.flipY, false);
  const skipColorSpaceConversion = defaultValue_default(
    options.skipColorSpaceConversion,
    false
  );
  checkAndResetRequest(this.request);
  if (!xhrBlobSupported || this.isDataUri || this.isBlobUri || !this.hasHeaders && !preferBlob) {
    return fetchImage({
      resource: this,
      flipY,
      skipColorSpaceConversion,
      preferImageBitmap
    });
  }
  const blobPromise = this.fetchBlob();
  if (!defined_default(blobPromise)) {
    return;
  }
  let supportsImageBitmap;
  let useImageBitmap;
  let generatedBlobResource;
  let generatedBlob;
  return Resource.supportsImageBitmapOptions().then(function(result) {
    supportsImageBitmap = result;
    useImageBitmap = supportsImageBitmap && preferImageBitmap;
    return blobPromise;
  }).then(function(blob) {
    if (!defined_default(blob)) {
      return;
    }
    generatedBlob = blob;
    if (useImageBitmap) {
      return Resource.createImageBitmapFromBlob(blob, {
        flipY,
        premultiplyAlpha: false,
        skipColorSpaceConversion
      });
    }
    const blobUrl = window.URL.createObjectURL(blob);
    generatedBlobResource = new Resource({
      url: blobUrl
    });
    return fetchImage({
      resource: generatedBlobResource,
      flipY,
      skipColorSpaceConversion,
      preferImageBitmap: false
    });
  }).then(function(image) {
    if (!defined_default(image)) {
      return;
    }
    image.blob = generatedBlob;
    if (useImageBitmap) {
      return image;
    }
    window.URL.revokeObjectURL(generatedBlobResource.url);
    return image;
  }).catch(function(error) {
    if (defined_default(generatedBlobResource)) {
      window.URL.revokeObjectURL(generatedBlobResource.url);
    }
    error.blob = generatedBlob;
    return Promise.reject(error);
  });
};
function fetchImage(options) {
  const resource = options.resource;
  const flipY = options.flipY;
  const skipColorSpaceConversion = options.skipColorSpaceConversion;
  const preferImageBitmap = options.preferImageBitmap;
  const request = resource.request;
  request.url = resource.url;
  request.requestFunction = function() {
    let crossOrigin = false;
    if (!resource.isDataUri && !resource.isBlobUri) {
      crossOrigin = resource.isCrossOriginUrl;
    }
    const deferred = defer_default();
    Resource._Implementations.createImage(
      request,
      crossOrigin,
      deferred,
      flipY,
      skipColorSpaceConversion,
      preferImageBitmap
    );
    return deferred.promise;
  };
  const promise = RequestScheduler_default.request(request);
  if (!defined_default(promise)) {
    return;
  }
  return promise.catch(function(e2) {
    if (request.state !== RequestState_default.FAILED) {
      return Promise.reject(e2);
    }
    return resource.retryOnError(e2).then(function(retry) {
      if (retry) {
        request.state = RequestState_default.UNISSUED;
        request.deferred = void 0;
        return fetchImage({
          resource,
          flipY,
          skipColorSpaceConversion,
          preferImageBitmap
        });
      }
      return Promise.reject(e2);
    });
  });
}
Resource.fetchImage = function(options) {
  const resource = new Resource(options);
  return resource.fetchImage({
    flipY: options.flipY,
    skipColorSpaceConversion: options.skipColorSpaceConversion,
    preferBlob: options.preferBlob,
    preferImageBitmap: options.preferImageBitmap
  });
};
Resource.prototype.fetchText = function() {
  return this.fetch({
    responseType: "text"
  });
};
Resource.fetchText = function(options) {
  const resource = new Resource(options);
  return resource.fetchText();
};
Resource.prototype.fetchJson = function() {
  const promise = this.fetch({
    responseType: "text",
    headers: {
      Accept: "application/json,*/*;q=0.01"
    }
  });
  if (!defined_default(promise)) {
    return void 0;
  }
  return promise.then(function(value) {
    if (!defined_default(value)) {
      return;
    }
    return JSON.parse(value);
  });
};
Resource.fetchJson = function(options) {
  const resource = new Resource(options);
  return resource.fetchJson();
};
Resource.prototype.fetchXML = function() {
  return this.fetch({
    responseType: "document",
    overrideMimeType: "text/xml"
  });
};
Resource.fetchXML = function(options) {
  const resource = new Resource(options);
  return resource.fetchXML();
};
Resource.prototype.fetchJsonp = function(callbackParameterName) {
  callbackParameterName = defaultValue_default(callbackParameterName, "callback");
  checkAndResetRequest(this.request);
  let functionName;
  do {
    functionName = `loadJsonp${Math_default.nextRandomNumber().toString().substring(2, 8)}`;
  } while (defined_default(window[functionName]));
  return fetchJsonp(this, callbackParameterName, functionName);
};
function fetchJsonp(resource, callbackParameterName, functionName) {
  const callbackQuery = {};
  callbackQuery[callbackParameterName] = functionName;
  resource.setQueryParameters(callbackQuery);
  const request = resource.request;
  request.url = resource.url;
  request.requestFunction = function() {
    const deferred = defer_default();
    window[functionName] = function(data) {
      deferred.resolve(data);
      try {
        delete window[functionName];
      } catch (e2) {
        window[functionName] = void 0;
      }
    };
    Resource._Implementations.loadAndExecuteScript(
      resource.url,
      functionName,
      deferred
    );
    return deferred.promise;
  };
  const promise = RequestScheduler_default.request(request);
  if (!defined_default(promise)) {
    return;
  }
  return promise.catch(function(e2) {
    if (request.state !== RequestState_default.FAILED) {
      return Promise.reject(e2);
    }
    return resource.retryOnError(e2).then(function(retry) {
      if (retry) {
        request.state = RequestState_default.UNISSUED;
        request.deferred = void 0;
        return fetchJsonp(resource, callbackParameterName, functionName);
      }
      return Promise.reject(e2);
    });
  });
}
Resource.fetchJsonp = function(options) {
  const resource = new Resource(options);
  return resource.fetchJsonp(options.callbackParameterName);
};
Resource.prototype._makeRequest = function(options) {
  const resource = this;
  checkAndResetRequest(resource.request);
  const request = resource.request;
  request.url = resource.url;
  request.requestFunction = function() {
    const responseType = options.responseType;
    const headers = combine_default(options.headers, resource.headers);
    const overrideMimeType = options.overrideMimeType;
    const method = options.method;
    const data = options.data;
    const deferred = defer_default();
    const xhr = Resource._Implementations.loadWithXhr(
      resource.url,
      responseType,
      method,
      data,
      headers,
      deferred,
      overrideMimeType
    );
    if (defined_default(xhr) && defined_default(xhr.abort)) {
      request.cancelFunction = function() {
        xhr.abort();
      };
    }
    return deferred.promise;
  };
  const promise = RequestScheduler_default.request(request);
  if (!defined_default(promise)) {
    return;
  }
  return promise.then(function(data) {
    request.cancelFunction = void 0;
    return data;
  }).catch(function(e2) {
    request.cancelFunction = void 0;
    if (request.state !== RequestState_default.FAILED) {
      return Promise.reject(e2);
    }
    return resource.retryOnError(e2).then(function(retry) {
      if (retry) {
        request.state = RequestState_default.UNISSUED;
        request.deferred = void 0;
        return resource.fetch(options);
      }
      return Promise.reject(e2);
    });
  });
};
var dataUriRegex2 = /^data:(.*?)(;base64)?,(.*)$/;
function decodeDataUriText(isBase64, data) {
  const result = decodeURIComponent(data);
  if (isBase64) {
    return atob(result);
  }
  return result;
}
function decodeDataUriArrayBuffer(isBase64, data) {
  const byteString = decodeDataUriText(isBase64, data);
  const buffer = new ArrayBuffer(byteString.length);
  const view = new Uint8Array(buffer);
  for (let i2 = 0; i2 < byteString.length; i2++) {
    view[i2] = byteString.charCodeAt(i2);
  }
  return buffer;
}
function decodeDataUri(dataUriRegexResult, responseType) {
  responseType = defaultValue_default(responseType, "");
  const mimeType = dataUriRegexResult[1];
  const isBase64 = !!dataUriRegexResult[2];
  const data = dataUriRegexResult[3];
  let buffer;
  let parser3;
  switch (responseType) {
    case "":
    case "text":
      return decodeDataUriText(isBase64, data);
    case "arraybuffer":
      return decodeDataUriArrayBuffer(isBase64, data);
    case "blob":
      buffer = decodeDataUriArrayBuffer(isBase64, data);
      return new Blob([buffer], {
        type: mimeType
      });
    case "document":
      parser3 = new DOMParser();
      return parser3.parseFromString(
        decodeDataUriText(isBase64, data),
        mimeType
      );
    case "json":
      return JSON.parse(decodeDataUriText(isBase64, data));
    default:
      throw new DeveloperError_default(`Unhandled responseType: ${responseType}`);
  }
}
Resource.prototype.fetch = function(options) {
  options = defaultClone(options, {});
  options.method = "GET";
  return this._makeRequest(options);
};
Resource.fetch = function(options) {
  const resource = new Resource(options);
  return resource.fetch({
    responseType: options.responseType,
    overrideMimeType: options.overrideMimeType
  });
};
Resource.prototype.delete = function(options) {
  options = defaultClone(options, {});
  options.method = "DELETE";
  return this._makeRequest(options);
};
Resource.delete = function(options) {
  const resource = new Resource(options);
  return resource.delete({
    responseType: options.responseType,
    overrideMimeType: options.overrideMimeType,
    data: options.data
  });
};
Resource.prototype.head = function(options) {
  options = defaultClone(options, {});
  options.method = "HEAD";
  return this._makeRequest(options);
};
Resource.head = function(options) {
  const resource = new Resource(options);
  return resource.head({
    responseType: options.responseType,
    overrideMimeType: options.overrideMimeType
  });
};
Resource.prototype.options = function(options) {
  options = defaultClone(options, {});
  options.method = "OPTIONS";
  return this._makeRequest(options);
};
Resource.options = function(options) {
  const resource = new Resource(options);
  return resource.options({
    responseType: options.responseType,
    overrideMimeType: options.overrideMimeType
  });
};
Resource.prototype.post = function(data, options) {
  Check_default.defined("data", data);
  options = defaultClone(options, {});
  options.method = "POST";
  options.data = data;
  return this._makeRequest(options);
};
Resource.post = function(options) {
  const resource = new Resource(options);
  return resource.post(options.data, {
    responseType: options.responseType,
    overrideMimeType: options.overrideMimeType
  });
};
Resource.prototype.put = function(data, options) {
  Check_default.defined("data", data);
  options = defaultClone(options, {});
  options.method = "PUT";
  options.data = data;
  return this._makeRequest(options);
};
Resource.put = function(options) {
  const resource = new Resource(options);
  return resource.put(options.data, {
    responseType: options.responseType,
    overrideMimeType: options.overrideMimeType
  });
};
Resource.prototype.patch = function(data, options) {
  Check_default.defined("data", data);
  options = defaultClone(options, {});
  options.method = "PATCH";
  options.data = data;
  return this._makeRequest(options);
};
Resource.patch = function(options) {
  const resource = new Resource(options);
  return resource.patch(options.data, {
    responseType: options.responseType,
    overrideMimeType: options.overrideMimeType
  });
};
Resource._Implementations = {};
Resource._Implementations.loadImageElement = function(url2, crossOrigin, deferred) {
  const image = new Image();
  image.onload = function() {
    if (image.naturalWidth === 0 && image.naturalHeight === 0 && image.width === 0 && image.height === 0) {
      image.width = 300;
      image.height = 150;
    }
    deferred.resolve(image);
  };
  image.onerror = function(e2) {
    deferred.reject(e2);
  };
  if (crossOrigin) {
    if (TrustedServers_default.contains(url2)) {
      image.crossOrigin = "use-credentials";
    } else {
      image.crossOrigin = "";
    }
  }
  image.src = url2;
};
Resource._Implementations.createImage = function(request, crossOrigin, deferred, flipY, skipColorSpaceConversion, preferImageBitmap) {
  const url2 = request.url;
  Resource.supportsImageBitmapOptions().then(function(supportsImageBitmap) {
    if (!(supportsImageBitmap && preferImageBitmap)) {
      Resource._Implementations.loadImageElement(url2, crossOrigin, deferred);
      return;
    }
    const responseType = "blob";
    const method = "GET";
    const xhrDeferred = defer_default();
    const xhr = Resource._Implementations.loadWithXhr(
      url2,
      responseType,
      method,
      void 0,
      void 0,
      xhrDeferred,
      void 0,
      void 0,
      void 0
    );
    if (defined_default(xhr) && defined_default(xhr.abort)) {
      request.cancelFunction = function() {
        xhr.abort();
      };
    }
    return xhrDeferred.promise.then(function(blob) {
      if (!defined_default(blob)) {
        deferred.reject(
          new RuntimeError_default(
            `Successfully retrieved ${url2} but it contained no content.`
          )
        );
        return;
      }
      return Resource.createImageBitmapFromBlob(blob, {
        flipY,
        premultiplyAlpha: false,
        skipColorSpaceConversion
      });
    }).then(function(image) {
      deferred.resolve(image);
    });
  }).catch(function(e2) {
    deferred.reject(e2);
  });
};
Resource.createImageBitmapFromBlob = function(blob, options) {
  Check_default.defined("options", options);
  Check_default.typeOf.bool("options.flipY", options.flipY);
  Check_default.typeOf.bool("options.premultiplyAlpha", options.premultiplyAlpha);
  Check_default.typeOf.bool(
    "options.skipColorSpaceConversion",
    options.skipColorSpaceConversion
  );
  return createImageBitmap(blob, {
    imageOrientation: options.flipY ? "flipY" : "none",
    premultiplyAlpha: options.premultiplyAlpha ? "premultiply" : "none",
    colorSpaceConversion: options.skipColorSpaceConversion ? "none" : "default"
  });
};
function decodeResponse(loadWithHttpResponse, responseType) {
  switch (responseType) {
    case "text":
      return loadWithHttpResponse.toString("utf8");
    case "json":
      return JSON.parse(loadWithHttpResponse.toString("utf8"));
    default:
      return new Uint8Array(loadWithHttpResponse).buffer;
  }
}
function loadWithHttpRequest(url2, responseType, method, data, headers, deferred, overrideMimeType) {
  const URL2 = require_url().parse(url2);
  const http = URL2.protocol === "https:" ? (init_https(), __toCommonJS(https_exports)) : (init_http(), __toCommonJS(http_exports));
  const zlib = (init_zlib(), __toCommonJS(zlib_exports));
  const options = {
    protocol: URL2.protocol,
    hostname: URL2.hostname,
    port: URL2.port,
    path: URL2.path,
    query: URL2.query,
    method,
    headers
  };
  http.request(options).on("response", function(res) {
    if (res.statusCode < 200 || res.statusCode >= 300) {
      deferred.reject(
        new RequestErrorEvent_default(res.statusCode, res, res.headers)
      );
      return;
    }
    const chunkArray = [];
    res.on("data", function(chunk) {
      chunkArray.push(chunk);
    });
    res.on("end", function() {
      const result = Buffer.concat(chunkArray);
      if (res.headers["content-encoding"] === "gzip") {
        zlib.gunzip(result, function(error, resultUnzipped) {
          if (error) {
            deferred.reject(
              new RuntimeError_default("Error decompressing response.")
            );
          } else {
            deferred.resolve(decodeResponse(resultUnzipped, responseType));
          }
        });
      } else {
        deferred.resolve(decodeResponse(result, responseType));
      }
    });
  }).on("error", function(e2) {
    deferred.reject(new RequestErrorEvent_default());
  }).end();
}
var noXMLHttpRequest = typeof XMLHttpRequest === "undefined";
Resource._Implementations.loadWithXhr = function(url2, responseType, method, data, headers, deferred, overrideMimeType) {
  const dataUriRegexResult = dataUriRegex2.exec(url2);
  if (dataUriRegexResult !== null) {
    deferred.resolve(decodeDataUri(dataUriRegexResult, responseType));
    return;
  }
  if (noXMLHttpRequest) {
    loadWithHttpRequest(
      url2,
      responseType,
      method,
      data,
      headers,
      deferred,
      overrideMimeType
    );
    return;
  }
  const xhr = new XMLHttpRequest();
  if (TrustedServers_default.contains(url2)) {
    xhr.withCredentials = true;
  }
  xhr.open(method, url2, true);
  if (defined_default(overrideMimeType) && defined_default(xhr.overrideMimeType)) {
    xhr.overrideMimeType(overrideMimeType);
  }
  if (defined_default(headers)) {
    for (const key in headers) {
      if (headers.hasOwnProperty(key)) {
        xhr.setRequestHeader(key, headers[key]);
      }
    }
  }
  if (defined_default(responseType)) {
    xhr.responseType = responseType;
  }
  let localFile = false;
  if (typeof url2 === "string") {
    localFile = url2.indexOf("file://") === 0 || typeof window !== "undefined" && window.location.origin === "file://";
  }
  xhr.onload = function() {
    if ((xhr.status < 200 || xhr.status >= 300) && !(localFile && xhr.status === 0)) {
      deferred.reject(
        new RequestErrorEvent_default(
          xhr.status,
          xhr.response,
          xhr.getAllResponseHeaders()
        )
      );
      return;
    }
    const response = xhr.response;
    const browserResponseType = xhr.responseType;
    if (method === "HEAD" || method === "OPTIONS") {
      const responseHeaderString = xhr.getAllResponseHeaders();
      const splitHeaders = responseHeaderString.trim().split(/[\r\n]+/);
      const responseHeaders = {};
      splitHeaders.forEach(function(line) {
        const parts = line.split(": ");
        const header = parts.shift();
        responseHeaders[header] = parts.join(": ");
      });
      deferred.resolve(responseHeaders);
      return;
    }
    if (xhr.status === 204) {
      deferred.resolve();
    } else if (defined_default(response) && (!defined_default(responseType) || browserResponseType === responseType)) {
      deferred.resolve(response);
    } else if (responseType === "json" && typeof response === "string") {
      try {
        deferred.resolve(JSON.parse(response));
      } catch (e2) {
        deferred.reject(e2);
      }
    } else if ((browserResponseType === "" || browserResponseType === "document") && defined_default(xhr.responseXML) && xhr.responseXML.hasChildNodes()) {
      deferred.resolve(xhr.responseXML);
    } else if ((browserResponseType === "" || browserResponseType === "text") && defined_default(xhr.responseText)) {
      deferred.resolve(xhr.responseText);
    } else {
      deferred.reject(
        new RuntimeError_default("Invalid XMLHttpRequest response type.")
      );
    }
  };
  xhr.onerror = function(e2) {
    deferred.reject(new RequestErrorEvent_default());
  };
  xhr.send(data);
  return xhr;
};
Resource._Implementations.loadAndExecuteScript = function(url2, functionName, deferred) {
  return loadAndExecuteScript_default(url2, functionName).catch(function(e2) {
    deferred.reject(e2);
  });
};
Resource._DefaultImplementations = {};
Resource._DefaultImplementations.createImage = Resource._Implementations.createImage;
Resource._DefaultImplementations.loadWithXhr = Resource._Implementations.loadWithXhr;
Resource._DefaultImplementations.loadAndExecuteScript = Resource._Implementations.loadAndExecuteScript;
Resource.DEFAULT = Object.freeze(
  new Resource({
    url: typeof document === "undefined" ? "" : document.location.href.split("?")[0]
  })
);
var Resource_default = Resource;

// node_modules/cesium/Source/Core/buildModuleUrl.js
var cesiumScriptRegex = /((?:.*\/)|^)Cesium\.js(?:\?|\#|$)/;
var a2;
function tryMakeAbsolute(url2) {
  if (typeof document === "undefined") {
    return url2;
  }
  if (!defined_default(a2)) {
    a2 = document.createElement("a");
  }
  a2.href = url2;
  a2.href = a2.href;
  return a2.href;
}
var baseResource;
function getCesiumBaseUrl() {
  if (defined_default(baseResource)) {
    return baseResource;
  }
  let baseUrlString;
  if (true) {
    baseUrlString = "cesium/";
  } else if (typeof define === "object" && defined_default(define.amd) && !define.amd.toUrlUndefined && defined_default(__require.toUrl)) {
    baseUrlString = getAbsoluteUri_default(
      "..",
      buildModuleUrl("Core/buildModuleUrl.js")
    );
  } else {
    baseUrlString = getBaseUrlFromCesiumScript();
  }
  if (!defined_default(baseUrlString)) {
    throw new DeveloperError_default(
      "Unable to determine Cesium base URL automatically, try defining a global variable called CESIUM_BASE_URL."
    );
  }
  baseResource = new Resource_default({
    url: tryMakeAbsolute(baseUrlString)
  });
  baseResource.appendForwardSlash();
  return baseResource;
}
function buildModuleUrlFromRequireToUrl(moduleID) {
  return tryMakeAbsolute(__require.toUrl(`../${moduleID}`));
}
function buildModuleUrlFromBaseUrl(moduleID) {
  const resource = getCesiumBaseUrl().getDerivedResource({
    url: moduleID
  });
  return resource.url;
}
var implementation;
function buildModuleUrl(relativeUrl) {
  if (!defined_default(implementation)) {
    if (typeof define === "object" && defined_default(define.amd) && !define.amd.toUrlUndefined && defined_default(__require.toUrl)) {
      implementation = buildModuleUrlFromRequireToUrl;
    } else {
      implementation = buildModuleUrlFromBaseUrl;
    }
  }
  const url2 = implementation(relativeUrl);
  return url2;
}
buildModuleUrl._cesiumScriptRegex = cesiumScriptRegex;
buildModuleUrl._buildModuleUrlFromBaseUrl = buildModuleUrlFromBaseUrl;
buildModuleUrl._clearBaseResource = function() {
  baseResource = void 0;
};
buildModuleUrl.setBaseUrl = function(value) {
  baseResource = Resource_default.DEFAULT.getDerivedResource({
    url: value
  });
};
buildModuleUrl.getCesiumBaseUrl = getCesiumBaseUrl;
var buildModuleUrl_default = buildModuleUrl;

// node_modules/cesium/Source/Core/Cartesian2.js
function Cartesian2(x, y) {
  this.x = defaultValue_default(x, 0);
  this.y = defaultValue_default(y, 0);
}
Cartesian2.fromElements = function(x, y, result) {
  if (!defined_default(result)) {
    return new Cartesian2(x, y);
  }
  result.x = x;
  result.y = y;
  return result;
};
Cartesian2.clone = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Cartesian2(cartesian11.x, cartesian11.y);
  }
  result.x = cartesian11.x;
  result.y = cartesian11.y;
  return result;
};
Cartesian2.fromCartesian3 = Cartesian2.clone;
Cartesian2.fromCartesian4 = Cartesian2.clone;
Cartesian2.packedLength = 2;
Cartesian2.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.x;
  array[startingIndex] = value.y;
  return array;
};
Cartesian2.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new Cartesian2();
  }
  result.x = array[startingIndex++];
  result.y = array[startingIndex];
  return result;
};
Cartesian2.packArray = function(array, result) {
  Check_default.defined("array", array);
  const length3 = array.length;
  const resultLength = length3 * 2;
  if (!defined_default(result)) {
    result = new Array(resultLength);
  } else if (!Array.isArray(result) && result.length !== resultLength) {
    throw new DeveloperError_default(
      "If result is a typed array, it must have exactly array.length * 2 elements"
    );
  } else if (result.length !== resultLength) {
    result.length = resultLength;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    Cartesian2.pack(array[i2], result, i2 * 2);
  }
  return result;
};
Cartesian2.unpackArray = function(array, result) {
  Check_default.defined("array", array);
  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 2);
  if (array.length % 2 !== 0) {
    throw new DeveloperError_default("array length must be a multiple of 2.");
  }
  const length3 = array.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 2);
  } else {
    result.length = length3 / 2;
  }
  for (let i2 = 0; i2 < length3; i2 += 2) {
    const index2 = i2 / 2;
    result[index2] = Cartesian2.unpack(array, i2, result[index2]);
  }
  return result;
};
Cartesian2.fromArray = Cartesian2.unpack;
Cartesian2.maximumComponent = function(cartesian11) {
  Check_default.typeOf.object("cartesian", cartesian11);
  return Math.max(cartesian11.x, cartesian11.y);
};
Cartesian2.minimumComponent = function(cartesian11) {
  Check_default.typeOf.object("cartesian", cartesian11);
  return Math.min(cartesian11.x, cartesian11.y);
};
Cartesian2.minimumByComponent = function(first, second, result) {
  Check_default.typeOf.object("first", first);
  Check_default.typeOf.object("second", second);
  Check_default.typeOf.object("result", result);
  result.x = Math.min(first.x, second.x);
  result.y = Math.min(first.y, second.y);
  return result;
};
Cartesian2.maximumByComponent = function(first, second, result) {
  Check_default.typeOf.object("first", first);
  Check_default.typeOf.object("second", second);
  Check_default.typeOf.object("result", result);
  result.x = Math.max(first.x, second.x);
  result.y = Math.max(first.y, second.y);
  return result;
};
Cartesian2.clamp = function(value, min3, max3, result) {
  Check_default.typeOf.object("value", value);
  Check_default.typeOf.object("min", min3);
  Check_default.typeOf.object("max", max3);
  Check_default.typeOf.object("result", result);
  const x = Math_default.clamp(value.x, min3.x, max3.x);
  const y = Math_default.clamp(value.y, min3.y, max3.y);
  result.x = x;
  result.y = y;
  return result;
};
Cartesian2.magnitudeSquared = function(cartesian11) {
  Check_default.typeOf.object("cartesian", cartesian11);
  return cartesian11.x * cartesian11.x + cartesian11.y * cartesian11.y;
};
Cartesian2.magnitude = function(cartesian11) {
  return Math.sqrt(Cartesian2.magnitudeSquared(cartesian11));
};
var distanceScratch3 = new Cartesian2();
Cartesian2.distance = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Cartesian2.subtract(left, right, distanceScratch3);
  return Cartesian2.magnitude(distanceScratch3);
};
Cartesian2.distanceSquared = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Cartesian2.subtract(left, right, distanceScratch3);
  return Cartesian2.magnitudeSquared(distanceScratch3);
};
Cartesian2.normalize = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const magnitude = Cartesian2.magnitude(cartesian11);
  result.x = cartesian11.x / magnitude;
  result.y = cartesian11.y / magnitude;
  if (isNaN(result.x) || isNaN(result.y)) {
    throw new DeveloperError_default("normalized result is not a number");
  }
  return result;
};
Cartesian2.dot = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  return left.x * right.x + left.y * right.y;
};
Cartesian2.cross = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  return left.x * right.y - left.y * right.x;
};
Cartesian2.multiplyComponents = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x * right.x;
  result.y = left.y * right.y;
  return result;
};
Cartesian2.divideComponents = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x / right.x;
  result.y = left.y / right.y;
  return result;
};
Cartesian2.add = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x + right.x;
  result.y = left.y + right.y;
  return result;
};
Cartesian2.subtract = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x - right.x;
  result.y = left.y - right.y;
  return result;
};
Cartesian2.multiplyByScalar = function(cartesian11, scalar, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.x = cartesian11.x * scalar;
  result.y = cartesian11.y * scalar;
  return result;
};
Cartesian2.divideByScalar = function(cartesian11, scalar, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.x = cartesian11.x / scalar;
  result.y = cartesian11.y / scalar;
  return result;
};
Cartesian2.negate = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result.x = -cartesian11.x;
  result.y = -cartesian11.y;
  return result;
};
Cartesian2.abs = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result.x = Math.abs(cartesian11.x);
  result.y = Math.abs(cartesian11.y);
  return result;
};
var lerpScratch3 = new Cartesian2();
Cartesian2.lerp = function(start, end, t, result) {
  Check_default.typeOf.object("start", start);
  Check_default.typeOf.object("end", end);
  Check_default.typeOf.number("t", t);
  Check_default.typeOf.object("result", result);
  Cartesian2.multiplyByScalar(end, t, lerpScratch3);
  result = Cartesian2.multiplyByScalar(start, 1 - t, result);
  return Cartesian2.add(lerpScratch3, result, result);
};
var angleBetweenScratch3 = new Cartesian2();
var angleBetweenScratch22 = new Cartesian2();
Cartesian2.angleBetween = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Cartesian2.normalize(left, angleBetweenScratch3);
  Cartesian2.normalize(right, angleBetweenScratch22);
  return Math_default.acosClamped(
    Cartesian2.dot(angleBetweenScratch3, angleBetweenScratch22)
  );
};
var mostOrthogonalAxisScratch3 = new Cartesian2();
Cartesian2.mostOrthogonalAxis = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const f2 = Cartesian2.normalize(cartesian11, mostOrthogonalAxisScratch3);
  Cartesian2.abs(f2, f2);
  if (f2.x <= f2.y) {
    result = Cartesian2.clone(Cartesian2.UNIT_X, result);
  } else {
    result = Cartesian2.clone(Cartesian2.UNIT_Y, result);
  }
  return result;
};
Cartesian2.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y;
};
Cartesian2.equalsArray = function(cartesian11, array, offset2) {
  return cartesian11.x === array[offset2] && cartesian11.y === array[offset2 + 1];
};
Cartesian2.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
  return left === right || defined_default(left) && defined_default(right) && Math_default.equalsEpsilon(
    left.x,
    right.x,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    left.y,
    right.y,
    relativeEpsilon,
    absoluteEpsilon
  );
};
Cartesian2.ZERO = Object.freeze(new Cartesian2(0, 0));
Cartesian2.ONE = Object.freeze(new Cartesian2(1, 1));
Cartesian2.UNIT_X = Object.freeze(new Cartesian2(1, 0));
Cartesian2.UNIT_Y = Object.freeze(new Cartesian2(0, 1));
Cartesian2.prototype.clone = function(result) {
  return Cartesian2.clone(this, result);
};
Cartesian2.prototype.equals = function(right) {
  return Cartesian2.equals(this, right);
};
Cartesian2.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
  return Cartesian2.equalsEpsilon(
    this,
    right,
    relativeEpsilon,
    absoluteEpsilon
  );
};
Cartesian2.prototype.toString = function() {
  return `(${this.x}, ${this.y})`;
};
var Cartesian2_default = Cartesian2;

// node_modules/cesium/Source/Core/GeographicTilingScheme.js
function GeographicTilingScheme(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._rectangle = defaultValue_default(options.rectangle, Rectangle_default.MAX_VALUE);
  this._projection = new GeographicProjection_default(this._ellipsoid);
  this._numberOfLevelZeroTilesX = defaultValue_default(
    options.numberOfLevelZeroTilesX,
    2
  );
  this._numberOfLevelZeroTilesY = defaultValue_default(
    options.numberOfLevelZeroTilesY,
    1
  );
}
Object.defineProperties(GeographicTilingScheme.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  },
  rectangle: {
    get: function() {
      return this._rectangle;
    }
  },
  projection: {
    get: function() {
      return this._projection;
    }
  }
});
GeographicTilingScheme.prototype.getNumberOfXTilesAtLevel = function(level) {
  return this._numberOfLevelZeroTilesX << level;
};
GeographicTilingScheme.prototype.getNumberOfYTilesAtLevel = function(level) {
  return this._numberOfLevelZeroTilesY << level;
};
GeographicTilingScheme.prototype.rectangleToNativeRectangle = function(rectangle, result) {
  Check_default.defined("rectangle", rectangle);
  const west = Math_default.toDegrees(rectangle.west);
  const south = Math_default.toDegrees(rectangle.south);
  const east = Math_default.toDegrees(rectangle.east);
  const north = Math_default.toDegrees(rectangle.north);
  if (!defined_default(result)) {
    return new Rectangle_default(west, south, east, north);
  }
  result.west = west;
  result.south = south;
  result.east = east;
  result.north = north;
  return result;
};
GeographicTilingScheme.prototype.tileXYToNativeRectangle = function(x, y, level, result) {
  const rectangleRadians = this.tileXYToRectangle(x, y, level, result);
  rectangleRadians.west = Math_default.toDegrees(rectangleRadians.west);
  rectangleRadians.south = Math_default.toDegrees(rectangleRadians.south);
  rectangleRadians.east = Math_default.toDegrees(rectangleRadians.east);
  rectangleRadians.north = Math_default.toDegrees(rectangleRadians.north);
  return rectangleRadians;
};
GeographicTilingScheme.prototype.tileXYToRectangle = function(x, y, level, result) {
  const rectangle = this._rectangle;
  const xTiles = this.getNumberOfXTilesAtLevel(level);
  const yTiles = this.getNumberOfYTilesAtLevel(level);
  const xTileWidth = rectangle.width / xTiles;
  const west = x * xTileWidth + rectangle.west;
  const east = (x + 1) * xTileWidth + rectangle.west;
  const yTileHeight = rectangle.height / yTiles;
  const north = rectangle.north - y * yTileHeight;
  const south = rectangle.north - (y + 1) * yTileHeight;
  if (!defined_default(result)) {
    result = new Rectangle_default(west, south, east, north);
  }
  result.west = west;
  result.south = south;
  result.east = east;
  result.north = north;
  return result;
};
GeographicTilingScheme.prototype.positionToTileXY = function(position, level, result) {
  const rectangle = this._rectangle;
  if (!Rectangle_default.contains(rectangle, position)) {
    return void 0;
  }
  const xTiles = this.getNumberOfXTilesAtLevel(level);
  const yTiles = this.getNumberOfYTilesAtLevel(level);
  const xTileWidth = rectangle.width / xTiles;
  const yTileHeight = rectangle.height / yTiles;
  let longitude = position.longitude;
  if (rectangle.east < rectangle.west) {
    longitude += Math_default.TWO_PI;
  }
  let xTileCoordinate = (longitude - rectangle.west) / xTileWidth | 0;
  if (xTileCoordinate >= xTiles) {
    xTileCoordinate = xTiles - 1;
  }
  let yTileCoordinate = (rectangle.north - position.latitude) / yTileHeight | 0;
  if (yTileCoordinate >= yTiles) {
    yTileCoordinate = yTiles - 1;
  }
  if (!defined_default(result)) {
    return new Cartesian2_default(xTileCoordinate, yTileCoordinate);
  }
  result.x = xTileCoordinate;
  result.y = yTileCoordinate;
  return result;
};
var GeographicTilingScheme_default = GeographicTilingScheme;

// node_modules/cesium/Source/Core/ApproximateTerrainHeights.js
var scratchDiagonalCartesianNE = new Cartesian3_default();
var scratchDiagonalCartesianSW = new Cartesian3_default();
var scratchDiagonalCartographic = new Cartographic_default();
var scratchCenterCartesian = new Cartesian3_default();
var scratchSurfaceCartesian = new Cartesian3_default();
var scratchBoundingSphere = new BoundingSphere_default();
var tilingScheme = new GeographicTilingScheme_default();
var scratchCorners = [
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default()
];
var scratchTileXY = new Cartesian2_default();
var ApproximateTerrainHeights = {};
ApproximateTerrainHeights.initialize = function() {
  let initPromise = ApproximateTerrainHeights._initPromise;
  if (defined_default(initPromise)) {
    return initPromise;
  }
  initPromise = Resource_default.fetchJson(
    buildModuleUrl_default("Assets/approximateTerrainHeights.json")
  ).then(function(json) {
    ApproximateTerrainHeights._terrainHeights = json;
  });
  ApproximateTerrainHeights._initPromise = initPromise;
  return initPromise;
};
ApproximateTerrainHeights.getMinimumMaximumHeights = function(rectangle, ellipsoid) {
  Check_default.defined("rectangle", rectangle);
  if (!defined_default(ApproximateTerrainHeights._terrainHeights)) {
    throw new DeveloperError_default(
      "You must call ApproximateTerrainHeights.initialize and wait for the promise to resolve before using this function"
    );
  }
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  const xyLevel = getTileXYLevel(rectangle);
  let minTerrainHeight = ApproximateTerrainHeights._defaultMinTerrainHeight;
  let maxTerrainHeight = ApproximateTerrainHeights._defaultMaxTerrainHeight;
  if (defined_default(xyLevel)) {
    const key = `${xyLevel.level}-${xyLevel.x}-${xyLevel.y}`;
    const heights = ApproximateTerrainHeights._terrainHeights[key];
    if (defined_default(heights)) {
      minTerrainHeight = heights[0];
      maxTerrainHeight = heights[1];
    }
    ellipsoid.cartographicToCartesian(
      Rectangle_default.northeast(rectangle, scratchDiagonalCartographic),
      scratchDiagonalCartesianNE
    );
    ellipsoid.cartographicToCartesian(
      Rectangle_default.southwest(rectangle, scratchDiagonalCartographic),
      scratchDiagonalCartesianSW
    );
    Cartesian3_default.midpoint(
      scratchDiagonalCartesianSW,
      scratchDiagonalCartesianNE,
      scratchCenterCartesian
    );
    const surfacePosition = ellipsoid.scaleToGeodeticSurface(
      scratchCenterCartesian,
      scratchSurfaceCartesian
    );
    if (defined_default(surfacePosition)) {
      const distance2 = Cartesian3_default.distance(
        scratchCenterCartesian,
        surfacePosition
      );
      minTerrainHeight = Math.min(minTerrainHeight, -distance2);
    } else {
      minTerrainHeight = ApproximateTerrainHeights._defaultMinTerrainHeight;
    }
  }
  minTerrainHeight = Math.max(
    ApproximateTerrainHeights._defaultMinTerrainHeight,
    minTerrainHeight
  );
  return {
    minimumTerrainHeight: minTerrainHeight,
    maximumTerrainHeight: maxTerrainHeight
  };
};
ApproximateTerrainHeights.getBoundingSphere = function(rectangle, ellipsoid) {
  Check_default.defined("rectangle", rectangle);
  if (!defined_default(ApproximateTerrainHeights._terrainHeights)) {
    throw new DeveloperError_default(
      "You must call ApproximateTerrainHeights.initialize and wait for the promise to resolve before using this function"
    );
  }
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  const xyLevel = getTileXYLevel(rectangle);
  let maxTerrainHeight = ApproximateTerrainHeights._defaultMaxTerrainHeight;
  if (defined_default(xyLevel)) {
    const key = `${xyLevel.level}-${xyLevel.x}-${xyLevel.y}`;
    const heights = ApproximateTerrainHeights._terrainHeights[key];
    if (defined_default(heights)) {
      maxTerrainHeight = heights[1];
    }
  }
  const result = BoundingSphere_default.fromRectangle3D(rectangle, ellipsoid, 0);
  BoundingSphere_default.fromRectangle3D(
    rectangle,
    ellipsoid,
    maxTerrainHeight,
    scratchBoundingSphere
  );
  return BoundingSphere_default.union(result, scratchBoundingSphere, result);
};
function getTileXYLevel(rectangle) {
  Cartographic_default.fromRadians(
    rectangle.east,
    rectangle.north,
    0,
    scratchCorners[0]
  );
  Cartographic_default.fromRadians(
    rectangle.west,
    rectangle.north,
    0,
    scratchCorners[1]
  );
  Cartographic_default.fromRadians(
    rectangle.east,
    rectangle.south,
    0,
    scratchCorners[2]
  );
  Cartographic_default.fromRadians(
    rectangle.west,
    rectangle.south,
    0,
    scratchCorners[3]
  );
  let lastLevelX = 0, lastLevelY = 0;
  let currentX = 0, currentY = 0;
  const maxLevel = ApproximateTerrainHeights._terrainHeightsMaxLevel;
  let i2;
  for (i2 = 0; i2 <= maxLevel; ++i2) {
    let failed = false;
    for (let j = 0; j < 4; ++j) {
      const corner = scratchCorners[j];
      tilingScheme.positionToTileXY(corner, i2, scratchTileXY);
      if (j === 0) {
        currentX = scratchTileXY.x;
        currentY = scratchTileXY.y;
      } else if (currentX !== scratchTileXY.x || currentY !== scratchTileXY.y) {
        failed = true;
        break;
      }
    }
    if (failed) {
      break;
    }
    lastLevelX = currentX;
    lastLevelY = currentY;
  }
  if (i2 === 0) {
    return void 0;
  }
  return {
    x: lastLevelX,
    y: lastLevelY,
    level: i2 > maxLevel ? maxLevel : i2 - 1
  };
}
ApproximateTerrainHeights._terrainHeightsMaxLevel = 6;
ApproximateTerrainHeights._defaultMaxTerrainHeight = 9e3;
ApproximateTerrainHeights._defaultMinTerrainHeight = -1e5;
ApproximateTerrainHeights._terrainHeights = void 0;
ApproximateTerrainHeights._initPromise = void 0;
Object.defineProperties(ApproximateTerrainHeights, {
  initialized: {
    get: function() {
      return defined_default(ApproximateTerrainHeights._terrainHeights);
    }
  }
});
var ApproximateTerrainHeights_default = ApproximateTerrainHeights;

// node_modules/cesium/Source/ThirdParty/dompurify.js
function _toConsumableArray(arr) {
  if (Array.isArray(arr)) {
    for (var i2 = 0, arr2 = Array(arr.length); i2 < arr.length; i2++) {
      arr2[i2] = arr[i2];
    }
    return arr2;
  } else {
    return Array.from(arr);
  }
}
var hasOwnProperty = Object.hasOwnProperty;
var setPrototypeOf = Object.setPrototypeOf;
var isFrozen = Object.isFrozen;
var getPrototypeOf = Object.getPrototypeOf;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var freeze = Object.freeze;
var seal = Object.seal;
var create = Object.create;
var _ref = typeof Reflect !== "undefined" && Reflect;
var apply = _ref.apply;
var construct = _ref.construct;
if (!apply) {
  apply = function apply2(fun, thisValue, args) {
    return fun.apply(thisValue, args);
  };
}
if (!freeze) {
  freeze = function freeze2(x) {
    return x;
  };
}
if (!seal) {
  seal = function seal2(x) {
    return x;
  };
}
if (!construct) {
  construct = function construct2(Func, args) {
    return new (Function.prototype.bind.apply(Func, [null].concat(_toConsumableArray(args))))();
  };
}
var arrayForEach = unapply(Array.prototype.forEach);
var arrayPop = unapply(Array.prototype.pop);
var arrayPush = unapply(Array.prototype.push);
var stringToLowerCase = unapply(String.prototype.toLowerCase);
var stringMatch = unapply(String.prototype.match);
var stringReplace = unapply(String.prototype.replace);
var stringIndexOf = unapply(String.prototype.indexOf);
var stringTrim = unapply(String.prototype.trim);
var regExpTest = unapply(RegExp.prototype.test);
var typeErrorCreate = unconstruct(TypeError);
function unapply(func) {
  return function(thisArg) {
    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }
    return apply(func, thisArg, args);
  };
}
function unconstruct(func) {
  return function() {
    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }
    return construct(func, args);
  };
}
function addToSet(set2, array) {
  if (setPrototypeOf) {
    setPrototypeOf(set2, null);
  }
  var l2 = array.length;
  while (l2--) {
    var element = array[l2];
    if (typeof element === "string") {
      var lcElement = stringToLowerCase(element);
      if (lcElement !== element) {
        if (!isFrozen(array)) {
          array[l2] = lcElement;
        }
        element = lcElement;
      }
    }
    set2[element] = true;
  }
  return set2;
}
function clone2(object2) {
  var newObject = create(null);
  var property = void 0;
  for (property in object2) {
    if (apply(hasOwnProperty, object2, [property])) {
      newObject[property] = object2[property];
    }
  }
  return newObject;
}
function lookupGetter(object2, prop) {
  while (object2 !== null) {
    var desc = getOwnPropertyDescriptor(object2, prop);
    if (desc) {
      if (desc.get) {
        return unapply(desc.get);
      }
      if (typeof desc.value === "function") {
        return unapply(desc.value);
      }
    }
    object2 = getPrototypeOf(object2);
  }
  function fallbackValue(element) {
    console.warn("fallback value for", element);
    return null;
  }
  return fallbackValue;
}
var html = freeze(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "section", "select", "shadow", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]);
var svg = freeze(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]);
var svgFilters = freeze(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]);
var svgDisallowed = freeze(["animate", "color-profile", "cursor", "discard", "fedropshadow", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]);
var mathMl = freeze(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover"]);
var mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]);
var text = freeze(["#text"]);
var html$1 = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "pattern", "placeholder", "playsinline", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "xmlns", "slot"]);
var svg$1 = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]);
var mathMl$1 = freeze(["accent", "accentunder", "align", "bevelled", "close", "columnsalign", "columnlines", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lspace", "lquote", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]);
var xml = freeze(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]);
var MUSTACHE_EXPR = seal(/\{\{[\s\S]*|[\s\S]*\}\}/gm);
var ERB_EXPR = seal(/<%[\s\S]*|[\s\S]*%>/gm);
var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/);
var ARIA_ATTR = seal(/^aria-[\-\w]+$/);
var IS_ALLOWED_URI = seal(
  /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
);
var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
var ATTR_WHITESPACE = seal(
  /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
);
var DOCTYPE_NAME = seal(/^html$/i);
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
  return typeof obj;
} : function(obj) {
  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
function _toConsumableArray$1(arr) {
  if (Array.isArray(arr)) {
    for (var i2 = 0, arr2 = Array(arr.length); i2 < arr.length; i2++) {
      arr2[i2] = arr[i2];
    }
    return arr2;
  } else {
    return Array.from(arr);
  }
}
var getGlobal = function getGlobal2() {
  return typeof window === "undefined" ? null : window;
};
var _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes, document2) {
  if ((typeof trustedTypes === "undefined" ? "undefined" : _typeof(trustedTypes)) !== "object" || typeof trustedTypes.createPolicy !== "function") {
    return null;
  }
  var suffix = null;
  var ATTR_NAME = "data-tt-policy-suffix";
  if (document2.currentScript && document2.currentScript.hasAttribute(ATTR_NAME)) {
    suffix = document2.currentScript.getAttribute(ATTR_NAME);
  }
  var policyName = "dompurify" + (suffix ? "#" + suffix : "");
  try {
    return trustedTypes.createPolicy(policyName, {
      createHTML: function createHTML(html$$1) {
        return html$$1;
      }
    });
  } catch (_2) {
    console.warn("TrustedTypes policy " + policyName + " could not be created.");
    return null;
  }
};
function createDOMPurify() {
  var window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
  var DOMPurify = function DOMPurify2(root) {
    return createDOMPurify(root);
  };
  DOMPurify.version = "2.3.6";
  DOMPurify.removed = [];
  if (!window2 || !window2.document || window2.document.nodeType !== 9) {
    DOMPurify.isSupported = false;
    return DOMPurify;
  }
  var originalDocument = window2.document;
  var document2 = window2.document;
  var DocumentFragment2 = window2.DocumentFragment, HTMLTemplateElement = window2.HTMLTemplateElement, Node7 = window2.Node, Element2 = window2.Element, NodeFilter = window2.NodeFilter, _window$NamedNodeMap = window2.NamedNodeMap, NamedNodeMap = _window$NamedNodeMap === void 0 ? window2.NamedNodeMap || window2.MozNamedAttrMap : _window$NamedNodeMap, HTMLFormElement = window2.HTMLFormElement, DOMParser2 = window2.DOMParser, trustedTypes = window2.trustedTypes;
  var ElementPrototype = Element2.prototype;
  var cloneNode = lookupGetter(ElementPrototype, "cloneNode");
  var getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
  var getChildNodes = lookupGetter(ElementPrototype, "childNodes");
  var getParentNode = lookupGetter(ElementPrototype, "parentNode");
  if (typeof HTMLTemplateElement === "function") {
    var template = document2.createElement("template");
    if (template.content && template.content.ownerDocument) {
      document2 = template.content.ownerDocument;
    }
  }
  var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument);
  var emptyHTML = trustedTypesPolicy ? trustedTypesPolicy.createHTML("") : "";
  var _document = document2, implementation4 = _document.implementation, createNodeIterator = _document.createNodeIterator, createDocumentFragment = _document.createDocumentFragment, getElementsByTagName = _document.getElementsByTagName;
  var importNode = originalDocument.importNode;
  var documentMode = {};
  try {
    documentMode = clone2(document2).documentMode ? document2.documentMode : {};
  } catch (_2) {
  }
  var hooks = {};
  DOMPurify.isSupported = typeof getParentNode === "function" && implementation4 && typeof implementation4.createHTMLDocument !== "undefined" && documentMode !== 9;
  var MUSTACHE_EXPR$$1 = MUSTACHE_EXPR, ERB_EXPR$$1 = ERB_EXPR, DATA_ATTR$$1 = DATA_ATTR, ARIA_ATTR$$1 = ARIA_ATTR, IS_SCRIPT_OR_DATA$$1 = IS_SCRIPT_OR_DATA, ATTR_WHITESPACE$$1 = ATTR_WHITESPACE;
  var IS_ALLOWED_URI$$1 = IS_ALLOWED_URI;
  var ALLOWED_TAGS = null;
  var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(html), _toConsumableArray$1(svg), _toConsumableArray$1(svgFilters), _toConsumableArray$1(mathMl), _toConsumableArray$1(text)));
  var ALLOWED_ATTR = null;
  var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray$1(html$1), _toConsumableArray$1(svg$1), _toConsumableArray$1(mathMl$1), _toConsumableArray$1(xml)));
  var CUSTOM_ELEMENT_HANDLING = Object.seal(Object.create(null, {
    tagNameCheck: {
      writable: true,
      configurable: false,
      enumerable: true,
      value: null
    },
    attributeNameCheck: {
      writable: true,
      configurable: false,
      enumerable: true,
      value: null
    },
    allowCustomizedBuiltInElements: {
      writable: true,
      configurable: false,
      enumerable: true,
      value: false
    }
  }));
  var FORBID_TAGS = null;
  var FORBID_ATTR = null;
  var ALLOW_ARIA_ATTR = true;
  var ALLOW_DATA_ATTR = true;
  var ALLOW_UNKNOWN_PROTOCOLS = false;
  var SAFE_FOR_TEMPLATES = false;
  var WHOLE_DOCUMENT = false;
  var SET_CONFIG = false;
  var FORCE_BODY = false;
  var RETURN_DOM = false;
  var RETURN_DOM_FRAGMENT = false;
  var RETURN_TRUSTED_TYPE = false;
  var SANITIZE_DOM = true;
  var KEEP_CONTENT = true;
  var IN_PLACE = false;
  var USE_PROFILES = {};
  var FORBID_CONTENTS = null;
  var DEFAULT_FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
  var DATA_URI_TAGS = null;
  var DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]);
  var URI_SAFE_ATTRIBUTES = null;
  var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]);
  var MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
  var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
  var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
  var NAMESPACE = HTML_NAMESPACE;
  var IS_EMPTY_INPUT = false;
  var PARSER_MEDIA_TYPE = void 0;
  var SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
  var DEFAULT_PARSER_MEDIA_TYPE = "text/html";
  var transformCaseFunc = void 0;
  var CONFIG = null;
  var formElement = document2.createElement("form");
  var isRegexOrFunction = function isRegexOrFunction2(testValue) {
    return testValue instanceof RegExp || testValue instanceof Function;
  };
  var _parseConfig = function _parseConfig2(cfg) {
    if (CONFIG && CONFIG === cfg) {
      return;
    }
    if (!cfg || (typeof cfg === "undefined" ? "undefined" : _typeof(cfg)) !== "object") {
      cfg = {};
    }
    cfg = clone2(cfg);
    ALLOWED_TAGS = "ALLOWED_TAGS" in cfg ? addToSet({}, cfg.ALLOWED_TAGS) : DEFAULT_ALLOWED_TAGS;
    ALLOWED_ATTR = "ALLOWED_ATTR" in cfg ? addToSet({}, cfg.ALLOWED_ATTR) : DEFAULT_ALLOWED_ATTR;
    URI_SAFE_ATTRIBUTES = "ADD_URI_SAFE_ATTR" in cfg ? addToSet(clone2(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR) : DEFAULT_URI_SAFE_ATTRIBUTES;
    DATA_URI_TAGS = "ADD_DATA_URI_TAGS" in cfg ? addToSet(clone2(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS) : DEFAULT_DATA_URI_TAGS;
    FORBID_CONTENTS = "FORBID_CONTENTS" in cfg ? addToSet({}, cfg.FORBID_CONTENTS) : DEFAULT_FORBID_CONTENTS;
    FORBID_TAGS = "FORBID_TAGS" in cfg ? addToSet({}, cfg.FORBID_TAGS) : {};
    FORBID_ATTR = "FORBID_ATTR" in cfg ? addToSet({}, cfg.FORBID_ATTR) : {};
    USE_PROFILES = "USE_PROFILES" in cfg ? cfg.USE_PROFILES : false;
    ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
    ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
    ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false;
    SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false;
    WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false;
    RETURN_DOM = cfg.RETURN_DOM || false;
    RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false;
    RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false;
    FORCE_BODY = cfg.FORCE_BODY || false;
    SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
    KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
    IN_PLACE = cfg.IN_PLACE || false;
    IS_ALLOWED_URI$$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$$1;
    NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
      CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
    }
    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
      CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
    }
    if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === "boolean") {
      CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
    }
    PARSER_MEDIA_TYPE = SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? PARSER_MEDIA_TYPE = DEFAULT_PARSER_MEDIA_TYPE : PARSER_MEDIA_TYPE = cfg.PARSER_MEDIA_TYPE;
    transformCaseFunc = PARSER_MEDIA_TYPE === "application/xhtml+xml" ? function(x) {
      return x;
    } : stringToLowerCase;
    if (SAFE_FOR_TEMPLATES) {
      ALLOW_DATA_ATTR = false;
    }
    if (RETURN_DOM_FRAGMENT) {
      RETURN_DOM = true;
    }
    if (USE_PROFILES) {
      ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(text)));
      ALLOWED_ATTR = [];
      if (USE_PROFILES.html === true) {
        addToSet(ALLOWED_TAGS, html);
        addToSet(ALLOWED_ATTR, html$1);
      }
      if (USE_PROFILES.svg === true) {
        addToSet(ALLOWED_TAGS, svg);
        addToSet(ALLOWED_ATTR, svg$1);
        addToSet(ALLOWED_ATTR, xml);
      }
      if (USE_PROFILES.svgFilters === true) {
        addToSet(ALLOWED_TAGS, svgFilters);
        addToSet(ALLOWED_ATTR, svg$1);
        addToSet(ALLOWED_ATTR, xml);
      }
      if (USE_PROFILES.mathMl === true) {
        addToSet(ALLOWED_TAGS, mathMl);
        addToSet(ALLOWED_ATTR, mathMl$1);
        addToSet(ALLOWED_ATTR, xml);
      }
    }
    if (cfg.ADD_TAGS) {
      if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
        ALLOWED_TAGS = clone2(ALLOWED_TAGS);
      }
      addToSet(ALLOWED_TAGS, cfg.ADD_TAGS);
    }
    if (cfg.ADD_ATTR) {
      if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
        ALLOWED_ATTR = clone2(ALLOWED_ATTR);
      }
      addToSet(ALLOWED_ATTR, cfg.ADD_ATTR);
    }
    if (cfg.ADD_URI_SAFE_ATTR) {
      addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR);
    }
    if (cfg.FORBID_CONTENTS) {
      if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
        FORBID_CONTENTS = clone2(FORBID_CONTENTS);
      }
      addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS);
    }
    if (KEEP_CONTENT) {
      ALLOWED_TAGS["#text"] = true;
    }
    if (WHOLE_DOCUMENT) {
      addToSet(ALLOWED_TAGS, ["html", "head", "body"]);
    }
    if (ALLOWED_TAGS.table) {
      addToSet(ALLOWED_TAGS, ["tbody"]);
      delete FORBID_TAGS.tbody;
    }
    if (freeze) {
      freeze(cfg);
    }
    CONFIG = cfg;
  };
  var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
  var HTML_INTEGRATION_POINTS = addToSet({}, ["foreignobject", "desc", "title", "annotation-xml"]);
  var ALL_SVG_TAGS = addToSet({}, svg);
  addToSet(ALL_SVG_TAGS, svgFilters);
  addToSet(ALL_SVG_TAGS, svgDisallowed);
  var ALL_MATHML_TAGS = addToSet({}, mathMl);
  addToSet(ALL_MATHML_TAGS, mathMlDisallowed);
  var _checkValidNamespace = function _checkValidNamespace2(element) {
    var parent = getParentNode(element);
    if (!parent || !parent.tagName) {
      parent = {
        namespaceURI: HTML_NAMESPACE,
        tagName: "template"
      };
    }
    var tagName = stringToLowerCase(element.tagName);
    var parentTagName = stringToLowerCase(parent.tagName);
    if (element.namespaceURI === SVG_NAMESPACE) {
      if (parent.namespaceURI === HTML_NAMESPACE) {
        return tagName === "svg";
      }
      if (parent.namespaceURI === MATHML_NAMESPACE) {
        return tagName === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
      }
      return Boolean(ALL_SVG_TAGS[tagName]);
    }
    if (element.namespaceURI === MATHML_NAMESPACE) {
      if (parent.namespaceURI === HTML_NAMESPACE) {
        return tagName === "math";
      }
      if (parent.namespaceURI === SVG_NAMESPACE) {
        return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
      }
      return Boolean(ALL_MATHML_TAGS[tagName]);
    }
    if (element.namespaceURI === HTML_NAMESPACE) {
      if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
        return false;
      }
      if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
        return false;
      }
      var commonSvgAndHTMLElements = addToSet({}, ["title", "style", "font", "a", "script"]);
      return !ALL_MATHML_TAGS[tagName] && (commonSvgAndHTMLElements[tagName] || !ALL_SVG_TAGS[tagName]);
    }
    return false;
  };
  var _forceRemove = function _forceRemove2(node) {
    arrayPush(DOMPurify.removed, { element: node });
    try {
      node.parentNode.removeChild(node);
    } catch (_2) {
      try {
        node.outerHTML = emptyHTML;
      } catch (_3) {
        node.remove();
      }
    }
  };
  var _removeAttribute = function _removeAttribute2(name, node) {
    try {
      arrayPush(DOMPurify.removed, {
        attribute: node.getAttributeNode(name),
        from: node
      });
    } catch (_2) {
      arrayPush(DOMPurify.removed, {
        attribute: null,
        from: node
      });
    }
    node.removeAttribute(name);
    if (name === "is" && !ALLOWED_ATTR[name]) {
      if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
        try {
          _forceRemove(node);
        } catch (_2) {
        }
      } else {
        try {
          node.setAttribute(name, "");
        } catch (_2) {
        }
      }
    }
  };
  var _initDocument = function _initDocument2(dirty) {
    var doc = void 0;
    var leadingWhitespace = void 0;
    if (FORCE_BODY) {
      dirty = "<remove></remove>" + dirty;
    } else {
      var matches = stringMatch(dirty, /^[\r\n\t ]+/);
      leadingWhitespace = matches && matches[0];
    }
    if (PARSER_MEDIA_TYPE === "application/xhtml+xml") {
      dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + "</body></html>";
    }
    var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
    if (NAMESPACE === HTML_NAMESPACE) {
      try {
        doc = new DOMParser2().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
      } catch (_2) {
      }
    }
    if (!doc || !doc.documentElement) {
      doc = implementation4.createDocument(NAMESPACE, "template", null);
      try {
        doc.documentElement.innerHTML = IS_EMPTY_INPUT ? "" : dirtyPayload;
      } catch (_2) {
      }
    }
    var body = doc.body || doc.documentElement;
    if (dirty && leadingWhitespace) {
      body.insertBefore(document2.createTextNode(leadingWhitespace), body.childNodes[0] || null);
    }
    if (NAMESPACE === HTML_NAMESPACE) {
      return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0];
    }
    return WHOLE_DOCUMENT ? doc.documentElement : body;
  };
  var _createIterator = function _createIterator2(root) {
    return createNodeIterator.call(
      root.ownerDocument || root,
      root,
      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT,
      null,
      false
    );
  };
  var _isClobbered = function _isClobbered2(elm) {
    return elm instanceof HTMLFormElement && (typeof elm.nodeName !== "string" || typeof elm.textContent !== "string" || typeof elm.removeChild !== "function" || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== "function" || typeof elm.setAttribute !== "function" || typeof elm.namespaceURI !== "string" || typeof elm.insertBefore !== "function");
  };
  var _isNode = function _isNode2(object2) {
    return (typeof Node7 === "undefined" ? "undefined" : _typeof(Node7)) === "object" ? object2 instanceof Node7 : object2 && (typeof object2 === "undefined" ? "undefined" : _typeof(object2)) === "object" && typeof object2.nodeType === "number" && typeof object2.nodeName === "string";
  };
  var _executeHook = function _executeHook2(entryPoint, currentNode, data) {
    if (!hooks[entryPoint]) {
      return;
    }
    arrayForEach(hooks[entryPoint], function(hook) {
      hook.call(DOMPurify, currentNode, data, CONFIG);
    });
  };
  var _sanitizeElements = function _sanitizeElements2(currentNode) {
    var content = void 0;
    _executeHook("beforeSanitizeElements", currentNode, null);
    if (_isClobbered(currentNode)) {
      _forceRemove(currentNode);
      return true;
    }
    if (stringMatch(currentNode.nodeName, /[\u0080-\uFFFF]/)) {
      _forceRemove(currentNode);
      return true;
    }
    var tagName = transformCaseFunc(currentNode.nodeName);
    _executeHook("uponSanitizeElement", currentNode, {
      tagName,
      allowedTags: ALLOWED_TAGS
    });
    if (!_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
      _forceRemove(currentNode);
      return true;
    }
    if (tagName === "select" && regExpTest(/<template/i, currentNode.innerHTML)) {
      _forceRemove(currentNode);
      return true;
    }
    if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
      if (!FORBID_TAGS[tagName] && _basicCustomElementTest(tagName)) {
        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName))
          return false;
        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName))
          return false;
      }
      if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
        var parentNode = getParentNode(currentNode) || currentNode.parentNode;
        var childNodes = getChildNodes(currentNode) || currentNode.childNodes;
        if (childNodes && parentNode) {
          var childCount = childNodes.length;
          for (var i2 = childCount - 1; i2 >= 0; --i2) {
            parentNode.insertBefore(cloneNode(childNodes[i2], true), getNextSibling(currentNode));
          }
        }
      }
      _forceRemove(currentNode);
      return true;
    }
    if (currentNode instanceof Element2 && !_checkValidNamespace(currentNode)) {
      _forceRemove(currentNode);
      return true;
    }
    if ((tagName === "noscript" || tagName === "noembed") && regExpTest(/<\/no(script|embed)/i, currentNode.innerHTML)) {
      _forceRemove(currentNode);
      return true;
    }
    if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {
      content = currentNode.textContent;
      content = stringReplace(content, MUSTACHE_EXPR$$1, " ");
      content = stringReplace(content, ERB_EXPR$$1, " ");
      if (currentNode.textContent !== content) {
        arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
        currentNode.textContent = content;
      }
    }
    _executeHook("afterSanitizeElements", currentNode, null);
    return false;
  };
  var _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
    if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) {
      return false;
    }
    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR$$1, lcName))
      ;
    else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$$1, lcName))
      ;
    else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
      if (_basicCustomElementTest(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) || lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value)))
        ;
      else {
        return false;
      }
    } else if (URI_SAFE_ATTRIBUTES[lcName])
      ;
    else if (regExpTest(IS_ALLOWED_URI$$1, stringReplace(value, ATTR_WHITESPACE$$1, "")))
      ;
    else if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag])
      ;
    else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$$1, stringReplace(value, ATTR_WHITESPACE$$1, "")))
      ;
    else if (!value)
      ;
    else {
      return false;
    }
    return true;
  };
  var _basicCustomElementTest = function _basicCustomElementTest2(tagName) {
    return tagName.indexOf("-") > 0;
  };
  var _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
    var attr = void 0;
    var value = void 0;
    var lcName = void 0;
    var l2 = void 0;
    _executeHook("beforeSanitizeAttributes", currentNode, null);
    var attributes = currentNode.attributes;
    if (!attributes) {
      return;
    }
    var hookEvent = {
      attrName: "",
      attrValue: "",
      keepAttr: true,
      allowedAttributes: ALLOWED_ATTR
    };
    l2 = attributes.length;
    while (l2--) {
      attr = attributes[l2];
      var _attr = attr, name = _attr.name, namespaceURI = _attr.namespaceURI;
      value = stringTrim(attr.value);
      lcName = transformCaseFunc(name);
      hookEvent.attrName = lcName;
      hookEvent.attrValue = value;
      hookEvent.keepAttr = true;
      hookEvent.forceKeepAttr = void 0;
      _executeHook("uponSanitizeAttribute", currentNode, hookEvent);
      value = hookEvent.attrValue;
      if (hookEvent.forceKeepAttr) {
        continue;
      }
      _removeAttribute(name, currentNode);
      if (!hookEvent.keepAttr) {
        continue;
      }
      if (regExpTest(/\/>/i, value)) {
        _removeAttribute(name, currentNode);
        continue;
      }
      if (SAFE_FOR_TEMPLATES) {
        value = stringReplace(value, MUSTACHE_EXPR$$1, " ");
        value = stringReplace(value, ERB_EXPR$$1, " ");
      }
      var lcTag = transformCaseFunc(currentNode.nodeName);
      if (!_isValidAttribute(lcTag, lcName, value)) {
        continue;
      }
      try {
        if (namespaceURI) {
          currentNode.setAttributeNS(namespaceURI, name, value);
        } else {
          currentNode.setAttribute(name, value);
        }
        arrayPop(DOMPurify.removed);
      } catch (_2) {
      }
    }
    _executeHook("afterSanitizeAttributes", currentNode, null);
  };
  var _sanitizeShadowDOM = function _sanitizeShadowDOM2(fragment) {
    var shadowNode = void 0;
    var shadowIterator = _createIterator(fragment);
    _executeHook("beforeSanitizeShadowDOM", fragment, null);
    while (shadowNode = shadowIterator.nextNode()) {
      _executeHook("uponSanitizeShadowNode", shadowNode, null);
      if (_sanitizeElements(shadowNode)) {
        continue;
      }
      if (shadowNode.content instanceof DocumentFragment2) {
        _sanitizeShadowDOM2(shadowNode.content);
      }
      _sanitizeAttributes(shadowNode);
    }
    _executeHook("afterSanitizeShadowDOM", fragment, null);
  };
  DOMPurify.sanitize = function(dirty, cfg) {
    var body = void 0;
    var importedNode = void 0;
    var currentNode = void 0;
    var oldNode = void 0;
    var returnNode = void 0;
    IS_EMPTY_INPUT = !dirty;
    if (IS_EMPTY_INPUT) {
      dirty = "<!-->";
    }
    if (typeof dirty !== "string" && !_isNode(dirty)) {
      if (typeof dirty.toString !== "function") {
        throw typeErrorCreate("toString is not a function");
      } else {
        dirty = dirty.toString();
        if (typeof dirty !== "string") {
          throw typeErrorCreate("dirty is not a string, aborting");
        }
      }
    }
    if (!DOMPurify.isSupported) {
      if (_typeof(window2.toStaticHTML) === "object" || typeof window2.toStaticHTML === "function") {
        if (typeof dirty === "string") {
          return window2.toStaticHTML(dirty);
        }
        if (_isNode(dirty)) {
          return window2.toStaticHTML(dirty.outerHTML);
        }
      }
      return dirty;
    }
    if (!SET_CONFIG) {
      _parseConfig(cfg);
    }
    DOMPurify.removed = [];
    if (typeof dirty === "string") {
      IN_PLACE = false;
    }
    if (IN_PLACE) {
      if (dirty.nodeName) {
        var tagName = transformCaseFunc(dirty.nodeName);
        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
          throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
        }
      }
    } else if (dirty instanceof Node7) {
      body = _initDocument("<!---->");
      importedNode = body.ownerDocument.importNode(dirty, true);
      if (importedNode.nodeType === 1 && importedNode.nodeName === "BODY") {
        body = importedNode;
      } else if (importedNode.nodeName === "HTML") {
        body = importedNode;
      } else {
        body.appendChild(importedNode);
      }
    } else {
      if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && dirty.indexOf("<") === -1) {
        return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
      }
      body = _initDocument(dirty);
      if (!body) {
        return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
      }
    }
    if (body && FORCE_BODY) {
      _forceRemove(body.firstChild);
    }
    var nodeIterator = _createIterator(IN_PLACE ? dirty : body);
    while (currentNode = nodeIterator.nextNode()) {
      if (currentNode.nodeType === 3 && currentNode === oldNode) {
        continue;
      }
      if (_sanitizeElements(currentNode)) {
        continue;
      }
      if (currentNode.content instanceof DocumentFragment2) {
        _sanitizeShadowDOM(currentNode.content);
      }
      _sanitizeAttributes(currentNode);
      oldNode = currentNode;
    }
    oldNode = null;
    if (IN_PLACE) {
      return dirty;
    }
    if (RETURN_DOM) {
      if (RETURN_DOM_FRAGMENT) {
        returnNode = createDocumentFragment.call(body.ownerDocument);
        while (body.firstChild) {
          returnNode.appendChild(body.firstChild);
        }
      } else {
        returnNode = body;
      }
      if (ALLOWED_ATTR.shadowroot) {
        returnNode = importNode.call(originalDocument, returnNode, true);
      }
      return returnNode;
    }
    var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
    if (WHOLE_DOCUMENT && ALLOWED_TAGS["!doctype"] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
      serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
    }
    if (SAFE_FOR_TEMPLATES) {
      serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$$1, " ");
      serializedHTML = stringReplace(serializedHTML, ERB_EXPR$$1, " ");
    }
    return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
  };
  DOMPurify.setConfig = function(cfg) {
    _parseConfig(cfg);
    SET_CONFIG = true;
  };
  DOMPurify.clearConfig = function() {
    CONFIG = null;
    SET_CONFIG = false;
  };
  DOMPurify.isValidAttribute = function(tag, attr, value) {
    if (!CONFIG) {
      _parseConfig({});
    }
    var lcTag = transformCaseFunc(tag);
    var lcName = transformCaseFunc(attr);
    return _isValidAttribute(lcTag, lcName, value);
  };
  DOMPurify.addHook = function(entryPoint, hookFunction) {
    if (typeof hookFunction !== "function") {
      return;
    }
    hooks[entryPoint] = hooks[entryPoint] || [];
    arrayPush(hooks[entryPoint], hookFunction);
  };
  DOMPurify.removeHook = function(entryPoint) {
    if (hooks[entryPoint]) {
      arrayPop(hooks[entryPoint]);
    }
  };
  DOMPurify.removeHooks = function(entryPoint) {
    if (hooks[entryPoint]) {
      hooks[entryPoint] = [];
    }
  };
  DOMPurify.removeAllHooks = function() {
    hooks = {};
  };
  return DOMPurify;
}
var purify = createDOMPurify();

// node_modules/cesium/Source/Core/Credit.js
var nextCreditId = 0;
var creditToId = {};
function Credit(html2, showOnScreen) {
  Check_default.typeOf.string("html", html2);
  let id;
  const key = html2;
  if (defined_default(creditToId[key])) {
    id = creditToId[key];
  } else {
    id = nextCreditId++;
    creditToId[key] = id;
  }
  showOnScreen = defaultValue_default(showOnScreen, false);
  this._id = id;
  this._html = html2;
  this._showOnScreen = showOnScreen;
  this._element = void 0;
}
Object.defineProperties(Credit.prototype, {
  html: {
    get: function() {
      return this._html;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  showOnScreen: {
    get: function() {
      return this._showOnScreen;
    },
    set: function(value) {
      this._showOnScreen = value;
    }
  },
  element: {
    get: function() {
      if (!defined_default(this._element)) {
        const html2 = purify.sanitize(this._html);
        const div = document.createElement("div");
        div._creditId = this._id;
        div.style.display = "inline";
        div.innerHTML = html2;
        const links = div.querySelectorAll("a");
        for (let i2 = 0; i2 < links.length; i2++) {
          links[i2].setAttribute("target", "_blank");
        }
        this._element = div;
      }
      return this._element;
    }
  }
});
Credit.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left._id === right._id && left._showOnScreen === right._showOnScreen;
};
Credit.prototype.equals = function(credit) {
  return Credit.equals(this, credit);
};
Credit.getIonCredit = function(attribution) {
  const showOnScreen = defined_default(attribution.collapsible) && !attribution.collapsible;
  const credit = new Credit(attribution.html, showOnScreen);
  credit._isIon = credit.html.indexOf("ion-credit.png") !== -1;
  return credit;
};
Credit.clone = function(credit) {
  if (defined_default(credit)) {
    return new Credit(credit.html, credit.showOnScreen);
  }
};
var Credit_default = Credit;

// node_modules/cesium/Source/Core/HeightmapEncoding.js
var HeightmapEncoding = {
  NONE: 0,
  LERC: 1
};
var HeightmapEncoding_default = Object.freeze(HeightmapEncoding);

// node_modules/cesium/Source/Core/AxisAlignedBoundingBox.js
function AxisAlignedBoundingBox(minimum, maximum, center) {
  this.minimum = Cartesian3_default.clone(defaultValue_default(minimum, Cartesian3_default.ZERO));
  this.maximum = Cartesian3_default.clone(defaultValue_default(maximum, Cartesian3_default.ZERO));
  if (!defined_default(center)) {
    center = Cartesian3_default.midpoint(this.minimum, this.maximum, new Cartesian3_default());
  } else {
    center = Cartesian3_default.clone(center);
  }
  this.center = center;
}
AxisAlignedBoundingBox.fromCorners = function(minimum, maximum, result) {
  Check_default.defined("minimum", minimum);
  Check_default.defined("maximum", maximum);
  if (!defined_default(result)) {
    result = new AxisAlignedBoundingBox();
  }
  result.minimum = Cartesian3_default.clone(minimum, result.minimum);
  result.maximum = Cartesian3_default.clone(maximum, result.maximum);
  result.center = Cartesian3_default.midpoint(minimum, maximum, result.center);
  return result;
};
AxisAlignedBoundingBox.fromPoints = function(positions, result) {
  if (!defined_default(result)) {
    result = new AxisAlignedBoundingBox();
  }
  if (!defined_default(positions) || positions.length === 0) {
    result.minimum = Cartesian3_default.clone(Cartesian3_default.ZERO, result.minimum);
    result.maximum = Cartesian3_default.clone(Cartesian3_default.ZERO, result.maximum);
    result.center = Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
    return result;
  }
  let minimumX = positions[0].x;
  let minimumY = positions[0].y;
  let minimumZ = positions[0].z;
  let maximumX = positions[0].x;
  let maximumY = positions[0].y;
  let maximumZ = positions[0].z;
  const length3 = positions.length;
  for (let i2 = 1; i2 < length3; i2++) {
    const p2 = positions[i2];
    const x = p2.x;
    const y = p2.y;
    const z = p2.z;
    minimumX = Math.min(x, minimumX);
    maximumX = Math.max(x, maximumX);
    minimumY = Math.min(y, minimumY);
    maximumY = Math.max(y, maximumY);
    minimumZ = Math.min(z, minimumZ);
    maximumZ = Math.max(z, maximumZ);
  }
  const minimum = result.minimum;
  minimum.x = minimumX;
  minimum.y = minimumY;
  minimum.z = minimumZ;
  const maximum = result.maximum;
  maximum.x = maximumX;
  maximum.y = maximumY;
  maximum.z = maximumZ;
  result.center = Cartesian3_default.midpoint(minimum, maximum, result.center);
  return result;
};
AxisAlignedBoundingBox.clone = function(box, result) {
  if (!defined_default(box)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new AxisAlignedBoundingBox(box.minimum, box.maximum, box.center);
  }
  result.minimum = Cartesian3_default.clone(box.minimum, result.minimum);
  result.maximum = Cartesian3_default.clone(box.maximum, result.maximum);
  result.center = Cartesian3_default.clone(box.center, result.center);
  return result;
};
AxisAlignedBoundingBox.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && Cartesian3_default.equals(left.center, right.center) && Cartesian3_default.equals(left.minimum, right.minimum) && Cartesian3_default.equals(left.maximum, right.maximum);
};
var intersectScratch = new Cartesian3_default();
AxisAlignedBoundingBox.intersectPlane = function(box, plane) {
  Check_default.defined("box", box);
  Check_default.defined("plane", plane);
  intersectScratch = Cartesian3_default.subtract(
    box.maximum,
    box.minimum,
    intersectScratch
  );
  const h = Cartesian3_default.multiplyByScalar(
    intersectScratch,
    0.5,
    intersectScratch
  );
  const normal2 = plane.normal;
  const e2 = h.x * Math.abs(normal2.x) + h.y * Math.abs(normal2.y) + h.z * Math.abs(normal2.z);
  const s2 = Cartesian3_default.dot(box.center, normal2) + plane.distance;
  if (s2 - e2 > 0) {
    return Intersect_default.INSIDE;
  }
  if (s2 + e2 < 0) {
    return Intersect_default.OUTSIDE;
  }
  return Intersect_default.INTERSECTING;
};
AxisAlignedBoundingBox.prototype.clone = function(result) {
  return AxisAlignedBoundingBox.clone(this, result);
};
AxisAlignedBoundingBox.prototype.intersectPlane = function(plane) {
  return AxisAlignedBoundingBox.intersectPlane(this, plane);
};
AxisAlignedBoundingBox.prototype.equals = function(right) {
  return AxisAlignedBoundingBox.equals(this, right);
};
var AxisAlignedBoundingBox_default = AxisAlignedBoundingBox;

// node_modules/cesium/Source/Core/EllipsoidalOccluder.js
function EllipsoidalOccluder(ellipsoid, cameraPosition) {
  Check_default.typeOf.object("ellipsoid", ellipsoid);
  this._ellipsoid = ellipsoid;
  this._cameraPosition = new Cartesian3_default();
  this._cameraPositionInScaledSpace = new Cartesian3_default();
  this._distanceToLimbInScaledSpaceSquared = 0;
  if (defined_default(cameraPosition)) {
    this.cameraPosition = cameraPosition;
  }
}
Object.defineProperties(EllipsoidalOccluder.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  },
  cameraPosition: {
    get: function() {
      return this._cameraPosition;
    },
    set: function(cameraPosition) {
      const ellipsoid = this._ellipsoid;
      const cv = ellipsoid.transformPositionToScaledSpace(
        cameraPosition,
        this._cameraPositionInScaledSpace
      );
      const vhMagnitudeSquared = Cartesian3_default.magnitudeSquared(cv) - 1;
      Cartesian3_default.clone(cameraPosition, this._cameraPosition);
      this._cameraPositionInScaledSpace = cv;
      this._distanceToLimbInScaledSpaceSquared = vhMagnitudeSquared;
    }
  }
});
var scratchCartesian = new Cartesian3_default();
EllipsoidalOccluder.prototype.isPointVisible = function(occludee) {
  const ellipsoid = this._ellipsoid;
  const occludeeScaledSpacePosition = ellipsoid.transformPositionToScaledSpace(
    occludee,
    scratchCartesian
  );
  return isScaledSpacePointVisible(
    occludeeScaledSpacePosition,
    this._cameraPositionInScaledSpace,
    this._distanceToLimbInScaledSpaceSquared
  );
};
EllipsoidalOccluder.prototype.isScaledSpacePointVisible = function(occludeeScaledSpacePosition) {
  return isScaledSpacePointVisible(
    occludeeScaledSpacePosition,
    this._cameraPositionInScaledSpace,
    this._distanceToLimbInScaledSpaceSquared
  );
};
var scratchCameraPositionInScaledSpaceShrunk = new Cartesian3_default();
EllipsoidalOccluder.prototype.isScaledSpacePointVisiblePossiblyUnderEllipsoid = function(occludeeScaledSpacePosition, minimumHeight) {
  const ellipsoid = this._ellipsoid;
  let vhMagnitudeSquared;
  let cv;
  if (defined_default(minimumHeight) && minimumHeight < 0 && ellipsoid.minimumRadius > -minimumHeight) {
    cv = scratchCameraPositionInScaledSpaceShrunk;
    cv.x = this._cameraPosition.x / (ellipsoid.radii.x + minimumHeight);
    cv.y = this._cameraPosition.y / (ellipsoid.radii.y + minimumHeight);
    cv.z = this._cameraPosition.z / (ellipsoid.radii.z + minimumHeight);
    vhMagnitudeSquared = cv.x * cv.x + cv.y * cv.y + cv.z * cv.z - 1;
  } else {
    cv = this._cameraPositionInScaledSpace;
    vhMagnitudeSquared = this._distanceToLimbInScaledSpaceSquared;
  }
  return isScaledSpacePointVisible(
    occludeeScaledSpacePosition,
    cv,
    vhMagnitudeSquared
  );
};
EllipsoidalOccluder.prototype.computeHorizonCullingPoint = function(directionToPoint, positions, result) {
  return computeHorizonCullingPointFromPositions(
    this._ellipsoid,
    directionToPoint,
    positions,
    result
  );
};
var scratchEllipsoidShrunk = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
EllipsoidalOccluder.prototype.computeHorizonCullingPointPossiblyUnderEllipsoid = function(directionToPoint, positions, minimumHeight, result) {
  const possiblyShrunkEllipsoid = getPossiblyShrunkEllipsoid(
    this._ellipsoid,
    minimumHeight,
    scratchEllipsoidShrunk
  );
  return computeHorizonCullingPointFromPositions(
    possiblyShrunkEllipsoid,
    directionToPoint,
    positions,
    result
  );
};
EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVertices = function(directionToPoint, vertices, stride, center, result) {
  return computeHorizonCullingPointFromVertices(
    this._ellipsoid,
    directionToPoint,
    vertices,
    stride,
    center,
    result
  );
};
EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid = function(directionToPoint, vertices, stride, center, minimumHeight, result) {
  const possiblyShrunkEllipsoid = getPossiblyShrunkEllipsoid(
    this._ellipsoid,
    minimumHeight,
    scratchEllipsoidShrunk
  );
  return computeHorizonCullingPointFromVertices(
    possiblyShrunkEllipsoid,
    directionToPoint,
    vertices,
    stride,
    center,
    result
  );
};
var subsampleScratch = [];
EllipsoidalOccluder.prototype.computeHorizonCullingPointFromRectangle = function(rectangle, ellipsoid, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  const positions = Rectangle_default.subsample(
    rectangle,
    ellipsoid,
    0,
    subsampleScratch
  );
  const bs = BoundingSphere_default.fromPoints(positions);
  if (Cartesian3_default.magnitude(bs.center) < 0.1 * ellipsoid.minimumRadius) {
    return void 0;
  }
  return this.computeHorizonCullingPoint(bs.center, positions, result);
};
var scratchEllipsoidShrunkRadii = new Cartesian3_default();
function getPossiblyShrunkEllipsoid(ellipsoid, minimumHeight, result) {
  if (defined_default(minimumHeight) && minimumHeight < 0 && ellipsoid.minimumRadius > -minimumHeight) {
    const ellipsoidShrunkRadii = Cartesian3_default.fromElements(
      ellipsoid.radii.x + minimumHeight,
      ellipsoid.radii.y + minimumHeight,
      ellipsoid.radii.z + minimumHeight,
      scratchEllipsoidShrunkRadii
    );
    ellipsoid = Ellipsoid_default.fromCartesian3(ellipsoidShrunkRadii, result);
  }
  return ellipsoid;
}
function computeHorizonCullingPointFromPositions(ellipsoid, directionToPoint, positions, result) {
  Check_default.typeOf.object("directionToPoint", directionToPoint);
  Check_default.defined("positions", positions);
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  const scaledSpaceDirectionToPoint = computeScaledSpaceDirectionToPoint(
    ellipsoid,
    directionToPoint
  );
  let resultMagnitude = 0;
  for (let i2 = 0, len = positions.length; i2 < len; ++i2) {
    const position = positions[i2];
    const candidateMagnitude = computeMagnitude(
      ellipsoid,
      position,
      scaledSpaceDirectionToPoint
    );
    if (candidateMagnitude < 0) {
      return void 0;
    }
    resultMagnitude = Math.max(resultMagnitude, candidateMagnitude);
  }
  return magnitudeToPoint(scaledSpaceDirectionToPoint, resultMagnitude, result);
}
var positionScratch = new Cartesian3_default();
function computeHorizonCullingPointFromVertices(ellipsoid, directionToPoint, vertices, stride, center, result) {
  Check_default.typeOf.object("directionToPoint", directionToPoint);
  Check_default.defined("vertices", vertices);
  Check_default.typeOf.number("stride", stride);
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  stride = defaultValue_default(stride, 3);
  center = defaultValue_default(center, Cartesian3_default.ZERO);
  const scaledSpaceDirectionToPoint = computeScaledSpaceDirectionToPoint(
    ellipsoid,
    directionToPoint
  );
  let resultMagnitude = 0;
  for (let i2 = 0, len = vertices.length; i2 < len; i2 += stride) {
    positionScratch.x = vertices[i2] + center.x;
    positionScratch.y = vertices[i2 + 1] + center.y;
    positionScratch.z = vertices[i2 + 2] + center.z;
    const candidateMagnitude = computeMagnitude(
      ellipsoid,
      positionScratch,
      scaledSpaceDirectionToPoint
    );
    if (candidateMagnitude < 0) {
      return void 0;
    }
    resultMagnitude = Math.max(resultMagnitude, candidateMagnitude);
  }
  return magnitudeToPoint(scaledSpaceDirectionToPoint, resultMagnitude, result);
}
function isScaledSpacePointVisible(occludeeScaledSpacePosition, cameraPositionInScaledSpace, distanceToLimbInScaledSpaceSquared) {
  const cv = cameraPositionInScaledSpace;
  const vhMagnitudeSquared = distanceToLimbInScaledSpaceSquared;
  const vt = Cartesian3_default.subtract(
    occludeeScaledSpacePosition,
    cv,
    scratchCartesian
  );
  const vtDotVc = -Cartesian3_default.dot(vt, cv);
  const isOccluded = vhMagnitudeSquared < 0 ? vtDotVc > 0 : vtDotVc > vhMagnitudeSquared && vtDotVc * vtDotVc / Cartesian3_default.magnitudeSquared(vt) > vhMagnitudeSquared;
  return !isOccluded;
}
var scaledSpaceScratch = new Cartesian3_default();
var directionScratch = new Cartesian3_default();
function computeMagnitude(ellipsoid, position, scaledSpaceDirectionToPoint) {
  const scaledSpacePosition = ellipsoid.transformPositionToScaledSpace(
    position,
    scaledSpaceScratch
  );
  let magnitudeSquared = Cartesian3_default.magnitudeSquared(scaledSpacePosition);
  let magnitude = Math.sqrt(magnitudeSquared);
  const direction2 = Cartesian3_default.divideByScalar(
    scaledSpacePosition,
    magnitude,
    directionScratch
  );
  magnitudeSquared = Math.max(1, magnitudeSquared);
  magnitude = Math.max(1, magnitude);
  const cosAlpha = Cartesian3_default.dot(direction2, scaledSpaceDirectionToPoint);
  const sinAlpha = Cartesian3_default.magnitude(
    Cartesian3_default.cross(direction2, scaledSpaceDirectionToPoint, direction2)
  );
  const cosBeta = 1 / magnitude;
  const sinBeta = Math.sqrt(magnitudeSquared - 1) * cosBeta;
  return 1 / (cosAlpha * cosBeta - sinAlpha * sinBeta);
}
function magnitudeToPoint(scaledSpaceDirectionToPoint, resultMagnitude, result) {
  if (resultMagnitude <= 0 || resultMagnitude === 1 / 0 || resultMagnitude !== resultMagnitude) {
    return void 0;
  }
  return Cartesian3_default.multiplyByScalar(
    scaledSpaceDirectionToPoint,
    resultMagnitude,
    result
  );
}
var directionToPointScratch = new Cartesian3_default();
function computeScaledSpaceDirectionToPoint(ellipsoid, directionToPoint) {
  if (Cartesian3_default.equals(directionToPoint, Cartesian3_default.ZERO)) {
    return directionToPoint;
  }
  ellipsoid.transformPositionToScaledSpace(
    directionToPoint,
    directionToPointScratch
  );
  return Cartesian3_default.normalize(directionToPointScratch, directionToPointScratch);
}
var EllipsoidalOccluder_default = EllipsoidalOccluder;

// node_modules/cesium/Source/Core/QuadraticRealPolynomial.js
var QuadraticRealPolynomial = {};
QuadraticRealPolynomial.computeDiscriminant = function(a4, b, c14) {
  if (typeof a4 !== "number") {
    throw new DeveloperError_default("a is a required number.");
  }
  if (typeof b !== "number") {
    throw new DeveloperError_default("b is a required number.");
  }
  if (typeof c14 !== "number") {
    throw new DeveloperError_default("c is a required number.");
  }
  const discriminant = b * b - 4 * a4 * c14;
  return discriminant;
};
function addWithCancellationCheck(left, right, tolerance) {
  const difference = left + right;
  if (Math_default.sign(left) !== Math_default.sign(right) && Math.abs(difference / Math.max(Math.abs(left), Math.abs(right))) < tolerance) {
    return 0;
  }
  return difference;
}
QuadraticRealPolynomial.computeRealRoots = function(a4, b, c14) {
  if (typeof a4 !== "number") {
    throw new DeveloperError_default("a is a required number.");
  }
  if (typeof b !== "number") {
    throw new DeveloperError_default("b is a required number.");
  }
  if (typeof c14 !== "number") {
    throw new DeveloperError_default("c is a required number.");
  }
  let ratio;
  if (a4 === 0) {
    if (b === 0) {
      return [];
    }
    return [-c14 / b];
  } else if (b === 0) {
    if (c14 === 0) {
      return [0, 0];
    }
    const cMagnitude = Math.abs(c14);
    const aMagnitude = Math.abs(a4);
    if (cMagnitude < aMagnitude && cMagnitude / aMagnitude < Math_default.EPSILON14) {
      return [0, 0];
    } else if (cMagnitude > aMagnitude && aMagnitude / cMagnitude < Math_default.EPSILON14) {
      return [];
    }
    ratio = -c14 / a4;
    if (ratio < 0) {
      return [];
    }
    const root = Math.sqrt(ratio);
    return [-root, root];
  } else if (c14 === 0) {
    ratio = -b / a4;
    if (ratio < 0) {
      return [ratio, 0];
    }
    return [0, ratio];
  }
  const b2 = b * b;
  const four_ac = 4 * a4 * c14;
  const radicand = addWithCancellationCheck(b2, -four_ac, Math_default.EPSILON14);
  if (radicand < 0) {
    return [];
  }
  const q = -0.5 * addWithCancellationCheck(
    b,
    Math_default.sign(b) * Math.sqrt(radicand),
    Math_default.EPSILON14
  );
  if (b > 0) {
    return [q / a4, c14 / q];
  }
  return [c14 / q, q / a4];
};
var QuadraticRealPolynomial_default = QuadraticRealPolynomial;

// node_modules/cesium/Source/Core/CubicRealPolynomial.js
var CubicRealPolynomial = {};
CubicRealPolynomial.computeDiscriminant = function(a4, b, c14, d) {
  if (typeof a4 !== "number") {
    throw new DeveloperError_default("a is a required number.");
  }
  if (typeof b !== "number") {
    throw new DeveloperError_default("b is a required number.");
  }
  if (typeof c14 !== "number") {
    throw new DeveloperError_default("c is a required number.");
  }
  if (typeof d !== "number") {
    throw new DeveloperError_default("d is a required number.");
  }
  const a22 = a4 * a4;
  const b2 = b * b;
  const c22 = c14 * c14;
  const d2 = d * d;
  const discriminant = 18 * a4 * b * c14 * d + b2 * c22 - 27 * a22 * d2 - 4 * (a4 * c22 * c14 + b2 * b * d);
  return discriminant;
};
function computeRealRoots(a4, b, c14, d) {
  const A = a4;
  const B = b / 3;
  const C = c14 / 3;
  const D = d;
  const AC = A * C;
  const BD = B * D;
  const B2 = B * B;
  const C2 = C * C;
  const delta1 = A * C - B2;
  const delta2 = A * D - B * C;
  const delta3 = B * D - C2;
  const discriminant = 4 * delta1 * delta3 - delta2 * delta2;
  let temp;
  let temp1;
  if (discriminant < 0) {
    let ABar;
    let CBar;
    let DBar;
    if (B2 * BD >= AC * C2) {
      ABar = A;
      CBar = delta1;
      DBar = -2 * B * delta1 + A * delta2;
    } else {
      ABar = D;
      CBar = delta3;
      DBar = -D * delta2 + 2 * C * delta3;
    }
    const s2 = DBar < 0 ? -1 : 1;
    const temp0 = -s2 * Math.abs(ABar) * Math.sqrt(-discriminant);
    temp1 = -DBar + temp0;
    const x = temp1 / 2;
    const p2 = x < 0 ? -Math.pow(-x, 1 / 3) : Math.pow(x, 1 / 3);
    const q = temp1 === temp0 ? -p2 : -CBar / p2;
    temp = CBar <= 0 ? p2 + q : -DBar / (p2 * p2 + q * q + CBar);
    if (B2 * BD >= AC * C2) {
      return [(temp - B) / A];
    }
    return [-D / (temp + C)];
  }
  const CBarA = delta1;
  const DBarA = -2 * B * delta1 + A * delta2;
  const CBarD = delta3;
  const DBarD = -D * delta2 + 2 * C * delta3;
  const squareRootOfDiscriminant = Math.sqrt(discriminant);
  const halfSquareRootOf3 = Math.sqrt(3) / 2;
  let theta = Math.abs(Math.atan2(A * squareRootOfDiscriminant, -DBarA) / 3);
  temp = 2 * Math.sqrt(-CBarA);
  let cosine = Math.cos(theta);
  temp1 = temp * cosine;
  let temp3 = temp * (-cosine / 2 - halfSquareRootOf3 * Math.sin(theta));
  const numeratorLarge = temp1 + temp3 > 2 * B ? temp1 - B : temp3 - B;
  const denominatorLarge = A;
  const root1 = numeratorLarge / denominatorLarge;
  theta = Math.abs(Math.atan2(D * squareRootOfDiscriminant, -DBarD) / 3);
  temp = 2 * Math.sqrt(-CBarD);
  cosine = Math.cos(theta);
  temp1 = temp * cosine;
  temp3 = temp * (-cosine / 2 - halfSquareRootOf3 * Math.sin(theta));
  const numeratorSmall = -D;
  const denominatorSmall = temp1 + temp3 < 2 * C ? temp1 + C : temp3 + C;
  const root3 = numeratorSmall / denominatorSmall;
  const E = denominatorLarge * denominatorSmall;
  const F = -numeratorLarge * denominatorSmall - denominatorLarge * numeratorSmall;
  const G = numeratorLarge * numeratorSmall;
  const root2 = (C * F - B * G) / (-B * F + C * E);
  if (root1 <= root2) {
    if (root1 <= root3) {
      if (root2 <= root3) {
        return [root1, root2, root3];
      }
      return [root1, root3, root2];
    }
    return [root3, root1, root2];
  }
  if (root1 <= root3) {
    return [root2, root1, root3];
  }
  if (root2 <= root3) {
    return [root2, root3, root1];
  }
  return [root3, root2, root1];
}
CubicRealPolynomial.computeRealRoots = function(a4, b, c14, d) {
  if (typeof a4 !== "number") {
    throw new DeveloperError_default("a is a required number.");
  }
  if (typeof b !== "number") {
    throw new DeveloperError_default("b is a required number.");
  }
  if (typeof c14 !== "number") {
    throw new DeveloperError_default("c is a required number.");
  }
  if (typeof d !== "number") {
    throw new DeveloperError_default("d is a required number.");
  }
  let roots;
  let ratio;
  if (a4 === 0) {
    return QuadraticRealPolynomial_default.computeRealRoots(b, c14, d);
  } else if (b === 0) {
    if (c14 === 0) {
      if (d === 0) {
        return [0, 0, 0];
      }
      ratio = -d / a4;
      const root = ratio < 0 ? -Math.pow(-ratio, 1 / 3) : Math.pow(ratio, 1 / 3);
      return [root, root, root];
    } else if (d === 0) {
      roots = QuadraticRealPolynomial_default.computeRealRoots(a4, 0, c14);
      if (roots.Length === 0) {
        return [0];
      }
      return [roots[0], 0, roots[1]];
    }
    return computeRealRoots(a4, 0, c14, d);
  } else if (c14 === 0) {
    if (d === 0) {
      ratio = -b / a4;
      if (ratio < 0) {
        return [ratio, 0, 0];
      }
      return [0, 0, ratio];
    }
    return computeRealRoots(a4, b, 0, d);
  } else if (d === 0) {
    roots = QuadraticRealPolynomial_default.computeRealRoots(a4, b, c14);
    if (roots.length === 0) {
      return [0];
    } else if (roots[1] <= 0) {
      return [roots[0], roots[1], 0];
    } else if (roots[0] >= 0) {
      return [0, roots[0], roots[1]];
    }
    return [roots[0], 0, roots[1]];
  }
  return computeRealRoots(a4, b, c14, d);
};
var CubicRealPolynomial_default = CubicRealPolynomial;

// node_modules/cesium/Source/Core/QuarticRealPolynomial.js
var QuarticRealPolynomial = {};
QuarticRealPolynomial.computeDiscriminant = function(a4, b, c14, d, e2) {
  if (typeof a4 !== "number") {
    throw new DeveloperError_default("a is a required number.");
  }
  if (typeof b !== "number") {
    throw new DeveloperError_default("b is a required number.");
  }
  if (typeof c14 !== "number") {
    throw new DeveloperError_default("c is a required number.");
  }
  if (typeof d !== "number") {
    throw new DeveloperError_default("d is a required number.");
  }
  if (typeof e2 !== "number") {
    throw new DeveloperError_default("e is a required number.");
  }
  const a22 = a4 * a4;
  const a32 = a22 * a4;
  const b2 = b * b;
  const b3 = b2 * b;
  const c22 = c14 * c14;
  const c33 = c22 * c14;
  const d2 = d * d;
  const d3 = d2 * d;
  const e22 = e2 * e2;
  const e3 = e22 * e2;
  const discriminant = b2 * c22 * d2 - 4 * b3 * d3 - 4 * a4 * c33 * d2 + 18 * a4 * b * c14 * d3 - 27 * a22 * d2 * d2 + 256 * a32 * e3 + e2 * (18 * b3 * c14 * d - 4 * b2 * c33 + 16 * a4 * c22 * c22 - 80 * a4 * b * c22 * d - 6 * a4 * b2 * d2 + 144 * a22 * c14 * d2) + e22 * (144 * a4 * b2 * c14 - 27 * b2 * b2 - 128 * a22 * c22 - 192 * a22 * b * d);
  return discriminant;
};
function original(a32, a22, a1, a0) {
  const a3Squared = a32 * a32;
  const p2 = a22 - 3 * a3Squared / 8;
  const q = a1 - a22 * a32 / 2 + a3Squared * a32 / 8;
  const r2 = a0 - a1 * a32 / 4 + a22 * a3Squared / 16 - 3 * a3Squared * a3Squared / 256;
  const cubicRoots = CubicRealPolynomial_default.computeRealRoots(
    1,
    2 * p2,
    p2 * p2 - 4 * r2,
    -q * q
  );
  if (cubicRoots.length > 0) {
    const temp = -a32 / 4;
    const hSquared = cubicRoots[cubicRoots.length - 1];
    if (Math.abs(hSquared) < Math_default.EPSILON14) {
      const roots = QuadraticRealPolynomial_default.computeRealRoots(1, p2, r2);
      if (roots.length === 2) {
        const root0 = roots[0];
        const root1 = roots[1];
        let y;
        if (root0 >= 0 && root1 >= 0) {
          const y0 = Math.sqrt(root0);
          const y1 = Math.sqrt(root1);
          return [temp - y1, temp - y0, temp + y0, temp + y1];
        } else if (root0 >= 0 && root1 < 0) {
          y = Math.sqrt(root0);
          return [temp - y, temp + y];
        } else if (root0 < 0 && root1 >= 0) {
          y = Math.sqrt(root1);
          return [temp - y, temp + y];
        }
      }
      return [];
    } else if (hSquared > 0) {
      const h = Math.sqrt(hSquared);
      const m = (p2 + hSquared - q / h) / 2;
      const n2 = (p2 + hSquared + q / h) / 2;
      const roots1 = QuadraticRealPolynomial_default.computeRealRoots(1, h, m);
      const roots2 = QuadraticRealPolynomial_default.computeRealRoots(1, -h, n2);
      if (roots1.length !== 0) {
        roots1[0] += temp;
        roots1[1] += temp;
        if (roots2.length !== 0) {
          roots2[0] += temp;
          roots2[1] += temp;
          if (roots1[1] <= roots2[0]) {
            return [roots1[0], roots1[1], roots2[0], roots2[1]];
          } else if (roots2[1] <= roots1[0]) {
            return [roots2[0], roots2[1], roots1[0], roots1[1]];
          } else if (roots1[0] >= roots2[0] && roots1[1] <= roots2[1]) {
            return [roots2[0], roots1[0], roots1[1], roots2[1]];
          } else if (roots2[0] >= roots1[0] && roots2[1] <= roots1[1]) {
            return [roots1[0], roots2[0], roots2[1], roots1[1]];
          } else if (roots1[0] > roots2[0] && roots1[0] < roots2[1]) {
            return [roots2[0], roots1[0], roots2[1], roots1[1]];
          }
          return [roots1[0], roots2[0], roots1[1], roots2[1]];
        }
        return roots1;
      }
      if (roots2.length !== 0) {
        roots2[0] += temp;
        roots2[1] += temp;
        return roots2;
      }
      return [];
    }
  }
  return [];
}
function neumark(a32, a22, a1, a0) {
  const a1Squared = a1 * a1;
  const a2Squared = a22 * a22;
  const a3Squared = a32 * a32;
  const p2 = -2 * a22;
  const q = a1 * a32 + a2Squared - 4 * a0;
  const r2 = a3Squared * a0 - a1 * a22 * a32 + a1Squared;
  const cubicRoots = CubicRealPolynomial_default.computeRealRoots(1, p2, q, r2);
  if (cubicRoots.length > 0) {
    const y = cubicRoots[0];
    const temp = a22 - y;
    const tempSquared = temp * temp;
    const g1 = a32 / 2;
    const h1 = temp / 2;
    const m = tempSquared - 4 * a0;
    const mError = tempSquared + 4 * Math.abs(a0);
    const n2 = a3Squared - 4 * y;
    const nError = a3Squared + 4 * Math.abs(y);
    let g2;
    let h2;
    if (y < 0 || m * nError < n2 * mError) {
      const squareRootOfN = Math.sqrt(n2);
      g2 = squareRootOfN / 2;
      h2 = squareRootOfN === 0 ? 0 : (a32 * h1 - a1) / squareRootOfN;
    } else {
      const squareRootOfM = Math.sqrt(m);
      g2 = squareRootOfM === 0 ? 0 : (a32 * h1 - a1) / squareRootOfM;
      h2 = squareRootOfM / 2;
    }
    let G;
    let g;
    if (g1 === 0 && g2 === 0) {
      G = 0;
      g = 0;
    } else if (Math_default.sign(g1) === Math_default.sign(g2)) {
      G = g1 + g2;
      g = y / G;
    } else {
      g = g1 - g2;
      G = y / g;
    }
    let H;
    let h;
    if (h1 === 0 && h2 === 0) {
      H = 0;
      h = 0;
    } else if (Math_default.sign(h1) === Math_default.sign(h2)) {
      H = h1 + h2;
      h = a0 / H;
    } else {
      h = h1 - h2;
      H = a0 / h;
    }
    const roots1 = QuadraticRealPolynomial_default.computeRealRoots(1, G, H);
    const roots2 = QuadraticRealPolynomial_default.computeRealRoots(1, g, h);
    if (roots1.length !== 0) {
      if (roots2.length !== 0) {
        if (roots1[1] <= roots2[0]) {
          return [roots1[0], roots1[1], roots2[0], roots2[1]];
        } else if (roots2[1] <= roots1[0]) {
          return [roots2[0], roots2[1], roots1[0], roots1[1]];
        } else if (roots1[0] >= roots2[0] && roots1[1] <= roots2[1]) {
          return [roots2[0], roots1[0], roots1[1], roots2[1]];
        } else if (roots2[0] >= roots1[0] && roots2[1] <= roots1[1]) {
          return [roots1[0], roots2[0], roots2[1], roots1[1]];
        } else if (roots1[0] > roots2[0] && roots1[0] < roots2[1]) {
          return [roots2[0], roots1[0], roots2[1], roots1[1]];
        }
        return [roots1[0], roots2[0], roots1[1], roots2[1]];
      }
      return roots1;
    }
    if (roots2.length !== 0) {
      return roots2;
    }
  }
  return [];
}
QuarticRealPolynomial.computeRealRoots = function(a4, b, c14, d, e2) {
  if (typeof a4 !== "number") {
    throw new DeveloperError_default("a is a required number.");
  }
  if (typeof b !== "number") {
    throw new DeveloperError_default("b is a required number.");
  }
  if (typeof c14 !== "number") {
    throw new DeveloperError_default("c is a required number.");
  }
  if (typeof d !== "number") {
    throw new DeveloperError_default("d is a required number.");
  }
  if (typeof e2 !== "number") {
    throw new DeveloperError_default("e is a required number.");
  }
  if (Math.abs(a4) < Math_default.EPSILON15) {
    return CubicRealPolynomial_default.computeRealRoots(b, c14, d, e2);
  }
  const a32 = b / a4;
  const a22 = c14 / a4;
  const a1 = d / a4;
  const a0 = e2 / a4;
  let k = a32 < 0 ? 1 : 0;
  k += a22 < 0 ? k + 1 : k;
  k += a1 < 0 ? k + 1 : k;
  k += a0 < 0 ? k + 1 : k;
  switch (k) {
    case 0:
      return original(a32, a22, a1, a0);
    case 1:
      return neumark(a32, a22, a1, a0);
    case 2:
      return neumark(a32, a22, a1, a0);
    case 3:
      return original(a32, a22, a1, a0);
    case 4:
      return original(a32, a22, a1, a0);
    case 5:
      return neumark(a32, a22, a1, a0);
    case 6:
      return original(a32, a22, a1, a0);
    case 7:
      return original(a32, a22, a1, a0);
    case 8:
      return neumark(a32, a22, a1, a0);
    case 9:
      return original(a32, a22, a1, a0);
    case 10:
      return original(a32, a22, a1, a0);
    case 11:
      return neumark(a32, a22, a1, a0);
    case 12:
      return original(a32, a22, a1, a0);
    case 13:
      return original(a32, a22, a1, a0);
    case 14:
      return original(a32, a22, a1, a0);
    case 15:
      return original(a32, a22, a1, a0);
    default:
      return void 0;
  }
};
var QuarticRealPolynomial_default = QuarticRealPolynomial;

// node_modules/cesium/Source/Core/Ray.js
function Ray(origin, direction2) {
  direction2 = Cartesian3_default.clone(defaultValue_default(direction2, Cartesian3_default.ZERO));
  if (!Cartesian3_default.equals(direction2, Cartesian3_default.ZERO)) {
    Cartesian3_default.normalize(direction2, direction2);
  }
  this.origin = Cartesian3_default.clone(defaultValue_default(origin, Cartesian3_default.ZERO));
  this.direction = direction2;
}
Ray.clone = function(ray, result) {
  if (!defined_default(ray)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Ray(ray.origin, ray.direction);
  }
  result.origin = Cartesian3_default.clone(ray.origin);
  result.direction = Cartesian3_default.clone(ray.direction);
  return result;
};
Ray.getPoint = function(ray, t, result) {
  Check_default.typeOf.object("ray", ray);
  Check_default.typeOf.number("t", t);
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  result = Cartesian3_default.multiplyByScalar(ray.direction, t, result);
  return Cartesian3_default.add(ray.origin, result, result);
};
var Ray_default = Ray;

// node_modules/cesium/Source/Core/IntersectionTests.js
var IntersectionTests = {};
IntersectionTests.rayPlane = function(ray, plane, result) {
  if (!defined_default(ray)) {
    throw new DeveloperError_default("ray is required.");
  }
  if (!defined_default(plane)) {
    throw new DeveloperError_default("plane is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  const origin = ray.origin;
  const direction2 = ray.direction;
  const normal2 = plane.normal;
  const denominator = Cartesian3_default.dot(normal2, direction2);
  if (Math.abs(denominator) < Math_default.EPSILON15) {
    return void 0;
  }
  const t = (-plane.distance - Cartesian3_default.dot(normal2, origin)) / denominator;
  if (t < 0) {
    return void 0;
  }
  result = Cartesian3_default.multiplyByScalar(direction2, t, result);
  return Cartesian3_default.add(origin, result, result);
};
var scratchEdge0 = new Cartesian3_default();
var scratchEdge1 = new Cartesian3_default();
var scratchPVec = new Cartesian3_default();
var scratchTVec = new Cartesian3_default();
var scratchQVec = new Cartesian3_default();
IntersectionTests.rayTriangleParametric = function(ray, p0, p1, p2, cullBackFaces) {
  if (!defined_default(ray)) {
    throw new DeveloperError_default("ray is required.");
  }
  if (!defined_default(p0)) {
    throw new DeveloperError_default("p0 is required.");
  }
  if (!defined_default(p1)) {
    throw new DeveloperError_default("p1 is required.");
  }
  if (!defined_default(p2)) {
    throw new DeveloperError_default("p2 is required.");
  }
  cullBackFaces = defaultValue_default(cullBackFaces, false);
  const origin = ray.origin;
  const direction2 = ray.direction;
  const edge0 = Cartesian3_default.subtract(p1, p0, scratchEdge0);
  const edge1 = Cartesian3_default.subtract(p2, p0, scratchEdge1);
  const p3 = Cartesian3_default.cross(direction2, edge1, scratchPVec);
  const det = Cartesian3_default.dot(edge0, p3);
  let tvec;
  let q;
  let u3;
  let v7;
  let t;
  if (cullBackFaces) {
    if (det < Math_default.EPSILON6) {
      return void 0;
    }
    tvec = Cartesian3_default.subtract(origin, p0, scratchTVec);
    u3 = Cartesian3_default.dot(tvec, p3);
    if (u3 < 0 || u3 > det) {
      return void 0;
    }
    q = Cartesian3_default.cross(tvec, edge0, scratchQVec);
    v7 = Cartesian3_default.dot(direction2, q);
    if (v7 < 0 || u3 + v7 > det) {
      return void 0;
    }
    t = Cartesian3_default.dot(edge1, q) / det;
  } else {
    if (Math.abs(det) < Math_default.EPSILON6) {
      return void 0;
    }
    const invDet = 1 / det;
    tvec = Cartesian3_default.subtract(origin, p0, scratchTVec);
    u3 = Cartesian3_default.dot(tvec, p3) * invDet;
    if (u3 < 0 || u3 > 1) {
      return void 0;
    }
    q = Cartesian3_default.cross(tvec, edge0, scratchQVec);
    v7 = Cartesian3_default.dot(direction2, q) * invDet;
    if (v7 < 0 || u3 + v7 > 1) {
      return void 0;
    }
    t = Cartesian3_default.dot(edge1, q) * invDet;
  }
  return t;
};
IntersectionTests.rayTriangle = function(ray, p0, p1, p2, cullBackFaces, result) {
  const t = IntersectionTests.rayTriangleParametric(
    ray,
    p0,
    p1,
    p2,
    cullBackFaces
  );
  if (!defined_default(t) || t < 0) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  Cartesian3_default.multiplyByScalar(ray.direction, t, result);
  return Cartesian3_default.add(ray.origin, result, result);
};
var scratchLineSegmentTriangleRay = new Ray_default();
IntersectionTests.lineSegmentTriangle = function(v02, v13, p0, p1, p2, cullBackFaces, result) {
  if (!defined_default(v02)) {
    throw new DeveloperError_default("v0 is required.");
  }
  if (!defined_default(v13)) {
    throw new DeveloperError_default("v1 is required.");
  }
  if (!defined_default(p0)) {
    throw new DeveloperError_default("p0 is required.");
  }
  if (!defined_default(p1)) {
    throw new DeveloperError_default("p1 is required.");
  }
  if (!defined_default(p2)) {
    throw new DeveloperError_default("p2 is required.");
  }
  const ray = scratchLineSegmentTriangleRay;
  Cartesian3_default.clone(v02, ray.origin);
  Cartesian3_default.subtract(v13, v02, ray.direction);
  Cartesian3_default.normalize(ray.direction, ray.direction);
  const t = IntersectionTests.rayTriangleParametric(
    ray,
    p0,
    p1,
    p2,
    cullBackFaces
  );
  if (!defined_default(t) || t < 0 || t > Cartesian3_default.distance(v02, v13)) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  Cartesian3_default.multiplyByScalar(ray.direction, t, result);
  return Cartesian3_default.add(ray.origin, result, result);
};
function solveQuadratic(a4, b, c14, result) {
  const det = b * b - 4 * a4 * c14;
  if (det < 0) {
    return void 0;
  } else if (det > 0) {
    const denom = 1 / (2 * a4);
    const disc = Math.sqrt(det);
    const root0 = (-b + disc) * denom;
    const root1 = (-b - disc) * denom;
    if (root0 < root1) {
      result.root0 = root0;
      result.root1 = root1;
    } else {
      result.root0 = root1;
      result.root1 = root0;
    }
    return result;
  }
  const root = -b / (2 * a4);
  if (root === 0) {
    return void 0;
  }
  result.root0 = result.root1 = root;
  return result;
}
var raySphereRoots = {
  root0: 0,
  root1: 0
};
function raySphere(ray, sphere, result) {
  if (!defined_default(result)) {
    result = new Interval_default();
  }
  const origin = ray.origin;
  const direction2 = ray.direction;
  const center = sphere.center;
  const radiusSquared = sphere.radius * sphere.radius;
  const diff = Cartesian3_default.subtract(origin, center, scratchPVec);
  const a4 = Cartesian3_default.dot(direction2, direction2);
  const b = 2 * Cartesian3_default.dot(direction2, diff);
  const c14 = Cartesian3_default.magnitudeSquared(diff) - radiusSquared;
  const roots = solveQuadratic(a4, b, c14, raySphereRoots);
  if (!defined_default(roots)) {
    return void 0;
  }
  result.start = roots.root0;
  result.stop = roots.root1;
  return result;
}
IntersectionTests.raySphere = function(ray, sphere, result) {
  if (!defined_default(ray)) {
    throw new DeveloperError_default("ray is required.");
  }
  if (!defined_default(sphere)) {
    throw new DeveloperError_default("sphere is required.");
  }
  result = raySphere(ray, sphere, result);
  if (!defined_default(result) || result.stop < 0) {
    return void 0;
  }
  result.start = Math.max(result.start, 0);
  return result;
};
var scratchLineSegmentRay = new Ray_default();
IntersectionTests.lineSegmentSphere = function(p0, p1, sphere, result) {
  if (!defined_default(p0)) {
    throw new DeveloperError_default("p0 is required.");
  }
  if (!defined_default(p1)) {
    throw new DeveloperError_default("p1 is required.");
  }
  if (!defined_default(sphere)) {
    throw new DeveloperError_default("sphere is required.");
  }
  const ray = scratchLineSegmentRay;
  Cartesian3_default.clone(p0, ray.origin);
  const direction2 = Cartesian3_default.subtract(p1, p0, ray.direction);
  const maxT = Cartesian3_default.magnitude(direction2);
  Cartesian3_default.normalize(direction2, direction2);
  result = raySphere(ray, sphere, result);
  if (!defined_default(result) || result.stop < 0 || result.start > maxT) {
    return void 0;
  }
  result.start = Math.max(result.start, 0);
  result.stop = Math.min(result.stop, maxT);
  return result;
};
var scratchQ = new Cartesian3_default();
var scratchW = new Cartesian3_default();
IntersectionTests.rayEllipsoid = function(ray, ellipsoid) {
  if (!defined_default(ray)) {
    throw new DeveloperError_default("ray is required.");
  }
  if (!defined_default(ellipsoid)) {
    throw new DeveloperError_default("ellipsoid is required.");
  }
  const inverseRadii = ellipsoid.oneOverRadii;
  const q = Cartesian3_default.multiplyComponents(inverseRadii, ray.origin, scratchQ);
  const w = Cartesian3_default.multiplyComponents(
    inverseRadii,
    ray.direction,
    scratchW
  );
  const q22 = Cartesian3_default.magnitudeSquared(q);
  const qw = Cartesian3_default.dot(q, w);
  let difference, w2, product, discriminant, temp;
  if (q22 > 1) {
    if (qw >= 0) {
      return void 0;
    }
    const qw2 = qw * qw;
    difference = q22 - 1;
    w2 = Cartesian3_default.magnitudeSquared(w);
    product = w2 * difference;
    if (qw2 < product) {
      return void 0;
    } else if (qw2 > product) {
      discriminant = qw * qw - product;
      temp = -qw + Math.sqrt(discriminant);
      const root0 = temp / w2;
      const root1 = difference / temp;
      if (root0 < root1) {
        return new Interval_default(root0, root1);
      }
      return {
        start: root1,
        stop: root0
      };
    }
    const root = Math.sqrt(difference / w2);
    return new Interval_default(root, root);
  } else if (q22 < 1) {
    difference = q22 - 1;
    w2 = Cartesian3_default.magnitudeSquared(w);
    product = w2 * difference;
    discriminant = qw * qw - product;
    temp = -qw + Math.sqrt(discriminant);
    return new Interval_default(0, temp / w2);
  }
  if (qw < 0) {
    w2 = Cartesian3_default.magnitudeSquared(w);
    return new Interval_default(0, -qw / w2);
  }
  return void 0;
};
function addWithCancellationCheck2(left, right, tolerance) {
  const difference = left + right;
  if (Math_default.sign(left) !== Math_default.sign(right) && Math.abs(difference / Math.max(Math.abs(left), Math.abs(right))) < tolerance) {
    return 0;
  }
  return difference;
}
function quadraticVectorExpression(A, b, c14, x, w) {
  const xSquared = x * x;
  const wSquared = w * w;
  const l2 = (A[Matrix3_default.COLUMN1ROW1] - A[Matrix3_default.COLUMN2ROW2]) * wSquared;
  const l1 = w * (x * addWithCancellationCheck2(
    A[Matrix3_default.COLUMN1ROW0],
    A[Matrix3_default.COLUMN0ROW1],
    Math_default.EPSILON15
  ) + b.y);
  const l0 = A[Matrix3_default.COLUMN0ROW0] * xSquared + A[Matrix3_default.COLUMN2ROW2] * wSquared + x * b.x + c14;
  const r1 = wSquared * addWithCancellationCheck2(
    A[Matrix3_default.COLUMN2ROW1],
    A[Matrix3_default.COLUMN1ROW2],
    Math_default.EPSILON15
  );
  const r0 = w * (x * addWithCancellationCheck2(A[Matrix3_default.COLUMN2ROW0], A[Matrix3_default.COLUMN0ROW2]) + b.z);
  let cosines;
  const solutions = [];
  if (r0 === 0 && r1 === 0) {
    cosines = QuadraticRealPolynomial_default.computeRealRoots(l2, l1, l0);
    if (cosines.length === 0) {
      return solutions;
    }
    const cosine0 = cosines[0];
    const sine0 = Math.sqrt(Math.max(1 - cosine0 * cosine0, 0));
    solutions.push(new Cartesian3_default(x, w * cosine0, w * -sine0));
    solutions.push(new Cartesian3_default(x, w * cosine0, w * sine0));
    if (cosines.length === 2) {
      const cosine1 = cosines[1];
      const sine1 = Math.sqrt(Math.max(1 - cosine1 * cosine1, 0));
      solutions.push(new Cartesian3_default(x, w * cosine1, w * -sine1));
      solutions.push(new Cartesian3_default(x, w * cosine1, w * sine1));
    }
    return solutions;
  }
  const r0Squared = r0 * r0;
  const r1Squared = r1 * r1;
  const l2Squared = l2 * l2;
  const r0r1 = r0 * r1;
  const c42 = l2Squared + r1Squared;
  const c33 = 2 * (l1 * l2 + r0r1);
  const c22 = 2 * l0 * l2 + l1 * l1 - r1Squared + r0Squared;
  const c15 = 2 * (l0 * l1 - r0r1);
  const c0 = l0 * l0 - r0Squared;
  if (c42 === 0 && c33 === 0 && c22 === 0 && c15 === 0) {
    return solutions;
  }
  cosines = QuarticRealPolynomial_default.computeRealRoots(c42, c33, c22, c15, c0);
  const length3 = cosines.length;
  if (length3 === 0) {
    return solutions;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    const cosine = cosines[i2];
    const cosineSquared = cosine * cosine;
    const sineSquared = Math.max(1 - cosineSquared, 0);
    const sine = Math.sqrt(sineSquared);
    let left;
    if (Math_default.sign(l2) === Math_default.sign(l0)) {
      left = addWithCancellationCheck2(
        l2 * cosineSquared + l0,
        l1 * cosine,
        Math_default.EPSILON12
      );
    } else if (Math_default.sign(l0) === Math_default.sign(l1 * cosine)) {
      left = addWithCancellationCheck2(
        l2 * cosineSquared,
        l1 * cosine + l0,
        Math_default.EPSILON12
      );
    } else {
      left = addWithCancellationCheck2(
        l2 * cosineSquared + l1 * cosine,
        l0,
        Math_default.EPSILON12
      );
    }
    const right = addWithCancellationCheck2(
      r1 * cosine,
      r0,
      Math_default.EPSILON15
    );
    const product = left * right;
    if (product < 0) {
      solutions.push(new Cartesian3_default(x, w * cosine, w * sine));
    } else if (product > 0) {
      solutions.push(new Cartesian3_default(x, w * cosine, w * -sine));
    } else if (sine !== 0) {
      solutions.push(new Cartesian3_default(x, w * cosine, w * -sine));
      solutions.push(new Cartesian3_default(x, w * cosine, w * sine));
      ++i2;
    } else {
      solutions.push(new Cartesian3_default(x, w * cosine, w * sine));
    }
  }
  return solutions;
}
var firstAxisScratch = new Cartesian3_default();
var secondAxisScratch = new Cartesian3_default();
var thirdAxisScratch = new Cartesian3_default();
var referenceScratch = new Cartesian3_default();
var bCart = new Cartesian3_default();
var bScratch = new Matrix3_default();
var btScratch = new Matrix3_default();
var diScratch = new Matrix3_default();
var dScratch = new Matrix3_default();
var cScratch = new Matrix3_default();
var tempMatrix = new Matrix3_default();
var aScratch = new Matrix3_default();
var sScratch = new Cartesian3_default();
var closestScratch = new Cartesian3_default();
var surfPointScratch = new Cartographic_default();
IntersectionTests.grazingAltitudeLocation = function(ray, ellipsoid) {
  if (!defined_default(ray)) {
    throw new DeveloperError_default("ray is required.");
  }
  if (!defined_default(ellipsoid)) {
    throw new DeveloperError_default("ellipsoid is required.");
  }
  const position = ray.origin;
  const direction2 = ray.direction;
  if (!Cartesian3_default.equals(position, Cartesian3_default.ZERO)) {
    const normal2 = ellipsoid.geodeticSurfaceNormal(position, firstAxisScratch);
    if (Cartesian3_default.dot(direction2, normal2) >= 0) {
      return position;
    }
  }
  const intersects3 = defined_default(this.rayEllipsoid(ray, ellipsoid));
  const f2 = ellipsoid.transformPositionToScaledSpace(
    direction2,
    firstAxisScratch
  );
  const firstAxis = Cartesian3_default.normalize(f2, f2);
  const reference = Cartesian3_default.mostOrthogonalAxis(f2, referenceScratch);
  const secondAxis = Cartesian3_default.normalize(
    Cartesian3_default.cross(reference, firstAxis, secondAxisScratch),
    secondAxisScratch
  );
  const thirdAxis = Cartesian3_default.normalize(
    Cartesian3_default.cross(firstAxis, secondAxis, thirdAxisScratch),
    thirdAxisScratch
  );
  const B = bScratch;
  B[0] = firstAxis.x;
  B[1] = firstAxis.y;
  B[2] = firstAxis.z;
  B[3] = secondAxis.x;
  B[4] = secondAxis.y;
  B[5] = secondAxis.z;
  B[6] = thirdAxis.x;
  B[7] = thirdAxis.y;
  B[8] = thirdAxis.z;
  const B_T = Matrix3_default.transpose(B, btScratch);
  const D_I = Matrix3_default.fromScale(ellipsoid.radii, diScratch);
  const D = Matrix3_default.fromScale(ellipsoid.oneOverRadii, dScratch);
  const C = cScratch;
  C[0] = 0;
  C[1] = -direction2.z;
  C[2] = direction2.y;
  C[3] = direction2.z;
  C[4] = 0;
  C[5] = -direction2.x;
  C[6] = -direction2.y;
  C[7] = direction2.x;
  C[8] = 0;
  const temp = Matrix3_default.multiply(
    Matrix3_default.multiply(B_T, D, tempMatrix),
    C,
    tempMatrix
  );
  const A = Matrix3_default.multiply(
    Matrix3_default.multiply(temp, D_I, aScratch),
    B,
    aScratch
  );
  const b = Matrix3_default.multiplyByVector(temp, position, bCart);
  const solutions = quadraticVectorExpression(
    A,
    Cartesian3_default.negate(b, firstAxisScratch),
    0,
    0,
    1
  );
  let s2;
  let altitude;
  const length3 = solutions.length;
  if (length3 > 0) {
    let closest = Cartesian3_default.clone(Cartesian3_default.ZERO, closestScratch);
    let maximumValue = Number.NEGATIVE_INFINITY;
    for (let i2 = 0; i2 < length3; ++i2) {
      s2 = Matrix3_default.multiplyByVector(
        D_I,
        Matrix3_default.multiplyByVector(B, solutions[i2], sScratch),
        sScratch
      );
      const v7 = Cartesian3_default.normalize(
        Cartesian3_default.subtract(s2, position, referenceScratch),
        referenceScratch
      );
      const dotProduct = Cartesian3_default.dot(v7, direction2);
      if (dotProduct > maximumValue) {
        maximumValue = dotProduct;
        closest = Cartesian3_default.clone(s2, closest);
      }
    }
    const surfacePoint = ellipsoid.cartesianToCartographic(
      closest,
      surfPointScratch
    );
    maximumValue = Math_default.clamp(maximumValue, 0, 1);
    altitude = Cartesian3_default.magnitude(
      Cartesian3_default.subtract(closest, position, referenceScratch)
    ) * Math.sqrt(1 - maximumValue * maximumValue);
    altitude = intersects3 ? -altitude : altitude;
    surfacePoint.height = altitude;
    return ellipsoid.cartographicToCartesian(surfacePoint, new Cartesian3_default());
  }
  return void 0;
};
var lineSegmentPlaneDifference = new Cartesian3_default();
IntersectionTests.lineSegmentPlane = function(endPoint0, endPoint1, plane, result) {
  if (!defined_default(endPoint0)) {
    throw new DeveloperError_default("endPoint0 is required.");
  }
  if (!defined_default(endPoint1)) {
    throw new DeveloperError_default("endPoint1 is required.");
  }
  if (!defined_default(plane)) {
    throw new DeveloperError_default("plane is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  const difference = Cartesian3_default.subtract(
    endPoint1,
    endPoint0,
    lineSegmentPlaneDifference
  );
  const normal2 = plane.normal;
  const nDotDiff = Cartesian3_default.dot(normal2, difference);
  if (Math.abs(nDotDiff) < Math_default.EPSILON6) {
    return void 0;
  }
  const nDotP0 = Cartesian3_default.dot(normal2, endPoint0);
  const t = -(plane.distance + nDotP0) / nDotDiff;
  if (t < 0 || t > 1) {
    return void 0;
  }
  Cartesian3_default.multiplyByScalar(difference, t, result);
  Cartesian3_default.add(endPoint0, result, result);
  return result;
};
IntersectionTests.trianglePlaneIntersection = function(p0, p1, p2, plane) {
  if (!defined_default(p0) || !defined_default(p1) || !defined_default(p2) || !defined_default(plane)) {
    throw new DeveloperError_default("p0, p1, p2, and plane are required.");
  }
  const planeNormal = plane.normal;
  const planeD = plane.distance;
  const p0Behind = Cartesian3_default.dot(planeNormal, p0) + planeD < 0;
  const p1Behind = Cartesian3_default.dot(planeNormal, p1) + planeD < 0;
  const p2Behind = Cartesian3_default.dot(planeNormal, p2) + planeD < 0;
  let numBehind = 0;
  numBehind += p0Behind ? 1 : 0;
  numBehind += p1Behind ? 1 : 0;
  numBehind += p2Behind ? 1 : 0;
  let u12, u22;
  if (numBehind === 1 || numBehind === 2) {
    u12 = new Cartesian3_default();
    u22 = new Cartesian3_default();
  }
  if (numBehind === 1) {
    if (p0Behind) {
      IntersectionTests.lineSegmentPlane(p0, p1, plane, u12);
      IntersectionTests.lineSegmentPlane(p0, p2, plane, u22);
      return {
        positions: [p0, p1, p2, u12, u22],
        indices: [
          0,
          3,
          4,
          1,
          2,
          4,
          1,
          4,
          3
        ]
      };
    } else if (p1Behind) {
      IntersectionTests.lineSegmentPlane(p1, p2, plane, u12);
      IntersectionTests.lineSegmentPlane(p1, p0, plane, u22);
      return {
        positions: [p0, p1, p2, u12, u22],
        indices: [
          1,
          3,
          4,
          2,
          0,
          4,
          2,
          4,
          3
        ]
      };
    } else if (p2Behind) {
      IntersectionTests.lineSegmentPlane(p2, p0, plane, u12);
      IntersectionTests.lineSegmentPlane(p2, p1, plane, u22);
      return {
        positions: [p0, p1, p2, u12, u22],
        indices: [
          2,
          3,
          4,
          0,
          1,
          4,
          0,
          4,
          3
        ]
      };
    }
  } else if (numBehind === 2) {
    if (!p0Behind) {
      IntersectionTests.lineSegmentPlane(p1, p0, plane, u12);
      IntersectionTests.lineSegmentPlane(p2, p0, plane, u22);
      return {
        positions: [p0, p1, p2, u12, u22],
        indices: [
          1,
          2,
          4,
          1,
          4,
          3,
          0,
          3,
          4
        ]
      };
    } else if (!p1Behind) {
      IntersectionTests.lineSegmentPlane(p2, p1, plane, u12);
      IntersectionTests.lineSegmentPlane(p0, p1, plane, u22);
      return {
        positions: [p0, p1, p2, u12, u22],
        indices: [
          2,
          0,
          4,
          2,
          4,
          3,
          1,
          3,
          4
        ]
      };
    } else if (!p2Behind) {
      IntersectionTests.lineSegmentPlane(p0, p2, plane, u12);
      IntersectionTests.lineSegmentPlane(p1, p2, plane, u22);
      return {
        positions: [p0, p1, p2, u12, u22],
        indices: [
          0,
          1,
          4,
          0,
          4,
          3,
          2,
          3,
          4
        ]
      };
    }
  }
  return void 0;
};
var IntersectionTests_default = IntersectionTests;

// node_modules/cesium/Source/Core/Plane.js
function Plane(normal2, distance2) {
  Check_default.typeOf.object("normal", normal2);
  if (!Math_default.equalsEpsilon(
    Cartesian3_default.magnitude(normal2),
    1,
    Math_default.EPSILON6
  )) {
    throw new DeveloperError_default("normal must be normalized.");
  }
  Check_default.typeOf.number("distance", distance2);
  this.normal = Cartesian3_default.clone(normal2);
  this.distance = distance2;
}
Plane.fromPointNormal = function(point, normal2, result) {
  Check_default.typeOf.object("point", point);
  Check_default.typeOf.object("normal", normal2);
  if (!Math_default.equalsEpsilon(
    Cartesian3_default.magnitude(normal2),
    1,
    Math_default.EPSILON6
  )) {
    throw new DeveloperError_default("normal must be normalized.");
  }
  const distance2 = -Cartesian3_default.dot(normal2, point);
  if (!defined_default(result)) {
    return new Plane(normal2, distance2);
  }
  Cartesian3_default.clone(normal2, result.normal);
  result.distance = distance2;
  return result;
};
var scratchNormal = new Cartesian3_default();
Plane.fromCartesian4 = function(coefficients, result) {
  Check_default.typeOf.object("coefficients", coefficients);
  const normal2 = Cartesian3_default.fromCartesian4(coefficients, scratchNormal);
  const distance2 = coefficients.w;
  if (!Math_default.equalsEpsilon(
    Cartesian3_default.magnitude(normal2),
    1,
    Math_default.EPSILON6
  )) {
    throw new DeveloperError_default("normal must be normalized.");
  }
  if (!defined_default(result)) {
    return new Plane(normal2, distance2);
  }
  Cartesian3_default.clone(normal2, result.normal);
  result.distance = distance2;
  return result;
};
Plane.getPointDistance = function(plane, point) {
  Check_default.typeOf.object("plane", plane);
  Check_default.typeOf.object("point", point);
  return Cartesian3_default.dot(plane.normal, point) + plane.distance;
};
var scratchCartesian2 = new Cartesian3_default();
Plane.projectPointOntoPlane = function(plane, point, result) {
  Check_default.typeOf.object("plane", plane);
  Check_default.typeOf.object("point", point);
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  const pointDistance = Plane.getPointDistance(plane, point);
  const scaledNormal = Cartesian3_default.multiplyByScalar(
    plane.normal,
    pointDistance,
    scratchCartesian2
  );
  return Cartesian3_default.subtract(point, scaledNormal, result);
};
var scratchInverseTranspose = new Matrix4_default();
var scratchPlaneCartesian4 = new Cartesian4_default();
var scratchTransformNormal = new Cartesian3_default();
Plane.transform = function(plane, transform4, result) {
  Check_default.typeOf.object("plane", plane);
  Check_default.typeOf.object("transform", transform4);
  const normal2 = plane.normal;
  const distance2 = plane.distance;
  const inverseTranspose2 = Matrix4_default.inverseTranspose(
    transform4,
    scratchInverseTranspose
  );
  let planeAsCartesian4 = Cartesian4_default.fromElements(
    normal2.x,
    normal2.y,
    normal2.z,
    distance2,
    scratchPlaneCartesian4
  );
  planeAsCartesian4 = Matrix4_default.multiplyByVector(
    inverseTranspose2,
    planeAsCartesian4,
    planeAsCartesian4
  );
  const transformedNormal = Cartesian3_default.fromCartesian4(
    planeAsCartesian4,
    scratchTransformNormal
  );
  planeAsCartesian4 = Cartesian4_default.divideByScalar(
    planeAsCartesian4,
    Cartesian3_default.magnitude(transformedNormal),
    planeAsCartesian4
  );
  return Plane.fromCartesian4(planeAsCartesian4, result);
};
Plane.clone = function(plane, result) {
  Check_default.typeOf.object("plane", plane);
  if (!defined_default(result)) {
    return new Plane(plane.normal, plane.distance);
  }
  Cartesian3_default.clone(plane.normal, result.normal);
  result.distance = plane.distance;
  return result;
};
Plane.equals = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  return left.distance === right.distance && Cartesian3_default.equals(left.normal, right.normal);
};
Plane.ORIGIN_XY_PLANE = Object.freeze(new Plane(Cartesian3_default.UNIT_Z, 0));
Plane.ORIGIN_YZ_PLANE = Object.freeze(new Plane(Cartesian3_default.UNIT_X, 0));
Plane.ORIGIN_ZX_PLANE = Object.freeze(new Plane(Cartesian3_default.UNIT_Y, 0));
var Plane_default = Plane;

// node_modules/cesium/Source/Core/binarySearch.js
function binarySearch(array, itemToFind, comparator) {
  Check_default.defined("array", array);
  Check_default.defined("itemToFind", itemToFind);
  Check_default.defined("comparator", comparator);
  let low = 0;
  let high = array.length - 1;
  let i2;
  let comparison;
  while (low <= high) {
    i2 = ~~((low + high) / 2);
    comparison = comparator(array[i2], itemToFind);
    if (comparison < 0) {
      low = i2 + 1;
      continue;
    }
    if (comparison > 0) {
      high = i2 - 1;
      continue;
    }
    return i2;
  }
  return ~(high + 1);
}
var binarySearch_default = binarySearch;

// node_modules/cesium/Source/Core/EarthOrientationParametersSample.js
function EarthOrientationParametersSample(xPoleWander, yPoleWander, xPoleOffset, yPoleOffset, ut1MinusUtc) {
  this.xPoleWander = xPoleWander;
  this.yPoleWander = yPoleWander;
  this.xPoleOffset = xPoleOffset;
  this.yPoleOffset = yPoleOffset;
  this.ut1MinusUtc = ut1MinusUtc;
}
var EarthOrientationParametersSample_default = EarthOrientationParametersSample;

// node_modules/cesium/Source/Core/GregorianDate.js
function GregorianDate(year, month, day, hour, minute, second, millisecond, isLeapSecond) {
  this.year = year;
  this.month = month;
  this.day = day;
  this.hour = hour;
  this.minute = minute;
  this.second = second;
  this.millisecond = millisecond;
  this.isLeapSecond = isLeapSecond;
}
var GregorianDate_default = GregorianDate;

// node_modules/cesium/Source/Core/isLeapYear.js
function isLeapYear(year) {
  if (year === null || isNaN(year)) {
    throw new DeveloperError_default("year is required and must be a number.");
  }
  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
}
var isLeapYear_default = isLeapYear;

// node_modules/cesium/Source/Core/LeapSecond.js
function LeapSecond(date, offset2) {
  this.julianDate = date;
  this.offset = offset2;
}
var LeapSecond_default = LeapSecond;

// node_modules/cesium/Source/Core/TimeConstants.js
var TimeConstants = {
  SECONDS_PER_MILLISECOND: 1e-3,
  SECONDS_PER_MINUTE: 60,
  MINUTES_PER_HOUR: 60,
  HOURS_PER_DAY: 24,
  SECONDS_PER_HOUR: 3600,
  MINUTES_PER_DAY: 1440,
  SECONDS_PER_DAY: 86400,
  DAYS_PER_JULIAN_CENTURY: 36525,
  PICOSECOND: 1e-9,
  MODIFIED_JULIAN_DATE_DIFFERENCE: 24000005e-1
};
var TimeConstants_default = Object.freeze(TimeConstants);

// node_modules/cesium/Source/Core/TimeStandard.js
var TimeStandard = {
  UTC: 0,
  TAI: 1
};
var TimeStandard_default = Object.freeze(TimeStandard);

// node_modules/cesium/Source/Core/JulianDate.js
var gregorianDateScratch = new GregorianDate_default();
var daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
var daysInLeapFeburary = 29;
function compareLeapSecondDates(leapSecond, dateToFind) {
  return JulianDate.compare(leapSecond.julianDate, dateToFind.julianDate);
}
var binarySearchScratchLeapSecond = new LeapSecond_default();
function convertUtcToTai(julianDate) {
  binarySearchScratchLeapSecond.julianDate = julianDate;
  const leapSeconds = JulianDate.leapSeconds;
  let index2 = binarySearch_default(
    leapSeconds,
    binarySearchScratchLeapSecond,
    compareLeapSecondDates
  );
  if (index2 < 0) {
    index2 = ~index2;
  }
  if (index2 >= leapSeconds.length) {
    index2 = leapSeconds.length - 1;
  }
  let offset2 = leapSeconds[index2].offset;
  if (index2 > 0) {
    const difference = JulianDate.secondsDifference(
      leapSeconds[index2].julianDate,
      julianDate
    );
    if (difference > offset2) {
      index2--;
      offset2 = leapSeconds[index2].offset;
    }
  }
  JulianDate.addSeconds(julianDate, offset2, julianDate);
}
function convertTaiToUtc(julianDate, result) {
  binarySearchScratchLeapSecond.julianDate = julianDate;
  const leapSeconds = JulianDate.leapSeconds;
  let index2 = binarySearch_default(
    leapSeconds,
    binarySearchScratchLeapSecond,
    compareLeapSecondDates
  );
  if (index2 < 0) {
    index2 = ~index2;
  }
  if (index2 === 0) {
    return JulianDate.addSeconds(julianDate, -leapSeconds[0].offset, result);
  }
  if (index2 >= leapSeconds.length) {
    return JulianDate.addSeconds(
      julianDate,
      -leapSeconds[index2 - 1].offset,
      result
    );
  }
  const difference = JulianDate.secondsDifference(
    leapSeconds[index2].julianDate,
    julianDate
  );
  if (difference === 0) {
    return JulianDate.addSeconds(
      julianDate,
      -leapSeconds[index2].offset,
      result
    );
  }
  if (difference <= 1) {
    return void 0;
  }
  return JulianDate.addSeconds(
    julianDate,
    -leapSeconds[--index2].offset,
    result
  );
}
function setComponents(wholeDays, secondsOfDay, julianDate) {
  const extraDays = secondsOfDay / TimeConstants_default.SECONDS_PER_DAY | 0;
  wholeDays += extraDays;
  secondsOfDay -= TimeConstants_default.SECONDS_PER_DAY * extraDays;
  if (secondsOfDay < 0) {
    wholeDays--;
    secondsOfDay += TimeConstants_default.SECONDS_PER_DAY;
  }
  julianDate.dayNumber = wholeDays;
  julianDate.secondsOfDay = secondsOfDay;
  return julianDate;
}
function computeJulianDateComponents(year, month, day, hour, minute, second, millisecond) {
  const a4 = (month - 14) / 12 | 0;
  const b = year + 4800 + a4;
  let dayNumber = (1461 * b / 4 | 0) + (367 * (month - 2 - 12 * a4) / 12 | 0) - (3 * ((b + 100) / 100 | 0) / 4 | 0) + day - 32075;
  hour = hour - 12;
  if (hour < 0) {
    hour += 24;
  }
  const secondsOfDay = second + (hour * TimeConstants_default.SECONDS_PER_HOUR + minute * TimeConstants_default.SECONDS_PER_MINUTE + millisecond * TimeConstants_default.SECONDS_PER_MILLISECOND);
  if (secondsOfDay >= 43200) {
    dayNumber -= 1;
  }
  return [dayNumber, secondsOfDay];
}
var matchCalendarYear = /^(\d{4})$/;
var matchCalendarMonth = /^(\d{4})-(\d{2})$/;
var matchOrdinalDate = /^(\d{4})-?(\d{3})$/;
var matchWeekDate = /^(\d{4})-?W(\d{2})-?(\d{1})?$/;
var matchCalendarDate = /^(\d{4})-?(\d{2})-?(\d{2})$/;
var utcOffset = /([Z+\-])?(\d{2})?:?(\d{2})?$/;
var matchHours = /^(\d{2})(\.\d+)?/.source + utcOffset.source;
var matchHoursMinutes = /^(\d{2}):?(\d{2})(\.\d+)?/.source + utcOffset.source;
var matchHoursMinutesSeconds = /^(\d{2}):?(\d{2}):?(\d{2})(\.\d+)?/.source + utcOffset.source;
var iso8601ErrorMessage = "Invalid ISO 8601 date.";
function JulianDate(julianDayNumber, secondsOfDay, timeStandard) {
  this.dayNumber = void 0;
  this.secondsOfDay = void 0;
  julianDayNumber = defaultValue_default(julianDayNumber, 0);
  secondsOfDay = defaultValue_default(secondsOfDay, 0);
  timeStandard = defaultValue_default(timeStandard, TimeStandard_default.UTC);
  const wholeDays = julianDayNumber | 0;
  secondsOfDay = secondsOfDay + (julianDayNumber - wholeDays) * TimeConstants_default.SECONDS_PER_DAY;
  setComponents(wholeDays, secondsOfDay, this);
  if (timeStandard === TimeStandard_default.UTC) {
    convertUtcToTai(this);
  }
}
JulianDate.fromGregorianDate = function(date, result) {
  if (!(date instanceof GregorianDate_default)) {
    throw new DeveloperError_default("date must be a valid GregorianDate.");
  }
  const components = computeJulianDateComponents(
    date.year,
    date.month,
    date.day,
    date.hour,
    date.minute,
    date.second,
    date.millisecond
  );
  if (!defined_default(result)) {
    return new JulianDate(components[0], components[1], TimeStandard_default.UTC);
  }
  setComponents(components[0], components[1], result);
  convertUtcToTai(result);
  return result;
};
JulianDate.fromDate = function(date, result) {
  if (!(date instanceof Date) || isNaN(date.getTime())) {
    throw new DeveloperError_default("date must be a valid JavaScript Date.");
  }
  const components = computeJulianDateComponents(
    date.getUTCFullYear(),
    date.getUTCMonth() + 1,
    date.getUTCDate(),
    date.getUTCHours(),
    date.getUTCMinutes(),
    date.getUTCSeconds(),
    date.getUTCMilliseconds()
  );
  if (!defined_default(result)) {
    return new JulianDate(components[0], components[1], TimeStandard_default.UTC);
  }
  setComponents(components[0], components[1], result);
  convertUtcToTai(result);
  return result;
};
JulianDate.fromIso8601 = function(iso8601String, result) {
  if (typeof iso8601String !== "string") {
    throw new DeveloperError_default(iso8601ErrorMessage);
  }
  iso8601String = iso8601String.replace(",", ".");
  let tokens = iso8601String.split("T");
  let year;
  let month = 1;
  let day = 1;
  let hour = 0;
  let minute = 0;
  let second = 0;
  let millisecond = 0;
  const date = tokens[0];
  const time = tokens[1];
  let tmp2;
  let inLeapYear;
  if (!defined_default(date)) {
    throw new DeveloperError_default(iso8601ErrorMessage);
  }
  let dashCount;
  tokens = date.match(matchCalendarDate);
  if (tokens !== null) {
    dashCount = date.split("-").length - 1;
    if (dashCount > 0 && dashCount !== 2) {
      throw new DeveloperError_default(iso8601ErrorMessage);
    }
    year = +tokens[1];
    month = +tokens[2];
    day = +tokens[3];
  } else {
    tokens = date.match(matchCalendarMonth);
    if (tokens !== null) {
      year = +tokens[1];
      month = +tokens[2];
    } else {
      tokens = date.match(matchCalendarYear);
      if (tokens !== null) {
        year = +tokens[1];
      } else {
        let dayOfYear;
        tokens = date.match(matchOrdinalDate);
        if (tokens !== null) {
          year = +tokens[1];
          dayOfYear = +tokens[2];
          inLeapYear = isLeapYear_default(year);
          if (dayOfYear < 1 || inLeapYear && dayOfYear > 366 || !inLeapYear && dayOfYear > 365) {
            throw new DeveloperError_default(iso8601ErrorMessage);
          }
        } else {
          tokens = date.match(matchWeekDate);
          if (tokens !== null) {
            year = +tokens[1];
            const weekNumber = +tokens[2];
            const dayOfWeek = +tokens[3] || 0;
            dashCount = date.split("-").length - 1;
            if (dashCount > 0 && (!defined_default(tokens[3]) && dashCount !== 1 || defined_default(tokens[3]) && dashCount !== 2)) {
              throw new DeveloperError_default(iso8601ErrorMessage);
            }
            const january4 = new Date(Date.UTC(year, 0, 4));
            dayOfYear = weekNumber * 7 + dayOfWeek - january4.getUTCDay() - 3;
          } else {
            throw new DeveloperError_default(iso8601ErrorMessage);
          }
        }
        tmp2 = new Date(Date.UTC(year, 0, 1));
        tmp2.setUTCDate(dayOfYear);
        month = tmp2.getUTCMonth() + 1;
        day = tmp2.getUTCDate();
      }
    }
  }
  inLeapYear = isLeapYear_default(year);
  if (month < 1 || month > 12 || day < 1 || (month !== 2 || !inLeapYear) && day > daysInMonth[month - 1] || inLeapYear && month === 2 && day > daysInLeapFeburary) {
    throw new DeveloperError_default(iso8601ErrorMessage);
  }
  let offsetIndex;
  if (defined_default(time)) {
    tokens = time.match(matchHoursMinutesSeconds);
    if (tokens !== null) {
      dashCount = time.split(":").length - 1;
      if (dashCount > 0 && dashCount !== 2 && dashCount !== 3) {
        throw new DeveloperError_default(iso8601ErrorMessage);
      }
      hour = +tokens[1];
      minute = +tokens[2];
      second = +tokens[3];
      millisecond = +(tokens[4] || 0) * 1e3;
      offsetIndex = 5;
    } else {
      tokens = time.match(matchHoursMinutes);
      if (tokens !== null) {
        dashCount = time.split(":").length - 1;
        if (dashCount > 2) {
          throw new DeveloperError_default(iso8601ErrorMessage);
        }
        hour = +tokens[1];
        minute = +tokens[2];
        second = +(tokens[3] || 0) * 60;
        offsetIndex = 4;
      } else {
        tokens = time.match(matchHours);
        if (tokens !== null) {
          hour = +tokens[1];
          minute = +(tokens[2] || 0) * 60;
          offsetIndex = 3;
        } else {
          throw new DeveloperError_default(iso8601ErrorMessage);
        }
      }
    }
    if (minute >= 60 || second >= 61 || hour > 24 || hour === 24 && (minute > 0 || second > 0 || millisecond > 0)) {
      throw new DeveloperError_default(iso8601ErrorMessage);
    }
    const offset2 = tokens[offsetIndex];
    const offsetHours = +tokens[offsetIndex + 1];
    const offsetMinutes = +(tokens[offsetIndex + 2] || 0);
    switch (offset2) {
      case "+":
        hour = hour - offsetHours;
        minute = minute - offsetMinutes;
        break;
      case "-":
        hour = hour + offsetHours;
        minute = minute + offsetMinutes;
        break;
      case "Z":
        break;
      default:
        minute = minute + new Date(
          Date.UTC(year, month - 1, day, hour, minute)
        ).getTimezoneOffset();
        break;
    }
  }
  const isLeapSecond = second === 60;
  if (isLeapSecond) {
    second--;
  }
  while (minute >= 60) {
    minute -= 60;
    hour++;
  }
  while (hour >= 24) {
    hour -= 24;
    day++;
  }
  tmp2 = inLeapYear && month === 2 ? daysInLeapFeburary : daysInMonth[month - 1];
  while (day > tmp2) {
    day -= tmp2;
    month++;
    if (month > 12) {
      month -= 12;
      year++;
    }
    tmp2 = inLeapYear && month === 2 ? daysInLeapFeburary : daysInMonth[month - 1];
  }
  while (minute < 0) {
    minute += 60;
    hour--;
  }
  while (hour < 0) {
    hour += 24;
    day--;
  }
  while (day < 1) {
    month--;
    if (month < 1) {
      month += 12;
      year--;
    }
    tmp2 = inLeapYear && month === 2 ? daysInLeapFeburary : daysInMonth[month - 1];
    day += tmp2;
  }
  const components = computeJulianDateComponents(
    year,
    month,
    day,
    hour,
    minute,
    second,
    millisecond
  );
  if (!defined_default(result)) {
    result = new JulianDate(components[0], components[1], TimeStandard_default.UTC);
  } else {
    setComponents(components[0], components[1], result);
    convertUtcToTai(result);
  }
  if (isLeapSecond) {
    JulianDate.addSeconds(result, 1, result);
  }
  return result;
};
JulianDate.now = function(result) {
  return JulianDate.fromDate(new Date(), result);
};
var toGregorianDateScratch = new JulianDate(0, 0, TimeStandard_default.TAI);
JulianDate.toGregorianDate = function(julianDate, result) {
  if (!defined_default(julianDate)) {
    throw new DeveloperError_default("julianDate is required.");
  }
  let isLeapSecond = false;
  let thisUtc = convertTaiToUtc(julianDate, toGregorianDateScratch);
  if (!defined_default(thisUtc)) {
    JulianDate.addSeconds(julianDate, -1, toGregorianDateScratch);
    thisUtc = convertTaiToUtc(toGregorianDateScratch, toGregorianDateScratch);
    isLeapSecond = true;
  }
  let julianDayNumber = thisUtc.dayNumber;
  const secondsOfDay = thisUtc.secondsOfDay;
  if (secondsOfDay >= 43200) {
    julianDayNumber += 1;
  }
  let L = julianDayNumber + 68569 | 0;
  const N = 4 * L / 146097 | 0;
  L = L - ((146097 * N + 3) / 4 | 0) | 0;
  const I = 4e3 * (L + 1) / 1461001 | 0;
  L = L - (1461 * I / 4 | 0) + 31 | 0;
  const J = 80 * L / 2447 | 0;
  const day = L - (2447 * J / 80 | 0) | 0;
  L = J / 11 | 0;
  const month = J + 2 - 12 * L | 0;
  const year = 100 * (N - 49) + I + L | 0;
  let hour = secondsOfDay / TimeConstants_default.SECONDS_PER_HOUR | 0;
  let remainingSeconds = secondsOfDay - hour * TimeConstants_default.SECONDS_PER_HOUR;
  const minute = remainingSeconds / TimeConstants_default.SECONDS_PER_MINUTE | 0;
  remainingSeconds = remainingSeconds - minute * TimeConstants_default.SECONDS_PER_MINUTE;
  let second = remainingSeconds | 0;
  const millisecond = (remainingSeconds - second) / TimeConstants_default.SECONDS_PER_MILLISECOND;
  hour += 12;
  if (hour > 23) {
    hour -= 24;
  }
  if (isLeapSecond) {
    second += 1;
  }
  if (!defined_default(result)) {
    return new GregorianDate_default(
      year,
      month,
      day,
      hour,
      minute,
      second,
      millisecond,
      isLeapSecond
    );
  }
  result.year = year;
  result.month = month;
  result.day = day;
  result.hour = hour;
  result.minute = minute;
  result.second = second;
  result.millisecond = millisecond;
  result.isLeapSecond = isLeapSecond;
  return result;
};
JulianDate.toDate = function(julianDate) {
  if (!defined_default(julianDate)) {
    throw new DeveloperError_default("julianDate is required.");
  }
  const gDate = JulianDate.toGregorianDate(julianDate, gregorianDateScratch);
  let second = gDate.second;
  if (gDate.isLeapSecond) {
    second -= 1;
  }
  return new Date(
    Date.UTC(
      gDate.year,
      gDate.month - 1,
      gDate.day,
      gDate.hour,
      gDate.minute,
      second,
      gDate.millisecond
    )
  );
};
JulianDate.toIso8601 = function(julianDate, precision) {
  if (!defined_default(julianDate)) {
    throw new DeveloperError_default("julianDate is required.");
  }
  const gDate = JulianDate.toGregorianDate(julianDate, gregorianDateScratch);
  let year = gDate.year;
  let month = gDate.month;
  let day = gDate.day;
  let hour = gDate.hour;
  const minute = gDate.minute;
  const second = gDate.second;
  const millisecond = gDate.millisecond;
  if (year === 1e4 && month === 1 && day === 1 && hour === 0 && minute === 0 && second === 0 && millisecond === 0) {
    year = 9999;
    month = 12;
    day = 31;
    hour = 24;
  }
  let millisecondStr;
  if (!defined_default(precision) && millisecond !== 0) {
    millisecondStr = (millisecond * 0.01).toString().replace(".", "");
    return `${year.toString().padStart(4, "0")}-${month.toString().padStart(2, "0")}-${day.toString().padStart(2, "0")}T${hour.toString().padStart(2, "0")}:${minute.toString().padStart(2, "0")}:${second.toString().padStart(2, "0")}.${millisecondStr}Z`;
  }
  if (!defined_default(precision) || precision === 0) {
    return `${year.toString().padStart(4, "0")}-${month.toString().padStart(2, "0")}-${day.toString().padStart(2, "0")}T${hour.toString().padStart(2, "0")}:${minute.toString().padStart(2, "0")}:${second.toString().padStart(2, "0")}Z`;
  }
  millisecondStr = (millisecond * 0.01).toFixed(precision).replace(".", "").slice(0, precision);
  return `${year.toString().padStart(4, "0")}-${month.toString().padStart(2, "0")}-${day.toString().padStart(2, "0")}T${hour.toString().padStart(2, "0")}:${minute.toString().padStart(2, "0")}:${second.toString().padStart(2, "0")}.${millisecondStr}Z`;
};
JulianDate.clone = function(julianDate, result) {
  if (!defined_default(julianDate)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new JulianDate(
      julianDate.dayNumber,
      julianDate.secondsOfDay,
      TimeStandard_default.TAI
    );
  }
  result.dayNumber = julianDate.dayNumber;
  result.secondsOfDay = julianDate.secondsOfDay;
  return result;
};
JulianDate.compare = function(left, right) {
  if (!defined_default(left)) {
    throw new DeveloperError_default("left is required.");
  }
  if (!defined_default(right)) {
    throw new DeveloperError_default("right is required.");
  }
  const julianDayNumberDifference = left.dayNumber - right.dayNumber;
  if (julianDayNumberDifference !== 0) {
    return julianDayNumberDifference;
  }
  return left.secondsOfDay - right.secondsOfDay;
};
JulianDate.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.dayNumber === right.dayNumber && left.secondsOfDay === right.secondsOfDay;
};
JulianDate.equalsEpsilon = function(left, right, epsilon) {
  epsilon = defaultValue_default(epsilon, 0);
  return left === right || defined_default(left) && defined_default(right) && Math.abs(JulianDate.secondsDifference(left, right)) <= epsilon;
};
JulianDate.totalDays = function(julianDate) {
  if (!defined_default(julianDate)) {
    throw new DeveloperError_default("julianDate is required.");
  }
  return julianDate.dayNumber + julianDate.secondsOfDay / TimeConstants_default.SECONDS_PER_DAY;
};
JulianDate.secondsDifference = function(left, right) {
  if (!defined_default(left)) {
    throw new DeveloperError_default("left is required.");
  }
  if (!defined_default(right)) {
    throw new DeveloperError_default("right is required.");
  }
  const dayDifference = (left.dayNumber - right.dayNumber) * TimeConstants_default.SECONDS_PER_DAY;
  return dayDifference + (left.secondsOfDay - right.secondsOfDay);
};
JulianDate.daysDifference = function(left, right) {
  if (!defined_default(left)) {
    throw new DeveloperError_default("left is required.");
  }
  if (!defined_default(right)) {
    throw new DeveloperError_default("right is required.");
  }
  const dayDifference = left.dayNumber - right.dayNumber;
  const secondDifference = (left.secondsOfDay - right.secondsOfDay) / TimeConstants_default.SECONDS_PER_DAY;
  return dayDifference + secondDifference;
};
JulianDate.computeTaiMinusUtc = function(julianDate) {
  binarySearchScratchLeapSecond.julianDate = julianDate;
  const leapSeconds = JulianDate.leapSeconds;
  let index2 = binarySearch_default(
    leapSeconds,
    binarySearchScratchLeapSecond,
    compareLeapSecondDates
  );
  if (index2 < 0) {
    index2 = ~index2;
    --index2;
    if (index2 < 0) {
      index2 = 0;
    }
  }
  return leapSeconds[index2].offset;
};
JulianDate.addSeconds = function(julianDate, seconds, result) {
  if (!defined_default(julianDate)) {
    throw new DeveloperError_default("julianDate is required.");
  }
  if (!defined_default(seconds)) {
    throw new DeveloperError_default("seconds is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  return setComponents(
    julianDate.dayNumber,
    julianDate.secondsOfDay + seconds,
    result
  );
};
JulianDate.addMinutes = function(julianDate, minutes, result) {
  if (!defined_default(julianDate)) {
    throw new DeveloperError_default("julianDate is required.");
  }
  if (!defined_default(minutes)) {
    throw new DeveloperError_default("minutes is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const newSecondsOfDay = julianDate.secondsOfDay + minutes * TimeConstants_default.SECONDS_PER_MINUTE;
  return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
};
JulianDate.addHours = function(julianDate, hours, result) {
  if (!defined_default(julianDate)) {
    throw new DeveloperError_default("julianDate is required.");
  }
  if (!defined_default(hours)) {
    throw new DeveloperError_default("hours is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const newSecondsOfDay = julianDate.secondsOfDay + hours * TimeConstants_default.SECONDS_PER_HOUR;
  return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
};
JulianDate.addDays = function(julianDate, days, result) {
  if (!defined_default(julianDate)) {
    throw new DeveloperError_default("julianDate is required.");
  }
  if (!defined_default(days)) {
    throw new DeveloperError_default("days is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const newJulianDayNumber = julianDate.dayNumber + days;
  return setComponents(newJulianDayNumber, julianDate.secondsOfDay, result);
};
JulianDate.lessThan = function(left, right) {
  return JulianDate.compare(left, right) < 0;
};
JulianDate.lessThanOrEquals = function(left, right) {
  return JulianDate.compare(left, right) <= 0;
};
JulianDate.greaterThan = function(left, right) {
  return JulianDate.compare(left, right) > 0;
};
JulianDate.greaterThanOrEquals = function(left, right) {
  return JulianDate.compare(left, right) >= 0;
};
JulianDate.prototype.clone = function(result) {
  return JulianDate.clone(this, result);
};
JulianDate.prototype.equals = function(right) {
  return JulianDate.equals(this, right);
};
JulianDate.prototype.equalsEpsilon = function(right, epsilon) {
  return JulianDate.equalsEpsilon(this, right, epsilon);
};
JulianDate.prototype.toString = function() {
  return JulianDate.toIso8601(this);
};
JulianDate.leapSeconds = [
  new LeapSecond_default(new JulianDate(2441317, 43210, TimeStandard_default.TAI), 10),
  new LeapSecond_default(new JulianDate(2441499, 43211, TimeStandard_default.TAI), 11),
  new LeapSecond_default(new JulianDate(2441683, 43212, TimeStandard_default.TAI), 12),
  new LeapSecond_default(new JulianDate(2442048, 43213, TimeStandard_default.TAI), 13),
  new LeapSecond_default(new JulianDate(2442413, 43214, TimeStandard_default.TAI), 14),
  new LeapSecond_default(new JulianDate(2442778, 43215, TimeStandard_default.TAI), 15),
  new LeapSecond_default(new JulianDate(2443144, 43216, TimeStandard_default.TAI), 16),
  new LeapSecond_default(new JulianDate(2443509, 43217, TimeStandard_default.TAI), 17),
  new LeapSecond_default(new JulianDate(2443874, 43218, TimeStandard_default.TAI), 18),
  new LeapSecond_default(new JulianDate(2444239, 43219, TimeStandard_default.TAI), 19),
  new LeapSecond_default(new JulianDate(2444786, 43220, TimeStandard_default.TAI), 20),
  new LeapSecond_default(new JulianDate(2445151, 43221, TimeStandard_default.TAI), 21),
  new LeapSecond_default(new JulianDate(2445516, 43222, TimeStandard_default.TAI), 22),
  new LeapSecond_default(new JulianDate(2446247, 43223, TimeStandard_default.TAI), 23),
  new LeapSecond_default(new JulianDate(2447161, 43224, TimeStandard_default.TAI), 24),
  new LeapSecond_default(new JulianDate(2447892, 43225, TimeStandard_default.TAI), 25),
  new LeapSecond_default(new JulianDate(2448257, 43226, TimeStandard_default.TAI), 26),
  new LeapSecond_default(new JulianDate(2448804, 43227, TimeStandard_default.TAI), 27),
  new LeapSecond_default(new JulianDate(2449169, 43228, TimeStandard_default.TAI), 28),
  new LeapSecond_default(new JulianDate(2449534, 43229, TimeStandard_default.TAI), 29),
  new LeapSecond_default(new JulianDate(2450083, 43230, TimeStandard_default.TAI), 30),
  new LeapSecond_default(new JulianDate(2450630, 43231, TimeStandard_default.TAI), 31),
  new LeapSecond_default(new JulianDate(2451179, 43232, TimeStandard_default.TAI), 32),
  new LeapSecond_default(new JulianDate(2453736, 43233, TimeStandard_default.TAI), 33),
  new LeapSecond_default(new JulianDate(2454832, 43234, TimeStandard_default.TAI), 34),
  new LeapSecond_default(new JulianDate(2456109, 43235, TimeStandard_default.TAI), 35),
  new LeapSecond_default(new JulianDate(2457204, 43236, TimeStandard_default.TAI), 36),
  new LeapSecond_default(new JulianDate(2457754, 43237, TimeStandard_default.TAI), 37)
];
var JulianDate_default = JulianDate;

// node_modules/cesium/Source/Core/EarthOrientationParameters.js
function EarthOrientationParameters(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._dates = void 0;
  this._samples = void 0;
  this._dateColumn = -1;
  this._xPoleWanderRadiansColumn = -1;
  this._yPoleWanderRadiansColumn = -1;
  this._ut1MinusUtcSecondsColumn = -1;
  this._xCelestialPoleOffsetRadiansColumn = -1;
  this._yCelestialPoleOffsetRadiansColumn = -1;
  this._taiMinusUtcSecondsColumn = -1;
  this._columnCount = 0;
  this._lastIndex = -1;
  this._downloadPromise = void 0;
  this._dataError = void 0;
  this._addNewLeapSeconds = defaultValue_default(options.addNewLeapSeconds, true);
  if (defined_default(options.data)) {
    onDataReady(this, options.data);
  } else if (defined_default(options.url)) {
    const resource = Resource_default.createIfNeeded(options.url);
    const that = this;
    this._downloadPromise = resource.fetchJson().then(function(eopData) {
      onDataReady(that, eopData);
    }).catch(function() {
      that._dataError = `An error occurred while retrieving the EOP data from the URL ${resource.url}.`;
    });
  } else {
    onDataReady(this, {
      columnNames: [
        "dateIso8601",
        "modifiedJulianDateUtc",
        "xPoleWanderRadians",
        "yPoleWanderRadians",
        "ut1MinusUtcSeconds",
        "lengthOfDayCorrectionSeconds",
        "xCelestialPoleOffsetRadians",
        "yCelestialPoleOffsetRadians",
        "taiMinusUtcSeconds"
      ],
      samples: []
    });
  }
}
EarthOrientationParameters.NONE = Object.freeze({
  getPromiseToLoad: function() {
    return Promise.resolve();
  },
  compute: function(date, result) {
    if (!defined_default(result)) {
      result = new EarthOrientationParametersSample_default(0, 0, 0, 0, 0);
    } else {
      result.xPoleWander = 0;
      result.yPoleWander = 0;
      result.xPoleOffset = 0;
      result.yPoleOffset = 0;
      result.ut1MinusUtc = 0;
    }
    return result;
  }
});
EarthOrientationParameters.prototype.getPromiseToLoad = function() {
  return Promise.resolve(this._downloadPromise);
};
EarthOrientationParameters.prototype.compute = function(date, result) {
  if (!defined_default(this._samples)) {
    if (defined_default(this._dataError)) {
      throw new RuntimeError_default(this._dataError);
    }
    return void 0;
  }
  if (!defined_default(result)) {
    result = new EarthOrientationParametersSample_default(0, 0, 0, 0, 0);
  }
  if (this._samples.length === 0) {
    result.xPoleWander = 0;
    result.yPoleWander = 0;
    result.xPoleOffset = 0;
    result.yPoleOffset = 0;
    result.ut1MinusUtc = 0;
    return result;
  }
  const dates = this._dates;
  const lastIndex = this._lastIndex;
  let before = 0;
  let after = 0;
  if (defined_default(lastIndex)) {
    const previousIndexDate = dates[lastIndex];
    const nextIndexDate = dates[lastIndex + 1];
    const isAfterPrevious = JulianDate_default.lessThanOrEquals(
      previousIndexDate,
      date
    );
    const isAfterLastSample = !defined_default(nextIndexDate);
    const isBeforeNext = isAfterLastSample || JulianDate_default.greaterThanOrEquals(nextIndexDate, date);
    if (isAfterPrevious && isBeforeNext) {
      before = lastIndex;
      if (!isAfterLastSample && nextIndexDate.equals(date)) {
        ++before;
      }
      after = before + 1;
      interpolate(this, dates, this._samples, date, before, after, result);
      return result;
    }
  }
  let index2 = binarySearch_default(dates, date, JulianDate_default.compare, this._dateColumn);
  if (index2 >= 0) {
    if (index2 < dates.length - 1 && dates[index2 + 1].equals(date)) {
      ++index2;
    }
    before = index2;
    after = index2;
  } else {
    after = ~index2;
    before = after - 1;
    if (before < 0) {
      before = 0;
    }
  }
  this._lastIndex = before;
  interpolate(this, dates, this._samples, date, before, after, result);
  return result;
};
function compareLeapSecondDates2(leapSecond, dateToFind) {
  return JulianDate_default.compare(leapSecond.julianDate, dateToFind);
}
function onDataReady(eop, eopData) {
  if (!defined_default(eopData.columnNames)) {
    eop._dataError = "Error in loaded EOP data: The columnNames property is required.";
    return;
  }
  if (!defined_default(eopData.samples)) {
    eop._dataError = "Error in loaded EOP data: The samples property is required.";
    return;
  }
  const dateColumn = eopData.columnNames.indexOf("modifiedJulianDateUtc");
  const xPoleWanderRadiansColumn = eopData.columnNames.indexOf(
    "xPoleWanderRadians"
  );
  const yPoleWanderRadiansColumn = eopData.columnNames.indexOf(
    "yPoleWanderRadians"
  );
  const ut1MinusUtcSecondsColumn = eopData.columnNames.indexOf(
    "ut1MinusUtcSeconds"
  );
  const xCelestialPoleOffsetRadiansColumn = eopData.columnNames.indexOf(
    "xCelestialPoleOffsetRadians"
  );
  const yCelestialPoleOffsetRadiansColumn = eopData.columnNames.indexOf(
    "yCelestialPoleOffsetRadians"
  );
  const taiMinusUtcSecondsColumn = eopData.columnNames.indexOf(
    "taiMinusUtcSeconds"
  );
  if (dateColumn < 0 || xPoleWanderRadiansColumn < 0 || yPoleWanderRadiansColumn < 0 || ut1MinusUtcSecondsColumn < 0 || xCelestialPoleOffsetRadiansColumn < 0 || yCelestialPoleOffsetRadiansColumn < 0 || taiMinusUtcSecondsColumn < 0) {
    eop._dataError = "Error in loaded EOP data: The columnNames property must include modifiedJulianDateUtc, xPoleWanderRadians, yPoleWanderRadians, ut1MinusUtcSeconds, xCelestialPoleOffsetRadians, yCelestialPoleOffsetRadians, and taiMinusUtcSeconds columns";
    return;
  }
  const samples = eop._samples = eopData.samples;
  const dates = eop._dates = [];
  eop._dateColumn = dateColumn;
  eop._xPoleWanderRadiansColumn = xPoleWanderRadiansColumn;
  eop._yPoleWanderRadiansColumn = yPoleWanderRadiansColumn;
  eop._ut1MinusUtcSecondsColumn = ut1MinusUtcSecondsColumn;
  eop._xCelestialPoleOffsetRadiansColumn = xCelestialPoleOffsetRadiansColumn;
  eop._yCelestialPoleOffsetRadiansColumn = yCelestialPoleOffsetRadiansColumn;
  eop._taiMinusUtcSecondsColumn = taiMinusUtcSecondsColumn;
  eop._columnCount = eopData.columnNames.length;
  eop._lastIndex = void 0;
  let lastTaiMinusUtc;
  const addNewLeapSeconds = eop._addNewLeapSeconds;
  for (let i2 = 0, len = samples.length; i2 < len; i2 += eop._columnCount) {
    const mjd = samples[i2 + dateColumn];
    const taiMinusUtc = samples[i2 + taiMinusUtcSecondsColumn];
    const day = mjd + TimeConstants_default.MODIFIED_JULIAN_DATE_DIFFERENCE;
    const date = new JulianDate_default(day, taiMinusUtc, TimeStandard_default.TAI);
    dates.push(date);
    if (addNewLeapSeconds) {
      if (taiMinusUtc !== lastTaiMinusUtc && defined_default(lastTaiMinusUtc)) {
        const leapSeconds = JulianDate_default.leapSeconds;
        const leapSecondIndex = binarySearch_default(
          leapSeconds,
          date,
          compareLeapSecondDates2
        );
        if (leapSecondIndex < 0) {
          const leapSecond = new LeapSecond_default(date, taiMinusUtc);
          leapSeconds.splice(~leapSecondIndex, 0, leapSecond);
        }
      }
      lastTaiMinusUtc = taiMinusUtc;
    }
  }
}
function fillResultFromIndex(eop, samples, index2, columnCount, result) {
  const start = index2 * columnCount;
  result.xPoleWander = samples[start + eop._xPoleWanderRadiansColumn];
  result.yPoleWander = samples[start + eop._yPoleWanderRadiansColumn];
  result.xPoleOffset = samples[start + eop._xCelestialPoleOffsetRadiansColumn];
  result.yPoleOffset = samples[start + eop._yCelestialPoleOffsetRadiansColumn];
  result.ut1MinusUtc = samples[start + eop._ut1MinusUtcSecondsColumn];
}
function linearInterp(dx, y1, y2) {
  return y1 + dx * (y2 - y1);
}
function interpolate(eop, dates, samples, date, before, after, result) {
  const columnCount = eop._columnCount;
  if (after > dates.length - 1) {
    result.xPoleWander = 0;
    result.yPoleWander = 0;
    result.xPoleOffset = 0;
    result.yPoleOffset = 0;
    result.ut1MinusUtc = 0;
    return result;
  }
  const beforeDate = dates[before];
  const afterDate = dates[after];
  if (beforeDate.equals(afterDate) || date.equals(beforeDate)) {
    fillResultFromIndex(eop, samples, before, columnCount, result);
    return result;
  } else if (date.equals(afterDate)) {
    fillResultFromIndex(eop, samples, after, columnCount, result);
    return result;
  }
  const factor2 = JulianDate_default.secondsDifference(date, beforeDate) / JulianDate_default.secondsDifference(afterDate, beforeDate);
  const startBefore = before * columnCount;
  const startAfter = after * columnCount;
  let beforeUt1MinusUtc = samples[startBefore + eop._ut1MinusUtcSecondsColumn];
  let afterUt1MinusUtc = samples[startAfter + eop._ut1MinusUtcSecondsColumn];
  const offsetDifference = afterUt1MinusUtc - beforeUt1MinusUtc;
  if (offsetDifference > 0.5 || offsetDifference < -0.5) {
    const beforeTaiMinusUtc = samples[startBefore + eop._taiMinusUtcSecondsColumn];
    const afterTaiMinusUtc = samples[startAfter + eop._taiMinusUtcSecondsColumn];
    if (beforeTaiMinusUtc !== afterTaiMinusUtc) {
      if (afterDate.equals(date)) {
        beforeUt1MinusUtc = afterUt1MinusUtc;
      } else {
        afterUt1MinusUtc -= afterTaiMinusUtc - beforeTaiMinusUtc;
      }
    }
  }
  result.xPoleWander = linearInterp(
    factor2,
    samples[startBefore + eop._xPoleWanderRadiansColumn],
    samples[startAfter + eop._xPoleWanderRadiansColumn]
  );
  result.yPoleWander = linearInterp(
    factor2,
    samples[startBefore + eop._yPoleWanderRadiansColumn],
    samples[startAfter + eop._yPoleWanderRadiansColumn]
  );
  result.xPoleOffset = linearInterp(
    factor2,
    samples[startBefore + eop._xCelestialPoleOffsetRadiansColumn],
    samples[startAfter + eop._xCelestialPoleOffsetRadiansColumn]
  );
  result.yPoleOffset = linearInterp(
    factor2,
    samples[startBefore + eop._yCelestialPoleOffsetRadiansColumn],
    samples[startAfter + eop._yCelestialPoleOffsetRadiansColumn]
  );
  result.ut1MinusUtc = linearInterp(
    factor2,
    beforeUt1MinusUtc,
    afterUt1MinusUtc
  );
  return result;
}
var EarthOrientationParameters_default = EarthOrientationParameters;

// node_modules/cesium/Source/Core/HeadingPitchRoll.js
function HeadingPitchRoll(heading, pitch, roll) {
  this.heading = defaultValue_default(heading, 0);
  this.pitch = defaultValue_default(pitch, 0);
  this.roll = defaultValue_default(roll, 0);
}
HeadingPitchRoll.fromQuaternion = function(quaternion, result) {
  if (!defined_default(quaternion)) {
    throw new DeveloperError_default("quaternion is required");
  }
  if (!defined_default(result)) {
    result = new HeadingPitchRoll();
  }
  const test = 2 * (quaternion.w * quaternion.y - quaternion.z * quaternion.x);
  const denominatorRoll = 1 - 2 * (quaternion.x * quaternion.x + quaternion.y * quaternion.y);
  const numeratorRoll = 2 * (quaternion.w * quaternion.x + quaternion.y * quaternion.z);
  const denominatorHeading = 1 - 2 * (quaternion.y * quaternion.y + quaternion.z * quaternion.z);
  const numeratorHeading = 2 * (quaternion.w * quaternion.z + quaternion.x * quaternion.y);
  result.heading = -Math.atan2(numeratorHeading, denominatorHeading);
  result.roll = Math.atan2(numeratorRoll, denominatorRoll);
  result.pitch = -Math_default.asinClamped(test);
  return result;
};
HeadingPitchRoll.fromDegrees = function(heading, pitch, roll, result) {
  if (!defined_default(heading)) {
    throw new DeveloperError_default("heading is required");
  }
  if (!defined_default(pitch)) {
    throw new DeveloperError_default("pitch is required");
  }
  if (!defined_default(roll)) {
    throw new DeveloperError_default("roll is required");
  }
  if (!defined_default(result)) {
    result = new HeadingPitchRoll();
  }
  result.heading = heading * Math_default.RADIANS_PER_DEGREE;
  result.pitch = pitch * Math_default.RADIANS_PER_DEGREE;
  result.roll = roll * Math_default.RADIANS_PER_DEGREE;
  return result;
};
HeadingPitchRoll.clone = function(headingPitchRoll, result) {
  if (!defined_default(headingPitchRoll)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new HeadingPitchRoll(
      headingPitchRoll.heading,
      headingPitchRoll.pitch,
      headingPitchRoll.roll
    );
  }
  result.heading = headingPitchRoll.heading;
  result.pitch = headingPitchRoll.pitch;
  result.roll = headingPitchRoll.roll;
  return result;
};
HeadingPitchRoll.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.heading === right.heading && left.pitch === right.pitch && left.roll === right.roll;
};
HeadingPitchRoll.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
  return left === right || defined_default(left) && defined_default(right) && Math_default.equalsEpsilon(
    left.heading,
    right.heading,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    left.pitch,
    right.pitch,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    left.roll,
    right.roll,
    relativeEpsilon,
    absoluteEpsilon
  );
};
HeadingPitchRoll.prototype.clone = function(result) {
  return HeadingPitchRoll.clone(this, result);
};
HeadingPitchRoll.prototype.equals = function(right) {
  return HeadingPitchRoll.equals(this, right);
};
HeadingPitchRoll.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
  return HeadingPitchRoll.equalsEpsilon(
    this,
    right,
    relativeEpsilon,
    absoluteEpsilon
  );
};
HeadingPitchRoll.prototype.toString = function() {
  return `(${this.heading}, ${this.pitch}, ${this.roll})`;
};
var HeadingPitchRoll_default = HeadingPitchRoll;

// node_modules/cesium/Source/Core/Iau2006XysSample.js
function Iau2006XysSample(x, y, s2) {
  this.x = x;
  this.y = y;
  this.s = s2;
}
var Iau2006XysSample_default = Iau2006XysSample;

// node_modules/cesium/Source/Core/Iau2006XysData.js
function Iau2006XysData(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._xysFileUrlTemplate = Resource_default.createIfNeeded(
    options.xysFileUrlTemplate
  );
  this._interpolationOrder = defaultValue_default(options.interpolationOrder, 9);
  this._sampleZeroJulianEphemerisDate = defaultValue_default(
    options.sampleZeroJulianEphemerisDate,
    24423965e-1
  );
  this._sampleZeroDateTT = new JulianDate_default(
    this._sampleZeroJulianEphemerisDate,
    0,
    TimeStandard_default.TAI
  );
  this._stepSizeDays = defaultValue_default(options.stepSizeDays, 1);
  this._samplesPerXysFile = defaultValue_default(options.samplesPerXysFile, 1e3);
  this._totalSamples = defaultValue_default(options.totalSamples, 27426);
  this._samples = new Array(this._totalSamples * 3);
  this._chunkDownloadsInProgress = [];
  const order = this._interpolationOrder;
  const denom = this._denominators = new Array(order + 1);
  const xTable = this._xTable = new Array(order + 1);
  const stepN = Math.pow(this._stepSizeDays, order);
  for (let i2 = 0; i2 <= order; ++i2) {
    denom[i2] = stepN;
    xTable[i2] = i2 * this._stepSizeDays;
    for (let j = 0; j <= order; ++j) {
      if (j !== i2) {
        denom[i2] *= i2 - j;
      }
    }
    denom[i2] = 1 / denom[i2];
  }
  this._work = new Array(order + 1);
  this._coef = new Array(order + 1);
}
var julianDateScratch = new JulianDate_default(0, 0, TimeStandard_default.TAI);
function getDaysSinceEpoch(xys, dayTT, secondTT) {
  const dateTT2 = julianDateScratch;
  dateTT2.dayNumber = dayTT;
  dateTT2.secondsOfDay = secondTT;
  return JulianDate_default.daysDifference(dateTT2, xys._sampleZeroDateTT);
}
Iau2006XysData.prototype.preload = function(startDayTT, startSecondTT, stopDayTT, stopSecondTT) {
  const startDaysSinceEpoch = getDaysSinceEpoch(
    this,
    startDayTT,
    startSecondTT
  );
  const stopDaysSinceEpoch = getDaysSinceEpoch(this, stopDayTT, stopSecondTT);
  let startIndex = startDaysSinceEpoch / this._stepSizeDays - this._interpolationOrder / 2 | 0;
  if (startIndex < 0) {
    startIndex = 0;
  }
  let stopIndex = stopDaysSinceEpoch / this._stepSizeDays - this._interpolationOrder / 2 | 0 + this._interpolationOrder;
  if (stopIndex >= this._totalSamples) {
    stopIndex = this._totalSamples - 1;
  }
  const startChunk = startIndex / this._samplesPerXysFile | 0;
  const stopChunk = stopIndex / this._samplesPerXysFile | 0;
  const promises = [];
  for (let i2 = startChunk; i2 <= stopChunk; ++i2) {
    promises.push(requestXysChunk(this, i2));
  }
  return Promise.all(promises);
};
Iau2006XysData.prototype.computeXysRadians = function(dayTT, secondTT, result) {
  const daysSinceEpoch = getDaysSinceEpoch(this, dayTT, secondTT);
  if (daysSinceEpoch < 0) {
    return void 0;
  }
  const centerIndex = daysSinceEpoch / this._stepSizeDays | 0;
  if (centerIndex >= this._totalSamples) {
    return void 0;
  }
  const degree = this._interpolationOrder;
  let firstIndex = centerIndex - (degree / 2 | 0);
  if (firstIndex < 0) {
    firstIndex = 0;
  }
  let lastIndex = firstIndex + degree;
  if (lastIndex >= this._totalSamples) {
    lastIndex = this._totalSamples - 1;
    firstIndex = lastIndex - degree;
    if (firstIndex < 0) {
      firstIndex = 0;
    }
  }
  let isDataMissing = false;
  const samples = this._samples;
  if (!defined_default(samples[firstIndex * 3])) {
    requestXysChunk(this, firstIndex / this._samplesPerXysFile | 0);
    isDataMissing = true;
  }
  if (!defined_default(samples[lastIndex * 3])) {
    requestXysChunk(this, lastIndex / this._samplesPerXysFile | 0);
    isDataMissing = true;
  }
  if (isDataMissing) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new Iau2006XysSample_default(0, 0, 0);
  } else {
    result.x = 0;
    result.y = 0;
    result.s = 0;
  }
  const x = daysSinceEpoch - firstIndex * this._stepSizeDays;
  const work = this._work;
  const denom = this._denominators;
  const coef = this._coef;
  const xTable = this._xTable;
  let i2, j;
  for (i2 = 0; i2 <= degree; ++i2) {
    work[i2] = x - xTable[i2];
  }
  for (i2 = 0; i2 <= degree; ++i2) {
    coef[i2] = 1;
    for (j = 0; j <= degree; ++j) {
      if (j !== i2) {
        coef[i2] *= work[j];
      }
    }
    coef[i2] *= denom[i2];
    let sampleIndex = (firstIndex + i2) * 3;
    result.x += coef[i2] * samples[sampleIndex++];
    result.y += coef[i2] * samples[sampleIndex++];
    result.s += coef[i2] * samples[sampleIndex];
  }
  return result;
};
function requestXysChunk(xysData, chunkIndex) {
  if (xysData._chunkDownloadsInProgress[chunkIndex]) {
    return xysData._chunkDownloadsInProgress[chunkIndex];
  }
  const deferred = defer_default();
  xysData._chunkDownloadsInProgress[chunkIndex] = deferred;
  let chunkUrl;
  const xysFileUrlTemplate = xysData._xysFileUrlTemplate;
  if (defined_default(xysFileUrlTemplate)) {
    chunkUrl = xysFileUrlTemplate.getDerivedResource({
      templateValues: {
        0: chunkIndex
      }
    });
  } else {
    chunkUrl = new Resource_default({
      url: buildModuleUrl_default(`Assets/IAU2006_XYS/IAU2006_XYS_${chunkIndex}.json`)
    });
  }
  chunkUrl.fetchJson().then(function(chunk) {
    xysData._chunkDownloadsInProgress[chunkIndex] = false;
    const samples = xysData._samples;
    const newSamples = chunk.samples;
    const startIndex = chunkIndex * xysData._samplesPerXysFile * 3;
    for (let i2 = 0, len = newSamples.length; i2 < len; ++i2) {
      samples[startIndex + i2] = newSamples[i2];
    }
    deferred.resolve();
  });
  return deferred.promise;
}
var Iau2006XysData_default = Iau2006XysData;

// node_modules/cesium/Source/Core/Fullscreen.js
var _supportsFullscreen;
var _names = {
  requestFullscreen: void 0,
  exitFullscreen: void 0,
  fullscreenEnabled: void 0,
  fullscreenElement: void 0,
  fullscreenchange: void 0,
  fullscreenerror: void 0
};
var Fullscreen = {};
Object.defineProperties(Fullscreen, {
  element: {
    get: function() {
      if (!Fullscreen.supportsFullscreen()) {
        return void 0;
      }
      return document[_names.fullscreenElement];
    }
  },
  changeEventName: {
    get: function() {
      if (!Fullscreen.supportsFullscreen()) {
        return void 0;
      }
      return _names.fullscreenchange;
    }
  },
  errorEventName: {
    get: function() {
      if (!Fullscreen.supportsFullscreen()) {
        return void 0;
      }
      return _names.fullscreenerror;
    }
  },
  enabled: {
    get: function() {
      if (!Fullscreen.supportsFullscreen()) {
        return void 0;
      }
      return document[_names.fullscreenEnabled];
    }
  },
  fullscreen: {
    get: function() {
      if (!Fullscreen.supportsFullscreen()) {
        return void 0;
      }
      return Fullscreen.element !== null;
    }
  }
});
Fullscreen.supportsFullscreen = function() {
  if (defined_default(_supportsFullscreen)) {
    return _supportsFullscreen;
  }
  _supportsFullscreen = false;
  const body = document.body;
  if (typeof body.requestFullscreen === "function") {
    _names.requestFullscreen = "requestFullscreen";
    _names.exitFullscreen = "exitFullscreen";
    _names.fullscreenEnabled = "fullscreenEnabled";
    _names.fullscreenElement = "fullscreenElement";
    _names.fullscreenchange = "fullscreenchange";
    _names.fullscreenerror = "fullscreenerror";
    _supportsFullscreen = true;
    return _supportsFullscreen;
  }
  const prefixes = ["webkit", "moz", "o", "ms", "khtml"];
  let name;
  for (let i2 = 0, len = prefixes.length; i2 < len; ++i2) {
    const prefix = prefixes[i2];
    name = `${prefix}RequestFullscreen`;
    if (typeof body[name] === "function") {
      _names.requestFullscreen = name;
      _supportsFullscreen = true;
    } else {
      name = `${prefix}RequestFullScreen`;
      if (typeof body[name] === "function") {
        _names.requestFullscreen = name;
        _supportsFullscreen = true;
      }
    }
    name = `${prefix}ExitFullscreen`;
    if (typeof document[name] === "function") {
      _names.exitFullscreen = name;
    } else {
      name = `${prefix}CancelFullScreen`;
      if (typeof document[name] === "function") {
        _names.exitFullscreen = name;
      }
    }
    name = `${prefix}FullscreenEnabled`;
    if (document[name] !== void 0) {
      _names.fullscreenEnabled = name;
    } else {
      name = `${prefix}FullScreenEnabled`;
      if (document[name] !== void 0) {
        _names.fullscreenEnabled = name;
      }
    }
    name = `${prefix}FullscreenElement`;
    if (document[name] !== void 0) {
      _names.fullscreenElement = name;
    } else {
      name = `${prefix}FullScreenElement`;
      if (document[name] !== void 0) {
        _names.fullscreenElement = name;
      }
    }
    name = `${prefix}fullscreenchange`;
    if (document[`on${name}`] !== void 0) {
      if (prefix === "ms") {
        name = "MSFullscreenChange";
      }
      _names.fullscreenchange = name;
    }
    name = `${prefix}fullscreenerror`;
    if (document[`on${name}`] !== void 0) {
      if (prefix === "ms") {
        name = "MSFullscreenError";
      }
      _names.fullscreenerror = name;
    }
  }
  return _supportsFullscreen;
};
Fullscreen.requestFullscreen = function(element, vrDevice) {
  if (!Fullscreen.supportsFullscreen()) {
    return;
  }
  element[_names.requestFullscreen]({ vrDisplay: vrDevice });
};
Fullscreen.exitFullscreen = function() {
  if (!Fullscreen.supportsFullscreen()) {
    return;
  }
  document[_names.exitFullscreen]();
};
Fullscreen._names = _names;
var Fullscreen_default = Fullscreen;

// node_modules/cesium/Source/Core/FeatureDetection.js
var theNavigator;
if (typeof navigator !== "undefined") {
  theNavigator = navigator;
} else {
  theNavigator = {};
}
function extractVersion(versionString) {
  const parts = versionString.split(".");
  for (let i2 = 0, len = parts.length; i2 < len; ++i2) {
    parts[i2] = parseInt(parts[i2], 10);
  }
  return parts;
}
var isChromeResult;
var chromeVersionResult;
function isChrome() {
  if (!defined_default(isChromeResult)) {
    isChromeResult = false;
    if (!isEdge()) {
      const fields = / Chrome\/([\.0-9]+)/.exec(theNavigator.userAgent);
      if (fields !== null) {
        isChromeResult = true;
        chromeVersionResult = extractVersion(fields[1]);
      }
    }
  }
  return isChromeResult;
}
function chromeVersion() {
  return isChrome() && chromeVersionResult;
}
var isSafariResult;
var safariVersionResult;
function isSafari() {
  if (!defined_default(isSafariResult)) {
    isSafariResult = false;
    if (!isChrome() && !isEdge() && / Safari\/[\.0-9]+/.test(theNavigator.userAgent)) {
      const fields = / Version\/([\.0-9]+)/.exec(theNavigator.userAgent);
      if (fields !== null) {
        isSafariResult = true;
        safariVersionResult = extractVersion(fields[1]);
      }
    }
  }
  return isSafariResult;
}
function safariVersion() {
  return isSafari() && safariVersionResult;
}
var isWebkitResult;
var webkitVersionResult;
function isWebkit() {
  if (!defined_default(isWebkitResult)) {
    isWebkitResult = false;
    const fields = / AppleWebKit\/([\.0-9]+)(\+?)/.exec(theNavigator.userAgent);
    if (fields !== null) {
      isWebkitResult = true;
      webkitVersionResult = extractVersion(fields[1]);
      webkitVersionResult.isNightly = !!fields[2];
    }
  }
  return isWebkitResult;
}
function webkitVersion() {
  return isWebkit() && webkitVersionResult;
}
var isInternetExplorerResult;
var internetExplorerVersionResult;
function isInternetExplorer() {
  if (!defined_default(isInternetExplorerResult)) {
    isInternetExplorerResult = false;
    let fields;
    if (theNavigator.appName === "Microsoft Internet Explorer") {
      fields = /MSIE ([0-9]{1,}[\.0-9]{0,})/.exec(theNavigator.userAgent);
      if (fields !== null) {
        isInternetExplorerResult = true;
        internetExplorerVersionResult = extractVersion(fields[1]);
      }
    } else if (theNavigator.appName === "Netscape") {
      fields = /Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/.exec(
        theNavigator.userAgent
      );
      if (fields !== null) {
        isInternetExplorerResult = true;
        internetExplorerVersionResult = extractVersion(fields[1]);
      }
    }
  }
  return isInternetExplorerResult;
}
function internetExplorerVersion() {
  return isInternetExplorer() && internetExplorerVersionResult;
}
var isEdgeResult;
var edgeVersionResult;
function isEdge() {
  if (!defined_default(isEdgeResult)) {
    isEdgeResult = false;
    const fields = / Edge\/([\.0-9]+)/.exec(theNavigator.userAgent);
    if (fields !== null) {
      isEdgeResult = true;
      edgeVersionResult = extractVersion(fields[1]);
    }
  }
  return isEdgeResult;
}
function edgeVersion() {
  return isEdge() && edgeVersionResult;
}
var isFirefoxResult;
var firefoxVersionResult;
function isFirefox() {
  if (!defined_default(isFirefoxResult)) {
    isFirefoxResult = false;
    const fields = /Firefox\/([\.0-9]+)/.exec(theNavigator.userAgent);
    if (fields !== null) {
      isFirefoxResult = true;
      firefoxVersionResult = extractVersion(fields[1]);
    }
  }
  return isFirefoxResult;
}
var isWindowsResult;
function isWindows() {
  if (!defined_default(isWindowsResult)) {
    isWindowsResult = /Windows/i.test(theNavigator.appVersion);
  }
  return isWindowsResult;
}
var isIPadOrIOSResult;
function isIPadOrIOS() {
  if (!defined_default(isIPadOrIOSResult)) {
    isIPadOrIOSResult = navigator.platform === "iPhone" || navigator.platform === "iPod" || navigator.platform === "iPad";
  }
  return isIPadOrIOSResult;
}
function firefoxVersion() {
  return isFirefox() && firefoxVersionResult;
}
var hasPointerEvents;
function supportsPointerEvents() {
  if (!defined_default(hasPointerEvents)) {
    hasPointerEvents = !isFirefox() && typeof PointerEvent !== "undefined" && (!defined_default(theNavigator.pointerEnabled) || theNavigator.pointerEnabled);
  }
  return hasPointerEvents;
}
var imageRenderingValueResult;
var supportsImageRenderingPixelatedResult;
function supportsImageRenderingPixelated() {
  if (!defined_default(supportsImageRenderingPixelatedResult)) {
    const canvas = document.createElement("canvas");
    canvas.setAttribute(
      "style",
      "image-rendering: -moz-crisp-edges;image-rendering: pixelated;"
    );
    const tmp2 = canvas.style.imageRendering;
    supportsImageRenderingPixelatedResult = defined_default(tmp2) && tmp2 !== "";
    if (supportsImageRenderingPixelatedResult) {
      imageRenderingValueResult = tmp2;
    }
  }
  return supportsImageRenderingPixelatedResult;
}
function imageRenderingValue() {
  return supportsImageRenderingPixelated() ? imageRenderingValueResult : void 0;
}
function supportsWebP() {
  if (!supportsWebP.initialized) {
    throw new DeveloperError_default(
      "You must call FeatureDetection.supportsWebP.initialize and wait for the promise to resolve before calling FeatureDetection.supportsWebP"
    );
  }
  return supportsWebP._result;
}
supportsWebP._promise = void 0;
supportsWebP._result = void 0;
supportsWebP.initialize = function() {
  if (defined_default(supportsWebP._promise)) {
    return supportsWebP._promise;
  }
  const supportsWebPDeferred = defer_default();
  supportsWebP._promise = supportsWebPDeferred.promise;
  if (isEdge()) {
    supportsWebP._result = false;
    supportsWebPDeferred.resolve(supportsWebP._result);
    return supportsWebPDeferred.promise;
  }
  const image = new Image();
  image.onload = function() {
    supportsWebP._result = image.width > 0 && image.height > 0;
    supportsWebPDeferred.resolve(supportsWebP._result);
  };
  image.onerror = function() {
    supportsWebP._result = false;
    supportsWebPDeferred.resolve(supportsWebP._result);
  };
  image.src = "data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA";
  return supportsWebPDeferred.promise;
};
Object.defineProperties(supportsWebP, {
  initialized: {
    get: function() {
      return defined_default(supportsWebP._result);
    }
  }
});
var typedArrayTypes = [];
if (typeof ArrayBuffer !== "undefined") {
  typedArrayTypes.push(
    Int8Array,
    Uint8Array,
    Int16Array,
    Uint16Array,
    Int32Array,
    Uint32Array,
    Float32Array,
    Float64Array
  );
  if (typeof Uint8ClampedArray !== "undefined") {
    typedArrayTypes.push(Uint8ClampedArray);
  }
  if (typeof Uint8ClampedArray !== "undefined") {
    typedArrayTypes.push(Uint8ClampedArray);
  }
  if (typeof BigInt64Array !== "undefined") {
    typedArrayTypes.push(BigInt64Array);
  }
  if (typeof BigUint64Array !== "undefined") {
    typedArrayTypes.push(BigUint64Array);
  }
}
var FeatureDetection = {
  isChrome,
  chromeVersion,
  isSafari,
  safariVersion,
  isWebkit,
  webkitVersion,
  isInternetExplorer,
  internetExplorerVersion,
  isEdge,
  edgeVersion,
  isFirefox,
  firefoxVersion,
  isWindows,
  isIPadOrIOS,
  hardwareConcurrency: defaultValue_default(theNavigator.hardwareConcurrency, 3),
  supportsPointerEvents,
  supportsImageRenderingPixelated,
  supportsWebP,
  imageRenderingValue,
  typedArrayTypes
};
FeatureDetection.supportsBasis = function(scene) {
  return FeatureDetection.supportsWebAssembly() && scene.context.supportsBasis;
};
FeatureDetection.supportsFullscreen = function() {
  return Fullscreen_default.supportsFullscreen();
};
FeatureDetection.supportsTypedArrays = function() {
  return typeof ArrayBuffer !== "undefined";
};
FeatureDetection.supportsBigInt64Array = function() {
  return typeof BigInt64Array !== "undefined";
};
FeatureDetection.supportsBigUint64Array = function() {
  return typeof BigUint64Array !== "undefined";
};
FeatureDetection.supportsBigInt = function() {
  return typeof BigInt !== "undefined";
};
FeatureDetection.supportsWebWorkers = function() {
  return typeof Worker !== "undefined";
};
FeatureDetection.supportsWebAssembly = function() {
  return typeof WebAssembly !== "undefined" && !FeatureDetection.isEdge();
};
var FeatureDetection_default = FeatureDetection;

// node_modules/cesium/Source/Core/Quaternion.js
function Quaternion(x, y, z, w) {
  this.x = defaultValue_default(x, 0);
  this.y = defaultValue_default(y, 0);
  this.z = defaultValue_default(z, 0);
  this.w = defaultValue_default(w, 0);
}
var fromAxisAngleScratch = new Cartesian3_default();
Quaternion.fromAxisAngle = function(axis, angle, result) {
  Check_default.typeOf.object("axis", axis);
  Check_default.typeOf.number("angle", angle);
  const halfAngle = angle / 2;
  const s2 = Math.sin(halfAngle);
  fromAxisAngleScratch = Cartesian3_default.normalize(axis, fromAxisAngleScratch);
  const x = fromAxisAngleScratch.x * s2;
  const y = fromAxisAngleScratch.y * s2;
  const z = fromAxisAngleScratch.z * s2;
  const w = Math.cos(halfAngle);
  if (!defined_default(result)) {
    return new Quaternion(x, y, z, w);
  }
  result.x = x;
  result.y = y;
  result.z = z;
  result.w = w;
  return result;
};
var fromRotationMatrixNext = [1, 2, 0];
var fromRotationMatrixQuat = new Array(3);
Quaternion.fromRotationMatrix = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  let root;
  let x;
  let y;
  let z;
  let w;
  const m00 = matrix[Matrix3_default.COLUMN0ROW0];
  const m11 = matrix[Matrix3_default.COLUMN1ROW1];
  const m22 = matrix[Matrix3_default.COLUMN2ROW2];
  const trace = m00 + m11 + m22;
  if (trace > 0) {
    root = Math.sqrt(trace + 1);
    w = 0.5 * root;
    root = 0.5 / root;
    x = (matrix[Matrix3_default.COLUMN1ROW2] - matrix[Matrix3_default.COLUMN2ROW1]) * root;
    y = (matrix[Matrix3_default.COLUMN2ROW0] - matrix[Matrix3_default.COLUMN0ROW2]) * root;
    z = (matrix[Matrix3_default.COLUMN0ROW1] - matrix[Matrix3_default.COLUMN1ROW0]) * root;
  } else {
    const next = fromRotationMatrixNext;
    let i2 = 0;
    if (m11 > m00) {
      i2 = 1;
    }
    if (m22 > m00 && m22 > m11) {
      i2 = 2;
    }
    const j = next[i2];
    const k = next[j];
    root = Math.sqrt(
      matrix[Matrix3_default.getElementIndex(i2, i2)] - matrix[Matrix3_default.getElementIndex(j, j)] - matrix[Matrix3_default.getElementIndex(k, k)] + 1
    );
    const quat = fromRotationMatrixQuat;
    quat[i2] = 0.5 * root;
    root = 0.5 / root;
    w = (matrix[Matrix3_default.getElementIndex(k, j)] - matrix[Matrix3_default.getElementIndex(j, k)]) * root;
    quat[j] = (matrix[Matrix3_default.getElementIndex(j, i2)] + matrix[Matrix3_default.getElementIndex(i2, j)]) * root;
    quat[k] = (matrix[Matrix3_default.getElementIndex(k, i2)] + matrix[Matrix3_default.getElementIndex(i2, k)]) * root;
    x = -quat[0];
    y = -quat[1];
    z = -quat[2];
  }
  if (!defined_default(result)) {
    return new Quaternion(x, y, z, w);
  }
  result.x = x;
  result.y = y;
  result.z = z;
  result.w = w;
  return result;
};
var scratchHPRQuaternion = new Quaternion();
var scratchHeadingQuaternion = new Quaternion();
var scratchPitchQuaternion = new Quaternion();
var scratchRollQuaternion = new Quaternion();
Quaternion.fromHeadingPitchRoll = function(headingPitchRoll, result) {
  Check_default.typeOf.object("headingPitchRoll", headingPitchRoll);
  scratchRollQuaternion = Quaternion.fromAxisAngle(
    Cartesian3_default.UNIT_X,
    headingPitchRoll.roll,
    scratchHPRQuaternion
  );
  scratchPitchQuaternion = Quaternion.fromAxisAngle(
    Cartesian3_default.UNIT_Y,
    -headingPitchRoll.pitch,
    result
  );
  result = Quaternion.multiply(
    scratchPitchQuaternion,
    scratchRollQuaternion,
    scratchPitchQuaternion
  );
  scratchHeadingQuaternion = Quaternion.fromAxisAngle(
    Cartesian3_default.UNIT_Z,
    -headingPitchRoll.heading,
    scratchHPRQuaternion
  );
  return Quaternion.multiply(scratchHeadingQuaternion, result, result);
};
var sampledQuaternionAxis = new Cartesian3_default();
var sampledQuaternionRotation = new Cartesian3_default();
var sampledQuaternionTempQuaternion = new Quaternion();
var sampledQuaternionQuaternion0 = new Quaternion();
var sampledQuaternionQuaternion0Conjugate = new Quaternion();
Quaternion.packedLength = 4;
Quaternion.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.x;
  array[startingIndex++] = value.y;
  array[startingIndex++] = value.z;
  array[startingIndex] = value.w;
  return array;
};
Quaternion.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new Quaternion();
  }
  result.x = array[startingIndex];
  result.y = array[startingIndex + 1];
  result.z = array[startingIndex + 2];
  result.w = array[startingIndex + 3];
  return result;
};
Quaternion.packedInterpolationLength = 3;
Quaternion.convertPackedArrayForInterpolation = function(packedArray, startingIndex, lastIndex, result) {
  Quaternion.unpack(
    packedArray,
    lastIndex * 4,
    sampledQuaternionQuaternion0Conjugate
  );
  Quaternion.conjugate(
    sampledQuaternionQuaternion0Conjugate,
    sampledQuaternionQuaternion0Conjugate
  );
  for (let i2 = 0, len = lastIndex - startingIndex + 1; i2 < len; i2++) {
    const offset2 = i2 * 3;
    Quaternion.unpack(
      packedArray,
      (startingIndex + i2) * 4,
      sampledQuaternionTempQuaternion
    );
    Quaternion.multiply(
      sampledQuaternionTempQuaternion,
      sampledQuaternionQuaternion0Conjugate,
      sampledQuaternionTempQuaternion
    );
    if (sampledQuaternionTempQuaternion.w < 0) {
      Quaternion.negate(
        sampledQuaternionTempQuaternion,
        sampledQuaternionTempQuaternion
      );
    }
    Quaternion.computeAxis(
      sampledQuaternionTempQuaternion,
      sampledQuaternionAxis
    );
    const angle = Quaternion.computeAngle(sampledQuaternionTempQuaternion);
    if (!defined_default(result)) {
      result = [];
    }
    result[offset2] = sampledQuaternionAxis.x * angle;
    result[offset2 + 1] = sampledQuaternionAxis.y * angle;
    result[offset2 + 2] = sampledQuaternionAxis.z * angle;
  }
};
Quaternion.unpackInterpolationResult = function(array, sourceArray, firstIndex, lastIndex, result) {
  if (!defined_default(result)) {
    result = new Quaternion();
  }
  Cartesian3_default.fromArray(array, 0, sampledQuaternionRotation);
  const magnitude = Cartesian3_default.magnitude(sampledQuaternionRotation);
  Quaternion.unpack(sourceArray, lastIndex * 4, sampledQuaternionQuaternion0);
  if (magnitude === 0) {
    Quaternion.clone(Quaternion.IDENTITY, sampledQuaternionTempQuaternion);
  } else {
    Quaternion.fromAxisAngle(
      sampledQuaternionRotation,
      magnitude,
      sampledQuaternionTempQuaternion
    );
  }
  return Quaternion.multiply(
    sampledQuaternionTempQuaternion,
    sampledQuaternionQuaternion0,
    result
  );
};
Quaternion.clone = function(quaternion, result) {
  if (!defined_default(quaternion)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Quaternion(
      quaternion.x,
      quaternion.y,
      quaternion.z,
      quaternion.w
    );
  }
  result.x = quaternion.x;
  result.y = quaternion.y;
  result.z = quaternion.z;
  result.w = quaternion.w;
  return result;
};
Quaternion.conjugate = function(quaternion, result) {
  Check_default.typeOf.object("quaternion", quaternion);
  Check_default.typeOf.object("result", result);
  result.x = -quaternion.x;
  result.y = -quaternion.y;
  result.z = -quaternion.z;
  result.w = quaternion.w;
  return result;
};
Quaternion.magnitudeSquared = function(quaternion) {
  Check_default.typeOf.object("quaternion", quaternion);
  return quaternion.x * quaternion.x + quaternion.y * quaternion.y + quaternion.z * quaternion.z + quaternion.w * quaternion.w;
};
Quaternion.magnitude = function(quaternion) {
  return Math.sqrt(Quaternion.magnitudeSquared(quaternion));
};
Quaternion.normalize = function(quaternion, result) {
  Check_default.typeOf.object("result", result);
  const inverseMagnitude = 1 / Quaternion.magnitude(quaternion);
  const x = quaternion.x * inverseMagnitude;
  const y = quaternion.y * inverseMagnitude;
  const z = quaternion.z * inverseMagnitude;
  const w = quaternion.w * inverseMagnitude;
  result.x = x;
  result.y = y;
  result.z = z;
  result.w = w;
  return result;
};
Quaternion.inverse = function(quaternion, result) {
  Check_default.typeOf.object("result", result);
  const magnitudeSquared = Quaternion.magnitudeSquared(quaternion);
  result = Quaternion.conjugate(quaternion, result);
  return Quaternion.multiplyByScalar(result, 1 / magnitudeSquared, result);
};
Quaternion.add = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x + right.x;
  result.y = left.y + right.y;
  result.z = left.z + right.z;
  result.w = left.w + right.w;
  return result;
};
Quaternion.subtract = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.x = left.x - right.x;
  result.y = left.y - right.y;
  result.z = left.z - right.z;
  result.w = left.w - right.w;
  return result;
};
Quaternion.negate = function(quaternion, result) {
  Check_default.typeOf.object("quaternion", quaternion);
  Check_default.typeOf.object("result", result);
  result.x = -quaternion.x;
  result.y = -quaternion.y;
  result.z = -quaternion.z;
  result.w = -quaternion.w;
  return result;
};
Quaternion.dot = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  return left.x * right.x + left.y * right.y + left.z * right.z + left.w * right.w;
};
Quaternion.multiply = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  const leftX = left.x;
  const leftY = left.y;
  const leftZ = left.z;
  const leftW = left.w;
  const rightX = right.x;
  const rightY = right.y;
  const rightZ = right.z;
  const rightW = right.w;
  const x = leftW * rightX + leftX * rightW + leftY * rightZ - leftZ * rightY;
  const y = leftW * rightY - leftX * rightZ + leftY * rightW + leftZ * rightX;
  const z = leftW * rightZ + leftX * rightY - leftY * rightX + leftZ * rightW;
  const w = leftW * rightW - leftX * rightX - leftY * rightY - leftZ * rightZ;
  result.x = x;
  result.y = y;
  result.z = z;
  result.w = w;
  return result;
};
Quaternion.multiplyByScalar = function(quaternion, scalar, result) {
  Check_default.typeOf.object("quaternion", quaternion);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.x = quaternion.x * scalar;
  result.y = quaternion.y * scalar;
  result.z = quaternion.z * scalar;
  result.w = quaternion.w * scalar;
  return result;
};
Quaternion.divideByScalar = function(quaternion, scalar, result) {
  Check_default.typeOf.object("quaternion", quaternion);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.x = quaternion.x / scalar;
  result.y = quaternion.y / scalar;
  result.z = quaternion.z / scalar;
  result.w = quaternion.w / scalar;
  return result;
};
Quaternion.computeAxis = function(quaternion, result) {
  Check_default.typeOf.object("quaternion", quaternion);
  Check_default.typeOf.object("result", result);
  const w = quaternion.w;
  if (Math.abs(w - 1) < Math_default.EPSILON6) {
    result.x = result.y = result.z = 0;
    return result;
  }
  const scalar = 1 / Math.sqrt(1 - w * w);
  result.x = quaternion.x * scalar;
  result.y = quaternion.y * scalar;
  result.z = quaternion.z * scalar;
  return result;
};
Quaternion.computeAngle = function(quaternion) {
  Check_default.typeOf.object("quaternion", quaternion);
  if (Math.abs(quaternion.w - 1) < Math_default.EPSILON6) {
    return 0;
  }
  return 2 * Math.acos(quaternion.w);
};
var lerpScratch4 = new Quaternion();
Quaternion.lerp = function(start, end, t, result) {
  Check_default.typeOf.object("start", start);
  Check_default.typeOf.object("end", end);
  Check_default.typeOf.number("t", t);
  Check_default.typeOf.object("result", result);
  lerpScratch4 = Quaternion.multiplyByScalar(end, t, lerpScratch4);
  result = Quaternion.multiplyByScalar(start, 1 - t, result);
  return Quaternion.add(lerpScratch4, result, result);
};
var slerpEndNegated = new Quaternion();
var slerpScaledP = new Quaternion();
var slerpScaledR = new Quaternion();
Quaternion.slerp = function(start, end, t, result) {
  Check_default.typeOf.object("start", start);
  Check_default.typeOf.object("end", end);
  Check_default.typeOf.number("t", t);
  Check_default.typeOf.object("result", result);
  let dot2 = Quaternion.dot(start, end);
  let r2 = end;
  if (dot2 < 0) {
    dot2 = -dot2;
    r2 = slerpEndNegated = Quaternion.negate(end, slerpEndNegated);
  }
  if (1 - dot2 < Math_default.EPSILON6) {
    return Quaternion.lerp(start, r2, t, result);
  }
  const theta = Math.acos(dot2);
  slerpScaledP = Quaternion.multiplyByScalar(
    start,
    Math.sin((1 - t) * theta),
    slerpScaledP
  );
  slerpScaledR = Quaternion.multiplyByScalar(
    r2,
    Math.sin(t * theta),
    slerpScaledR
  );
  result = Quaternion.add(slerpScaledP, slerpScaledR, result);
  return Quaternion.multiplyByScalar(result, 1 / Math.sin(theta), result);
};
Quaternion.log = function(quaternion, result) {
  Check_default.typeOf.object("quaternion", quaternion);
  Check_default.typeOf.object("result", result);
  const theta = Math_default.acosClamped(quaternion.w);
  let thetaOverSinTheta = 0;
  if (theta !== 0) {
    thetaOverSinTheta = theta / Math.sin(theta);
  }
  return Cartesian3_default.multiplyByScalar(quaternion, thetaOverSinTheta, result);
};
Quaternion.exp = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const theta = Cartesian3_default.magnitude(cartesian11);
  let sinThetaOverTheta = 0;
  if (theta !== 0) {
    sinThetaOverTheta = Math.sin(theta) / theta;
  }
  result.x = cartesian11.x * sinThetaOverTheta;
  result.y = cartesian11.y * sinThetaOverTheta;
  result.z = cartesian11.z * sinThetaOverTheta;
  result.w = Math.cos(theta);
  return result;
};
var squadScratchCartesian0 = new Cartesian3_default();
var squadScratchCartesian1 = new Cartesian3_default();
var squadScratchQuaternion0 = new Quaternion();
var squadScratchQuaternion1 = new Quaternion();
Quaternion.computeInnerQuadrangle = function(q0, q12, q22, result) {
  Check_default.typeOf.object("q0", q0);
  Check_default.typeOf.object("q1", q12);
  Check_default.typeOf.object("q2", q22);
  Check_default.typeOf.object("result", result);
  const qInv = Quaternion.conjugate(q12, squadScratchQuaternion0);
  Quaternion.multiply(qInv, q22, squadScratchQuaternion1);
  const cart0 = Quaternion.log(squadScratchQuaternion1, squadScratchCartesian0);
  Quaternion.multiply(qInv, q0, squadScratchQuaternion1);
  const cart1 = Quaternion.log(squadScratchQuaternion1, squadScratchCartesian1);
  Cartesian3_default.add(cart0, cart1, cart0);
  Cartesian3_default.multiplyByScalar(cart0, 0.25, cart0);
  Cartesian3_default.negate(cart0, cart0);
  Quaternion.exp(cart0, squadScratchQuaternion0);
  return Quaternion.multiply(q12, squadScratchQuaternion0, result);
};
Quaternion.squad = function(q0, q12, s0, s1, t, result) {
  Check_default.typeOf.object("q0", q0);
  Check_default.typeOf.object("q1", q12);
  Check_default.typeOf.object("s0", s0);
  Check_default.typeOf.object("s1", s1);
  Check_default.typeOf.number("t", t);
  Check_default.typeOf.object("result", result);
  const slerp0 = Quaternion.slerp(q0, q12, t, squadScratchQuaternion0);
  const slerp1 = Quaternion.slerp(s0, s1, t, squadScratchQuaternion1);
  return Quaternion.slerp(slerp0, slerp1, 2 * t * (1 - t), result);
};
var fastSlerpScratchQuaternion = new Quaternion();
var opmu = 1.9011074535173003;
var u = FeatureDetection_default.supportsTypedArrays() ? new Float32Array(8) : [];
var v = FeatureDetection_default.supportsTypedArrays() ? new Float32Array(8) : [];
var bT = FeatureDetection_default.supportsTypedArrays() ? new Float32Array(8) : [];
var bD = FeatureDetection_default.supportsTypedArrays() ? new Float32Array(8) : [];
for (let i2 = 0; i2 < 7; ++i2) {
  const s2 = i2 + 1;
  const t = 2 * s2 + 1;
  u[i2] = 1 / (s2 * t);
  v[i2] = s2 / t;
}
u[7] = opmu / (8 * 17);
v[7] = opmu * 8 / 17;
Quaternion.fastSlerp = function(start, end, t, result) {
  Check_default.typeOf.object("start", start);
  Check_default.typeOf.object("end", end);
  Check_default.typeOf.number("t", t);
  Check_default.typeOf.object("result", result);
  let x = Quaternion.dot(start, end);
  let sign3;
  if (x >= 0) {
    sign3 = 1;
  } else {
    sign3 = -1;
    x = -x;
  }
  const xm1 = x - 1;
  const d = 1 - t;
  const sqrT = t * t;
  const sqrD = d * d;
  for (let i2 = 7; i2 >= 0; --i2) {
    bT[i2] = (u[i2] * sqrT - v[i2]) * xm1;
    bD[i2] = (u[i2] * sqrD - v[i2]) * xm1;
  }
  const cT = sign3 * t * (1 + bT[0] * (1 + bT[1] * (1 + bT[2] * (1 + bT[3] * (1 + bT[4] * (1 + bT[5] * (1 + bT[6] * (1 + bT[7]))))))));
  const cD = d * (1 + bD[0] * (1 + bD[1] * (1 + bD[2] * (1 + bD[3] * (1 + bD[4] * (1 + bD[5] * (1 + bD[6] * (1 + bD[7]))))))));
  const temp = Quaternion.multiplyByScalar(
    start,
    cD,
    fastSlerpScratchQuaternion
  );
  Quaternion.multiplyByScalar(end, cT, result);
  return Quaternion.add(temp, result, result);
};
Quaternion.fastSquad = function(q0, q12, s0, s1, t, result) {
  Check_default.typeOf.object("q0", q0);
  Check_default.typeOf.object("q1", q12);
  Check_default.typeOf.object("s0", s0);
  Check_default.typeOf.object("s1", s1);
  Check_default.typeOf.number("t", t);
  Check_default.typeOf.object("result", result);
  const slerp0 = Quaternion.fastSlerp(q0, q12, t, squadScratchQuaternion0);
  const slerp1 = Quaternion.fastSlerp(s0, s1, t, squadScratchQuaternion1);
  return Quaternion.fastSlerp(slerp0, slerp1, 2 * t * (1 - t), result);
};
Quaternion.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y && left.z === right.z && left.w === right.w;
};
Quaternion.equalsEpsilon = function(left, right, epsilon) {
  epsilon = defaultValue_default(epsilon, 0);
  return left === right || defined_default(left) && defined_default(right) && Math.abs(left.x - right.x) <= epsilon && Math.abs(left.y - right.y) <= epsilon && Math.abs(left.z - right.z) <= epsilon && Math.abs(left.w - right.w) <= epsilon;
};
Quaternion.ZERO = Object.freeze(new Quaternion(0, 0, 0, 0));
Quaternion.IDENTITY = Object.freeze(new Quaternion(0, 0, 0, 1));
Quaternion.prototype.clone = function(result) {
  return Quaternion.clone(this, result);
};
Quaternion.prototype.equals = function(right) {
  return Quaternion.equals(this, right);
};
Quaternion.prototype.equalsEpsilon = function(right, epsilon) {
  return Quaternion.equalsEpsilon(this, right, epsilon);
};
Quaternion.prototype.toString = function() {
  return `(${this.x}, ${this.y}, ${this.z}, ${this.w})`;
};
var Quaternion_default = Quaternion;

// node_modules/cesium/Source/Core/Transforms.js
var Transforms = {};
var vectorProductLocalFrame = {
  up: {
    south: "east",
    north: "west",
    west: "south",
    east: "north"
  },
  down: {
    south: "west",
    north: "east",
    west: "north",
    east: "south"
  },
  south: {
    up: "west",
    down: "east",
    west: "down",
    east: "up"
  },
  north: {
    up: "east",
    down: "west",
    west: "up",
    east: "down"
  },
  west: {
    up: "north",
    down: "south",
    north: "down",
    south: "up"
  },
  east: {
    up: "south",
    down: "north",
    north: "up",
    south: "down"
  }
};
var degeneratePositionLocalFrame = {
  north: [-1, 0, 0],
  east: [0, 1, 0],
  up: [0, 0, 1],
  south: [1, 0, 0],
  west: [0, -1, 0],
  down: [0, 0, -1]
};
var localFrameToFixedFrameCache = {};
var scratchCalculateCartesian = {
  east: new Cartesian3_default(),
  north: new Cartesian3_default(),
  up: new Cartesian3_default(),
  west: new Cartesian3_default(),
  south: new Cartesian3_default(),
  down: new Cartesian3_default()
};
var scratchFirstCartesian = new Cartesian3_default();
var scratchSecondCartesian = new Cartesian3_default();
var scratchThirdCartesian = new Cartesian3_default();
Transforms.localFrameToFixedFrameGenerator = function(firstAxis, secondAxis) {
  if (!vectorProductLocalFrame.hasOwnProperty(firstAxis) || !vectorProductLocalFrame[firstAxis].hasOwnProperty(secondAxis)) {
    throw new DeveloperError_default(
      "firstAxis and secondAxis must be east, north, up, west, south or down."
    );
  }
  const thirdAxis = vectorProductLocalFrame[firstAxis][secondAxis];
  let resultat;
  const hashAxis = firstAxis + secondAxis;
  if (defined_default(localFrameToFixedFrameCache[hashAxis])) {
    resultat = localFrameToFixedFrameCache[hashAxis];
  } else {
    resultat = function(origin, ellipsoid, result) {
      if (!defined_default(origin)) {
        throw new DeveloperError_default("origin is required.");
      }
      if (!defined_default(result)) {
        result = new Matrix4_default();
      }
      if (Cartesian3_default.equalsEpsilon(origin, Cartesian3_default.ZERO, Math_default.EPSILON14)) {
        Cartesian3_default.unpack(
          degeneratePositionLocalFrame[firstAxis],
          0,
          scratchFirstCartesian
        );
        Cartesian3_default.unpack(
          degeneratePositionLocalFrame[secondAxis],
          0,
          scratchSecondCartesian
        );
        Cartesian3_default.unpack(
          degeneratePositionLocalFrame[thirdAxis],
          0,
          scratchThirdCartesian
        );
      } else if (Math_default.equalsEpsilon(origin.x, 0, Math_default.EPSILON14) && Math_default.equalsEpsilon(origin.y, 0, Math_default.EPSILON14)) {
        const sign3 = Math_default.sign(origin.z);
        Cartesian3_default.unpack(
          degeneratePositionLocalFrame[firstAxis],
          0,
          scratchFirstCartesian
        );
        if (firstAxis !== "east" && firstAxis !== "west") {
          Cartesian3_default.multiplyByScalar(
            scratchFirstCartesian,
            sign3,
            scratchFirstCartesian
          );
        }
        Cartesian3_default.unpack(
          degeneratePositionLocalFrame[secondAxis],
          0,
          scratchSecondCartesian
        );
        if (secondAxis !== "east" && secondAxis !== "west") {
          Cartesian3_default.multiplyByScalar(
            scratchSecondCartesian,
            sign3,
            scratchSecondCartesian
          );
        }
        Cartesian3_default.unpack(
          degeneratePositionLocalFrame[thirdAxis],
          0,
          scratchThirdCartesian
        );
        if (thirdAxis !== "east" && thirdAxis !== "west") {
          Cartesian3_default.multiplyByScalar(
            scratchThirdCartesian,
            sign3,
            scratchThirdCartesian
          );
        }
      } else {
        ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
        ellipsoid.geodeticSurfaceNormal(origin, scratchCalculateCartesian.up);
        const up = scratchCalculateCartesian.up;
        const east = scratchCalculateCartesian.east;
        east.x = -origin.y;
        east.y = origin.x;
        east.z = 0;
        Cartesian3_default.normalize(east, scratchCalculateCartesian.east);
        Cartesian3_default.cross(up, east, scratchCalculateCartesian.north);
        Cartesian3_default.multiplyByScalar(
          scratchCalculateCartesian.up,
          -1,
          scratchCalculateCartesian.down
        );
        Cartesian3_default.multiplyByScalar(
          scratchCalculateCartesian.east,
          -1,
          scratchCalculateCartesian.west
        );
        Cartesian3_default.multiplyByScalar(
          scratchCalculateCartesian.north,
          -1,
          scratchCalculateCartesian.south
        );
        scratchFirstCartesian = scratchCalculateCartesian[firstAxis];
        scratchSecondCartesian = scratchCalculateCartesian[secondAxis];
        scratchThirdCartesian = scratchCalculateCartesian[thirdAxis];
      }
      result[0] = scratchFirstCartesian.x;
      result[1] = scratchFirstCartesian.y;
      result[2] = scratchFirstCartesian.z;
      result[3] = 0;
      result[4] = scratchSecondCartesian.x;
      result[5] = scratchSecondCartesian.y;
      result[6] = scratchSecondCartesian.z;
      result[7] = 0;
      result[8] = scratchThirdCartesian.x;
      result[9] = scratchThirdCartesian.y;
      result[10] = scratchThirdCartesian.z;
      result[11] = 0;
      result[12] = origin.x;
      result[13] = origin.y;
      result[14] = origin.z;
      result[15] = 1;
      return result;
    };
    localFrameToFixedFrameCache[hashAxis] = resultat;
  }
  return resultat;
};
Transforms.eastNorthUpToFixedFrame = Transforms.localFrameToFixedFrameGenerator(
  "east",
  "north"
);
Transforms.northEastDownToFixedFrame = Transforms.localFrameToFixedFrameGenerator(
  "north",
  "east"
);
Transforms.northUpEastToFixedFrame = Transforms.localFrameToFixedFrameGenerator(
  "north",
  "up"
);
Transforms.northWestUpToFixedFrame = Transforms.localFrameToFixedFrameGenerator(
  "north",
  "west"
);
var scratchHPRQuaternion2 = new Quaternion_default();
var scratchScale = new Cartesian3_default(1, 1, 1);
var scratchHPRMatrix4 = new Matrix4_default();
Transforms.headingPitchRollToFixedFrame = function(origin, headingPitchRoll, ellipsoid, fixedFrameTransform, result) {
  Check_default.typeOf.object("HeadingPitchRoll", headingPitchRoll);
  fixedFrameTransform = defaultValue_default(
    fixedFrameTransform,
    Transforms.eastNorthUpToFixedFrame
  );
  const hprQuaternion = Quaternion_default.fromHeadingPitchRoll(
    headingPitchRoll,
    scratchHPRQuaternion2
  );
  const hprMatrix = Matrix4_default.fromTranslationQuaternionRotationScale(
    Cartesian3_default.ZERO,
    hprQuaternion,
    scratchScale,
    scratchHPRMatrix4
  );
  result = fixedFrameTransform(origin, ellipsoid, result);
  return Matrix4_default.multiply(result, hprMatrix, result);
};
var scratchENUMatrix4 = new Matrix4_default();
var scratchHPRMatrix3 = new Matrix3_default();
Transforms.headingPitchRollQuaternion = function(origin, headingPitchRoll, ellipsoid, fixedFrameTransform, result) {
  Check_default.typeOf.object("HeadingPitchRoll", headingPitchRoll);
  const transform4 = Transforms.headingPitchRollToFixedFrame(
    origin,
    headingPitchRoll,
    ellipsoid,
    fixedFrameTransform,
    scratchENUMatrix4
  );
  const rotation = Matrix4_default.getMatrix3(transform4, scratchHPRMatrix3);
  return Quaternion_default.fromRotationMatrix(rotation, result);
};
var noScale = new Cartesian3_default(1, 1, 1);
var hprCenterScratch = new Cartesian3_default();
var ffScratch = new Matrix4_default();
var hprTransformScratch = new Matrix4_default();
var hprRotationScratch = new Matrix3_default();
var hprQuaternionScratch = new Quaternion_default();
Transforms.fixedFrameToHeadingPitchRoll = function(transform4, ellipsoid, fixedFrameTransform, result) {
  Check_default.defined("transform", transform4);
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  fixedFrameTransform = defaultValue_default(
    fixedFrameTransform,
    Transforms.eastNorthUpToFixedFrame
  );
  if (!defined_default(result)) {
    result = new HeadingPitchRoll_default();
  }
  const center = Matrix4_default.getTranslation(transform4, hprCenterScratch);
  if (Cartesian3_default.equals(center, Cartesian3_default.ZERO)) {
    result.heading = 0;
    result.pitch = 0;
    result.roll = 0;
    return result;
  }
  let toFixedFrame = Matrix4_default.inverseTransformation(
    fixedFrameTransform(center, ellipsoid, ffScratch),
    ffScratch
  );
  let transformCopy = Matrix4_default.setScale(transform4, noScale, hprTransformScratch);
  transformCopy = Matrix4_default.setTranslation(
    transformCopy,
    Cartesian3_default.ZERO,
    transformCopy
  );
  toFixedFrame = Matrix4_default.multiply(toFixedFrame, transformCopy, toFixedFrame);
  let quaternionRotation = Quaternion_default.fromRotationMatrix(
    Matrix4_default.getMatrix3(toFixedFrame, hprRotationScratch),
    hprQuaternionScratch
  );
  quaternionRotation = Quaternion_default.normalize(
    quaternionRotation,
    quaternionRotation
  );
  return HeadingPitchRoll_default.fromQuaternion(quaternionRotation, result);
};
var gmstConstant0 = 6 * 3600 + 41 * 60 + 50.54841;
var gmstConstant1 = 8640184812866e-6;
var gmstConstant2 = 0.093104;
var gmstConstant3 = -62e-7;
var rateCoef = 11772758384668e-32;
var wgs84WRPrecessing = 72921158553e-15;
var twoPiOverSecondsInDay = Math_default.TWO_PI / 86400;
var dateInUtc = new JulianDate_default();
Transforms.computeTemeToPseudoFixedMatrix = function(date, result) {
  if (!defined_default(date)) {
    throw new DeveloperError_default("date is required.");
  }
  dateInUtc = JulianDate_default.addSeconds(
    date,
    -JulianDate_default.computeTaiMinusUtc(date),
    dateInUtc
  );
  const utcDayNumber = dateInUtc.dayNumber;
  const utcSecondsIntoDay = dateInUtc.secondsOfDay;
  let t;
  const diffDays = utcDayNumber - 2451545;
  if (utcSecondsIntoDay >= 43200) {
    t = (diffDays + 0.5) / TimeConstants_default.DAYS_PER_JULIAN_CENTURY;
  } else {
    t = (diffDays - 0.5) / TimeConstants_default.DAYS_PER_JULIAN_CENTURY;
  }
  const gmst0 = gmstConstant0 + t * (gmstConstant1 + t * (gmstConstant2 + t * gmstConstant3));
  const angle = gmst0 * twoPiOverSecondsInDay % Math_default.TWO_PI;
  const ratio = wgs84WRPrecessing + rateCoef * (utcDayNumber - 24515455e-1);
  const secondsSinceMidnight = (utcSecondsIntoDay + TimeConstants_default.SECONDS_PER_DAY * 0.5) % TimeConstants_default.SECONDS_PER_DAY;
  const gha = angle + ratio * secondsSinceMidnight;
  const cosGha = Math.cos(gha);
  const sinGha = Math.sin(gha);
  if (!defined_default(result)) {
    return new Matrix3_default(
      cosGha,
      sinGha,
      0,
      -sinGha,
      cosGha,
      0,
      0,
      0,
      1
    );
  }
  result[0] = cosGha;
  result[1] = -sinGha;
  result[2] = 0;
  result[3] = sinGha;
  result[4] = cosGha;
  result[5] = 0;
  result[6] = 0;
  result[7] = 0;
  result[8] = 1;
  return result;
};
Transforms.iau2006XysData = new Iau2006XysData_default();
Transforms.earthOrientationParameters = EarthOrientationParameters_default.NONE;
var ttMinusTai = 32.184;
var j2000ttDays = 2451545;
Transforms.preloadIcrfFixed = function(timeInterval) {
  const startDayTT = timeInterval.start.dayNumber;
  const startSecondTT = timeInterval.start.secondsOfDay + ttMinusTai;
  const stopDayTT = timeInterval.stop.dayNumber;
  const stopSecondTT = timeInterval.stop.secondsOfDay + ttMinusTai;
  const xysPromise = Transforms.iau2006XysData.preload(
    startDayTT,
    startSecondTT,
    stopDayTT,
    stopSecondTT
  );
  const eopPromise = Transforms.earthOrientationParameters.getPromiseToLoad();
  return Promise.all([xysPromise, eopPromise]);
};
Transforms.computeIcrfToFixedMatrix = function(date, result) {
  if (!defined_default(date)) {
    throw new DeveloperError_default("date is required.");
  }
  if (!defined_default(result)) {
    result = new Matrix3_default();
  }
  const fixedToIcrfMtx = Transforms.computeFixedToIcrfMatrix(date, result);
  if (!defined_default(fixedToIcrfMtx)) {
    return void 0;
  }
  return Matrix3_default.transpose(fixedToIcrfMtx, result);
};
var xysScratch = new Iau2006XysSample_default(0, 0, 0);
var eopScratch = new EarthOrientationParametersSample_default(
  0,
  0,
  0,
  0,
  0,
  0
);
var rotation1Scratch = new Matrix3_default();
var rotation2Scratch = new Matrix3_default();
Transforms.computeFixedToIcrfMatrix = function(date, result) {
  if (!defined_default(date)) {
    throw new DeveloperError_default("date is required.");
  }
  if (!defined_default(result)) {
    result = new Matrix3_default();
  }
  const eop = Transforms.earthOrientationParameters.compute(date, eopScratch);
  if (!defined_default(eop)) {
    return void 0;
  }
  const dayTT = date.dayNumber;
  const secondTT = date.secondsOfDay + ttMinusTai;
  const xys = Transforms.iau2006XysData.computeXysRadians(
    dayTT,
    secondTT,
    xysScratch
  );
  if (!defined_default(xys)) {
    return void 0;
  }
  const x = xys.x + eop.xPoleOffset;
  const y = xys.y + eop.yPoleOffset;
  const a4 = 1 / (1 + Math.sqrt(1 - x * x - y * y));
  const rotation1 = rotation1Scratch;
  rotation1[0] = 1 - a4 * x * x;
  rotation1[3] = -a4 * x * y;
  rotation1[6] = x;
  rotation1[1] = -a4 * x * y;
  rotation1[4] = 1 - a4 * y * y;
  rotation1[7] = y;
  rotation1[2] = -x;
  rotation1[5] = -y;
  rotation1[8] = 1 - a4 * (x * x + y * y);
  const rotation2 = Matrix3_default.fromRotationZ(-xys.s, rotation2Scratch);
  const matrixQ = Matrix3_default.multiply(rotation1, rotation2, rotation1Scratch);
  const dateUt1day = date.dayNumber;
  const dateUt1sec = date.secondsOfDay - JulianDate_default.computeTaiMinusUtc(date) + eop.ut1MinusUtc;
  const daysSinceJ2000 = dateUt1day - 2451545;
  const fractionOfDay = dateUt1sec / TimeConstants_default.SECONDS_PER_DAY;
  let era = 0.779057273264 + fractionOfDay + 0.00273781191135448 * (daysSinceJ2000 + fractionOfDay);
  era = era % 1 * Math_default.TWO_PI;
  const earthRotation = Matrix3_default.fromRotationZ(era, rotation2Scratch);
  const pfToIcrf = Matrix3_default.multiply(matrixQ, earthRotation, rotation1Scratch);
  const cosxp = Math.cos(eop.xPoleWander);
  const cosyp = Math.cos(eop.yPoleWander);
  const sinxp = Math.sin(eop.xPoleWander);
  const sinyp = Math.sin(eop.yPoleWander);
  let ttt = dayTT - j2000ttDays + secondTT / TimeConstants_default.SECONDS_PER_DAY;
  ttt /= 36525;
  const sp = -47e-6 * ttt * Math_default.RADIANS_PER_DEGREE / 3600;
  const cossp = Math.cos(sp);
  const sinsp = Math.sin(sp);
  const fToPfMtx = rotation2Scratch;
  fToPfMtx[0] = cosxp * cossp;
  fToPfMtx[1] = cosxp * sinsp;
  fToPfMtx[2] = sinxp;
  fToPfMtx[3] = -cosyp * sinsp + sinyp * sinxp * cossp;
  fToPfMtx[4] = cosyp * cossp + sinyp * sinxp * sinsp;
  fToPfMtx[5] = -sinyp * cosxp;
  fToPfMtx[6] = -sinyp * sinsp - cosyp * sinxp * cossp;
  fToPfMtx[7] = sinyp * cossp - cosyp * sinxp * sinsp;
  fToPfMtx[8] = cosyp * cosxp;
  return Matrix3_default.multiply(pfToIcrf, fToPfMtx, result);
};
var pointToWindowCoordinatesTemp = new Cartesian4_default();
Transforms.pointToWindowCoordinates = function(modelViewProjectionMatrix, viewportTransformation, point, result) {
  result = Transforms.pointToGLWindowCoordinates(
    modelViewProjectionMatrix,
    viewportTransformation,
    point,
    result
  );
  result.y = 2 * viewportTransformation[5] - result.y;
  return result;
};
Transforms.pointToGLWindowCoordinates = function(modelViewProjectionMatrix, viewportTransformation, point, result) {
  if (!defined_default(modelViewProjectionMatrix)) {
    throw new DeveloperError_default("modelViewProjectionMatrix is required.");
  }
  if (!defined_default(viewportTransformation)) {
    throw new DeveloperError_default("viewportTransformation is required.");
  }
  if (!defined_default(point)) {
    throw new DeveloperError_default("point is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian2_default();
  }
  const tmp2 = pointToWindowCoordinatesTemp;
  Matrix4_default.multiplyByVector(
    modelViewProjectionMatrix,
    Cartesian4_default.fromElements(point.x, point.y, point.z, 1, tmp2),
    tmp2
  );
  Cartesian4_default.multiplyByScalar(tmp2, 1 / tmp2.w, tmp2);
  Matrix4_default.multiplyByVector(viewportTransformation, tmp2, tmp2);
  return Cartesian2_default.fromCartesian4(tmp2, result);
};
var normalScratch = new Cartesian3_default();
var rightScratch = new Cartesian3_default();
var upScratch = new Cartesian3_default();
Transforms.rotationMatrixFromPositionVelocity = function(position, velocity, ellipsoid, result) {
  if (!defined_default(position)) {
    throw new DeveloperError_default("position is required.");
  }
  if (!defined_default(velocity)) {
    throw new DeveloperError_default("velocity is required.");
  }
  const normal2 = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84).geodeticSurfaceNormal(
    position,
    normalScratch
  );
  let right = Cartesian3_default.cross(velocity, normal2, rightScratch);
  if (Cartesian3_default.equalsEpsilon(right, Cartesian3_default.ZERO, Math_default.EPSILON6)) {
    right = Cartesian3_default.clone(Cartesian3_default.UNIT_X, right);
  }
  const up = Cartesian3_default.cross(right, velocity, upScratch);
  Cartesian3_default.normalize(up, up);
  Cartesian3_default.cross(velocity, up, right);
  Cartesian3_default.negate(right, right);
  Cartesian3_default.normalize(right, right);
  if (!defined_default(result)) {
    result = new Matrix3_default();
  }
  result[0] = velocity.x;
  result[1] = velocity.y;
  result[2] = velocity.z;
  result[3] = right.x;
  result[4] = right.y;
  result[5] = right.z;
  result[6] = up.x;
  result[7] = up.y;
  result[8] = up.z;
  return result;
};
var swizzleMatrix = new Matrix4_default(
  0,
  0,
  1,
  0,
  1,
  0,
  0,
  0,
  0,
  1,
  0,
  0,
  0,
  0,
  0,
  1
);
var scratchCartographic = new Cartographic_default();
var scratchCartesian3Projection = new Cartesian3_default();
var scratchCenter = new Cartesian3_default();
var scratchRotation = new Matrix3_default();
var scratchFromENU = new Matrix4_default();
var scratchToENU = new Matrix4_default();
Transforms.basisTo2D = function(projection, matrix, result) {
  if (!defined_default(projection)) {
    throw new DeveloperError_default("projection is required.");
  }
  if (!defined_default(matrix)) {
    throw new DeveloperError_default("matrix is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const rtcCenter = Matrix4_default.getTranslation(matrix, scratchCenter);
  const ellipsoid = projection.ellipsoid;
  const cartographic2 = ellipsoid.cartesianToCartographic(
    rtcCenter,
    scratchCartographic
  );
  const projectedPosition2 = projection.project(
    cartographic2,
    scratchCartesian3Projection
  );
  Cartesian3_default.fromElements(
    projectedPosition2.z,
    projectedPosition2.x,
    projectedPosition2.y,
    projectedPosition2
  );
  const fromENU = Transforms.eastNorthUpToFixedFrame(
    rtcCenter,
    ellipsoid,
    scratchFromENU
  );
  const toENU = Matrix4_default.inverseTransformation(fromENU, scratchToENU);
  const rotation = Matrix4_default.getMatrix3(matrix, scratchRotation);
  const local = Matrix4_default.multiplyByMatrix3(toENU, rotation, result);
  Matrix4_default.multiply(swizzleMatrix, local, result);
  Matrix4_default.setTranslation(result, projectedPosition2, result);
  return result;
};
Transforms.wgs84To2DModelMatrix = function(projection, center, result) {
  if (!defined_default(projection)) {
    throw new DeveloperError_default("projection is required.");
  }
  if (!defined_default(center)) {
    throw new DeveloperError_default("center is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const ellipsoid = projection.ellipsoid;
  const fromENU = Transforms.eastNorthUpToFixedFrame(
    center,
    ellipsoid,
    scratchFromENU
  );
  const toENU = Matrix4_default.inverseTransformation(fromENU, scratchToENU);
  const cartographic2 = ellipsoid.cartesianToCartographic(
    center,
    scratchCartographic
  );
  const projectedPosition2 = projection.project(
    cartographic2,
    scratchCartesian3Projection
  );
  Cartesian3_default.fromElements(
    projectedPosition2.z,
    projectedPosition2.x,
    projectedPosition2.y,
    projectedPosition2
  );
  const translation3 = Matrix4_default.fromTranslation(
    projectedPosition2,
    scratchFromENU
  );
  Matrix4_default.multiply(swizzleMatrix, toENU, result);
  Matrix4_default.multiply(translation3, result, result);
  return result;
};
var Transforms_default = Transforms;

// node_modules/cesium/Source/Core/EllipsoidTangentPlane.js
var scratchCart4 = new Cartesian4_default();
function EllipsoidTangentPlane(origin, ellipsoid) {
  Check_default.defined("origin", origin);
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  origin = ellipsoid.scaleToGeodeticSurface(origin);
  if (!defined_default(origin)) {
    throw new DeveloperError_default(
      "origin must not be at the center of the ellipsoid."
    );
  }
  const eastNorthUp = Transforms_default.eastNorthUpToFixedFrame(origin, ellipsoid);
  this._ellipsoid = ellipsoid;
  this._origin = origin;
  this._xAxis = Cartesian3_default.fromCartesian4(
    Matrix4_default.getColumn(eastNorthUp, 0, scratchCart4)
  );
  this._yAxis = Cartesian3_default.fromCartesian4(
    Matrix4_default.getColumn(eastNorthUp, 1, scratchCart4)
  );
  const normal2 = Cartesian3_default.fromCartesian4(
    Matrix4_default.getColumn(eastNorthUp, 2, scratchCart4)
  );
  this._plane = Plane_default.fromPointNormal(origin, normal2);
}
Object.defineProperties(EllipsoidTangentPlane.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  },
  origin: {
    get: function() {
      return this._origin;
    }
  },
  plane: {
    get: function() {
      return this._plane;
    }
  },
  xAxis: {
    get: function() {
      return this._xAxis;
    }
  },
  yAxis: {
    get: function() {
      return this._yAxis;
    }
  },
  zAxis: {
    get: function() {
      return this._plane.normal;
    }
  }
});
var tmp = new AxisAlignedBoundingBox_default();
EllipsoidTangentPlane.fromPoints = function(cartesians, ellipsoid) {
  Check_default.defined("cartesians", cartesians);
  const box = AxisAlignedBoundingBox_default.fromPoints(cartesians, tmp);
  return new EllipsoidTangentPlane(box.center, ellipsoid);
};
var scratchProjectPointOntoPlaneRay = new Ray_default();
var scratchProjectPointOntoPlaneCartesian3 = new Cartesian3_default();
EllipsoidTangentPlane.prototype.projectPointOntoPlane = function(cartesian11, result) {
  Check_default.defined("cartesian", cartesian11);
  const ray = scratchProjectPointOntoPlaneRay;
  ray.origin = cartesian11;
  Cartesian3_default.normalize(cartesian11, ray.direction);
  let intersectionPoint = IntersectionTests_default.rayPlane(
    ray,
    this._plane,
    scratchProjectPointOntoPlaneCartesian3
  );
  if (!defined_default(intersectionPoint)) {
    Cartesian3_default.negate(ray.direction, ray.direction);
    intersectionPoint = IntersectionTests_default.rayPlane(
      ray,
      this._plane,
      scratchProjectPointOntoPlaneCartesian3
    );
  }
  if (defined_default(intersectionPoint)) {
    const v7 = Cartesian3_default.subtract(
      intersectionPoint,
      this._origin,
      intersectionPoint
    );
    const x = Cartesian3_default.dot(this._xAxis, v7);
    const y = Cartesian3_default.dot(this._yAxis, v7);
    if (!defined_default(result)) {
      return new Cartesian2_default(x, y);
    }
    result.x = x;
    result.y = y;
    return result;
  }
  return void 0;
};
EllipsoidTangentPlane.prototype.projectPointsOntoPlane = function(cartesians, result) {
  Check_default.defined("cartesians", cartesians);
  if (!defined_default(result)) {
    result = [];
  }
  let count = 0;
  const length3 = cartesians.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const p2 = this.projectPointOntoPlane(cartesians[i2], result[count]);
    if (defined_default(p2)) {
      result[count] = p2;
      count++;
    }
  }
  result.length = count;
  return result;
};
EllipsoidTangentPlane.prototype.projectPointToNearestOnPlane = function(cartesian11, result) {
  Check_default.defined("cartesian", cartesian11);
  if (!defined_default(result)) {
    result = new Cartesian2_default();
  }
  const ray = scratchProjectPointOntoPlaneRay;
  ray.origin = cartesian11;
  Cartesian3_default.clone(this._plane.normal, ray.direction);
  let intersectionPoint = IntersectionTests_default.rayPlane(
    ray,
    this._plane,
    scratchProjectPointOntoPlaneCartesian3
  );
  if (!defined_default(intersectionPoint)) {
    Cartesian3_default.negate(ray.direction, ray.direction);
    intersectionPoint = IntersectionTests_default.rayPlane(
      ray,
      this._plane,
      scratchProjectPointOntoPlaneCartesian3
    );
  }
  const v7 = Cartesian3_default.subtract(
    intersectionPoint,
    this._origin,
    intersectionPoint
  );
  const x = Cartesian3_default.dot(this._xAxis, v7);
  const y = Cartesian3_default.dot(this._yAxis, v7);
  result.x = x;
  result.y = y;
  return result;
};
EllipsoidTangentPlane.prototype.projectPointsToNearestOnPlane = function(cartesians, result) {
  Check_default.defined("cartesians", cartesians);
  if (!defined_default(result)) {
    result = [];
  }
  const length3 = cartesians.length;
  result.length = length3;
  for (let i2 = 0; i2 < length3; i2++) {
    result[i2] = this.projectPointToNearestOnPlane(cartesians[i2], result[i2]);
  }
  return result;
};
var projectPointsOntoEllipsoidScratch = new Cartesian3_default();
EllipsoidTangentPlane.prototype.projectPointOntoEllipsoid = function(cartesian11, result) {
  Check_default.defined("cartesian", cartesian11);
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  const ellipsoid = this._ellipsoid;
  const origin = this._origin;
  const xAxis = this._xAxis;
  const yAxis = this._yAxis;
  const tmp2 = projectPointsOntoEllipsoidScratch;
  Cartesian3_default.multiplyByScalar(xAxis, cartesian11.x, tmp2);
  result = Cartesian3_default.add(origin, tmp2, result);
  Cartesian3_default.multiplyByScalar(yAxis, cartesian11.y, tmp2);
  Cartesian3_default.add(result, tmp2, result);
  ellipsoid.scaleToGeocentricSurface(result, result);
  return result;
};
EllipsoidTangentPlane.prototype.projectPointsOntoEllipsoid = function(cartesians, result) {
  Check_default.defined("cartesians", cartesians);
  const length3 = cartesians.length;
  if (!defined_default(result)) {
    result = new Array(length3);
  } else {
    result.length = length3;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    result[i2] = this.projectPointOntoEllipsoid(cartesians[i2], result[i2]);
  }
  return result;
};
var EllipsoidTangentPlane_default = EllipsoidTangentPlane;

// node_modules/cesium/Source/Core/OrientedBoundingBox.js
function OrientedBoundingBox(center, halfAxes) {
  this.center = Cartesian3_default.clone(defaultValue_default(center, Cartesian3_default.ZERO));
  this.halfAxes = Matrix3_default.clone(defaultValue_default(halfAxes, Matrix3_default.ZERO));
}
OrientedBoundingBox.packedLength = Cartesian3_default.packedLength + Matrix3_default.packedLength;
OrientedBoundingBox.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  Cartesian3_default.pack(value.center, array, startingIndex);
  Matrix3_default.pack(value.halfAxes, array, startingIndex + Cartesian3_default.packedLength);
  return array;
};
OrientedBoundingBox.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new OrientedBoundingBox();
  }
  Cartesian3_default.unpack(array, startingIndex, result.center);
  Matrix3_default.unpack(
    array,
    startingIndex + Cartesian3_default.packedLength,
    result.halfAxes
  );
  return result;
};
var scratchCartesian1 = new Cartesian3_default();
var scratchCartesian22 = new Cartesian3_default();
var scratchCartesian32 = new Cartesian3_default();
var scratchCartesian4 = new Cartesian3_default();
var scratchCartesian5 = new Cartesian3_default();
var scratchCartesian6 = new Cartesian3_default();
var scratchCovarianceResult = new Matrix3_default();
var scratchEigenResult = {
  unitary: new Matrix3_default(),
  diagonal: new Matrix3_default()
};
OrientedBoundingBox.fromPoints = function(positions, result) {
  if (!defined_default(result)) {
    result = new OrientedBoundingBox();
  }
  if (!defined_default(positions) || positions.length === 0) {
    result.halfAxes = Matrix3_default.ZERO;
    result.center = Cartesian3_default.ZERO;
    return result;
  }
  let i2;
  const length3 = positions.length;
  const meanPoint = Cartesian3_default.clone(positions[0], scratchCartesian1);
  for (i2 = 1; i2 < length3; i2++) {
    Cartesian3_default.add(meanPoint, positions[i2], meanPoint);
  }
  const invLength = 1 / length3;
  Cartesian3_default.multiplyByScalar(meanPoint, invLength, meanPoint);
  let exx = 0;
  let exy = 0;
  let exz = 0;
  let eyy = 0;
  let eyz = 0;
  let ezz = 0;
  let p2;
  for (i2 = 0; i2 < length3; i2++) {
    p2 = Cartesian3_default.subtract(positions[i2], meanPoint, scratchCartesian22);
    exx += p2.x * p2.x;
    exy += p2.x * p2.y;
    exz += p2.x * p2.z;
    eyy += p2.y * p2.y;
    eyz += p2.y * p2.z;
    ezz += p2.z * p2.z;
  }
  exx *= invLength;
  exy *= invLength;
  exz *= invLength;
  eyy *= invLength;
  eyz *= invLength;
  ezz *= invLength;
  const covarianceMatrix = scratchCovarianceResult;
  covarianceMatrix[0] = exx;
  covarianceMatrix[1] = exy;
  covarianceMatrix[2] = exz;
  covarianceMatrix[3] = exy;
  covarianceMatrix[4] = eyy;
  covarianceMatrix[5] = eyz;
  covarianceMatrix[6] = exz;
  covarianceMatrix[7] = eyz;
  covarianceMatrix[8] = ezz;
  const eigenDecomposition = Matrix3_default.computeEigenDecomposition(
    covarianceMatrix,
    scratchEigenResult
  );
  const rotation = Matrix3_default.clone(eigenDecomposition.unitary, result.halfAxes);
  let v13 = Matrix3_default.getColumn(rotation, 0, scratchCartesian4);
  let v23 = Matrix3_default.getColumn(rotation, 1, scratchCartesian5);
  let v32 = Matrix3_default.getColumn(rotation, 2, scratchCartesian6);
  let u12 = -Number.MAX_VALUE;
  let u22 = -Number.MAX_VALUE;
  let u3 = -Number.MAX_VALUE;
  let l1 = Number.MAX_VALUE;
  let l2 = Number.MAX_VALUE;
  let l3 = Number.MAX_VALUE;
  for (i2 = 0; i2 < length3; i2++) {
    p2 = positions[i2];
    u12 = Math.max(Cartesian3_default.dot(v13, p2), u12);
    u22 = Math.max(Cartesian3_default.dot(v23, p2), u22);
    u3 = Math.max(Cartesian3_default.dot(v32, p2), u3);
    l1 = Math.min(Cartesian3_default.dot(v13, p2), l1);
    l2 = Math.min(Cartesian3_default.dot(v23, p2), l2);
    l3 = Math.min(Cartesian3_default.dot(v32, p2), l3);
  }
  v13 = Cartesian3_default.multiplyByScalar(v13, 0.5 * (l1 + u12), v13);
  v23 = Cartesian3_default.multiplyByScalar(v23, 0.5 * (l2 + u22), v23);
  v32 = Cartesian3_default.multiplyByScalar(v32, 0.5 * (l3 + u3), v32);
  const center = Cartesian3_default.add(v13, v23, result.center);
  Cartesian3_default.add(center, v32, center);
  const scale = scratchCartesian32;
  scale.x = u12 - l1;
  scale.y = u22 - l2;
  scale.z = u3 - l3;
  Cartesian3_default.multiplyByScalar(scale, 0.5, scale);
  Matrix3_default.multiplyByScale(result.halfAxes, scale, result.halfAxes);
  return result;
};
var scratchOffset = new Cartesian3_default();
var scratchScale2 = new Cartesian3_default();
function fromPlaneExtents(planeOrigin, planeXAxis, planeYAxis, planeZAxis, minimumX, maximumX, minimumY, maximumY, minimumZ, maximumZ, result) {
  if (!defined_default(minimumX) || !defined_default(maximumX) || !defined_default(minimumY) || !defined_default(maximumY) || !defined_default(minimumZ) || !defined_default(maximumZ)) {
    throw new DeveloperError_default(
      "all extents (minimum/maximum X/Y/Z) are required."
    );
  }
  if (!defined_default(result)) {
    result = new OrientedBoundingBox();
  }
  const halfAxes = result.halfAxes;
  Matrix3_default.setColumn(halfAxes, 0, planeXAxis, halfAxes);
  Matrix3_default.setColumn(halfAxes, 1, planeYAxis, halfAxes);
  Matrix3_default.setColumn(halfAxes, 2, planeZAxis, halfAxes);
  let centerOffset = scratchOffset;
  centerOffset.x = (minimumX + maximumX) / 2;
  centerOffset.y = (minimumY + maximumY) / 2;
  centerOffset.z = (minimumZ + maximumZ) / 2;
  const scale = scratchScale2;
  scale.x = (maximumX - minimumX) / 2;
  scale.y = (maximumY - minimumY) / 2;
  scale.z = (maximumZ - minimumZ) / 2;
  const center = result.center;
  centerOffset = Matrix3_default.multiplyByVector(halfAxes, centerOffset, centerOffset);
  Cartesian3_default.add(planeOrigin, centerOffset, center);
  Matrix3_default.multiplyByScale(halfAxes, scale, halfAxes);
  return result;
}
var scratchRectangleCenterCartographic = new Cartographic_default();
var scratchRectangleCenter = new Cartesian3_default();
var scratchPerimeterCartographicNC = new Cartographic_default();
var scratchPerimeterCartographicNW = new Cartographic_default();
var scratchPerimeterCartographicCW = new Cartographic_default();
var scratchPerimeterCartographicSW = new Cartographic_default();
var scratchPerimeterCartographicSC = new Cartographic_default();
var scratchPerimeterCartesianNC = new Cartesian3_default();
var scratchPerimeterCartesianNW = new Cartesian3_default();
var scratchPerimeterCartesianCW = new Cartesian3_default();
var scratchPerimeterCartesianSW = new Cartesian3_default();
var scratchPerimeterCartesianSC = new Cartesian3_default();
var scratchPerimeterProjectedNC = new Cartesian2_default();
var scratchPerimeterProjectedNW = new Cartesian2_default();
var scratchPerimeterProjectedCW = new Cartesian2_default();
var scratchPerimeterProjectedSW = new Cartesian2_default();
var scratchPerimeterProjectedSC = new Cartesian2_default();
var scratchPlaneOrigin = new Cartesian3_default();
var scratchPlaneNormal = new Cartesian3_default();
var scratchPlaneXAxis = new Cartesian3_default();
var scratchHorizonCartesian = new Cartesian3_default();
var scratchHorizonProjected = new Cartesian2_default();
var scratchMaxY = new Cartesian3_default();
var scratchMinY = new Cartesian3_default();
var scratchZ = new Cartesian3_default();
var scratchPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
OrientedBoundingBox.fromRectangle = function(rectangle, minimumHeight, maximumHeight, ellipsoid, result) {
  if (!defined_default(rectangle)) {
    throw new DeveloperError_default("rectangle is required");
  }
  if (rectangle.width < 0 || rectangle.width > Math_default.TWO_PI) {
    throw new DeveloperError_default("Rectangle width must be between 0 and 2*pi");
  }
  if (rectangle.height < 0 || rectangle.height > Math_default.PI) {
    throw new DeveloperError_default("Rectangle height must be between 0 and pi");
  }
  if (defined_default(ellipsoid) && !Math_default.equalsEpsilon(
    ellipsoid.radii.x,
    ellipsoid.radii.y,
    Math_default.EPSILON15
  )) {
    throw new DeveloperError_default(
      "Ellipsoid must be an ellipsoid of revolution (radii.x == radii.y)"
    );
  }
  minimumHeight = defaultValue_default(minimumHeight, 0);
  maximumHeight = defaultValue_default(maximumHeight, 0);
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  let minX, maxX, minY, maxY, minZ, maxZ, plane;
  if (rectangle.width <= Math_default.PI) {
    const tangentPointCartographic = Rectangle_default.center(
      rectangle,
      scratchRectangleCenterCartographic
    );
    const tangentPoint = ellipsoid.cartographicToCartesian(
      tangentPointCartographic,
      scratchRectangleCenter
    );
    const tangentPlane = new EllipsoidTangentPlane_default(tangentPoint, ellipsoid);
    plane = tangentPlane.plane;
    const lonCenter = tangentPointCartographic.longitude;
    const latCenter = rectangle.south < 0 && rectangle.north > 0 ? 0 : tangentPointCartographic.latitude;
    const perimeterCartographicNC = Cartographic_default.fromRadians(
      lonCenter,
      rectangle.north,
      maximumHeight,
      scratchPerimeterCartographicNC
    );
    const perimeterCartographicNW = Cartographic_default.fromRadians(
      rectangle.west,
      rectangle.north,
      maximumHeight,
      scratchPerimeterCartographicNW
    );
    const perimeterCartographicCW = Cartographic_default.fromRadians(
      rectangle.west,
      latCenter,
      maximumHeight,
      scratchPerimeterCartographicCW
    );
    const perimeterCartographicSW = Cartographic_default.fromRadians(
      rectangle.west,
      rectangle.south,
      maximumHeight,
      scratchPerimeterCartographicSW
    );
    const perimeterCartographicSC = Cartographic_default.fromRadians(
      lonCenter,
      rectangle.south,
      maximumHeight,
      scratchPerimeterCartographicSC
    );
    const perimeterCartesianNC = ellipsoid.cartographicToCartesian(
      perimeterCartographicNC,
      scratchPerimeterCartesianNC
    );
    let perimeterCartesianNW = ellipsoid.cartographicToCartesian(
      perimeterCartographicNW,
      scratchPerimeterCartesianNW
    );
    const perimeterCartesianCW = ellipsoid.cartographicToCartesian(
      perimeterCartographicCW,
      scratchPerimeterCartesianCW
    );
    let perimeterCartesianSW = ellipsoid.cartographicToCartesian(
      perimeterCartographicSW,
      scratchPerimeterCartesianSW
    );
    const perimeterCartesianSC = ellipsoid.cartographicToCartesian(
      perimeterCartographicSC,
      scratchPerimeterCartesianSC
    );
    const perimeterProjectedNC = tangentPlane.projectPointToNearestOnPlane(
      perimeterCartesianNC,
      scratchPerimeterProjectedNC
    );
    const perimeterProjectedNW = tangentPlane.projectPointToNearestOnPlane(
      perimeterCartesianNW,
      scratchPerimeterProjectedNW
    );
    const perimeterProjectedCW = tangentPlane.projectPointToNearestOnPlane(
      perimeterCartesianCW,
      scratchPerimeterProjectedCW
    );
    const perimeterProjectedSW = tangentPlane.projectPointToNearestOnPlane(
      perimeterCartesianSW,
      scratchPerimeterProjectedSW
    );
    const perimeterProjectedSC = tangentPlane.projectPointToNearestOnPlane(
      perimeterCartesianSC,
      scratchPerimeterProjectedSC
    );
    minX = Math.min(
      perimeterProjectedNW.x,
      perimeterProjectedCW.x,
      perimeterProjectedSW.x
    );
    maxX = -minX;
    maxY = Math.max(perimeterProjectedNW.y, perimeterProjectedNC.y);
    minY = Math.min(perimeterProjectedSW.y, perimeterProjectedSC.y);
    perimeterCartographicNW.height = perimeterCartographicSW.height = minimumHeight;
    perimeterCartesianNW = ellipsoid.cartographicToCartesian(
      perimeterCartographicNW,
      scratchPerimeterCartesianNW
    );
    perimeterCartesianSW = ellipsoid.cartographicToCartesian(
      perimeterCartographicSW,
      scratchPerimeterCartesianSW
    );
    minZ = Math.min(
      Plane_default.getPointDistance(plane, perimeterCartesianNW),
      Plane_default.getPointDistance(plane, perimeterCartesianSW)
    );
    maxZ = maximumHeight;
    return fromPlaneExtents(
      tangentPlane.origin,
      tangentPlane.xAxis,
      tangentPlane.yAxis,
      tangentPlane.zAxis,
      minX,
      maxX,
      minY,
      maxY,
      minZ,
      maxZ,
      result
    );
  }
  const fullyAboveEquator = rectangle.south > 0;
  const fullyBelowEquator = rectangle.north < 0;
  const latitudeNearestToEquator = fullyAboveEquator ? rectangle.south : fullyBelowEquator ? rectangle.north : 0;
  const centerLongitude = Rectangle_default.center(
    rectangle,
    scratchRectangleCenterCartographic
  ).longitude;
  const planeOrigin = Cartesian3_default.fromRadians(
    centerLongitude,
    latitudeNearestToEquator,
    maximumHeight,
    ellipsoid,
    scratchPlaneOrigin
  );
  planeOrigin.z = 0;
  const isPole = Math.abs(planeOrigin.x) < Math_default.EPSILON10 && Math.abs(planeOrigin.y) < Math_default.EPSILON10;
  const planeNormal = !isPole ? Cartesian3_default.normalize(planeOrigin, scratchPlaneNormal) : Cartesian3_default.UNIT_X;
  const planeYAxis = Cartesian3_default.UNIT_Z;
  const planeXAxis = Cartesian3_default.cross(
    planeNormal,
    planeYAxis,
    scratchPlaneXAxis
  );
  plane = Plane_default.fromPointNormal(planeOrigin, planeNormal, scratchPlane);
  const horizonCartesian = Cartesian3_default.fromRadians(
    centerLongitude + Math_default.PI_OVER_TWO,
    latitudeNearestToEquator,
    maximumHeight,
    ellipsoid,
    scratchHorizonCartesian
  );
  maxX = Cartesian3_default.dot(
    Plane_default.projectPointOntoPlane(
      plane,
      horizonCartesian,
      scratchHorizonProjected
    ),
    planeXAxis
  );
  minX = -maxX;
  maxY = Cartesian3_default.fromRadians(
    0,
    rectangle.north,
    fullyBelowEquator ? minimumHeight : maximumHeight,
    ellipsoid,
    scratchMaxY
  ).z;
  minY = Cartesian3_default.fromRadians(
    0,
    rectangle.south,
    fullyAboveEquator ? minimumHeight : maximumHeight,
    ellipsoid,
    scratchMinY
  ).z;
  const farZ = Cartesian3_default.fromRadians(
    rectangle.east,
    latitudeNearestToEquator,
    maximumHeight,
    ellipsoid,
    scratchZ
  );
  minZ = Plane_default.getPointDistance(plane, farZ);
  maxZ = 0;
  return fromPlaneExtents(
    planeOrigin,
    planeXAxis,
    planeYAxis,
    planeNormal,
    minX,
    maxX,
    minY,
    maxY,
    minZ,
    maxZ,
    result
  );
};
OrientedBoundingBox.fromTransformation = function(transformation, result) {
  Check_default.typeOf.object("transformation", transformation);
  if (!defined_default(result)) {
    result = new OrientedBoundingBox();
  }
  result.center = Matrix4_default.getTranslation(transformation, result.center);
  result.halfAxes = Matrix4_default.getMatrix3(transformation, result.halfAxes);
  result.halfAxes = Matrix3_default.multiplyByScalar(
    result.halfAxes,
    0.5,
    result.halfAxes
  );
  return result;
};
OrientedBoundingBox.clone = function(box, result) {
  if (!defined_default(box)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new OrientedBoundingBox(box.center, box.halfAxes);
  }
  Cartesian3_default.clone(box.center, result.center);
  Matrix3_default.clone(box.halfAxes, result.halfAxes);
  return result;
};
OrientedBoundingBox.intersectPlane = function(box, plane) {
  if (!defined_default(box)) {
    throw new DeveloperError_default("box is required.");
  }
  if (!defined_default(plane)) {
    throw new DeveloperError_default("plane is required.");
  }
  const center = box.center;
  const normal2 = plane.normal;
  const halfAxes = box.halfAxes;
  const normalX = normal2.x, normalY = normal2.y, normalZ = normal2.z;
  const radEffective = Math.abs(
    normalX * halfAxes[Matrix3_default.COLUMN0ROW0] + normalY * halfAxes[Matrix3_default.COLUMN0ROW1] + normalZ * halfAxes[Matrix3_default.COLUMN0ROW2]
  ) + Math.abs(
    normalX * halfAxes[Matrix3_default.COLUMN1ROW0] + normalY * halfAxes[Matrix3_default.COLUMN1ROW1] + normalZ * halfAxes[Matrix3_default.COLUMN1ROW2]
  ) + Math.abs(
    normalX * halfAxes[Matrix3_default.COLUMN2ROW0] + normalY * halfAxes[Matrix3_default.COLUMN2ROW1] + normalZ * halfAxes[Matrix3_default.COLUMN2ROW2]
  );
  const distanceToPlane = Cartesian3_default.dot(normal2, center) + plane.distance;
  if (distanceToPlane <= -radEffective) {
    return Intersect_default.OUTSIDE;
  } else if (distanceToPlane >= radEffective) {
    return Intersect_default.INSIDE;
  }
  return Intersect_default.INTERSECTING;
};
var scratchCartesianU = new Cartesian3_default();
var scratchCartesianV = new Cartesian3_default();
var scratchCartesianW = new Cartesian3_default();
var scratchValidAxis2 = new Cartesian3_default();
var scratchValidAxis3 = new Cartesian3_default();
var scratchPPrime = new Cartesian3_default();
OrientedBoundingBox.distanceSquaredTo = function(box, cartesian11) {
  if (!defined_default(box)) {
    throw new DeveloperError_default("box is required.");
  }
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required.");
  }
  const offset2 = Cartesian3_default.subtract(cartesian11, box.center, scratchOffset);
  const halfAxes = box.halfAxes;
  let u3 = Matrix3_default.getColumn(halfAxes, 0, scratchCartesianU);
  let v7 = Matrix3_default.getColumn(halfAxes, 1, scratchCartesianV);
  let w = Matrix3_default.getColumn(halfAxes, 2, scratchCartesianW);
  const uHalf = Cartesian3_default.magnitude(u3);
  const vHalf = Cartesian3_default.magnitude(v7);
  const wHalf = Cartesian3_default.magnitude(w);
  let uValid = true;
  let vValid = true;
  let wValid = true;
  if (uHalf > 0) {
    Cartesian3_default.divideByScalar(u3, uHalf, u3);
  } else {
    uValid = false;
  }
  if (vHalf > 0) {
    Cartesian3_default.divideByScalar(v7, vHalf, v7);
  } else {
    vValid = false;
  }
  if (wHalf > 0) {
    Cartesian3_default.divideByScalar(w, wHalf, w);
  } else {
    wValid = false;
  }
  const numberOfDegenerateAxes = !uValid + !vValid + !wValid;
  let validAxis1;
  let validAxis2;
  let validAxis3;
  if (numberOfDegenerateAxes === 1) {
    let degenerateAxis = u3;
    validAxis1 = v7;
    validAxis2 = w;
    if (!vValid) {
      degenerateAxis = v7;
      validAxis1 = u3;
    } else if (!wValid) {
      degenerateAxis = w;
      validAxis2 = u3;
    }
    validAxis3 = Cartesian3_default.cross(validAxis1, validAxis2, scratchValidAxis3);
    if (degenerateAxis === u3) {
      u3 = validAxis3;
    } else if (degenerateAxis === v7) {
      v7 = validAxis3;
    } else if (degenerateAxis === w) {
      w = validAxis3;
    }
  } else if (numberOfDegenerateAxes === 2) {
    validAxis1 = u3;
    if (vValid) {
      validAxis1 = v7;
    } else if (wValid) {
      validAxis1 = w;
    }
    let crossVector = Cartesian3_default.UNIT_Y;
    if (crossVector.equalsEpsilon(validAxis1, Math_default.EPSILON3)) {
      crossVector = Cartesian3_default.UNIT_X;
    }
    validAxis2 = Cartesian3_default.cross(validAxis1, crossVector, scratchValidAxis2);
    Cartesian3_default.normalize(validAxis2, validAxis2);
    validAxis3 = Cartesian3_default.cross(validAxis1, validAxis2, scratchValidAxis3);
    Cartesian3_default.normalize(validAxis3, validAxis3);
    if (validAxis1 === u3) {
      v7 = validAxis2;
      w = validAxis3;
    } else if (validAxis1 === v7) {
      w = validAxis2;
      u3 = validAxis3;
    } else if (validAxis1 === w) {
      u3 = validAxis2;
      v7 = validAxis3;
    }
  } else if (numberOfDegenerateAxes === 3) {
    u3 = Cartesian3_default.UNIT_X;
    v7 = Cartesian3_default.UNIT_Y;
    w = Cartesian3_default.UNIT_Z;
  }
  const pPrime = scratchPPrime;
  pPrime.x = Cartesian3_default.dot(offset2, u3);
  pPrime.y = Cartesian3_default.dot(offset2, v7);
  pPrime.z = Cartesian3_default.dot(offset2, w);
  let distanceSquared = 0;
  let d;
  if (pPrime.x < -uHalf) {
    d = pPrime.x + uHalf;
    distanceSquared += d * d;
  } else if (pPrime.x > uHalf) {
    d = pPrime.x - uHalf;
    distanceSquared += d * d;
  }
  if (pPrime.y < -vHalf) {
    d = pPrime.y + vHalf;
    distanceSquared += d * d;
  } else if (pPrime.y > vHalf) {
    d = pPrime.y - vHalf;
    distanceSquared += d * d;
  }
  if (pPrime.z < -wHalf) {
    d = pPrime.z + wHalf;
    distanceSquared += d * d;
  } else if (pPrime.z > wHalf) {
    d = pPrime.z - wHalf;
    distanceSquared += d * d;
  }
  return distanceSquared;
};
var scratchCorner = new Cartesian3_default();
var scratchToCenter = new Cartesian3_default();
OrientedBoundingBox.computePlaneDistances = function(box, position, direction2, result) {
  if (!defined_default(box)) {
    throw new DeveloperError_default("box is required.");
  }
  if (!defined_default(position)) {
    throw new DeveloperError_default("position is required.");
  }
  if (!defined_default(direction2)) {
    throw new DeveloperError_default("direction is required.");
  }
  if (!defined_default(result)) {
    result = new Interval_default();
  }
  let minDist = Number.POSITIVE_INFINITY;
  let maxDist = Number.NEGATIVE_INFINITY;
  const center = box.center;
  const halfAxes = box.halfAxes;
  const u3 = Matrix3_default.getColumn(halfAxes, 0, scratchCartesianU);
  const v7 = Matrix3_default.getColumn(halfAxes, 1, scratchCartesianV);
  const w = Matrix3_default.getColumn(halfAxes, 2, scratchCartesianW);
  const corner = Cartesian3_default.add(u3, v7, scratchCorner);
  Cartesian3_default.add(corner, w, corner);
  Cartesian3_default.add(corner, center, corner);
  const toCenter = Cartesian3_default.subtract(corner, position, scratchToCenter);
  let mag = Cartesian3_default.dot(direction2, toCenter);
  minDist = Math.min(mag, minDist);
  maxDist = Math.max(mag, maxDist);
  Cartesian3_default.add(center, u3, corner);
  Cartesian3_default.add(corner, v7, corner);
  Cartesian3_default.subtract(corner, w, corner);
  Cartesian3_default.subtract(corner, position, toCenter);
  mag = Cartesian3_default.dot(direction2, toCenter);
  minDist = Math.min(mag, minDist);
  maxDist = Math.max(mag, maxDist);
  Cartesian3_default.add(center, u3, corner);
  Cartesian3_default.subtract(corner, v7, corner);
  Cartesian3_default.add(corner, w, corner);
  Cartesian3_default.subtract(corner, position, toCenter);
  mag = Cartesian3_default.dot(direction2, toCenter);
  minDist = Math.min(mag, minDist);
  maxDist = Math.max(mag, maxDist);
  Cartesian3_default.add(center, u3, corner);
  Cartesian3_default.subtract(corner, v7, corner);
  Cartesian3_default.subtract(corner, w, corner);
  Cartesian3_default.subtract(corner, position, toCenter);
  mag = Cartesian3_default.dot(direction2, toCenter);
  minDist = Math.min(mag, minDist);
  maxDist = Math.max(mag, maxDist);
  Cartesian3_default.subtract(center, u3, corner);
  Cartesian3_default.add(corner, v7, corner);
  Cartesian3_default.add(corner, w, corner);
  Cartesian3_default.subtract(corner, position, toCenter);
  mag = Cartesian3_default.dot(direction2, toCenter);
  minDist = Math.min(mag, minDist);
  maxDist = Math.max(mag, maxDist);
  Cartesian3_default.subtract(center, u3, corner);
  Cartesian3_default.add(corner, v7, corner);
  Cartesian3_default.subtract(corner, w, corner);
  Cartesian3_default.subtract(corner, position, toCenter);
  mag = Cartesian3_default.dot(direction2, toCenter);
  minDist = Math.min(mag, minDist);
  maxDist = Math.max(mag, maxDist);
  Cartesian3_default.subtract(center, u3, corner);
  Cartesian3_default.subtract(corner, v7, corner);
  Cartesian3_default.add(corner, w, corner);
  Cartesian3_default.subtract(corner, position, toCenter);
  mag = Cartesian3_default.dot(direction2, toCenter);
  minDist = Math.min(mag, minDist);
  maxDist = Math.max(mag, maxDist);
  Cartesian3_default.subtract(center, u3, corner);
  Cartesian3_default.subtract(corner, v7, corner);
  Cartesian3_default.subtract(corner, w, corner);
  Cartesian3_default.subtract(corner, position, toCenter);
  mag = Cartesian3_default.dot(direction2, toCenter);
  minDist = Math.min(mag, minDist);
  maxDist = Math.max(mag, maxDist);
  result.start = minDist;
  result.stop = maxDist;
  return result;
};
var scratchXAxis = new Cartesian3_default();
var scratchYAxis = new Cartesian3_default();
var scratchZAxis = new Cartesian3_default();
OrientedBoundingBox.computeCorners = function(box, result) {
  Check_default.typeOf.object("box", box);
  if (!defined_default(result)) {
    result = [
      new Cartesian3_default(),
      new Cartesian3_default(),
      new Cartesian3_default(),
      new Cartesian3_default(),
      new Cartesian3_default(),
      new Cartesian3_default(),
      new Cartesian3_default(),
      new Cartesian3_default()
    ];
  }
  const center = box.center;
  const halfAxes = box.halfAxes;
  const xAxis = Matrix3_default.getColumn(halfAxes, 0, scratchXAxis);
  const yAxis = Matrix3_default.getColumn(halfAxes, 1, scratchYAxis);
  const zAxis = Matrix3_default.getColumn(halfAxes, 2, scratchZAxis);
  Cartesian3_default.clone(center, result[0]);
  Cartesian3_default.subtract(result[0], xAxis, result[0]);
  Cartesian3_default.subtract(result[0], yAxis, result[0]);
  Cartesian3_default.subtract(result[0], zAxis, result[0]);
  Cartesian3_default.clone(center, result[1]);
  Cartesian3_default.subtract(result[1], xAxis, result[1]);
  Cartesian3_default.subtract(result[1], yAxis, result[1]);
  Cartesian3_default.add(result[1], zAxis, result[1]);
  Cartesian3_default.clone(center, result[2]);
  Cartesian3_default.subtract(result[2], xAxis, result[2]);
  Cartesian3_default.add(result[2], yAxis, result[2]);
  Cartesian3_default.subtract(result[2], zAxis, result[2]);
  Cartesian3_default.clone(center, result[3]);
  Cartesian3_default.subtract(result[3], xAxis, result[3]);
  Cartesian3_default.add(result[3], yAxis, result[3]);
  Cartesian3_default.add(result[3], zAxis, result[3]);
  Cartesian3_default.clone(center, result[4]);
  Cartesian3_default.add(result[4], xAxis, result[4]);
  Cartesian3_default.subtract(result[4], yAxis, result[4]);
  Cartesian3_default.subtract(result[4], zAxis, result[4]);
  Cartesian3_default.clone(center, result[5]);
  Cartesian3_default.add(result[5], xAxis, result[5]);
  Cartesian3_default.subtract(result[5], yAxis, result[5]);
  Cartesian3_default.add(result[5], zAxis, result[5]);
  Cartesian3_default.clone(center, result[6]);
  Cartesian3_default.add(result[6], xAxis, result[6]);
  Cartesian3_default.add(result[6], yAxis, result[6]);
  Cartesian3_default.subtract(result[6], zAxis, result[6]);
  Cartesian3_default.clone(center, result[7]);
  Cartesian3_default.add(result[7], xAxis, result[7]);
  Cartesian3_default.add(result[7], yAxis, result[7]);
  Cartesian3_default.add(result[7], zAxis, result[7]);
  return result;
};
var scratchRotationScale = new Matrix3_default();
OrientedBoundingBox.computeTransformation = function(box, result) {
  Check_default.typeOf.object("box", box);
  if (!defined_default(result)) {
    result = new Matrix4_default();
  }
  const translation3 = box.center;
  const rotationScale = Matrix3_default.multiplyByUniformScale(
    box.halfAxes,
    2,
    scratchRotationScale
  );
  return Matrix4_default.fromRotationTranslation(rotationScale, translation3, result);
};
var scratchBoundingSphere2 = new BoundingSphere_default();
OrientedBoundingBox.isOccluded = function(box, occluder) {
  if (!defined_default(box)) {
    throw new DeveloperError_default("box is required.");
  }
  if (!defined_default(occluder)) {
    throw new DeveloperError_default("occluder is required.");
  }
  const sphere = BoundingSphere_default.fromOrientedBoundingBox(
    box,
    scratchBoundingSphere2
  );
  return !occluder.isBoundingSphereVisible(sphere);
};
OrientedBoundingBox.prototype.intersectPlane = function(plane) {
  return OrientedBoundingBox.intersectPlane(this, plane);
};
OrientedBoundingBox.prototype.distanceSquaredTo = function(cartesian11) {
  return OrientedBoundingBox.distanceSquaredTo(this, cartesian11);
};
OrientedBoundingBox.prototype.computePlaneDistances = function(position, direction2, result) {
  return OrientedBoundingBox.computePlaneDistances(
    this,
    position,
    direction2,
    result
  );
};
OrientedBoundingBox.prototype.computeCorners = function(result) {
  return OrientedBoundingBox.computeCorners(this, result);
};
OrientedBoundingBox.prototype.computeTransformation = function(result) {
  return OrientedBoundingBox.computeTransformation(this, result);
};
OrientedBoundingBox.prototype.isOccluded = function(occluder) {
  return OrientedBoundingBox.isOccluded(this, occluder);
};
OrientedBoundingBox.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && Cartesian3_default.equals(left.center, right.center) && Matrix3_default.equals(left.halfAxes, right.halfAxes);
};
OrientedBoundingBox.prototype.clone = function(result) {
  return OrientedBoundingBox.clone(this, result);
};
OrientedBoundingBox.prototype.equals = function(right) {
  return OrientedBoundingBox.equals(this, right);
};
var OrientedBoundingBox_default = OrientedBoundingBox;

// node_modules/cesium/Source/Core/WebGLConstants.js
var WebGLConstants = {
  DEPTH_BUFFER_BIT: 256,
  STENCIL_BUFFER_BIT: 1024,
  COLOR_BUFFER_BIT: 16384,
  POINTS: 0,
  LINES: 1,
  LINE_LOOP: 2,
  LINE_STRIP: 3,
  TRIANGLES: 4,
  TRIANGLE_STRIP: 5,
  TRIANGLE_FAN: 6,
  ZERO: 0,
  ONE: 1,
  SRC_COLOR: 768,
  ONE_MINUS_SRC_COLOR: 769,
  SRC_ALPHA: 770,
  ONE_MINUS_SRC_ALPHA: 771,
  DST_ALPHA: 772,
  ONE_MINUS_DST_ALPHA: 773,
  DST_COLOR: 774,
  ONE_MINUS_DST_COLOR: 775,
  SRC_ALPHA_SATURATE: 776,
  FUNC_ADD: 32774,
  BLEND_EQUATION: 32777,
  BLEND_EQUATION_RGB: 32777,
  BLEND_EQUATION_ALPHA: 34877,
  FUNC_SUBTRACT: 32778,
  FUNC_REVERSE_SUBTRACT: 32779,
  BLEND_DST_RGB: 32968,
  BLEND_SRC_RGB: 32969,
  BLEND_DST_ALPHA: 32970,
  BLEND_SRC_ALPHA: 32971,
  CONSTANT_COLOR: 32769,
  ONE_MINUS_CONSTANT_COLOR: 32770,
  CONSTANT_ALPHA: 32771,
  ONE_MINUS_CONSTANT_ALPHA: 32772,
  BLEND_COLOR: 32773,
  ARRAY_BUFFER: 34962,
  ELEMENT_ARRAY_BUFFER: 34963,
  ARRAY_BUFFER_BINDING: 34964,
  ELEMENT_ARRAY_BUFFER_BINDING: 34965,
  STREAM_DRAW: 35040,
  STATIC_DRAW: 35044,
  DYNAMIC_DRAW: 35048,
  BUFFER_SIZE: 34660,
  BUFFER_USAGE: 34661,
  CURRENT_VERTEX_ATTRIB: 34342,
  FRONT: 1028,
  BACK: 1029,
  FRONT_AND_BACK: 1032,
  CULL_FACE: 2884,
  BLEND: 3042,
  DITHER: 3024,
  STENCIL_TEST: 2960,
  DEPTH_TEST: 2929,
  SCISSOR_TEST: 3089,
  POLYGON_OFFSET_FILL: 32823,
  SAMPLE_ALPHA_TO_COVERAGE: 32926,
  SAMPLE_COVERAGE: 32928,
  NO_ERROR: 0,
  INVALID_ENUM: 1280,
  INVALID_VALUE: 1281,
  INVALID_OPERATION: 1282,
  OUT_OF_MEMORY: 1285,
  CW: 2304,
  CCW: 2305,
  LINE_WIDTH: 2849,
  ALIASED_POINT_SIZE_RANGE: 33901,
  ALIASED_LINE_WIDTH_RANGE: 33902,
  CULL_FACE_MODE: 2885,
  FRONT_FACE: 2886,
  DEPTH_RANGE: 2928,
  DEPTH_WRITEMASK: 2930,
  DEPTH_CLEAR_VALUE: 2931,
  DEPTH_FUNC: 2932,
  STENCIL_CLEAR_VALUE: 2961,
  STENCIL_FUNC: 2962,
  STENCIL_FAIL: 2964,
  STENCIL_PASS_DEPTH_FAIL: 2965,
  STENCIL_PASS_DEPTH_PASS: 2966,
  STENCIL_REF: 2967,
  STENCIL_VALUE_MASK: 2963,
  STENCIL_WRITEMASK: 2968,
  STENCIL_BACK_FUNC: 34816,
  STENCIL_BACK_FAIL: 34817,
  STENCIL_BACK_PASS_DEPTH_FAIL: 34818,
  STENCIL_BACK_PASS_DEPTH_PASS: 34819,
  STENCIL_BACK_REF: 36003,
  STENCIL_BACK_VALUE_MASK: 36004,
  STENCIL_BACK_WRITEMASK: 36005,
  VIEWPORT: 2978,
  SCISSOR_BOX: 3088,
  COLOR_CLEAR_VALUE: 3106,
  COLOR_WRITEMASK: 3107,
  UNPACK_ALIGNMENT: 3317,
  PACK_ALIGNMENT: 3333,
  MAX_TEXTURE_SIZE: 3379,
  MAX_VIEWPORT_DIMS: 3386,
  SUBPIXEL_BITS: 3408,
  RED_BITS: 3410,
  GREEN_BITS: 3411,
  BLUE_BITS: 3412,
  ALPHA_BITS: 3413,
  DEPTH_BITS: 3414,
  STENCIL_BITS: 3415,
  POLYGON_OFFSET_UNITS: 10752,
  POLYGON_OFFSET_FACTOR: 32824,
  TEXTURE_BINDING_2D: 32873,
  SAMPLE_BUFFERS: 32936,
  SAMPLES: 32937,
  SAMPLE_COVERAGE_VALUE: 32938,
  SAMPLE_COVERAGE_INVERT: 32939,
  COMPRESSED_TEXTURE_FORMATS: 34467,
  DONT_CARE: 4352,
  FASTEST: 4353,
  NICEST: 4354,
  GENERATE_MIPMAP_HINT: 33170,
  BYTE: 5120,
  UNSIGNED_BYTE: 5121,
  SHORT: 5122,
  UNSIGNED_SHORT: 5123,
  INT: 5124,
  UNSIGNED_INT: 5125,
  FLOAT: 5126,
  DEPTH_COMPONENT: 6402,
  ALPHA: 6406,
  RGB: 6407,
  RGBA: 6408,
  LUMINANCE: 6409,
  LUMINANCE_ALPHA: 6410,
  UNSIGNED_SHORT_4_4_4_4: 32819,
  UNSIGNED_SHORT_5_5_5_1: 32820,
  UNSIGNED_SHORT_5_6_5: 33635,
  FRAGMENT_SHADER: 35632,
  VERTEX_SHADER: 35633,
  MAX_VERTEX_ATTRIBS: 34921,
  MAX_VERTEX_UNIFORM_VECTORS: 36347,
  MAX_VARYING_VECTORS: 36348,
  MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661,
  MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660,
  MAX_TEXTURE_IMAGE_UNITS: 34930,
  MAX_FRAGMENT_UNIFORM_VECTORS: 36349,
  SHADER_TYPE: 35663,
  DELETE_STATUS: 35712,
  LINK_STATUS: 35714,
  VALIDATE_STATUS: 35715,
  ATTACHED_SHADERS: 35717,
  ACTIVE_UNIFORMS: 35718,
  ACTIVE_ATTRIBUTES: 35721,
  SHADING_LANGUAGE_VERSION: 35724,
  CURRENT_PROGRAM: 35725,
  NEVER: 512,
  LESS: 513,
  EQUAL: 514,
  LEQUAL: 515,
  GREATER: 516,
  NOTEQUAL: 517,
  GEQUAL: 518,
  ALWAYS: 519,
  KEEP: 7680,
  REPLACE: 7681,
  INCR: 7682,
  DECR: 7683,
  INVERT: 5386,
  INCR_WRAP: 34055,
  DECR_WRAP: 34056,
  VENDOR: 7936,
  RENDERER: 7937,
  VERSION: 7938,
  NEAREST: 9728,
  LINEAR: 9729,
  NEAREST_MIPMAP_NEAREST: 9984,
  LINEAR_MIPMAP_NEAREST: 9985,
  NEAREST_MIPMAP_LINEAR: 9986,
  LINEAR_MIPMAP_LINEAR: 9987,
  TEXTURE_MAG_FILTER: 10240,
  TEXTURE_MIN_FILTER: 10241,
  TEXTURE_WRAP_S: 10242,
  TEXTURE_WRAP_T: 10243,
  TEXTURE_2D: 3553,
  TEXTURE: 5890,
  TEXTURE_CUBE_MAP: 34067,
  TEXTURE_BINDING_CUBE_MAP: 34068,
  TEXTURE_CUBE_MAP_POSITIVE_X: 34069,
  TEXTURE_CUBE_MAP_NEGATIVE_X: 34070,
  TEXTURE_CUBE_MAP_POSITIVE_Y: 34071,
  TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072,
  TEXTURE_CUBE_MAP_POSITIVE_Z: 34073,
  TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074,
  MAX_CUBE_MAP_TEXTURE_SIZE: 34076,
  TEXTURE0: 33984,
  TEXTURE1: 33985,
  TEXTURE2: 33986,
  TEXTURE3: 33987,
  TEXTURE4: 33988,
  TEXTURE5: 33989,
  TEXTURE6: 33990,
  TEXTURE7: 33991,
  TEXTURE8: 33992,
  TEXTURE9: 33993,
  TEXTURE10: 33994,
  TEXTURE11: 33995,
  TEXTURE12: 33996,
  TEXTURE13: 33997,
  TEXTURE14: 33998,
  TEXTURE15: 33999,
  TEXTURE16: 34e3,
  TEXTURE17: 34001,
  TEXTURE18: 34002,
  TEXTURE19: 34003,
  TEXTURE20: 34004,
  TEXTURE21: 34005,
  TEXTURE22: 34006,
  TEXTURE23: 34007,
  TEXTURE24: 34008,
  TEXTURE25: 34009,
  TEXTURE26: 34010,
  TEXTURE27: 34011,
  TEXTURE28: 34012,
  TEXTURE29: 34013,
  TEXTURE30: 34014,
  TEXTURE31: 34015,
  ACTIVE_TEXTURE: 34016,
  REPEAT: 10497,
  CLAMP_TO_EDGE: 33071,
  MIRRORED_REPEAT: 33648,
  FLOAT_VEC2: 35664,
  FLOAT_VEC3: 35665,
  FLOAT_VEC4: 35666,
  INT_VEC2: 35667,
  INT_VEC3: 35668,
  INT_VEC4: 35669,
  BOOL: 35670,
  BOOL_VEC2: 35671,
  BOOL_VEC3: 35672,
  BOOL_VEC4: 35673,
  FLOAT_MAT2: 35674,
  FLOAT_MAT3: 35675,
  FLOAT_MAT4: 35676,
  SAMPLER_2D: 35678,
  SAMPLER_CUBE: 35680,
  VERTEX_ATTRIB_ARRAY_ENABLED: 34338,
  VERTEX_ATTRIB_ARRAY_SIZE: 34339,
  VERTEX_ATTRIB_ARRAY_STRIDE: 34340,
  VERTEX_ATTRIB_ARRAY_TYPE: 34341,
  VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922,
  VERTEX_ATTRIB_ARRAY_POINTER: 34373,
  VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975,
  IMPLEMENTATION_COLOR_READ_TYPE: 35738,
  IMPLEMENTATION_COLOR_READ_FORMAT: 35739,
  COMPILE_STATUS: 35713,
  LOW_FLOAT: 36336,
  MEDIUM_FLOAT: 36337,
  HIGH_FLOAT: 36338,
  LOW_INT: 36339,
  MEDIUM_INT: 36340,
  HIGH_INT: 36341,
  FRAMEBUFFER: 36160,
  RENDERBUFFER: 36161,
  RGBA4: 32854,
  RGB5_A1: 32855,
  RGB565: 36194,
  DEPTH_COMPONENT16: 33189,
  STENCIL_INDEX: 6401,
  STENCIL_INDEX8: 36168,
  DEPTH_STENCIL: 34041,
  RENDERBUFFER_WIDTH: 36162,
  RENDERBUFFER_HEIGHT: 36163,
  RENDERBUFFER_INTERNAL_FORMAT: 36164,
  RENDERBUFFER_RED_SIZE: 36176,
  RENDERBUFFER_GREEN_SIZE: 36177,
  RENDERBUFFER_BLUE_SIZE: 36178,
  RENDERBUFFER_ALPHA_SIZE: 36179,
  RENDERBUFFER_DEPTH_SIZE: 36180,
  RENDERBUFFER_STENCIL_SIZE: 36181,
  FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048,
  FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049,
  FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050,
  FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051,
  COLOR_ATTACHMENT0: 36064,
  DEPTH_ATTACHMENT: 36096,
  STENCIL_ATTACHMENT: 36128,
  DEPTH_STENCIL_ATTACHMENT: 33306,
  NONE: 0,
  FRAMEBUFFER_COMPLETE: 36053,
  FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054,
  FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055,
  FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057,
  FRAMEBUFFER_UNSUPPORTED: 36061,
  FRAMEBUFFER_BINDING: 36006,
  RENDERBUFFER_BINDING: 36007,
  MAX_RENDERBUFFER_SIZE: 34024,
  INVALID_FRAMEBUFFER_OPERATION: 1286,
  UNPACK_FLIP_Y_WEBGL: 37440,
  UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441,
  CONTEXT_LOST_WEBGL: 37442,
  UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443,
  BROWSER_DEFAULT_WEBGL: 37444,
  COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
  COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
  COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
  COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
  COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
  COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
  COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
  COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
  COMPRESSED_RGBA_ASTC_4x4_WEBGL: 37808,
  COMPRESSED_RGB_ETC1_WEBGL: 36196,
  COMPRESSED_RGBA_BPTC_UNORM: 36492,
  HALF_FLOAT_OES: 36193,
  DOUBLE: 5130,
  READ_BUFFER: 3074,
  UNPACK_ROW_LENGTH: 3314,
  UNPACK_SKIP_ROWS: 3315,
  UNPACK_SKIP_PIXELS: 3316,
  PACK_ROW_LENGTH: 3330,
  PACK_SKIP_ROWS: 3331,
  PACK_SKIP_PIXELS: 3332,
  COLOR: 6144,
  DEPTH: 6145,
  STENCIL: 6146,
  RED: 6403,
  RGB8: 32849,
  RGBA8: 32856,
  RGB10_A2: 32857,
  TEXTURE_BINDING_3D: 32874,
  UNPACK_SKIP_IMAGES: 32877,
  UNPACK_IMAGE_HEIGHT: 32878,
  TEXTURE_3D: 32879,
  TEXTURE_WRAP_R: 32882,
  MAX_3D_TEXTURE_SIZE: 32883,
  UNSIGNED_INT_2_10_10_10_REV: 33640,
  MAX_ELEMENTS_VERTICES: 33e3,
  MAX_ELEMENTS_INDICES: 33001,
  TEXTURE_MIN_LOD: 33082,
  TEXTURE_MAX_LOD: 33083,
  TEXTURE_BASE_LEVEL: 33084,
  TEXTURE_MAX_LEVEL: 33085,
  MIN: 32775,
  MAX: 32776,
  DEPTH_COMPONENT24: 33190,
  MAX_TEXTURE_LOD_BIAS: 34045,
  TEXTURE_COMPARE_MODE: 34892,
  TEXTURE_COMPARE_FUNC: 34893,
  CURRENT_QUERY: 34917,
  QUERY_RESULT: 34918,
  QUERY_RESULT_AVAILABLE: 34919,
  STREAM_READ: 35041,
  STREAM_COPY: 35042,
  STATIC_READ: 35045,
  STATIC_COPY: 35046,
  DYNAMIC_READ: 35049,
  DYNAMIC_COPY: 35050,
  MAX_DRAW_BUFFERS: 34852,
  DRAW_BUFFER0: 34853,
  DRAW_BUFFER1: 34854,
  DRAW_BUFFER2: 34855,
  DRAW_BUFFER3: 34856,
  DRAW_BUFFER4: 34857,
  DRAW_BUFFER5: 34858,
  DRAW_BUFFER6: 34859,
  DRAW_BUFFER7: 34860,
  DRAW_BUFFER8: 34861,
  DRAW_BUFFER9: 34862,
  DRAW_BUFFER10: 34863,
  DRAW_BUFFER11: 34864,
  DRAW_BUFFER12: 34865,
  DRAW_BUFFER13: 34866,
  DRAW_BUFFER14: 34867,
  DRAW_BUFFER15: 34868,
  MAX_FRAGMENT_UNIFORM_COMPONENTS: 35657,
  MAX_VERTEX_UNIFORM_COMPONENTS: 35658,
  SAMPLER_3D: 35679,
  SAMPLER_2D_SHADOW: 35682,
  FRAGMENT_SHADER_DERIVATIVE_HINT: 35723,
  PIXEL_PACK_BUFFER: 35051,
  PIXEL_UNPACK_BUFFER: 35052,
  PIXEL_PACK_BUFFER_BINDING: 35053,
  PIXEL_UNPACK_BUFFER_BINDING: 35055,
  FLOAT_MAT2x3: 35685,
  FLOAT_MAT2x4: 35686,
  FLOAT_MAT3x2: 35687,
  FLOAT_MAT3x4: 35688,
  FLOAT_MAT4x2: 35689,
  FLOAT_MAT4x3: 35690,
  SRGB: 35904,
  SRGB8: 35905,
  SRGB8_ALPHA8: 35907,
  COMPARE_REF_TO_TEXTURE: 34894,
  RGBA32F: 34836,
  RGB32F: 34837,
  RGBA16F: 34842,
  RGB16F: 34843,
  VERTEX_ATTRIB_ARRAY_INTEGER: 35069,
  MAX_ARRAY_TEXTURE_LAYERS: 35071,
  MIN_PROGRAM_TEXEL_OFFSET: 35076,
  MAX_PROGRAM_TEXEL_OFFSET: 35077,
  MAX_VARYING_COMPONENTS: 35659,
  TEXTURE_2D_ARRAY: 35866,
  TEXTURE_BINDING_2D_ARRAY: 35869,
  R11F_G11F_B10F: 35898,
  UNSIGNED_INT_10F_11F_11F_REV: 35899,
  RGB9_E5: 35901,
  UNSIGNED_INT_5_9_9_9_REV: 35902,
  TRANSFORM_FEEDBACK_BUFFER_MODE: 35967,
  MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 35968,
  TRANSFORM_FEEDBACK_VARYINGS: 35971,
  TRANSFORM_FEEDBACK_BUFFER_START: 35972,
  TRANSFORM_FEEDBACK_BUFFER_SIZE: 35973,
  TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976,
  RASTERIZER_DISCARD: 35977,
  MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 35978,
  MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 35979,
  INTERLEAVED_ATTRIBS: 35980,
  SEPARATE_ATTRIBS: 35981,
  TRANSFORM_FEEDBACK_BUFFER: 35982,
  TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983,
  RGBA32UI: 36208,
  RGB32UI: 36209,
  RGBA16UI: 36214,
  RGB16UI: 36215,
  RGBA8UI: 36220,
  RGB8UI: 36221,
  RGBA32I: 36226,
  RGB32I: 36227,
  RGBA16I: 36232,
  RGB16I: 36233,
  RGBA8I: 36238,
  RGB8I: 36239,
  RED_INTEGER: 36244,
  RGB_INTEGER: 36248,
  RGBA_INTEGER: 36249,
  SAMPLER_2D_ARRAY: 36289,
  SAMPLER_2D_ARRAY_SHADOW: 36292,
  SAMPLER_CUBE_SHADOW: 36293,
  UNSIGNED_INT_VEC2: 36294,
  UNSIGNED_INT_VEC3: 36295,
  UNSIGNED_INT_VEC4: 36296,
  INT_SAMPLER_2D: 36298,
  INT_SAMPLER_3D: 36299,
  INT_SAMPLER_CUBE: 36300,
  INT_SAMPLER_2D_ARRAY: 36303,
  UNSIGNED_INT_SAMPLER_2D: 36306,
  UNSIGNED_INT_SAMPLER_3D: 36307,
  UNSIGNED_INT_SAMPLER_CUBE: 36308,
  UNSIGNED_INT_SAMPLER_2D_ARRAY: 36311,
  DEPTH_COMPONENT32F: 36012,
  DEPTH32F_STENCIL8: 36013,
  FLOAT_32_UNSIGNED_INT_24_8_REV: 36269,
  FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 33296,
  FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 33297,
  FRAMEBUFFER_ATTACHMENT_RED_SIZE: 33298,
  FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 33299,
  FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 33300,
  FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 33301,
  FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 33302,
  FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 33303,
  FRAMEBUFFER_DEFAULT: 33304,
  UNSIGNED_INT_24_8: 34042,
  DEPTH24_STENCIL8: 35056,
  UNSIGNED_NORMALIZED: 35863,
  DRAW_FRAMEBUFFER_BINDING: 36006,
  READ_FRAMEBUFFER: 36008,
  DRAW_FRAMEBUFFER: 36009,
  READ_FRAMEBUFFER_BINDING: 36010,
  RENDERBUFFER_SAMPLES: 36011,
  FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 36052,
  MAX_COLOR_ATTACHMENTS: 36063,
  COLOR_ATTACHMENT1: 36065,
  COLOR_ATTACHMENT2: 36066,
  COLOR_ATTACHMENT3: 36067,
  COLOR_ATTACHMENT4: 36068,
  COLOR_ATTACHMENT5: 36069,
  COLOR_ATTACHMENT6: 36070,
  COLOR_ATTACHMENT7: 36071,
  COLOR_ATTACHMENT8: 36072,
  COLOR_ATTACHMENT9: 36073,
  COLOR_ATTACHMENT10: 36074,
  COLOR_ATTACHMENT11: 36075,
  COLOR_ATTACHMENT12: 36076,
  COLOR_ATTACHMENT13: 36077,
  COLOR_ATTACHMENT14: 36078,
  COLOR_ATTACHMENT15: 36079,
  FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 36182,
  MAX_SAMPLES: 36183,
  HALF_FLOAT: 5131,
  RG: 33319,
  RG_INTEGER: 33320,
  R8: 33321,
  RG8: 33323,
  R16F: 33325,
  R32F: 33326,
  RG16F: 33327,
  RG32F: 33328,
  R8I: 33329,
  R8UI: 33330,
  R16I: 33331,
  R16UI: 33332,
  R32I: 33333,
  R32UI: 33334,
  RG8I: 33335,
  RG8UI: 33336,
  RG16I: 33337,
  RG16UI: 33338,
  RG32I: 33339,
  RG32UI: 33340,
  VERTEX_ARRAY_BINDING: 34229,
  R8_SNORM: 36756,
  RG8_SNORM: 36757,
  RGB8_SNORM: 36758,
  RGBA8_SNORM: 36759,
  SIGNED_NORMALIZED: 36764,
  COPY_READ_BUFFER: 36662,
  COPY_WRITE_BUFFER: 36663,
  COPY_READ_BUFFER_BINDING: 36662,
  COPY_WRITE_BUFFER_BINDING: 36663,
  UNIFORM_BUFFER: 35345,
  UNIFORM_BUFFER_BINDING: 35368,
  UNIFORM_BUFFER_START: 35369,
  UNIFORM_BUFFER_SIZE: 35370,
  MAX_VERTEX_UNIFORM_BLOCKS: 35371,
  MAX_FRAGMENT_UNIFORM_BLOCKS: 35373,
  MAX_COMBINED_UNIFORM_BLOCKS: 35374,
  MAX_UNIFORM_BUFFER_BINDINGS: 35375,
  MAX_UNIFORM_BLOCK_SIZE: 35376,
  MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 35377,
  MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 35379,
  UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380,
  ACTIVE_UNIFORM_BLOCKS: 35382,
  UNIFORM_TYPE: 35383,
  UNIFORM_SIZE: 35384,
  UNIFORM_BLOCK_INDEX: 35386,
  UNIFORM_OFFSET: 35387,
  UNIFORM_ARRAY_STRIDE: 35388,
  UNIFORM_MATRIX_STRIDE: 35389,
  UNIFORM_IS_ROW_MAJOR: 35390,
  UNIFORM_BLOCK_BINDING: 35391,
  UNIFORM_BLOCK_DATA_SIZE: 35392,
  UNIFORM_BLOCK_ACTIVE_UNIFORMS: 35394,
  UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 35395,
  UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 35396,
  UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 35398,
  INVALID_INDEX: 4294967295,
  MAX_VERTEX_OUTPUT_COMPONENTS: 37154,
  MAX_FRAGMENT_INPUT_COMPONENTS: 37157,
  MAX_SERVER_WAIT_TIMEOUT: 37137,
  OBJECT_TYPE: 37138,
  SYNC_CONDITION: 37139,
  SYNC_STATUS: 37140,
  SYNC_FLAGS: 37141,
  SYNC_FENCE: 37142,
  SYNC_GPU_COMMANDS_COMPLETE: 37143,
  UNSIGNALED: 37144,
  SIGNALED: 37145,
  ALREADY_SIGNALED: 37146,
  TIMEOUT_EXPIRED: 37147,
  CONDITION_SATISFIED: 37148,
  WAIT_FAILED: 37149,
  SYNC_FLUSH_COMMANDS_BIT: 1,
  VERTEX_ATTRIB_ARRAY_DIVISOR: 35070,
  ANY_SAMPLES_PASSED: 35887,
  ANY_SAMPLES_PASSED_CONSERVATIVE: 36202,
  SAMPLER_BINDING: 35097,
  RGB10_A2UI: 36975,
  INT_2_10_10_10_REV: 36255,
  TRANSFORM_FEEDBACK: 36386,
  TRANSFORM_FEEDBACK_PAUSED: 36387,
  TRANSFORM_FEEDBACK_ACTIVE: 36388,
  TRANSFORM_FEEDBACK_BINDING: 36389,
  COMPRESSED_R11_EAC: 37488,
  COMPRESSED_SIGNED_R11_EAC: 37489,
  COMPRESSED_RG11_EAC: 37490,
  COMPRESSED_SIGNED_RG11_EAC: 37491,
  COMPRESSED_RGB8_ETC2: 37492,
  COMPRESSED_SRGB8_ETC2: 37493,
  COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37494,
  COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37495,
  COMPRESSED_RGBA8_ETC2_EAC: 37496,
  COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37497,
  TEXTURE_IMMUTABLE_FORMAT: 37167,
  MAX_ELEMENT_INDEX: 36203,
  TEXTURE_IMMUTABLE_LEVELS: 33503,
  MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047
};
var WebGLConstants_default = Object.freeze(WebGLConstants);

// node_modules/cesium/Source/Core/ComponentDatatype.js
var ComponentDatatype = {
  BYTE: WebGLConstants_default.BYTE,
  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
  SHORT: WebGLConstants_default.SHORT,
  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
  INT: WebGLConstants_default.INT,
  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT,
  FLOAT: WebGLConstants_default.FLOAT,
  DOUBLE: WebGLConstants_default.DOUBLE
};
ComponentDatatype.getSizeInBytes = function(componentDatatype) {
  if (!defined_default(componentDatatype)) {
    throw new DeveloperError_default("value is required.");
  }
  switch (componentDatatype) {
    case ComponentDatatype.BYTE:
      return Int8Array.BYTES_PER_ELEMENT;
    case ComponentDatatype.UNSIGNED_BYTE:
      return Uint8Array.BYTES_PER_ELEMENT;
    case ComponentDatatype.SHORT:
      return Int16Array.BYTES_PER_ELEMENT;
    case ComponentDatatype.UNSIGNED_SHORT:
      return Uint16Array.BYTES_PER_ELEMENT;
    case ComponentDatatype.INT:
      return Int32Array.BYTES_PER_ELEMENT;
    case ComponentDatatype.UNSIGNED_INT:
      return Uint32Array.BYTES_PER_ELEMENT;
    case ComponentDatatype.FLOAT:
      return Float32Array.BYTES_PER_ELEMENT;
    case ComponentDatatype.DOUBLE:
      return Float64Array.BYTES_PER_ELEMENT;
    default:
      throw new DeveloperError_default("componentDatatype is not a valid value.");
  }
};
ComponentDatatype.fromTypedArray = function(array) {
  if (array instanceof Int8Array) {
    return ComponentDatatype.BYTE;
  }
  if (array instanceof Uint8Array) {
    return ComponentDatatype.UNSIGNED_BYTE;
  }
  if (array instanceof Int16Array) {
    return ComponentDatatype.SHORT;
  }
  if (array instanceof Uint16Array) {
    return ComponentDatatype.UNSIGNED_SHORT;
  }
  if (array instanceof Int32Array) {
    return ComponentDatatype.INT;
  }
  if (array instanceof Uint32Array) {
    return ComponentDatatype.UNSIGNED_INT;
  }
  if (array instanceof Float32Array) {
    return ComponentDatatype.FLOAT;
  }
  if (array instanceof Float64Array) {
    return ComponentDatatype.DOUBLE;
  }
};
ComponentDatatype.validate = function(componentDatatype) {
  return defined_default(componentDatatype) && (componentDatatype === ComponentDatatype.BYTE || componentDatatype === ComponentDatatype.UNSIGNED_BYTE || componentDatatype === ComponentDatatype.SHORT || componentDatatype === ComponentDatatype.UNSIGNED_SHORT || componentDatatype === ComponentDatatype.INT || componentDatatype === ComponentDatatype.UNSIGNED_INT || componentDatatype === ComponentDatatype.FLOAT || componentDatatype === ComponentDatatype.DOUBLE);
};
ComponentDatatype.createTypedArray = function(componentDatatype, valuesOrLength) {
  if (!defined_default(componentDatatype)) {
    throw new DeveloperError_default("componentDatatype is required.");
  }
  if (!defined_default(valuesOrLength)) {
    throw new DeveloperError_default("valuesOrLength is required.");
  }
  switch (componentDatatype) {
    case ComponentDatatype.BYTE:
      return new Int8Array(valuesOrLength);
    case ComponentDatatype.UNSIGNED_BYTE:
      return new Uint8Array(valuesOrLength);
    case ComponentDatatype.SHORT:
      return new Int16Array(valuesOrLength);
    case ComponentDatatype.UNSIGNED_SHORT:
      return new Uint16Array(valuesOrLength);
    case ComponentDatatype.INT:
      return new Int32Array(valuesOrLength);
    case ComponentDatatype.UNSIGNED_INT:
      return new Uint32Array(valuesOrLength);
    case ComponentDatatype.FLOAT:
      return new Float32Array(valuesOrLength);
    case ComponentDatatype.DOUBLE:
      return new Float64Array(valuesOrLength);
    default:
      throw new DeveloperError_default("componentDatatype is not a valid value.");
  }
};
ComponentDatatype.createArrayBufferView = function(componentDatatype, buffer, byteOffset, length3) {
  if (!defined_default(componentDatatype)) {
    throw new DeveloperError_default("componentDatatype is required.");
  }
  if (!defined_default(buffer)) {
    throw new DeveloperError_default("buffer is required.");
  }
  byteOffset = defaultValue_default(byteOffset, 0);
  length3 = defaultValue_default(
    length3,
    (buffer.byteLength - byteOffset) / ComponentDatatype.getSizeInBytes(componentDatatype)
  );
  switch (componentDatatype) {
    case ComponentDatatype.BYTE:
      return new Int8Array(buffer, byteOffset, length3);
    case ComponentDatatype.UNSIGNED_BYTE:
      return new Uint8Array(buffer, byteOffset, length3);
    case ComponentDatatype.SHORT:
      return new Int16Array(buffer, byteOffset, length3);
    case ComponentDatatype.UNSIGNED_SHORT:
      return new Uint16Array(buffer, byteOffset, length3);
    case ComponentDatatype.INT:
      return new Int32Array(buffer, byteOffset, length3);
    case ComponentDatatype.UNSIGNED_INT:
      return new Uint32Array(buffer, byteOffset, length3);
    case ComponentDatatype.FLOAT:
      return new Float32Array(buffer, byteOffset, length3);
    case ComponentDatatype.DOUBLE:
      return new Float64Array(buffer, byteOffset, length3);
    default:
      throw new DeveloperError_default("componentDatatype is not a valid value.");
  }
};
ComponentDatatype.fromName = function(name) {
  switch (name) {
    case "BYTE":
      return ComponentDatatype.BYTE;
    case "UNSIGNED_BYTE":
      return ComponentDatatype.UNSIGNED_BYTE;
    case "SHORT":
      return ComponentDatatype.SHORT;
    case "UNSIGNED_SHORT":
      return ComponentDatatype.UNSIGNED_SHORT;
    case "INT":
      return ComponentDatatype.INT;
    case "UNSIGNED_INT":
      return ComponentDatatype.UNSIGNED_INT;
    case "FLOAT":
      return ComponentDatatype.FLOAT;
    case "DOUBLE":
      return ComponentDatatype.DOUBLE;
    default:
      throw new DeveloperError_default("name is not a valid value.");
  }
};
var ComponentDatatype_default = Object.freeze(ComponentDatatype);

// node_modules/cesium/Source/Core/Matrix2.js
function Matrix2(column0Row0, column1Row0, column0Row1, column1Row1) {
  this[0] = defaultValue_default(column0Row0, 0);
  this[1] = defaultValue_default(column0Row1, 0);
  this[2] = defaultValue_default(column1Row0, 0);
  this[3] = defaultValue_default(column1Row1, 0);
}
Matrix2.packedLength = 4;
Matrix2.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value[0];
  array[startingIndex++] = value[1];
  array[startingIndex++] = value[2];
  array[startingIndex++] = value[3];
  return array;
};
Matrix2.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new Matrix2();
  }
  result[0] = array[startingIndex++];
  result[1] = array[startingIndex++];
  result[2] = array[startingIndex++];
  result[3] = array[startingIndex++];
  return result;
};
Matrix2.packArray = function(array, result) {
  Check_default.defined("array", array);
  const length3 = array.length;
  const resultLength = length3 * 4;
  if (!defined_default(result)) {
    result = new Array(resultLength);
  } else if (!Array.isArray(result) && result.length !== resultLength) {
    throw new DeveloperError_default(
      "If result is a typed array, it must have exactly array.length * 4 elements"
    );
  } else if (result.length !== resultLength) {
    result.length = resultLength;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    Matrix2.pack(array[i2], result, i2 * 4);
  }
  return result;
};
Matrix2.unpackArray = function(array, result) {
  Check_default.defined("array", array);
  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 4);
  if (array.length % 4 !== 0) {
    throw new DeveloperError_default("array length must be a multiple of 4.");
  }
  const length3 = array.length;
  if (!defined_default(result)) {
    result = new Array(length3 / 4);
  } else {
    result.length = length3 / 4;
  }
  for (let i2 = 0; i2 < length3; i2 += 4) {
    const index2 = i2 / 4;
    result[index2] = Matrix2.unpack(array, i2, result[index2]);
  }
  return result;
};
Matrix2.clone = function(matrix, result) {
  if (!defined_default(matrix)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Matrix2(matrix[0], matrix[2], matrix[1], matrix[3]);
  }
  result[0] = matrix[0];
  result[1] = matrix[1];
  result[2] = matrix[2];
  result[3] = matrix[3];
  return result;
};
Matrix2.fromArray = Matrix2.unpack;
Matrix2.fromColumnMajorArray = function(values, result) {
  Check_default.defined("values", values);
  return Matrix2.clone(values, result);
};
Matrix2.fromRowMajorArray = function(values, result) {
  Check_default.defined("values", values);
  if (!defined_default(result)) {
    return new Matrix2(values[0], values[1], values[2], values[3]);
  }
  result[0] = values[0];
  result[1] = values[2];
  result[2] = values[1];
  result[3] = values[3];
  return result;
};
Matrix2.fromScale = function(scale, result) {
  Check_default.typeOf.object("scale", scale);
  if (!defined_default(result)) {
    return new Matrix2(scale.x, 0, 0, scale.y);
  }
  result[0] = scale.x;
  result[1] = 0;
  result[2] = 0;
  result[3] = scale.y;
  return result;
};
Matrix2.fromUniformScale = function(scale, result) {
  Check_default.typeOf.number("scale", scale);
  if (!defined_default(result)) {
    return new Matrix2(scale, 0, 0, scale);
  }
  result[0] = scale;
  result[1] = 0;
  result[2] = 0;
  result[3] = scale;
  return result;
};
Matrix2.fromRotation = function(angle, result) {
  Check_default.typeOf.number("angle", angle);
  const cosAngle = Math.cos(angle);
  const sinAngle = Math.sin(angle);
  if (!defined_default(result)) {
    return new Matrix2(cosAngle, -sinAngle, sinAngle, cosAngle);
  }
  result[0] = cosAngle;
  result[1] = sinAngle;
  result[2] = -sinAngle;
  result[3] = cosAngle;
  return result;
};
Matrix2.toArray = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  if (!defined_default(result)) {
    return [matrix[0], matrix[1], matrix[2], matrix[3]];
  }
  result[0] = matrix[0];
  result[1] = matrix[1];
  result[2] = matrix[2];
  result[3] = matrix[3];
  return result;
};
Matrix2.getElementIndex = function(column, row) {
  Check_default.typeOf.number.greaterThanOrEquals("row", row, 0);
  Check_default.typeOf.number.lessThanOrEquals("row", row, 1);
  Check_default.typeOf.number.greaterThanOrEquals("column", column, 0);
  Check_default.typeOf.number.lessThanOrEquals("column", column, 1);
  return column * 2 + row;
};
Matrix2.getColumn = function(matrix, index2, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 1);
  Check_default.typeOf.object("result", result);
  const startIndex = index2 * 2;
  const x = matrix[startIndex];
  const y = matrix[startIndex + 1];
  result.x = x;
  result.y = y;
  return result;
};
Matrix2.setColumn = function(matrix, index2, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 1);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result = Matrix2.clone(matrix, result);
  const startIndex = index2 * 2;
  result[startIndex] = cartesian11.x;
  result[startIndex + 1] = cartesian11.y;
  return result;
};
Matrix2.getRow = function(matrix, index2, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 1);
  Check_default.typeOf.object("result", result);
  const x = matrix[index2];
  const y = matrix[index2 + 2];
  result.x = x;
  result.y = y;
  return result;
};
Matrix2.setRow = function(matrix, index2, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThanOrEquals("index", index2, 1);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  result = Matrix2.clone(matrix, result);
  result[index2] = cartesian11.x;
  result[index2 + 2] = cartesian11.y;
  return result;
};
var scaleScratch13 = new Cartesian2_default();
Matrix2.setScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("scale", scale);
  Check_default.typeOf.object("result", result);
  const existingScale = Matrix2.getScale(matrix, scaleScratch13);
  const scaleRatioX = scale.x / existingScale.x;
  const scaleRatioY = scale.y / existingScale.y;
  result[0] = matrix[0] * scaleRatioX;
  result[1] = matrix[1] * scaleRatioX;
  result[2] = matrix[2] * scaleRatioY;
  result[3] = matrix[3] * scaleRatioY;
  return result;
};
var scaleScratch23 = new Cartesian2_default();
Matrix2.setUniformScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number("scale", scale);
  Check_default.typeOf.object("result", result);
  const existingScale = Matrix2.getScale(matrix, scaleScratch23);
  const scaleRatioX = scale / existingScale.x;
  const scaleRatioY = scale / existingScale.y;
  result[0] = matrix[0] * scaleRatioX;
  result[1] = matrix[1] * scaleRatioX;
  result[2] = matrix[2] * scaleRatioY;
  result[3] = matrix[3] * scaleRatioY;
  return result;
};
var scratchColumn3 = new Cartesian2_default();
Matrix2.getScale = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result.x = Cartesian2_default.magnitude(
    Cartesian2_default.fromElements(matrix[0], matrix[1], scratchColumn3)
  );
  result.y = Cartesian2_default.magnitude(
    Cartesian2_default.fromElements(matrix[2], matrix[3], scratchColumn3)
  );
  return result;
};
var scaleScratch33 = new Cartesian2_default();
Matrix2.getMaximumScale = function(matrix) {
  Matrix2.getScale(matrix, scaleScratch33);
  return Cartesian2_default.maximumComponent(scaleScratch33);
};
var scaleScratch43 = new Cartesian2_default();
Matrix2.setRotation = function(matrix, rotation, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const scale = Matrix2.getScale(matrix, scaleScratch43);
  result[0] = rotation[0] * scale.x;
  result[1] = rotation[1] * scale.x;
  result[2] = rotation[2] * scale.y;
  result[3] = rotation[3] * scale.y;
  return result;
};
var scaleScratch53 = new Cartesian2_default();
Matrix2.getRotation = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const scale = Matrix2.getScale(matrix, scaleScratch53);
  result[0] = matrix[0] / scale.x;
  result[1] = matrix[1] / scale.x;
  result[2] = matrix[2] / scale.y;
  result[3] = matrix[3] / scale.y;
  return result;
};
Matrix2.multiply = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  const column0Row0 = left[0] * right[0] + left[2] * right[1];
  const column1Row0 = left[0] * right[2] + left[2] * right[3];
  const column0Row1 = left[1] * right[0] + left[3] * right[1];
  const column1Row1 = left[1] * right[2] + left[3] * right[3];
  result[0] = column0Row0;
  result[1] = column0Row1;
  result[2] = column1Row0;
  result[3] = column1Row1;
  return result;
};
Matrix2.add = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result[0] = left[0] + right[0];
  result[1] = left[1] + right[1];
  result[2] = left[2] + right[2];
  result[3] = left[3] + right[3];
  return result;
};
Matrix2.subtract = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result[0] = left[0] - right[0];
  result[1] = left[1] - right[1];
  result[2] = left[2] - right[2];
  result[3] = left[3] - right[3];
  return result;
};
Matrix2.multiplyByVector = function(matrix, cartesian11, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("cartesian", cartesian11);
  Check_default.typeOf.object("result", result);
  const x = matrix[0] * cartesian11.x + matrix[2] * cartesian11.y;
  const y = matrix[1] * cartesian11.x + matrix[3] * cartesian11.y;
  result.x = x;
  result.y = y;
  return result;
};
Matrix2.multiplyByScalar = function(matrix, scalar, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0] * scalar;
  result[1] = matrix[1] * scalar;
  result[2] = matrix[2] * scalar;
  result[3] = matrix[3] * scalar;
  return result;
};
Matrix2.multiplyByScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("scale", scale);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0] * scale.x;
  result[1] = matrix[1] * scale.x;
  result[2] = matrix[2] * scale.y;
  result[3] = matrix[3] * scale.y;
  return result;
};
Matrix2.multiplyByUniformScale = function(matrix, scale, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.number("scale", scale);
  Check_default.typeOf.object("result", result);
  result[0] = matrix[0] * scale;
  result[1] = matrix[1] * scale;
  result[2] = matrix[2] * scale;
  result[3] = matrix[3] * scale;
  return result;
};
Matrix2.negate = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result[0] = -matrix[0];
  result[1] = -matrix[1];
  result[2] = -matrix[2];
  result[3] = -matrix[3];
  return result;
};
Matrix2.transpose = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  const column0Row0 = matrix[0];
  const column0Row1 = matrix[2];
  const column1Row0 = matrix[1];
  const column1Row1 = matrix[3];
  result[0] = column0Row0;
  result[1] = column0Row1;
  result[2] = column1Row0;
  result[3] = column1Row1;
  return result;
};
Matrix2.abs = function(matrix, result) {
  Check_default.typeOf.object("matrix", matrix);
  Check_default.typeOf.object("result", result);
  result[0] = Math.abs(matrix[0]);
  result[1] = Math.abs(matrix[1]);
  result[2] = Math.abs(matrix[2]);
  result[3] = Math.abs(matrix[3]);
  return result;
};
Matrix2.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left[0] === right[0] && left[1] === right[1] && left[2] === right[2] && left[3] === right[3];
};
Matrix2.equalsArray = function(matrix, array, offset2) {
  return matrix[0] === array[offset2] && matrix[1] === array[offset2 + 1] && matrix[2] === array[offset2 + 2] && matrix[3] === array[offset2 + 3];
};
Matrix2.equalsEpsilon = function(left, right, epsilon) {
  epsilon = defaultValue_default(epsilon, 0);
  return left === right || defined_default(left) && defined_default(right) && Math.abs(left[0] - right[0]) <= epsilon && Math.abs(left[1] - right[1]) <= epsilon && Math.abs(left[2] - right[2]) <= epsilon && Math.abs(left[3] - right[3]) <= epsilon;
};
Matrix2.IDENTITY = Object.freeze(new Matrix2(1, 0, 0, 1));
Matrix2.ZERO = Object.freeze(new Matrix2(0, 0, 0, 0));
Matrix2.COLUMN0ROW0 = 0;
Matrix2.COLUMN0ROW1 = 1;
Matrix2.COLUMN1ROW0 = 2;
Matrix2.COLUMN1ROW1 = 3;
Object.defineProperties(Matrix2.prototype, {
  length: {
    get: function() {
      return Matrix2.packedLength;
    }
  }
});
Matrix2.prototype.clone = function(result) {
  return Matrix2.clone(this, result);
};
Matrix2.prototype.equals = function(right) {
  return Matrix2.equals(this, right);
};
Matrix2.prototype.equalsEpsilon = function(right, epsilon) {
  return Matrix2.equalsEpsilon(this, right, epsilon);
};
Matrix2.prototype.toString = function() {
  return `(${this[0]}, ${this[2]})
(${this[1]}, ${this[3]})`;
};
var Matrix2_default = Matrix2;

// node_modules/cesium/Source/Scene/AttributeType.js
var AttributeType = {
  SCALAR: "SCALAR",
  VEC2: "VEC2",
  VEC3: "VEC3",
  VEC4: "VEC4",
  MAT2: "MAT2",
  MAT3: "MAT3",
  MAT4: "MAT4"
};
AttributeType.getMathType = function(attributeType) {
  switch (attributeType) {
    case AttributeType.SCALAR:
      return Number;
    case AttributeType.VEC2:
      return Cartesian2_default;
    case AttributeType.VEC3:
      return Cartesian3_default;
    case AttributeType.VEC4:
      return Cartesian4_default;
    case AttributeType.MAT2:
      return Matrix2_default;
    case AttributeType.MAT3:
      return Matrix3_default;
    case AttributeType.MAT4:
      return Matrix4_default;
    default:
      throw new DeveloperError_default("attributeType is not a valid value.");
  }
};
AttributeType.getNumberOfComponents = function(attributeType) {
  switch (attributeType) {
    case AttributeType.SCALAR:
      return 1;
    case AttributeType.VEC2:
      return 2;
    case AttributeType.VEC3:
      return 3;
    case AttributeType.VEC4:
    case AttributeType.MAT2:
      return 4;
    case AttributeType.MAT3:
      return 9;
    case AttributeType.MAT4:
      return 16;
    default:
      throw new DeveloperError_default("attributeType is not a valid value.");
  }
};
AttributeType.getAttributeLocationCount = function(attributeType) {
  switch (attributeType) {
    case AttributeType.SCALAR:
    case AttributeType.VEC2:
    case AttributeType.VEC3:
    case AttributeType.VEC4:
      return 1;
    case AttributeType.MAT2:
      return 2;
    case AttributeType.MAT3:
      return 3;
    case AttributeType.MAT4:
      return 4;
    default:
      throw new DeveloperError_default("attributeType is not a valid value.");
  }
};
AttributeType.getGlslType = function(attributeType) {
  Check_default.typeOf.string("attributeType", attributeType);
  switch (attributeType) {
    case AttributeType.SCALAR:
      return "float";
    case AttributeType.VEC2:
      return "vec2";
    case AttributeType.VEC3:
      return "vec3";
    case AttributeType.VEC4:
      return "vec4";
    case AttributeType.MAT2:
      return "mat2";
    case AttributeType.MAT3:
      return "mat3";
    case AttributeType.MAT4:
      return "mat4";
    default:
      throw new DeveloperError_default("attributeType is not a valid value.");
  }
};
var AttributeType_default = Object.freeze(AttributeType);

// node_modules/cesium/Source/Core/AttributeCompression.js
var RIGHT_SHIFT = 1 / 256;
var LEFT_SHIFT = 256;
var AttributeCompression = {};
AttributeCompression.octEncodeInRange = function(vector, rangeMax, result) {
  Check_default.defined("vector", vector);
  Check_default.defined("result", result);
  const magSquared = Cartesian3_default.magnitudeSquared(vector);
  if (Math.abs(magSquared - 1) > Math_default.EPSILON6) {
    throw new DeveloperError_default("vector must be normalized.");
  }
  result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
  result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
  if (vector.z < 0) {
    const x = result.x;
    const y = result.y;
    result.x = (1 - Math.abs(y)) * Math_default.signNotZero(x);
    result.y = (1 - Math.abs(x)) * Math_default.signNotZero(y);
  }
  result.x = Math_default.toSNorm(result.x, rangeMax);
  result.y = Math_default.toSNorm(result.y, rangeMax);
  return result;
};
AttributeCompression.octEncode = function(vector, result) {
  return AttributeCompression.octEncodeInRange(vector, 255, result);
};
var octEncodeScratch = new Cartesian2_default();
var uint8ForceArray = new Uint8Array(1);
function forceUint8(value) {
  uint8ForceArray[0] = value;
  return uint8ForceArray[0];
}
AttributeCompression.octEncodeToCartesian4 = function(vector, result) {
  AttributeCompression.octEncodeInRange(vector, 65535, octEncodeScratch);
  result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);
  result.y = forceUint8(octEncodeScratch.x);
  result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT);
  result.w = forceUint8(octEncodeScratch.y);
  return result;
};
AttributeCompression.octDecodeInRange = function(x, y, rangeMax, result) {
  Check_default.defined("result", result);
  if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {
    throw new DeveloperError_default(
      `x and y must be unsigned normalized integers between 0 and ${rangeMax}`
    );
  }
  result.x = Math_default.fromSNorm(x, rangeMax);
  result.y = Math_default.fromSNorm(y, rangeMax);
  result.z = 1 - (Math.abs(result.x) + Math.abs(result.y));
  if (result.z < 0) {
    const oldVX = result.x;
    result.x = (1 - Math.abs(result.y)) * Math_default.signNotZero(oldVX);
    result.y = (1 - Math.abs(oldVX)) * Math_default.signNotZero(result.y);
  }
  return Cartesian3_default.normalize(result, result);
};
AttributeCompression.octDecode = function(x, y, result) {
  return AttributeCompression.octDecodeInRange(x, y, 255, result);
};
AttributeCompression.octDecodeFromCartesian4 = function(encoded, result) {
  Check_default.typeOf.object("encoded", encoded);
  Check_default.typeOf.object("result", result);
  const x = encoded.x;
  const y = encoded.y;
  const z = encoded.z;
  const w = encoded.w;
  if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {
    throw new DeveloperError_default(
      "x, y, z, and w must be unsigned normalized integers between 0 and 255"
    );
  }
  const xOct16 = x * LEFT_SHIFT + y;
  const yOct16 = z * LEFT_SHIFT + w;
  return AttributeCompression.octDecodeInRange(xOct16, yOct16, 65535, result);
};
AttributeCompression.octPackFloat = function(encoded) {
  Check_default.defined("encoded", encoded);
  return 256 * encoded.x + encoded.y;
};
var scratchEncodeCart2 = new Cartesian2_default();
AttributeCompression.octEncodeFloat = function(vector) {
  AttributeCompression.octEncode(vector, scratchEncodeCart2);
  return AttributeCompression.octPackFloat(scratchEncodeCart2);
};
AttributeCompression.octDecodeFloat = function(value, result) {
  Check_default.defined("value", value);
  const temp = value / 256;
  const x = Math.floor(temp);
  const y = (temp - x) * 256;
  return AttributeCompression.octDecode(x, y, result);
};
AttributeCompression.octPack = function(v13, v23, v32, result) {
  Check_default.defined("v1", v13);
  Check_default.defined("v2", v23);
  Check_default.defined("v3", v32);
  Check_default.defined("result", result);
  const encoded1 = AttributeCompression.octEncodeFloat(v13);
  const encoded2 = AttributeCompression.octEncodeFloat(v23);
  const encoded3 = AttributeCompression.octEncode(v32, scratchEncodeCart2);
  result.x = 65536 * encoded3.x + encoded1;
  result.y = 65536 * encoded3.y + encoded2;
  return result;
};
AttributeCompression.octUnpack = function(packed, v13, v23, v32) {
  Check_default.defined("packed", packed);
  Check_default.defined("v1", v13);
  Check_default.defined("v2", v23);
  Check_default.defined("v3", v32);
  let temp = packed.x / 65536;
  const x = Math.floor(temp);
  const encodedFloat1 = (temp - x) * 65536;
  temp = packed.y / 65536;
  const y = Math.floor(temp);
  const encodedFloat2 = (temp - y) * 65536;
  AttributeCompression.octDecodeFloat(encodedFloat1, v13);
  AttributeCompression.octDecodeFloat(encodedFloat2, v23);
  AttributeCompression.octDecode(x, y, v32);
};
AttributeCompression.compressTextureCoordinates = function(textureCoordinates) {
  Check_default.defined("textureCoordinates", textureCoordinates);
  const x = textureCoordinates.x * 4095 | 0;
  const y = textureCoordinates.y * 4095 | 0;
  return 4096 * x + y;
};
AttributeCompression.decompressTextureCoordinates = function(compressed, result) {
  Check_default.defined("compressed", compressed);
  Check_default.defined("result", result);
  const temp = compressed / 4096;
  const xZeroTo4095 = Math.floor(temp);
  result.x = xZeroTo4095 / 4095;
  result.y = (compressed - xZeroTo4095 * 4096) / 4095;
  return result;
};
function zigZagDecode(value) {
  return value >> 1 ^ -(value & 1);
}
AttributeCompression.zigZagDeltaDecode = function(uBuffer, vBuffer, heightBuffer) {
  Check_default.defined("uBuffer", uBuffer);
  Check_default.defined("vBuffer", vBuffer);
  Check_default.typeOf.number.equals(
    "uBuffer.length",
    "vBuffer.length",
    uBuffer.length,
    vBuffer.length
  );
  if (defined_default(heightBuffer)) {
    Check_default.typeOf.number.equals(
      "uBuffer.length",
      "heightBuffer.length",
      uBuffer.length,
      heightBuffer.length
    );
  }
  const count = uBuffer.length;
  let u3 = 0;
  let v7 = 0;
  let height = 0;
  for (let i2 = 0; i2 < count; ++i2) {
    u3 += zigZagDecode(uBuffer[i2]);
    v7 += zigZagDecode(vBuffer[i2]);
    uBuffer[i2] = u3;
    vBuffer[i2] = v7;
    if (defined_default(heightBuffer)) {
      height += zigZagDecode(heightBuffer[i2]);
      heightBuffer[i2] = height;
    }
  }
};
AttributeCompression.dequantize = function(typedArray, componentDatatype, type, count) {
  Check_default.defined("typedArray", typedArray);
  Check_default.defined("componentDatatype", componentDatatype);
  Check_default.defined("type", type);
  Check_default.defined("count", count);
  const componentsPerAttribute = AttributeType_default.getNumberOfComponents(type);
  let divisor;
  switch (componentDatatype) {
    case ComponentDatatype_default.BYTE:
      divisor = 127;
      break;
    case ComponentDatatype_default.UNSIGNED_BYTE:
      divisor = 255;
      break;
    case ComponentDatatype_default.SHORT:
      divisor = 32767;
      break;
    case ComponentDatatype_default.UNSIGNED_SHORT:
      divisor = 65535;
      break;
    case ComponentDatatype_default.INT:
      divisor = 2147483647;
      break;
    case ComponentDatatype_default.UNSIGNED_INT:
      divisor = 4294967295;
      break;
    default:
      throw new DeveloperError_default(
        `Cannot dequantize component datatype: ${componentDatatype}`
      );
  }
  const dequantizedTypedArray = new Float32Array(
    count * componentsPerAttribute
  );
  for (let i2 = 0; i2 < count; i2++) {
    for (let j = 0; j < componentsPerAttribute; j++) {
      const index2 = i2 * componentsPerAttribute + j;
      dequantizedTypedArray[index2] = Math.max(
        typedArray[index2] / divisor,
        -1
      );
    }
  }
  return dequantizedTypedArray;
};
AttributeCompression.decodeRGB565 = function(typedArray, result) {
  Check_default.defined("typedArray", typedArray);
  const expectedLength = typedArray.length * 3;
  if (defined_default(result)) {
    Check_default.typeOf.number.equals(
      "result.length",
      "typedArray.length * 3",
      result.length,
      expectedLength
    );
  }
  const count = typedArray.length;
  if (!defined_default(result)) {
    result = new Float32Array(count * 3);
  }
  const mask5 = (1 << 5) - 1;
  const mask6 = (1 << 6) - 1;
  const normalize5 = 1 / 31;
  const normalize6 = 1 / 63;
  for (let i2 = 0; i2 < count; i2++) {
    const value = typedArray[i2];
    const red = value >> 11;
    const green = value >> 5 & mask6;
    const blue = value & mask5;
    const offset2 = 3 * i2;
    result[offset2] = red * normalize5;
    result[offset2 + 1] = green * normalize6;
    result[offset2 + 2] = blue * normalize5;
  }
  return result;
};
var AttributeCompression_default = AttributeCompression;

// node_modules/cesium/Source/Core/TerrainExaggeration.js
var TerrainExaggeration = {};
TerrainExaggeration.getHeight = function(height, scale, relativeHeight) {
  return (height - relativeHeight) * scale + relativeHeight;
};
var scratchCartographic2 = new Cartesian3_default();
TerrainExaggeration.getPosition = function(position, ellipsoid, terrainExaggeration, terrainExaggerationRelativeHeight, result) {
  const cartographic2 = ellipsoid.cartesianToCartographic(
    position,
    scratchCartographic2
  );
  const newHeight = TerrainExaggeration.getHeight(
    cartographic2.height,
    terrainExaggeration,
    terrainExaggerationRelativeHeight
  );
  return Cartesian3_default.fromRadians(
    cartographic2.longitude,
    cartographic2.latitude,
    newHeight,
    ellipsoid,
    result
  );
};
var TerrainExaggeration_default = TerrainExaggeration;

// node_modules/cesium/Source/Core/TerrainQuantization.js
var TerrainQuantization = {
  NONE: 0,
  BITS12: 1
};
var TerrainQuantization_default = Object.freeze(TerrainQuantization);

// node_modules/cesium/Source/Core/TerrainEncoding.js
var cartesian3Scratch = new Cartesian3_default();
var cartesian3DimScratch = new Cartesian3_default();
var cartesian2Scratch = new Cartesian2_default();
var matrix4Scratch = new Matrix4_default();
var matrix4Scratch2 = new Matrix4_default();
var SHIFT_LEFT_12 = Math.pow(2, 12);
function TerrainEncoding(center, axisAlignedBoundingBox, minimumHeight, maximumHeight, fromENU, hasVertexNormals, hasWebMercatorT, hasGeodeticSurfaceNormals, exaggeration, exaggerationRelativeHeight) {
  let quantization = TerrainQuantization_default.NONE;
  let toENU;
  let matrix;
  if (defined_default(axisAlignedBoundingBox) && defined_default(minimumHeight) && defined_default(maximumHeight) && defined_default(fromENU)) {
    const minimum = axisAlignedBoundingBox.minimum;
    const maximum = axisAlignedBoundingBox.maximum;
    const dimensions = Cartesian3_default.subtract(
      maximum,
      minimum,
      cartesian3DimScratch
    );
    const hDim = maximumHeight - minimumHeight;
    const maxDim = Math.max(Cartesian3_default.maximumComponent(dimensions), hDim);
    if (maxDim < SHIFT_LEFT_12 - 1) {
      quantization = TerrainQuantization_default.BITS12;
    } else {
      quantization = TerrainQuantization_default.NONE;
    }
    toENU = Matrix4_default.inverseTransformation(fromENU, new Matrix4_default());
    const translation3 = Cartesian3_default.negate(minimum, cartesian3Scratch);
    Matrix4_default.multiply(
      Matrix4_default.fromTranslation(translation3, matrix4Scratch),
      toENU,
      toENU
    );
    const scale = cartesian3Scratch;
    scale.x = 1 / dimensions.x;
    scale.y = 1 / dimensions.y;
    scale.z = 1 / dimensions.z;
    Matrix4_default.multiply(Matrix4_default.fromScale(scale, matrix4Scratch), toENU, toENU);
    matrix = Matrix4_default.clone(fromENU);
    Matrix4_default.setTranslation(matrix, Cartesian3_default.ZERO, matrix);
    fromENU = Matrix4_default.clone(fromENU, new Matrix4_default());
    const translationMatrix = Matrix4_default.fromTranslation(minimum, matrix4Scratch);
    const scaleMatrix2 = Matrix4_default.fromScale(dimensions, matrix4Scratch2);
    const st = Matrix4_default.multiply(translationMatrix, scaleMatrix2, matrix4Scratch);
    Matrix4_default.multiply(fromENU, st, fromENU);
    Matrix4_default.multiply(matrix, st, matrix);
  }
  this.quantization = quantization;
  this.minimumHeight = minimumHeight;
  this.maximumHeight = maximumHeight;
  this.center = Cartesian3_default.clone(center);
  this.toScaledENU = toENU;
  this.fromScaledENU = fromENU;
  this.matrix = matrix;
  this.hasVertexNormals = hasVertexNormals;
  this.hasWebMercatorT = defaultValue_default(hasWebMercatorT, false);
  this.hasGeodeticSurfaceNormals = defaultValue_default(
    hasGeodeticSurfaceNormals,
    false
  );
  this.exaggeration = defaultValue_default(exaggeration, 1);
  this.exaggerationRelativeHeight = defaultValue_default(
    exaggerationRelativeHeight,
    0
  );
  this.stride = 0;
  this._offsetGeodeticSurfaceNormal = 0;
  this._offsetVertexNormal = 0;
  this._calculateStrideAndOffsets();
}
TerrainEncoding.prototype.encode = function(vertexBuffer, bufferIndex, position, uv, height, normalToPack, webMercatorT, geodeticSurfaceNormal) {
  const u3 = uv.x;
  const v7 = uv.y;
  if (this.quantization === TerrainQuantization_default.BITS12) {
    position = Matrix4_default.multiplyByPoint(
      this.toScaledENU,
      position,
      cartesian3Scratch
    );
    position.x = Math_default.clamp(position.x, 0, 1);
    position.y = Math_default.clamp(position.y, 0, 1);
    position.z = Math_default.clamp(position.z, 0, 1);
    const hDim = this.maximumHeight - this.minimumHeight;
    const h = Math_default.clamp((height - this.minimumHeight) / hDim, 0, 1);
    Cartesian2_default.fromElements(position.x, position.y, cartesian2Scratch);
    const compressed0 = AttributeCompression_default.compressTextureCoordinates(
      cartesian2Scratch
    );
    Cartesian2_default.fromElements(position.z, h, cartesian2Scratch);
    const compressed1 = AttributeCompression_default.compressTextureCoordinates(
      cartesian2Scratch
    );
    Cartesian2_default.fromElements(u3, v7, cartesian2Scratch);
    const compressed2 = AttributeCompression_default.compressTextureCoordinates(
      cartesian2Scratch
    );
    vertexBuffer[bufferIndex++] = compressed0;
    vertexBuffer[bufferIndex++] = compressed1;
    vertexBuffer[bufferIndex++] = compressed2;
    if (this.hasWebMercatorT) {
      Cartesian2_default.fromElements(webMercatorT, 0, cartesian2Scratch);
      const compressed3 = AttributeCompression_default.compressTextureCoordinates(
        cartesian2Scratch
      );
      vertexBuffer[bufferIndex++] = compressed3;
    }
  } else {
    Cartesian3_default.subtract(position, this.center, cartesian3Scratch);
    vertexBuffer[bufferIndex++] = cartesian3Scratch.x;
    vertexBuffer[bufferIndex++] = cartesian3Scratch.y;
    vertexBuffer[bufferIndex++] = cartesian3Scratch.z;
    vertexBuffer[bufferIndex++] = height;
    vertexBuffer[bufferIndex++] = u3;
    vertexBuffer[bufferIndex++] = v7;
    if (this.hasWebMercatorT) {
      vertexBuffer[bufferIndex++] = webMercatorT;
    }
  }
  if (this.hasVertexNormals) {
    vertexBuffer[bufferIndex++] = AttributeCompression_default.octPackFloat(
      normalToPack
    );
  }
  if (this.hasGeodeticSurfaceNormals) {
    vertexBuffer[bufferIndex++] = geodeticSurfaceNormal.x;
    vertexBuffer[bufferIndex++] = geodeticSurfaceNormal.y;
    vertexBuffer[bufferIndex++] = geodeticSurfaceNormal.z;
  }
  return bufferIndex;
};
var scratchPosition = new Cartesian3_default();
var scratchGeodeticSurfaceNormal = new Cartesian3_default();
TerrainEncoding.prototype.addGeodeticSurfaceNormals = function(oldBuffer, newBuffer, ellipsoid) {
  if (this.hasGeodeticSurfaceNormals) {
    return;
  }
  const oldStride = this.stride;
  const vertexCount = oldBuffer.length / oldStride;
  this.hasGeodeticSurfaceNormals = true;
  this._calculateStrideAndOffsets();
  const newStride = this.stride;
  for (let index2 = 0; index2 < vertexCount; index2++) {
    for (let offset2 = 0; offset2 < oldStride; offset2++) {
      const oldIndex = index2 * oldStride + offset2;
      const newIndex = index2 * newStride + offset2;
      newBuffer[newIndex] = oldBuffer[oldIndex];
    }
    const position = this.decodePosition(newBuffer, index2, scratchPosition);
    const geodeticSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
      position,
      scratchGeodeticSurfaceNormal
    );
    const bufferIndex = index2 * newStride + this._offsetGeodeticSurfaceNormal;
    newBuffer[bufferIndex] = geodeticSurfaceNormal.x;
    newBuffer[bufferIndex + 1] = geodeticSurfaceNormal.y;
    newBuffer[bufferIndex + 2] = geodeticSurfaceNormal.z;
  }
};
TerrainEncoding.prototype.removeGeodeticSurfaceNormals = function(oldBuffer, newBuffer) {
  if (!this.hasGeodeticSurfaceNormals) {
    return;
  }
  const oldStride = this.stride;
  const vertexCount = oldBuffer.length / oldStride;
  this.hasGeodeticSurfaceNormals = false;
  this._calculateStrideAndOffsets();
  const newStride = this.stride;
  for (let index2 = 0; index2 < vertexCount; index2++) {
    for (let offset2 = 0; offset2 < newStride; offset2++) {
      const oldIndex = index2 * oldStride + offset2;
      const newIndex = index2 * newStride + offset2;
      newBuffer[newIndex] = oldBuffer[oldIndex];
    }
  }
};
TerrainEncoding.prototype.decodePosition = function(buffer, index2, result) {
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  index2 *= this.stride;
  if (this.quantization === TerrainQuantization_default.BITS12) {
    const xy = AttributeCompression_default.decompressTextureCoordinates(
      buffer[index2],
      cartesian2Scratch
    );
    result.x = xy.x;
    result.y = xy.y;
    const zh = AttributeCompression_default.decompressTextureCoordinates(
      buffer[index2 + 1],
      cartesian2Scratch
    );
    result.z = zh.x;
    return Matrix4_default.multiplyByPoint(this.fromScaledENU, result, result);
  }
  result.x = buffer[index2];
  result.y = buffer[index2 + 1];
  result.z = buffer[index2 + 2];
  return Cartesian3_default.add(result, this.center, result);
};
TerrainEncoding.prototype.getExaggeratedPosition = function(buffer, index2, result) {
  result = this.decodePosition(buffer, index2, result);
  const exaggeration = this.exaggeration;
  const exaggerationRelativeHeight = this.exaggerationRelativeHeight;
  const hasExaggeration = exaggeration !== 1;
  if (hasExaggeration && this.hasGeodeticSurfaceNormals) {
    const geodeticSurfaceNormal = this.decodeGeodeticSurfaceNormal(
      buffer,
      index2,
      scratchGeodeticSurfaceNormal
    );
    const rawHeight = this.decodeHeight(buffer, index2);
    const heightDifference = TerrainExaggeration_default.getHeight(
      rawHeight,
      exaggeration,
      exaggerationRelativeHeight
    ) - rawHeight;
    result.x += geodeticSurfaceNormal.x * heightDifference;
    result.y += geodeticSurfaceNormal.y * heightDifference;
    result.z += geodeticSurfaceNormal.z * heightDifference;
  }
  return result;
};
TerrainEncoding.prototype.decodeTextureCoordinates = function(buffer, index2, result) {
  if (!defined_default(result)) {
    result = new Cartesian2_default();
  }
  index2 *= this.stride;
  if (this.quantization === TerrainQuantization_default.BITS12) {
    return AttributeCompression_default.decompressTextureCoordinates(
      buffer[index2 + 2],
      result
    );
  }
  return Cartesian2_default.fromElements(buffer[index2 + 4], buffer[index2 + 5], result);
};
TerrainEncoding.prototype.decodeHeight = function(buffer, index2) {
  index2 *= this.stride;
  if (this.quantization === TerrainQuantization_default.BITS12) {
    const zh = AttributeCompression_default.decompressTextureCoordinates(
      buffer[index2 + 1],
      cartesian2Scratch
    );
    return zh.y * (this.maximumHeight - this.minimumHeight) + this.minimumHeight;
  }
  return buffer[index2 + 3];
};
TerrainEncoding.prototype.decodeWebMercatorT = function(buffer, index2) {
  index2 *= this.stride;
  if (this.quantization === TerrainQuantization_default.BITS12) {
    return AttributeCompression_default.decompressTextureCoordinates(
      buffer[index2 + 3],
      cartesian2Scratch
    ).x;
  }
  return buffer[index2 + 6];
};
TerrainEncoding.prototype.getOctEncodedNormal = function(buffer, index2, result) {
  index2 = index2 * this.stride + this._offsetVertexNormal;
  const temp = buffer[index2] / 256;
  const x = Math.floor(temp);
  const y = (temp - x) * 256;
  return Cartesian2_default.fromElements(x, y, result);
};
TerrainEncoding.prototype.decodeGeodeticSurfaceNormal = function(buffer, index2, result) {
  index2 = index2 * this.stride + this._offsetGeodeticSurfaceNormal;
  result.x = buffer[index2];
  result.y = buffer[index2 + 1];
  result.z = buffer[index2 + 2];
  return result;
};
TerrainEncoding.prototype._calculateStrideAndOffsets = function() {
  let vertexStride = 0;
  switch (this.quantization) {
    case TerrainQuantization_default.BITS12:
      vertexStride += 3;
      break;
    default:
      vertexStride += 6;
  }
  if (this.hasWebMercatorT) {
    vertexStride += 1;
  }
  if (this.hasVertexNormals) {
    this._offsetVertexNormal = vertexStride;
    vertexStride += 1;
  }
  if (this.hasGeodeticSurfaceNormals) {
    this._offsetGeodeticSurfaceNormal = vertexStride;
    vertexStride += 3;
  }
  this.stride = vertexStride;
};
var attributesIndicesNone = {
  position3DAndHeight: 0,
  textureCoordAndEncodedNormals: 1,
  geodeticSurfaceNormal: 2
};
var attributesIndicesBits12 = {
  compressed0: 0,
  compressed1: 1,
  geodeticSurfaceNormal: 2
};
TerrainEncoding.prototype.getAttributes = function(buffer) {
  const datatype = ComponentDatatype_default.FLOAT;
  const sizeInBytes = ComponentDatatype_default.getSizeInBytes(datatype);
  const strideInBytes = this.stride * sizeInBytes;
  let offsetInBytes = 0;
  const attributes = [];
  function addAttribute2(index2, componentsPerAttribute) {
    attributes.push({
      index: index2,
      vertexBuffer: buffer,
      componentDatatype: datatype,
      componentsPerAttribute,
      offsetInBytes,
      strideInBytes
    });
    offsetInBytes += componentsPerAttribute * sizeInBytes;
  }
  if (this.quantization === TerrainQuantization_default.NONE) {
    addAttribute2(attributesIndicesNone.position3DAndHeight, 4);
    let componentsTexCoordAndNormals = 2;
    componentsTexCoordAndNormals += this.hasWebMercatorT ? 1 : 0;
    componentsTexCoordAndNormals += this.hasVertexNormals ? 1 : 0;
    addAttribute2(
      attributesIndicesNone.textureCoordAndEncodedNormals,
      componentsTexCoordAndNormals
    );
    if (this.hasGeodeticSurfaceNormals) {
      addAttribute2(attributesIndicesNone.geodeticSurfaceNormal, 3);
    }
  } else {
    const usingAttribute0Component4 = this.hasWebMercatorT || this.hasVertexNormals;
    const usingAttribute1Component1 = this.hasWebMercatorT && this.hasVertexNormals;
    addAttribute2(
      attributesIndicesBits12.compressed0,
      usingAttribute0Component4 ? 4 : 3
    );
    if (usingAttribute1Component1) {
      addAttribute2(attributesIndicesBits12.compressed1, 1);
    }
    if (this.hasGeodeticSurfaceNormals) {
      addAttribute2(attributesIndicesBits12.geodeticSurfaceNormal, 3);
    }
  }
  return attributes;
};
TerrainEncoding.prototype.getAttributeLocations = function() {
  if (this.quantization === TerrainQuantization_default.NONE) {
    return attributesIndicesNone;
  }
  return attributesIndicesBits12;
};
TerrainEncoding.clone = function(encoding, result) {
  if (!defined_default(encoding)) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new TerrainEncoding();
  }
  result.quantization = encoding.quantization;
  result.minimumHeight = encoding.minimumHeight;
  result.maximumHeight = encoding.maximumHeight;
  result.center = Cartesian3_default.clone(encoding.center);
  result.toScaledENU = Matrix4_default.clone(encoding.toScaledENU);
  result.fromScaledENU = Matrix4_default.clone(encoding.fromScaledENU);
  result.matrix = Matrix4_default.clone(encoding.matrix);
  result.hasVertexNormals = encoding.hasVertexNormals;
  result.hasWebMercatorT = encoding.hasWebMercatorT;
  result.hasGeodeticSurfaceNormals = encoding.hasGeodeticSurfaceNormals;
  result.exaggeration = encoding.exaggeration;
  result.exaggerationRelativeHeight = encoding.exaggerationRelativeHeight;
  result._calculateStrideAndOffsets();
  return result;
};
var TerrainEncoding_default = TerrainEncoding;

// node_modules/cesium/Source/Core/WebMercatorProjection.js
function WebMercatorProjection(ellipsoid) {
  this._ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  this._semimajorAxis = this._ellipsoid.maximumRadius;
  this._oneOverSemimajorAxis = 1 / this._semimajorAxis;
}
Object.defineProperties(WebMercatorProjection.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  }
});
WebMercatorProjection.mercatorAngleToGeodeticLatitude = function(mercatorAngle) {
  return Math_default.PI_OVER_TWO - 2 * Math.atan(Math.exp(-mercatorAngle));
};
WebMercatorProjection.geodeticLatitudeToMercatorAngle = function(latitude) {
  if (latitude > WebMercatorProjection.MaximumLatitude) {
    latitude = WebMercatorProjection.MaximumLatitude;
  } else if (latitude < -WebMercatorProjection.MaximumLatitude) {
    latitude = -WebMercatorProjection.MaximumLatitude;
  }
  const sinLatitude = Math.sin(latitude);
  return 0.5 * Math.log((1 + sinLatitude) / (1 - sinLatitude));
};
WebMercatorProjection.MaximumLatitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(
  Math.PI
);
WebMercatorProjection.prototype.project = function(cartographic2, result) {
  const semimajorAxis = this._semimajorAxis;
  const x = cartographic2.longitude * semimajorAxis;
  const y = WebMercatorProjection.geodeticLatitudeToMercatorAngle(
    cartographic2.latitude
  ) * semimajorAxis;
  const z = cartographic2.height;
  if (!defined_default(result)) {
    return new Cartesian3_default(x, y, z);
  }
  result.x = x;
  result.y = y;
  result.z = z;
  return result;
};
WebMercatorProjection.prototype.unproject = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required");
  }
  const oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
  const longitude = cartesian11.x * oneOverEarthSemimajorAxis;
  const latitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(
    cartesian11.y * oneOverEarthSemimajorAxis
  );
  const height = cartesian11.z;
  if (!defined_default(result)) {
    return new Cartographic_default(longitude, latitude, height);
  }
  result.longitude = longitude;
  result.latitude = latitude;
  result.height = height;
  return result;
};
var WebMercatorProjection_default = WebMercatorProjection;

// node_modules/cesium/Source/Core/HeightmapTessellator.js
var HeightmapTessellator = {};
HeightmapTessellator.DEFAULT_STRUCTURE = Object.freeze({
  heightScale: 1,
  heightOffset: 0,
  elementsPerHeight: 1,
  stride: 1,
  elementMultiplier: 256,
  isBigEndian: false
});
var cartesian3Scratch2 = new Cartesian3_default();
var matrix4Scratch3 = new Matrix4_default();
var minimumScratch = new Cartesian3_default();
var maximumScratch = new Cartesian3_default();
HeightmapTessellator.computeVertices = function(options) {
  if (!defined_default(options) || !defined_default(options.heightmap)) {
    throw new DeveloperError_default("options.heightmap is required.");
  }
  if (!defined_default(options.width) || !defined_default(options.height)) {
    throw new DeveloperError_default("options.width and options.height are required.");
  }
  if (!defined_default(options.nativeRectangle)) {
    throw new DeveloperError_default("options.nativeRectangle is required.");
  }
  if (!defined_default(options.skirtHeight)) {
    throw new DeveloperError_default("options.skirtHeight is required.");
  }
  const cos4 = Math.cos;
  const sin4 = Math.sin;
  const sqrt2 = Math.sqrt;
  const atan = Math.atan;
  const exp = Math.exp;
  const piOverTwo = Math_default.PI_OVER_TWO;
  const toRadians = Math_default.toRadians;
  const heightmap = options.heightmap;
  const width = options.width;
  const height = options.height;
  const skirtHeight = options.skirtHeight;
  const hasSkirts = skirtHeight > 0;
  const isGeographic = defaultValue_default(options.isGeographic, true);
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  const oneOverGlobeSemimajorAxis = 1 / ellipsoid.maximumRadius;
  const nativeRectangle = Rectangle_default.clone(options.nativeRectangle);
  const rectangle = Rectangle_default.clone(options.rectangle);
  let geographicWest;
  let geographicSouth;
  let geographicEast;
  let geographicNorth;
  if (!defined_default(rectangle)) {
    if (isGeographic) {
      geographicWest = toRadians(nativeRectangle.west);
      geographicSouth = toRadians(nativeRectangle.south);
      geographicEast = toRadians(nativeRectangle.east);
      geographicNorth = toRadians(nativeRectangle.north);
    } else {
      geographicWest = nativeRectangle.west * oneOverGlobeSemimajorAxis;
      geographicSouth = piOverTwo - 2 * atan(exp(-nativeRectangle.south * oneOverGlobeSemimajorAxis));
      geographicEast = nativeRectangle.east * oneOverGlobeSemimajorAxis;
      geographicNorth = piOverTwo - 2 * atan(exp(-nativeRectangle.north * oneOverGlobeSemimajorAxis));
    }
  } else {
    geographicWest = rectangle.west;
    geographicSouth = rectangle.south;
    geographicEast = rectangle.east;
    geographicNorth = rectangle.north;
  }
  let relativeToCenter = options.relativeToCenter;
  const hasRelativeToCenter = defined_default(relativeToCenter);
  relativeToCenter = hasRelativeToCenter ? relativeToCenter : Cartesian3_default.ZERO;
  const includeWebMercatorT = defaultValue_default(options.includeWebMercatorT, false);
  const exaggeration = defaultValue_default(options.exaggeration, 1);
  const exaggerationRelativeHeight = defaultValue_default(
    options.exaggerationRelativeHeight,
    0
  );
  const hasExaggeration = exaggeration !== 1;
  const includeGeodeticSurfaceNormals = hasExaggeration;
  const structure = defaultValue_default(
    options.structure,
    HeightmapTessellator.DEFAULT_STRUCTURE
  );
  const heightScale = defaultValue_default(
    structure.heightScale,
    HeightmapTessellator.DEFAULT_STRUCTURE.heightScale
  );
  const heightOffset = defaultValue_default(
    structure.heightOffset,
    HeightmapTessellator.DEFAULT_STRUCTURE.heightOffset
  );
  const elementsPerHeight = defaultValue_default(
    structure.elementsPerHeight,
    HeightmapTessellator.DEFAULT_STRUCTURE.elementsPerHeight
  );
  const stride = defaultValue_default(
    structure.stride,
    HeightmapTessellator.DEFAULT_STRUCTURE.stride
  );
  const elementMultiplier = defaultValue_default(
    structure.elementMultiplier,
    HeightmapTessellator.DEFAULT_STRUCTURE.elementMultiplier
  );
  const isBigEndian = defaultValue_default(
    structure.isBigEndian,
    HeightmapTessellator.DEFAULT_STRUCTURE.isBigEndian
  );
  let rectangleWidth = Rectangle_default.computeWidth(nativeRectangle);
  let rectangleHeight = Rectangle_default.computeHeight(nativeRectangle);
  const granularityX = rectangleWidth / (width - 1);
  const granularityY = rectangleHeight / (height - 1);
  if (!isGeographic) {
    rectangleWidth *= oneOverGlobeSemimajorAxis;
    rectangleHeight *= oneOverGlobeSemimajorAxis;
  }
  const radiiSquared = ellipsoid.radiiSquared;
  const radiiSquaredX = radiiSquared.x;
  const radiiSquaredY = radiiSquared.y;
  const radiiSquaredZ = radiiSquared.z;
  let minimumHeight = 65536;
  let maximumHeight = -65536;
  const fromENU = Transforms_default.eastNorthUpToFixedFrame(
    relativeToCenter,
    ellipsoid
  );
  const toENU = Matrix4_default.inverseTransformation(fromENU, matrix4Scratch3);
  let southMercatorY;
  let oneOverMercatorHeight;
  if (includeWebMercatorT) {
    southMercatorY = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(
      geographicSouth
    );
    oneOverMercatorHeight = 1 / (WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(geographicNorth) - southMercatorY);
  }
  const minimum = minimumScratch;
  minimum.x = Number.POSITIVE_INFINITY;
  minimum.y = Number.POSITIVE_INFINITY;
  minimum.z = Number.POSITIVE_INFINITY;
  const maximum = maximumScratch;
  maximum.x = Number.NEGATIVE_INFINITY;
  maximum.y = Number.NEGATIVE_INFINITY;
  maximum.z = Number.NEGATIVE_INFINITY;
  let hMin = Number.POSITIVE_INFINITY;
  const gridVertexCount = width * height;
  const edgeVertexCount = skirtHeight > 0 ? width * 2 + height * 2 : 0;
  const vertexCount = gridVertexCount + edgeVertexCount;
  const positions = new Array(vertexCount);
  const heights = new Array(vertexCount);
  const uvs = new Array(vertexCount);
  const webMercatorTs = includeWebMercatorT ? new Array(vertexCount) : [];
  const geodeticSurfaceNormals = includeGeodeticSurfaceNormals ? new Array(vertexCount) : [];
  let startRow = 0;
  let endRow = height;
  let startCol = 0;
  let endCol = width;
  if (hasSkirts) {
    --startRow;
    ++endRow;
    --startCol;
    ++endCol;
  }
  const skirtOffsetPercentage = 1e-5;
  for (let rowIndex = startRow; rowIndex < endRow; ++rowIndex) {
    let row = rowIndex;
    if (row < 0) {
      row = 0;
    }
    if (row >= height) {
      row = height - 1;
    }
    let latitude = nativeRectangle.north - granularityY * row;
    if (!isGeographic) {
      latitude = piOverTwo - 2 * atan(exp(-latitude * oneOverGlobeSemimajorAxis));
    } else {
      latitude = toRadians(latitude);
    }
    let v7 = (latitude - geographicSouth) / (geographicNorth - geographicSouth);
    v7 = Math_default.clamp(v7, 0, 1);
    const isNorthEdge = rowIndex === startRow;
    const isSouthEdge = rowIndex === endRow - 1;
    if (skirtHeight > 0) {
      if (isNorthEdge) {
        latitude += skirtOffsetPercentage * rectangleHeight;
      } else if (isSouthEdge) {
        latitude -= skirtOffsetPercentage * rectangleHeight;
      }
    }
    const cosLatitude = cos4(latitude);
    const nZ = sin4(latitude);
    const kZ = radiiSquaredZ * nZ;
    let webMercatorT;
    if (includeWebMercatorT) {
      webMercatorT = (WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(latitude) - southMercatorY) * oneOverMercatorHeight;
    }
    for (let colIndex = startCol; colIndex < endCol; ++colIndex) {
      let col = colIndex;
      if (col < 0) {
        col = 0;
      }
      if (col >= width) {
        col = width - 1;
      }
      const terrainOffset = row * (width * stride) + col * stride;
      let heightSample;
      if (elementsPerHeight === 1) {
        heightSample = heightmap[terrainOffset];
      } else {
        heightSample = 0;
        let elementOffset;
        if (isBigEndian) {
          for (elementOffset = 0; elementOffset < elementsPerHeight; ++elementOffset) {
            heightSample = heightSample * elementMultiplier + heightmap[terrainOffset + elementOffset];
          }
        } else {
          for (elementOffset = elementsPerHeight - 1; elementOffset >= 0; --elementOffset) {
            heightSample = heightSample * elementMultiplier + heightmap[terrainOffset + elementOffset];
          }
        }
      }
      heightSample = heightSample * heightScale + heightOffset;
      maximumHeight = Math.max(maximumHeight, heightSample);
      minimumHeight = Math.min(minimumHeight, heightSample);
      let longitude = nativeRectangle.west + granularityX * col;
      if (!isGeographic) {
        longitude = longitude * oneOverGlobeSemimajorAxis;
      } else {
        longitude = toRadians(longitude);
      }
      let u3 = (longitude - geographicWest) / (geographicEast - geographicWest);
      u3 = Math_default.clamp(u3, 0, 1);
      let index2 = row * width + col;
      if (skirtHeight > 0) {
        const isWestEdge = colIndex === startCol;
        const isEastEdge = colIndex === endCol - 1;
        const isEdge2 = isNorthEdge || isSouthEdge || isWestEdge || isEastEdge;
        const isCorner = (isNorthEdge || isSouthEdge) && (isWestEdge || isEastEdge);
        if (isCorner) {
          continue;
        } else if (isEdge2) {
          heightSample -= skirtHeight;
          if (isWestEdge) {
            index2 = gridVertexCount + (height - row - 1);
            longitude -= skirtOffsetPercentage * rectangleWidth;
          } else if (isSouthEdge) {
            index2 = gridVertexCount + height + (width - col - 1);
          } else if (isEastEdge) {
            index2 = gridVertexCount + height + width + row;
            longitude += skirtOffsetPercentage * rectangleWidth;
          } else if (isNorthEdge) {
            index2 = gridVertexCount + height + width + height + col;
          }
        }
      }
      const nX = cosLatitude * cos4(longitude);
      const nY = cosLatitude * sin4(longitude);
      const kX = radiiSquaredX * nX;
      const kY = radiiSquaredY * nY;
      const gamma = sqrt2(kX * nX + kY * nY + kZ * nZ);
      const oneOverGamma = 1 / gamma;
      const rSurfaceX = kX * oneOverGamma;
      const rSurfaceY = kY * oneOverGamma;
      const rSurfaceZ = kZ * oneOverGamma;
      const position = new Cartesian3_default();
      position.x = rSurfaceX + nX * heightSample;
      position.y = rSurfaceY + nY * heightSample;
      position.z = rSurfaceZ + nZ * heightSample;
      Matrix4_default.multiplyByPoint(toENU, position, cartesian3Scratch2);
      Cartesian3_default.minimumByComponent(cartesian3Scratch2, minimum, minimum);
      Cartesian3_default.maximumByComponent(cartesian3Scratch2, maximum, maximum);
      hMin = Math.min(hMin, heightSample);
      positions[index2] = position;
      uvs[index2] = new Cartesian2_default(u3, v7);
      heights[index2] = heightSample;
      if (includeWebMercatorT) {
        webMercatorTs[index2] = webMercatorT;
      }
      if (includeGeodeticSurfaceNormals) {
        geodeticSurfaceNormals[index2] = ellipsoid.geodeticSurfaceNormal(
          position
        );
      }
    }
  }
  const boundingSphere3D = BoundingSphere_default.fromPoints(positions);
  let orientedBoundingBox;
  if (defined_default(rectangle)) {
    orientedBoundingBox = OrientedBoundingBox_default.fromRectangle(
      rectangle,
      minimumHeight,
      maximumHeight,
      ellipsoid
    );
  }
  let occludeePointInScaledSpace;
  if (hasRelativeToCenter) {
    const occluder = new EllipsoidalOccluder_default(ellipsoid);
    occludeePointInScaledSpace = occluder.computeHorizonCullingPointPossiblyUnderEllipsoid(
      relativeToCenter,
      positions,
      minimumHeight
    );
  }
  const aaBox = new AxisAlignedBoundingBox_default(minimum, maximum, relativeToCenter);
  const encoding = new TerrainEncoding_default(
    relativeToCenter,
    aaBox,
    hMin,
    maximumHeight,
    fromENU,
    false,
    includeWebMercatorT,
    includeGeodeticSurfaceNormals,
    exaggeration,
    exaggerationRelativeHeight
  );
  const vertices = new Float32Array(vertexCount * encoding.stride);
  let bufferIndex = 0;
  for (let j = 0; j < vertexCount; ++j) {
    bufferIndex = encoding.encode(
      vertices,
      bufferIndex,
      positions[j],
      uvs[j],
      heights[j],
      void 0,
      webMercatorTs[j],
      geodeticSurfaceNormals[j]
    );
  }
  return {
    vertices,
    maximumHeight,
    minimumHeight,
    encoding,
    boundingSphere3D,
    orientedBoundingBox,
    occludeePointInScaledSpace
  };
};
var HeightmapTessellator_default = HeightmapTessellator;

// node_modules/cesium/Source/Core/destroyObject.js
function returnTrue() {
  return true;
}
function destroyObject(object2, message) {
  message = defaultValue_default(
    message,
    "This object was destroyed, i.e., destroy() was called."
  );
  function throwOnDestroyed() {
    throw new DeveloperError_default(message);
  }
  for (const key in object2) {
    if (typeof object2[key] === "function") {
      object2[key] = throwOnDestroyed;
    }
  }
  object2.isDestroyed = returnTrue;
  return void 0;
}
var destroyObject_default = destroyObject;

// node_modules/cesium/Source/Core/TaskProcessor.js
function canTransferArrayBuffer() {
  if (!defined_default(TaskProcessor._canTransferArrayBuffer)) {
    const worker = new Worker(
      getWorkerUrl("Workers/transferTypedArrayTest.js")
    );
    worker.postMessage = defaultValue_default(
      worker.webkitPostMessage,
      worker.postMessage
    );
    const value = 99;
    const array = new Int8Array([value]);
    try {
      worker.postMessage(
        {
          array
        },
        [array.buffer]
      );
    } catch (e2) {
      TaskProcessor._canTransferArrayBuffer = false;
      return TaskProcessor._canTransferArrayBuffer;
    }
    const deferred = defer_default();
    worker.onmessage = function(event) {
      const array2 = event.data.array;
      const result = defined_default(array2) && array2[0] === value;
      deferred.resolve(result);
      worker.terminate();
      TaskProcessor._canTransferArrayBuffer = result;
    };
    TaskProcessor._canTransferArrayBuffer = deferred.promise;
  }
  return TaskProcessor._canTransferArrayBuffer;
}
var taskCompletedEvent = new Event_default();
function completeTask(processor, data) {
  --processor._activeTasks;
  const id = data.id;
  if (!defined_default(id)) {
    return;
  }
  const deferreds = processor._deferreds;
  const deferred = deferreds[id];
  if (defined_default(data.error)) {
    let error = data.error;
    if (error.name === "RuntimeError") {
      error = new RuntimeError_default(data.error.message);
      error.stack = data.error.stack;
    } else if (error.name === "DeveloperError") {
      error = new DeveloperError_default(data.error.message);
      error.stack = data.error.stack;
    }
    taskCompletedEvent.raiseEvent(error);
    deferred.reject(error);
  } else {
    taskCompletedEvent.raiseEvent();
    deferred.resolve(data.result);
  }
  delete deferreds[id];
}
function getWorkerUrl(moduleID) {
  let url2 = buildModuleUrl_default(moduleID);
  if (isCrossOriginUrl_default(url2)) {
    const script = `importScripts("${url2}");`;
    let blob;
    try {
      blob = new Blob([script], {
        type: "application/javascript"
      });
    } catch (e2) {
      const BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
      const blobBuilder = new BlobBuilder();
      blobBuilder.append(script);
      blob = blobBuilder.getBlob("application/javascript");
    }
    const URL2 = window.URL || window.webkitURL;
    url2 = URL2.createObjectURL(blob);
  }
  return url2;
}
var bootstrapperUrlResult;
function getBootstrapperUrl() {
  if (!defined_default(bootstrapperUrlResult)) {
    bootstrapperUrlResult = getWorkerUrl("Workers/cesiumWorkerBootstrapper.js");
  }
  return bootstrapperUrlResult;
}
function createWorker(processor) {
  const worker = new Worker(getBootstrapperUrl());
  worker.postMessage = defaultValue_default(
    worker.webkitPostMessage,
    worker.postMessage
  );
  const bootstrapMessage = {
    loaderConfig: {
      paths: {
        Workers: buildModuleUrl_default("Workers")
      },
      baseUrl: buildModuleUrl_default.getCesiumBaseUrl().url
    },
    workerModule: processor._workerPath
  };
  worker.postMessage(bootstrapMessage);
  worker.onmessage = function(event) {
    completeTask(processor, event.data);
  };
  return worker;
}
function getWebAssemblyLoaderConfig(processor, wasmOptions) {
  const config2 = {
    modulePath: void 0,
    wasmBinaryFile: void 0,
    wasmBinary: void 0
  };
  if (!FeatureDetection_default.supportsWebAssembly()) {
    if (!defined_default(wasmOptions.fallbackModulePath)) {
      throw new RuntimeError_default(
        `This browser does not support Web Assembly, and no backup module was provided for ${processor._workerPath}`
      );
    }
    config2.modulePath = buildModuleUrl_default(wasmOptions.fallbackModulePath);
    return Promise.resolve(config2);
  }
  config2.modulePath = buildModuleUrl_default(wasmOptions.modulePath);
  config2.wasmBinaryFile = buildModuleUrl_default(wasmOptions.wasmBinaryFile);
  return Resource_default.fetchArrayBuffer({
    url: config2.wasmBinaryFile
  }).then(function(arrayBuffer) {
    config2.wasmBinary = arrayBuffer;
    return config2;
  });
}
function TaskProcessor(workerPath, maximumActiveTasks) {
  const uri = new URI(workerPath);
  this._workerPath = uri.scheme().length !== 0 && uri.fragment().length === 0 ? workerPath : TaskProcessor._workerModulePrefix + workerPath;
  this._maximumActiveTasks = defaultValue_default(
    maximumActiveTasks,
    Number.POSITIVE_INFINITY
  );
  this._activeTasks = 0;
  this._deferreds = {};
  this._nextID = 0;
}
var emptyTransferableObjectArray = [];
TaskProcessor.prototype.scheduleTask = function(parameters, transferableObjects) {
  if (!defined_default(this._worker)) {
    this._worker = createWorker(this);
  }
  if (this._activeTasks >= this._maximumActiveTasks) {
    return void 0;
  }
  ++this._activeTasks;
  const processor = this;
  return Promise.resolve(canTransferArrayBuffer()).then(function(canTransferArrayBuffer2) {
    if (!defined_default(transferableObjects)) {
      transferableObjects = emptyTransferableObjectArray;
    } else if (!canTransferArrayBuffer2) {
      transferableObjects.length = 0;
    }
    const id = processor._nextID++;
    const deferred = defer_default();
    processor._deferreds[id] = deferred;
    processor._worker.postMessage(
      {
        id,
        parameters,
        canTransferArrayBuffer: canTransferArrayBuffer2
      },
      transferableObjects
    );
    return deferred.promise;
  });
};
TaskProcessor.prototype.initWebAssemblyModule = function(webAssemblyOptions) {
  if (!defined_default(this._worker)) {
    this._worker = createWorker(this);
  }
  const deferred = defer_default();
  const processor = this;
  const worker = this._worker;
  getWebAssemblyLoaderConfig(this, webAssemblyOptions).then(function(wasmConfig) {
    return Promise.resolve(canTransferArrayBuffer()).then(function(canTransferArrayBuffer2) {
      let transferableObjects;
      const binary = wasmConfig.wasmBinary;
      if (defined_default(binary) && canTransferArrayBuffer2) {
        transferableObjects = [binary];
      }
      worker.onmessage = function(event) {
        worker.onmessage = function(event2) {
          completeTask(processor, event2.data);
        };
        deferred.resolve(event.data);
      };
      worker.postMessage(
        { webAssemblyConfig: wasmConfig },
        transferableObjects
      );
    });
  });
  return deferred.promise;
};
TaskProcessor.prototype.isDestroyed = function() {
  return false;
};
TaskProcessor.prototype.destroy = function() {
  if (defined_default(this._worker)) {
    this._worker.terminate();
  }
  return destroyObject_default(this);
};
TaskProcessor.taskCompletedEvent = taskCompletedEvent;
TaskProcessor._defaultWorkerModulePrefix = "Workers/";
TaskProcessor._workerModulePrefix = TaskProcessor._defaultWorkerModulePrefix;
TaskProcessor._canTransferArrayBuffer = void 0;
var TaskProcessor_default = TaskProcessor;

// node_modules/cesium/Source/Core/TerrainData.js
function TerrainData() {
  DeveloperError_default.throwInstantiationError();
}
Object.defineProperties(TerrainData.prototype, {
  credits: {
    get: DeveloperError_default.throwInstantiationError
  },
  waterMask: {
    get: DeveloperError_default.throwInstantiationError
  }
});
TerrainData.prototype.interpolateHeight = DeveloperError_default.throwInstantiationError;
TerrainData.prototype.isChildAvailable = DeveloperError_default.throwInstantiationError;
TerrainData.prototype.createMesh = DeveloperError_default.throwInstantiationError;
TerrainData.prototype.upsample = DeveloperError_default.throwInstantiationError;
TerrainData.prototype.wasCreatedByUpsampling = DeveloperError_default.throwInstantiationError;
TerrainData.maximumAsynchronousTasks = 5;
var TerrainData_default = TerrainData;

// node_modules/cesium/Source/Core/TerrainMesh.js
function TerrainMesh(center, vertices, indices2, indexCountWithoutSkirts, vertexCountWithoutSkirts, minimumHeight, maximumHeight, boundingSphere3D, occludeePointInScaledSpace, vertexStride, orientedBoundingBox, encoding, westIndicesSouthToNorth, southIndicesEastToWest, eastIndicesNorthToSouth, northIndicesWestToEast) {
  this.center = center;
  this.vertices = vertices;
  this.stride = defaultValue_default(vertexStride, 6);
  this.indices = indices2;
  this.indexCountWithoutSkirts = indexCountWithoutSkirts;
  this.vertexCountWithoutSkirts = vertexCountWithoutSkirts;
  this.minimumHeight = minimumHeight;
  this.maximumHeight = maximumHeight;
  this.boundingSphere3D = boundingSphere3D;
  this.occludeePointInScaledSpace = occludeePointInScaledSpace;
  this.orientedBoundingBox = orientedBoundingBox;
  this.encoding = encoding;
  this.westIndicesSouthToNorth = westIndicesSouthToNorth;
  this.southIndicesEastToWest = southIndicesEastToWest;
  this.eastIndicesNorthToSouth = eastIndicesNorthToSouth;
  this.northIndicesWestToEast = northIndicesWestToEast;
}
var TerrainMesh_default = TerrainMesh;

// node_modules/cesium/Source/Core/IndexDatatype.js
var IndexDatatype = {
  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT
};
IndexDatatype.getSizeInBytes = function(indexDatatype) {
  switch (indexDatatype) {
    case IndexDatatype.UNSIGNED_BYTE:
      return Uint8Array.BYTES_PER_ELEMENT;
    case IndexDatatype.UNSIGNED_SHORT:
      return Uint16Array.BYTES_PER_ELEMENT;
    case IndexDatatype.UNSIGNED_INT:
      return Uint32Array.BYTES_PER_ELEMENT;
  }
  throw new DeveloperError_default(
    "indexDatatype is required and must be a valid IndexDatatype constant."
  );
};
IndexDatatype.fromSizeInBytes = function(sizeInBytes) {
  switch (sizeInBytes) {
    case 2:
      return IndexDatatype.UNSIGNED_SHORT;
    case 4:
      return IndexDatatype.UNSIGNED_INT;
    case 1:
      return IndexDatatype.UNSIGNED_BYTE;
    default:
      throw new DeveloperError_default(
        "Size in bytes cannot be mapped to an IndexDatatype"
      );
  }
};
IndexDatatype.validate = function(indexDatatype) {
  return defined_default(indexDatatype) && (indexDatatype === IndexDatatype.UNSIGNED_BYTE || indexDatatype === IndexDatatype.UNSIGNED_SHORT || indexDatatype === IndexDatatype.UNSIGNED_INT);
};
IndexDatatype.createTypedArray = function(numberOfVertices, indicesLengthOrArray) {
  if (!defined_default(numberOfVertices)) {
    throw new DeveloperError_default("numberOfVertices is required.");
  }
  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
    return new Uint32Array(indicesLengthOrArray);
  }
  return new Uint16Array(indicesLengthOrArray);
};
IndexDatatype.createTypedArrayFromArrayBuffer = function(numberOfVertices, sourceArray, byteOffset, length3) {
  if (!defined_default(numberOfVertices)) {
    throw new DeveloperError_default("numberOfVertices is required.");
  }
  if (!defined_default(sourceArray)) {
    throw new DeveloperError_default("sourceArray is required.");
  }
  if (!defined_default(byteOffset)) {
    throw new DeveloperError_default("byteOffset is required.");
  }
  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
    return new Uint32Array(sourceArray, byteOffset, length3);
  }
  return new Uint16Array(sourceArray, byteOffset, length3);
};
var IndexDatatype_default = Object.freeze(IndexDatatype);

// node_modules/cesium/Source/Core/TerrainProvider.js
function TerrainProvider() {
  DeveloperError_default.throwInstantiationError();
}
Object.defineProperties(TerrainProvider.prototype, {
  errorEvent: {
    get: DeveloperError_default.throwInstantiationError
  },
  credit: {
    get: DeveloperError_default.throwInstantiationError
  },
  tilingScheme: {
    get: DeveloperError_default.throwInstantiationError
  },
  ready: {
    get: DeveloperError_default.throwInstantiationError
  },
  readyPromise: {
    get: DeveloperError_default.throwInstantiationError
  },
  hasWaterMask: {
    get: DeveloperError_default.throwInstantiationError
  },
  hasVertexNormals: {
    get: DeveloperError_default.throwInstantiationError
  },
  availability: {
    get: DeveloperError_default.throwInstantiationError
  }
});
var regularGridIndicesCache = [];
TerrainProvider.getRegularGridIndices = function(width, height) {
  if (width * height >= Math_default.FOUR_GIGABYTES) {
    throw new DeveloperError_default(
      "The total number of vertices (width * height) must be less than 4,294,967,296."
    );
  }
  let byWidth = regularGridIndicesCache[width];
  if (!defined_default(byWidth)) {
    regularGridIndicesCache[width] = byWidth = [];
  }
  let indices2 = byWidth[height];
  if (!defined_default(indices2)) {
    if (width * height < Math_default.SIXTY_FOUR_KILOBYTES) {
      indices2 = byWidth[height] = new Uint16Array(
        (width - 1) * (height - 1) * 6
      );
    } else {
      indices2 = byWidth[height] = new Uint32Array(
        (width - 1) * (height - 1) * 6
      );
    }
    addRegularGridIndices(width, height, indices2, 0);
  }
  return indices2;
};
var regularGridAndEdgeIndicesCache = [];
TerrainProvider.getRegularGridIndicesAndEdgeIndices = function(width, height) {
  if (width * height >= Math_default.FOUR_GIGABYTES) {
    throw new DeveloperError_default(
      "The total number of vertices (width * height) must be less than 4,294,967,296."
    );
  }
  let byWidth = regularGridAndEdgeIndicesCache[width];
  if (!defined_default(byWidth)) {
    regularGridAndEdgeIndicesCache[width] = byWidth = [];
  }
  let indicesAndEdges = byWidth[height];
  if (!defined_default(indicesAndEdges)) {
    const indices2 = TerrainProvider.getRegularGridIndices(width, height);
    const edgeIndices = getEdgeIndices(width, height);
    const westIndicesSouthToNorth = edgeIndices.westIndicesSouthToNorth;
    const southIndicesEastToWest = edgeIndices.southIndicesEastToWest;
    const eastIndicesNorthToSouth = edgeIndices.eastIndicesNorthToSouth;
    const northIndicesWestToEast = edgeIndices.northIndicesWestToEast;
    indicesAndEdges = byWidth[height] = {
      indices: indices2,
      westIndicesSouthToNorth,
      southIndicesEastToWest,
      eastIndicesNorthToSouth,
      northIndicesWestToEast
    };
  }
  return indicesAndEdges;
};
var regularGridAndSkirtAndEdgeIndicesCache = [];
TerrainProvider.getRegularGridAndSkirtIndicesAndEdgeIndices = function(width, height) {
  if (width * height >= Math_default.FOUR_GIGABYTES) {
    throw new DeveloperError_default(
      "The total number of vertices (width * height) must be less than 4,294,967,296."
    );
  }
  let byWidth = regularGridAndSkirtAndEdgeIndicesCache[width];
  if (!defined_default(byWidth)) {
    regularGridAndSkirtAndEdgeIndicesCache[width] = byWidth = [];
  }
  let indicesAndEdges = byWidth[height];
  if (!defined_default(indicesAndEdges)) {
    const gridVertexCount = width * height;
    const gridIndexCount = (width - 1) * (height - 1) * 6;
    const edgeVertexCount = width * 2 + height * 2;
    const edgeIndexCount = Math.max(0, edgeVertexCount - 4) * 6;
    const vertexCount = gridVertexCount + edgeVertexCount;
    const indexCount = gridIndexCount + edgeIndexCount;
    const edgeIndices = getEdgeIndices(width, height);
    const westIndicesSouthToNorth = edgeIndices.westIndicesSouthToNorth;
    const southIndicesEastToWest = edgeIndices.southIndicesEastToWest;
    const eastIndicesNorthToSouth = edgeIndices.eastIndicesNorthToSouth;
    const northIndicesWestToEast = edgeIndices.northIndicesWestToEast;
    const indices2 = IndexDatatype_default.createTypedArray(vertexCount, indexCount);
    addRegularGridIndices(width, height, indices2, 0);
    TerrainProvider.addSkirtIndices(
      westIndicesSouthToNorth,
      southIndicesEastToWest,
      eastIndicesNorthToSouth,
      northIndicesWestToEast,
      gridVertexCount,
      indices2,
      gridIndexCount
    );
    indicesAndEdges = byWidth[height] = {
      indices: indices2,
      westIndicesSouthToNorth,
      southIndicesEastToWest,
      eastIndicesNorthToSouth,
      northIndicesWestToEast,
      indexCountWithoutSkirts: gridIndexCount
    };
  }
  return indicesAndEdges;
};
TerrainProvider.addSkirtIndices = function(westIndicesSouthToNorth, southIndicesEastToWest, eastIndicesNorthToSouth, northIndicesWestToEast, vertexCount, indices2, offset2) {
  let vertexIndex = vertexCount;
  offset2 = addSkirtIndices(
    westIndicesSouthToNorth,
    vertexIndex,
    indices2,
    offset2
  );
  vertexIndex += westIndicesSouthToNorth.length;
  offset2 = addSkirtIndices(
    southIndicesEastToWest,
    vertexIndex,
    indices2,
    offset2
  );
  vertexIndex += southIndicesEastToWest.length;
  offset2 = addSkirtIndices(
    eastIndicesNorthToSouth,
    vertexIndex,
    indices2,
    offset2
  );
  vertexIndex += eastIndicesNorthToSouth.length;
  addSkirtIndices(northIndicesWestToEast, vertexIndex, indices2, offset2);
};
function getEdgeIndices(width, height) {
  const westIndicesSouthToNorth = new Array(height);
  const southIndicesEastToWest = new Array(width);
  const eastIndicesNorthToSouth = new Array(height);
  const northIndicesWestToEast = new Array(width);
  let i2;
  for (i2 = 0; i2 < width; ++i2) {
    northIndicesWestToEast[i2] = i2;
    southIndicesEastToWest[i2] = width * height - 1 - i2;
  }
  for (i2 = 0; i2 < height; ++i2) {
    eastIndicesNorthToSouth[i2] = (i2 + 1) * width - 1;
    westIndicesSouthToNorth[i2] = (height - i2 - 1) * width;
  }
  return {
    westIndicesSouthToNorth,
    southIndicesEastToWest,
    eastIndicesNorthToSouth,
    northIndicesWestToEast
  };
}
function addRegularGridIndices(width, height, indices2, offset2) {
  let index2 = 0;
  for (let j = 0; j < height - 1; ++j) {
    for (let i2 = 0; i2 < width - 1; ++i2) {
      const upperLeft = index2;
      const lowerLeft = upperLeft + width;
      const lowerRight = lowerLeft + 1;
      const upperRight = upperLeft + 1;
      indices2[offset2++] = upperLeft;
      indices2[offset2++] = lowerLeft;
      indices2[offset2++] = upperRight;
      indices2[offset2++] = upperRight;
      indices2[offset2++] = lowerLeft;
      indices2[offset2++] = lowerRight;
      ++index2;
    }
    ++index2;
  }
}
function addSkirtIndices(edgeIndices, vertexIndex, indices2, offset2) {
  let previousIndex = edgeIndices[0];
  const length3 = edgeIndices.length;
  for (let i2 = 1; i2 < length3; ++i2) {
    const index2 = edgeIndices[i2];
    indices2[offset2++] = previousIndex;
    indices2[offset2++] = index2;
    indices2[offset2++] = vertexIndex;
    indices2[offset2++] = vertexIndex;
    indices2[offset2++] = index2;
    indices2[offset2++] = vertexIndex + 1;
    previousIndex = index2;
    ++vertexIndex;
  }
  return offset2;
}
TerrainProvider.heightmapTerrainQuality = 0.25;
TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap = function(ellipsoid, tileImageWidth, numberOfTilesAtLevelZero) {
  return ellipsoid.maximumRadius * 2 * Math.PI * TerrainProvider.heightmapTerrainQuality / (tileImageWidth * numberOfTilesAtLevelZero);
};
TerrainProvider.prototype.requestTileGeometry = DeveloperError_default.throwInstantiationError;
TerrainProvider.prototype.getLevelMaximumGeometricError = DeveloperError_default.throwInstantiationError;
TerrainProvider.prototype.getTileDataAvailable = DeveloperError_default.throwInstantiationError;
TerrainProvider.prototype.loadTileDataAvailability = DeveloperError_default.throwInstantiationError;
var TerrainProvider_default = TerrainProvider;

// node_modules/cesium/Source/Core/HeightmapTerrainData.js
function HeightmapTerrainData(options) {
  if (!defined_default(options) || !defined_default(options.buffer)) {
    throw new DeveloperError_default("options.buffer is required.");
  }
  if (!defined_default(options.width)) {
    throw new DeveloperError_default("options.width is required.");
  }
  if (!defined_default(options.height)) {
    throw new DeveloperError_default("options.height is required.");
  }
  this._buffer = options.buffer;
  this._width = options.width;
  this._height = options.height;
  this._childTileMask = defaultValue_default(options.childTileMask, 15);
  this._encoding = defaultValue_default(options.encoding, HeightmapEncoding_default.NONE);
  const defaultStructure = HeightmapTessellator_default.DEFAULT_STRUCTURE;
  let structure = options.structure;
  if (!defined_default(structure)) {
    structure = defaultStructure;
  } else if (structure !== defaultStructure) {
    structure.heightScale = defaultValue_default(
      structure.heightScale,
      defaultStructure.heightScale
    );
    structure.heightOffset = defaultValue_default(
      structure.heightOffset,
      defaultStructure.heightOffset
    );
    structure.elementsPerHeight = defaultValue_default(
      structure.elementsPerHeight,
      defaultStructure.elementsPerHeight
    );
    structure.stride = defaultValue_default(structure.stride, defaultStructure.stride);
    structure.elementMultiplier = defaultValue_default(
      structure.elementMultiplier,
      defaultStructure.elementMultiplier
    );
    structure.isBigEndian = defaultValue_default(
      structure.isBigEndian,
      defaultStructure.isBigEndian
    );
  }
  this._structure = structure;
  this._createdByUpsampling = defaultValue_default(options.createdByUpsampling, false);
  this._waterMask = options.waterMask;
  this._skirtHeight = void 0;
  this._bufferType = this._encoding === HeightmapEncoding_default.LERC ? Float32Array : this._buffer.constructor;
  this._mesh = void 0;
}
Object.defineProperties(HeightmapTerrainData.prototype, {
  credits: {
    get: function() {
      return void 0;
    }
  },
  waterMask: {
    get: function() {
      return this._waterMask;
    }
  },
  childTileMask: {
    get: function() {
      return this._childTileMask;
    }
  }
});
var createMeshTaskName = "createVerticesFromHeightmap";
var createMeshTaskProcessorNoThrottle = new TaskProcessor_default(createMeshTaskName);
var createMeshTaskProcessorThrottle = new TaskProcessor_default(
  createMeshTaskName,
  TerrainData_default.maximumAsynchronousTasks
);
HeightmapTerrainData.prototype.createMesh = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.tilingScheme", options.tilingScheme);
  Check_default.typeOf.number("options.x", options.x);
  Check_default.typeOf.number("options.y", options.y);
  Check_default.typeOf.number("options.level", options.level);
  const tilingScheme2 = options.tilingScheme;
  const x = options.x;
  const y = options.y;
  const level = options.level;
  const exaggeration = defaultValue_default(options.exaggeration, 1);
  const exaggerationRelativeHeight = defaultValue_default(
    options.exaggerationRelativeHeight,
    0
  );
  const throttle = defaultValue_default(options.throttle, true);
  const ellipsoid = tilingScheme2.ellipsoid;
  const nativeRectangle = tilingScheme2.tileXYToNativeRectangle(x, y, level);
  const rectangle = tilingScheme2.tileXYToRectangle(x, y, level);
  const center = ellipsoid.cartographicToCartesian(Rectangle_default.center(rectangle));
  const structure = this._structure;
  const levelZeroMaxError = TerrainProvider_default.getEstimatedLevelZeroGeometricErrorForAHeightmap(
    ellipsoid,
    this._width,
    tilingScheme2.getNumberOfXTilesAtLevel(0)
  );
  const thisLevelMaxError = levelZeroMaxError / (1 << level);
  this._skirtHeight = Math.min(thisLevelMaxError * 4, 1e3);
  const createMeshTaskProcessor = throttle ? createMeshTaskProcessorThrottle : createMeshTaskProcessorNoThrottle;
  const verticesPromise = createMeshTaskProcessor.scheduleTask({
    heightmap: this._buffer,
    structure,
    includeWebMercatorT: true,
    width: this._width,
    height: this._height,
    nativeRectangle,
    rectangle,
    relativeToCenter: center,
    ellipsoid,
    skirtHeight: this._skirtHeight,
    isGeographic: tilingScheme2.projection instanceof GeographicProjection_default,
    exaggeration,
    exaggerationRelativeHeight,
    encoding: this._encoding
  });
  if (!defined_default(verticesPromise)) {
    return void 0;
  }
  const that = this;
  return Promise.resolve(verticesPromise).then(function(result) {
    let indicesAndEdges;
    if (that._skirtHeight > 0) {
      indicesAndEdges = TerrainProvider_default.getRegularGridAndSkirtIndicesAndEdgeIndices(
        result.gridWidth,
        result.gridHeight
      );
    } else {
      indicesAndEdges = TerrainProvider_default.getRegularGridIndicesAndEdgeIndices(
        result.gridWidth,
        result.gridHeight
      );
    }
    const vertexCountWithoutSkirts = result.gridWidth * result.gridHeight;
    that._mesh = new TerrainMesh_default(
      center,
      new Float32Array(result.vertices),
      indicesAndEdges.indices,
      indicesAndEdges.indexCountWithoutSkirts,
      vertexCountWithoutSkirts,
      result.minimumHeight,
      result.maximumHeight,
      BoundingSphere_default.clone(result.boundingSphere3D),
      Cartesian3_default.clone(result.occludeePointInScaledSpace),
      result.numberOfAttributes,
      OrientedBoundingBox_default.clone(result.orientedBoundingBox),
      TerrainEncoding_default.clone(result.encoding),
      indicesAndEdges.westIndicesSouthToNorth,
      indicesAndEdges.southIndicesEastToWest,
      indicesAndEdges.eastIndicesNorthToSouth,
      indicesAndEdges.northIndicesWestToEast
    );
    that._buffer = void 0;
    return that._mesh;
  });
};
HeightmapTerrainData.prototype._createMeshSync = function(options) {
  Check_default.typeOf.object("options.tilingScheme", options.tilingScheme);
  Check_default.typeOf.number("options.x", options.x);
  Check_default.typeOf.number("options.y", options.y);
  Check_default.typeOf.number("options.level", options.level);
  const tilingScheme2 = options.tilingScheme;
  const x = options.x;
  const y = options.y;
  const level = options.level;
  const exaggeration = defaultValue_default(options.exaggeration, 1);
  const exaggerationRelativeHeight = defaultValue_default(
    options.exaggerationRelativeHeight,
    0
  );
  const ellipsoid = tilingScheme2.ellipsoid;
  const nativeRectangle = tilingScheme2.tileXYToNativeRectangle(x, y, level);
  const rectangle = tilingScheme2.tileXYToRectangle(x, y, level);
  const center = ellipsoid.cartographicToCartesian(Rectangle_default.center(rectangle));
  const structure = this._structure;
  const levelZeroMaxError = TerrainProvider_default.getEstimatedLevelZeroGeometricErrorForAHeightmap(
    ellipsoid,
    this._width,
    tilingScheme2.getNumberOfXTilesAtLevel(0)
  );
  const thisLevelMaxError = levelZeroMaxError / (1 << level);
  this._skirtHeight = Math.min(thisLevelMaxError * 4, 1e3);
  const result = HeightmapTessellator_default.computeVertices({
    heightmap: this._buffer,
    structure,
    includeWebMercatorT: true,
    width: this._width,
    height: this._height,
    nativeRectangle,
    rectangle,
    relativeToCenter: center,
    ellipsoid,
    skirtHeight: this._skirtHeight,
    isGeographic: tilingScheme2.projection instanceof GeographicProjection_default,
    exaggeration,
    exaggerationRelativeHeight
  });
  this._buffer = void 0;
  let indicesAndEdges;
  if (this._skirtHeight > 0) {
    indicesAndEdges = TerrainProvider_default.getRegularGridAndSkirtIndicesAndEdgeIndices(
      this._width,
      this._height
    );
  } else {
    indicesAndEdges = TerrainProvider_default.getRegularGridIndicesAndEdgeIndices(
      this._width,
      this._height
    );
  }
  const vertexCountWithoutSkirts = result.gridWidth * result.gridHeight;
  this._mesh = new TerrainMesh_default(
    center,
    result.vertices,
    indicesAndEdges.indices,
    indicesAndEdges.indexCountWithoutSkirts,
    vertexCountWithoutSkirts,
    result.minimumHeight,
    result.maximumHeight,
    result.boundingSphere3D,
    result.occludeePointInScaledSpace,
    result.encoding.stride,
    result.orientedBoundingBox,
    result.encoding,
    indicesAndEdges.westIndicesSouthToNorth,
    indicesAndEdges.southIndicesEastToWest,
    indicesAndEdges.eastIndicesNorthToSouth,
    indicesAndEdges.northIndicesWestToEast
  );
  return this._mesh;
};
HeightmapTerrainData.prototype.interpolateHeight = function(rectangle, longitude, latitude) {
  const width = this._width;
  const height = this._height;
  const structure = this._structure;
  const stride = structure.stride;
  const elementsPerHeight = structure.elementsPerHeight;
  const elementMultiplier = structure.elementMultiplier;
  const isBigEndian = structure.isBigEndian;
  const heightOffset = structure.heightOffset;
  const heightScale = structure.heightScale;
  const isMeshCreated = defined_default(this._mesh);
  const isLERCEncoding = this._encoding === HeightmapEncoding_default.LERC;
  const isInterpolationImpossible = !isMeshCreated && isLERCEncoding;
  if (isInterpolationImpossible) {
    return void 0;
  }
  let heightSample;
  if (isMeshCreated) {
    const buffer = this._mesh.vertices;
    const encoding = this._mesh.encoding;
    heightSample = interpolateMeshHeight(
      buffer,
      encoding,
      heightOffset,
      heightScale,
      rectangle,
      width,
      height,
      longitude,
      latitude
    );
  } else {
    heightSample = interpolateHeight(
      this._buffer,
      elementsPerHeight,
      elementMultiplier,
      stride,
      isBigEndian,
      rectangle,
      width,
      height,
      longitude,
      latitude
    );
    heightSample = heightSample * heightScale + heightOffset;
  }
  return heightSample;
};
HeightmapTerrainData.prototype.upsample = function(tilingScheme2, thisX, thisY, thisLevel, descendantX, descendantY, descendantLevel) {
  if (!defined_default(tilingScheme2)) {
    throw new DeveloperError_default("tilingScheme is required.");
  }
  if (!defined_default(thisX)) {
    throw new DeveloperError_default("thisX is required.");
  }
  if (!defined_default(thisY)) {
    throw new DeveloperError_default("thisY is required.");
  }
  if (!defined_default(thisLevel)) {
    throw new DeveloperError_default("thisLevel is required.");
  }
  if (!defined_default(descendantX)) {
    throw new DeveloperError_default("descendantX is required.");
  }
  if (!defined_default(descendantY)) {
    throw new DeveloperError_default("descendantY is required.");
  }
  if (!defined_default(descendantLevel)) {
    throw new DeveloperError_default("descendantLevel is required.");
  }
  const levelDifference = descendantLevel - thisLevel;
  if (levelDifference > 1) {
    throw new DeveloperError_default(
      "Upsampling through more than one level at a time is not currently supported."
    );
  }
  const meshData = this._mesh;
  if (!defined_default(meshData)) {
    return void 0;
  }
  const width = this._width;
  const height = this._height;
  const structure = this._structure;
  const stride = structure.stride;
  const heights = new this._bufferType(width * height * stride);
  const buffer = meshData.vertices;
  const encoding = meshData.encoding;
  const sourceRectangle = tilingScheme2.tileXYToRectangle(
    thisX,
    thisY,
    thisLevel
  );
  const destinationRectangle = tilingScheme2.tileXYToRectangle(
    descendantX,
    descendantY,
    descendantLevel
  );
  const heightOffset = structure.heightOffset;
  const heightScale = structure.heightScale;
  const elementsPerHeight = structure.elementsPerHeight;
  const elementMultiplier = structure.elementMultiplier;
  const isBigEndian = structure.isBigEndian;
  const divisor = Math.pow(elementMultiplier, elementsPerHeight - 1);
  for (let j = 0; j < height; ++j) {
    const latitude = Math_default.lerp(
      destinationRectangle.north,
      destinationRectangle.south,
      j / (height - 1)
    );
    for (let i2 = 0; i2 < width; ++i2) {
      const longitude = Math_default.lerp(
        destinationRectangle.west,
        destinationRectangle.east,
        i2 / (width - 1)
      );
      let heightSample = interpolateMeshHeight(
        buffer,
        encoding,
        heightOffset,
        heightScale,
        sourceRectangle,
        width,
        height,
        longitude,
        latitude
      );
      heightSample = heightSample < structure.lowestEncodedHeight ? structure.lowestEncodedHeight : heightSample;
      heightSample = heightSample > structure.highestEncodedHeight ? structure.highestEncodedHeight : heightSample;
      setHeight(
        heights,
        elementsPerHeight,
        elementMultiplier,
        divisor,
        stride,
        isBigEndian,
        j * width + i2,
        heightSample
      );
    }
  }
  return Promise.resolve(
    new HeightmapTerrainData({
      buffer: heights,
      width,
      height,
      childTileMask: 0,
      structure: this._structure,
      createdByUpsampling: true
    })
  );
};
HeightmapTerrainData.prototype.isChildAvailable = function(thisX, thisY, childX, childY) {
  if (!defined_default(thisX)) {
    throw new DeveloperError_default("thisX is required.");
  }
  if (!defined_default(thisY)) {
    throw new DeveloperError_default("thisY is required.");
  }
  if (!defined_default(childX)) {
    throw new DeveloperError_default("childX is required.");
  }
  if (!defined_default(childY)) {
    throw new DeveloperError_default("childY is required.");
  }
  let bitNumber = 2;
  if (childX !== thisX * 2) {
    ++bitNumber;
  }
  if (childY !== thisY * 2) {
    bitNumber -= 2;
  }
  return (this._childTileMask & 1 << bitNumber) !== 0;
};
HeightmapTerrainData.prototype.wasCreatedByUpsampling = function() {
  return this._createdByUpsampling;
};
function interpolateHeight(sourceHeights, elementsPerHeight, elementMultiplier, stride, isBigEndian, sourceRectangle, width, height, longitude, latitude) {
  const fromWest = (longitude - sourceRectangle.west) * (width - 1) / (sourceRectangle.east - sourceRectangle.west);
  const fromSouth = (latitude - sourceRectangle.south) * (height - 1) / (sourceRectangle.north - sourceRectangle.south);
  let westInteger = fromWest | 0;
  let eastInteger = westInteger + 1;
  if (eastInteger >= width) {
    eastInteger = width - 1;
    westInteger = width - 2;
  }
  let southInteger = fromSouth | 0;
  let northInteger = southInteger + 1;
  if (northInteger >= height) {
    northInteger = height - 1;
    southInteger = height - 2;
  }
  const dx = fromWest - westInteger;
  const dy = fromSouth - southInteger;
  southInteger = height - 1 - southInteger;
  northInteger = height - 1 - northInteger;
  const southwestHeight = getHeight(
    sourceHeights,
    elementsPerHeight,
    elementMultiplier,
    stride,
    isBigEndian,
    southInteger * width + westInteger
  );
  const southeastHeight = getHeight(
    sourceHeights,
    elementsPerHeight,
    elementMultiplier,
    stride,
    isBigEndian,
    southInteger * width + eastInteger
  );
  const northwestHeight = getHeight(
    sourceHeights,
    elementsPerHeight,
    elementMultiplier,
    stride,
    isBigEndian,
    northInteger * width + westInteger
  );
  const northeastHeight = getHeight(
    sourceHeights,
    elementsPerHeight,
    elementMultiplier,
    stride,
    isBigEndian,
    northInteger * width + eastInteger
  );
  return triangleInterpolateHeight(
    dx,
    dy,
    southwestHeight,
    southeastHeight,
    northwestHeight,
    northeastHeight
  );
}
function interpolateMeshHeight(buffer, encoding, heightOffset, heightScale, sourceRectangle, width, height, longitude, latitude) {
  const fromWest = (longitude - sourceRectangle.west) * (width - 1) / (sourceRectangle.east - sourceRectangle.west);
  const fromSouth = (latitude - sourceRectangle.south) * (height - 1) / (sourceRectangle.north - sourceRectangle.south);
  let westInteger = fromWest | 0;
  let eastInteger = westInteger + 1;
  if (eastInteger >= width) {
    eastInteger = width - 1;
    westInteger = width - 2;
  }
  let southInteger = fromSouth | 0;
  let northInteger = southInteger + 1;
  if (northInteger >= height) {
    northInteger = height - 1;
    southInteger = height - 2;
  }
  const dx = fromWest - westInteger;
  const dy = fromSouth - southInteger;
  southInteger = height - 1 - southInteger;
  northInteger = height - 1 - northInteger;
  const southwestHeight = (encoding.decodeHeight(buffer, southInteger * width + westInteger) - heightOffset) / heightScale;
  const southeastHeight = (encoding.decodeHeight(buffer, southInteger * width + eastInteger) - heightOffset) / heightScale;
  const northwestHeight = (encoding.decodeHeight(buffer, northInteger * width + westInteger) - heightOffset) / heightScale;
  const northeastHeight = (encoding.decodeHeight(buffer, northInteger * width + eastInteger) - heightOffset) / heightScale;
  return triangleInterpolateHeight(
    dx,
    dy,
    southwestHeight,
    southeastHeight,
    northwestHeight,
    northeastHeight
  );
}
function triangleInterpolateHeight(dX, dY, southwestHeight, southeastHeight, northwestHeight, northeastHeight) {
  if (dY < dX) {
    return southwestHeight + dX * (southeastHeight - southwestHeight) + dY * (northeastHeight - southeastHeight);
  }
  return southwestHeight + dX * (northeastHeight - northwestHeight) + dY * (northwestHeight - southwestHeight);
}
function getHeight(heights, elementsPerHeight, elementMultiplier, stride, isBigEndian, index2) {
  index2 *= stride;
  let height = 0;
  let i2;
  if (isBigEndian) {
    for (i2 = 0; i2 < elementsPerHeight; ++i2) {
      height = height * elementMultiplier + heights[index2 + i2];
    }
  } else {
    for (i2 = elementsPerHeight - 1; i2 >= 0; --i2) {
      height = height * elementMultiplier + heights[index2 + i2];
    }
  }
  return height;
}
function setHeight(heights, elementsPerHeight, elementMultiplier, divisor, stride, isBigEndian, index2, height) {
  index2 *= stride;
  let i2;
  if (isBigEndian) {
    for (i2 = 0; i2 < elementsPerHeight - 1; ++i2) {
      heights[index2 + i2] = height / divisor | 0;
      height -= heights[index2 + i2] * divisor;
      divisor /= elementMultiplier;
    }
  } else {
    for (i2 = elementsPerHeight - 1; i2 > 0; --i2) {
      heights[index2 + i2] = height / divisor | 0;
      height -= heights[index2 + i2] * divisor;
      divisor /= elementMultiplier;
    }
  }
  heights[index2 + i2] = height;
}
var HeightmapTerrainData_default = HeightmapTerrainData;

// node_modules/cesium/Source/Core/TileAvailability.js
function TileAvailability(tilingScheme2, maximumLevel) {
  this._tilingScheme = tilingScheme2;
  this._maximumLevel = maximumLevel;
  this._rootNodes = [];
}
var rectangleScratch = new Rectangle_default();
function findNode(level, x, y, nodes) {
  const count = nodes.length;
  for (let i2 = 0; i2 < count; ++i2) {
    const node = nodes[i2];
    if (node.x === x && node.y === y && node.level === level) {
      return true;
    }
  }
  return false;
}
TileAvailability.prototype.addAvailableTileRange = function(level, startX, startY, endX, endY) {
  const tilingScheme2 = this._tilingScheme;
  const rootNodes = this._rootNodes;
  if (level === 0) {
    for (let y = startY; y <= endY; ++y) {
      for (let x = startX; x <= endX; ++x) {
        if (!findNode(level, x, y, rootNodes)) {
          rootNodes.push(new QuadtreeNode(tilingScheme2, void 0, 0, x, y));
        }
      }
    }
  }
  tilingScheme2.tileXYToRectangle(startX, startY, level, rectangleScratch);
  const west = rectangleScratch.west;
  const north = rectangleScratch.north;
  tilingScheme2.tileXYToRectangle(endX, endY, level, rectangleScratch);
  const east = rectangleScratch.east;
  const south = rectangleScratch.south;
  const rectangleWithLevel = new RectangleWithLevel(
    level,
    west,
    south,
    east,
    north
  );
  for (let i2 = 0; i2 < rootNodes.length; ++i2) {
    const rootNode = rootNodes[i2];
    if (rectanglesOverlap(rootNode.extent, rectangleWithLevel)) {
      putRectangleInQuadtree(this._maximumLevel, rootNode, rectangleWithLevel);
    }
  }
};
TileAvailability.prototype.computeMaximumLevelAtPosition = function(position) {
  let node;
  for (let nodeIndex = 0; nodeIndex < this._rootNodes.length; ++nodeIndex) {
    const rootNode = this._rootNodes[nodeIndex];
    if (rectangleContainsPosition(rootNode.extent, position)) {
      node = rootNode;
      break;
    }
  }
  if (!defined_default(node)) {
    return -1;
  }
  return findMaxLevelFromNode(void 0, node, position);
};
var rectanglesScratch = [];
var remainingToCoverByLevelScratch = [];
var westScratch = new Rectangle_default();
var eastScratch = new Rectangle_default();
TileAvailability.prototype.computeBestAvailableLevelOverRectangle = function(rectangle) {
  const rectangles = rectanglesScratch;
  rectangles.length = 0;
  if (rectangle.east < rectangle.west) {
    rectangles.push(
      Rectangle_default.fromRadians(
        -Math.PI,
        rectangle.south,
        rectangle.east,
        rectangle.north,
        westScratch
      )
    );
    rectangles.push(
      Rectangle_default.fromRadians(
        rectangle.west,
        rectangle.south,
        Math.PI,
        rectangle.north,
        eastScratch
      )
    );
  } else {
    rectangles.push(rectangle);
  }
  const remainingToCoverByLevel = remainingToCoverByLevelScratch;
  remainingToCoverByLevel.length = 0;
  let i2;
  for (i2 = 0; i2 < this._rootNodes.length; ++i2) {
    updateCoverageWithNode(
      remainingToCoverByLevel,
      this._rootNodes[i2],
      rectangles
    );
  }
  for (i2 = remainingToCoverByLevel.length - 1; i2 >= 0; --i2) {
    if (defined_default(remainingToCoverByLevel[i2]) && remainingToCoverByLevel[i2].length === 0) {
      return i2;
    }
  }
  return 0;
};
var cartographicScratch = new Cartographic_default();
TileAvailability.prototype.isTileAvailable = function(level, x, y) {
  const rectangle = this._tilingScheme.tileXYToRectangle(
    x,
    y,
    level,
    rectangleScratch
  );
  Rectangle_default.center(rectangle, cartographicScratch);
  return this.computeMaximumLevelAtPosition(cartographicScratch) >= level;
};
TileAvailability.prototype.computeChildMaskForTile = function(level, x, y) {
  const childLevel = level + 1;
  if (childLevel >= this._maximumLevel) {
    return 0;
  }
  let mask = 0;
  mask |= this.isTileAvailable(childLevel, 2 * x, 2 * y + 1) ? 1 : 0;
  mask |= this.isTileAvailable(childLevel, 2 * x + 1, 2 * y + 1) ? 2 : 0;
  mask |= this.isTileAvailable(childLevel, 2 * x, 2 * y) ? 4 : 0;
  mask |= this.isTileAvailable(childLevel, 2 * x + 1, 2 * y) ? 8 : 0;
  return mask;
};
function QuadtreeNode(tilingScheme2, parent, level, x, y) {
  this.tilingScheme = tilingScheme2;
  this.parent = parent;
  this.level = level;
  this.x = x;
  this.y = y;
  this.extent = tilingScheme2.tileXYToRectangle(x, y, level);
  this.rectangles = [];
  this._sw = void 0;
  this._se = void 0;
  this._nw = void 0;
  this._ne = void 0;
}
Object.defineProperties(QuadtreeNode.prototype, {
  nw: {
    get: function() {
      if (!this._nw) {
        this._nw = new QuadtreeNode(
          this.tilingScheme,
          this,
          this.level + 1,
          this.x * 2,
          this.y * 2
        );
      }
      return this._nw;
    }
  },
  ne: {
    get: function() {
      if (!this._ne) {
        this._ne = new QuadtreeNode(
          this.tilingScheme,
          this,
          this.level + 1,
          this.x * 2 + 1,
          this.y * 2
        );
      }
      return this._ne;
    }
  },
  sw: {
    get: function() {
      if (!this._sw) {
        this._sw = new QuadtreeNode(
          this.tilingScheme,
          this,
          this.level + 1,
          this.x * 2,
          this.y * 2 + 1
        );
      }
      return this._sw;
    }
  },
  se: {
    get: function() {
      if (!this._se) {
        this._se = new QuadtreeNode(
          this.tilingScheme,
          this,
          this.level + 1,
          this.x * 2 + 1,
          this.y * 2 + 1
        );
      }
      return this._se;
    }
  }
});
function RectangleWithLevel(level, west, south, east, north) {
  this.level = level;
  this.west = west;
  this.south = south;
  this.east = east;
  this.north = north;
}
function rectanglesOverlap(rectangle1, rectangle2) {
  const west = Math.max(rectangle1.west, rectangle2.west);
  const south = Math.max(rectangle1.south, rectangle2.south);
  const east = Math.min(rectangle1.east, rectangle2.east);
  const north = Math.min(rectangle1.north, rectangle2.north);
  return south < north && west < east;
}
function putRectangleInQuadtree(maxDepth, node, rectangle) {
  while (node.level < maxDepth) {
    if (rectangleFullyContainsRectangle(node.nw.extent, rectangle)) {
      node = node.nw;
    } else if (rectangleFullyContainsRectangle(node.ne.extent, rectangle)) {
      node = node.ne;
    } else if (rectangleFullyContainsRectangle(node.sw.extent, rectangle)) {
      node = node.sw;
    } else if (rectangleFullyContainsRectangle(node.se.extent, rectangle)) {
      node = node.se;
    } else {
      break;
    }
  }
  if (node.rectangles.length === 0 || node.rectangles[node.rectangles.length - 1].level <= rectangle.level) {
    node.rectangles.push(rectangle);
  } else {
    let index2 = binarySearch_default(
      node.rectangles,
      rectangle.level,
      rectangleLevelComparator
    );
    if (index2 < 0) {
      index2 = ~index2;
    }
    node.rectangles.splice(index2, 0, rectangle);
  }
}
function rectangleLevelComparator(a4, b) {
  return a4.level - b;
}
function rectangleFullyContainsRectangle(potentialContainer, rectangleToTest) {
  return rectangleToTest.west >= potentialContainer.west && rectangleToTest.east <= potentialContainer.east && rectangleToTest.south >= potentialContainer.south && rectangleToTest.north <= potentialContainer.north;
}
function rectangleContainsPosition(potentialContainer, positionToTest) {
  return positionToTest.longitude >= potentialContainer.west && positionToTest.longitude <= potentialContainer.east && positionToTest.latitude >= potentialContainer.south && positionToTest.latitude <= potentialContainer.north;
}
function findMaxLevelFromNode(stopNode, node, position) {
  let maxLevel = 0;
  let found = false;
  while (!found) {
    const nw = node._nw && rectangleContainsPosition(node._nw.extent, position);
    const ne = node._ne && rectangleContainsPosition(node._ne.extent, position);
    const sw = node._sw && rectangleContainsPosition(node._sw.extent, position);
    const se = node._se && rectangleContainsPosition(node._se.extent, position);
    if (nw + ne + sw + se > 1) {
      if (nw) {
        maxLevel = Math.max(
          maxLevel,
          findMaxLevelFromNode(node, node._nw, position)
        );
      }
      if (ne) {
        maxLevel = Math.max(
          maxLevel,
          findMaxLevelFromNode(node, node._ne, position)
        );
      }
      if (sw) {
        maxLevel = Math.max(
          maxLevel,
          findMaxLevelFromNode(node, node._sw, position)
        );
      }
      if (se) {
        maxLevel = Math.max(
          maxLevel,
          findMaxLevelFromNode(node, node._se, position)
        );
      }
      break;
    } else if (nw) {
      node = node._nw;
    } else if (ne) {
      node = node._ne;
    } else if (sw) {
      node = node._sw;
    } else if (se) {
      node = node._se;
    } else {
      found = true;
    }
  }
  while (node !== stopNode) {
    const rectangles = node.rectangles;
    for (let i2 = rectangles.length - 1; i2 >= 0 && rectangles[i2].level > maxLevel; --i2) {
      const rectangle = rectangles[i2];
      if (rectangleContainsPosition(rectangle, position)) {
        maxLevel = rectangle.level;
      }
    }
    node = node.parent;
  }
  return maxLevel;
}
function updateCoverageWithNode(remainingToCoverByLevel, node, rectanglesToCover) {
  if (!node) {
    return;
  }
  let i2;
  let anyOverlap = false;
  for (i2 = 0; i2 < rectanglesToCover.length; ++i2) {
    anyOverlap = anyOverlap || rectanglesOverlap(node.extent, rectanglesToCover[i2]);
  }
  if (!anyOverlap) {
    return;
  }
  const rectangles = node.rectangles;
  for (i2 = 0; i2 < rectangles.length; ++i2) {
    const rectangle = rectangles[i2];
    if (!remainingToCoverByLevel[rectangle.level]) {
      remainingToCoverByLevel[rectangle.level] = rectanglesToCover;
    }
    remainingToCoverByLevel[rectangle.level] = subtractRectangle(
      remainingToCoverByLevel[rectangle.level],
      rectangle
    );
  }
  updateCoverageWithNode(remainingToCoverByLevel, node._nw, rectanglesToCover);
  updateCoverageWithNode(remainingToCoverByLevel, node._ne, rectanglesToCover);
  updateCoverageWithNode(remainingToCoverByLevel, node._sw, rectanglesToCover);
  updateCoverageWithNode(remainingToCoverByLevel, node._se, rectanglesToCover);
}
function subtractRectangle(rectangleList, rectangleToSubtract) {
  const result = [];
  for (let i2 = 0; i2 < rectangleList.length; ++i2) {
    const rectangle = rectangleList[i2];
    if (!rectanglesOverlap(rectangle, rectangleToSubtract)) {
      result.push(rectangle);
    } else {
      if (rectangle.west < rectangleToSubtract.west) {
        result.push(
          new Rectangle_default(
            rectangle.west,
            rectangle.south,
            rectangleToSubtract.west,
            rectangle.north
          )
        );
      }
      if (rectangle.east > rectangleToSubtract.east) {
        result.push(
          new Rectangle_default(
            rectangleToSubtract.east,
            rectangle.south,
            rectangle.east,
            rectangle.north
          )
        );
      }
      if (rectangle.south < rectangleToSubtract.south) {
        result.push(
          new Rectangle_default(
            Math.max(rectangleToSubtract.west, rectangle.west),
            rectangle.south,
            Math.min(rectangleToSubtract.east, rectangle.east),
            rectangleToSubtract.south
          )
        );
      }
      if (rectangle.north > rectangleToSubtract.north) {
        result.push(
          new Rectangle_default(
            Math.max(rectangleToSubtract.west, rectangle.west),
            rectangleToSubtract.north,
            Math.min(rectangleToSubtract.east, rectangle.east),
            rectangle.north
          )
        );
      }
    }
  }
  return result;
}
var TileAvailability_default = TileAvailability;

// node_modules/cesium/Source/Core/formatError.js
function formatError(object2) {
  let result;
  const name = object2.name;
  const message = object2.message;
  if (defined_default(name) && defined_default(message)) {
    result = `${name}: ${message}`;
  } else {
    result = object2.toString();
  }
  const stack = object2.stack;
  if (defined_default(stack)) {
    result += `
${stack}`;
  }
  return result;
}
var formatError_default = formatError;

// node_modules/cesium/Source/Core/TileProviderError.js
function TileProviderError(provider, message, x, y, level, timesRetried, error) {
  this.provider = provider;
  this.message = message;
  this.x = x;
  this.y = y;
  this.level = level;
  this.timesRetried = defaultValue_default(timesRetried, 0);
  this.retry = false;
  this.error = error;
}
TileProviderError.handleError = function(previousError, provider, event, message, x, y, level, retryFunction, errorDetails) {
  let error = previousError;
  if (!defined_default(previousError)) {
    error = new TileProviderError(
      provider,
      message,
      x,
      y,
      level,
      0,
      errorDetails
    );
  } else {
    error.provider = provider;
    error.message = message;
    error.x = x;
    error.y = y;
    error.level = level;
    error.retry = false;
    error.error = errorDetails;
    ++error.timesRetried;
  }
  if (event.numberOfListeners > 0) {
    event.raiseEvent(error);
  } else {
    console.log(
      `An error occurred in "${provider.constructor.name}": ${formatError_default(
        message
      )}`
    );
  }
  if (error.retry && defined_default(retryFunction)) {
    retryFunction();
  }
  return error;
};
TileProviderError.handleSuccess = function(previousError) {
  if (defined_default(previousError)) {
    previousError.timesRetried = -1;
  }
};
var TileProviderError_default = TileProviderError;

// node_modules/cesium/Source/Core/WebMercatorTilingScheme.js
function WebMercatorTilingScheme(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._numberOfLevelZeroTilesX = defaultValue_default(
    options.numberOfLevelZeroTilesX,
    1
  );
  this._numberOfLevelZeroTilesY = defaultValue_default(
    options.numberOfLevelZeroTilesY,
    1
  );
  this._projection = new WebMercatorProjection_default(this._ellipsoid);
  if (defined_default(options.rectangleSouthwestInMeters) && defined_default(options.rectangleNortheastInMeters)) {
    this._rectangleSouthwestInMeters = options.rectangleSouthwestInMeters;
    this._rectangleNortheastInMeters = options.rectangleNortheastInMeters;
  } else {
    const semimajorAxisTimesPi = this._ellipsoid.maximumRadius * Math.PI;
    this._rectangleSouthwestInMeters = new Cartesian2_default(
      -semimajorAxisTimesPi,
      -semimajorAxisTimesPi
    );
    this._rectangleNortheastInMeters = new Cartesian2_default(
      semimajorAxisTimesPi,
      semimajorAxisTimesPi
    );
  }
  const southwest = this._projection.unproject(
    this._rectangleSouthwestInMeters
  );
  const northeast = this._projection.unproject(
    this._rectangleNortheastInMeters
  );
  this._rectangle = new Rectangle_default(
    southwest.longitude,
    southwest.latitude,
    northeast.longitude,
    northeast.latitude
  );
}
Object.defineProperties(WebMercatorTilingScheme.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  },
  rectangle: {
    get: function() {
      return this._rectangle;
    }
  },
  projection: {
    get: function() {
      return this._projection;
    }
  }
});
WebMercatorTilingScheme.prototype.getNumberOfXTilesAtLevel = function(level) {
  return this._numberOfLevelZeroTilesX << level;
};
WebMercatorTilingScheme.prototype.getNumberOfYTilesAtLevel = function(level) {
  return this._numberOfLevelZeroTilesY << level;
};
WebMercatorTilingScheme.prototype.rectangleToNativeRectangle = function(rectangle, result) {
  const projection = this._projection;
  const southwest = projection.project(Rectangle_default.southwest(rectangle));
  const northeast = projection.project(Rectangle_default.northeast(rectangle));
  if (!defined_default(result)) {
    return new Rectangle_default(southwest.x, southwest.y, northeast.x, northeast.y);
  }
  result.west = southwest.x;
  result.south = southwest.y;
  result.east = northeast.x;
  result.north = northeast.y;
  return result;
};
WebMercatorTilingScheme.prototype.tileXYToNativeRectangle = function(x, y, level, result) {
  const xTiles = this.getNumberOfXTilesAtLevel(level);
  const yTiles = this.getNumberOfYTilesAtLevel(level);
  const xTileWidth = (this._rectangleNortheastInMeters.x - this._rectangleSouthwestInMeters.x) / xTiles;
  const west = this._rectangleSouthwestInMeters.x + x * xTileWidth;
  const east = this._rectangleSouthwestInMeters.x + (x + 1) * xTileWidth;
  const yTileHeight = (this._rectangleNortheastInMeters.y - this._rectangleSouthwestInMeters.y) / yTiles;
  const north = this._rectangleNortheastInMeters.y - y * yTileHeight;
  const south = this._rectangleNortheastInMeters.y - (y + 1) * yTileHeight;
  if (!defined_default(result)) {
    return new Rectangle_default(west, south, east, north);
  }
  result.west = west;
  result.south = south;
  result.east = east;
  result.north = north;
  return result;
};
WebMercatorTilingScheme.prototype.tileXYToRectangle = function(x, y, level, result) {
  const nativeRectangle = this.tileXYToNativeRectangle(x, y, level, result);
  const projection = this._projection;
  const southwest = projection.unproject(
    new Cartesian2_default(nativeRectangle.west, nativeRectangle.south)
  );
  const northeast = projection.unproject(
    new Cartesian2_default(nativeRectangle.east, nativeRectangle.north)
  );
  nativeRectangle.west = southwest.longitude;
  nativeRectangle.south = southwest.latitude;
  nativeRectangle.east = northeast.longitude;
  nativeRectangle.north = northeast.latitude;
  return nativeRectangle;
};
WebMercatorTilingScheme.prototype.positionToTileXY = function(position, level, result) {
  const rectangle = this._rectangle;
  if (!Rectangle_default.contains(rectangle, position)) {
    return void 0;
  }
  const xTiles = this.getNumberOfXTilesAtLevel(level);
  const yTiles = this.getNumberOfYTilesAtLevel(level);
  const overallWidth = this._rectangleNortheastInMeters.x - this._rectangleSouthwestInMeters.x;
  const xTileWidth = overallWidth / xTiles;
  const overallHeight = this._rectangleNortheastInMeters.y - this._rectangleSouthwestInMeters.y;
  const yTileHeight = overallHeight / yTiles;
  const projection = this._projection;
  const webMercatorPosition = projection.project(position);
  const distanceFromWest = webMercatorPosition.x - this._rectangleSouthwestInMeters.x;
  const distanceFromNorth = this._rectangleNortheastInMeters.y - webMercatorPosition.y;
  let xTileCoordinate = distanceFromWest / xTileWidth | 0;
  if (xTileCoordinate >= xTiles) {
    xTileCoordinate = xTiles - 1;
  }
  let yTileCoordinate = distanceFromNorth / yTileHeight | 0;
  if (yTileCoordinate >= yTiles) {
    yTileCoordinate = yTiles - 1;
  }
  if (!defined_default(result)) {
    return new Cartesian2_default(xTileCoordinate, yTileCoordinate);
  }
  result.x = xTileCoordinate;
  result.y = yTileCoordinate;
  return result;
};
var WebMercatorTilingScheme_default = WebMercatorTilingScheme;

// node_modules/cesium/Source/Core/ArcGISTiledElevationTerrainProvider.js
var ALL_CHILDREN = 15;
function ArcGISTiledElevationTerrainProvider(options) {
  if (!defined_default(options) || !defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  this._resource = void 0;
  this._credit = void 0;
  this._tilingScheme = void 0;
  this._levelZeroMaximumGeometricError = void 0;
  this._maxLevel = void 0;
  this._terrainDataStructure = void 0;
  this._ready = false;
  this._width = void 0;
  this._height = void 0;
  this._encoding = void 0;
  const token = options.token;
  this._hasAvailability = false;
  this._tilesAvailable = void 0;
  this._tilesAvailablityLoaded = void 0;
  this._availableCache = {};
  const that = this;
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._readyPromise = Promise.resolve(options.url).then(function(url2) {
    let resource = Resource_default.createIfNeeded(url2);
    resource.appendForwardSlash();
    if (defined_default(token)) {
      resource = resource.getDerivedResource({
        queryParameters: {
          token
        }
      });
    }
    that._resource = resource;
    const metadataResource = resource.getDerivedResource({
      queryParameters: {
        f: "pjson"
      }
    });
    return metadataResource.fetchJson();
  }).then(function(metadata) {
    const copyrightText = metadata.copyrightText;
    if (defined_default(copyrightText)) {
      that._credit = new Credit_default(copyrightText);
    }
    const spatialReference = metadata.spatialReference;
    const wkid = defaultValue_default(
      spatialReference.latestWkid,
      spatialReference.wkid
    );
    const extent = metadata.extent;
    const tilingSchemeOptions = {
      ellipsoid
    };
    if (wkid === 4326) {
      tilingSchemeOptions.rectangle = Rectangle_default.fromDegrees(
        extent.xmin,
        extent.ymin,
        extent.xmax,
        extent.ymax
      );
      that._tilingScheme = new GeographicTilingScheme_default(tilingSchemeOptions);
    } else if (wkid === 3857) {
      tilingSchemeOptions.rectangleSouthwestInMeters = new Cartesian2_default(
        extent.xmin,
        extent.ymin
      );
      tilingSchemeOptions.rectangleNortheastInMeters = new Cartesian2_default(
        extent.xmax,
        extent.ymax
      );
      that._tilingScheme = new WebMercatorTilingScheme_default(tilingSchemeOptions);
    } else {
      return Promise.reject(new RuntimeError_default("Invalid spatial reference"));
    }
    const tileInfo = metadata.tileInfo;
    if (!defined_default(tileInfo)) {
      return Promise.reject(new RuntimeError_default("tileInfo is required"));
    }
    that._width = tileInfo.rows + 1;
    that._height = tileInfo.cols + 1;
    that._encoding = tileInfo.format === "LERC" ? HeightmapEncoding_default.LERC : HeightmapEncoding_default.NONE;
    that._lodCount = tileInfo.lods.length - 1;
    const hasAvailability = that._hasAvailability = metadata.capabilities.indexOf("Tilemap") !== -1;
    if (hasAvailability) {
      that._tilesAvailable = new TileAvailability_default(
        that._tilingScheme,
        that._lodCount
      );
      that._tilesAvailable.addAvailableTileRange(
        0,
        0,
        0,
        that._tilingScheme.getNumberOfXTilesAtLevel(0),
        that._tilingScheme.getNumberOfYTilesAtLevel(0)
      );
      that._tilesAvailablityLoaded = new TileAvailability_default(
        that._tilingScheme,
        that._lodCount
      );
    }
    that._levelZeroMaximumGeometricError = TerrainProvider_default.getEstimatedLevelZeroGeometricErrorForAHeightmap(
      that._tilingScheme.ellipsoid,
      that._width,
      that._tilingScheme.getNumberOfXTilesAtLevel(0)
    );
    if (metadata.bandCount > 1) {
      console.log(
        "ArcGISTiledElevationTerrainProvider: Terrain data has more than 1 band. Using the first one."
      );
    }
    that._terrainDataStructure = {
      elementMultiplier: 1,
      lowestEncodedHeight: metadata.minValues[0],
      highestEncodedHeight: metadata.maxValues[0]
    };
    that._ready = true;
    return true;
  }).catch(function(error) {
    const message = `An error occurred while accessing ${that._resource.url}.`;
    TileProviderError_default.handleError(void 0, that, that._errorEvent, message);
    return Promise.reject(error);
  });
  this._errorEvent = new Event_default();
}
Object.defineProperties(ArcGISTiledElevationTerrainProvider.prototype, {
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  credit: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "credit must not be called before ready returns true."
        );
      }
      return this._credit;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before ready returns true."
        );
      }
      return this._tilingScheme;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  hasWaterMask: {
    get: function() {
      return false;
    }
  },
  hasVertexNormals: {
    get: function() {
      return false;
    }
  },
  availability: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "availability must not be called before the terrain provider is ready."
        );
      }
      return this._tilesAvailable;
    }
  }
});
ArcGISTiledElevationTerrainProvider.prototype.requestTileGeometry = function(x, y, level, request) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "requestTileGeometry must not be called before the terrain provider is ready."
    );
  }
  const tileResource = this._resource.getDerivedResource({
    url: `tile/${level}/${y}/${x}`,
    request
  });
  const hasAvailability = this._hasAvailability;
  let availabilityPromise = Promise.resolve(true);
  let availabilityRequest;
  if (hasAvailability && !defined_default(isTileAvailable(this, level + 1, x * 2, y * 2))) {
    const availabilityResult = requestAvailability(
      this,
      level + 1,
      x * 2,
      y * 2
    );
    availabilityPromise = availabilityResult.promise;
    availabilityRequest = availabilityResult.request;
  }
  const promise = tileResource.fetchArrayBuffer();
  if (!defined_default(promise) || !defined_default(availabilityPromise)) {
    return void 0;
  }
  const that = this;
  const tilesAvailable = this._tilesAvailable;
  return Promise.all([promise, availabilityPromise]).then(function(result) {
    return new HeightmapTerrainData_default({
      buffer: result[0],
      width: that._width,
      height: that._height,
      childTileMask: hasAvailability ? tilesAvailable.computeChildMaskForTile(level, x, y) : ALL_CHILDREN,
      structure: that._terrainDataStructure,
      encoding: that._encoding
    });
  }).catch(function(error) {
    if (defined_default(availabilityRequest) && availabilityRequest.state === RequestState_default.CANCELLED) {
      request.cancel();
      return request.deferred.promise.finally(function() {
        request.state = RequestState_default.CANCELLED;
        return Promise.reject(error);
      });
    }
    return Promise.reject(error);
  });
};
function isTileAvailable(that, level, x, y) {
  if (!that._hasAvailability) {
    return void 0;
  }
  const tilesAvailablityLoaded = that._tilesAvailablityLoaded;
  const tilesAvailable = that._tilesAvailable;
  if (level > that._lodCount) {
    return false;
  }
  if (tilesAvailable.isTileAvailable(level, x, y)) {
    return true;
  }
  if (tilesAvailablityLoaded.isTileAvailable(level, x, y)) {
    return false;
  }
  return void 0;
}
ArcGISTiledElevationTerrainProvider.prototype.getLevelMaximumGeometricError = function(level) {
  if (!this.ready) {
    throw new DeveloperError_default(
      "getLevelMaximumGeometricError must not be called before ready returns true."
    );
  }
  return this._levelZeroMaximumGeometricError / (1 << level);
};
ArcGISTiledElevationTerrainProvider.prototype.getTileDataAvailable = function(x, y, level) {
  if (!this._hasAvailability) {
    return void 0;
  }
  const result = isTileAvailable(this, level, x, y);
  if (defined_default(result)) {
    return result;
  }
  requestAvailability(this, level, x, y);
  return void 0;
};
ArcGISTiledElevationTerrainProvider.prototype.loadTileDataAvailability = function(x, y, level) {
  return void 0;
};
function findRange(origin, width, height, data) {
  const endCol = width - 1;
  const endRow = height - 1;
  const value = data[origin.y * width + origin.x];
  const endingIndices = [];
  const range2 = {
    startX: origin.x,
    startY: origin.y,
    endX: 0,
    endY: 0
  };
  const corner = new Cartesian2_default(origin.x + 1, origin.y + 1);
  let doneX = false;
  let doneY = false;
  while (!(doneX && doneY)) {
    let endX = corner.x;
    const endY = doneY ? corner.y + 1 : corner.y;
    if (!doneX) {
      for (let y = origin.y; y < endY; ++y) {
        if (data[y * width + corner.x] !== value) {
          doneX = true;
          break;
        }
      }
      if (doneX) {
        endingIndices.push(new Cartesian2_default(corner.x, origin.y));
        --corner.x;
        --endX;
        range2.endX = corner.x;
      } else if (corner.x === endCol) {
        range2.endX = corner.x;
        doneX = true;
      } else {
        ++corner.x;
      }
    }
    if (!doneY) {
      const col = corner.y * width;
      for (let x = origin.x; x <= endX; ++x) {
        if (data[col + x] !== value) {
          doneY = true;
          break;
        }
      }
      if (doneY) {
        endingIndices.push(new Cartesian2_default(origin.x, corner.y));
        --corner.y;
        range2.endY = corner.y;
      } else if (corner.y === endRow) {
        range2.endY = corner.y;
        doneY = true;
      } else {
        ++corner.y;
      }
    }
  }
  return {
    endingIndices,
    range: range2,
    value
  };
}
function computeAvailability(x, y, width, height, data) {
  const ranges = [];
  const singleValue = data.every(function(val) {
    return val === data[0];
  });
  if (singleValue) {
    if (data[0] === 1) {
      ranges.push({
        startX: x,
        startY: y,
        endX: x + width - 1,
        endY: y + height - 1
      });
    }
    return ranges;
  }
  let positions = [new Cartesian2_default(0, 0)];
  while (positions.length > 0) {
    const origin = positions.pop();
    const result = findRange(origin, width, height, data);
    if (result.value === 1) {
      const range2 = result.range;
      range2.startX += x;
      range2.endX += x;
      range2.startY += y;
      range2.endY += y;
      ranges.push(range2);
    }
    const endingIndices = result.endingIndices;
    if (endingIndices.length > 0) {
      positions = positions.concat(endingIndices);
    }
  }
  return ranges;
}
function requestAvailability(that, level, x, y) {
  if (!that._hasAvailability) {
    return {};
  }
  const xOffset = Math.floor(x / 128) * 128;
  const yOffset = Math.floor(y / 128) * 128;
  const dim = Math.min(1 << level, 128);
  const url2 = `tilemap/${level}/${yOffset}/${xOffset}/${dim}/${dim}`;
  const availableCache = that._availableCache;
  if (defined_default(availableCache[url2])) {
    return availableCache[url2];
  }
  const request = new Request_default({
    throttle: false,
    throttleByServer: true,
    type: RequestType_default.TERRAIN
  });
  const tilemapResource = that._resource.getDerivedResource({
    url: url2,
    request
  });
  let promise = tilemapResource.fetchJson();
  if (!defined_default(promise)) {
    return {};
  }
  promise = promise.then(function(result) {
    const available = computeAvailability(
      xOffset,
      yOffset,
      dim,
      dim,
      result.data
    );
    that._tilesAvailablityLoaded.addAvailableTileRange(
      level,
      xOffset,
      yOffset,
      xOffset + dim,
      yOffset + dim
    );
    const tilesAvailable = that._tilesAvailable;
    for (let i2 = 0; i2 < available.length; ++i2) {
      const range2 = available[i2];
      tilesAvailable.addAvailableTileRange(
        level,
        range2.startX,
        range2.startY,
        range2.endX,
        range2.endY
      );
    }
    return isTileAvailable(that, level, x, y);
  });
  availableCache[url2] = {
    promise,
    request
  };
  promise = promise.finally(function(result) {
    delete availableCache[url2];
    return result;
  });
  return {
    promise,
    request
  };
}
var ArcGISTiledElevationTerrainProvider_default = ArcGISTiledElevationTerrainProvider;

// node_modules/cesium/Source/Core/ArcType.js
var ArcType = {
  NONE: 0,
  GEODESIC: 1,
  RHUMB: 2
};
var ArcType_default = Object.freeze(ArcType);

// node_modules/cesium/Source/Core/AssociativeArray.js
function AssociativeArray() {
  this._array = [];
  this._hash = {};
}
Object.defineProperties(AssociativeArray.prototype, {
  length: {
    get: function() {
      return this._array.length;
    }
  },
  values: {
    get: function() {
      return this._array;
    }
  }
});
AssociativeArray.prototype.contains = function(key) {
  if (typeof key !== "string" && typeof key !== "number") {
    throw new DeveloperError_default("key is required to be a string or number.");
  }
  return defined_default(this._hash[key]);
};
AssociativeArray.prototype.set = function(key, value) {
  if (typeof key !== "string" && typeof key !== "number") {
    throw new DeveloperError_default("key is required to be a string or number.");
  }
  const oldValue2 = this._hash[key];
  if (value !== oldValue2) {
    this.remove(key);
    this._hash[key] = value;
    this._array.push(value);
  }
};
AssociativeArray.prototype.get = function(key) {
  if (typeof key !== "string" && typeof key !== "number") {
    throw new DeveloperError_default("key is required to be a string or number.");
  }
  return this._hash[key];
};
AssociativeArray.prototype.remove = function(key) {
  if (defined_default(key) && typeof key !== "string" && typeof key !== "number") {
    throw new DeveloperError_default("key is required to be a string or number.");
  }
  const value = this._hash[key];
  const hasValue = defined_default(value);
  if (hasValue) {
    const array = this._array;
    array.splice(array.indexOf(value), 1);
    delete this._hash[key];
  }
  return hasValue;
};
AssociativeArray.prototype.removeAll = function() {
  const array = this._array;
  if (array.length > 0) {
    this._hash = {};
    array.length = 0;
  }
};
var AssociativeArray_default = AssociativeArray;

// node_modules/cesium/Source/Core/BingMapsGeocoderService.js
var url = "https://dev.virtualearth.net/REST/v1/Locations";
function BingMapsGeocoderService(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const key = options.key;
  if (!defined_default(key)) {
    throw new DeveloperError_default("options.key is required.");
  }
  this._key = key;
  const queryParameters = {
    key
  };
  if (defined_default(options.culture)) {
    queryParameters.culture = options.culture;
  }
  this._resource = new Resource_default({
    url,
    queryParameters
  });
}
Object.defineProperties(BingMapsGeocoderService.prototype, {
  url: {
    get: function() {
      return url;
    }
  },
  key: {
    get: function() {
      return this._key;
    }
  }
});
BingMapsGeocoderService.prototype.geocode = function(query) {
  Check_default.typeOf.string("query", query);
  const resource = this._resource.getDerivedResource({
    queryParameters: {
      query
    }
  });
  return resource.fetchJsonp("jsonp").then(function(result) {
    if (result.resourceSets.length === 0) {
      return [];
    }
    const results = result.resourceSets[0].resources;
    return results.map(function(resource2) {
      const bbox2 = resource2.bbox;
      const south = bbox2[0];
      const west = bbox2[1];
      const north = bbox2[2];
      const east = bbox2[3];
      return {
        displayName: resource2.name,
        destination: Rectangle_default.fromDegrees(west, south, east, north)
      };
    });
  });
};
var BingMapsGeocoderService_default = BingMapsGeocoderService;

// node_modules/cesium/Source/Core/BoundingRectangle.js
function BoundingRectangle(x, y, width, height) {
  this.x = defaultValue_default(x, 0);
  this.y = defaultValue_default(y, 0);
  this.width = defaultValue_default(width, 0);
  this.height = defaultValue_default(height, 0);
}
BoundingRectangle.packedLength = 4;
BoundingRectangle.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.x;
  array[startingIndex++] = value.y;
  array[startingIndex++] = value.width;
  array[startingIndex] = value.height;
  return array;
};
BoundingRectangle.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new BoundingRectangle();
  }
  result.x = array[startingIndex++];
  result.y = array[startingIndex++];
  result.width = array[startingIndex++];
  result.height = array[startingIndex];
  return result;
};
BoundingRectangle.fromPoints = function(positions, result) {
  if (!defined_default(result)) {
    result = new BoundingRectangle();
  }
  if (!defined_default(positions) || positions.length === 0) {
    result.x = 0;
    result.y = 0;
    result.width = 0;
    result.height = 0;
    return result;
  }
  const length3 = positions.length;
  let minimumX = positions[0].x;
  let minimumY = positions[0].y;
  let maximumX = positions[0].x;
  let maximumY = positions[0].y;
  for (let i2 = 1; i2 < length3; i2++) {
    const p2 = positions[i2];
    const x = p2.x;
    const y = p2.y;
    minimumX = Math.min(x, minimumX);
    maximumX = Math.max(x, maximumX);
    minimumY = Math.min(y, minimumY);
    maximumY = Math.max(y, maximumY);
  }
  result.x = minimumX;
  result.y = minimumY;
  result.width = maximumX - minimumX;
  result.height = maximumY - minimumY;
  return result;
};
var defaultProjection2 = new GeographicProjection_default();
var fromRectangleLowerLeft = new Cartographic_default();
var fromRectangleUpperRight = new Cartographic_default();
BoundingRectangle.fromRectangle = function(rectangle, projection, result) {
  if (!defined_default(result)) {
    result = new BoundingRectangle();
  }
  if (!defined_default(rectangle)) {
    result.x = 0;
    result.y = 0;
    result.width = 0;
    result.height = 0;
    return result;
  }
  projection = defaultValue_default(projection, defaultProjection2);
  const lowerLeft = projection.project(
    Rectangle_default.southwest(rectangle, fromRectangleLowerLeft)
  );
  const upperRight = projection.project(
    Rectangle_default.northeast(rectangle, fromRectangleUpperRight)
  );
  Cartesian2_default.subtract(upperRight, lowerLeft, upperRight);
  result.x = lowerLeft.x;
  result.y = lowerLeft.y;
  result.width = upperRight.x;
  result.height = upperRight.y;
  return result;
};
BoundingRectangle.clone = function(rectangle, result) {
  if (!defined_default(rectangle)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new BoundingRectangle(
      rectangle.x,
      rectangle.y,
      rectangle.width,
      rectangle.height
    );
  }
  result.x = rectangle.x;
  result.y = rectangle.y;
  result.width = rectangle.width;
  result.height = rectangle.height;
  return result;
};
BoundingRectangle.union = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  if (!defined_default(result)) {
    result = new BoundingRectangle();
  }
  const lowerLeftX = Math.min(left.x, right.x);
  const lowerLeftY = Math.min(left.y, right.y);
  const upperRightX = Math.max(left.x + left.width, right.x + right.width);
  const upperRightY = Math.max(left.y + left.height, right.y + right.height);
  result.x = lowerLeftX;
  result.y = lowerLeftY;
  result.width = upperRightX - lowerLeftX;
  result.height = upperRightY - lowerLeftY;
  return result;
};
BoundingRectangle.expand = function(rectangle, point, result) {
  Check_default.typeOf.object("rectangle", rectangle);
  Check_default.typeOf.object("point", point);
  result = BoundingRectangle.clone(rectangle, result);
  const width = point.x - result.x;
  const height = point.y - result.y;
  if (width > result.width) {
    result.width = width;
  } else if (width < 0) {
    result.width -= width;
    result.x = point.x;
  }
  if (height > result.height) {
    result.height = height;
  } else if (height < 0) {
    result.height -= height;
    result.y = point.y;
  }
  return result;
};
BoundingRectangle.intersect = function(left, right) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  const leftX = left.x;
  const leftY = left.y;
  const rightX = right.x;
  const rightY = right.y;
  if (!(leftX > rightX + right.width || leftX + left.width < rightX || leftY + left.height < rightY || leftY > rightY + right.height)) {
    return Intersect_default.INTERSECTING;
  }
  return Intersect_default.OUTSIDE;
};
BoundingRectangle.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y && left.width === right.width && left.height === right.height;
};
BoundingRectangle.prototype.clone = function(result) {
  return BoundingRectangle.clone(this, result);
};
BoundingRectangle.prototype.intersect = function(right) {
  return BoundingRectangle.intersect(this, right);
};
BoundingRectangle.prototype.equals = function(right) {
  return BoundingRectangle.equals(this, right);
};
var BoundingRectangle_default = BoundingRectangle;

// node_modules/cesium/Source/Core/arrayFill.js
function arrayFill(array, value, start, end) {
  Check_default.defined("array", array);
  Check_default.defined("value", value);
  if (defined_default(start)) {
    Check_default.typeOf.number("start", start);
  }
  if (defined_default(end)) {
    Check_default.typeOf.number("end", end);
  }
  if (typeof array.fill === "function") {
    return array.fill(value, start, end);
  }
  const length3 = array.length >>> 0;
  const relativeStart = defaultValue_default(start, 0);
  let k = relativeStart < 0 ? Math.max(length3 + relativeStart, 0) : Math.min(relativeStart, length3);
  const relativeEnd = defaultValue_default(end, length3);
  const last = relativeEnd < 0 ? Math.max(length3 + relativeEnd, 0) : Math.min(relativeEnd, length3);
  while (k < last) {
    array[k] = value;
    k++;
  }
  return array;
}
var arrayFill_default = arrayFill;

// node_modules/cesium/Source/Core/GeometryType.js
var GeometryType = {
  NONE: 0,
  TRIANGLES: 1,
  LINES: 2,
  POLYLINES: 3
};
var GeometryType_default = Object.freeze(GeometryType);

// node_modules/cesium/Source/Core/PrimitiveType.js
var PrimitiveType = {
  POINTS: WebGLConstants_default.POINTS,
  LINES: WebGLConstants_default.LINES,
  LINE_LOOP: WebGLConstants_default.LINE_LOOP,
  LINE_STRIP: WebGLConstants_default.LINE_STRIP,
  TRIANGLES: WebGLConstants_default.TRIANGLES,
  TRIANGLE_STRIP: WebGLConstants_default.TRIANGLE_STRIP,
  TRIANGLE_FAN: WebGLConstants_default.TRIANGLE_FAN
};
PrimitiveType.isLines = function(primitiveType) {
  return primitiveType === PrimitiveType.LINES || primitiveType === PrimitiveType.LINE_LOOP || primitiveType === PrimitiveType.LINE_STRIP;
};
PrimitiveType.isTriangles = function(primitiveType) {
  return primitiveType === PrimitiveType.TRIANGLES || primitiveType === PrimitiveType.TRIANGLE_STRIP || primitiveType === PrimitiveType.TRIANGLE_FAN;
};
PrimitiveType.validate = function(primitiveType) {
  return primitiveType === PrimitiveType.POINTS || primitiveType === PrimitiveType.LINES || primitiveType === PrimitiveType.LINE_LOOP || primitiveType === PrimitiveType.LINE_STRIP || primitiveType === PrimitiveType.TRIANGLES || primitiveType === PrimitiveType.TRIANGLE_STRIP || primitiveType === PrimitiveType.TRIANGLE_FAN;
};
var PrimitiveType_default = Object.freeze(PrimitiveType);

// node_modules/cesium/Source/Core/Geometry.js
function Geometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.attributes", options.attributes);
  this.attributes = options.attributes;
  this.indices = options.indices;
  this.primitiveType = defaultValue_default(
    options.primitiveType,
    PrimitiveType_default.TRIANGLES
  );
  this.boundingSphere = options.boundingSphere;
  this.geometryType = defaultValue_default(options.geometryType, GeometryType_default.NONE);
  this.boundingSphereCV = options.boundingSphereCV;
  this.offsetAttribute = options.offsetAttribute;
}
Geometry.computeNumberOfVertices = function(geometry) {
  Check_default.typeOf.object("geometry", geometry);
  let numberOfVertices = -1;
  for (const property in geometry.attributes) {
    if (geometry.attributes.hasOwnProperty(property) && defined_default(geometry.attributes[property]) && defined_default(geometry.attributes[property].values)) {
      const attribute = geometry.attributes[property];
      const num = attribute.values.length / attribute.componentsPerAttribute;
      if (numberOfVertices !== num && numberOfVertices !== -1) {
        throw new DeveloperError_default(
          "All attribute lists must have the same number of attributes."
        );
      }
      numberOfVertices = num;
    }
  }
  return numberOfVertices;
};
var rectangleCenterScratch = new Cartographic_default();
var enuCenterScratch = new Cartesian3_default();
var fixedFrameToEnuScratch = new Matrix4_default();
var boundingRectanglePointsCartographicScratch = [
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default()
];
var boundingRectanglePointsEnuScratch = [
  new Cartesian2_default(),
  new Cartesian2_default(),
  new Cartesian2_default()
];
var points2DScratch = [new Cartesian2_default(), new Cartesian2_default(), new Cartesian2_default()];
var pointEnuScratch = new Cartesian3_default();
var enuRotationScratch = new Quaternion_default();
var enuRotationMatrixScratch = new Matrix4_default();
var rotation2DScratch = new Matrix2_default();
Geometry._textureCoordinateRotationPoints = function(positions, stRotation, ellipsoid, boundingRectangle) {
  let i2;
  const rectangleCenter = Rectangle_default.center(
    boundingRectangle,
    rectangleCenterScratch
  );
  const enuCenter = Cartographic_default.toCartesian(
    rectangleCenter,
    ellipsoid,
    enuCenterScratch
  );
  const enuToFixedFrame = Transforms_default.eastNorthUpToFixedFrame(
    enuCenter,
    ellipsoid,
    fixedFrameToEnuScratch
  );
  const fixedFrameToEnu = Matrix4_default.inverse(
    enuToFixedFrame,
    fixedFrameToEnuScratch
  );
  const boundingPointsEnu = boundingRectanglePointsEnuScratch;
  const boundingPointsCarto = boundingRectanglePointsCartographicScratch;
  boundingPointsCarto[0].longitude = boundingRectangle.west;
  boundingPointsCarto[0].latitude = boundingRectangle.south;
  boundingPointsCarto[1].longitude = boundingRectangle.west;
  boundingPointsCarto[1].latitude = boundingRectangle.north;
  boundingPointsCarto[2].longitude = boundingRectangle.east;
  boundingPointsCarto[2].latitude = boundingRectangle.south;
  let posEnu = pointEnuScratch;
  for (i2 = 0; i2 < 3; i2++) {
    Cartographic_default.toCartesian(boundingPointsCarto[i2], ellipsoid, posEnu);
    posEnu = Matrix4_default.multiplyByPointAsVector(fixedFrameToEnu, posEnu, posEnu);
    boundingPointsEnu[i2].x = posEnu.x;
    boundingPointsEnu[i2].y = posEnu.y;
  }
  const rotation = Quaternion_default.fromAxisAngle(
    Cartesian3_default.UNIT_Z,
    -stRotation,
    enuRotationScratch
  );
  const textureMatrix = Matrix3_default.fromQuaternion(
    rotation,
    enuRotationMatrixScratch
  );
  const positionsLength = positions.length;
  let enuMinX = Number.POSITIVE_INFINITY;
  let enuMinY = Number.POSITIVE_INFINITY;
  let enuMaxX = Number.NEGATIVE_INFINITY;
  let enuMaxY = Number.NEGATIVE_INFINITY;
  for (i2 = 0; i2 < positionsLength; i2++) {
    posEnu = Matrix4_default.multiplyByPointAsVector(
      fixedFrameToEnu,
      positions[i2],
      posEnu
    );
    posEnu = Matrix3_default.multiplyByVector(textureMatrix, posEnu, posEnu);
    enuMinX = Math.min(enuMinX, posEnu.x);
    enuMinY = Math.min(enuMinY, posEnu.y);
    enuMaxX = Math.max(enuMaxX, posEnu.x);
    enuMaxY = Math.max(enuMaxY, posEnu.y);
  }
  const toDesiredInComputed = Matrix2_default.fromRotation(
    stRotation,
    rotation2DScratch
  );
  const points2D = points2DScratch;
  points2D[0].x = enuMinX;
  points2D[0].y = enuMinY;
  points2D[1].x = enuMinX;
  points2D[1].y = enuMaxY;
  points2D[2].x = enuMaxX;
  points2D[2].y = enuMinY;
  const boundingEnuMin = boundingPointsEnu[0];
  const boundingPointsWidth = boundingPointsEnu[2].x - boundingEnuMin.x;
  const boundingPointsHeight = boundingPointsEnu[1].y - boundingEnuMin.y;
  for (i2 = 0; i2 < 3; i2++) {
    const point2D = points2D[i2];
    Matrix2_default.multiplyByVector(toDesiredInComputed, point2D, point2D);
    point2D.x = (point2D.x - boundingEnuMin.x) / boundingPointsWidth;
    point2D.y = (point2D.y - boundingEnuMin.y) / boundingPointsHeight;
  }
  const minXYCorner = points2D[0];
  const maxYCorner = points2D[1];
  const maxXCorner = points2D[2];
  const result = new Array(6);
  Cartesian2_default.pack(minXYCorner, result);
  Cartesian2_default.pack(maxYCorner, result, 2);
  Cartesian2_default.pack(maxXCorner, result, 4);
  return result;
};
var Geometry_default = Geometry;

// node_modules/cesium/Source/Core/GeometryAttribute.js
function GeometryAttribute(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.componentDatatype)) {
    throw new DeveloperError_default("options.componentDatatype is required.");
  }
  if (!defined_default(options.componentsPerAttribute)) {
    throw new DeveloperError_default("options.componentsPerAttribute is required.");
  }
  if (options.componentsPerAttribute < 1 || options.componentsPerAttribute > 4) {
    throw new DeveloperError_default(
      "options.componentsPerAttribute must be between 1 and 4."
    );
  }
  if (!defined_default(options.values)) {
    throw new DeveloperError_default("options.values is required.");
  }
  this.componentDatatype = options.componentDatatype;
  this.componentsPerAttribute = options.componentsPerAttribute;
  this.normalize = defaultValue_default(options.normalize, false);
  this.values = options.values;
}
var GeometryAttribute_default = GeometryAttribute;

// node_modules/cesium/Source/Core/GeometryAttributes.js
function GeometryAttributes(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.position = options.position;
  this.normal = options.normal;
  this.st = options.st;
  this.bitangent = options.bitangent;
  this.tangent = options.tangent;
  this.color = options.color;
}
var GeometryAttributes_default = GeometryAttributes;

// node_modules/cesium/Source/Core/GeometryOffsetAttribute.js
var GeometryOffsetAttribute = {
  NONE: 0,
  TOP: 1,
  ALL: 2
};
var GeometryOffsetAttribute_default = Object.freeze(GeometryOffsetAttribute);

// node_modules/cesium/Source/Core/VertexFormat.js
function VertexFormat(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.position = defaultValue_default(options.position, false);
  this.normal = defaultValue_default(options.normal, false);
  this.st = defaultValue_default(options.st, false);
  this.bitangent = defaultValue_default(options.bitangent, false);
  this.tangent = defaultValue_default(options.tangent, false);
  this.color = defaultValue_default(options.color, false);
}
VertexFormat.POSITION_ONLY = Object.freeze(
  new VertexFormat({
    position: true
  })
);
VertexFormat.POSITION_AND_NORMAL = Object.freeze(
  new VertexFormat({
    position: true,
    normal: true
  })
);
VertexFormat.POSITION_NORMAL_AND_ST = Object.freeze(
  new VertexFormat({
    position: true,
    normal: true,
    st: true
  })
);
VertexFormat.POSITION_AND_ST = Object.freeze(
  new VertexFormat({
    position: true,
    st: true
  })
);
VertexFormat.POSITION_AND_COLOR = Object.freeze(
  new VertexFormat({
    position: true,
    color: true
  })
);
VertexFormat.ALL = Object.freeze(
  new VertexFormat({
    position: true,
    normal: true,
    st: true,
    tangent: true,
    bitangent: true
  })
);
VertexFormat.DEFAULT = VertexFormat.POSITION_NORMAL_AND_ST;
VertexFormat.packedLength = 6;
VertexFormat.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.position ? 1 : 0;
  array[startingIndex++] = value.normal ? 1 : 0;
  array[startingIndex++] = value.st ? 1 : 0;
  array[startingIndex++] = value.tangent ? 1 : 0;
  array[startingIndex++] = value.bitangent ? 1 : 0;
  array[startingIndex] = value.color ? 1 : 0;
  return array;
};
VertexFormat.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new VertexFormat();
  }
  result.position = array[startingIndex++] === 1;
  result.normal = array[startingIndex++] === 1;
  result.st = array[startingIndex++] === 1;
  result.tangent = array[startingIndex++] === 1;
  result.bitangent = array[startingIndex++] === 1;
  result.color = array[startingIndex] === 1;
  return result;
};
VertexFormat.clone = function(vertexFormat, result) {
  if (!defined_default(vertexFormat)) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new VertexFormat();
  }
  result.position = vertexFormat.position;
  result.normal = vertexFormat.normal;
  result.st = vertexFormat.st;
  result.tangent = vertexFormat.tangent;
  result.bitangent = vertexFormat.bitangent;
  result.color = vertexFormat.color;
  return result;
};
var VertexFormat_default = VertexFormat;

// node_modules/cesium/Source/Core/BoxGeometry.js
var diffScratch = new Cartesian3_default();
function BoxGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const min3 = options.minimum;
  const max3 = options.maximum;
  Check_default.typeOf.object("min", min3);
  Check_default.typeOf.object("max", max3);
  if (defined_default(options.offsetAttribute) && options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
    throw new DeveloperError_default(
      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
    );
  }
  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
  this._minimum = Cartesian3_default.clone(min3);
  this._maximum = Cartesian3_default.clone(max3);
  this._vertexFormat = vertexFormat;
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createBoxGeometry";
}
BoxGeometry.fromDimensions = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const dimensions = options.dimensions;
  Check_default.typeOf.object("dimensions", dimensions);
  Check_default.typeOf.number.greaterThanOrEquals("dimensions.x", dimensions.x, 0);
  Check_default.typeOf.number.greaterThanOrEquals("dimensions.y", dimensions.y, 0);
  Check_default.typeOf.number.greaterThanOrEquals("dimensions.z", dimensions.z, 0);
  const corner = Cartesian3_default.multiplyByScalar(dimensions, 0.5, new Cartesian3_default());
  return new BoxGeometry({
    minimum: Cartesian3_default.negate(corner, new Cartesian3_default()),
    maximum: corner,
    vertexFormat: options.vertexFormat,
    offsetAttribute: options.offsetAttribute
  });
};
BoxGeometry.fromAxisAlignedBoundingBox = function(boundingBox) {
  Check_default.typeOf.object("boundingBox", boundingBox);
  return new BoxGeometry({
    minimum: boundingBox.minimum,
    maximum: boundingBox.maximum
  });
};
BoxGeometry.packedLength = 2 * Cartesian3_default.packedLength + VertexFormat_default.packedLength + 1;
BoxGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  Cartesian3_default.pack(value._minimum, array, startingIndex);
  Cartesian3_default.pack(
    value._maximum,
    array,
    startingIndex + Cartesian3_default.packedLength
  );
  VertexFormat_default.pack(
    value._vertexFormat,
    array,
    startingIndex + 2 * Cartesian3_default.packedLength
  );
  array[startingIndex + 2 * Cartesian3_default.packedLength + VertexFormat_default.packedLength] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchMin = new Cartesian3_default();
var scratchMax = new Cartesian3_default();
var scratchVertexFormat = new VertexFormat_default();
var scratchOptions = {
  minimum: scratchMin,
  maximum: scratchMax,
  vertexFormat: scratchVertexFormat,
  offsetAttribute: void 0
};
BoxGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const min3 = Cartesian3_default.unpack(array, startingIndex, scratchMin);
  const max3 = Cartesian3_default.unpack(
    array,
    startingIndex + Cartesian3_default.packedLength,
    scratchMax
  );
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex + 2 * Cartesian3_default.packedLength,
    scratchVertexFormat
  );
  const offsetAttribute = array[startingIndex + 2 * Cartesian3_default.packedLength + VertexFormat_default.packedLength];
  if (!defined_default(result)) {
    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new BoxGeometry(scratchOptions);
  }
  result._minimum = Cartesian3_default.clone(min3, result._minimum);
  result._maximum = Cartesian3_default.clone(max3, result._maximum);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
BoxGeometry.createGeometry = function(boxGeometry) {
  const min3 = boxGeometry._minimum;
  const max3 = boxGeometry._maximum;
  const vertexFormat = boxGeometry._vertexFormat;
  if (Cartesian3_default.equals(min3, max3)) {
    return;
  }
  const attributes = new GeometryAttributes_default();
  let indices2;
  let positions;
  if (vertexFormat.position && (vertexFormat.st || vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent)) {
    if (vertexFormat.position) {
      positions = new Float64Array(6 * 4 * 3);
      positions[0] = min3.x;
      positions[1] = min3.y;
      positions[2] = max3.z;
      positions[3] = max3.x;
      positions[4] = min3.y;
      positions[5] = max3.z;
      positions[6] = max3.x;
      positions[7] = max3.y;
      positions[8] = max3.z;
      positions[9] = min3.x;
      positions[10] = max3.y;
      positions[11] = max3.z;
      positions[12] = min3.x;
      positions[13] = min3.y;
      positions[14] = min3.z;
      positions[15] = max3.x;
      positions[16] = min3.y;
      positions[17] = min3.z;
      positions[18] = max3.x;
      positions[19] = max3.y;
      positions[20] = min3.z;
      positions[21] = min3.x;
      positions[22] = max3.y;
      positions[23] = min3.z;
      positions[24] = max3.x;
      positions[25] = min3.y;
      positions[26] = min3.z;
      positions[27] = max3.x;
      positions[28] = max3.y;
      positions[29] = min3.z;
      positions[30] = max3.x;
      positions[31] = max3.y;
      positions[32] = max3.z;
      positions[33] = max3.x;
      positions[34] = min3.y;
      positions[35] = max3.z;
      positions[36] = min3.x;
      positions[37] = min3.y;
      positions[38] = min3.z;
      positions[39] = min3.x;
      positions[40] = max3.y;
      positions[41] = min3.z;
      positions[42] = min3.x;
      positions[43] = max3.y;
      positions[44] = max3.z;
      positions[45] = min3.x;
      positions[46] = min3.y;
      positions[47] = max3.z;
      positions[48] = min3.x;
      positions[49] = max3.y;
      positions[50] = min3.z;
      positions[51] = max3.x;
      positions[52] = max3.y;
      positions[53] = min3.z;
      positions[54] = max3.x;
      positions[55] = max3.y;
      positions[56] = max3.z;
      positions[57] = min3.x;
      positions[58] = max3.y;
      positions[59] = max3.z;
      positions[60] = min3.x;
      positions[61] = min3.y;
      positions[62] = min3.z;
      positions[63] = max3.x;
      positions[64] = min3.y;
      positions[65] = min3.z;
      positions[66] = max3.x;
      positions[67] = min3.y;
      positions[68] = max3.z;
      positions[69] = min3.x;
      positions[70] = min3.y;
      positions[71] = max3.z;
      attributes.position = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.DOUBLE,
        componentsPerAttribute: 3,
        values: positions
      });
    }
    if (vertexFormat.normal) {
      const normals = new Float32Array(6 * 4 * 3);
      normals[0] = 0;
      normals[1] = 0;
      normals[2] = 1;
      normals[3] = 0;
      normals[4] = 0;
      normals[5] = 1;
      normals[6] = 0;
      normals[7] = 0;
      normals[8] = 1;
      normals[9] = 0;
      normals[10] = 0;
      normals[11] = 1;
      normals[12] = 0;
      normals[13] = 0;
      normals[14] = -1;
      normals[15] = 0;
      normals[16] = 0;
      normals[17] = -1;
      normals[18] = 0;
      normals[19] = 0;
      normals[20] = -1;
      normals[21] = 0;
      normals[22] = 0;
      normals[23] = -1;
      normals[24] = 1;
      normals[25] = 0;
      normals[26] = 0;
      normals[27] = 1;
      normals[28] = 0;
      normals[29] = 0;
      normals[30] = 1;
      normals[31] = 0;
      normals[32] = 0;
      normals[33] = 1;
      normals[34] = 0;
      normals[35] = 0;
      normals[36] = -1;
      normals[37] = 0;
      normals[38] = 0;
      normals[39] = -1;
      normals[40] = 0;
      normals[41] = 0;
      normals[42] = -1;
      normals[43] = 0;
      normals[44] = 0;
      normals[45] = -1;
      normals[46] = 0;
      normals[47] = 0;
      normals[48] = 0;
      normals[49] = 1;
      normals[50] = 0;
      normals[51] = 0;
      normals[52] = 1;
      normals[53] = 0;
      normals[54] = 0;
      normals[55] = 1;
      normals[56] = 0;
      normals[57] = 0;
      normals[58] = 1;
      normals[59] = 0;
      normals[60] = 0;
      normals[61] = -1;
      normals[62] = 0;
      normals[63] = 0;
      normals[64] = -1;
      normals[65] = 0;
      normals[66] = 0;
      normals[67] = -1;
      normals[68] = 0;
      normals[69] = 0;
      normals[70] = -1;
      normals[71] = 0;
      attributes.normal = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: normals
      });
    }
    if (vertexFormat.st) {
      const texCoords = new Float32Array(6 * 4 * 2);
      texCoords[0] = 0;
      texCoords[1] = 0;
      texCoords[2] = 1;
      texCoords[3] = 0;
      texCoords[4] = 1;
      texCoords[5] = 1;
      texCoords[6] = 0;
      texCoords[7] = 1;
      texCoords[8] = 1;
      texCoords[9] = 0;
      texCoords[10] = 0;
      texCoords[11] = 0;
      texCoords[12] = 0;
      texCoords[13] = 1;
      texCoords[14] = 1;
      texCoords[15] = 1;
      texCoords[16] = 0;
      texCoords[17] = 0;
      texCoords[18] = 1;
      texCoords[19] = 0;
      texCoords[20] = 1;
      texCoords[21] = 1;
      texCoords[22] = 0;
      texCoords[23] = 1;
      texCoords[24] = 1;
      texCoords[25] = 0;
      texCoords[26] = 0;
      texCoords[27] = 0;
      texCoords[28] = 0;
      texCoords[29] = 1;
      texCoords[30] = 1;
      texCoords[31] = 1;
      texCoords[32] = 1;
      texCoords[33] = 0;
      texCoords[34] = 0;
      texCoords[35] = 0;
      texCoords[36] = 0;
      texCoords[37] = 1;
      texCoords[38] = 1;
      texCoords[39] = 1;
      texCoords[40] = 0;
      texCoords[41] = 0;
      texCoords[42] = 1;
      texCoords[43] = 0;
      texCoords[44] = 1;
      texCoords[45] = 1;
      texCoords[46] = 0;
      texCoords[47] = 1;
      attributes.st = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 2,
        values: texCoords
      });
    }
    if (vertexFormat.tangent) {
      const tangents = new Float32Array(6 * 4 * 3);
      tangents[0] = 1;
      tangents[1] = 0;
      tangents[2] = 0;
      tangents[3] = 1;
      tangents[4] = 0;
      tangents[5] = 0;
      tangents[6] = 1;
      tangents[7] = 0;
      tangents[8] = 0;
      tangents[9] = 1;
      tangents[10] = 0;
      tangents[11] = 0;
      tangents[12] = -1;
      tangents[13] = 0;
      tangents[14] = 0;
      tangents[15] = -1;
      tangents[16] = 0;
      tangents[17] = 0;
      tangents[18] = -1;
      tangents[19] = 0;
      tangents[20] = 0;
      tangents[21] = -1;
      tangents[22] = 0;
      tangents[23] = 0;
      tangents[24] = 0;
      tangents[25] = 1;
      tangents[26] = 0;
      tangents[27] = 0;
      tangents[28] = 1;
      tangents[29] = 0;
      tangents[30] = 0;
      tangents[31] = 1;
      tangents[32] = 0;
      tangents[33] = 0;
      tangents[34] = 1;
      tangents[35] = 0;
      tangents[36] = 0;
      tangents[37] = -1;
      tangents[38] = 0;
      tangents[39] = 0;
      tangents[40] = -1;
      tangents[41] = 0;
      tangents[42] = 0;
      tangents[43] = -1;
      tangents[44] = 0;
      tangents[45] = 0;
      tangents[46] = -1;
      tangents[47] = 0;
      tangents[48] = -1;
      tangents[49] = 0;
      tangents[50] = 0;
      tangents[51] = -1;
      tangents[52] = 0;
      tangents[53] = 0;
      tangents[54] = -1;
      tangents[55] = 0;
      tangents[56] = 0;
      tangents[57] = -1;
      tangents[58] = 0;
      tangents[59] = 0;
      tangents[60] = 1;
      tangents[61] = 0;
      tangents[62] = 0;
      tangents[63] = 1;
      tangents[64] = 0;
      tangents[65] = 0;
      tangents[66] = 1;
      tangents[67] = 0;
      tangents[68] = 0;
      tangents[69] = 1;
      tangents[70] = 0;
      tangents[71] = 0;
      attributes.tangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: tangents
      });
    }
    if (vertexFormat.bitangent) {
      const bitangents = new Float32Array(6 * 4 * 3);
      bitangents[0] = 0;
      bitangents[1] = 1;
      bitangents[2] = 0;
      bitangents[3] = 0;
      bitangents[4] = 1;
      bitangents[5] = 0;
      bitangents[6] = 0;
      bitangents[7] = 1;
      bitangents[8] = 0;
      bitangents[9] = 0;
      bitangents[10] = 1;
      bitangents[11] = 0;
      bitangents[12] = 0;
      bitangents[13] = 1;
      bitangents[14] = 0;
      bitangents[15] = 0;
      bitangents[16] = 1;
      bitangents[17] = 0;
      bitangents[18] = 0;
      bitangents[19] = 1;
      bitangents[20] = 0;
      bitangents[21] = 0;
      bitangents[22] = 1;
      bitangents[23] = 0;
      bitangents[24] = 0;
      bitangents[25] = 0;
      bitangents[26] = 1;
      bitangents[27] = 0;
      bitangents[28] = 0;
      bitangents[29] = 1;
      bitangents[30] = 0;
      bitangents[31] = 0;
      bitangents[32] = 1;
      bitangents[33] = 0;
      bitangents[34] = 0;
      bitangents[35] = 1;
      bitangents[36] = 0;
      bitangents[37] = 0;
      bitangents[38] = 1;
      bitangents[39] = 0;
      bitangents[40] = 0;
      bitangents[41] = 1;
      bitangents[42] = 0;
      bitangents[43] = 0;
      bitangents[44] = 1;
      bitangents[45] = 0;
      bitangents[46] = 0;
      bitangents[47] = 1;
      bitangents[48] = 0;
      bitangents[49] = 0;
      bitangents[50] = 1;
      bitangents[51] = 0;
      bitangents[52] = 0;
      bitangents[53] = 1;
      bitangents[54] = 0;
      bitangents[55] = 0;
      bitangents[56] = 1;
      bitangents[57] = 0;
      bitangents[58] = 0;
      bitangents[59] = 1;
      bitangents[60] = 0;
      bitangents[61] = 0;
      bitangents[62] = 1;
      bitangents[63] = 0;
      bitangents[64] = 0;
      bitangents[65] = 1;
      bitangents[66] = 0;
      bitangents[67] = 0;
      bitangents[68] = 1;
      bitangents[69] = 0;
      bitangents[70] = 0;
      bitangents[71] = 1;
      attributes.bitangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: bitangents
      });
    }
    indices2 = new Uint16Array(6 * 2 * 3);
    indices2[0] = 0;
    indices2[1] = 1;
    indices2[2] = 2;
    indices2[3] = 0;
    indices2[4] = 2;
    indices2[5] = 3;
    indices2[6] = 4 + 2;
    indices2[7] = 4 + 1;
    indices2[8] = 4 + 0;
    indices2[9] = 4 + 3;
    indices2[10] = 4 + 2;
    indices2[11] = 4 + 0;
    indices2[12] = 8 + 0;
    indices2[13] = 8 + 1;
    indices2[14] = 8 + 2;
    indices2[15] = 8 + 0;
    indices2[16] = 8 + 2;
    indices2[17] = 8 + 3;
    indices2[18] = 12 + 2;
    indices2[19] = 12 + 1;
    indices2[20] = 12 + 0;
    indices2[21] = 12 + 3;
    indices2[22] = 12 + 2;
    indices2[23] = 12 + 0;
    indices2[24] = 16 + 2;
    indices2[25] = 16 + 1;
    indices2[26] = 16 + 0;
    indices2[27] = 16 + 3;
    indices2[28] = 16 + 2;
    indices2[29] = 16 + 0;
    indices2[30] = 20 + 0;
    indices2[31] = 20 + 1;
    indices2[32] = 20 + 2;
    indices2[33] = 20 + 0;
    indices2[34] = 20 + 2;
    indices2[35] = 20 + 3;
  } else {
    positions = new Float64Array(8 * 3);
    positions[0] = min3.x;
    positions[1] = min3.y;
    positions[2] = min3.z;
    positions[3] = max3.x;
    positions[4] = min3.y;
    positions[5] = min3.z;
    positions[6] = max3.x;
    positions[7] = max3.y;
    positions[8] = min3.z;
    positions[9] = min3.x;
    positions[10] = max3.y;
    positions[11] = min3.z;
    positions[12] = min3.x;
    positions[13] = min3.y;
    positions[14] = max3.z;
    positions[15] = max3.x;
    positions[16] = min3.y;
    positions[17] = max3.z;
    positions[18] = max3.x;
    positions[19] = max3.y;
    positions[20] = max3.z;
    positions[21] = min3.x;
    positions[22] = max3.y;
    positions[23] = max3.z;
    attributes.position = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: positions
    });
    indices2 = new Uint16Array(6 * 2 * 3);
    indices2[0] = 4;
    indices2[1] = 5;
    indices2[2] = 6;
    indices2[3] = 4;
    indices2[4] = 6;
    indices2[5] = 7;
    indices2[6] = 1;
    indices2[7] = 0;
    indices2[8] = 3;
    indices2[9] = 1;
    indices2[10] = 3;
    indices2[11] = 2;
    indices2[12] = 1;
    indices2[13] = 6;
    indices2[14] = 5;
    indices2[15] = 1;
    indices2[16] = 2;
    indices2[17] = 6;
    indices2[18] = 2;
    indices2[19] = 3;
    indices2[20] = 7;
    indices2[21] = 2;
    indices2[22] = 7;
    indices2[23] = 6;
    indices2[24] = 3;
    indices2[25] = 0;
    indices2[26] = 4;
    indices2[27] = 3;
    indices2[28] = 4;
    indices2[29] = 7;
    indices2[30] = 0;
    indices2[31] = 1;
    indices2[32] = 5;
    indices2[33] = 0;
    indices2[34] = 5;
    indices2[35] = 4;
  }
  const diff = Cartesian3_default.subtract(max3, min3, diffScratch);
  const radius = Cartesian3_default.magnitude(diff) * 0.5;
  if (defined_default(boxGeometry._offsetAttribute)) {
    const length3 = positions.length;
    const applyOffset = new Uint8Array(length3 / 3);
    const offsetValue = boxGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
    arrayFill_default(applyOffset, offsetValue);
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: applyOffset
    });
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingSphere: new BoundingSphere_default(Cartesian3_default.ZERO, radius),
    offsetAttribute: boxGeometry._offsetAttribute
  });
};
var unitBoxGeometry;
BoxGeometry.getUnitBox = function() {
  if (!defined_default(unitBoxGeometry)) {
    unitBoxGeometry = BoxGeometry.createGeometry(
      BoxGeometry.fromDimensions({
        dimensions: new Cartesian3_default(1, 1, 1),
        vertexFormat: VertexFormat_default.POSITION_ONLY
      })
    );
  }
  return unitBoxGeometry;
};
var BoxGeometry_default = BoxGeometry;

// node_modules/cesium/Source/Core/BoxOutlineGeometry.js
var diffScratch2 = new Cartesian3_default();
function BoxOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const min3 = options.minimum;
  const max3 = options.maximum;
  Check_default.typeOf.object("min", min3);
  Check_default.typeOf.object("max", max3);
  if (defined_default(options.offsetAttribute) && options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
    throw new DeveloperError_default(
      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
    );
  }
  this._min = Cartesian3_default.clone(min3);
  this._max = Cartesian3_default.clone(max3);
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createBoxOutlineGeometry";
}
BoxOutlineGeometry.fromDimensions = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const dimensions = options.dimensions;
  Check_default.typeOf.object("dimensions", dimensions);
  Check_default.typeOf.number.greaterThanOrEquals("dimensions.x", dimensions.x, 0);
  Check_default.typeOf.number.greaterThanOrEquals("dimensions.y", dimensions.y, 0);
  Check_default.typeOf.number.greaterThanOrEquals("dimensions.z", dimensions.z, 0);
  const corner = Cartesian3_default.multiplyByScalar(dimensions, 0.5, new Cartesian3_default());
  return new BoxOutlineGeometry({
    minimum: Cartesian3_default.negate(corner, new Cartesian3_default()),
    maximum: corner,
    offsetAttribute: options.offsetAttribute
  });
};
BoxOutlineGeometry.fromAxisAlignedBoundingBox = function(boundingBox) {
  Check_default.typeOf.object("boundindBox", boundingBox);
  return new BoxOutlineGeometry({
    minimum: boundingBox.minimum,
    maximum: boundingBox.maximum
  });
};
BoxOutlineGeometry.packedLength = 2 * Cartesian3_default.packedLength + 1;
BoxOutlineGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  Cartesian3_default.pack(value._min, array, startingIndex);
  Cartesian3_default.pack(value._max, array, startingIndex + Cartesian3_default.packedLength);
  array[startingIndex + Cartesian3_default.packedLength * 2] = defaultValue_default(
    value._offsetAttribute,
    -1
  );
  return array;
};
var scratchMin2 = new Cartesian3_default();
var scratchMax2 = new Cartesian3_default();
var scratchOptions2 = {
  minimum: scratchMin2,
  maximum: scratchMax2,
  offsetAttribute: void 0
};
BoxOutlineGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const min3 = Cartesian3_default.unpack(array, startingIndex, scratchMin2);
  const max3 = Cartesian3_default.unpack(
    array,
    startingIndex + Cartesian3_default.packedLength,
    scratchMax2
  );
  const offsetAttribute = array[startingIndex + Cartesian3_default.packedLength * 2];
  if (!defined_default(result)) {
    scratchOptions2.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new BoxOutlineGeometry(scratchOptions2);
  }
  result._min = Cartesian3_default.clone(min3, result._min);
  result._max = Cartesian3_default.clone(max3, result._max);
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
BoxOutlineGeometry.createGeometry = function(boxGeometry) {
  const min3 = boxGeometry._min;
  const max3 = boxGeometry._max;
  if (Cartesian3_default.equals(min3, max3)) {
    return;
  }
  const attributes = new GeometryAttributes_default();
  const indices2 = new Uint16Array(12 * 2);
  const positions = new Float64Array(8 * 3);
  positions[0] = min3.x;
  positions[1] = min3.y;
  positions[2] = min3.z;
  positions[3] = max3.x;
  positions[4] = min3.y;
  positions[5] = min3.z;
  positions[6] = max3.x;
  positions[7] = max3.y;
  positions[8] = min3.z;
  positions[9] = min3.x;
  positions[10] = max3.y;
  positions[11] = min3.z;
  positions[12] = min3.x;
  positions[13] = min3.y;
  positions[14] = max3.z;
  positions[15] = max3.x;
  positions[16] = min3.y;
  positions[17] = max3.z;
  positions[18] = max3.x;
  positions[19] = max3.y;
  positions[20] = max3.z;
  positions[21] = min3.x;
  positions[22] = max3.y;
  positions[23] = max3.z;
  attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: positions
  });
  indices2[0] = 4;
  indices2[1] = 5;
  indices2[2] = 5;
  indices2[3] = 6;
  indices2[4] = 6;
  indices2[5] = 7;
  indices2[6] = 7;
  indices2[7] = 4;
  indices2[8] = 0;
  indices2[9] = 1;
  indices2[10] = 1;
  indices2[11] = 2;
  indices2[12] = 2;
  indices2[13] = 3;
  indices2[14] = 3;
  indices2[15] = 0;
  indices2[16] = 0;
  indices2[17] = 4;
  indices2[18] = 1;
  indices2[19] = 5;
  indices2[20] = 2;
  indices2[21] = 6;
  indices2[22] = 3;
  indices2[23] = 7;
  const diff = Cartesian3_default.subtract(max3, min3, diffScratch2);
  const radius = Cartesian3_default.magnitude(diff) * 0.5;
  if (defined_default(boxGeometry._offsetAttribute)) {
    const length3 = positions.length;
    const applyOffset = new Uint8Array(length3 / 3);
    const offsetValue = boxGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
    arrayFill_default(applyOffset, offsetValue);
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: applyOffset
    });
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere: new BoundingSphere_default(Cartesian3_default.ZERO, radius),
    offsetAttribute: boxGeometry._offsetAttribute
  });
};
var BoxOutlineGeometry_default = BoxOutlineGeometry;

// node_modules/cesium/Source/Core/CartographicGeocoderService.js
function CartographicGeocoderService() {
}
CartographicGeocoderService.prototype.geocode = function(query) {
  Check_default.typeOf.string("query", query);
  const splitQuery = query.match(/[^\s,\n]+/g);
  if (splitQuery.length === 2 || splitQuery.length === 3) {
    let longitude = +splitQuery[0];
    let latitude = +splitQuery[1];
    const height = splitQuery.length === 3 ? +splitQuery[2] : 300;
    if (isNaN(longitude) && isNaN(latitude)) {
      const coordTest = /^(\d+.?\d*)([nsew])/i;
      for (let i2 = 0; i2 < splitQuery.length; ++i2) {
        const splitCoord = splitQuery[i2].match(coordTest);
        if (coordTest.test(splitQuery[i2]) && splitCoord.length === 3) {
          if (/^[ns]/i.test(splitCoord[2])) {
            latitude = /^[n]/i.test(splitCoord[2]) ? +splitCoord[1] : -splitCoord[1];
          } else if (/^[ew]/i.test(splitCoord[2])) {
            longitude = /^[e]/i.test(splitCoord[2]) ? +splitCoord[1] : -splitCoord[1];
          }
        }
      }
    }
    if (!isNaN(longitude) && !isNaN(latitude) && !isNaN(height)) {
      const result = {
        displayName: query,
        destination: Cartesian3_default.fromDegrees(longitude, latitude, height)
      };
      return Promise.resolve([result]);
    }
  }
  return Promise.resolve([]);
};
var CartographicGeocoderService_default = CartographicGeocoderService;

// node_modules/cesium/Source/Core/Spline.js
function Spline() {
  this.times = void 0;
  this.points = void 0;
  DeveloperError_default.throwInstantiationError();
}
Spline.getPointType = function(point) {
  if (typeof point === "number") {
    return Number;
  }
  if (point instanceof Cartesian3_default) {
    return Cartesian3_default;
  }
  if (point instanceof Quaternion_default) {
    return Quaternion_default;
  }
  throw new DeveloperError_default(
    "point must be a Cartesian3, Quaternion, or Number."
  );
};
Spline.prototype.evaluate = DeveloperError_default.throwInstantiationError;
Spline.prototype.findTimeInterval = function(time, startIndex) {
  const times = this.times;
  const length3 = times.length;
  Check_default.typeOf.number("time", time);
  if (time < times[0] || time > times[length3 - 1]) {
    throw new DeveloperError_default("time is out of range.");
  }
  startIndex = defaultValue_default(startIndex, 0);
  if (time >= times[startIndex]) {
    if (startIndex + 1 < length3 && time < times[startIndex + 1]) {
      return startIndex;
    } else if (startIndex + 2 < length3 && time < times[startIndex + 2]) {
      return startIndex + 1;
    }
  } else if (startIndex - 1 >= 0 && time >= times[startIndex - 1]) {
    return startIndex - 1;
  }
  let i2;
  if (time > times[startIndex]) {
    for (i2 = startIndex; i2 < length3 - 1; ++i2) {
      if (time >= times[i2] && time < times[i2 + 1]) {
        break;
      }
    }
  } else {
    for (i2 = startIndex - 1; i2 >= 0; --i2) {
      if (time >= times[i2] && time < times[i2 + 1]) {
        break;
      }
    }
  }
  if (i2 === length3 - 1) {
    i2 = length3 - 2;
  }
  return i2;
};
Spline.prototype.wrapTime = function(time) {
  Check_default.typeOf.number("time", time);
  const times = this.times;
  const timeEnd = times[times.length - 1];
  const timeStart = times[0];
  const timeStretch = timeEnd - timeStart;
  let divs;
  if (time < timeStart) {
    divs = Math.floor((timeStart - time) / timeStretch) + 1;
    time += divs * timeStretch;
  }
  if (time > timeEnd) {
    divs = Math.floor((time - timeEnd) / timeStretch) + 1;
    time -= divs * timeStretch;
  }
  return time;
};
Spline.prototype.clampTime = function(time) {
  Check_default.typeOf.number("time", time);
  const times = this.times;
  return Math_default.clamp(time, times[0], times[times.length - 1]);
};
var Spline_default = Spline;

// node_modules/cesium/Source/Core/LinearSpline.js
function LinearSpline(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const points = options.points;
  const times = options.times;
  if (!defined_default(points) || !defined_default(times)) {
    throw new DeveloperError_default("points and times are required.");
  }
  if (points.length < 2) {
    throw new DeveloperError_default(
      "points.length must be greater than or equal to 2."
    );
  }
  if (times.length !== points.length) {
    throw new DeveloperError_default("times.length must be equal to points.length.");
  }
  this._times = times;
  this._points = points;
  this._pointType = Spline_default.getPointType(points[0]);
  this._lastTimeIndex = 0;
}
Object.defineProperties(LinearSpline.prototype, {
  times: {
    get: function() {
      return this._times;
    }
  },
  points: {
    get: function() {
      return this._points;
    }
  }
});
LinearSpline.prototype.findTimeInterval = Spline_default.prototype.findTimeInterval;
LinearSpline.prototype.wrapTime = Spline_default.prototype.wrapTime;
LinearSpline.prototype.clampTime = Spline_default.prototype.clampTime;
LinearSpline.prototype.evaluate = function(time, result) {
  const points = this.points;
  const times = this.times;
  const i2 = this._lastTimeIndex = this.findTimeInterval(
    time,
    this._lastTimeIndex
  );
  const u3 = (time - times[i2]) / (times[i2 + 1] - times[i2]);
  const PointType = this._pointType;
  if (PointType === Number) {
    return (1 - u3) * points[i2] + u3 * points[i2 + 1];
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  return Cartesian3_default.lerp(points[i2], points[i2 + 1], u3, result);
};
var LinearSpline_default = LinearSpline;

// node_modules/cesium/Source/Core/TridiagonalSystemSolver.js
var TridiagonalSystemSolver = {};
TridiagonalSystemSolver.solve = function(lower, diagonal, upper, right) {
  if (!defined_default(lower) || !(lower instanceof Array)) {
    throw new DeveloperError_default("The array lower is required.");
  }
  if (!defined_default(diagonal) || !(diagonal instanceof Array)) {
    throw new DeveloperError_default("The array diagonal is required.");
  }
  if (!defined_default(upper) || !(upper instanceof Array)) {
    throw new DeveloperError_default("The array upper is required.");
  }
  if (!defined_default(right) || !(right instanceof Array)) {
    throw new DeveloperError_default("The array right is required.");
  }
  if (diagonal.length !== right.length) {
    throw new DeveloperError_default("diagonal and right must have the same lengths.");
  }
  if (lower.length !== upper.length) {
    throw new DeveloperError_default("lower and upper must have the same lengths.");
  } else if (lower.length !== diagonal.length - 1) {
    throw new DeveloperError_default(
      "lower and upper must be one less than the length of diagonal."
    );
  }
  const c14 = new Array(upper.length);
  const d = new Array(right.length);
  const x = new Array(right.length);
  let i2;
  for (i2 = 0; i2 < d.length; i2++) {
    d[i2] = new Cartesian3_default();
    x[i2] = new Cartesian3_default();
  }
  c14[0] = upper[0] / diagonal[0];
  d[0] = Cartesian3_default.multiplyByScalar(right[0], 1 / diagonal[0], d[0]);
  let scalar;
  for (i2 = 1; i2 < c14.length; ++i2) {
    scalar = 1 / (diagonal[i2] - c14[i2 - 1] * lower[i2 - 1]);
    c14[i2] = upper[i2] * scalar;
    d[i2] = Cartesian3_default.subtract(
      right[i2],
      Cartesian3_default.multiplyByScalar(d[i2 - 1], lower[i2 - 1], d[i2]),
      d[i2]
    );
    d[i2] = Cartesian3_default.multiplyByScalar(d[i2], scalar, d[i2]);
  }
  scalar = 1 / (diagonal[i2] - c14[i2 - 1] * lower[i2 - 1]);
  d[i2] = Cartesian3_default.subtract(
    right[i2],
    Cartesian3_default.multiplyByScalar(d[i2 - 1], lower[i2 - 1], d[i2]),
    d[i2]
  );
  d[i2] = Cartesian3_default.multiplyByScalar(d[i2], scalar, d[i2]);
  x[x.length - 1] = d[d.length - 1];
  for (i2 = x.length - 2; i2 >= 0; --i2) {
    x[i2] = Cartesian3_default.subtract(
      d[i2],
      Cartesian3_default.multiplyByScalar(x[i2 + 1], c14[i2], x[i2]),
      x[i2]
    );
  }
  return x;
};
var TridiagonalSystemSolver_default = TridiagonalSystemSolver;

// node_modules/cesium/Source/Core/HermiteSpline.js
var scratchLower = [];
var scratchDiagonal = [];
var scratchUpper = [];
var scratchRight = [];
function generateClamped(points, firstTangent, lastTangent) {
  const l2 = scratchLower;
  const u3 = scratchUpper;
  const d = scratchDiagonal;
  const r2 = scratchRight;
  l2.length = u3.length = points.length - 1;
  d.length = r2.length = points.length;
  let i2;
  l2[0] = d[0] = 1;
  u3[0] = 0;
  let right = r2[0];
  if (!defined_default(right)) {
    right = r2[0] = new Cartesian3_default();
  }
  Cartesian3_default.clone(firstTangent, right);
  for (i2 = 1; i2 < l2.length - 1; ++i2) {
    l2[i2] = u3[i2] = 1;
    d[i2] = 4;
    right = r2[i2];
    if (!defined_default(right)) {
      right = r2[i2] = new Cartesian3_default();
    }
    Cartesian3_default.subtract(points[i2 + 1], points[i2 - 1], right);
    Cartesian3_default.multiplyByScalar(right, 3, right);
  }
  l2[i2] = 0;
  u3[i2] = 1;
  d[i2] = 4;
  right = r2[i2];
  if (!defined_default(right)) {
    right = r2[i2] = new Cartesian3_default();
  }
  Cartesian3_default.subtract(points[i2 + 1], points[i2 - 1], right);
  Cartesian3_default.multiplyByScalar(right, 3, right);
  d[i2 + 1] = 1;
  right = r2[i2 + 1];
  if (!defined_default(right)) {
    right = r2[i2 + 1] = new Cartesian3_default();
  }
  Cartesian3_default.clone(lastTangent, right);
  return TridiagonalSystemSolver_default.solve(l2, d, u3, r2);
}
function generateNatural(points) {
  const l2 = scratchLower;
  const u3 = scratchUpper;
  const d = scratchDiagonal;
  const r2 = scratchRight;
  l2.length = u3.length = points.length - 1;
  d.length = r2.length = points.length;
  let i2;
  l2[0] = u3[0] = 1;
  d[0] = 2;
  let right = r2[0];
  if (!defined_default(right)) {
    right = r2[0] = new Cartesian3_default();
  }
  Cartesian3_default.subtract(points[1], points[0], right);
  Cartesian3_default.multiplyByScalar(right, 3, right);
  for (i2 = 1; i2 < l2.length; ++i2) {
    l2[i2] = u3[i2] = 1;
    d[i2] = 4;
    right = r2[i2];
    if (!defined_default(right)) {
      right = r2[i2] = new Cartesian3_default();
    }
    Cartesian3_default.subtract(points[i2 + 1], points[i2 - 1], right);
    Cartesian3_default.multiplyByScalar(right, 3, right);
  }
  d[i2] = 2;
  right = r2[i2];
  if (!defined_default(right)) {
    right = r2[i2] = new Cartesian3_default();
  }
  Cartesian3_default.subtract(points[i2], points[i2 - 1], right);
  Cartesian3_default.multiplyByScalar(right, 3, right);
  return TridiagonalSystemSolver_default.solve(l2, d, u3, r2);
}
function HermiteSpline(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const points = options.points;
  const times = options.times;
  const inTangents = options.inTangents;
  const outTangents = options.outTangents;
  if (!defined_default(points) || !defined_default(times) || !defined_default(inTangents) || !defined_default(outTangents)) {
    throw new DeveloperError_default(
      "times, points, inTangents, and outTangents are required."
    );
  }
  if (points.length < 2) {
    throw new DeveloperError_default(
      "points.length must be greater than or equal to 2."
    );
  }
  if (times.length !== points.length) {
    throw new DeveloperError_default("times.length must be equal to points.length.");
  }
  if (inTangents.length !== outTangents.length || inTangents.length !== points.length - 1) {
    throw new DeveloperError_default(
      "inTangents and outTangents must have a length equal to points.length - 1."
    );
  }
  this._times = times;
  this._points = points;
  this._pointType = Spline_default.getPointType(points[0]);
  if (this._pointType !== Spline_default.getPointType(inTangents[0]) || this._pointType !== Spline_default.getPointType(outTangents[0])) {
    throw new DeveloperError_default(
      "inTangents and outTangents must be of the same type as points."
    );
  }
  this._inTangents = inTangents;
  this._outTangents = outTangents;
  this._lastTimeIndex = 0;
}
Object.defineProperties(HermiteSpline.prototype, {
  times: {
    get: function() {
      return this._times;
    }
  },
  points: {
    get: function() {
      return this._points;
    }
  },
  inTangents: {
    get: function() {
      return this._inTangents;
    }
  },
  outTangents: {
    get: function() {
      return this._outTangents;
    }
  }
});
HermiteSpline.createC1 = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const times = options.times;
  const points = options.points;
  const tangents = options.tangents;
  if (!defined_default(points) || !defined_default(times) || !defined_default(tangents)) {
    throw new DeveloperError_default("points, times and tangents are required.");
  }
  if (points.length < 2) {
    throw new DeveloperError_default(
      "points.length must be greater than or equal to 2."
    );
  }
  if (times.length !== points.length || times.length !== tangents.length) {
    throw new DeveloperError_default(
      "times, points and tangents must have the same length."
    );
  }
  const outTangents = tangents.slice(0, tangents.length - 1);
  const inTangents = tangents.slice(1, tangents.length);
  return new HermiteSpline({
    times,
    points,
    inTangents,
    outTangents
  });
};
HermiteSpline.createNaturalCubic = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const times = options.times;
  const points = options.points;
  if (!defined_default(points) || !defined_default(times)) {
    throw new DeveloperError_default("points and times are required.");
  }
  if (points.length < 2) {
    throw new DeveloperError_default(
      "points.length must be greater than or equal to 2."
    );
  }
  if (times.length !== points.length) {
    throw new DeveloperError_default("times.length must be equal to points.length.");
  }
  if (points.length < 3) {
    return new LinearSpline_default({
      points,
      times
    });
  }
  const tangents = generateNatural(points);
  const outTangents = tangents.slice(0, tangents.length - 1);
  const inTangents = tangents.slice(1, tangents.length);
  return new HermiteSpline({
    times,
    points,
    inTangents,
    outTangents
  });
};
HermiteSpline.createClampedCubic = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const times = options.times;
  const points = options.points;
  const firstTangent = options.firstTangent;
  const lastTangent = options.lastTangent;
  if (!defined_default(points) || !defined_default(times) || !defined_default(firstTangent) || !defined_default(lastTangent)) {
    throw new DeveloperError_default(
      "points, times, firstTangent and lastTangent are required."
    );
  }
  if (points.length < 2) {
    throw new DeveloperError_default(
      "points.length must be greater than or equal to 2."
    );
  }
  if (times.length !== points.length) {
    throw new DeveloperError_default("times.length must be equal to points.length.");
  }
  const PointType = Spline_default.getPointType(points[0]);
  if (PointType !== Spline_default.getPointType(firstTangent) || PointType !== Spline_default.getPointType(lastTangent)) {
    throw new DeveloperError_default(
      "firstTangent and lastTangent must be of the same type as points."
    );
  }
  if (points.length < 3) {
    return new LinearSpline_default({
      points,
      times
    });
  }
  const tangents = generateClamped(points, firstTangent, lastTangent);
  const outTangents = tangents.slice(0, tangents.length - 1);
  const inTangents = tangents.slice(1, tangents.length);
  return new HermiteSpline({
    times,
    points,
    inTangents,
    outTangents
  });
};
HermiteSpline.hermiteCoefficientMatrix = new Matrix4_default(
  2,
  -3,
  0,
  1,
  -2,
  3,
  0,
  0,
  1,
  -2,
  1,
  0,
  1,
  -1,
  0,
  0
);
HermiteSpline.prototype.findTimeInterval = Spline_default.prototype.findTimeInterval;
var scratchTimeVec = new Cartesian4_default();
var scratchTemp = new Cartesian3_default();
HermiteSpline.prototype.wrapTime = Spline_default.prototype.wrapTime;
HermiteSpline.prototype.clampTime = Spline_default.prototype.clampTime;
HermiteSpline.prototype.evaluate = function(time, result) {
  const points = this.points;
  const times = this.times;
  const inTangents = this.inTangents;
  const outTangents = this.outTangents;
  this._lastTimeIndex = this.findTimeInterval(time, this._lastTimeIndex);
  const i2 = this._lastTimeIndex;
  const timesDelta = times[i2 + 1] - times[i2];
  const u3 = (time - times[i2]) / timesDelta;
  const timeVec = scratchTimeVec;
  timeVec.z = u3;
  timeVec.y = u3 * u3;
  timeVec.x = timeVec.y * u3;
  timeVec.w = 1;
  const coefs = Matrix4_default.multiplyByVector(
    HermiteSpline.hermiteCoefficientMatrix,
    timeVec,
    timeVec
  );
  coefs.z *= timesDelta;
  coefs.w *= timesDelta;
  const PointType = this._pointType;
  if (PointType === Number) {
    return points[i2] * coefs.x + points[i2 + 1] * coefs.y + outTangents[i2] * coefs.z + inTangents[i2] * coefs.w;
  }
  if (!defined_default(result)) {
    result = new PointType();
  }
  result = PointType.multiplyByScalar(points[i2], coefs.x, result);
  PointType.multiplyByScalar(points[i2 + 1], coefs.y, scratchTemp);
  PointType.add(result, scratchTemp, result);
  PointType.multiplyByScalar(outTangents[i2], coefs.z, scratchTemp);
  PointType.add(result, scratchTemp, result);
  PointType.multiplyByScalar(inTangents[i2], coefs.w, scratchTemp);
  return PointType.add(result, scratchTemp, result);
};
var HermiteSpline_default = HermiteSpline;

// node_modules/cesium/Source/Core/CatmullRomSpline.js
var scratchTimeVec2 = new Cartesian4_default();
var scratchTemp0 = new Cartesian3_default();
var scratchTemp1 = new Cartesian3_default();
function createEvaluateFunction(spline) {
  const points = spline.points;
  const times = spline.times;
  if (points.length < 3) {
    const t0 = times[0];
    const invSpan = 1 / (times[1] - t0);
    const p0 = points[0];
    const p1 = points[1];
    return function(time, result) {
      if (!defined_default(result)) {
        result = new Cartesian3_default();
      }
      const u3 = (time - t0) * invSpan;
      return Cartesian3_default.lerp(p0, p1, u3, result);
    };
  }
  return function(time, result) {
    if (!defined_default(result)) {
      result = new Cartesian3_default();
    }
    const i2 = spline._lastTimeIndex = spline.findTimeInterval(
      time,
      spline._lastTimeIndex
    );
    const u3 = (time - times[i2]) / (times[i2 + 1] - times[i2]);
    const timeVec = scratchTimeVec2;
    timeVec.z = u3;
    timeVec.y = u3 * u3;
    timeVec.x = timeVec.y * u3;
    timeVec.w = 1;
    let p0;
    let p1;
    let p2;
    let p3;
    let coefs;
    if (i2 === 0) {
      p0 = points[0];
      p1 = points[1];
      p2 = spline.firstTangent;
      p3 = Cartesian3_default.subtract(points[2], p0, scratchTemp0);
      Cartesian3_default.multiplyByScalar(p3, 0.5, p3);
      coefs = Matrix4_default.multiplyByVector(
        HermiteSpline_default.hermiteCoefficientMatrix,
        timeVec,
        timeVec
      );
    } else if (i2 === points.length - 2) {
      p0 = points[i2];
      p1 = points[i2 + 1];
      p3 = spline.lastTangent;
      p2 = Cartesian3_default.subtract(p1, points[i2 - 1], scratchTemp0);
      Cartesian3_default.multiplyByScalar(p2, 0.5, p2);
      coefs = Matrix4_default.multiplyByVector(
        HermiteSpline_default.hermiteCoefficientMatrix,
        timeVec,
        timeVec
      );
    } else {
      p0 = points[i2 - 1];
      p1 = points[i2];
      p2 = points[i2 + 1];
      p3 = points[i2 + 2];
      coefs = Matrix4_default.multiplyByVector(
        CatmullRomSpline.catmullRomCoefficientMatrix,
        timeVec,
        timeVec
      );
    }
    result = Cartesian3_default.multiplyByScalar(p0, coefs.x, result);
    Cartesian3_default.multiplyByScalar(p1, coefs.y, scratchTemp1);
    Cartesian3_default.add(result, scratchTemp1, result);
    Cartesian3_default.multiplyByScalar(p2, coefs.z, scratchTemp1);
    Cartesian3_default.add(result, scratchTemp1, result);
    Cartesian3_default.multiplyByScalar(p3, coefs.w, scratchTemp1);
    return Cartesian3_default.add(result, scratchTemp1, result);
  };
}
var firstTangentScratch = new Cartesian3_default();
var lastTangentScratch = new Cartesian3_default();
function CatmullRomSpline(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const points = options.points;
  const times = options.times;
  let firstTangent = options.firstTangent;
  let lastTangent = options.lastTangent;
  Check_default.defined("points", points);
  Check_default.defined("times", times);
  Check_default.typeOf.number.greaterThanOrEquals("points.length", points.length, 2);
  Check_default.typeOf.number.equals(
    "times.length",
    "points.length",
    times.length,
    points.length
  );
  if (points.length > 2) {
    if (!defined_default(firstTangent)) {
      firstTangent = firstTangentScratch;
      Cartesian3_default.multiplyByScalar(points[1], 2, firstTangent);
      Cartesian3_default.subtract(firstTangent, points[2], firstTangent);
      Cartesian3_default.subtract(firstTangent, points[0], firstTangent);
      Cartesian3_default.multiplyByScalar(firstTangent, 0.5, firstTangent);
    }
    if (!defined_default(lastTangent)) {
      const n2 = points.length - 1;
      lastTangent = lastTangentScratch;
      Cartesian3_default.multiplyByScalar(points[n2 - 1], 2, lastTangent);
      Cartesian3_default.subtract(points[n2], lastTangent, lastTangent);
      Cartesian3_default.add(lastTangent, points[n2 - 2], lastTangent);
      Cartesian3_default.multiplyByScalar(lastTangent, 0.5, lastTangent);
    }
  }
  this._times = times;
  this._points = points;
  this._firstTangent = Cartesian3_default.clone(firstTangent);
  this._lastTangent = Cartesian3_default.clone(lastTangent);
  this._evaluateFunction = createEvaluateFunction(this);
  this._lastTimeIndex = 0;
}
Object.defineProperties(CatmullRomSpline.prototype, {
  times: {
    get: function() {
      return this._times;
    }
  },
  points: {
    get: function() {
      return this._points;
    }
  },
  firstTangent: {
    get: function() {
      return this._firstTangent;
    }
  },
  lastTangent: {
    get: function() {
      return this._lastTangent;
    }
  }
});
CatmullRomSpline.catmullRomCoefficientMatrix = new Matrix4_default(
  -0.5,
  1,
  -0.5,
  0,
  1.5,
  -2.5,
  0,
  1,
  -1.5,
  2,
  0.5,
  0,
  0.5,
  -0.5,
  0,
  0
);
CatmullRomSpline.prototype.findTimeInterval = Spline_default.prototype.findTimeInterval;
CatmullRomSpline.prototype.wrapTime = Spline_default.prototype.wrapTime;
CatmullRomSpline.prototype.clampTime = Spline_default.prototype.clampTime;
CatmullRomSpline.prototype.evaluate = function(time, result) {
  return this._evaluateFunction(time, result);
};
var CatmullRomSpline_default = CatmullRomSpline;

// node_modules/cesium/Source/Core/getStringFromTypedArray.js
function getStringFromTypedArray(uint8Array, byteOffset, byteLength) {
  if (!defined_default(uint8Array)) {
    throw new DeveloperError_default("uint8Array is required.");
  }
  if (byteOffset < 0) {
    throw new DeveloperError_default("byteOffset cannot be negative.");
  }
  if (byteLength < 0) {
    throw new DeveloperError_default("byteLength cannot be negative.");
  }
  if (byteOffset + byteLength > uint8Array.byteLength) {
    throw new DeveloperError_default("sub-region exceeds array bounds.");
  }
  byteOffset = defaultValue_default(byteOffset, 0);
  byteLength = defaultValue_default(byteLength, uint8Array.byteLength - byteOffset);
  uint8Array = uint8Array.subarray(byteOffset, byteOffset + byteLength);
  return getStringFromTypedArray.decode(uint8Array);
}
getStringFromTypedArray.decodeWithTextDecoder = function(view) {
  const decoder = new TextDecoder("utf-8");
  return decoder.decode(view);
};
getStringFromTypedArray.decodeWithFromCharCode = function(view) {
  let result = "";
  const codePoints = utf8Handler(view);
  const length3 = codePoints.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    let cp = codePoints[i2];
    if (cp <= 65535) {
      result += String.fromCharCode(cp);
    } else {
      cp -= 65536;
      result += String.fromCharCode((cp >> 10) + 55296, (cp & 1023) + 56320);
    }
  }
  return result;
};
function inRange(a4, min3, max3) {
  return min3 <= a4 && a4 <= max3;
}
function utf8Handler(utfBytes) {
  let codePoint = 0;
  let bytesSeen = 0;
  let bytesNeeded = 0;
  let lowerBoundary = 128;
  let upperBoundary = 191;
  const codePoints = [];
  const length3 = utfBytes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const currentByte = utfBytes[i2];
    if (bytesNeeded === 0) {
      if (inRange(currentByte, 0, 127)) {
        codePoints.push(currentByte);
        continue;
      }
      if (inRange(currentByte, 194, 223)) {
        bytesNeeded = 1;
        codePoint = currentByte & 31;
        continue;
      }
      if (inRange(currentByte, 224, 239)) {
        if (currentByte === 224) {
          lowerBoundary = 160;
        }
        if (currentByte === 237) {
          upperBoundary = 159;
        }
        bytesNeeded = 2;
        codePoint = currentByte & 15;
        continue;
      }
      if (inRange(currentByte, 240, 244)) {
        if (currentByte === 240) {
          lowerBoundary = 144;
        }
        if (currentByte === 244) {
          upperBoundary = 143;
        }
        bytesNeeded = 3;
        codePoint = currentByte & 7;
        continue;
      }
      throw new RuntimeError_default("String decoding failed.");
    }
    if (!inRange(currentByte, lowerBoundary, upperBoundary)) {
      codePoint = bytesNeeded = bytesSeen = 0;
      lowerBoundary = 128;
      upperBoundary = 191;
      --i2;
      continue;
    }
    lowerBoundary = 128;
    upperBoundary = 191;
    codePoint = codePoint << 6 | currentByte & 63;
    ++bytesSeen;
    if (bytesSeen === bytesNeeded) {
      codePoints.push(codePoint);
      codePoint = bytesNeeded = bytesSeen = 0;
    }
  }
  return codePoints;
}
if (typeof TextDecoder !== "undefined") {
  getStringFromTypedArray.decode = getStringFromTypedArray.decodeWithTextDecoder;
} else {
  getStringFromTypedArray.decode = getStringFromTypedArray.decodeWithFromCharCode;
}
var getStringFromTypedArray_default = getStringFromTypedArray;

// node_modules/cesium/Source/Core/getJsonFromTypedArray.js
function getJsonFromTypedArray(uint8Array, byteOffset, byteLength) {
  return JSON.parse(
    getStringFromTypedArray_default(uint8Array, byteOffset, byteLength)
  );
}
var getJsonFromTypedArray_default = getJsonFromTypedArray;

// node_modules/cesium/Source/Core/Intersections2D.js
var Intersections2D = {};
Intersections2D.clipTriangleAtAxisAlignedThreshold = function(threshold, keepAbove, u0, u12, u22, result) {
  if (!defined_default(threshold)) {
    throw new DeveloperError_default("threshold is required.");
  }
  if (!defined_default(keepAbove)) {
    throw new DeveloperError_default("keepAbove is required.");
  }
  if (!defined_default(u0)) {
    throw new DeveloperError_default("u0 is required.");
  }
  if (!defined_default(u12)) {
    throw new DeveloperError_default("u1 is required.");
  }
  if (!defined_default(u22)) {
    throw new DeveloperError_default("u2 is required.");
  }
  if (!defined_default(result)) {
    result = [];
  } else {
    result.length = 0;
  }
  let u0Behind;
  let u1Behind;
  let u2Behind;
  if (keepAbove) {
    u0Behind = u0 < threshold;
    u1Behind = u12 < threshold;
    u2Behind = u22 < threshold;
  } else {
    u0Behind = u0 > threshold;
    u1Behind = u12 > threshold;
    u2Behind = u22 > threshold;
  }
  const numBehind = u0Behind + u1Behind + u2Behind;
  let u01Ratio;
  let u02Ratio;
  let u12Ratio;
  let u10Ratio;
  let u20Ratio;
  let u21Ratio;
  if (numBehind === 1) {
    if (u0Behind) {
      u01Ratio = (threshold - u0) / (u12 - u0);
      u02Ratio = (threshold - u0) / (u22 - u0);
      result.push(1);
      result.push(2);
      if (u02Ratio !== 1) {
        result.push(-1);
        result.push(0);
        result.push(2);
        result.push(u02Ratio);
      }
      if (u01Ratio !== 1) {
        result.push(-1);
        result.push(0);
        result.push(1);
        result.push(u01Ratio);
      }
    } else if (u1Behind) {
      u12Ratio = (threshold - u12) / (u22 - u12);
      u10Ratio = (threshold - u12) / (u0 - u12);
      result.push(2);
      result.push(0);
      if (u10Ratio !== 1) {
        result.push(-1);
        result.push(1);
        result.push(0);
        result.push(u10Ratio);
      }
      if (u12Ratio !== 1) {
        result.push(-1);
        result.push(1);
        result.push(2);
        result.push(u12Ratio);
      }
    } else if (u2Behind) {
      u20Ratio = (threshold - u22) / (u0 - u22);
      u21Ratio = (threshold - u22) / (u12 - u22);
      result.push(0);
      result.push(1);
      if (u21Ratio !== 1) {
        result.push(-1);
        result.push(2);
        result.push(1);
        result.push(u21Ratio);
      }
      if (u20Ratio !== 1) {
        result.push(-1);
        result.push(2);
        result.push(0);
        result.push(u20Ratio);
      }
    }
  } else if (numBehind === 2) {
    if (!u0Behind && u0 !== threshold) {
      u10Ratio = (threshold - u12) / (u0 - u12);
      u20Ratio = (threshold - u22) / (u0 - u22);
      result.push(0);
      result.push(-1);
      result.push(1);
      result.push(0);
      result.push(u10Ratio);
      result.push(-1);
      result.push(2);
      result.push(0);
      result.push(u20Ratio);
    } else if (!u1Behind && u12 !== threshold) {
      u21Ratio = (threshold - u22) / (u12 - u22);
      u01Ratio = (threshold - u0) / (u12 - u0);
      result.push(1);
      result.push(-1);
      result.push(2);
      result.push(1);
      result.push(u21Ratio);
      result.push(-1);
      result.push(0);
      result.push(1);
      result.push(u01Ratio);
    } else if (!u2Behind && u22 !== threshold) {
      u02Ratio = (threshold - u0) / (u22 - u0);
      u12Ratio = (threshold - u12) / (u22 - u12);
      result.push(2);
      result.push(-1);
      result.push(0);
      result.push(2);
      result.push(u02Ratio);
      result.push(-1);
      result.push(1);
      result.push(2);
      result.push(u12Ratio);
    }
  } else if (numBehind !== 3) {
    result.push(0);
    result.push(1);
    result.push(2);
  }
  return result;
};
Intersections2D.computeBarycentricCoordinates = function(x, y, x1, y1, x2, y2, x3, y3, result) {
  if (!defined_default(x)) {
    throw new DeveloperError_default("x is required.");
  }
  if (!defined_default(y)) {
    throw new DeveloperError_default("y is required.");
  }
  if (!defined_default(x1)) {
    throw new DeveloperError_default("x1 is required.");
  }
  if (!defined_default(y1)) {
    throw new DeveloperError_default("y1 is required.");
  }
  if (!defined_default(x2)) {
    throw new DeveloperError_default("x2 is required.");
  }
  if (!defined_default(y2)) {
    throw new DeveloperError_default("y2 is required.");
  }
  if (!defined_default(x3)) {
    throw new DeveloperError_default("x3 is required.");
  }
  if (!defined_default(y3)) {
    throw new DeveloperError_default("y3 is required.");
  }
  const x1mx3 = x1 - x3;
  const x3mx2 = x3 - x2;
  const y2my3 = y2 - y3;
  const y1my3 = y1 - y3;
  const inverseDeterminant = 1 / (y2my3 * x1mx3 + x3mx2 * y1my3);
  const ymy3 = y - y3;
  const xmx3 = x - x3;
  const l1 = (y2my3 * xmx3 + x3mx2 * ymy3) * inverseDeterminant;
  const l2 = (-y1my3 * xmx3 + x1mx3 * ymy3) * inverseDeterminant;
  const l3 = 1 - l1 - l2;
  if (defined_default(result)) {
    result.x = l1;
    result.y = l2;
    result.z = l3;
    return result;
  }
  return new Cartesian3_default(l1, l2, l3);
};
Intersections2D.computeLineSegmentLineSegmentIntersection = function(x00, y00, x01, y01, x10, y10, x11, y11, result) {
  Check_default.typeOf.number("x00", x00);
  Check_default.typeOf.number("y00", y00);
  Check_default.typeOf.number("x01", x01);
  Check_default.typeOf.number("y01", y01);
  Check_default.typeOf.number("x10", x10);
  Check_default.typeOf.number("y10", y10);
  Check_default.typeOf.number("x11", x11);
  Check_default.typeOf.number("y11", y11);
  const numerator1A = (x11 - x10) * (y00 - y10) - (y11 - y10) * (x00 - x10);
  const numerator1B = (x01 - x00) * (y00 - y10) - (y01 - y00) * (x00 - x10);
  const denominator1 = (y11 - y10) * (x01 - x00) - (x11 - x10) * (y01 - y00);
  if (denominator1 === 0) {
    return;
  }
  const ua1 = numerator1A / denominator1;
  const ub1 = numerator1B / denominator1;
  if (ua1 >= 0 && ua1 <= 1 && ub1 >= 0 && ub1 <= 1) {
    if (!defined_default(result)) {
      result = new Cartesian2_default();
    }
    result.x = x00 + ua1 * (x01 - x00);
    result.y = y00 + ua1 * (y01 - y00);
    return result;
  }
};
var Intersections2D_default = Intersections2D;

// node_modules/cesium/Source/Core/QuantizedMeshTerrainData.js
function QuantizedMeshTerrainData(options) {
  if (!defined_default(options) || !defined_default(options.quantizedVertices)) {
    throw new DeveloperError_default("options.quantizedVertices is required.");
  }
  if (!defined_default(options.indices)) {
    throw new DeveloperError_default("options.indices is required.");
  }
  if (!defined_default(options.minimumHeight)) {
    throw new DeveloperError_default("options.minimumHeight is required.");
  }
  if (!defined_default(options.maximumHeight)) {
    throw new DeveloperError_default("options.maximumHeight is required.");
  }
  if (!defined_default(options.maximumHeight)) {
    throw new DeveloperError_default("options.maximumHeight is required.");
  }
  if (!defined_default(options.boundingSphere)) {
    throw new DeveloperError_default("options.boundingSphere is required.");
  }
  if (!defined_default(options.horizonOcclusionPoint)) {
    throw new DeveloperError_default("options.horizonOcclusionPoint is required.");
  }
  if (!defined_default(options.westIndices)) {
    throw new DeveloperError_default("options.westIndices is required.");
  }
  if (!defined_default(options.southIndices)) {
    throw new DeveloperError_default("options.southIndices is required.");
  }
  if (!defined_default(options.eastIndices)) {
    throw new DeveloperError_default("options.eastIndices is required.");
  }
  if (!defined_default(options.northIndices)) {
    throw new DeveloperError_default("options.northIndices is required.");
  }
  if (!defined_default(options.westSkirtHeight)) {
    throw new DeveloperError_default("options.westSkirtHeight is required.");
  }
  if (!defined_default(options.southSkirtHeight)) {
    throw new DeveloperError_default("options.southSkirtHeight is required.");
  }
  if (!defined_default(options.eastSkirtHeight)) {
    throw new DeveloperError_default("options.eastSkirtHeight is required.");
  }
  if (!defined_default(options.northSkirtHeight)) {
    throw new DeveloperError_default("options.northSkirtHeight is required.");
  }
  this._quantizedVertices = options.quantizedVertices;
  this._encodedNormals = options.encodedNormals;
  this._indices = options.indices;
  this._minimumHeight = options.minimumHeight;
  this._maximumHeight = options.maximumHeight;
  this._boundingSphere = options.boundingSphere;
  this._orientedBoundingBox = options.orientedBoundingBox;
  this._horizonOcclusionPoint = options.horizonOcclusionPoint;
  this._credits = options.credits;
  const vertexCount = this._quantizedVertices.length / 3;
  const uValues = this._uValues = this._quantizedVertices.subarray(
    0,
    vertexCount
  );
  const vValues = this._vValues = this._quantizedVertices.subarray(
    vertexCount,
    2 * vertexCount
  );
  this._heightValues = this._quantizedVertices.subarray(
    2 * vertexCount,
    3 * vertexCount
  );
  function sortByV(a4, b) {
    return vValues[a4] - vValues[b];
  }
  function sortByU(a4, b) {
    return uValues[a4] - uValues[b];
  }
  this._westIndices = sortIndicesIfNecessary(
    options.westIndices,
    sortByV,
    vertexCount
  );
  this._southIndices = sortIndicesIfNecessary(
    options.southIndices,
    sortByU,
    vertexCount
  );
  this._eastIndices = sortIndicesIfNecessary(
    options.eastIndices,
    sortByV,
    vertexCount
  );
  this._northIndices = sortIndicesIfNecessary(
    options.northIndices,
    sortByU,
    vertexCount
  );
  this._westSkirtHeight = options.westSkirtHeight;
  this._southSkirtHeight = options.southSkirtHeight;
  this._eastSkirtHeight = options.eastSkirtHeight;
  this._northSkirtHeight = options.northSkirtHeight;
  this._childTileMask = defaultValue_default(options.childTileMask, 15);
  this._createdByUpsampling = defaultValue_default(options.createdByUpsampling, false);
  this._waterMask = options.waterMask;
  this._mesh = void 0;
}
Object.defineProperties(QuantizedMeshTerrainData.prototype, {
  credits: {
    get: function() {
      return this._credits;
    }
  },
  waterMask: {
    get: function() {
      return this._waterMask;
    }
  },
  childTileMask: {
    get: function() {
      return this._childTileMask;
    }
  },
  canUpsample: {
    get: function() {
      return defined_default(this._mesh);
    }
  }
});
var arrayScratch = [];
function sortIndicesIfNecessary(indices2, sortFunction, vertexCount) {
  arrayScratch.length = indices2.length;
  let needsSort = false;
  for (let i2 = 0, len = indices2.length; i2 < len; ++i2) {
    arrayScratch[i2] = indices2[i2];
    needsSort = needsSort || i2 > 0 && sortFunction(indices2[i2 - 1], indices2[i2]) > 0;
  }
  if (needsSort) {
    arrayScratch.sort(sortFunction);
    return IndexDatatype_default.createTypedArray(vertexCount, arrayScratch);
  }
  return indices2;
}
var createMeshTaskName2 = "createVerticesFromQuantizedTerrainMesh";
var createMeshTaskProcessorNoThrottle2 = new TaskProcessor_default(createMeshTaskName2);
var createMeshTaskProcessorThrottle2 = new TaskProcessor_default(
  createMeshTaskName2,
  TerrainData_default.maximumAsynchronousTasks
);
QuantizedMeshTerrainData.prototype.createMesh = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.tilingScheme", options.tilingScheme);
  Check_default.typeOf.number("options.x", options.x);
  Check_default.typeOf.number("options.y", options.y);
  Check_default.typeOf.number("options.level", options.level);
  const tilingScheme2 = options.tilingScheme;
  const x = options.x;
  const y = options.y;
  const level = options.level;
  const exaggeration = defaultValue_default(options.exaggeration, 1);
  const exaggerationRelativeHeight = defaultValue_default(
    options.exaggerationRelativeHeight,
    0
  );
  const throttle = defaultValue_default(options.throttle, true);
  const ellipsoid = tilingScheme2.ellipsoid;
  const rectangle = tilingScheme2.tileXYToRectangle(x, y, level);
  const createMeshTaskProcessor = throttle ? createMeshTaskProcessorThrottle2 : createMeshTaskProcessorNoThrottle2;
  const verticesPromise = createMeshTaskProcessor.scheduleTask({
    minimumHeight: this._minimumHeight,
    maximumHeight: this._maximumHeight,
    quantizedVertices: this._quantizedVertices,
    octEncodedNormals: this._encodedNormals,
    includeWebMercatorT: true,
    indices: this._indices,
    westIndices: this._westIndices,
    southIndices: this._southIndices,
    eastIndices: this._eastIndices,
    northIndices: this._northIndices,
    westSkirtHeight: this._westSkirtHeight,
    southSkirtHeight: this._southSkirtHeight,
    eastSkirtHeight: this._eastSkirtHeight,
    northSkirtHeight: this._northSkirtHeight,
    rectangle,
    relativeToCenter: this._boundingSphere.center,
    ellipsoid,
    exaggeration,
    exaggerationRelativeHeight
  });
  if (!defined_default(verticesPromise)) {
    return void 0;
  }
  const that = this;
  return Promise.resolve(verticesPromise).then(function(result) {
    const vertexCountWithoutSkirts = that._quantizedVertices.length / 3;
    const vertexCount = vertexCountWithoutSkirts + that._westIndices.length + that._southIndices.length + that._eastIndices.length + that._northIndices.length;
    const indicesTypedArray = IndexDatatype_default.createTypedArray(
      vertexCount,
      result.indices
    );
    const vertices = new Float32Array(result.vertices);
    const rtc = result.center;
    const minimumHeight = result.minimumHeight;
    const maximumHeight = result.maximumHeight;
    const boundingSphere = that._boundingSphere;
    const obb = that._orientedBoundingBox;
    const occludeePointInScaledSpace = defaultValue_default(
      Cartesian3_default.clone(result.occludeePointInScaledSpace),
      that._horizonOcclusionPoint
    );
    const stride = result.vertexStride;
    const terrainEncoding = TerrainEncoding_default.clone(result.encoding);
    that._mesh = new TerrainMesh_default(
      rtc,
      vertices,
      indicesTypedArray,
      result.indexCountWithoutSkirts,
      vertexCountWithoutSkirts,
      minimumHeight,
      maximumHeight,
      boundingSphere,
      occludeePointInScaledSpace,
      stride,
      obb,
      terrainEncoding,
      result.westIndicesSouthToNorth,
      result.southIndicesEastToWest,
      result.eastIndicesNorthToSouth,
      result.northIndicesWestToEast
    );
    that._quantizedVertices = void 0;
    that._encodedNormals = void 0;
    that._indices = void 0;
    that._uValues = void 0;
    that._vValues = void 0;
    that._heightValues = void 0;
    that._westIndices = void 0;
    that._southIndices = void 0;
    that._eastIndices = void 0;
    that._northIndices = void 0;
    return that._mesh;
  });
};
var upsampleTaskProcessor = new TaskProcessor_default(
  "upsampleQuantizedTerrainMesh",
  TerrainData_default.maximumAsynchronousTasks
);
QuantizedMeshTerrainData.prototype.upsample = function(tilingScheme2, thisX, thisY, thisLevel, descendantX, descendantY, descendantLevel) {
  if (!defined_default(tilingScheme2)) {
    throw new DeveloperError_default("tilingScheme is required.");
  }
  if (!defined_default(thisX)) {
    throw new DeveloperError_default("thisX is required.");
  }
  if (!defined_default(thisY)) {
    throw new DeveloperError_default("thisY is required.");
  }
  if (!defined_default(thisLevel)) {
    throw new DeveloperError_default("thisLevel is required.");
  }
  if (!defined_default(descendantX)) {
    throw new DeveloperError_default("descendantX is required.");
  }
  if (!defined_default(descendantY)) {
    throw new DeveloperError_default("descendantY is required.");
  }
  if (!defined_default(descendantLevel)) {
    throw new DeveloperError_default("descendantLevel is required.");
  }
  const levelDifference = descendantLevel - thisLevel;
  if (levelDifference > 1) {
    throw new DeveloperError_default(
      "Upsampling through more than one level at a time is not currently supported."
    );
  }
  const mesh2 = this._mesh;
  if (!defined_default(this._mesh)) {
    return void 0;
  }
  const isEastChild = thisX * 2 !== descendantX;
  const isNorthChild = thisY * 2 === descendantY;
  const ellipsoid = tilingScheme2.ellipsoid;
  const childRectangle = tilingScheme2.tileXYToRectangle(
    descendantX,
    descendantY,
    descendantLevel
  );
  const upsamplePromise = upsampleTaskProcessor.scheduleTask({
    vertices: mesh2.vertices,
    vertexCountWithoutSkirts: mesh2.vertexCountWithoutSkirts,
    indices: mesh2.indices,
    indexCountWithoutSkirts: mesh2.indexCountWithoutSkirts,
    encoding: mesh2.encoding,
    minimumHeight: this._minimumHeight,
    maximumHeight: this._maximumHeight,
    isEastChild,
    isNorthChild,
    childRectangle,
    ellipsoid
  });
  if (!defined_default(upsamplePromise)) {
    return void 0;
  }
  let shortestSkirt = Math.min(this._westSkirtHeight, this._eastSkirtHeight);
  shortestSkirt = Math.min(shortestSkirt, this._southSkirtHeight);
  shortestSkirt = Math.min(shortestSkirt, this._northSkirtHeight);
  const westSkirtHeight = isEastChild ? shortestSkirt * 0.5 : this._westSkirtHeight;
  const southSkirtHeight = isNorthChild ? shortestSkirt * 0.5 : this._southSkirtHeight;
  const eastSkirtHeight = isEastChild ? this._eastSkirtHeight : shortestSkirt * 0.5;
  const northSkirtHeight = isNorthChild ? this._northSkirtHeight : shortestSkirt * 0.5;
  const credits = this._credits;
  return Promise.resolve(upsamplePromise).then(function(result) {
    const quantizedVertices = new Uint16Array(result.vertices);
    const indicesTypedArray = IndexDatatype_default.createTypedArray(
      quantizedVertices.length / 3,
      result.indices
    );
    let encodedNormals;
    if (defined_default(result.encodedNormals)) {
      encodedNormals = new Uint8Array(result.encodedNormals);
    }
    return new QuantizedMeshTerrainData({
      quantizedVertices,
      indices: indicesTypedArray,
      encodedNormals,
      minimumHeight: result.minimumHeight,
      maximumHeight: result.maximumHeight,
      boundingSphere: BoundingSphere_default.clone(result.boundingSphere),
      orientedBoundingBox: OrientedBoundingBox_default.clone(
        result.orientedBoundingBox
      ),
      horizonOcclusionPoint: Cartesian3_default.clone(result.horizonOcclusionPoint),
      westIndices: result.westIndices,
      southIndices: result.southIndices,
      eastIndices: result.eastIndices,
      northIndices: result.northIndices,
      westSkirtHeight,
      southSkirtHeight,
      eastSkirtHeight,
      northSkirtHeight,
      childTileMask: 0,
      credits,
      createdByUpsampling: true
    });
  });
};
var maxShort = 32767;
var barycentricCoordinateScratch = new Cartesian3_default();
QuantizedMeshTerrainData.prototype.interpolateHeight = function(rectangle, longitude, latitude) {
  let u3 = Math_default.clamp(
    (longitude - rectangle.west) / rectangle.width,
    0,
    1
  );
  u3 *= maxShort;
  let v7 = Math_default.clamp(
    (latitude - rectangle.south) / rectangle.height,
    0,
    1
  );
  v7 *= maxShort;
  if (!defined_default(this._mesh)) {
    return interpolateHeight2(this, u3, v7);
  }
  return interpolateMeshHeight2(this, u3, v7);
};
function pointInBoundingBox(u3, v7, u0, v02, u12, v13, u22, v23) {
  const minU = Math.min(u0, u12, u22);
  const maxU = Math.max(u0, u12, u22);
  const minV = Math.min(v02, v13, v23);
  const maxV = Math.max(v02, v13, v23);
  return u3 >= minU && u3 <= maxU && v7 >= minV && v7 <= maxV;
}
var texCoordScratch0 = new Cartesian2_default();
var texCoordScratch1 = new Cartesian2_default();
var texCoordScratch2 = new Cartesian2_default();
function interpolateMeshHeight2(terrainData, u3, v7) {
  const mesh2 = terrainData._mesh;
  const vertices = mesh2.vertices;
  const encoding = mesh2.encoding;
  const indices2 = mesh2.indices;
  for (let i2 = 0, len = indices2.length; i2 < len; i2 += 3) {
    const i0 = indices2[i2];
    const i1 = indices2[i2 + 1];
    const i22 = indices2[i2 + 2];
    const uv0 = encoding.decodeTextureCoordinates(
      vertices,
      i0,
      texCoordScratch0
    );
    const uv1 = encoding.decodeTextureCoordinates(
      vertices,
      i1,
      texCoordScratch1
    );
    const uv2 = encoding.decodeTextureCoordinates(
      vertices,
      i22,
      texCoordScratch2
    );
    if (pointInBoundingBox(u3, v7, uv0.x, uv0.y, uv1.x, uv1.y, uv2.x, uv2.y)) {
      const barycentric = Intersections2D_default.computeBarycentricCoordinates(
        u3,
        v7,
        uv0.x,
        uv0.y,
        uv1.x,
        uv1.y,
        uv2.x,
        uv2.y,
        barycentricCoordinateScratch
      );
      if (barycentric.x >= -1e-15 && barycentric.y >= -1e-15 && barycentric.z >= -1e-15) {
        const h0 = encoding.decodeHeight(vertices, i0);
        const h1 = encoding.decodeHeight(vertices, i1);
        const h2 = encoding.decodeHeight(vertices, i22);
        return barycentric.x * h0 + barycentric.y * h1 + barycentric.z * h2;
      }
    }
  }
  return void 0;
}
function interpolateHeight2(terrainData, u3, v7) {
  const uBuffer = terrainData._uValues;
  const vBuffer = terrainData._vValues;
  const heightBuffer = terrainData._heightValues;
  const indices2 = terrainData._indices;
  for (let i2 = 0, len = indices2.length; i2 < len; i2 += 3) {
    const i0 = indices2[i2];
    const i1 = indices2[i2 + 1];
    const i22 = indices2[i2 + 2];
    const u0 = uBuffer[i0];
    const u12 = uBuffer[i1];
    const u22 = uBuffer[i22];
    const v02 = vBuffer[i0];
    const v13 = vBuffer[i1];
    const v23 = vBuffer[i22];
    if (pointInBoundingBox(u3, v7, u0, v02, u12, v13, u22, v23)) {
      const barycentric = Intersections2D_default.computeBarycentricCoordinates(
        u3,
        v7,
        u0,
        v02,
        u12,
        v13,
        u22,
        v23,
        barycentricCoordinateScratch
      );
      if (barycentric.x >= -1e-15 && barycentric.y >= -1e-15 && barycentric.z >= -1e-15) {
        const quantizedHeight = barycentric.x * heightBuffer[i0] + barycentric.y * heightBuffer[i1] + barycentric.z * heightBuffer[i22];
        return Math_default.lerp(
          terrainData._minimumHeight,
          terrainData._maximumHeight,
          quantizedHeight / maxShort
        );
      }
    }
  }
  return void 0;
}
QuantizedMeshTerrainData.prototype.isChildAvailable = function(thisX, thisY, childX, childY) {
  if (!defined_default(thisX)) {
    throw new DeveloperError_default("thisX is required.");
  }
  if (!defined_default(thisY)) {
    throw new DeveloperError_default("thisY is required.");
  }
  if (!defined_default(childX)) {
    throw new DeveloperError_default("childX is required.");
  }
  if (!defined_default(childY)) {
    throw new DeveloperError_default("childY is required.");
  }
  let bitNumber = 2;
  if (childX !== thisX * 2) {
    ++bitNumber;
  }
  if (childY !== thisY * 2) {
    bitNumber -= 2;
  }
  return (this._childTileMask & 1 << bitNumber) !== 0;
};
QuantizedMeshTerrainData.prototype.wasCreatedByUpsampling = function() {
  return this._createdByUpsampling;
};
var QuantizedMeshTerrainData_default = QuantizedMeshTerrainData;

// node_modules/cesium/Source/Core/CesiumTerrainProvider.js
function LayerInformation(layer) {
  this.resource = layer.resource;
  this.version = layer.version;
  this.isHeightmap = layer.isHeightmap;
  this.tileUrlTemplates = layer.tileUrlTemplates;
  this.availability = layer.availability;
  this.hasVertexNormals = layer.hasVertexNormals;
  this.hasWaterMask = layer.hasWaterMask;
  this.hasMetadata = layer.hasMetadata;
  this.availabilityLevels = layer.availabilityLevels;
  this.availabilityTilesLoaded = layer.availabilityTilesLoaded;
  this.littleEndianExtensionSize = layer.littleEndianExtensionSize;
  this.availabilityPromiseCache = {};
}
function CesiumTerrainProvider(options) {
  if (!defined_default(options) || !defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  this._heightmapWidth = 65;
  this._heightmapStructure = void 0;
  this._hasWaterMask = false;
  this._hasVertexNormals = false;
  this._ellipsoid = options.ellipsoid;
  this._requestVertexNormals = defaultValue_default(
    options.requestVertexNormals,
    false
  );
  this._requestWaterMask = defaultValue_default(options.requestWaterMask, false);
  this._requestMetadata = defaultValue_default(options.requestMetadata, true);
  this._errorEvent = new Event_default();
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  this._credit = credit;
  this._availability = void 0;
  const deferred = defer_default();
  this._ready = false;
  this._readyPromise = deferred;
  this._tileCredits = void 0;
  const that = this;
  let lastResource;
  let layerJsonResource;
  let metadataError;
  const layers = this._layers = [];
  let attribution = "";
  const overallAvailability = [];
  let overallMaxZoom = 0;
  Promise.resolve(options.url).then(function(url2) {
    const resource = Resource_default.createIfNeeded(url2);
    resource.appendForwardSlash();
    lastResource = resource;
    layerJsonResource = lastResource.getDerivedResource({
      url: "layer.json"
    });
    that._tileCredits = resource.credits;
    requestLayerJson();
  }).catch(function(e2) {
    deferred.reject(e2);
  });
  function parseMetadataSuccess(data) {
    let message;
    if (!data.format) {
      message = "The tile format is not specified in the layer.json file.";
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        message,
        void 0,
        void 0,
        void 0,
        requestLayerJson
      );
      return;
    }
    if (!data.tiles || data.tiles.length === 0) {
      message = "The layer.json file does not specify any tile URL templates.";
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        message,
        void 0,
        void 0,
        void 0,
        requestLayerJson
      );
      return;
    }
    let hasVertexNormals = false;
    let hasWaterMask = false;
    let hasMetadata = false;
    let littleEndianExtensionSize = true;
    let isHeightmap = false;
    if (data.format === "heightmap-1.0") {
      isHeightmap = true;
      if (!defined_default(that._heightmapStructure)) {
        that._heightmapStructure = {
          heightScale: 1 / 5,
          heightOffset: -1e3,
          elementsPerHeight: 1,
          stride: 1,
          elementMultiplier: 256,
          isBigEndian: false,
          lowestEncodedHeight: 0,
          highestEncodedHeight: 256 * 256 - 1
        };
      }
      hasWaterMask = true;
      that._requestWaterMask = true;
    } else if (data.format.indexOf("quantized-mesh-1.") !== 0) {
      message = `The tile format "${data.format}" is invalid or not supported.`;
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        message,
        void 0,
        void 0,
        void 0,
        requestLayerJson
      );
      return;
    }
    const tileUrlTemplates = data.tiles;
    const maxZoom = data.maxzoom;
    overallMaxZoom = Math.max(overallMaxZoom, maxZoom);
    if (!data.projection || data.projection === "EPSG:4326") {
      that._tilingScheme = new GeographicTilingScheme_default({
        numberOfLevelZeroTilesX: 2,
        numberOfLevelZeroTilesY: 1,
        ellipsoid: that._ellipsoid
      });
    } else if (data.projection === "EPSG:3857") {
      that._tilingScheme = new WebMercatorTilingScheme_default({
        numberOfLevelZeroTilesX: 1,
        numberOfLevelZeroTilesY: 1,
        ellipsoid: that._ellipsoid
      });
    } else {
      message = `The projection "${data.projection}" is invalid or not supported.`;
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        message,
        void 0,
        void 0,
        void 0,
        requestLayerJson
      );
      return;
    }
    that._levelZeroMaximumGeometricError = TerrainProvider_default.getEstimatedLevelZeroGeometricErrorForAHeightmap(
      that._tilingScheme.ellipsoid,
      that._heightmapWidth,
      that._tilingScheme.getNumberOfXTilesAtLevel(0)
    );
    if (!data.scheme || data.scheme === "tms" || data.scheme === "slippyMap") {
      that._scheme = data.scheme;
    } else {
      message = `The scheme "${data.scheme}" is invalid or not supported.`;
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        message,
        void 0,
        void 0,
        void 0,
        requestLayerJson
      );
      return;
    }
    let availabilityTilesLoaded;
    if (defined_default(data.extensions) && data.extensions.indexOf("octvertexnormals") !== -1) {
      hasVertexNormals = true;
    } else if (defined_default(data.extensions) && data.extensions.indexOf("vertexnormals") !== -1) {
      hasVertexNormals = true;
      littleEndianExtensionSize = false;
    }
    if (defined_default(data.extensions) && data.extensions.indexOf("watermask") !== -1) {
      hasWaterMask = true;
    }
    if (defined_default(data.extensions) && data.extensions.indexOf("metadata") !== -1) {
      hasMetadata = true;
    }
    const availabilityLevels = data.metadataAvailability;
    const availableTiles = data.available;
    let availability;
    if (defined_default(availableTiles) && !defined_default(availabilityLevels)) {
      availability = new TileAvailability_default(
        that._tilingScheme,
        availableTiles.length
      );
      for (let level = 0; level < availableTiles.length; ++level) {
        const rangesAtLevel = availableTiles[level];
        const yTiles = that._tilingScheme.getNumberOfYTilesAtLevel(level);
        if (!defined_default(overallAvailability[level])) {
          overallAvailability[level] = [];
        }
        for (let rangeIndex = 0; rangeIndex < rangesAtLevel.length; ++rangeIndex) {
          const range2 = rangesAtLevel[rangeIndex];
          const yStart = yTiles - range2.endY - 1;
          const yEnd = yTiles - range2.startY - 1;
          overallAvailability[level].push([
            range2.startX,
            yStart,
            range2.endX,
            yEnd
          ]);
          availability.addAvailableTileRange(
            level,
            range2.startX,
            yStart,
            range2.endX,
            yEnd
          );
        }
      }
    } else if (defined_default(availabilityLevels)) {
      availabilityTilesLoaded = new TileAvailability_default(
        that._tilingScheme,
        maxZoom
      );
      availability = new TileAvailability_default(that._tilingScheme, maxZoom);
      overallAvailability[0] = [[0, 0, 1, 0]];
      availability.addAvailableTileRange(0, 0, 0, 1, 0);
    }
    that._hasWaterMask = that._hasWaterMask || hasWaterMask;
    that._hasVertexNormals = that._hasVertexNormals || hasVertexNormals;
    that._hasMetadata = that._hasMetadata || hasMetadata;
    if (defined_default(data.attribution)) {
      if (attribution.length > 0) {
        attribution += " ";
      }
      attribution += data.attribution;
    }
    layers.push(
      new LayerInformation({
        resource: lastResource,
        version: data.version,
        isHeightmap,
        tileUrlTemplates,
        availability,
        hasVertexNormals,
        hasWaterMask,
        hasMetadata,
        availabilityLevels,
        availabilityTilesLoaded,
        littleEndianExtensionSize
      })
    );
    const parentUrl = data.parentUrl;
    if (defined_default(parentUrl)) {
      if (!defined_default(availability)) {
        console.log(
          "A layer.json can't have a parentUrl if it does't have an available array."
        );
        return Promise.resolve();
      }
      lastResource = lastResource.getDerivedResource({
        url: parentUrl
      });
      lastResource.appendForwardSlash();
      layerJsonResource = lastResource.getDerivedResource({
        url: "layer.json"
      });
      const parentMetadata = layerJsonResource.fetchJson();
      return Promise.resolve(parentMetadata).then(parseMetadataSuccess).catch(parseMetadataFailure);
    }
    return Promise.resolve();
  }
  function parseMetadataFailure(data) {
    const message = `An error occurred while accessing ${layerJsonResource.url}.`;
    metadataError = TileProviderError_default.handleError(
      metadataError,
      that,
      that._errorEvent,
      message,
      void 0,
      void 0,
      void 0,
      requestLayerJson
    );
  }
  function metadataSuccess(data) {
    parseMetadataSuccess(data).then(function() {
      if (defined_default(metadataError)) {
        return;
      }
      const length3 = overallAvailability.length;
      if (length3 > 0) {
        const availability = that._availability = new TileAvailability_default(
          that._tilingScheme,
          overallMaxZoom
        );
        for (let level = 0; level < length3; ++level) {
          const levelRanges = overallAvailability[level];
          for (let i2 = 0; i2 < levelRanges.length; ++i2) {
            const range2 = levelRanges[i2];
            availability.addAvailableTileRange(
              level,
              range2[0],
              range2[1],
              range2[2],
              range2[3]
            );
          }
        }
      }
      if (attribution.length > 0) {
        const layerJsonCredit = new Credit_default(attribution);
        if (defined_default(that._tileCredits)) {
          that._tileCredits.push(layerJsonCredit);
        } else {
          that._tileCredits = [layerJsonCredit];
        }
      }
      that._ready = true;
      that._readyPromise.resolve(true);
    });
  }
  function metadataFailure(data) {
    if (defined_default(data) && data.statusCode === 404) {
      metadataSuccess({
        tilejson: "2.1.0",
        format: "heightmap-1.0",
        version: "1.0.0",
        scheme: "tms",
        tiles: ["{z}/{x}/{y}.terrain?v={version}"]
      });
      return;
    }
    parseMetadataFailure(data);
  }
  function requestLayerJson() {
    Promise.resolve(layerJsonResource.fetchJson()).then(metadataSuccess).catch(metadataFailure);
  }
}
var QuantizedMeshExtensionIds = {
  OCT_VERTEX_NORMALS: 1,
  WATER_MASK: 2,
  METADATA: 4
};
function getRequestHeader(extensionsList) {
  if (!defined_default(extensionsList) || extensionsList.length === 0) {
    return {
      Accept: "application/vnd.quantized-mesh,application/octet-stream;q=0.9,*/*;q=0.01"
    };
  }
  const extensions = extensionsList.join("-");
  return {
    Accept: `application/vnd.quantized-mesh;extensions=${extensions},application/octet-stream;q=0.9,*/*;q=0.01`
  };
}
function createHeightmapTerrainData(provider, buffer, level, x, y) {
  const heightBuffer = new Uint16Array(
    buffer,
    0,
    provider._heightmapWidth * provider._heightmapWidth
  );
  return new HeightmapTerrainData_default({
    buffer: heightBuffer,
    childTileMask: new Uint8Array(buffer, heightBuffer.byteLength, 1)[0],
    waterMask: new Uint8Array(
      buffer,
      heightBuffer.byteLength + 1,
      buffer.byteLength - heightBuffer.byteLength - 1
    ),
    width: provider._heightmapWidth,
    height: provider._heightmapWidth,
    structure: provider._heightmapStructure,
    credits: provider._tileCredits
  });
}
function createQuantizedMeshTerrainData(provider, buffer, level, x, y, layer) {
  const littleEndianExtensionSize = layer.littleEndianExtensionSize;
  let pos = 0;
  const cartesian3Elements = 3;
  const boundingSphereElements = cartesian3Elements + 1;
  const cartesian3Length = Float64Array.BYTES_PER_ELEMENT * cartesian3Elements;
  const boundingSphereLength = Float64Array.BYTES_PER_ELEMENT * boundingSphereElements;
  const encodedVertexElements = 3;
  const encodedVertexLength = Uint16Array.BYTES_PER_ELEMENT * encodedVertexElements;
  const triangleElements = 3;
  let bytesPerIndex = Uint16Array.BYTES_PER_ELEMENT;
  let triangleLength = bytesPerIndex * triangleElements;
  const view = new DataView(buffer);
  const center = new Cartesian3_default(
    view.getFloat64(pos, true),
    view.getFloat64(pos + 8, true),
    view.getFloat64(pos + 16, true)
  );
  pos += cartesian3Length;
  const minimumHeight = view.getFloat32(pos, true);
  pos += Float32Array.BYTES_PER_ELEMENT;
  const maximumHeight = view.getFloat32(pos, true);
  pos += Float32Array.BYTES_PER_ELEMENT;
  const boundingSphere = new BoundingSphere_default(
    new Cartesian3_default(
      view.getFloat64(pos, true),
      view.getFloat64(pos + 8, true),
      view.getFloat64(pos + 16, true)
    ),
    view.getFloat64(pos + cartesian3Length, true)
  );
  pos += boundingSphereLength;
  const horizonOcclusionPoint = new Cartesian3_default(
    view.getFloat64(pos, true),
    view.getFloat64(pos + 8, true),
    view.getFloat64(pos + 16, true)
  );
  pos += cartesian3Length;
  const vertexCount = view.getUint32(pos, true);
  pos += Uint32Array.BYTES_PER_ELEMENT;
  const encodedVertexBuffer = new Uint16Array(buffer, pos, vertexCount * 3);
  pos += vertexCount * encodedVertexLength;
  if (vertexCount > 64 * 1024) {
    bytesPerIndex = Uint32Array.BYTES_PER_ELEMENT;
    triangleLength = bytesPerIndex * triangleElements;
  }
  const uBuffer = encodedVertexBuffer.subarray(0, vertexCount);
  const vBuffer = encodedVertexBuffer.subarray(vertexCount, 2 * vertexCount);
  const heightBuffer = encodedVertexBuffer.subarray(
    vertexCount * 2,
    3 * vertexCount
  );
  AttributeCompression_default.zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer);
  if (pos % bytesPerIndex !== 0) {
    pos += bytesPerIndex - pos % bytesPerIndex;
  }
  const triangleCount = view.getUint32(pos, true);
  pos += Uint32Array.BYTES_PER_ELEMENT;
  const indices2 = IndexDatatype_default.createTypedArrayFromArrayBuffer(
    vertexCount,
    buffer,
    pos,
    triangleCount * triangleElements
  );
  pos += triangleCount * triangleLength;
  let highest = 0;
  const length3 = indices2.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const code = indices2[i2];
    indices2[i2] = highest - code;
    if (code === 0) {
      ++highest;
    }
  }
  const westVertexCount = view.getUint32(pos, true);
  pos += Uint32Array.BYTES_PER_ELEMENT;
  const westIndices = IndexDatatype_default.createTypedArrayFromArrayBuffer(
    vertexCount,
    buffer,
    pos,
    westVertexCount
  );
  pos += westVertexCount * bytesPerIndex;
  const southVertexCount = view.getUint32(pos, true);
  pos += Uint32Array.BYTES_PER_ELEMENT;
  const southIndices = IndexDatatype_default.createTypedArrayFromArrayBuffer(
    vertexCount,
    buffer,
    pos,
    southVertexCount
  );
  pos += southVertexCount * bytesPerIndex;
  const eastVertexCount = view.getUint32(pos, true);
  pos += Uint32Array.BYTES_PER_ELEMENT;
  const eastIndices = IndexDatatype_default.createTypedArrayFromArrayBuffer(
    vertexCount,
    buffer,
    pos,
    eastVertexCount
  );
  pos += eastVertexCount * bytesPerIndex;
  const northVertexCount = view.getUint32(pos, true);
  pos += Uint32Array.BYTES_PER_ELEMENT;
  const northIndices = IndexDatatype_default.createTypedArrayFromArrayBuffer(
    vertexCount,
    buffer,
    pos,
    northVertexCount
  );
  pos += northVertexCount * bytesPerIndex;
  let encodedNormalBuffer;
  let waterMaskBuffer;
  while (pos < view.byteLength) {
    const extensionId = view.getUint8(pos, true);
    pos += Uint8Array.BYTES_PER_ELEMENT;
    const extensionLength = view.getUint32(pos, littleEndianExtensionSize);
    pos += Uint32Array.BYTES_PER_ELEMENT;
    if (extensionId === QuantizedMeshExtensionIds.OCT_VERTEX_NORMALS && provider._requestVertexNormals) {
      encodedNormalBuffer = new Uint8Array(buffer, pos, vertexCount * 2);
    } else if (extensionId === QuantizedMeshExtensionIds.WATER_MASK && provider._requestWaterMask) {
      waterMaskBuffer = new Uint8Array(buffer, pos, extensionLength);
    } else if (extensionId === QuantizedMeshExtensionIds.METADATA && provider._requestMetadata) {
      const stringLength = view.getUint32(pos, true);
      if (stringLength > 0) {
        const metadata = getJsonFromTypedArray_default(
          new Uint8Array(buffer),
          pos + Uint32Array.BYTES_PER_ELEMENT,
          stringLength
        );
        const availableTiles = metadata.available;
        if (defined_default(availableTiles)) {
          for (let offset2 = 0; offset2 < availableTiles.length; ++offset2) {
            const availableLevel = level + offset2 + 1;
            const rangesAtLevel = availableTiles[offset2];
            const yTiles = provider._tilingScheme.getNumberOfYTilesAtLevel(
              availableLevel
            );
            for (let rangeIndex = 0; rangeIndex < rangesAtLevel.length; ++rangeIndex) {
              const range2 = rangesAtLevel[rangeIndex];
              const yStart = yTiles - range2.endY - 1;
              const yEnd = yTiles - range2.startY - 1;
              provider.availability.addAvailableTileRange(
                availableLevel,
                range2.startX,
                yStart,
                range2.endX,
                yEnd
              );
              layer.availability.addAvailableTileRange(
                availableLevel,
                range2.startX,
                yStart,
                range2.endX,
                yEnd
              );
            }
          }
        }
      }
      layer.availabilityTilesLoaded.addAvailableTileRange(level, x, y, x, y);
    }
    pos += extensionLength;
  }
  const skirtHeight = provider.getLevelMaximumGeometricError(level) * 5;
  const rectangle = provider._tilingScheme.tileXYToRectangle(x, y, level);
  const orientedBoundingBox = OrientedBoundingBox_default.fromRectangle(
    rectangle,
    minimumHeight,
    maximumHeight,
    provider._tilingScheme.ellipsoid
  );
  return new QuantizedMeshTerrainData_default({
    center,
    minimumHeight,
    maximumHeight,
    boundingSphere,
    orientedBoundingBox,
    horizonOcclusionPoint,
    quantizedVertices: encodedVertexBuffer,
    encodedNormals: encodedNormalBuffer,
    indices: indices2,
    westIndices,
    southIndices,
    eastIndices,
    northIndices,
    westSkirtHeight: skirtHeight,
    southSkirtHeight: skirtHeight,
    eastSkirtHeight: skirtHeight,
    northSkirtHeight: skirtHeight,
    childTileMask: provider.availability.computeChildMaskForTile(level, x, y),
    waterMask: waterMaskBuffer,
    credits: provider._tileCredits
  });
}
CesiumTerrainProvider.prototype.requestTileGeometry = function(x, y, level, request) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "requestTileGeometry must not be called before the terrain provider is ready."
    );
  }
  const layers = this._layers;
  let layerToUse;
  const layerCount = layers.length;
  if (layerCount === 1) {
    layerToUse = layers[0];
  } else {
    for (let i2 = 0; i2 < layerCount; ++i2) {
      const layer = layers[i2];
      if (!defined_default(layer.availability) || layer.availability.isTileAvailable(level, x, y)) {
        layerToUse = layer;
        break;
      }
    }
  }
  return requestTileGeometry(this, x, y, level, layerToUse, request);
};
function requestTileGeometry(provider, x, y, level, layerToUse, request) {
  if (!defined_default(layerToUse)) {
    return Promise.reject(new RuntimeError_default("Terrain tile doesn't exist"));
  }
  const urlTemplates = layerToUse.tileUrlTemplates;
  if (urlTemplates.length === 0) {
    return void 0;
  }
  let terrainY;
  if (!provider._scheme || provider._scheme === "tms") {
    const yTiles = provider._tilingScheme.getNumberOfYTilesAtLevel(level);
    terrainY = yTiles - y - 1;
  } else {
    terrainY = y;
  }
  const extensionList = [];
  if (provider._requestVertexNormals && layerToUse.hasVertexNormals) {
    extensionList.push(
      layerToUse.littleEndianExtensionSize ? "octvertexnormals" : "vertexnormals"
    );
  }
  if (provider._requestWaterMask && layerToUse.hasWaterMask) {
    extensionList.push("watermask");
  }
  if (provider._requestMetadata && layerToUse.hasMetadata) {
    extensionList.push("metadata");
  }
  let headers;
  let query;
  const url2 = urlTemplates[(x + terrainY + level) % urlTemplates.length];
  const resource = layerToUse.resource;
  if (defined_default(resource._ionEndpoint) && !defined_default(resource._ionEndpoint.externalType)) {
    if (extensionList.length !== 0) {
      query = { extensions: extensionList.join("-") };
    }
    headers = getRequestHeader(void 0);
  } else {
    headers = getRequestHeader(extensionList);
  }
  const promise = resource.getDerivedResource({
    url: url2,
    templateValues: {
      version: layerToUse.version,
      z: level,
      x,
      y: terrainY
    },
    queryParameters: query,
    headers,
    request
  }).fetchArrayBuffer();
  if (!defined_default(promise)) {
    return void 0;
  }
  return promise.then(function(buffer) {
    if (defined_default(provider._heightmapStructure)) {
      return createHeightmapTerrainData(provider, buffer, level, x, y);
    }
    return createQuantizedMeshTerrainData(
      provider,
      buffer,
      level,
      x,
      y,
      layerToUse
    );
  });
}
Object.defineProperties(CesiumTerrainProvider.prototype, {
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  credit: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "credit must not be called before the terrain provider is ready."
        );
      }
      return this._credit;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before the terrain provider is ready."
        );
      }
      return this._tilingScheme;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  hasWaterMask: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "hasWaterMask must not be called before the terrain provider is ready."
        );
      }
      return this._hasWaterMask && this._requestWaterMask;
    }
  },
  hasVertexNormals: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "hasVertexNormals must not be called before the terrain provider is ready."
        );
      }
      return this._hasVertexNormals && this._requestVertexNormals;
    }
  },
  hasMetadata: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "hasMetadata must not be called before the terrain provider is ready."
        );
      }
      return this._hasMetadata && this._requestMetadata;
    }
  },
  requestVertexNormals: {
    get: function() {
      return this._requestVertexNormals;
    }
  },
  requestWaterMask: {
    get: function() {
      return this._requestWaterMask;
    }
  },
  requestMetadata: {
    get: function() {
      return this._requestMetadata;
    }
  },
  availability: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "availability must not be called before the terrain provider is ready."
        );
      }
      return this._availability;
    }
  }
});
CesiumTerrainProvider.prototype.getLevelMaximumGeometricError = function(level) {
  return this._levelZeroMaximumGeometricError / (1 << level);
};
CesiumTerrainProvider.prototype.getTileDataAvailable = function(x, y, level) {
  if (!defined_default(this._availability)) {
    return void 0;
  }
  if (level > this._availability._maximumLevel) {
    return false;
  }
  if (this._availability.isTileAvailable(level, x, y)) {
    return true;
  }
  if (!this._hasMetadata) {
    return false;
  }
  const layers = this._layers;
  const count = layers.length;
  for (let i2 = 0; i2 < count; ++i2) {
    const layerResult = checkLayer(this, x, y, level, layers[i2], i2 === 0);
    if (layerResult.result) {
      return void 0;
    }
  }
  return false;
};
CesiumTerrainProvider.prototype.loadTileDataAvailability = function(x, y, level) {
  if (!defined_default(this._availability) || level > this._availability._maximumLevel || this._availability.isTileAvailable(level, x, y) || !this._hasMetadata) {
    return void 0;
  }
  const layers = this._layers;
  const count = layers.length;
  for (let i2 = 0; i2 < count; ++i2) {
    const layerResult = checkLayer(this, x, y, level, layers[i2], i2 === 0);
    if (defined_default(layerResult.promise)) {
      return layerResult.promise;
    }
  }
};
function getAvailabilityTile(layer, x, y, level) {
  if (level === 0) {
    return;
  }
  const availabilityLevels = layer.availabilityLevels;
  const parentLevel = level % availabilityLevels === 0 ? level - availabilityLevels : (level / availabilityLevels | 0) * availabilityLevels;
  const divisor = 1 << level - parentLevel;
  const parentX = x / divisor | 0;
  const parentY = y / divisor | 0;
  return {
    level: parentLevel,
    x: parentX,
    y: parentY
  };
}
function checkLayer(provider, x, y, level, layer, topLayer) {
  if (!defined_default(layer.availabilityLevels)) {
    return {
      result: false
    };
  }
  let cacheKey;
  const deleteFromCache = function() {
    delete layer.availabilityPromiseCache[cacheKey];
  };
  const availabilityTilesLoaded = layer.availabilityTilesLoaded;
  const availability = layer.availability;
  let tile = getAvailabilityTile(layer, x, y, level);
  while (defined_default(tile)) {
    if (availability.isTileAvailable(tile.level, tile.x, tile.y) && !availabilityTilesLoaded.isTileAvailable(tile.level, tile.x, tile.y)) {
      let requestPromise;
      if (!topLayer) {
        cacheKey = `${tile.level}-${tile.x}-${tile.y}`;
        requestPromise = layer.availabilityPromiseCache[cacheKey];
        if (!defined_default(requestPromise)) {
          const request = new Request_default({
            throttle: false,
            throttleByServer: true,
            type: RequestType_default.TERRAIN
          });
          requestPromise = requestTileGeometry(
            provider,
            tile.x,
            tile.y,
            tile.level,
            layer,
            request
          );
          if (defined_default(requestPromise)) {
            layer.availabilityPromiseCache[cacheKey] = requestPromise;
            requestPromise.then(deleteFromCache);
          }
        }
      }
      return {
        result: true,
        promise: requestPromise
      };
    }
    tile = getAvailabilityTile(layer, tile.x, tile.y, tile.level);
  }
  return {
    result: false
  };
}
CesiumTerrainProvider._getAvailabilityTile = getAvailabilityTile;
var CesiumTerrainProvider_default = CesiumTerrainProvider;

// node_modules/cesium/Source/Core/EllipseGeometryLibrary.js
var EllipseGeometryLibrary = {};
var rotAxis = new Cartesian3_default();
var tempVec = new Cartesian3_default();
var unitQuat = new Quaternion_default();
var rotMtx = new Matrix3_default();
function pointOnEllipsoid(theta, rotation, northVec, eastVec, aSqr, ab, bSqr, mag, unitPos, result) {
  const azimuth = theta + rotation;
  Cartesian3_default.multiplyByScalar(eastVec, Math.cos(azimuth), rotAxis);
  Cartesian3_default.multiplyByScalar(northVec, Math.sin(azimuth), tempVec);
  Cartesian3_default.add(rotAxis, tempVec, rotAxis);
  let cosThetaSquared = Math.cos(theta);
  cosThetaSquared = cosThetaSquared * cosThetaSquared;
  let sinThetaSquared = Math.sin(theta);
  sinThetaSquared = sinThetaSquared * sinThetaSquared;
  const radius = ab / Math.sqrt(bSqr * cosThetaSquared + aSqr * sinThetaSquared);
  const angle = radius / mag;
  Quaternion_default.fromAxisAngle(rotAxis, angle, unitQuat);
  Matrix3_default.fromQuaternion(unitQuat, rotMtx);
  Matrix3_default.multiplyByVector(rotMtx, unitPos, result);
  Cartesian3_default.normalize(result, result);
  Cartesian3_default.multiplyByScalar(result, mag, result);
  return result;
}
var scratchCartesian12 = new Cartesian3_default();
var scratchCartesian23 = new Cartesian3_default();
var scratchCartesian33 = new Cartesian3_default();
var scratchNormal2 = new Cartesian3_default();
EllipseGeometryLibrary.raisePositionsToHeight = function(positions, options, extrude) {
  const ellipsoid = options.ellipsoid;
  const height = options.height;
  const extrudedHeight = options.extrudedHeight;
  const size = extrude ? positions.length / 3 * 2 : positions.length / 3;
  const finalPositions = new Float64Array(size * 3);
  const length3 = positions.length;
  const bottomOffset = extrude ? length3 : 0;
  for (let i2 = 0; i2 < length3; i2 += 3) {
    const i1 = i2 + 1;
    const i22 = i2 + 2;
    const position = Cartesian3_default.fromArray(positions, i2, scratchCartesian12);
    ellipsoid.scaleToGeodeticSurface(position, position);
    const extrudedPosition = Cartesian3_default.clone(position, scratchCartesian23);
    const normal2 = ellipsoid.geodeticSurfaceNormal(position, scratchNormal2);
    const scaledNormal = Cartesian3_default.multiplyByScalar(
      normal2,
      height,
      scratchCartesian33
    );
    Cartesian3_default.add(position, scaledNormal, position);
    if (extrude) {
      Cartesian3_default.multiplyByScalar(normal2, extrudedHeight, scaledNormal);
      Cartesian3_default.add(extrudedPosition, scaledNormal, extrudedPosition);
      finalPositions[i2 + bottomOffset] = extrudedPosition.x;
      finalPositions[i1 + bottomOffset] = extrudedPosition.y;
      finalPositions[i22 + bottomOffset] = extrudedPosition.z;
    }
    finalPositions[i2] = position.x;
    finalPositions[i1] = position.y;
    finalPositions[i22] = position.z;
  }
  return finalPositions;
};
var unitPosScratch = new Cartesian3_default();
var eastVecScratch = new Cartesian3_default();
var northVecScratch = new Cartesian3_default();
EllipseGeometryLibrary.computeEllipsePositions = function(options, addFillPositions, addEdgePositions) {
  const semiMinorAxis = options.semiMinorAxis;
  const semiMajorAxis = options.semiMajorAxis;
  const rotation = options.rotation;
  const center = options.center;
  const granularity = options.granularity * 8;
  const aSqr = semiMinorAxis * semiMinorAxis;
  const bSqr = semiMajorAxis * semiMajorAxis;
  const ab = semiMajorAxis * semiMinorAxis;
  const mag = Cartesian3_default.magnitude(center);
  const unitPos = Cartesian3_default.normalize(center, unitPosScratch);
  let eastVec = Cartesian3_default.cross(Cartesian3_default.UNIT_Z, center, eastVecScratch);
  eastVec = Cartesian3_default.normalize(eastVec, eastVec);
  const northVec = Cartesian3_default.cross(unitPos, eastVec, northVecScratch);
  let numPts = 1 + Math.ceil(Math_default.PI_OVER_TWO / granularity);
  const deltaTheta = Math_default.PI_OVER_TWO / (numPts - 1);
  let theta = Math_default.PI_OVER_TWO - numPts * deltaTheta;
  if (theta < 0) {
    numPts -= Math.ceil(Math.abs(theta) / deltaTheta);
  }
  const size = 2 * (numPts * (numPts + 2));
  const positions = addFillPositions ? new Array(size * 3) : void 0;
  let positionIndex = 0;
  let position = scratchCartesian12;
  let reflectedPosition = scratchCartesian23;
  const outerPositionsLength = numPts * 4 * 3;
  let outerRightIndex = outerPositionsLength - 1;
  let outerLeftIndex = 0;
  const outerPositions = addEdgePositions ? new Array(outerPositionsLength) : void 0;
  let i2;
  let j;
  let numInterior;
  let t;
  let interiorPosition;
  theta = Math_default.PI_OVER_TWO;
  position = pointOnEllipsoid(
    theta,
    rotation,
    northVec,
    eastVec,
    aSqr,
    ab,
    bSqr,
    mag,
    unitPos,
    position
  );
  if (addFillPositions) {
    positions[positionIndex++] = position.x;
    positions[positionIndex++] = position.y;
    positions[positionIndex++] = position.z;
  }
  if (addEdgePositions) {
    outerPositions[outerRightIndex--] = position.z;
    outerPositions[outerRightIndex--] = position.y;
    outerPositions[outerRightIndex--] = position.x;
  }
  theta = Math_default.PI_OVER_TWO - deltaTheta;
  for (i2 = 1; i2 < numPts + 1; ++i2) {
    position = pointOnEllipsoid(
      theta,
      rotation,
      northVec,
      eastVec,
      aSqr,
      ab,
      bSqr,
      mag,
      unitPos,
      position
    );
    reflectedPosition = pointOnEllipsoid(
      Math.PI - theta,
      rotation,
      northVec,
      eastVec,
      aSqr,
      ab,
      bSqr,
      mag,
      unitPos,
      reflectedPosition
    );
    if (addFillPositions) {
      positions[positionIndex++] = position.x;
      positions[positionIndex++] = position.y;
      positions[positionIndex++] = position.z;
      numInterior = 2 * i2 + 2;
      for (j = 1; j < numInterior - 1; ++j) {
        t = j / (numInterior - 1);
        interiorPosition = Cartesian3_default.lerp(
          position,
          reflectedPosition,
          t,
          scratchCartesian33
        );
        positions[positionIndex++] = interiorPosition.x;
        positions[positionIndex++] = interiorPosition.y;
        positions[positionIndex++] = interiorPosition.z;
      }
      positions[positionIndex++] = reflectedPosition.x;
      positions[positionIndex++] = reflectedPosition.y;
      positions[positionIndex++] = reflectedPosition.z;
    }
    if (addEdgePositions) {
      outerPositions[outerRightIndex--] = position.z;
      outerPositions[outerRightIndex--] = position.y;
      outerPositions[outerRightIndex--] = position.x;
      outerPositions[outerLeftIndex++] = reflectedPosition.x;
      outerPositions[outerLeftIndex++] = reflectedPosition.y;
      outerPositions[outerLeftIndex++] = reflectedPosition.z;
    }
    theta = Math_default.PI_OVER_TWO - (i2 + 1) * deltaTheta;
  }
  for (i2 = numPts; i2 > 1; --i2) {
    theta = Math_default.PI_OVER_TWO - (i2 - 1) * deltaTheta;
    position = pointOnEllipsoid(
      -theta,
      rotation,
      northVec,
      eastVec,
      aSqr,
      ab,
      bSqr,
      mag,
      unitPos,
      position
    );
    reflectedPosition = pointOnEllipsoid(
      theta + Math.PI,
      rotation,
      northVec,
      eastVec,
      aSqr,
      ab,
      bSqr,
      mag,
      unitPos,
      reflectedPosition
    );
    if (addFillPositions) {
      positions[positionIndex++] = position.x;
      positions[positionIndex++] = position.y;
      positions[positionIndex++] = position.z;
      numInterior = 2 * (i2 - 1) + 2;
      for (j = 1; j < numInterior - 1; ++j) {
        t = j / (numInterior - 1);
        interiorPosition = Cartesian3_default.lerp(
          position,
          reflectedPosition,
          t,
          scratchCartesian33
        );
        positions[positionIndex++] = interiorPosition.x;
        positions[positionIndex++] = interiorPosition.y;
        positions[positionIndex++] = interiorPosition.z;
      }
      positions[positionIndex++] = reflectedPosition.x;
      positions[positionIndex++] = reflectedPosition.y;
      positions[positionIndex++] = reflectedPosition.z;
    }
    if (addEdgePositions) {
      outerPositions[outerRightIndex--] = position.z;
      outerPositions[outerRightIndex--] = position.y;
      outerPositions[outerRightIndex--] = position.x;
      outerPositions[outerLeftIndex++] = reflectedPosition.x;
      outerPositions[outerLeftIndex++] = reflectedPosition.y;
      outerPositions[outerLeftIndex++] = reflectedPosition.z;
    }
  }
  theta = Math_default.PI_OVER_TWO;
  position = pointOnEllipsoid(
    -theta,
    rotation,
    northVec,
    eastVec,
    aSqr,
    ab,
    bSqr,
    mag,
    unitPos,
    position
  );
  const r2 = {};
  if (addFillPositions) {
    positions[positionIndex++] = position.x;
    positions[positionIndex++] = position.y;
    positions[positionIndex++] = position.z;
    r2.positions = positions;
    r2.numPts = numPts;
  }
  if (addEdgePositions) {
    outerPositions[outerRightIndex--] = position.z;
    outerPositions[outerRightIndex--] = position.y;
    outerPositions[outerRightIndex--] = position.x;
    r2.outerPositions = outerPositions;
  }
  return r2;
};
var EllipseGeometryLibrary_default = EllipseGeometryLibrary;

// node_modules/cesium/Source/Core/GeometryInstance.js
function GeometryInstance(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.geometry)) {
    throw new DeveloperError_default("options.geometry is required.");
  }
  this.geometry = options.geometry;
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this.id = options.id;
  this.pickPrimitive = options.pickPrimitive;
  this.attributes = defaultValue_default(options.attributes, {});
  this.westHemisphereGeometry = void 0;
  this.eastHemisphereGeometry = void 0;
}
var GeometryInstance_default = GeometryInstance;

// node_modules/cesium/Source/Core/barycentricCoordinates.js
var scratchCartesian13 = new Cartesian3_default();
var scratchCartesian24 = new Cartesian3_default();
var scratchCartesian34 = new Cartesian3_default();
function barycentricCoordinates(point, p0, p1, p2, result) {
  Check_default.defined("point", point);
  Check_default.defined("p0", p0);
  Check_default.defined("p1", p1);
  Check_default.defined("p2", p2);
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  let v02;
  let v13;
  let v23;
  let dot00;
  let dot01;
  let dot02;
  let dot11;
  let dot12;
  if (!defined_default(p0.z)) {
    if (Cartesian2_default.equalsEpsilon(point, p0, Math_default.EPSILON14)) {
      return Cartesian3_default.clone(Cartesian3_default.UNIT_X, result);
    }
    if (Cartesian2_default.equalsEpsilon(point, p1, Math_default.EPSILON14)) {
      return Cartesian3_default.clone(Cartesian3_default.UNIT_Y, result);
    }
    if (Cartesian2_default.equalsEpsilon(point, p2, Math_default.EPSILON14)) {
      return Cartesian3_default.clone(Cartesian3_default.UNIT_Z, result);
    }
    v02 = Cartesian2_default.subtract(p1, p0, scratchCartesian13);
    v13 = Cartesian2_default.subtract(p2, p0, scratchCartesian24);
    v23 = Cartesian2_default.subtract(point, p0, scratchCartesian34);
    dot00 = Cartesian2_default.dot(v02, v02);
    dot01 = Cartesian2_default.dot(v02, v13);
    dot02 = Cartesian2_default.dot(v02, v23);
    dot11 = Cartesian2_default.dot(v13, v13);
    dot12 = Cartesian2_default.dot(v13, v23);
  } else {
    if (Cartesian3_default.equalsEpsilon(point, p0, Math_default.EPSILON14)) {
      return Cartesian3_default.clone(Cartesian3_default.UNIT_X, result);
    }
    if (Cartesian3_default.equalsEpsilon(point, p1, Math_default.EPSILON14)) {
      return Cartesian3_default.clone(Cartesian3_default.UNIT_Y, result);
    }
    if (Cartesian3_default.equalsEpsilon(point, p2, Math_default.EPSILON14)) {
      return Cartesian3_default.clone(Cartesian3_default.UNIT_Z, result);
    }
    v02 = Cartesian3_default.subtract(p1, p0, scratchCartesian13);
    v13 = Cartesian3_default.subtract(p2, p0, scratchCartesian24);
    v23 = Cartesian3_default.subtract(point, p0, scratchCartesian34);
    dot00 = Cartesian3_default.dot(v02, v02);
    dot01 = Cartesian3_default.dot(v02, v13);
    dot02 = Cartesian3_default.dot(v02, v23);
    dot11 = Cartesian3_default.dot(v13, v13);
    dot12 = Cartesian3_default.dot(v13, v23);
  }
  result.y = dot11 * dot02 - dot01 * dot12;
  result.z = dot00 * dot12 - dot01 * dot02;
  const q = dot00 * dot11 - dot01 * dot01;
  if (q === 0) {
    return void 0;
  }
  result.y /= q;
  result.z /= q;
  result.x = 1 - result.y - result.z;
  return result;
}
var barycentricCoordinates_default = barycentricCoordinates;

// node_modules/cesium/Source/Core/EncodedCartesian3.js
function EncodedCartesian3() {
  this.high = Cartesian3_default.clone(Cartesian3_default.ZERO);
  this.low = Cartesian3_default.clone(Cartesian3_default.ZERO);
}
EncodedCartesian3.encode = function(value, result) {
  Check_default.typeOf.number("value", value);
  if (!defined_default(result)) {
    result = {
      high: 0,
      low: 0
    };
  }
  let doubleHigh;
  if (value >= 0) {
    doubleHigh = Math.floor(value / 65536) * 65536;
    result.high = doubleHigh;
    result.low = value - doubleHigh;
  } else {
    doubleHigh = Math.floor(-value / 65536) * 65536;
    result.high = -doubleHigh;
    result.low = value + doubleHigh;
  }
  return result;
};
var scratchEncode = {
  high: 0,
  low: 0
};
EncodedCartesian3.fromCartesian = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  if (!defined_default(result)) {
    result = new EncodedCartesian3();
  }
  const high = result.high;
  const low = result.low;
  EncodedCartesian3.encode(cartesian11.x, scratchEncode);
  high.x = scratchEncode.high;
  low.x = scratchEncode.low;
  EncodedCartesian3.encode(cartesian11.y, scratchEncode);
  high.y = scratchEncode.high;
  low.y = scratchEncode.low;
  EncodedCartesian3.encode(cartesian11.z, scratchEncode);
  high.z = scratchEncode.high;
  low.z = scratchEncode.low;
  return result;
};
var encodedP = new EncodedCartesian3();
EncodedCartesian3.writeElements = function(cartesian11, cartesianArray, index2) {
  Check_default.defined("cartesianArray", cartesianArray);
  Check_default.typeOf.number("index", index2);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  EncodedCartesian3.fromCartesian(cartesian11, encodedP);
  const high = encodedP.high;
  const low = encodedP.low;
  cartesianArray[index2] = high.x;
  cartesianArray[index2 + 1] = high.y;
  cartesianArray[index2 + 2] = high.z;
  cartesianArray[index2 + 3] = low.x;
  cartesianArray[index2 + 4] = low.y;
  cartesianArray[index2 + 5] = low.z;
};
var EncodedCartesian3_default = EncodedCartesian3;

// node_modules/cesium/Source/Core/Tipsify.js
var Tipsify = {};
Tipsify.calculateACMR = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const indices2 = options.indices;
  let maximumIndex = options.maximumIndex;
  const cacheSize = defaultValue_default(options.cacheSize, 24);
  if (!defined_default(indices2)) {
    throw new DeveloperError_default("indices is required.");
  }
  const numIndices = indices2.length;
  if (numIndices < 3 || numIndices % 3 !== 0) {
    throw new DeveloperError_default("indices length must be a multiple of three.");
  }
  if (maximumIndex <= 0) {
    throw new DeveloperError_default("maximumIndex must be greater than zero.");
  }
  if (cacheSize < 3) {
    throw new DeveloperError_default("cacheSize must be greater than two.");
  }
  if (!defined_default(maximumIndex)) {
    maximumIndex = 0;
    let currentIndex = 0;
    let intoIndices = indices2[currentIndex];
    while (currentIndex < numIndices) {
      if (intoIndices > maximumIndex) {
        maximumIndex = intoIndices;
      }
      ++currentIndex;
      intoIndices = indices2[currentIndex];
    }
  }
  const vertexTimeStamps = [];
  for (let i2 = 0; i2 < maximumIndex + 1; i2++) {
    vertexTimeStamps[i2] = 0;
  }
  let s2 = cacheSize + 1;
  for (let j = 0; j < numIndices; ++j) {
    if (s2 - vertexTimeStamps[indices2[j]] > cacheSize) {
      vertexTimeStamps[indices2[j]] = s2;
      ++s2;
    }
  }
  return (s2 - cacheSize + 1) / (numIndices / 3);
};
Tipsify.tipsify = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const indices2 = options.indices;
  const maximumIndex = options.maximumIndex;
  const cacheSize = defaultValue_default(options.cacheSize, 24);
  let cursor;
  function skipDeadEnd(vertices2, deadEnd2, indices3, maximumIndexPlusOne2) {
    while (deadEnd2.length >= 1) {
      const d = deadEnd2[deadEnd2.length - 1];
      deadEnd2.splice(deadEnd2.length - 1, 1);
      if (vertices2[d].numLiveTriangles > 0) {
        return d;
      }
    }
    while (cursor < maximumIndexPlusOne2) {
      if (vertices2[cursor].numLiveTriangles > 0) {
        ++cursor;
        return cursor - 1;
      }
      ++cursor;
    }
    return -1;
  }
  function getNextVertex(indices3, cacheSize2, oneRing2, vertices2, s3, deadEnd2, maximumIndexPlusOne2) {
    let n2 = -1;
    let p2;
    let m = -1;
    let itOneRing = 0;
    while (itOneRing < oneRing2.length) {
      const index3 = oneRing2[itOneRing];
      if (vertices2[index3].numLiveTriangles) {
        p2 = 0;
        if (s3 - vertices2[index3].timeStamp + 2 * vertices2[index3].numLiveTriangles <= cacheSize2) {
          p2 = s3 - vertices2[index3].timeStamp;
        }
        if (p2 > m || m === -1) {
          m = p2;
          n2 = index3;
        }
      }
      ++itOneRing;
    }
    if (n2 === -1) {
      return skipDeadEnd(vertices2, deadEnd2, indices3, maximumIndexPlusOne2);
    }
    return n2;
  }
  if (!defined_default(indices2)) {
    throw new DeveloperError_default("indices is required.");
  }
  const numIndices = indices2.length;
  if (numIndices < 3 || numIndices % 3 !== 0) {
    throw new DeveloperError_default("indices length must be a multiple of three.");
  }
  if (maximumIndex <= 0) {
    throw new DeveloperError_default("maximumIndex must be greater than zero.");
  }
  if (cacheSize < 3) {
    throw new DeveloperError_default("cacheSize must be greater than two.");
  }
  let maximumIndexPlusOne = 0;
  let currentIndex = 0;
  let intoIndices = indices2[currentIndex];
  const endIndex = numIndices;
  if (defined_default(maximumIndex)) {
    maximumIndexPlusOne = maximumIndex + 1;
  } else {
    while (currentIndex < endIndex) {
      if (intoIndices > maximumIndexPlusOne) {
        maximumIndexPlusOne = intoIndices;
      }
      ++currentIndex;
      intoIndices = indices2[currentIndex];
    }
    if (maximumIndexPlusOne === -1) {
      return 0;
    }
    ++maximumIndexPlusOne;
  }
  const vertices = [];
  let i2;
  for (i2 = 0; i2 < maximumIndexPlusOne; i2++) {
    vertices[i2] = {
      numLiveTriangles: 0,
      timeStamp: 0,
      vertexTriangles: []
    };
  }
  currentIndex = 0;
  let triangle = 0;
  while (currentIndex < endIndex) {
    vertices[indices2[currentIndex]].vertexTriangles.push(triangle);
    ++vertices[indices2[currentIndex]].numLiveTriangles;
    vertices[indices2[currentIndex + 1]].vertexTriangles.push(triangle);
    ++vertices[indices2[currentIndex + 1]].numLiveTriangles;
    vertices[indices2[currentIndex + 2]].vertexTriangles.push(triangle);
    ++vertices[indices2[currentIndex + 2]].numLiveTriangles;
    ++triangle;
    currentIndex += 3;
  }
  let f2 = 0;
  let s2 = cacheSize + 1;
  cursor = 1;
  let oneRing = [];
  const deadEnd = [];
  let vertex;
  let intoVertices;
  let currentOutputIndex = 0;
  const outputIndices = [];
  const numTriangles = numIndices / 3;
  const triangleEmitted = [];
  for (i2 = 0; i2 < numTriangles; i2++) {
    triangleEmitted[i2] = false;
  }
  let index2;
  let limit;
  while (f2 !== -1) {
    oneRing = [];
    intoVertices = vertices[f2];
    limit = intoVertices.vertexTriangles.length;
    for (let k = 0; k < limit; ++k) {
      triangle = intoVertices.vertexTriangles[k];
      if (!triangleEmitted[triangle]) {
        triangleEmitted[triangle] = true;
        currentIndex = triangle + triangle + triangle;
        for (let j = 0; j < 3; ++j) {
          index2 = indices2[currentIndex];
          oneRing.push(index2);
          deadEnd.push(index2);
          outputIndices[currentOutputIndex] = index2;
          ++currentOutputIndex;
          vertex = vertices[index2];
          --vertex.numLiveTriangles;
          if (s2 - vertex.timeStamp > cacheSize) {
            vertex.timeStamp = s2;
            ++s2;
          }
          ++currentIndex;
        }
      }
    }
    f2 = getNextVertex(
      indices2,
      cacheSize,
      oneRing,
      vertices,
      s2,
      deadEnd,
      maximumIndexPlusOne
    );
  }
  return outputIndices;
};
var Tipsify_default = Tipsify;

// node_modules/cesium/Source/Core/GeometryPipeline.js
var GeometryPipeline = {};
function addTriangle(lines, index2, i0, i1, i2) {
  lines[index2++] = i0;
  lines[index2++] = i1;
  lines[index2++] = i1;
  lines[index2++] = i2;
  lines[index2++] = i2;
  lines[index2] = i0;
}
function trianglesToLines(triangles) {
  const count = triangles.length;
  const size = count / 3 * 6;
  const lines = IndexDatatype_default.createTypedArray(count, size);
  let index2 = 0;
  for (let i2 = 0; i2 < count; i2 += 3, index2 += 6) {
    addTriangle(lines, index2, triangles[i2], triangles[i2 + 1], triangles[i2 + 2]);
  }
  return lines;
}
function triangleStripToLines(triangles) {
  const count = triangles.length;
  if (count >= 3) {
    const size = (count - 2) * 6;
    const lines = IndexDatatype_default.createTypedArray(count, size);
    addTriangle(lines, 0, triangles[0], triangles[1], triangles[2]);
    let index2 = 6;
    for (let i2 = 3; i2 < count; ++i2, index2 += 6) {
      addTriangle(
        lines,
        index2,
        triangles[i2 - 1],
        triangles[i2],
        triangles[i2 - 2]
      );
    }
    return lines;
  }
  return new Uint16Array();
}
function triangleFanToLines(triangles) {
  if (triangles.length > 0) {
    const count = triangles.length - 1;
    const size = (count - 1) * 6;
    const lines = IndexDatatype_default.createTypedArray(count, size);
    const base = triangles[0];
    let index2 = 0;
    for (let i2 = 1; i2 < count; ++i2, index2 += 6) {
      addTriangle(lines, index2, base, triangles[i2], triangles[i2 + 1]);
    }
    return lines;
  }
  return new Uint16Array();
}
GeometryPipeline.toWireframe = function(geometry) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  const indices2 = geometry.indices;
  if (defined_default(indices2)) {
    switch (geometry.primitiveType) {
      case PrimitiveType_default.TRIANGLES:
        geometry.indices = trianglesToLines(indices2);
        break;
      case PrimitiveType_default.TRIANGLE_STRIP:
        geometry.indices = triangleStripToLines(indices2);
        break;
      case PrimitiveType_default.TRIANGLE_FAN:
        geometry.indices = triangleFanToLines(indices2);
        break;
      default:
        throw new DeveloperError_default(
          "geometry.primitiveType must be TRIANGLES, TRIANGLE_STRIP, or TRIANGLE_FAN."
        );
    }
    geometry.primitiveType = PrimitiveType_default.LINES;
  }
  return geometry;
};
GeometryPipeline.createLineSegmentsForVectors = function(geometry, attributeName, length3) {
  attributeName = defaultValue_default(attributeName, "normal");
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  if (!defined_default(geometry.attributes.position)) {
    throw new DeveloperError_default("geometry.attributes.position is required.");
  }
  if (!defined_default(geometry.attributes[attributeName])) {
    throw new DeveloperError_default(
      `geometry.attributes must have an attribute with the same name as the attributeName parameter, ${attributeName}.`
    );
  }
  length3 = defaultValue_default(length3, 1e4);
  const positions = geometry.attributes.position.values;
  const vectors = geometry.attributes[attributeName].values;
  const positionsLength = positions.length;
  const newPositions = new Float64Array(2 * positionsLength);
  let j = 0;
  for (let i2 = 0; i2 < positionsLength; i2 += 3) {
    newPositions[j++] = positions[i2];
    newPositions[j++] = positions[i2 + 1];
    newPositions[j++] = positions[i2 + 2];
    newPositions[j++] = positions[i2] + vectors[i2] * length3;
    newPositions[j++] = positions[i2 + 1] + vectors[i2 + 1] * length3;
    newPositions[j++] = positions[i2 + 2] + vectors[i2 + 2] * length3;
  }
  let newBoundingSphere;
  const bs = geometry.boundingSphere;
  if (defined_default(bs)) {
    newBoundingSphere = new BoundingSphere_default(bs.center, bs.radius + length3);
  }
  return new Geometry_default({
    attributes: {
      position: new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.DOUBLE,
        componentsPerAttribute: 3,
        values: newPositions
      })
    },
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere: newBoundingSphere
  });
};
GeometryPipeline.createAttributeLocations = function(geometry) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  const semantics = [
    "position",
    "positionHigh",
    "positionLow",
    "position3DHigh",
    "position3DLow",
    "position2DHigh",
    "position2DLow",
    "pickColor",
    "normal",
    "st",
    "tangent",
    "bitangent",
    "extrudeDirection",
    "compressedAttributes"
  ];
  const attributes = geometry.attributes;
  const indices2 = {};
  let j = 0;
  let i2;
  const len = semantics.length;
  for (i2 = 0; i2 < len; ++i2) {
    const semantic = semantics[i2];
    if (defined_default(attributes[semantic])) {
      indices2[semantic] = j++;
    }
  }
  for (const name in attributes) {
    if (attributes.hasOwnProperty(name) && !defined_default(indices2[name])) {
      indices2[name] = j++;
    }
  }
  return indices2;
};
GeometryPipeline.reorderForPreVertexCache = function(geometry) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  const numVertices = Geometry_default.computeNumberOfVertices(geometry);
  const indices2 = geometry.indices;
  if (defined_default(indices2)) {
    const indexCrossReferenceOldToNew = new Int32Array(numVertices);
    for (let i2 = 0; i2 < numVertices; i2++) {
      indexCrossReferenceOldToNew[i2] = -1;
    }
    const indicesIn = indices2;
    const numIndices = indicesIn.length;
    const indicesOut = IndexDatatype_default.createTypedArray(numVertices, numIndices);
    let intoIndicesIn = 0;
    let intoIndicesOut = 0;
    let nextIndex = 0;
    let tempIndex;
    while (intoIndicesIn < numIndices) {
      tempIndex = indexCrossReferenceOldToNew[indicesIn[intoIndicesIn]];
      if (tempIndex !== -1) {
        indicesOut[intoIndicesOut] = tempIndex;
      } else {
        tempIndex = indicesIn[intoIndicesIn];
        indexCrossReferenceOldToNew[tempIndex] = nextIndex;
        indicesOut[intoIndicesOut] = nextIndex;
        ++nextIndex;
      }
      ++intoIndicesIn;
      ++intoIndicesOut;
    }
    geometry.indices = indicesOut;
    const attributes = geometry.attributes;
    for (const property in attributes) {
      if (attributes.hasOwnProperty(property) && defined_default(attributes[property]) && defined_default(attributes[property].values)) {
        const attribute = attributes[property];
        const elementsIn = attribute.values;
        let intoElementsIn = 0;
        const numComponents = attribute.componentsPerAttribute;
        const elementsOut = ComponentDatatype_default.createTypedArray(
          attribute.componentDatatype,
          nextIndex * numComponents
        );
        while (intoElementsIn < numVertices) {
          const temp = indexCrossReferenceOldToNew[intoElementsIn];
          if (temp !== -1) {
            for (let j = 0; j < numComponents; j++) {
              elementsOut[numComponents * temp + j] = elementsIn[numComponents * intoElementsIn + j];
            }
          }
          ++intoElementsIn;
        }
        attribute.values = elementsOut;
      }
    }
  }
  return geometry;
};
GeometryPipeline.reorderForPostVertexCache = function(geometry, cacheCapacity) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  const indices2 = geometry.indices;
  if (geometry.primitiveType === PrimitiveType_default.TRIANGLES && defined_default(indices2)) {
    const numIndices = indices2.length;
    let maximumIndex = 0;
    for (let j = 0; j < numIndices; j++) {
      if (indices2[j] > maximumIndex) {
        maximumIndex = indices2[j];
      }
    }
    geometry.indices = Tipsify_default.tipsify({
      indices: indices2,
      maximumIndex,
      cacheSize: cacheCapacity
    });
  }
  return geometry;
};
function copyAttributesDescriptions(attributes) {
  const newAttributes = {};
  for (const attribute in attributes) {
    if (attributes.hasOwnProperty(attribute) && defined_default(attributes[attribute]) && defined_default(attributes[attribute].values)) {
      const attr = attributes[attribute];
      newAttributes[attribute] = new GeometryAttribute_default({
        componentDatatype: attr.componentDatatype,
        componentsPerAttribute: attr.componentsPerAttribute,
        normalize: attr.normalize,
        values: []
      });
    }
  }
  return newAttributes;
}
function copyVertex(destinationAttributes, sourceAttributes, index2) {
  for (const attribute in sourceAttributes) {
    if (sourceAttributes.hasOwnProperty(attribute) && defined_default(sourceAttributes[attribute]) && defined_default(sourceAttributes[attribute].values)) {
      const attr = sourceAttributes[attribute];
      for (let k = 0; k < attr.componentsPerAttribute; ++k) {
        destinationAttributes[attribute].values.push(
          attr.values[index2 * attr.componentsPerAttribute + k]
        );
      }
    }
  }
}
GeometryPipeline.fitToUnsignedShortIndices = function(geometry) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  if (defined_default(geometry.indices) && geometry.primitiveType !== PrimitiveType_default.TRIANGLES && geometry.primitiveType !== PrimitiveType_default.LINES && geometry.primitiveType !== PrimitiveType_default.POINTS) {
    throw new DeveloperError_default(
      "geometry.primitiveType must equal to PrimitiveType.TRIANGLES, PrimitiveType.LINES, or PrimitiveType.POINTS."
    );
  }
  const geometries = [];
  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
  if (defined_default(geometry.indices) && numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
    let oldToNewIndex = [];
    let newIndices = [];
    let currentIndex = 0;
    let newAttributes = copyAttributesDescriptions(geometry.attributes);
    const originalIndices = geometry.indices;
    const numberOfIndices = originalIndices.length;
    let indicesPerPrimitive;
    if (geometry.primitiveType === PrimitiveType_default.TRIANGLES) {
      indicesPerPrimitive = 3;
    } else if (geometry.primitiveType === PrimitiveType_default.LINES) {
      indicesPerPrimitive = 2;
    } else if (geometry.primitiveType === PrimitiveType_default.POINTS) {
      indicesPerPrimitive = 1;
    }
    for (let j = 0; j < numberOfIndices; j += indicesPerPrimitive) {
      for (let k = 0; k < indicesPerPrimitive; ++k) {
        const x = originalIndices[j + k];
        let i2 = oldToNewIndex[x];
        if (!defined_default(i2)) {
          i2 = currentIndex++;
          oldToNewIndex[x] = i2;
          copyVertex(newAttributes, geometry.attributes, x);
        }
        newIndices.push(i2);
      }
      if (currentIndex + indicesPerPrimitive >= Math_default.SIXTY_FOUR_KILOBYTES) {
        geometries.push(
          new Geometry_default({
            attributes: newAttributes,
            indices: newIndices,
            primitiveType: geometry.primitiveType,
            boundingSphere: geometry.boundingSphere,
            boundingSphereCV: geometry.boundingSphereCV
          })
        );
        oldToNewIndex = [];
        newIndices = [];
        currentIndex = 0;
        newAttributes = copyAttributesDescriptions(geometry.attributes);
      }
    }
    if (newIndices.length !== 0) {
      geometries.push(
        new Geometry_default({
          attributes: newAttributes,
          indices: newIndices,
          primitiveType: geometry.primitiveType,
          boundingSphere: geometry.boundingSphere,
          boundingSphereCV: geometry.boundingSphereCV
        })
      );
    }
  } else {
    geometries.push(geometry);
  }
  return geometries;
};
var scratchProjectTo2DCartesian3 = new Cartesian3_default();
var scratchProjectTo2DCartographic = new Cartographic_default();
GeometryPipeline.projectTo2D = function(geometry, attributeName, attributeName3D, attributeName2D, projection) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  if (!defined_default(attributeName)) {
    throw new DeveloperError_default("attributeName is required.");
  }
  if (!defined_default(attributeName3D)) {
    throw new DeveloperError_default("attributeName3D is required.");
  }
  if (!defined_default(attributeName2D)) {
    throw new DeveloperError_default("attributeName2D is required.");
  }
  if (!defined_default(geometry.attributes[attributeName])) {
    throw new DeveloperError_default(
      `geometry must have attribute matching the attributeName argument: ${attributeName}.`
    );
  }
  if (geometry.attributes[attributeName].componentDatatype !== ComponentDatatype_default.DOUBLE) {
    throw new DeveloperError_default(
      "The attribute componentDatatype must be ComponentDatatype.DOUBLE."
    );
  }
  const attribute = geometry.attributes[attributeName];
  projection = defined_default(projection) ? projection : new GeographicProjection_default();
  const ellipsoid = projection.ellipsoid;
  const values3D = attribute.values;
  const projectedValues = new Float64Array(values3D.length);
  let index2 = 0;
  for (let i2 = 0; i2 < values3D.length; i2 += 3) {
    const value = Cartesian3_default.fromArray(
      values3D,
      i2,
      scratchProjectTo2DCartesian3
    );
    const lonLat = ellipsoid.cartesianToCartographic(
      value,
      scratchProjectTo2DCartographic
    );
    if (!defined_default(lonLat)) {
      throw new DeveloperError_default(
        `Could not project point (${value.x}, ${value.y}, ${value.z}) to 2D.`
      );
    }
    const projectedLonLat = projection.project(
      lonLat,
      scratchProjectTo2DCartesian3
    );
    projectedValues[index2++] = projectedLonLat.x;
    projectedValues[index2++] = projectedLonLat.y;
    projectedValues[index2++] = projectedLonLat.z;
  }
  geometry.attributes[attributeName3D] = attribute;
  geometry.attributes[attributeName2D] = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: projectedValues
  });
  delete geometry.attributes[attributeName];
  return geometry;
};
var encodedResult = {
  high: 0,
  low: 0
};
GeometryPipeline.encodeAttribute = function(geometry, attributeName, attributeHighName, attributeLowName) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  if (!defined_default(attributeName)) {
    throw new DeveloperError_default("attributeName is required.");
  }
  if (!defined_default(attributeHighName)) {
    throw new DeveloperError_default("attributeHighName is required.");
  }
  if (!defined_default(attributeLowName)) {
    throw new DeveloperError_default("attributeLowName is required.");
  }
  if (!defined_default(geometry.attributes[attributeName])) {
    throw new DeveloperError_default(
      `geometry must have attribute matching the attributeName argument: ${attributeName}.`
    );
  }
  if (geometry.attributes[attributeName].componentDatatype !== ComponentDatatype_default.DOUBLE) {
    throw new DeveloperError_default(
      "The attribute componentDatatype must be ComponentDatatype.DOUBLE."
    );
  }
  const attribute = geometry.attributes[attributeName];
  const values = attribute.values;
  const length3 = values.length;
  const highValues = new Float32Array(length3);
  const lowValues = new Float32Array(length3);
  for (let i2 = 0; i2 < length3; ++i2) {
    EncodedCartesian3_default.encode(values[i2], encodedResult);
    highValues[i2] = encodedResult.high;
    lowValues[i2] = encodedResult.low;
  }
  const componentsPerAttribute = attribute.componentsPerAttribute;
  geometry.attributes[attributeHighName] = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute,
    values: highValues
  });
  geometry.attributes[attributeLowName] = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute,
    values: lowValues
  });
  delete geometry.attributes[attributeName];
  return geometry;
};
var scratchCartesian35 = new Cartesian3_default();
function transformPoint(matrix, attribute) {
  if (defined_default(attribute)) {
    const values = attribute.values;
    const length3 = values.length;
    for (let i2 = 0; i2 < length3; i2 += 3) {
      Cartesian3_default.unpack(values, i2, scratchCartesian35);
      Matrix4_default.multiplyByPoint(matrix, scratchCartesian35, scratchCartesian35);
      Cartesian3_default.pack(scratchCartesian35, values, i2);
    }
  }
}
function transformVector(matrix, attribute) {
  if (defined_default(attribute)) {
    const values = attribute.values;
    const length3 = values.length;
    for (let i2 = 0; i2 < length3; i2 += 3) {
      Cartesian3_default.unpack(values, i2, scratchCartesian35);
      Matrix3_default.multiplyByVector(matrix, scratchCartesian35, scratchCartesian35);
      scratchCartesian35 = Cartesian3_default.normalize(
        scratchCartesian35,
        scratchCartesian35
      );
      Cartesian3_default.pack(scratchCartesian35, values, i2);
    }
  }
}
var inverseTranspose = new Matrix4_default();
var normalMatrix = new Matrix3_default();
GeometryPipeline.transformToWorldCoordinates = function(instance) {
  if (!defined_default(instance)) {
    throw new DeveloperError_default("instance is required.");
  }
  const modelMatrix = instance.modelMatrix;
  if (Matrix4_default.equals(modelMatrix, Matrix4_default.IDENTITY)) {
    return instance;
  }
  const attributes = instance.geometry.attributes;
  transformPoint(modelMatrix, attributes.position);
  transformPoint(modelMatrix, attributes.prevPosition);
  transformPoint(modelMatrix, attributes.nextPosition);
  if (defined_default(attributes.normal) || defined_default(attributes.tangent) || defined_default(attributes.bitangent)) {
    Matrix4_default.inverse(modelMatrix, inverseTranspose);
    Matrix4_default.transpose(inverseTranspose, inverseTranspose);
    Matrix4_default.getMatrix3(inverseTranspose, normalMatrix);
    transformVector(normalMatrix, attributes.normal);
    transformVector(normalMatrix, attributes.tangent);
    transformVector(normalMatrix, attributes.bitangent);
  }
  const boundingSphere = instance.geometry.boundingSphere;
  if (defined_default(boundingSphere)) {
    instance.geometry.boundingSphere = BoundingSphere_default.transform(
      boundingSphere,
      modelMatrix,
      boundingSphere
    );
  }
  instance.modelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  return instance;
};
function findAttributesInAllGeometries(instances, propertyName) {
  const length3 = instances.length;
  const attributesInAllGeometries = {};
  const attributes0 = instances[0][propertyName].attributes;
  let name;
  for (name in attributes0) {
    if (attributes0.hasOwnProperty(name) && defined_default(attributes0[name]) && defined_default(attributes0[name].values)) {
      const attribute = attributes0[name];
      let numberOfComponents = attribute.values.length;
      let inAllGeometries = true;
      for (let i2 = 1; i2 < length3; ++i2) {
        const otherAttribute = instances[i2][propertyName].attributes[name];
        if (!defined_default(otherAttribute) || attribute.componentDatatype !== otherAttribute.componentDatatype || attribute.componentsPerAttribute !== otherAttribute.componentsPerAttribute || attribute.normalize !== otherAttribute.normalize) {
          inAllGeometries = false;
          break;
        }
        numberOfComponents += otherAttribute.values.length;
      }
      if (inAllGeometries) {
        attributesInAllGeometries[name] = new GeometryAttribute_default({
          componentDatatype: attribute.componentDatatype,
          componentsPerAttribute: attribute.componentsPerAttribute,
          normalize: attribute.normalize,
          values: ComponentDatatype_default.createTypedArray(
            attribute.componentDatatype,
            numberOfComponents
          )
        });
      }
    }
  }
  return attributesInAllGeometries;
}
var tempScratch = new Cartesian3_default();
function combineGeometries(instances, propertyName) {
  const length3 = instances.length;
  let name;
  let i2;
  let j;
  let k;
  const m = instances[0].modelMatrix;
  const haveIndices = defined_default(instances[0][propertyName].indices);
  const primitiveType = instances[0][propertyName].primitiveType;
  for (i2 = 1; i2 < length3; ++i2) {
    if (!Matrix4_default.equals(instances[i2].modelMatrix, m)) {
      throw new DeveloperError_default("All instances must have the same modelMatrix.");
    }
    if (defined_default(instances[i2][propertyName].indices) !== haveIndices) {
      throw new DeveloperError_default(
        "All instance geometries must have an indices or not have one."
      );
    }
    if (instances[i2][propertyName].primitiveType !== primitiveType) {
      throw new DeveloperError_default(
        "All instance geometries must have the same primitiveType."
      );
    }
  }
  const attributes = findAttributesInAllGeometries(instances, propertyName);
  let values;
  let sourceValues;
  let sourceValuesLength;
  for (name in attributes) {
    if (attributes.hasOwnProperty(name)) {
      values = attributes[name].values;
      k = 0;
      for (i2 = 0; i2 < length3; ++i2) {
        sourceValues = instances[i2][propertyName].attributes[name].values;
        sourceValuesLength = sourceValues.length;
        for (j = 0; j < sourceValuesLength; ++j) {
          values[k++] = sourceValues[j];
        }
      }
    }
  }
  let indices2;
  if (haveIndices) {
    let numberOfIndices = 0;
    for (i2 = 0; i2 < length3; ++i2) {
      numberOfIndices += instances[i2][propertyName].indices.length;
    }
    const numberOfVertices = Geometry_default.computeNumberOfVertices(
      new Geometry_default({
        attributes,
        primitiveType: PrimitiveType_default.POINTS
      })
    );
    const destIndices = IndexDatatype_default.createTypedArray(
      numberOfVertices,
      numberOfIndices
    );
    let destOffset = 0;
    let offset2 = 0;
    for (i2 = 0; i2 < length3; ++i2) {
      const sourceIndices = instances[i2][propertyName].indices;
      const sourceIndicesLen = sourceIndices.length;
      for (k = 0; k < sourceIndicesLen; ++k) {
        destIndices[destOffset++] = offset2 + sourceIndices[k];
      }
      offset2 += Geometry_default.computeNumberOfVertices(instances[i2][propertyName]);
    }
    indices2 = destIndices;
  }
  let center = new Cartesian3_default();
  let radius = 0;
  let bs;
  for (i2 = 0; i2 < length3; ++i2) {
    bs = instances[i2][propertyName].boundingSphere;
    if (!defined_default(bs)) {
      center = void 0;
      break;
    }
    Cartesian3_default.add(bs.center, center, center);
  }
  if (defined_default(center)) {
    Cartesian3_default.divideByScalar(center, length3, center);
    for (i2 = 0; i2 < length3; ++i2) {
      bs = instances[i2][propertyName].boundingSphere;
      const tempRadius = Cartesian3_default.magnitude(
        Cartesian3_default.subtract(bs.center, center, tempScratch)
      ) + bs.radius;
      if (tempRadius > radius) {
        radius = tempRadius;
      }
    }
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType,
    boundingSphere: defined_default(center) ? new BoundingSphere_default(center, radius) : void 0
  });
}
GeometryPipeline.combineInstances = function(instances) {
  if (!defined_default(instances) || instances.length < 1) {
    throw new DeveloperError_default(
      "instances is required and must have length greater than zero."
    );
  }
  const instanceGeometry = [];
  const instanceSplitGeometry = [];
  const length3 = instances.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const instance = instances[i2];
    if (defined_default(instance.geometry)) {
      instanceGeometry.push(instance);
    } else if (defined_default(instance.westHemisphereGeometry) && defined_default(instance.eastHemisphereGeometry)) {
      instanceSplitGeometry.push(instance);
    }
  }
  const geometries = [];
  if (instanceGeometry.length > 0) {
    geometries.push(combineGeometries(instanceGeometry, "geometry"));
  }
  if (instanceSplitGeometry.length > 0) {
    geometries.push(
      combineGeometries(instanceSplitGeometry, "westHemisphereGeometry")
    );
    geometries.push(
      combineGeometries(instanceSplitGeometry, "eastHemisphereGeometry")
    );
  }
  return geometries;
};
var normal = new Cartesian3_default();
var v0 = new Cartesian3_default();
var v1 = new Cartesian3_default();
var v2 = new Cartesian3_default();
GeometryPipeline.computeNormal = function(geometry) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  if (!defined_default(geometry.attributes.position) || !defined_default(geometry.attributes.position.values)) {
    throw new DeveloperError_default(
      "geometry.attributes.position.values is required."
    );
  }
  if (!defined_default(geometry.indices)) {
    throw new DeveloperError_default("geometry.indices is required.");
  }
  if (geometry.indices.length < 2 || geometry.indices.length % 3 !== 0) {
    throw new DeveloperError_default(
      "geometry.indices length must be greater than 0 and be a multiple of 3."
    );
  }
  if (geometry.primitiveType !== PrimitiveType_default.TRIANGLES) {
    throw new DeveloperError_default(
      "geometry.primitiveType must be PrimitiveType.TRIANGLES."
    );
  }
  const indices2 = geometry.indices;
  const attributes = geometry.attributes;
  const vertices = attributes.position.values;
  const numVertices = attributes.position.values.length / 3;
  const numIndices = indices2.length;
  const normalsPerVertex = new Array(numVertices);
  const normalsPerTriangle = new Array(numIndices / 3);
  const normalIndices = new Array(numIndices);
  let i2;
  for (i2 = 0; i2 < numVertices; i2++) {
    normalsPerVertex[i2] = {
      indexOffset: 0,
      count: 0,
      currentCount: 0
    };
  }
  let j = 0;
  for (i2 = 0; i2 < numIndices; i2 += 3) {
    const i0 = indices2[i2];
    const i1 = indices2[i2 + 1];
    const i22 = indices2[i2 + 2];
    const i03 = i0 * 3;
    const i13 = i1 * 3;
    const i23 = i22 * 3;
    v0.x = vertices[i03];
    v0.y = vertices[i03 + 1];
    v0.z = vertices[i03 + 2];
    v1.x = vertices[i13];
    v1.y = vertices[i13 + 1];
    v1.z = vertices[i13 + 2];
    v2.x = vertices[i23];
    v2.y = vertices[i23 + 1];
    v2.z = vertices[i23 + 2];
    normalsPerVertex[i0].count++;
    normalsPerVertex[i1].count++;
    normalsPerVertex[i22].count++;
    Cartesian3_default.subtract(v1, v0, v1);
    Cartesian3_default.subtract(v2, v0, v2);
    normalsPerTriangle[j] = Cartesian3_default.cross(v1, v2, new Cartesian3_default());
    j++;
  }
  let indexOffset = 0;
  for (i2 = 0; i2 < numVertices; i2++) {
    normalsPerVertex[i2].indexOffset += indexOffset;
    indexOffset += normalsPerVertex[i2].count;
  }
  j = 0;
  let vertexNormalData;
  for (i2 = 0; i2 < numIndices; i2 += 3) {
    vertexNormalData = normalsPerVertex[indices2[i2]];
    let index2 = vertexNormalData.indexOffset + vertexNormalData.currentCount;
    normalIndices[index2] = j;
    vertexNormalData.currentCount++;
    vertexNormalData = normalsPerVertex[indices2[i2 + 1]];
    index2 = vertexNormalData.indexOffset + vertexNormalData.currentCount;
    normalIndices[index2] = j;
    vertexNormalData.currentCount++;
    vertexNormalData = normalsPerVertex[indices2[i2 + 2]];
    index2 = vertexNormalData.indexOffset + vertexNormalData.currentCount;
    normalIndices[index2] = j;
    vertexNormalData.currentCount++;
    j++;
  }
  const normalValues = new Float32Array(numVertices * 3);
  for (i2 = 0; i2 < numVertices; i2++) {
    const i3 = i2 * 3;
    vertexNormalData = normalsPerVertex[i2];
    Cartesian3_default.clone(Cartesian3_default.ZERO, normal);
    if (vertexNormalData.count > 0) {
      for (j = 0; j < vertexNormalData.count; j++) {
        Cartesian3_default.add(
          normal,
          normalsPerTriangle[normalIndices[vertexNormalData.indexOffset + j]],
          normal
        );
      }
      if (Cartesian3_default.equalsEpsilon(Cartesian3_default.ZERO, normal, Math_default.EPSILON10)) {
        Cartesian3_default.clone(
          normalsPerTriangle[normalIndices[vertexNormalData.indexOffset]],
          normal
        );
      }
    }
    if (Cartesian3_default.equalsEpsilon(Cartesian3_default.ZERO, normal, Math_default.EPSILON10)) {
      normal.z = 1;
    }
    Cartesian3_default.normalize(normal, normal);
    normalValues[i3] = normal.x;
    normalValues[i3 + 1] = normal.y;
    normalValues[i3 + 2] = normal.z;
  }
  geometry.attributes.normal = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 3,
    values: normalValues
  });
  return geometry;
};
var normalScratch2 = new Cartesian3_default();
var normalScale = new Cartesian3_default();
var tScratch = new Cartesian3_default();
GeometryPipeline.computeTangentAndBitangent = function(geometry) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  const attributes = geometry.attributes;
  const indices2 = geometry.indices;
  if (!defined_default(attributes.position) || !defined_default(attributes.position.values)) {
    throw new DeveloperError_default(
      "geometry.attributes.position.values is required."
    );
  }
  if (!defined_default(attributes.normal) || !defined_default(attributes.normal.values)) {
    throw new DeveloperError_default("geometry.attributes.normal.values is required.");
  }
  if (!defined_default(attributes.st) || !defined_default(attributes.st.values)) {
    throw new DeveloperError_default("geometry.attributes.st.values is required.");
  }
  if (!defined_default(indices2)) {
    throw new DeveloperError_default("geometry.indices is required.");
  }
  if (indices2.length < 2 || indices2.length % 3 !== 0) {
    throw new DeveloperError_default(
      "geometry.indices length must be greater than 0 and be a multiple of 3."
    );
  }
  if (geometry.primitiveType !== PrimitiveType_default.TRIANGLES) {
    throw new DeveloperError_default(
      "geometry.primitiveType must be PrimitiveType.TRIANGLES."
    );
  }
  const vertices = geometry.attributes.position.values;
  const normals = geometry.attributes.normal.values;
  const st = geometry.attributes.st.values;
  const numVertices = geometry.attributes.position.values.length / 3;
  const numIndices = indices2.length;
  const tan1 = new Array(numVertices * 3);
  let i2;
  for (i2 = 0; i2 < tan1.length; i2++) {
    tan1[i2] = 0;
  }
  let i03;
  let i13;
  let i23;
  for (i2 = 0; i2 < numIndices; i2 += 3) {
    const i0 = indices2[i2];
    const i1 = indices2[i2 + 1];
    const i22 = indices2[i2 + 2];
    i03 = i0 * 3;
    i13 = i1 * 3;
    i23 = i22 * 3;
    const i02 = i0 * 2;
    const i12 = i1 * 2;
    const i222 = i22 * 2;
    const ux = vertices[i03];
    const uy = vertices[i03 + 1];
    const uz = vertices[i03 + 2];
    const wx = st[i02];
    const wy = st[i02 + 1];
    const t1 = st[i12 + 1] - wy;
    const t2 = st[i222 + 1] - wy;
    const r2 = 1 / ((st[i12] - wx) * t2 - (st[i222] - wx) * t1);
    const sdirx = (t2 * (vertices[i13] - ux) - t1 * (vertices[i23] - ux)) * r2;
    const sdiry = (t2 * (vertices[i13 + 1] - uy) - t1 * (vertices[i23 + 1] - uy)) * r2;
    const sdirz = (t2 * (vertices[i13 + 2] - uz) - t1 * (vertices[i23 + 2] - uz)) * r2;
    tan1[i03] += sdirx;
    tan1[i03 + 1] += sdiry;
    tan1[i03 + 2] += sdirz;
    tan1[i13] += sdirx;
    tan1[i13 + 1] += sdiry;
    tan1[i13 + 2] += sdirz;
    tan1[i23] += sdirx;
    tan1[i23 + 1] += sdiry;
    tan1[i23 + 2] += sdirz;
  }
  const tangentValues = new Float32Array(numVertices * 3);
  const bitangentValues = new Float32Array(numVertices * 3);
  for (i2 = 0; i2 < numVertices; i2++) {
    i03 = i2 * 3;
    i13 = i03 + 1;
    i23 = i03 + 2;
    const n2 = Cartesian3_default.fromArray(normals, i03, normalScratch2);
    const t = Cartesian3_default.fromArray(tan1, i03, tScratch);
    const scalar = Cartesian3_default.dot(n2, t);
    Cartesian3_default.multiplyByScalar(n2, scalar, normalScale);
    Cartesian3_default.normalize(Cartesian3_default.subtract(t, normalScale, t), t);
    tangentValues[i03] = t.x;
    tangentValues[i13] = t.y;
    tangentValues[i23] = t.z;
    Cartesian3_default.normalize(Cartesian3_default.cross(n2, t, t), t);
    bitangentValues[i03] = t.x;
    bitangentValues[i13] = t.y;
    bitangentValues[i23] = t.z;
  }
  geometry.attributes.tangent = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 3,
    values: tangentValues
  });
  geometry.attributes.bitangent = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 3,
    values: bitangentValues
  });
  return geometry;
};
var scratchCartesian25 = new Cartesian2_default();
var toEncode1 = new Cartesian3_default();
var toEncode2 = new Cartesian3_default();
var toEncode3 = new Cartesian3_default();
var encodeResult2 = new Cartesian2_default();
GeometryPipeline.compressVertices = function(geometry) {
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("geometry is required.");
  }
  const extrudeAttribute = geometry.attributes.extrudeDirection;
  let i2;
  let numVertices;
  if (defined_default(extrudeAttribute)) {
    const extrudeDirections = extrudeAttribute.values;
    numVertices = extrudeDirections.length / 3;
    const compressedDirections = new Float32Array(numVertices * 2);
    let i22 = 0;
    for (i2 = 0; i2 < numVertices; ++i2) {
      Cartesian3_default.fromArray(extrudeDirections, i2 * 3, toEncode1);
      if (Cartesian3_default.equals(toEncode1, Cartesian3_default.ZERO)) {
        i22 += 2;
        continue;
      }
      encodeResult2 = AttributeCompression_default.octEncodeInRange(
        toEncode1,
        65535,
        encodeResult2
      );
      compressedDirections[i22++] = encodeResult2.x;
      compressedDirections[i22++] = encodeResult2.y;
    }
    geometry.attributes.compressedAttributes = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: compressedDirections
    });
    delete geometry.attributes.extrudeDirection;
    return geometry;
  }
  const normalAttribute = geometry.attributes.normal;
  const stAttribute = geometry.attributes.st;
  const hasNormal = defined_default(normalAttribute);
  const hasSt = defined_default(stAttribute);
  if (!hasNormal && !hasSt) {
    return geometry;
  }
  const tangentAttribute = geometry.attributes.tangent;
  const bitangentAttribute = geometry.attributes.bitangent;
  const hasTangent = defined_default(tangentAttribute);
  const hasBitangent = defined_default(bitangentAttribute);
  let normals;
  let st;
  let tangents;
  let bitangents;
  if (hasNormal) {
    normals = normalAttribute.values;
  }
  if (hasSt) {
    st = stAttribute.values;
  }
  if (hasTangent) {
    tangents = tangentAttribute.values;
  }
  if (hasBitangent) {
    bitangents = bitangentAttribute.values;
  }
  const length3 = hasNormal ? normals.length : st.length;
  const numComponents = hasNormal ? 3 : 2;
  numVertices = length3 / numComponents;
  let compressedLength = numVertices;
  let numCompressedComponents = hasSt && hasNormal ? 2 : 1;
  numCompressedComponents += hasTangent || hasBitangent ? 1 : 0;
  compressedLength *= numCompressedComponents;
  const compressedAttributes = new Float32Array(compressedLength);
  let normalIndex = 0;
  for (i2 = 0; i2 < numVertices; ++i2) {
    if (hasSt) {
      Cartesian2_default.fromArray(st, i2 * 2, scratchCartesian25);
      compressedAttributes[normalIndex++] = AttributeCompression_default.compressTextureCoordinates(scratchCartesian25);
    }
    const index2 = i2 * 3;
    if (hasNormal && defined_default(tangents) && defined_default(bitangents)) {
      Cartesian3_default.fromArray(normals, index2, toEncode1);
      Cartesian3_default.fromArray(tangents, index2, toEncode2);
      Cartesian3_default.fromArray(bitangents, index2, toEncode3);
      AttributeCompression_default.octPack(
        toEncode1,
        toEncode2,
        toEncode3,
        scratchCartesian25
      );
      compressedAttributes[normalIndex++] = scratchCartesian25.x;
      compressedAttributes[normalIndex++] = scratchCartesian25.y;
    } else {
      if (hasNormal) {
        Cartesian3_default.fromArray(normals, index2, toEncode1);
        compressedAttributes[normalIndex++] = AttributeCompression_default.octEncodeFloat(toEncode1);
      }
      if (hasTangent) {
        Cartesian3_default.fromArray(tangents, index2, toEncode1);
        compressedAttributes[normalIndex++] = AttributeCompression_default.octEncodeFloat(toEncode1);
      }
      if (hasBitangent) {
        Cartesian3_default.fromArray(bitangents, index2, toEncode1);
        compressedAttributes[normalIndex++] = AttributeCompression_default.octEncodeFloat(toEncode1);
      }
    }
  }
  geometry.attributes.compressedAttributes = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: numCompressedComponents,
    values: compressedAttributes
  });
  if (hasNormal) {
    delete geometry.attributes.normal;
  }
  if (hasSt) {
    delete geometry.attributes.st;
  }
  if (hasBitangent) {
    delete geometry.attributes.bitangent;
  }
  if (hasTangent) {
    delete geometry.attributes.tangent;
  }
  return geometry;
};
function indexTriangles(geometry) {
  if (defined_default(geometry.indices)) {
    return geometry;
  }
  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
  if (numberOfVertices < 3) {
    throw new DeveloperError_default("The number of vertices must be at least three.");
  }
  if (numberOfVertices % 3 !== 0) {
    throw new DeveloperError_default(
      "The number of vertices must be a multiple of three."
    );
  }
  const indices2 = IndexDatatype_default.createTypedArray(
    numberOfVertices,
    numberOfVertices
  );
  for (let i2 = 0; i2 < numberOfVertices; ++i2) {
    indices2[i2] = i2;
  }
  geometry.indices = indices2;
  return geometry;
}
function indexTriangleFan(geometry) {
  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
  if (numberOfVertices < 3) {
    throw new DeveloperError_default("The number of vertices must be at least three.");
  }
  const indices2 = IndexDatatype_default.createTypedArray(
    numberOfVertices,
    (numberOfVertices - 2) * 3
  );
  indices2[0] = 1;
  indices2[1] = 0;
  indices2[2] = 2;
  let indicesIndex = 3;
  for (let i2 = 3; i2 < numberOfVertices; ++i2) {
    indices2[indicesIndex++] = i2 - 1;
    indices2[indicesIndex++] = 0;
    indices2[indicesIndex++] = i2;
  }
  geometry.indices = indices2;
  geometry.primitiveType = PrimitiveType_default.TRIANGLES;
  return geometry;
}
function indexTriangleStrip(geometry) {
  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
  if (numberOfVertices < 3) {
    throw new DeveloperError_default("The number of vertices must be at least 3.");
  }
  const indices2 = IndexDatatype_default.createTypedArray(
    numberOfVertices,
    (numberOfVertices - 2) * 3
  );
  indices2[0] = 0;
  indices2[1] = 1;
  indices2[2] = 2;
  if (numberOfVertices > 3) {
    indices2[3] = 0;
    indices2[4] = 2;
    indices2[5] = 3;
  }
  let indicesIndex = 6;
  for (let i2 = 3; i2 < numberOfVertices - 1; i2 += 2) {
    indices2[indicesIndex++] = i2;
    indices2[indicesIndex++] = i2 - 1;
    indices2[indicesIndex++] = i2 + 1;
    if (i2 + 2 < numberOfVertices) {
      indices2[indicesIndex++] = i2;
      indices2[indicesIndex++] = i2 + 1;
      indices2[indicesIndex++] = i2 + 2;
    }
  }
  geometry.indices = indices2;
  geometry.primitiveType = PrimitiveType_default.TRIANGLES;
  return geometry;
}
function indexLines(geometry) {
  if (defined_default(geometry.indices)) {
    return geometry;
  }
  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
  if (numberOfVertices < 2) {
    throw new DeveloperError_default("The number of vertices must be at least two.");
  }
  if (numberOfVertices % 2 !== 0) {
    throw new DeveloperError_default("The number of vertices must be a multiple of 2.");
  }
  const indices2 = IndexDatatype_default.createTypedArray(
    numberOfVertices,
    numberOfVertices
  );
  for (let i2 = 0; i2 < numberOfVertices; ++i2) {
    indices2[i2] = i2;
  }
  geometry.indices = indices2;
  return geometry;
}
function indexLineStrip(geometry) {
  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
  if (numberOfVertices < 2) {
    throw new DeveloperError_default("The number of vertices must be at least two.");
  }
  const indices2 = IndexDatatype_default.createTypedArray(
    numberOfVertices,
    (numberOfVertices - 1) * 2
  );
  indices2[0] = 0;
  indices2[1] = 1;
  let indicesIndex = 2;
  for (let i2 = 2; i2 < numberOfVertices; ++i2) {
    indices2[indicesIndex++] = i2 - 1;
    indices2[indicesIndex++] = i2;
  }
  geometry.indices = indices2;
  geometry.primitiveType = PrimitiveType_default.LINES;
  return geometry;
}
function indexLineLoop(geometry) {
  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
  if (numberOfVertices < 2) {
    throw new DeveloperError_default("The number of vertices must be at least two.");
  }
  const indices2 = IndexDatatype_default.createTypedArray(
    numberOfVertices,
    numberOfVertices * 2
  );
  indices2[0] = 0;
  indices2[1] = 1;
  let indicesIndex = 2;
  for (let i2 = 2; i2 < numberOfVertices; ++i2) {
    indices2[indicesIndex++] = i2 - 1;
    indices2[indicesIndex++] = i2;
  }
  indices2[indicesIndex++] = numberOfVertices - 1;
  indices2[indicesIndex] = 0;
  geometry.indices = indices2;
  geometry.primitiveType = PrimitiveType_default.LINES;
  return geometry;
}
function indexPrimitive(geometry) {
  switch (geometry.primitiveType) {
    case PrimitiveType_default.TRIANGLE_FAN:
      return indexTriangleFan(geometry);
    case PrimitiveType_default.TRIANGLE_STRIP:
      return indexTriangleStrip(geometry);
    case PrimitiveType_default.TRIANGLES:
      return indexTriangles(geometry);
    case PrimitiveType_default.LINE_STRIP:
      return indexLineStrip(geometry);
    case PrimitiveType_default.LINE_LOOP:
      return indexLineLoop(geometry);
    case PrimitiveType_default.LINES:
      return indexLines(geometry);
  }
  return geometry;
}
function offsetPointFromXZPlane(p2, isBehind) {
  if (Math.abs(p2.y) < Math_default.EPSILON6) {
    if (isBehind) {
      p2.y = -Math_default.EPSILON6;
    } else {
      p2.y = Math_default.EPSILON6;
    }
  }
}
function offsetTriangleFromXZPlane(p0, p1, p2) {
  if (p0.y !== 0 && p1.y !== 0 && p2.y !== 0) {
    offsetPointFromXZPlane(p0, p0.y < 0);
    offsetPointFromXZPlane(p1, p1.y < 0);
    offsetPointFromXZPlane(p2, p2.y < 0);
    return;
  }
  const p0y = Math.abs(p0.y);
  const p1y = Math.abs(p1.y);
  const p2y = Math.abs(p2.y);
  let sign3;
  if (p0y > p1y) {
    if (p0y > p2y) {
      sign3 = Math_default.sign(p0.y);
    } else {
      sign3 = Math_default.sign(p2.y);
    }
  } else if (p1y > p2y) {
    sign3 = Math_default.sign(p1.y);
  } else {
    sign3 = Math_default.sign(p2.y);
  }
  const isBehind = sign3 < 0;
  offsetPointFromXZPlane(p0, isBehind);
  offsetPointFromXZPlane(p1, isBehind);
  offsetPointFromXZPlane(p2, isBehind);
}
var c3 = new Cartesian3_default();
function getXZIntersectionOffsetPoints(p2, p1, u12, v13) {
  Cartesian3_default.add(
    p2,
    Cartesian3_default.multiplyByScalar(
      Cartesian3_default.subtract(p1, p2, c3),
      p2.y / (p2.y - p1.y),
      c3
    ),
    u12
  );
  Cartesian3_default.clone(u12, v13);
  offsetPointFromXZPlane(u12, true);
  offsetPointFromXZPlane(v13, false);
}
var u1 = new Cartesian3_default();
var u2 = new Cartesian3_default();
var q1 = new Cartesian3_default();
var q2 = new Cartesian3_default();
var splitTriangleResult = {
  positions: new Array(7),
  indices: new Array(3 * 3)
};
function splitTriangle(p0, p1, p2) {
  if (p0.x >= 0 || p1.x >= 0 || p2.x >= 0) {
    return void 0;
  }
  offsetTriangleFromXZPlane(p0, p1, p2);
  const p0Behind = p0.y < 0;
  const p1Behind = p1.y < 0;
  const p2Behind = p2.y < 0;
  let numBehind = 0;
  numBehind += p0Behind ? 1 : 0;
  numBehind += p1Behind ? 1 : 0;
  numBehind += p2Behind ? 1 : 0;
  const indices2 = splitTriangleResult.indices;
  if (numBehind === 1) {
    indices2[1] = 3;
    indices2[2] = 4;
    indices2[5] = 6;
    indices2[7] = 6;
    indices2[8] = 5;
    if (p0Behind) {
      getXZIntersectionOffsetPoints(p0, p1, u1, q1);
      getXZIntersectionOffsetPoints(p0, p2, u2, q2);
      indices2[0] = 0;
      indices2[3] = 1;
      indices2[4] = 2;
      indices2[6] = 1;
    } else if (p1Behind) {
      getXZIntersectionOffsetPoints(p1, p2, u1, q1);
      getXZIntersectionOffsetPoints(p1, p0, u2, q2);
      indices2[0] = 1;
      indices2[3] = 2;
      indices2[4] = 0;
      indices2[6] = 2;
    } else if (p2Behind) {
      getXZIntersectionOffsetPoints(p2, p0, u1, q1);
      getXZIntersectionOffsetPoints(p2, p1, u2, q2);
      indices2[0] = 2;
      indices2[3] = 0;
      indices2[4] = 1;
      indices2[6] = 0;
    }
  } else if (numBehind === 2) {
    indices2[2] = 4;
    indices2[4] = 4;
    indices2[5] = 3;
    indices2[7] = 5;
    indices2[8] = 6;
    if (!p0Behind) {
      getXZIntersectionOffsetPoints(p0, p1, u1, q1);
      getXZIntersectionOffsetPoints(p0, p2, u2, q2);
      indices2[0] = 1;
      indices2[1] = 2;
      indices2[3] = 1;
      indices2[6] = 0;
    } else if (!p1Behind) {
      getXZIntersectionOffsetPoints(p1, p2, u1, q1);
      getXZIntersectionOffsetPoints(p1, p0, u2, q2);
      indices2[0] = 2;
      indices2[1] = 0;
      indices2[3] = 2;
      indices2[6] = 1;
    } else if (!p2Behind) {
      getXZIntersectionOffsetPoints(p2, p0, u1, q1);
      getXZIntersectionOffsetPoints(p2, p1, u2, q2);
      indices2[0] = 0;
      indices2[1] = 1;
      indices2[3] = 0;
      indices2[6] = 2;
    }
  }
  const positions = splitTriangleResult.positions;
  positions[0] = p0;
  positions[1] = p1;
  positions[2] = p2;
  positions.length = 3;
  if (numBehind === 1 || numBehind === 2) {
    positions[3] = u1;
    positions[4] = u2;
    positions[5] = q1;
    positions[6] = q2;
    positions.length = 7;
  }
  return splitTriangleResult;
}
function updateGeometryAfterSplit(geometry, computeBoundingSphere) {
  const attributes = geometry.attributes;
  if (attributes.position.values.length === 0) {
    return void 0;
  }
  for (const property in attributes) {
    if (attributes.hasOwnProperty(property) && defined_default(attributes[property]) && defined_default(attributes[property].values)) {
      const attribute = attributes[property];
      attribute.values = ComponentDatatype_default.createTypedArray(
        attribute.componentDatatype,
        attribute.values
      );
    }
  }
  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
  geometry.indices = IndexDatatype_default.createTypedArray(
    numberOfVertices,
    geometry.indices
  );
  if (computeBoundingSphere) {
    geometry.boundingSphere = BoundingSphere_default.fromVertices(
      attributes.position.values
    );
  }
  return geometry;
}
function copyGeometryForSplit(geometry) {
  const attributes = geometry.attributes;
  const copiedAttributes = {};
  for (const property in attributes) {
    if (attributes.hasOwnProperty(property) && defined_default(attributes[property]) && defined_default(attributes[property].values)) {
      const attribute = attributes[property];
      copiedAttributes[property] = new GeometryAttribute_default({
        componentDatatype: attribute.componentDatatype,
        componentsPerAttribute: attribute.componentsPerAttribute,
        normalize: attribute.normalize,
        values: []
      });
    }
  }
  return new Geometry_default({
    attributes: copiedAttributes,
    indices: [],
    primitiveType: geometry.primitiveType
  });
}
function updateInstanceAfterSplit(instance, westGeometry, eastGeometry) {
  const computeBoundingSphere = defined_default(instance.geometry.boundingSphere);
  westGeometry = updateGeometryAfterSplit(westGeometry, computeBoundingSphere);
  eastGeometry = updateGeometryAfterSplit(eastGeometry, computeBoundingSphere);
  if (defined_default(eastGeometry) && !defined_default(westGeometry)) {
    instance.geometry = eastGeometry;
  } else if (!defined_default(eastGeometry) && defined_default(westGeometry)) {
    instance.geometry = westGeometry;
  } else {
    instance.westHemisphereGeometry = westGeometry;
    instance.eastHemisphereGeometry = eastGeometry;
    instance.geometry = void 0;
  }
}
function generateBarycentricInterpolateFunction(CartesianType, numberOfComponents) {
  const v0Scratch = new CartesianType();
  const v1Scratch2 = new CartesianType();
  const v2Scratch2 = new CartesianType();
  return function(i0, i1, i2, coords, sourceValues, currentValues, insertedIndex, normalize2) {
    const v02 = CartesianType.fromArray(
      sourceValues,
      i0 * numberOfComponents,
      v0Scratch
    );
    const v13 = CartesianType.fromArray(
      sourceValues,
      i1 * numberOfComponents,
      v1Scratch2
    );
    const v23 = CartesianType.fromArray(
      sourceValues,
      i2 * numberOfComponents,
      v2Scratch2
    );
    CartesianType.multiplyByScalar(v02, coords.x, v02);
    CartesianType.multiplyByScalar(v13, coords.y, v13);
    CartesianType.multiplyByScalar(v23, coords.z, v23);
    const value = CartesianType.add(v02, v13, v02);
    CartesianType.add(value, v23, value);
    if (normalize2) {
      CartesianType.normalize(value, value);
    }
    CartesianType.pack(
      value,
      currentValues,
      insertedIndex * numberOfComponents
    );
  };
}
var interpolateAndPackCartesian4 = generateBarycentricInterpolateFunction(
  Cartesian4_default,
  4
);
var interpolateAndPackCartesian3 = generateBarycentricInterpolateFunction(
  Cartesian3_default,
  3
);
var interpolateAndPackCartesian2 = generateBarycentricInterpolateFunction(
  Cartesian2_default,
  2
);
var interpolateAndPackBoolean = function(i0, i1, i2, coords, sourceValues, currentValues, insertedIndex) {
  const v13 = sourceValues[i0] * coords.x;
  const v23 = sourceValues[i1] * coords.y;
  const v32 = sourceValues[i2] * coords.z;
  currentValues[insertedIndex] = v13 + v23 + v32 > Math_default.EPSILON6 ? 1 : 0;
};
var p0Scratch = new Cartesian3_default();
var p1Scratch = new Cartesian3_default();
var p2Scratch = new Cartesian3_default();
var barycentricScratch = new Cartesian3_default();
function computeTriangleAttributes(i0, i1, i2, point, positions, normals, tangents, bitangents, texCoords, extrudeDirections, applyOffset, currentAttributes, customAttributeNames, customAttributesLength, allAttributes, insertedIndex) {
  if (!defined_default(normals) && !defined_default(tangents) && !defined_default(bitangents) && !defined_default(texCoords) && !defined_default(extrudeDirections) && customAttributesLength === 0) {
    return;
  }
  const p0 = Cartesian3_default.fromArray(positions, i0 * 3, p0Scratch);
  const p1 = Cartesian3_default.fromArray(positions, i1 * 3, p1Scratch);
  const p2 = Cartesian3_default.fromArray(positions, i2 * 3, p2Scratch);
  const coords = barycentricCoordinates_default(point, p0, p1, p2, barycentricScratch);
  if (!defined_default(coords)) {
    return;
  }
  if (defined_default(normals)) {
    interpolateAndPackCartesian3(
      i0,
      i1,
      i2,
      coords,
      normals,
      currentAttributes.normal.values,
      insertedIndex,
      true
    );
  }
  if (defined_default(extrudeDirections)) {
    const d0 = Cartesian3_default.fromArray(extrudeDirections, i0 * 3, p0Scratch);
    const d1 = Cartesian3_default.fromArray(extrudeDirections, i1 * 3, p1Scratch);
    const d2 = Cartesian3_default.fromArray(extrudeDirections, i2 * 3, p2Scratch);
    Cartesian3_default.multiplyByScalar(d0, coords.x, d0);
    Cartesian3_default.multiplyByScalar(d1, coords.y, d1);
    Cartesian3_default.multiplyByScalar(d2, coords.z, d2);
    let direction2;
    if (!Cartesian3_default.equals(d0, Cartesian3_default.ZERO) || !Cartesian3_default.equals(d1, Cartesian3_default.ZERO) || !Cartesian3_default.equals(d2, Cartesian3_default.ZERO)) {
      direction2 = Cartesian3_default.add(d0, d1, d0);
      Cartesian3_default.add(direction2, d2, direction2);
      Cartesian3_default.normalize(direction2, direction2);
    } else {
      direction2 = p0Scratch;
      direction2.x = 0;
      direction2.y = 0;
      direction2.z = 0;
    }
    Cartesian3_default.pack(
      direction2,
      currentAttributes.extrudeDirection.values,
      insertedIndex * 3
    );
  }
  if (defined_default(applyOffset)) {
    interpolateAndPackBoolean(
      i0,
      i1,
      i2,
      coords,
      applyOffset,
      currentAttributes.applyOffset.values,
      insertedIndex
    );
  }
  if (defined_default(tangents)) {
    interpolateAndPackCartesian3(
      i0,
      i1,
      i2,
      coords,
      tangents,
      currentAttributes.tangent.values,
      insertedIndex,
      true
    );
  }
  if (defined_default(bitangents)) {
    interpolateAndPackCartesian3(
      i0,
      i1,
      i2,
      coords,
      bitangents,
      currentAttributes.bitangent.values,
      insertedIndex,
      true
    );
  }
  if (defined_default(texCoords)) {
    interpolateAndPackCartesian2(
      i0,
      i1,
      i2,
      coords,
      texCoords,
      currentAttributes.st.values,
      insertedIndex
    );
  }
  if (customAttributesLength > 0) {
    for (let i3 = 0; i3 < customAttributesLength; i3++) {
      const attributeName = customAttributeNames[i3];
      genericInterpolate(
        i0,
        i1,
        i2,
        coords,
        insertedIndex,
        allAttributes[attributeName],
        currentAttributes[attributeName]
      );
    }
  }
}
function genericInterpolate(i0, i1, i2, coords, insertedIndex, sourceAttribute, currentAttribute) {
  const componentsPerAttribute = sourceAttribute.componentsPerAttribute;
  const sourceValues = sourceAttribute.values;
  const currentValues = currentAttribute.values;
  switch (componentsPerAttribute) {
    case 4:
      interpolateAndPackCartesian4(
        i0,
        i1,
        i2,
        coords,
        sourceValues,
        currentValues,
        insertedIndex,
        false
      );
      break;
    case 3:
      interpolateAndPackCartesian3(
        i0,
        i1,
        i2,
        coords,
        sourceValues,
        currentValues,
        insertedIndex,
        false
      );
      break;
    case 2:
      interpolateAndPackCartesian2(
        i0,
        i1,
        i2,
        coords,
        sourceValues,
        currentValues,
        insertedIndex,
        false
      );
      break;
    default:
      currentValues[insertedIndex] = sourceValues[i0] * coords.x + sourceValues[i1] * coords.y + sourceValues[i2] * coords.z;
  }
}
function insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices2, currentIndex, point) {
  const insertIndex = currentAttributes.position.values.length / 3;
  if (currentIndex !== -1) {
    const prevIndex = indices2[currentIndex];
    const newIndex = currentIndexMap[prevIndex];
    if (newIndex === -1) {
      currentIndexMap[prevIndex] = insertIndex;
      currentAttributes.position.values.push(point.x, point.y, point.z);
      currentIndices.push(insertIndex);
      return insertIndex;
    }
    currentIndices.push(newIndex);
    return newIndex;
  }
  currentAttributes.position.values.push(point.x, point.y, point.z);
  currentIndices.push(insertIndex);
  return insertIndex;
}
var NAMED_ATTRIBUTES = {
  position: true,
  normal: true,
  bitangent: true,
  tangent: true,
  st: true,
  extrudeDirection: true,
  applyOffset: true
};
function splitLongitudeTriangles(instance) {
  const geometry = instance.geometry;
  const attributes = geometry.attributes;
  const positions = attributes.position.values;
  const normals = defined_default(attributes.normal) ? attributes.normal.values : void 0;
  const bitangents = defined_default(attributes.bitangent) ? attributes.bitangent.values : void 0;
  const tangents = defined_default(attributes.tangent) ? attributes.tangent.values : void 0;
  const texCoords = defined_default(attributes.st) ? attributes.st.values : void 0;
  const extrudeDirections = defined_default(attributes.extrudeDirection) ? attributes.extrudeDirection.values : void 0;
  const applyOffset = defined_default(attributes.applyOffset) ? attributes.applyOffset.values : void 0;
  const indices2 = geometry.indices;
  const customAttributeNames = [];
  for (const attributeName in attributes) {
    if (attributes.hasOwnProperty(attributeName) && !NAMED_ATTRIBUTES[attributeName] && defined_default(attributes[attributeName])) {
      customAttributeNames.push(attributeName);
    }
  }
  const customAttributesLength = customAttributeNames.length;
  const eastGeometry = copyGeometryForSplit(geometry);
  const westGeometry = copyGeometryForSplit(geometry);
  let currentAttributes;
  let currentIndices;
  let currentIndexMap;
  let insertedIndex;
  let i2;
  const westGeometryIndexMap = [];
  westGeometryIndexMap.length = positions.length / 3;
  const eastGeometryIndexMap = [];
  eastGeometryIndexMap.length = positions.length / 3;
  for (i2 = 0; i2 < westGeometryIndexMap.length; ++i2) {
    westGeometryIndexMap[i2] = -1;
    eastGeometryIndexMap[i2] = -1;
  }
  const len = indices2.length;
  for (i2 = 0; i2 < len; i2 += 3) {
    const i0 = indices2[i2];
    const i1 = indices2[i2 + 1];
    const i22 = indices2[i2 + 2];
    let p0 = Cartesian3_default.fromArray(positions, i0 * 3);
    let p1 = Cartesian3_default.fromArray(positions, i1 * 3);
    let p2 = Cartesian3_default.fromArray(positions, i22 * 3);
    const result = splitTriangle(p0, p1, p2);
    if (defined_default(result) && result.positions.length > 3) {
      const resultPositions = result.positions;
      const resultIndices = result.indices;
      const resultLength = resultIndices.length;
      for (let j = 0; j < resultLength; ++j) {
        const resultIndex = resultIndices[j];
        const point = resultPositions[resultIndex];
        if (point.y < 0) {
          currentAttributes = westGeometry.attributes;
          currentIndices = westGeometry.indices;
          currentIndexMap = westGeometryIndexMap;
        } else {
          currentAttributes = eastGeometry.attributes;
          currentIndices = eastGeometry.indices;
          currentIndexMap = eastGeometryIndexMap;
        }
        insertedIndex = insertSplitPoint(
          currentAttributes,
          currentIndices,
          currentIndexMap,
          indices2,
          resultIndex < 3 ? i2 + resultIndex : -1,
          point
        );
        computeTriangleAttributes(
          i0,
          i1,
          i22,
          point,
          positions,
          normals,
          tangents,
          bitangents,
          texCoords,
          extrudeDirections,
          applyOffset,
          currentAttributes,
          customAttributeNames,
          customAttributesLength,
          attributes,
          insertedIndex
        );
      }
    } else {
      if (defined_default(result)) {
        p0 = result.positions[0];
        p1 = result.positions[1];
        p2 = result.positions[2];
      }
      if (p0.y < 0) {
        currentAttributes = westGeometry.attributes;
        currentIndices = westGeometry.indices;
        currentIndexMap = westGeometryIndexMap;
      } else {
        currentAttributes = eastGeometry.attributes;
        currentIndices = eastGeometry.indices;
        currentIndexMap = eastGeometryIndexMap;
      }
      insertedIndex = insertSplitPoint(
        currentAttributes,
        currentIndices,
        currentIndexMap,
        indices2,
        i2,
        p0
      );
      computeTriangleAttributes(
        i0,
        i1,
        i22,
        p0,
        positions,
        normals,
        tangents,
        bitangents,
        texCoords,
        extrudeDirections,
        applyOffset,
        currentAttributes,
        customAttributeNames,
        customAttributesLength,
        attributes,
        insertedIndex
      );
      insertedIndex = insertSplitPoint(
        currentAttributes,
        currentIndices,
        currentIndexMap,
        indices2,
        i2 + 1,
        p1
      );
      computeTriangleAttributes(
        i0,
        i1,
        i22,
        p1,
        positions,
        normals,
        tangents,
        bitangents,
        texCoords,
        extrudeDirections,
        applyOffset,
        currentAttributes,
        customAttributeNames,
        customAttributesLength,
        attributes,
        insertedIndex
      );
      insertedIndex = insertSplitPoint(
        currentAttributes,
        currentIndices,
        currentIndexMap,
        indices2,
        i2 + 2,
        p2
      );
      computeTriangleAttributes(
        i0,
        i1,
        i22,
        p2,
        positions,
        normals,
        tangents,
        bitangents,
        texCoords,
        extrudeDirections,
        applyOffset,
        currentAttributes,
        customAttributeNames,
        customAttributesLength,
        attributes,
        insertedIndex
      );
    }
  }
  updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
}
var xzPlane = Plane_default.fromPointNormal(Cartesian3_default.ZERO, Cartesian3_default.UNIT_Y);
var offsetScratch = new Cartesian3_default();
var offsetPointScratch = new Cartesian3_default();
function computeLineAttributes(i0, i1, point, positions, insertIndex, currentAttributes, applyOffset) {
  if (!defined_default(applyOffset)) {
    return;
  }
  const p0 = Cartesian3_default.fromArray(positions, i0 * 3, p0Scratch);
  if (Cartesian3_default.equalsEpsilon(p0, point, Math_default.EPSILON10)) {
    currentAttributes.applyOffset.values[insertIndex] = applyOffset[i0];
  } else {
    currentAttributes.applyOffset.values[insertIndex] = applyOffset[i1];
  }
}
function splitLongitudeLines(instance) {
  const geometry = instance.geometry;
  const attributes = geometry.attributes;
  const positions = attributes.position.values;
  const applyOffset = defined_default(attributes.applyOffset) ? attributes.applyOffset.values : void 0;
  const indices2 = geometry.indices;
  const eastGeometry = copyGeometryForSplit(geometry);
  const westGeometry = copyGeometryForSplit(geometry);
  let i2;
  const length3 = indices2.length;
  const westGeometryIndexMap = [];
  westGeometryIndexMap.length = positions.length / 3;
  const eastGeometryIndexMap = [];
  eastGeometryIndexMap.length = positions.length / 3;
  for (i2 = 0; i2 < westGeometryIndexMap.length; ++i2) {
    westGeometryIndexMap[i2] = -1;
    eastGeometryIndexMap[i2] = -1;
  }
  for (i2 = 0; i2 < length3; i2 += 2) {
    const i0 = indices2[i2];
    const i1 = indices2[i2 + 1];
    const p0 = Cartesian3_default.fromArray(positions, i0 * 3, p0Scratch);
    const p1 = Cartesian3_default.fromArray(positions, i1 * 3, p1Scratch);
    let insertIndex;
    if (Math.abs(p0.y) < Math_default.EPSILON6) {
      if (p0.y < 0) {
        p0.y = -Math_default.EPSILON6;
      } else {
        p0.y = Math_default.EPSILON6;
      }
    }
    if (Math.abs(p1.y) < Math_default.EPSILON6) {
      if (p1.y < 0) {
        p1.y = -Math_default.EPSILON6;
      } else {
        p1.y = Math_default.EPSILON6;
      }
    }
    let p0Attributes = eastGeometry.attributes;
    let p0Indices = eastGeometry.indices;
    let p0IndexMap = eastGeometryIndexMap;
    let p1Attributes = westGeometry.attributes;
    let p1Indices = westGeometry.indices;
    let p1IndexMap = westGeometryIndexMap;
    const intersection = IntersectionTests_default.lineSegmentPlane(
      p0,
      p1,
      xzPlane,
      p2Scratch
    );
    if (defined_default(intersection)) {
      const offset2 = Cartesian3_default.multiplyByScalar(
        Cartesian3_default.UNIT_Y,
        5 * Math_default.EPSILON9,
        offsetScratch
      );
      if (p0.y < 0) {
        Cartesian3_default.negate(offset2, offset2);
        p0Attributes = westGeometry.attributes;
        p0Indices = westGeometry.indices;
        p0IndexMap = westGeometryIndexMap;
        p1Attributes = eastGeometry.attributes;
        p1Indices = eastGeometry.indices;
        p1IndexMap = eastGeometryIndexMap;
      }
      const offsetPoint = Cartesian3_default.add(
        intersection,
        offset2,
        offsetPointScratch
      );
      insertIndex = insertSplitPoint(
        p0Attributes,
        p0Indices,
        p0IndexMap,
        indices2,
        i2,
        p0
      );
      computeLineAttributes(
        i0,
        i1,
        p0,
        positions,
        insertIndex,
        p0Attributes,
        applyOffset
      );
      insertIndex = insertSplitPoint(
        p0Attributes,
        p0Indices,
        p0IndexMap,
        indices2,
        -1,
        offsetPoint
      );
      computeLineAttributes(
        i0,
        i1,
        offsetPoint,
        positions,
        insertIndex,
        p0Attributes,
        applyOffset
      );
      Cartesian3_default.negate(offset2, offset2);
      Cartesian3_default.add(intersection, offset2, offsetPoint);
      insertIndex = insertSplitPoint(
        p1Attributes,
        p1Indices,
        p1IndexMap,
        indices2,
        -1,
        offsetPoint
      );
      computeLineAttributes(
        i0,
        i1,
        offsetPoint,
        positions,
        insertIndex,
        p1Attributes,
        applyOffset
      );
      insertIndex = insertSplitPoint(
        p1Attributes,
        p1Indices,
        p1IndexMap,
        indices2,
        i2 + 1,
        p1
      );
      computeLineAttributes(
        i0,
        i1,
        p1,
        positions,
        insertIndex,
        p1Attributes,
        applyOffset
      );
    } else {
      let currentAttributes;
      let currentIndices;
      let currentIndexMap;
      if (p0.y < 0) {
        currentAttributes = westGeometry.attributes;
        currentIndices = westGeometry.indices;
        currentIndexMap = westGeometryIndexMap;
      } else {
        currentAttributes = eastGeometry.attributes;
        currentIndices = eastGeometry.indices;
        currentIndexMap = eastGeometryIndexMap;
      }
      insertIndex = insertSplitPoint(
        currentAttributes,
        currentIndices,
        currentIndexMap,
        indices2,
        i2,
        p0
      );
      computeLineAttributes(
        i0,
        i1,
        p0,
        positions,
        insertIndex,
        currentAttributes,
        applyOffset
      );
      insertIndex = insertSplitPoint(
        currentAttributes,
        currentIndices,
        currentIndexMap,
        indices2,
        i2 + 1,
        p1
      );
      computeLineAttributes(
        i0,
        i1,
        p1,
        positions,
        insertIndex,
        currentAttributes,
        applyOffset
      );
    }
  }
  updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
}
var cartesian2Scratch0 = new Cartesian2_default();
var cartesian2Scratch1 = new Cartesian2_default();
var cartesian3Scratch0 = new Cartesian3_default();
var cartesian3Scratch22 = new Cartesian3_default();
var cartesian3Scratch3 = new Cartesian3_default();
var cartesian3Scratch4 = new Cartesian3_default();
var cartesian3Scratch5 = new Cartesian3_default();
var cartesian3Scratch6 = new Cartesian3_default();
var cartesian4Scratch0 = new Cartesian4_default();
function updateAdjacencyAfterSplit(geometry) {
  const attributes = geometry.attributes;
  const positions = attributes.position.values;
  const prevPositions = attributes.prevPosition.values;
  const nextPositions = attributes.nextPosition.values;
  const length3 = positions.length;
  for (let j = 0; j < length3; j += 3) {
    const position = Cartesian3_default.unpack(positions, j, cartesian3Scratch0);
    if (position.x > 0) {
      continue;
    }
    const prevPosition = Cartesian3_default.unpack(
      prevPositions,
      j,
      cartesian3Scratch22
    );
    if (position.y < 0 && prevPosition.y > 0 || position.y > 0 && prevPosition.y < 0) {
      if (j - 3 > 0) {
        prevPositions[j] = positions[j - 3];
        prevPositions[j + 1] = positions[j - 2];
        prevPositions[j + 2] = positions[j - 1];
      } else {
        Cartesian3_default.pack(position, prevPositions, j);
      }
    }
    const nextPosition = Cartesian3_default.unpack(
      nextPositions,
      j,
      cartesian3Scratch3
    );
    if (position.y < 0 && nextPosition.y > 0 || position.y > 0 && nextPosition.y < 0) {
      if (j + 3 < length3) {
        nextPositions[j] = positions[j + 3];
        nextPositions[j + 1] = positions[j + 4];
        nextPositions[j + 2] = positions[j + 5];
      } else {
        Cartesian3_default.pack(position, nextPositions, j);
      }
    }
  }
}
var offsetScalar = 5 * Math_default.EPSILON9;
var coplanarOffset = Math_default.EPSILON6;
function splitLongitudePolyline(instance) {
  const geometry = instance.geometry;
  const attributes = geometry.attributes;
  const positions = attributes.position.values;
  const prevPositions = attributes.prevPosition.values;
  const nextPositions = attributes.nextPosition.values;
  const expandAndWidths = attributes.expandAndWidth.values;
  const texCoords = defined_default(attributes.st) ? attributes.st.values : void 0;
  const colors = defined_default(attributes.color) ? attributes.color.values : void 0;
  const eastGeometry = copyGeometryForSplit(geometry);
  const westGeometry = copyGeometryForSplit(geometry);
  let i2;
  let j;
  let index2;
  let intersectionFound = false;
  const length3 = positions.length / 3;
  for (i2 = 0; i2 < length3; i2 += 4) {
    const i0 = i2;
    const i22 = i2 + 2;
    const p0 = Cartesian3_default.fromArray(positions, i0 * 3, cartesian3Scratch0);
    const p2 = Cartesian3_default.fromArray(positions, i22 * 3, cartesian3Scratch22);
    if (Math.abs(p0.y) < coplanarOffset) {
      p0.y = coplanarOffset * (p2.y < 0 ? -1 : 1);
      positions[i2 * 3 + 1] = p0.y;
      positions[(i2 + 1) * 3 + 1] = p0.y;
      for (j = i0 * 3; j < i0 * 3 + 4 * 3; j += 3) {
        prevPositions[j] = positions[i2 * 3];
        prevPositions[j + 1] = positions[i2 * 3 + 1];
        prevPositions[j + 2] = positions[i2 * 3 + 2];
      }
    }
    if (Math.abs(p2.y) < coplanarOffset) {
      p2.y = coplanarOffset * (p0.y < 0 ? -1 : 1);
      positions[(i2 + 2) * 3 + 1] = p2.y;
      positions[(i2 + 3) * 3 + 1] = p2.y;
      for (j = i0 * 3; j < i0 * 3 + 4 * 3; j += 3) {
        nextPositions[j] = positions[(i2 + 2) * 3];
        nextPositions[j + 1] = positions[(i2 + 2) * 3 + 1];
        nextPositions[j + 2] = positions[(i2 + 2) * 3 + 2];
      }
    }
    let p0Attributes = eastGeometry.attributes;
    let p0Indices = eastGeometry.indices;
    let p2Attributes = westGeometry.attributes;
    let p2Indices = westGeometry.indices;
    const intersection = IntersectionTests_default.lineSegmentPlane(
      p0,
      p2,
      xzPlane,
      cartesian3Scratch4
    );
    if (defined_default(intersection)) {
      intersectionFound = true;
      const offset2 = Cartesian3_default.multiplyByScalar(
        Cartesian3_default.UNIT_Y,
        offsetScalar,
        cartesian3Scratch5
      );
      if (p0.y < 0) {
        Cartesian3_default.negate(offset2, offset2);
        p0Attributes = westGeometry.attributes;
        p0Indices = westGeometry.indices;
        p2Attributes = eastGeometry.attributes;
        p2Indices = eastGeometry.indices;
      }
      const offsetPoint = Cartesian3_default.add(
        intersection,
        offset2,
        cartesian3Scratch6
      );
      p0Attributes.position.values.push(p0.x, p0.y, p0.z, p0.x, p0.y, p0.z);
      p0Attributes.position.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p0Attributes.position.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p0Attributes.prevPosition.values.push(
        prevPositions[i0 * 3],
        prevPositions[i0 * 3 + 1],
        prevPositions[i0 * 3 + 2]
      );
      p0Attributes.prevPosition.values.push(
        prevPositions[i0 * 3 + 3],
        prevPositions[i0 * 3 + 4],
        prevPositions[i0 * 3 + 5]
      );
      p0Attributes.prevPosition.values.push(p0.x, p0.y, p0.z, p0.x, p0.y, p0.z);
      p0Attributes.nextPosition.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p0Attributes.nextPosition.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p0Attributes.nextPosition.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p0Attributes.nextPosition.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      Cartesian3_default.negate(offset2, offset2);
      Cartesian3_default.add(intersection, offset2, offsetPoint);
      p2Attributes.position.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p2Attributes.position.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p2Attributes.position.values.push(p2.x, p2.y, p2.z, p2.x, p2.y, p2.z);
      p2Attributes.prevPosition.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p2Attributes.prevPosition.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p2Attributes.prevPosition.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p2Attributes.prevPosition.values.push(
        offsetPoint.x,
        offsetPoint.y,
        offsetPoint.z
      );
      p2Attributes.nextPosition.values.push(p2.x, p2.y, p2.z, p2.x, p2.y, p2.z);
      p2Attributes.nextPosition.values.push(
        nextPositions[i22 * 3],
        nextPositions[i22 * 3 + 1],
        nextPositions[i22 * 3 + 2]
      );
      p2Attributes.nextPosition.values.push(
        nextPositions[i22 * 3 + 3],
        nextPositions[i22 * 3 + 4],
        nextPositions[i22 * 3 + 5]
      );
      const ew0 = Cartesian2_default.fromArray(
        expandAndWidths,
        i0 * 2,
        cartesian2Scratch0
      );
      const width = Math.abs(ew0.y);
      p0Attributes.expandAndWidth.values.push(-1, width, 1, width);
      p0Attributes.expandAndWidth.values.push(-1, -width, 1, -width);
      p2Attributes.expandAndWidth.values.push(-1, width, 1, width);
      p2Attributes.expandAndWidth.values.push(-1, -width, 1, -width);
      let t = Cartesian3_default.magnitudeSquared(
        Cartesian3_default.subtract(intersection, p0, cartesian3Scratch3)
      );
      t /= Cartesian3_default.magnitudeSquared(
        Cartesian3_default.subtract(p2, p0, cartesian3Scratch3)
      );
      if (defined_default(colors)) {
        const c0 = Cartesian4_default.fromArray(colors, i0 * 4, cartesian4Scratch0);
        const c22 = Cartesian4_default.fromArray(colors, i22 * 4, cartesian4Scratch0);
        const r2 = Math_default.lerp(c0.x, c22.x, t);
        const g = Math_default.lerp(c0.y, c22.y, t);
        const b = Math_default.lerp(c0.z, c22.z, t);
        const a4 = Math_default.lerp(c0.w, c22.w, t);
        for (j = i0 * 4; j < i0 * 4 + 2 * 4; ++j) {
          p0Attributes.color.values.push(colors[j]);
        }
        p0Attributes.color.values.push(r2, g, b, a4);
        p0Attributes.color.values.push(r2, g, b, a4);
        p2Attributes.color.values.push(r2, g, b, a4);
        p2Attributes.color.values.push(r2, g, b, a4);
        for (j = i22 * 4; j < i22 * 4 + 2 * 4; ++j) {
          p2Attributes.color.values.push(colors[j]);
        }
      }
      if (defined_default(texCoords)) {
        const s0 = Cartesian2_default.fromArray(texCoords, i0 * 2, cartesian2Scratch0);
        const s3 = Cartesian2_default.fromArray(
          texCoords,
          (i2 + 3) * 2,
          cartesian2Scratch1
        );
        const sx = Math_default.lerp(s0.x, s3.x, t);
        for (j = i0 * 2; j < i0 * 2 + 2 * 2; ++j) {
          p0Attributes.st.values.push(texCoords[j]);
        }
        p0Attributes.st.values.push(sx, s0.y);
        p0Attributes.st.values.push(sx, s3.y);
        p2Attributes.st.values.push(sx, s0.y);
        p2Attributes.st.values.push(sx, s3.y);
        for (j = i22 * 2; j < i22 * 2 + 2 * 2; ++j) {
          p2Attributes.st.values.push(texCoords[j]);
        }
      }
      index2 = p0Attributes.position.values.length / 3 - 4;
      p0Indices.push(index2, index2 + 2, index2 + 1);
      p0Indices.push(index2 + 1, index2 + 2, index2 + 3);
      index2 = p2Attributes.position.values.length / 3 - 4;
      p2Indices.push(index2, index2 + 2, index2 + 1);
      p2Indices.push(index2 + 1, index2 + 2, index2 + 3);
    } else {
      let currentAttributes;
      let currentIndices;
      if (p0.y < 0) {
        currentAttributes = westGeometry.attributes;
        currentIndices = westGeometry.indices;
      } else {
        currentAttributes = eastGeometry.attributes;
        currentIndices = eastGeometry.indices;
      }
      currentAttributes.position.values.push(p0.x, p0.y, p0.z);
      currentAttributes.position.values.push(p0.x, p0.y, p0.z);
      currentAttributes.position.values.push(p2.x, p2.y, p2.z);
      currentAttributes.position.values.push(p2.x, p2.y, p2.z);
      for (j = i2 * 3; j < i2 * 3 + 4 * 3; ++j) {
        currentAttributes.prevPosition.values.push(prevPositions[j]);
        currentAttributes.nextPosition.values.push(nextPositions[j]);
      }
      for (j = i2 * 2; j < i2 * 2 + 4 * 2; ++j) {
        currentAttributes.expandAndWidth.values.push(expandAndWidths[j]);
        if (defined_default(texCoords)) {
          currentAttributes.st.values.push(texCoords[j]);
        }
      }
      if (defined_default(colors)) {
        for (j = i2 * 4; j < i2 * 4 + 4 * 4; ++j) {
          currentAttributes.color.values.push(colors[j]);
        }
      }
      index2 = currentAttributes.position.values.length / 3 - 4;
      currentIndices.push(index2, index2 + 2, index2 + 1);
      currentIndices.push(index2 + 1, index2 + 2, index2 + 3);
    }
  }
  if (intersectionFound) {
    updateAdjacencyAfterSplit(westGeometry);
    updateAdjacencyAfterSplit(eastGeometry);
  }
  updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
}
GeometryPipeline.splitLongitude = function(instance) {
  if (!defined_default(instance)) {
    throw new DeveloperError_default("instance is required.");
  }
  const geometry = instance.geometry;
  const boundingSphere = geometry.boundingSphere;
  if (defined_default(boundingSphere)) {
    const minX = boundingSphere.center.x - boundingSphere.radius;
    if (minX > 0 || BoundingSphere_default.intersectPlane(boundingSphere, Plane_default.ORIGIN_ZX_PLANE) !== Intersect_default.INTERSECTING) {
      return instance;
    }
  }
  if (geometry.geometryType !== GeometryType_default.NONE) {
    switch (geometry.geometryType) {
      case GeometryType_default.POLYLINES:
        splitLongitudePolyline(instance);
        break;
      case GeometryType_default.TRIANGLES:
        splitLongitudeTriangles(instance);
        break;
      case GeometryType_default.LINES:
        splitLongitudeLines(instance);
        break;
    }
  } else {
    indexPrimitive(geometry);
    if (geometry.primitiveType === PrimitiveType_default.TRIANGLES) {
      splitLongitudeTriangles(instance);
    } else if (geometry.primitiveType === PrimitiveType_default.LINES) {
      splitLongitudeLines(instance);
    }
  }
  return instance;
};
var GeometryPipeline_default = GeometryPipeline;

// node_modules/cesium/Source/Core/EllipseGeometry.js
var scratchCartesian14 = new Cartesian3_default();
var scratchCartesian26 = new Cartesian3_default();
var scratchCartesian36 = new Cartesian3_default();
var scratchCartesian42 = new Cartesian3_default();
var texCoordScratch = new Cartesian2_default();
var textureMatrixScratch = new Matrix3_default();
var tangentMatrixScratch = new Matrix3_default();
var quaternionScratch = new Quaternion_default();
var scratchNormal3 = new Cartesian3_default();
var scratchTangent = new Cartesian3_default();
var scratchBitangent = new Cartesian3_default();
var scratchCartographic3 = new Cartographic_default();
var projectedCenterScratch = new Cartesian3_default();
var scratchMinTexCoord = new Cartesian2_default();
var scratchMaxTexCoord = new Cartesian2_default();
function computeTopBottomAttributes(positions, options, extrude) {
  const vertexFormat = options.vertexFormat;
  const center = options.center;
  const semiMajorAxis = options.semiMajorAxis;
  const semiMinorAxis = options.semiMinorAxis;
  const ellipsoid = options.ellipsoid;
  const stRotation = options.stRotation;
  const size = extrude ? positions.length / 3 * 2 : positions.length / 3;
  const shadowVolume = options.shadowVolume;
  const textureCoordinates = vertexFormat.st ? new Float32Array(size * 2) : void 0;
  const normals = vertexFormat.normal ? new Float32Array(size * 3) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(size * 3) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(size * 3) : void 0;
  const extrudeNormals = shadowVolume ? new Float32Array(size * 3) : void 0;
  let textureCoordIndex = 0;
  let normal2 = scratchNormal3;
  let tangent = scratchTangent;
  let bitangent = scratchBitangent;
  const projection = new GeographicProjection_default(ellipsoid);
  const projectedCenter = projection.project(
    ellipsoid.cartesianToCartographic(center, scratchCartographic3),
    projectedCenterScratch
  );
  const geodeticNormal = ellipsoid.scaleToGeodeticSurface(
    center,
    scratchCartesian14
  );
  ellipsoid.geodeticSurfaceNormal(geodeticNormal, geodeticNormal);
  let textureMatrix = textureMatrixScratch;
  let tangentMatrix = tangentMatrixScratch;
  if (stRotation !== 0) {
    let rotation = Quaternion_default.fromAxisAngle(
      geodeticNormal,
      stRotation,
      quaternionScratch
    );
    textureMatrix = Matrix3_default.fromQuaternion(rotation, textureMatrix);
    rotation = Quaternion_default.fromAxisAngle(
      geodeticNormal,
      -stRotation,
      quaternionScratch
    );
    tangentMatrix = Matrix3_default.fromQuaternion(rotation, tangentMatrix);
  } else {
    textureMatrix = Matrix3_default.clone(Matrix3_default.IDENTITY, textureMatrix);
    tangentMatrix = Matrix3_default.clone(Matrix3_default.IDENTITY, tangentMatrix);
  }
  const minTexCoord = Cartesian2_default.fromElements(
    Number.POSITIVE_INFINITY,
    Number.POSITIVE_INFINITY,
    scratchMinTexCoord
  );
  const maxTexCoord = Cartesian2_default.fromElements(
    Number.NEGATIVE_INFINITY,
    Number.NEGATIVE_INFINITY,
    scratchMaxTexCoord
  );
  let length3 = positions.length;
  const bottomOffset = extrude ? length3 : 0;
  const stOffset = bottomOffset / 3 * 2;
  for (let i2 = 0; i2 < length3; i2 += 3) {
    const i1 = i2 + 1;
    const i22 = i2 + 2;
    const position = Cartesian3_default.fromArray(positions, i2, scratchCartesian14);
    if (vertexFormat.st) {
      const rotatedPoint = Matrix3_default.multiplyByVector(
        textureMatrix,
        position,
        scratchCartesian26
      );
      const projectedPoint = projection.project(
        ellipsoid.cartesianToCartographic(rotatedPoint, scratchCartographic3),
        scratchCartesian36
      );
      Cartesian3_default.subtract(projectedPoint, projectedCenter, projectedPoint);
      texCoordScratch.x = (projectedPoint.x + semiMajorAxis) / (2 * semiMajorAxis);
      texCoordScratch.y = (projectedPoint.y + semiMinorAxis) / (2 * semiMinorAxis);
      minTexCoord.x = Math.min(texCoordScratch.x, minTexCoord.x);
      minTexCoord.y = Math.min(texCoordScratch.y, minTexCoord.y);
      maxTexCoord.x = Math.max(texCoordScratch.x, maxTexCoord.x);
      maxTexCoord.y = Math.max(texCoordScratch.y, maxTexCoord.y);
      if (extrude) {
        textureCoordinates[textureCoordIndex + stOffset] = texCoordScratch.x;
        textureCoordinates[textureCoordIndex + 1 + stOffset] = texCoordScratch.y;
      }
      textureCoordinates[textureCoordIndex++] = texCoordScratch.x;
      textureCoordinates[textureCoordIndex++] = texCoordScratch.y;
    }
    if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent || shadowVolume) {
      normal2 = ellipsoid.geodeticSurfaceNormal(position, normal2);
      if (shadowVolume) {
        extrudeNormals[i2 + bottomOffset] = -normal2.x;
        extrudeNormals[i1 + bottomOffset] = -normal2.y;
        extrudeNormals[i22 + bottomOffset] = -normal2.z;
      }
      if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent) {
        if (vertexFormat.tangent || vertexFormat.bitangent) {
          tangent = Cartesian3_default.normalize(
            Cartesian3_default.cross(Cartesian3_default.UNIT_Z, normal2, tangent),
            tangent
          );
          Matrix3_default.multiplyByVector(tangentMatrix, tangent, tangent);
        }
        if (vertexFormat.normal) {
          normals[i2] = normal2.x;
          normals[i1] = normal2.y;
          normals[i22] = normal2.z;
          if (extrude) {
            normals[i2 + bottomOffset] = -normal2.x;
            normals[i1 + bottomOffset] = -normal2.y;
            normals[i22 + bottomOffset] = -normal2.z;
          }
        }
        if (vertexFormat.tangent) {
          tangents[i2] = tangent.x;
          tangents[i1] = tangent.y;
          tangents[i22] = tangent.z;
          if (extrude) {
            tangents[i2 + bottomOffset] = -tangent.x;
            tangents[i1 + bottomOffset] = -tangent.y;
            tangents[i22 + bottomOffset] = -tangent.z;
          }
        }
        if (vertexFormat.bitangent) {
          bitangent = Cartesian3_default.normalize(
            Cartesian3_default.cross(normal2, tangent, bitangent),
            bitangent
          );
          bitangents[i2] = bitangent.x;
          bitangents[i1] = bitangent.y;
          bitangents[i22] = bitangent.z;
          if (extrude) {
            bitangents[i2 + bottomOffset] = bitangent.x;
            bitangents[i1 + bottomOffset] = bitangent.y;
            bitangents[i22 + bottomOffset] = bitangent.z;
          }
        }
      }
    }
  }
  if (vertexFormat.st) {
    length3 = textureCoordinates.length;
    for (let k = 0; k < length3; k += 2) {
      textureCoordinates[k] = (textureCoordinates[k] - minTexCoord.x) / (maxTexCoord.x - minTexCoord.x);
      textureCoordinates[k + 1] = (textureCoordinates[k + 1] - minTexCoord.y) / (maxTexCoord.y - minTexCoord.y);
    }
  }
  const attributes = new GeometryAttributes_default();
  if (vertexFormat.position) {
    const finalPositions = EllipseGeometryLibrary_default.raisePositionsToHeight(
      positions,
      options,
      extrude
    );
    attributes.position = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: finalPositions
    });
  }
  if (vertexFormat.st) {
    attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: textureCoordinates
    });
  }
  if (vertexFormat.normal) {
    attributes.normal = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: normals
    });
  }
  if (vertexFormat.tangent) {
    attributes.tangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: tangents
    });
  }
  if (vertexFormat.bitangent) {
    attributes.bitangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: bitangents
    });
  }
  if (shadowVolume) {
    attributes.extrudeDirection = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: extrudeNormals
    });
  }
  if (extrude && defined_default(options.offsetAttribute)) {
    let offsetAttribute = new Uint8Array(size);
    if (options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
      offsetAttribute = arrayFill_default(offsetAttribute, 1, 0, size / 2);
    } else {
      const offsetValue = options.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      offsetAttribute = arrayFill_default(offsetAttribute, offsetValue);
    }
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: offsetAttribute
    });
  }
  return attributes;
}
function topIndices(numPts) {
  const indices2 = new Array(12 * (numPts * (numPts + 1)) - 6);
  let indicesIndex = 0;
  let prevIndex;
  let numInterior;
  let positionIndex;
  let i2;
  let j;
  prevIndex = 0;
  positionIndex = 1;
  for (i2 = 0; i2 < 3; i2++) {
    indices2[indicesIndex++] = positionIndex++;
    indices2[indicesIndex++] = prevIndex;
    indices2[indicesIndex++] = positionIndex;
  }
  for (i2 = 2; i2 < numPts + 1; ++i2) {
    positionIndex = i2 * (i2 + 1) - 1;
    prevIndex = (i2 - 1) * i2 - 1;
    indices2[indicesIndex++] = positionIndex++;
    indices2[indicesIndex++] = prevIndex;
    indices2[indicesIndex++] = positionIndex;
    numInterior = 2 * i2;
    for (j = 0; j < numInterior - 1; ++j) {
      indices2[indicesIndex++] = positionIndex;
      indices2[indicesIndex++] = prevIndex++;
      indices2[indicesIndex++] = prevIndex;
      indices2[indicesIndex++] = positionIndex++;
      indices2[indicesIndex++] = prevIndex;
      indices2[indicesIndex++] = positionIndex;
    }
    indices2[indicesIndex++] = positionIndex++;
    indices2[indicesIndex++] = prevIndex;
    indices2[indicesIndex++] = positionIndex;
  }
  numInterior = numPts * 2;
  ++positionIndex;
  ++prevIndex;
  for (i2 = 0; i2 < numInterior - 1; ++i2) {
    indices2[indicesIndex++] = positionIndex;
    indices2[indicesIndex++] = prevIndex++;
    indices2[indicesIndex++] = prevIndex;
    indices2[indicesIndex++] = positionIndex++;
    indices2[indicesIndex++] = prevIndex;
    indices2[indicesIndex++] = positionIndex;
  }
  indices2[indicesIndex++] = positionIndex;
  indices2[indicesIndex++] = prevIndex++;
  indices2[indicesIndex++] = prevIndex;
  indices2[indicesIndex++] = positionIndex++;
  indices2[indicesIndex++] = prevIndex++;
  indices2[indicesIndex++] = prevIndex;
  ++prevIndex;
  for (i2 = numPts - 1; i2 > 1; --i2) {
    indices2[indicesIndex++] = prevIndex++;
    indices2[indicesIndex++] = prevIndex;
    indices2[indicesIndex++] = positionIndex;
    numInterior = 2 * i2;
    for (j = 0; j < numInterior - 1; ++j) {
      indices2[indicesIndex++] = positionIndex;
      indices2[indicesIndex++] = prevIndex++;
      indices2[indicesIndex++] = prevIndex;
      indices2[indicesIndex++] = positionIndex++;
      indices2[indicesIndex++] = prevIndex;
      indices2[indicesIndex++] = positionIndex;
    }
    indices2[indicesIndex++] = prevIndex++;
    indices2[indicesIndex++] = prevIndex++;
    indices2[indicesIndex++] = positionIndex++;
  }
  for (i2 = 0; i2 < 3; i2++) {
    indices2[indicesIndex++] = prevIndex++;
    indices2[indicesIndex++] = prevIndex;
    indices2[indicesIndex++] = positionIndex;
  }
  return indices2;
}
var boundingSphereCenter = new Cartesian3_default();
function computeEllipse(options) {
  const center = options.center;
  boundingSphereCenter = Cartesian3_default.multiplyByScalar(
    options.ellipsoid.geodeticSurfaceNormal(center, boundingSphereCenter),
    options.height,
    boundingSphereCenter
  );
  boundingSphereCenter = Cartesian3_default.add(
    center,
    boundingSphereCenter,
    boundingSphereCenter
  );
  const boundingSphere = new BoundingSphere_default(
    boundingSphereCenter,
    options.semiMajorAxis
  );
  const cep = EllipseGeometryLibrary_default.computeEllipsePositions(
    options,
    true,
    false
  );
  const positions = cep.positions;
  const numPts = cep.numPts;
  const attributes = computeTopBottomAttributes(positions, options, false);
  let indices2 = topIndices(numPts);
  indices2 = IndexDatatype_default.createTypedArray(positions.length / 3, indices2);
  return {
    boundingSphere,
    attributes,
    indices: indices2
  };
}
function computeWallAttributes(positions, options) {
  const vertexFormat = options.vertexFormat;
  const center = options.center;
  const semiMajorAxis = options.semiMajorAxis;
  const semiMinorAxis = options.semiMinorAxis;
  const ellipsoid = options.ellipsoid;
  const height = options.height;
  const extrudedHeight = options.extrudedHeight;
  const stRotation = options.stRotation;
  const size = positions.length / 3 * 2;
  const finalPositions = new Float64Array(size * 3);
  const textureCoordinates = vertexFormat.st ? new Float32Array(size * 2) : void 0;
  const normals = vertexFormat.normal ? new Float32Array(size * 3) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(size * 3) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(size * 3) : void 0;
  const shadowVolume = options.shadowVolume;
  const extrudeNormals = shadowVolume ? new Float32Array(size * 3) : void 0;
  let textureCoordIndex = 0;
  let normal2 = scratchNormal3;
  let tangent = scratchTangent;
  let bitangent = scratchBitangent;
  const projection = new GeographicProjection_default(ellipsoid);
  const projectedCenter = projection.project(
    ellipsoid.cartesianToCartographic(center, scratchCartographic3),
    projectedCenterScratch
  );
  const geodeticNormal = ellipsoid.scaleToGeodeticSurface(
    center,
    scratchCartesian14
  );
  ellipsoid.geodeticSurfaceNormal(geodeticNormal, geodeticNormal);
  const rotation = Quaternion_default.fromAxisAngle(
    geodeticNormal,
    stRotation,
    quaternionScratch
  );
  const textureMatrix = Matrix3_default.fromQuaternion(rotation, textureMatrixScratch);
  const minTexCoord = Cartesian2_default.fromElements(
    Number.POSITIVE_INFINITY,
    Number.POSITIVE_INFINITY,
    scratchMinTexCoord
  );
  const maxTexCoord = Cartesian2_default.fromElements(
    Number.NEGATIVE_INFINITY,
    Number.NEGATIVE_INFINITY,
    scratchMaxTexCoord
  );
  let length3 = positions.length;
  const stOffset = length3 / 3 * 2;
  for (let i2 = 0; i2 < length3; i2 += 3) {
    const i1 = i2 + 1;
    const i22 = i2 + 2;
    let position = Cartesian3_default.fromArray(positions, i2, scratchCartesian14);
    let extrudedPosition;
    if (vertexFormat.st) {
      const rotatedPoint = Matrix3_default.multiplyByVector(
        textureMatrix,
        position,
        scratchCartesian26
      );
      const projectedPoint = projection.project(
        ellipsoid.cartesianToCartographic(rotatedPoint, scratchCartographic3),
        scratchCartesian36
      );
      Cartesian3_default.subtract(projectedPoint, projectedCenter, projectedPoint);
      texCoordScratch.x = (projectedPoint.x + semiMajorAxis) / (2 * semiMajorAxis);
      texCoordScratch.y = (projectedPoint.y + semiMinorAxis) / (2 * semiMinorAxis);
      minTexCoord.x = Math.min(texCoordScratch.x, minTexCoord.x);
      minTexCoord.y = Math.min(texCoordScratch.y, minTexCoord.y);
      maxTexCoord.x = Math.max(texCoordScratch.x, maxTexCoord.x);
      maxTexCoord.y = Math.max(texCoordScratch.y, maxTexCoord.y);
      textureCoordinates[textureCoordIndex + stOffset] = texCoordScratch.x;
      textureCoordinates[textureCoordIndex + 1 + stOffset] = texCoordScratch.y;
      textureCoordinates[textureCoordIndex++] = texCoordScratch.x;
      textureCoordinates[textureCoordIndex++] = texCoordScratch.y;
    }
    position = ellipsoid.scaleToGeodeticSurface(position, position);
    extrudedPosition = Cartesian3_default.clone(position, scratchCartesian26);
    normal2 = ellipsoid.geodeticSurfaceNormal(position, normal2);
    if (shadowVolume) {
      extrudeNormals[i2 + length3] = -normal2.x;
      extrudeNormals[i1 + length3] = -normal2.y;
      extrudeNormals[i22 + length3] = -normal2.z;
    }
    let scaledNormal = Cartesian3_default.multiplyByScalar(
      normal2,
      height,
      scratchCartesian42
    );
    position = Cartesian3_default.add(position, scaledNormal, position);
    scaledNormal = Cartesian3_default.multiplyByScalar(
      normal2,
      extrudedHeight,
      scaledNormal
    );
    extrudedPosition = Cartesian3_default.add(
      extrudedPosition,
      scaledNormal,
      extrudedPosition
    );
    if (vertexFormat.position) {
      finalPositions[i2 + length3] = extrudedPosition.x;
      finalPositions[i1 + length3] = extrudedPosition.y;
      finalPositions[i22 + length3] = extrudedPosition.z;
      finalPositions[i2] = position.x;
      finalPositions[i1] = position.y;
      finalPositions[i22] = position.z;
    }
    if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent) {
      bitangent = Cartesian3_default.clone(normal2, bitangent);
      const next = Cartesian3_default.fromArray(
        positions,
        (i2 + 3) % length3,
        scratchCartesian42
      );
      Cartesian3_default.subtract(next, position, next);
      const bottom = Cartesian3_default.subtract(
        extrudedPosition,
        position,
        scratchCartesian36
      );
      normal2 = Cartesian3_default.normalize(
        Cartesian3_default.cross(bottom, next, normal2),
        normal2
      );
      if (vertexFormat.normal) {
        normals[i2] = normal2.x;
        normals[i1] = normal2.y;
        normals[i22] = normal2.z;
        normals[i2 + length3] = normal2.x;
        normals[i1 + length3] = normal2.y;
        normals[i22 + length3] = normal2.z;
      }
      if (vertexFormat.tangent) {
        tangent = Cartesian3_default.normalize(
          Cartesian3_default.cross(bitangent, normal2, tangent),
          tangent
        );
        tangents[i2] = tangent.x;
        tangents[i1] = tangent.y;
        tangents[i22] = tangent.z;
        tangents[i2 + length3] = tangent.x;
        tangents[i2 + 1 + length3] = tangent.y;
        tangents[i2 + 2 + length3] = tangent.z;
      }
      if (vertexFormat.bitangent) {
        bitangents[i2] = bitangent.x;
        bitangents[i1] = bitangent.y;
        bitangents[i22] = bitangent.z;
        bitangents[i2 + length3] = bitangent.x;
        bitangents[i1 + length3] = bitangent.y;
        bitangents[i22 + length3] = bitangent.z;
      }
    }
  }
  if (vertexFormat.st) {
    length3 = textureCoordinates.length;
    for (let k = 0; k < length3; k += 2) {
      textureCoordinates[k] = (textureCoordinates[k] - minTexCoord.x) / (maxTexCoord.x - minTexCoord.x);
      textureCoordinates[k + 1] = (textureCoordinates[k + 1] - minTexCoord.y) / (maxTexCoord.y - minTexCoord.y);
    }
  }
  const attributes = new GeometryAttributes_default();
  if (vertexFormat.position) {
    attributes.position = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: finalPositions
    });
  }
  if (vertexFormat.st) {
    attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: textureCoordinates
    });
  }
  if (vertexFormat.normal) {
    attributes.normal = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: normals
    });
  }
  if (vertexFormat.tangent) {
    attributes.tangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: tangents
    });
  }
  if (vertexFormat.bitangent) {
    attributes.bitangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: bitangents
    });
  }
  if (shadowVolume) {
    attributes.extrudeDirection = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: extrudeNormals
    });
  }
  if (defined_default(options.offsetAttribute)) {
    let offsetAttribute = new Uint8Array(size);
    if (options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
      offsetAttribute = arrayFill_default(offsetAttribute, 1, 0, size / 2);
    } else {
      const offsetValue = options.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      offsetAttribute = arrayFill_default(offsetAttribute, offsetValue);
    }
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: offsetAttribute
    });
  }
  return attributes;
}
function computeWallIndices(positions) {
  const length3 = positions.length / 3;
  const indices2 = IndexDatatype_default.createTypedArray(length3, length3 * 6);
  let index2 = 0;
  for (let i2 = 0; i2 < length3; i2++) {
    const UL = i2;
    const LL = i2 + length3;
    const UR = (UL + 1) % length3;
    const LR = UR + length3;
    indices2[index2++] = UL;
    indices2[index2++] = LL;
    indices2[index2++] = UR;
    indices2[index2++] = UR;
    indices2[index2++] = LL;
    indices2[index2++] = LR;
  }
  return indices2;
}
var topBoundingSphere = new BoundingSphere_default();
var bottomBoundingSphere = new BoundingSphere_default();
function computeExtrudedEllipse(options) {
  const center = options.center;
  const ellipsoid = options.ellipsoid;
  const semiMajorAxis = options.semiMajorAxis;
  let scaledNormal = Cartesian3_default.multiplyByScalar(
    ellipsoid.geodeticSurfaceNormal(center, scratchCartesian14),
    options.height,
    scratchCartesian14
  );
  topBoundingSphere.center = Cartesian3_default.add(
    center,
    scaledNormal,
    topBoundingSphere.center
  );
  topBoundingSphere.radius = semiMajorAxis;
  scaledNormal = Cartesian3_default.multiplyByScalar(
    ellipsoid.geodeticSurfaceNormal(center, scaledNormal),
    options.extrudedHeight,
    scaledNormal
  );
  bottomBoundingSphere.center = Cartesian3_default.add(
    center,
    scaledNormal,
    bottomBoundingSphere.center
  );
  bottomBoundingSphere.radius = semiMajorAxis;
  const cep = EllipseGeometryLibrary_default.computeEllipsePositions(
    options,
    true,
    true
  );
  const positions = cep.positions;
  const numPts = cep.numPts;
  const outerPositions = cep.outerPositions;
  const boundingSphere = BoundingSphere_default.union(
    topBoundingSphere,
    bottomBoundingSphere
  );
  const topBottomAttributes = computeTopBottomAttributes(
    positions,
    options,
    true
  );
  let indices2 = topIndices(numPts);
  const length3 = indices2.length;
  indices2.length = length3 * 2;
  const posLength = positions.length / 3;
  for (let i2 = 0; i2 < length3; i2 += 3) {
    indices2[i2 + length3] = indices2[i2 + 2] + posLength;
    indices2[i2 + 1 + length3] = indices2[i2 + 1] + posLength;
    indices2[i2 + 2 + length3] = indices2[i2] + posLength;
  }
  const topBottomIndices = IndexDatatype_default.createTypedArray(
    posLength * 2 / 3,
    indices2
  );
  const topBottomGeo = new Geometry_default({
    attributes: topBottomAttributes,
    indices: topBottomIndices,
    primitiveType: PrimitiveType_default.TRIANGLES
  });
  const wallAttributes = computeWallAttributes(outerPositions, options);
  indices2 = computeWallIndices(outerPositions);
  const wallIndices = IndexDatatype_default.createTypedArray(
    outerPositions.length * 2 / 3,
    indices2
  );
  const wallGeo = new Geometry_default({
    attributes: wallAttributes,
    indices: wallIndices,
    primitiveType: PrimitiveType_default.TRIANGLES
  });
  const geo = GeometryPipeline_default.combineInstances([
    new GeometryInstance_default({
      geometry: topBottomGeo
    }),
    new GeometryInstance_default({
      geometry: wallGeo
    })
  ]);
  return {
    boundingSphere,
    attributes: geo[0].attributes,
    indices: geo[0].indices
  };
}
function computeRectangle(center, semiMajorAxis, semiMinorAxis, rotation, granularity, ellipsoid, result) {
  const cep = EllipseGeometryLibrary_default.computeEllipsePositions(
    {
      center,
      semiMajorAxis,
      semiMinorAxis,
      rotation,
      granularity
    },
    false,
    true
  );
  const positionsFlat = cep.outerPositions;
  const positionsCount = positionsFlat.length / 3;
  const positions = new Array(positionsCount);
  for (let i2 = 0; i2 < positionsCount; ++i2) {
    positions[i2] = Cartesian3_default.fromArray(positionsFlat, i2 * 3);
  }
  const rectangle = Rectangle_default.fromCartesianArray(positions, ellipsoid, result);
  if (rectangle.width > Math_default.PI) {
    rectangle.north = rectangle.north > 0 ? Math_default.PI_OVER_TWO - Math_default.EPSILON7 : rectangle.north;
    rectangle.south = rectangle.south < 0 ? Math_default.EPSILON7 - Math_default.PI_OVER_TWO : rectangle.south;
    rectangle.east = Math_default.PI;
    rectangle.west = -Math_default.PI;
  }
  return rectangle;
}
function EllipseGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const center = options.center;
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  const semiMajorAxis = options.semiMajorAxis;
  const semiMinorAxis = options.semiMinorAxis;
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
  Check_default.defined("options.center", center);
  Check_default.typeOf.number("options.semiMajorAxis", semiMajorAxis);
  Check_default.typeOf.number("options.semiMinorAxis", semiMinorAxis);
  if (semiMajorAxis < semiMinorAxis) {
    throw new DeveloperError_default(
      "semiMajorAxis must be greater than or equal to the semiMinorAxis."
    );
  }
  if (granularity <= 0) {
    throw new DeveloperError_default("granularity must be greater than zero.");
  }
  const height = defaultValue_default(options.height, 0);
  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
  this._center = Cartesian3_default.clone(center);
  this._semiMajorAxis = semiMajorAxis;
  this._semiMinorAxis = semiMinorAxis;
  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
  this._rotation = defaultValue_default(options.rotation, 0);
  this._stRotation = defaultValue_default(options.stRotation, 0);
  this._height = Math.max(extrudedHeight, height);
  this._granularity = granularity;
  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
  this._extrudedHeight = Math.min(extrudedHeight, height);
  this._shadowVolume = defaultValue_default(options.shadowVolume, false);
  this._workerName = "createEllipseGeometry";
  this._offsetAttribute = options.offsetAttribute;
  this._rectangle = void 0;
  this._textureCoordinateRotationPoints = void 0;
}
EllipseGeometry.packedLength = Cartesian3_default.packedLength + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 9;
EllipseGeometry.pack = function(value, array, startingIndex) {
  Check_default.defined("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  Cartesian3_default.pack(value._center, array, startingIndex);
  startingIndex += Cartesian3_default.packedLength;
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex++] = value._semiMajorAxis;
  array[startingIndex++] = value._semiMinorAxis;
  array[startingIndex++] = value._rotation;
  array[startingIndex++] = value._stRotation;
  array[startingIndex++] = value._height;
  array[startingIndex++] = value._granularity;
  array[startingIndex++] = value._extrudedHeight;
  array[startingIndex++] = value._shadowVolume ? 1 : 0;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchCenter2 = new Cartesian3_default();
var scratchEllipsoid = new Ellipsoid_default();
var scratchVertexFormat2 = new VertexFormat_default();
var scratchOptions3 = {
  center: scratchCenter2,
  ellipsoid: scratchEllipsoid,
  vertexFormat: scratchVertexFormat2,
  semiMajorAxis: void 0,
  semiMinorAxis: void 0,
  rotation: void 0,
  stRotation: void 0,
  height: void 0,
  granularity: void 0,
  extrudedHeight: void 0,
  shadowVolume: void 0,
  offsetAttribute: void 0
};
EllipseGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const center = Cartesian3_default.unpack(array, startingIndex, scratchCenter2);
  startingIndex += Cartesian3_default.packedLength;
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
  startingIndex += Ellipsoid_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat2
  );
  startingIndex += VertexFormat_default.packedLength;
  const semiMajorAxis = array[startingIndex++];
  const semiMinorAxis = array[startingIndex++];
  const rotation = array[startingIndex++];
  const stRotation = array[startingIndex++];
  const height = array[startingIndex++];
  const granularity = array[startingIndex++];
  const extrudedHeight = array[startingIndex++];
  const shadowVolume = array[startingIndex++] === 1;
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions3.height = height;
    scratchOptions3.extrudedHeight = extrudedHeight;
    scratchOptions3.granularity = granularity;
    scratchOptions3.stRotation = stRotation;
    scratchOptions3.rotation = rotation;
    scratchOptions3.semiMajorAxis = semiMajorAxis;
    scratchOptions3.semiMinorAxis = semiMinorAxis;
    scratchOptions3.shadowVolume = shadowVolume;
    scratchOptions3.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new EllipseGeometry(scratchOptions3);
  }
  result._center = Cartesian3_default.clone(center, result._center);
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._semiMajorAxis = semiMajorAxis;
  result._semiMinorAxis = semiMinorAxis;
  result._rotation = rotation;
  result._stRotation = stRotation;
  result._height = height;
  result._granularity = granularity;
  result._extrudedHeight = extrudedHeight;
  result._shadowVolume = shadowVolume;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
EllipseGeometry.computeRectangle = function(options, result) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const center = options.center;
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  const semiMajorAxis = options.semiMajorAxis;
  const semiMinorAxis = options.semiMinorAxis;
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  const rotation = defaultValue_default(options.rotation, 0);
  Check_default.defined("options.center", center);
  Check_default.typeOf.number("options.semiMajorAxis", semiMajorAxis);
  Check_default.typeOf.number("options.semiMinorAxis", semiMinorAxis);
  if (semiMajorAxis < semiMinorAxis) {
    throw new DeveloperError_default(
      "semiMajorAxis must be greater than or equal to the semiMinorAxis."
    );
  }
  if (granularity <= 0) {
    throw new DeveloperError_default("granularity must be greater than zero.");
  }
  return computeRectangle(
    center,
    semiMajorAxis,
    semiMinorAxis,
    rotation,
    granularity,
    ellipsoid,
    result
  );
};
EllipseGeometry.createGeometry = function(ellipseGeometry) {
  if (ellipseGeometry._semiMajorAxis <= 0 || ellipseGeometry._semiMinorAxis <= 0) {
    return;
  }
  const height = ellipseGeometry._height;
  const extrudedHeight = ellipseGeometry._extrudedHeight;
  const extrude = !Math_default.equalsEpsilon(
    height,
    extrudedHeight,
    0,
    Math_default.EPSILON2
  );
  ellipseGeometry._center = ellipseGeometry._ellipsoid.scaleToGeodeticSurface(
    ellipseGeometry._center,
    ellipseGeometry._center
  );
  const options = {
    center: ellipseGeometry._center,
    semiMajorAxis: ellipseGeometry._semiMajorAxis,
    semiMinorAxis: ellipseGeometry._semiMinorAxis,
    ellipsoid: ellipseGeometry._ellipsoid,
    rotation: ellipseGeometry._rotation,
    height,
    granularity: ellipseGeometry._granularity,
    vertexFormat: ellipseGeometry._vertexFormat,
    stRotation: ellipseGeometry._stRotation
  };
  let geometry;
  if (extrude) {
    options.extrudedHeight = extrudedHeight;
    options.shadowVolume = ellipseGeometry._shadowVolume;
    options.offsetAttribute = ellipseGeometry._offsetAttribute;
    geometry = computeExtrudedEllipse(options);
  } else {
    geometry = computeEllipse(options);
    if (defined_default(ellipseGeometry._offsetAttribute)) {
      const length3 = geometry.attributes.position.values.length;
      const applyOffset = new Uint8Array(length3 / 3);
      const offsetValue = ellipseGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      arrayFill_default(applyOffset, offsetValue);
      geometry.attributes.applyOffset = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
        componentsPerAttribute: 1,
        values: applyOffset
      });
    }
  }
  return new Geometry_default({
    attributes: geometry.attributes,
    indices: geometry.indices,
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingSphere: geometry.boundingSphere,
    offsetAttribute: ellipseGeometry._offsetAttribute
  });
};
EllipseGeometry.createShadowVolume = function(ellipseGeometry, minHeightFunc, maxHeightFunc) {
  const granularity = ellipseGeometry._granularity;
  const ellipsoid = ellipseGeometry._ellipsoid;
  const minHeight = minHeightFunc(granularity, ellipsoid);
  const maxHeight = maxHeightFunc(granularity, ellipsoid);
  return new EllipseGeometry({
    center: ellipseGeometry._center,
    semiMajorAxis: ellipseGeometry._semiMajorAxis,
    semiMinorAxis: ellipseGeometry._semiMinorAxis,
    ellipsoid,
    rotation: ellipseGeometry._rotation,
    stRotation: ellipseGeometry._stRotation,
    granularity,
    extrudedHeight: minHeight,
    height: maxHeight,
    vertexFormat: VertexFormat_default.POSITION_ONLY,
    shadowVolume: true
  });
};
function textureCoordinateRotationPoints(ellipseGeometry) {
  const stRotation = -ellipseGeometry._stRotation;
  if (stRotation === 0) {
    return [0, 0, 0, 1, 1, 0];
  }
  const cep = EllipseGeometryLibrary_default.computeEllipsePositions(
    {
      center: ellipseGeometry._center,
      semiMajorAxis: ellipseGeometry._semiMajorAxis,
      semiMinorAxis: ellipseGeometry._semiMinorAxis,
      rotation: ellipseGeometry._rotation,
      granularity: ellipseGeometry._granularity
    },
    false,
    true
  );
  const positionsFlat = cep.outerPositions;
  const positionsCount = positionsFlat.length / 3;
  const positions = new Array(positionsCount);
  for (let i2 = 0; i2 < positionsCount; ++i2) {
    positions[i2] = Cartesian3_default.fromArray(positionsFlat, i2 * 3);
  }
  const ellipsoid = ellipseGeometry._ellipsoid;
  const boundingRectangle = ellipseGeometry.rectangle;
  return Geometry_default._textureCoordinateRotationPoints(
    positions,
    stRotation,
    ellipsoid,
    boundingRectangle
  );
}
Object.defineProperties(EllipseGeometry.prototype, {
  rectangle: {
    get: function() {
      if (!defined_default(this._rectangle)) {
        this._rectangle = computeRectangle(
          this._center,
          this._semiMajorAxis,
          this._semiMinorAxis,
          this._rotation,
          this._granularity,
          this._ellipsoid
        );
      }
      return this._rectangle;
    }
  },
  textureCoordinateRotationPoints: {
    get: function() {
      if (!defined_default(this._textureCoordinateRotationPoints)) {
        this._textureCoordinateRotationPoints = textureCoordinateRotationPoints(
          this
        );
      }
      return this._textureCoordinateRotationPoints;
    }
  }
});
var EllipseGeometry_default = EllipseGeometry;

// node_modules/cesium/Source/Core/CircleGeometry.js
function CircleGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const radius = options.radius;
  Check_default.typeOf.number("radius", radius);
  const ellipseGeometryOptions = {
    center: options.center,
    semiMajorAxis: radius,
    semiMinorAxis: radius,
    ellipsoid: options.ellipsoid,
    height: options.height,
    extrudedHeight: options.extrudedHeight,
    granularity: options.granularity,
    vertexFormat: options.vertexFormat,
    stRotation: options.stRotation,
    shadowVolume: options.shadowVolume
  };
  this._ellipseGeometry = new EllipseGeometry_default(ellipseGeometryOptions);
  this._workerName = "createCircleGeometry";
}
CircleGeometry.packedLength = EllipseGeometry_default.packedLength;
CircleGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  return EllipseGeometry_default.pack(value._ellipseGeometry, array, startingIndex);
};
var scratchEllipseGeometry = new EllipseGeometry_default({
  center: new Cartesian3_default(),
  semiMajorAxis: 1,
  semiMinorAxis: 1
});
var scratchOptions4 = {
  center: new Cartesian3_default(),
  radius: void 0,
  ellipsoid: Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE),
  height: void 0,
  extrudedHeight: void 0,
  granularity: void 0,
  vertexFormat: new VertexFormat_default(),
  stRotation: void 0,
  semiMajorAxis: void 0,
  semiMinorAxis: void 0,
  shadowVolume: void 0
};
CircleGeometry.unpack = function(array, startingIndex, result) {
  const ellipseGeometry = EllipseGeometry_default.unpack(
    array,
    startingIndex,
    scratchEllipseGeometry
  );
  scratchOptions4.center = Cartesian3_default.clone(
    ellipseGeometry._center,
    scratchOptions4.center
  );
  scratchOptions4.ellipsoid = Ellipsoid_default.clone(
    ellipseGeometry._ellipsoid,
    scratchOptions4.ellipsoid
  );
  scratchOptions4.height = ellipseGeometry._height;
  scratchOptions4.extrudedHeight = ellipseGeometry._extrudedHeight;
  scratchOptions4.granularity = ellipseGeometry._granularity;
  scratchOptions4.vertexFormat = VertexFormat_default.clone(
    ellipseGeometry._vertexFormat,
    scratchOptions4.vertexFormat
  );
  scratchOptions4.stRotation = ellipseGeometry._stRotation;
  scratchOptions4.shadowVolume = ellipseGeometry._shadowVolume;
  if (!defined_default(result)) {
    scratchOptions4.radius = ellipseGeometry._semiMajorAxis;
    return new CircleGeometry(scratchOptions4);
  }
  scratchOptions4.semiMajorAxis = ellipseGeometry._semiMajorAxis;
  scratchOptions4.semiMinorAxis = ellipseGeometry._semiMinorAxis;
  result._ellipseGeometry = new EllipseGeometry_default(scratchOptions4);
  return result;
};
CircleGeometry.createGeometry = function(circleGeometry) {
  return EllipseGeometry_default.createGeometry(circleGeometry._ellipseGeometry);
};
CircleGeometry.createShadowVolume = function(circleGeometry, minHeightFunc, maxHeightFunc) {
  const granularity = circleGeometry._ellipseGeometry._granularity;
  const ellipsoid = circleGeometry._ellipseGeometry._ellipsoid;
  const minHeight = minHeightFunc(granularity, ellipsoid);
  const maxHeight = maxHeightFunc(granularity, ellipsoid);
  return new CircleGeometry({
    center: circleGeometry._ellipseGeometry._center,
    radius: circleGeometry._ellipseGeometry._semiMajorAxis,
    ellipsoid,
    stRotation: circleGeometry._ellipseGeometry._stRotation,
    granularity,
    extrudedHeight: minHeight,
    height: maxHeight,
    vertexFormat: VertexFormat_default.POSITION_ONLY,
    shadowVolume: true
  });
};
Object.defineProperties(CircleGeometry.prototype, {
  rectangle: {
    get: function() {
      return this._ellipseGeometry.rectangle;
    }
  },
  textureCoordinateRotationPoints: {
    get: function() {
      return this._ellipseGeometry.textureCoordinateRotationPoints;
    }
  }
});
var CircleGeometry_default = CircleGeometry;

// node_modules/cesium/Source/Core/EllipseOutlineGeometry.js
var scratchCartesian15 = new Cartesian3_default();
var boundingSphereCenter2 = new Cartesian3_default();
function computeEllipse2(options) {
  const center = options.center;
  boundingSphereCenter2 = Cartesian3_default.multiplyByScalar(
    options.ellipsoid.geodeticSurfaceNormal(center, boundingSphereCenter2),
    options.height,
    boundingSphereCenter2
  );
  boundingSphereCenter2 = Cartesian3_default.add(
    center,
    boundingSphereCenter2,
    boundingSphereCenter2
  );
  const boundingSphere = new BoundingSphere_default(
    boundingSphereCenter2,
    options.semiMajorAxis
  );
  const positions = EllipseGeometryLibrary_default.computeEllipsePositions(
    options,
    false,
    true
  ).outerPositions;
  const attributes = new GeometryAttributes_default({
    position: new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: EllipseGeometryLibrary_default.raisePositionsToHeight(
        positions,
        options,
        false
      )
    })
  });
  const length3 = positions.length / 3;
  const indices2 = IndexDatatype_default.createTypedArray(length3, length3 * 2);
  let index2 = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    indices2[index2++] = i2;
    indices2[index2++] = (i2 + 1) % length3;
  }
  return {
    boundingSphere,
    attributes,
    indices: indices2
  };
}
var topBoundingSphere2 = new BoundingSphere_default();
var bottomBoundingSphere2 = new BoundingSphere_default();
function computeExtrudedEllipse2(options) {
  const center = options.center;
  const ellipsoid = options.ellipsoid;
  const semiMajorAxis = options.semiMajorAxis;
  let scaledNormal = Cartesian3_default.multiplyByScalar(
    ellipsoid.geodeticSurfaceNormal(center, scratchCartesian15),
    options.height,
    scratchCartesian15
  );
  topBoundingSphere2.center = Cartesian3_default.add(
    center,
    scaledNormal,
    topBoundingSphere2.center
  );
  topBoundingSphere2.radius = semiMajorAxis;
  scaledNormal = Cartesian3_default.multiplyByScalar(
    ellipsoid.geodeticSurfaceNormal(center, scaledNormal),
    options.extrudedHeight,
    scaledNormal
  );
  bottomBoundingSphere2.center = Cartesian3_default.add(
    center,
    scaledNormal,
    bottomBoundingSphere2.center
  );
  bottomBoundingSphere2.radius = semiMajorAxis;
  let positions = EllipseGeometryLibrary_default.computeEllipsePositions(
    options,
    false,
    true
  ).outerPositions;
  const attributes = new GeometryAttributes_default({
    position: new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: EllipseGeometryLibrary_default.raisePositionsToHeight(
        positions,
        options,
        true
      )
    })
  });
  positions = attributes.position.values;
  const boundingSphere = BoundingSphere_default.union(
    topBoundingSphere2,
    bottomBoundingSphere2
  );
  let length3 = positions.length / 3;
  if (defined_default(options.offsetAttribute)) {
    let applyOffset = new Uint8Array(length3);
    if (options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
      applyOffset = arrayFill_default(applyOffset, 1, 0, length3 / 2);
    } else {
      const offsetValue = options.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      applyOffset = arrayFill_default(applyOffset, offsetValue);
    }
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: applyOffset
    });
  }
  let numberOfVerticalLines = defaultValue_default(options.numberOfVerticalLines, 16);
  numberOfVerticalLines = Math_default.clamp(
    numberOfVerticalLines,
    0,
    length3 / 2
  );
  const indices2 = IndexDatatype_default.createTypedArray(
    length3,
    length3 * 2 + numberOfVerticalLines * 2
  );
  length3 /= 2;
  let index2 = 0;
  let i2;
  for (i2 = 0; i2 < length3; ++i2) {
    indices2[index2++] = i2;
    indices2[index2++] = (i2 + 1) % length3;
    indices2[index2++] = i2 + length3;
    indices2[index2++] = (i2 + 1) % length3 + length3;
  }
  let numSide;
  if (numberOfVerticalLines > 0) {
    const numSideLines = Math.min(numberOfVerticalLines, length3);
    numSide = Math.round(length3 / numSideLines);
    const maxI = Math.min(numSide * numberOfVerticalLines, length3);
    for (i2 = 0; i2 < maxI; i2 += numSide) {
      indices2[index2++] = i2;
      indices2[index2++] = i2 + length3;
    }
  }
  return {
    boundingSphere,
    attributes,
    indices: indices2
  };
}
function EllipseOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const center = options.center;
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  const semiMajorAxis = options.semiMajorAxis;
  const semiMinorAxis = options.semiMinorAxis;
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  if (!defined_default(center)) {
    throw new DeveloperError_default("center is required.");
  }
  if (!defined_default(semiMajorAxis)) {
    throw new DeveloperError_default("semiMajorAxis is required.");
  }
  if (!defined_default(semiMinorAxis)) {
    throw new DeveloperError_default("semiMinorAxis is required.");
  }
  if (semiMajorAxis < semiMinorAxis) {
    throw new DeveloperError_default(
      "semiMajorAxis must be greater than or equal to the semiMinorAxis."
    );
  }
  if (granularity <= 0) {
    throw new DeveloperError_default("granularity must be greater than zero.");
  }
  const height = defaultValue_default(options.height, 0);
  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
  this._center = Cartesian3_default.clone(center);
  this._semiMajorAxis = semiMajorAxis;
  this._semiMinorAxis = semiMinorAxis;
  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
  this._rotation = defaultValue_default(options.rotation, 0);
  this._height = Math.max(extrudedHeight, height);
  this._granularity = granularity;
  this._extrudedHeight = Math.min(extrudedHeight, height);
  this._numberOfVerticalLines = Math.max(
    defaultValue_default(options.numberOfVerticalLines, 16),
    0
  );
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createEllipseOutlineGeometry";
}
EllipseOutlineGeometry.packedLength = Cartesian3_default.packedLength + Ellipsoid_default.packedLength + 8;
EllipseOutlineGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  Cartesian3_default.pack(value._center, array, startingIndex);
  startingIndex += Cartesian3_default.packedLength;
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  array[startingIndex++] = value._semiMajorAxis;
  array[startingIndex++] = value._semiMinorAxis;
  array[startingIndex++] = value._rotation;
  array[startingIndex++] = value._height;
  array[startingIndex++] = value._granularity;
  array[startingIndex++] = value._extrudedHeight;
  array[startingIndex++] = value._numberOfVerticalLines;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchCenter3 = new Cartesian3_default();
var scratchEllipsoid2 = new Ellipsoid_default();
var scratchOptions5 = {
  center: scratchCenter3,
  ellipsoid: scratchEllipsoid2,
  semiMajorAxis: void 0,
  semiMinorAxis: void 0,
  rotation: void 0,
  height: void 0,
  granularity: void 0,
  extrudedHeight: void 0,
  numberOfVerticalLines: void 0,
  offsetAttribute: void 0
};
EllipseOutlineGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  const center = Cartesian3_default.unpack(array, startingIndex, scratchCenter3);
  startingIndex += Cartesian3_default.packedLength;
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid2);
  startingIndex += Ellipsoid_default.packedLength;
  const semiMajorAxis = array[startingIndex++];
  const semiMinorAxis = array[startingIndex++];
  const rotation = array[startingIndex++];
  const height = array[startingIndex++];
  const granularity = array[startingIndex++];
  const extrudedHeight = array[startingIndex++];
  const numberOfVerticalLines = array[startingIndex++];
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions5.height = height;
    scratchOptions5.extrudedHeight = extrudedHeight;
    scratchOptions5.granularity = granularity;
    scratchOptions5.rotation = rotation;
    scratchOptions5.semiMajorAxis = semiMajorAxis;
    scratchOptions5.semiMinorAxis = semiMinorAxis;
    scratchOptions5.numberOfVerticalLines = numberOfVerticalLines;
    scratchOptions5.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new EllipseOutlineGeometry(scratchOptions5);
  }
  result._center = Cartesian3_default.clone(center, result._center);
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._semiMajorAxis = semiMajorAxis;
  result._semiMinorAxis = semiMinorAxis;
  result._rotation = rotation;
  result._height = height;
  result._granularity = granularity;
  result._extrudedHeight = extrudedHeight;
  result._numberOfVerticalLines = numberOfVerticalLines;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
EllipseOutlineGeometry.createGeometry = function(ellipseGeometry) {
  if (ellipseGeometry._semiMajorAxis <= 0 || ellipseGeometry._semiMinorAxis <= 0) {
    return;
  }
  const height = ellipseGeometry._height;
  const extrudedHeight = ellipseGeometry._extrudedHeight;
  const extrude = !Math_default.equalsEpsilon(
    height,
    extrudedHeight,
    0,
    Math_default.EPSILON2
  );
  ellipseGeometry._center = ellipseGeometry._ellipsoid.scaleToGeodeticSurface(
    ellipseGeometry._center,
    ellipseGeometry._center
  );
  const options = {
    center: ellipseGeometry._center,
    semiMajorAxis: ellipseGeometry._semiMajorAxis,
    semiMinorAxis: ellipseGeometry._semiMinorAxis,
    ellipsoid: ellipseGeometry._ellipsoid,
    rotation: ellipseGeometry._rotation,
    height,
    granularity: ellipseGeometry._granularity,
    numberOfVerticalLines: ellipseGeometry._numberOfVerticalLines
  };
  let geometry;
  if (extrude) {
    options.extrudedHeight = extrudedHeight;
    options.offsetAttribute = ellipseGeometry._offsetAttribute;
    geometry = computeExtrudedEllipse2(options);
  } else {
    geometry = computeEllipse2(options);
    if (defined_default(ellipseGeometry._offsetAttribute)) {
      const length3 = geometry.attributes.position.values.length;
      const applyOffset = new Uint8Array(length3 / 3);
      const offsetValue = ellipseGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      arrayFill_default(applyOffset, offsetValue);
      geometry.attributes.applyOffset = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
        componentsPerAttribute: 1,
        values: applyOffset
      });
    }
  }
  return new Geometry_default({
    attributes: geometry.attributes,
    indices: geometry.indices,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere: geometry.boundingSphere,
    offsetAttribute: ellipseGeometry._offsetAttribute
  });
};
var EllipseOutlineGeometry_default = EllipseOutlineGeometry;

// node_modules/cesium/Source/Core/CircleOutlineGeometry.js
function CircleOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const radius = options.radius;
  Check_default.typeOf.number("radius", radius);
  const ellipseGeometryOptions = {
    center: options.center,
    semiMajorAxis: radius,
    semiMinorAxis: radius,
    ellipsoid: options.ellipsoid,
    height: options.height,
    extrudedHeight: options.extrudedHeight,
    granularity: options.granularity,
    numberOfVerticalLines: options.numberOfVerticalLines
  };
  this._ellipseGeometry = new EllipseOutlineGeometry_default(ellipseGeometryOptions);
  this._workerName = "createCircleOutlineGeometry";
}
CircleOutlineGeometry.packedLength = EllipseOutlineGeometry_default.packedLength;
CircleOutlineGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  return EllipseOutlineGeometry_default.pack(
    value._ellipseGeometry,
    array,
    startingIndex
  );
};
var scratchEllipseGeometry2 = new EllipseOutlineGeometry_default({
  center: new Cartesian3_default(),
  semiMajorAxis: 1,
  semiMinorAxis: 1
});
var scratchOptions6 = {
  center: new Cartesian3_default(),
  radius: void 0,
  ellipsoid: Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE),
  height: void 0,
  extrudedHeight: void 0,
  granularity: void 0,
  numberOfVerticalLines: void 0,
  semiMajorAxis: void 0,
  semiMinorAxis: void 0
};
CircleOutlineGeometry.unpack = function(array, startingIndex, result) {
  const ellipseGeometry = EllipseOutlineGeometry_default.unpack(
    array,
    startingIndex,
    scratchEllipseGeometry2
  );
  scratchOptions6.center = Cartesian3_default.clone(
    ellipseGeometry._center,
    scratchOptions6.center
  );
  scratchOptions6.ellipsoid = Ellipsoid_default.clone(
    ellipseGeometry._ellipsoid,
    scratchOptions6.ellipsoid
  );
  scratchOptions6.height = ellipseGeometry._height;
  scratchOptions6.extrudedHeight = ellipseGeometry._extrudedHeight;
  scratchOptions6.granularity = ellipseGeometry._granularity;
  scratchOptions6.numberOfVerticalLines = ellipseGeometry._numberOfVerticalLines;
  if (!defined_default(result)) {
    scratchOptions6.radius = ellipseGeometry._semiMajorAxis;
    return new CircleOutlineGeometry(scratchOptions6);
  }
  scratchOptions6.semiMajorAxis = ellipseGeometry._semiMajorAxis;
  scratchOptions6.semiMinorAxis = ellipseGeometry._semiMinorAxis;
  result._ellipseGeometry = new EllipseOutlineGeometry_default(scratchOptions6);
  return result;
};
CircleOutlineGeometry.createGeometry = function(circleGeometry) {
  return EllipseOutlineGeometry_default.createGeometry(circleGeometry._ellipseGeometry);
};
var CircleOutlineGeometry_default = CircleOutlineGeometry;

// node_modules/cesium/Source/Core/ClockRange.js
var ClockRange = {
  UNBOUNDED: 0,
  CLAMPED: 1,
  LOOP_STOP: 2
};
var ClockRange_default = Object.freeze(ClockRange);

// node_modules/cesium/Source/Core/ClockStep.js
var ClockStep = {
  TICK_DEPENDENT: 0,
  SYSTEM_CLOCK_MULTIPLIER: 1,
  SYSTEM_CLOCK: 2
};
var ClockStep_default = Object.freeze(ClockStep);

// node_modules/cesium/Source/Core/getTimestamp.js
var getTimestamp;
if (typeof performance !== "undefined" && typeof performance.now === "function" && isFinite(performance.now())) {
  getTimestamp = function() {
    return performance.now();
  };
} else {
  getTimestamp = function() {
    return Date.now();
  };
}
var getTimestamp_default = getTimestamp;

// node_modules/cesium/Source/Core/Clock.js
function Clock(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let currentTime = options.currentTime;
  let startTime = options.startTime;
  let stopTime = options.stopTime;
  if (!defined_default(currentTime)) {
    if (defined_default(startTime)) {
      currentTime = JulianDate_default.clone(startTime);
    } else if (defined_default(stopTime)) {
      currentTime = JulianDate_default.addDays(stopTime, -1, new JulianDate_default());
    } else {
      currentTime = JulianDate_default.now();
    }
  } else {
    currentTime = JulianDate_default.clone(currentTime);
  }
  if (!defined_default(startTime)) {
    startTime = JulianDate_default.clone(currentTime);
  } else {
    startTime = JulianDate_default.clone(startTime);
  }
  if (!defined_default(stopTime)) {
    stopTime = JulianDate_default.addDays(startTime, 1, new JulianDate_default());
  } else {
    stopTime = JulianDate_default.clone(stopTime);
  }
  if (JulianDate_default.greaterThan(startTime, stopTime)) {
    throw new DeveloperError_default("startTime must come before stopTime.");
  }
  this.startTime = startTime;
  this.stopTime = stopTime;
  this.clockRange = defaultValue_default(options.clockRange, ClockRange_default.UNBOUNDED);
  this.canAnimate = defaultValue_default(options.canAnimate, true);
  this.onTick = new Event_default();
  this.onStop = new Event_default();
  this._currentTime = void 0;
  this._multiplier = void 0;
  this._clockStep = void 0;
  this._shouldAnimate = void 0;
  this._lastSystemTime = getTimestamp_default();
  this.currentTime = currentTime;
  this.multiplier = defaultValue_default(options.multiplier, 1);
  this.shouldAnimate = defaultValue_default(options.shouldAnimate, false);
  this.clockStep = defaultValue_default(
    options.clockStep,
    ClockStep_default.SYSTEM_CLOCK_MULTIPLIER
  );
}
Object.defineProperties(Clock.prototype, {
  currentTime: {
    get: function() {
      return this._currentTime;
    },
    set: function(value) {
      if (JulianDate_default.equals(this._currentTime, value)) {
        return;
      }
      if (this._clockStep === ClockStep_default.SYSTEM_CLOCK) {
        this._clockStep = ClockStep_default.SYSTEM_CLOCK_MULTIPLIER;
      }
      this._currentTime = value;
    }
  },
  multiplier: {
    get: function() {
      return this._multiplier;
    },
    set: function(value) {
      if (this._multiplier === value) {
        return;
      }
      if (this._clockStep === ClockStep_default.SYSTEM_CLOCK) {
        this._clockStep = ClockStep_default.SYSTEM_CLOCK_MULTIPLIER;
      }
      this._multiplier = value;
    }
  },
  clockStep: {
    get: function() {
      return this._clockStep;
    },
    set: function(value) {
      if (value === ClockStep_default.SYSTEM_CLOCK) {
        this._multiplier = 1;
        this._shouldAnimate = true;
        this._currentTime = JulianDate_default.now();
      }
      this._clockStep = value;
    }
  },
  shouldAnimate: {
    get: function() {
      return this._shouldAnimate;
    },
    set: function(value) {
      if (this._shouldAnimate === value) {
        return;
      }
      if (this._clockStep === ClockStep_default.SYSTEM_CLOCK) {
        this._clockStep = ClockStep_default.SYSTEM_CLOCK_MULTIPLIER;
      }
      this._shouldAnimate = value;
    }
  }
});
Clock.prototype.tick = function() {
  const currentSystemTime = getTimestamp_default();
  let currentTime = JulianDate_default.clone(this._currentTime);
  if (this.canAnimate && this._shouldAnimate) {
    const clockStep = this._clockStep;
    if (clockStep === ClockStep_default.SYSTEM_CLOCK) {
      currentTime = JulianDate_default.now(currentTime);
    } else {
      const multiplier = this._multiplier;
      if (clockStep === ClockStep_default.TICK_DEPENDENT) {
        currentTime = JulianDate_default.addSeconds(
          currentTime,
          multiplier,
          currentTime
        );
      } else {
        const milliseconds = currentSystemTime - this._lastSystemTime;
        currentTime = JulianDate_default.addSeconds(
          currentTime,
          multiplier * (milliseconds / 1e3),
          currentTime
        );
      }
      const clockRange = this.clockRange;
      const startTime = this.startTime;
      const stopTime = this.stopTime;
      if (clockRange === ClockRange_default.CLAMPED) {
        if (JulianDate_default.lessThan(currentTime, startTime)) {
          currentTime = JulianDate_default.clone(startTime, currentTime);
        } else if (JulianDate_default.greaterThan(currentTime, stopTime)) {
          currentTime = JulianDate_default.clone(stopTime, currentTime);
          this.onStop.raiseEvent(this);
        }
      } else if (clockRange === ClockRange_default.LOOP_STOP) {
        if (JulianDate_default.lessThan(currentTime, startTime)) {
          currentTime = JulianDate_default.clone(startTime, currentTime);
        }
        while (JulianDate_default.greaterThan(currentTime, stopTime)) {
          currentTime = JulianDate_default.addSeconds(
            startTime,
            JulianDate_default.secondsDifference(currentTime, stopTime),
            currentTime
          );
          this.onStop.raiseEvent(this);
        }
      }
    }
  }
  this._currentTime = currentTime;
  this._lastSystemTime = currentSystemTime;
  this.onTick.raiseEvent(this);
  return currentTime;
};
var Clock_default = Clock;

// node_modules/cesium/Source/Core/Color.js
function hue2rgb(m1, m2, h) {
  if (h < 0) {
    h += 1;
  }
  if (h > 1) {
    h -= 1;
  }
  if (h * 6 < 1) {
    return m1 + (m2 - m1) * 6 * h;
  }
  if (h * 2 < 1) {
    return m2;
  }
  if (h * 3 < 2) {
    return m1 + (m2 - m1) * (2 / 3 - h) * 6;
  }
  return m1;
}
function Color(red, green, blue, alpha) {
  this.red = defaultValue_default(red, 1);
  this.green = defaultValue_default(green, 1);
  this.blue = defaultValue_default(blue, 1);
  this.alpha = defaultValue_default(alpha, 1);
}
Color.fromCartesian4 = function(cartesian11, result) {
  Check_default.typeOf.object("cartesian", cartesian11);
  if (!defined_default(result)) {
    return new Color(cartesian11.x, cartesian11.y, cartesian11.z, cartesian11.w);
  }
  result.red = cartesian11.x;
  result.green = cartesian11.y;
  result.blue = cartesian11.z;
  result.alpha = cartesian11.w;
  return result;
};
Color.fromBytes = function(red, green, blue, alpha, result) {
  red = Color.byteToFloat(defaultValue_default(red, 255));
  green = Color.byteToFloat(defaultValue_default(green, 255));
  blue = Color.byteToFloat(defaultValue_default(blue, 255));
  alpha = Color.byteToFloat(defaultValue_default(alpha, 255));
  if (!defined_default(result)) {
    return new Color(red, green, blue, alpha);
  }
  result.red = red;
  result.green = green;
  result.blue = blue;
  result.alpha = alpha;
  return result;
};
Color.fromAlpha = function(color, alpha, result) {
  Check_default.typeOf.object("color", color);
  Check_default.typeOf.number("alpha", alpha);
  if (!defined_default(result)) {
    return new Color(color.red, color.green, color.blue, alpha);
  }
  result.red = color.red;
  result.green = color.green;
  result.blue = color.blue;
  result.alpha = alpha;
  return result;
};
var scratchArrayBuffer;
var scratchUint32Array;
var scratchUint8Array;
if (FeatureDetection_default.supportsTypedArrays()) {
  scratchArrayBuffer = new ArrayBuffer(4);
  scratchUint32Array = new Uint32Array(scratchArrayBuffer);
  scratchUint8Array = new Uint8Array(scratchArrayBuffer);
}
Color.fromRgba = function(rgba, result) {
  scratchUint32Array[0] = rgba;
  return Color.fromBytes(
    scratchUint8Array[0],
    scratchUint8Array[1],
    scratchUint8Array[2],
    scratchUint8Array[3],
    result
  );
};
Color.fromHsl = function(hue, saturation, lightness, alpha, result) {
  hue = defaultValue_default(hue, 0) % 1;
  saturation = defaultValue_default(saturation, 0);
  lightness = defaultValue_default(lightness, 0);
  alpha = defaultValue_default(alpha, 1);
  let red = lightness;
  let green = lightness;
  let blue = lightness;
  if (saturation !== 0) {
    let m2;
    if (lightness < 0.5) {
      m2 = lightness * (1 + saturation);
    } else {
      m2 = lightness + saturation - lightness * saturation;
    }
    const m1 = 2 * lightness - m2;
    red = hue2rgb(m1, m2, hue + 1 / 3);
    green = hue2rgb(m1, m2, hue);
    blue = hue2rgb(m1, m2, hue - 1 / 3);
  }
  if (!defined_default(result)) {
    return new Color(red, green, blue, alpha);
  }
  result.red = red;
  result.green = green;
  result.blue = blue;
  result.alpha = alpha;
  return result;
};
Color.fromRandom = function(options, result) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let red = options.red;
  if (!defined_default(red)) {
    const minimumRed = defaultValue_default(options.minimumRed, 0);
    const maximumRed = defaultValue_default(options.maximumRed, 1);
    Check_default.typeOf.number.lessThanOrEquals("minimumRed", minimumRed, maximumRed);
    red = minimumRed + Math_default.nextRandomNumber() * (maximumRed - minimumRed);
  }
  let green = options.green;
  if (!defined_default(green)) {
    const minimumGreen = defaultValue_default(options.minimumGreen, 0);
    const maximumGreen = defaultValue_default(options.maximumGreen, 1);
    Check_default.typeOf.number.lessThanOrEquals(
      "minimumGreen",
      minimumGreen,
      maximumGreen
    );
    green = minimumGreen + Math_default.nextRandomNumber() * (maximumGreen - minimumGreen);
  }
  let blue = options.blue;
  if (!defined_default(blue)) {
    const minimumBlue = defaultValue_default(options.minimumBlue, 0);
    const maximumBlue = defaultValue_default(options.maximumBlue, 1);
    Check_default.typeOf.number.lessThanOrEquals(
      "minimumBlue",
      minimumBlue,
      maximumBlue
    );
    blue = minimumBlue + Math_default.nextRandomNumber() * (maximumBlue - minimumBlue);
  }
  let alpha = options.alpha;
  if (!defined_default(alpha)) {
    const minimumAlpha = defaultValue_default(options.minimumAlpha, 0);
    const maximumAlpha = defaultValue_default(options.maximumAlpha, 1);
    Check_default.typeOf.number.lessThanOrEquals(
      "minumumAlpha",
      minimumAlpha,
      maximumAlpha
    );
    alpha = minimumAlpha + Math_default.nextRandomNumber() * (maximumAlpha - minimumAlpha);
  }
  if (!defined_default(result)) {
    return new Color(red, green, blue, alpha);
  }
  result.red = red;
  result.green = green;
  result.blue = blue;
  result.alpha = alpha;
  return result;
};
var rgbaMatcher = /^#([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])?$/i;
var rrggbbaaMatcher = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})?$/i;
var rgbParenthesesMatcher = /^rgba?\(\s*([0-9.]+%?)\s*,\s*([0-9.]+%?)\s*,\s*([0-9.]+%?)(?:\s*,\s*([0-9.]+))?\s*\)$/i;
var hslParenthesesMatcher = /^hsla?\(\s*([0-9.]+)\s*,\s*([0-9.]+%)\s*,\s*([0-9.]+%)(?:\s*,\s*([0-9.]+))?\s*\)$/i;
Color.fromCssColorString = function(color, result) {
  Check_default.typeOf.string("color", color);
  if (!defined_default(result)) {
    result = new Color();
  }
  color = color.replace(/\s/g, "");
  const namedColor = Color[color.toUpperCase()];
  if (defined_default(namedColor)) {
    Color.clone(namedColor, result);
    return result;
  }
  let matches = rgbaMatcher.exec(color);
  if (matches !== null) {
    result.red = parseInt(matches[1], 16) / 15;
    result.green = parseInt(matches[2], 16) / 15;
    result.blue = parseInt(matches[3], 16) / 15;
    result.alpha = parseInt(defaultValue_default(matches[4], "f"), 16) / 15;
    return result;
  }
  matches = rrggbbaaMatcher.exec(color);
  if (matches !== null) {
    result.red = parseInt(matches[1], 16) / 255;
    result.green = parseInt(matches[2], 16) / 255;
    result.blue = parseInt(matches[3], 16) / 255;
    result.alpha = parseInt(defaultValue_default(matches[4], "ff"), 16) / 255;
    return result;
  }
  matches = rgbParenthesesMatcher.exec(color);
  if (matches !== null) {
    result.red = parseFloat(matches[1]) / ("%" === matches[1].substr(-1) ? 100 : 255);
    result.green = parseFloat(matches[2]) / ("%" === matches[2].substr(-1) ? 100 : 255);
    result.blue = parseFloat(matches[3]) / ("%" === matches[3].substr(-1) ? 100 : 255);
    result.alpha = parseFloat(defaultValue_default(matches[4], "1.0"));
    return result;
  }
  matches = hslParenthesesMatcher.exec(color);
  if (matches !== null) {
    return Color.fromHsl(
      parseFloat(matches[1]) / 360,
      parseFloat(matches[2]) / 100,
      parseFloat(matches[3]) / 100,
      parseFloat(defaultValue_default(matches[4], "1.0")),
      result
    );
  }
  result = void 0;
  return result;
};
Color.packedLength = 4;
Color.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.red;
  array[startingIndex++] = value.green;
  array[startingIndex++] = value.blue;
  array[startingIndex] = value.alpha;
  return array;
};
Color.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new Color();
  }
  result.red = array[startingIndex++];
  result.green = array[startingIndex++];
  result.blue = array[startingIndex++];
  result.alpha = array[startingIndex];
  return result;
};
Color.byteToFloat = function(number) {
  return number / 255;
};
Color.floatToByte = function(number) {
  return number === 1 ? 255 : number * 256 | 0;
};
Color.clone = function(color, result) {
  if (!defined_default(color)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Color(color.red, color.green, color.blue, color.alpha);
  }
  result.red = color.red;
  result.green = color.green;
  result.blue = color.blue;
  result.alpha = color.alpha;
  return result;
};
Color.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.red === right.red && left.green === right.green && left.blue === right.blue && left.alpha === right.alpha;
};
Color.equalsArray = function(color, array, offset2) {
  return color.red === array[offset2] && color.green === array[offset2 + 1] && color.blue === array[offset2 + 2] && color.alpha === array[offset2 + 3];
};
Color.prototype.clone = function(result) {
  return Color.clone(this, result);
};
Color.prototype.equals = function(other) {
  return Color.equals(this, other);
};
Color.prototype.equalsEpsilon = function(other, epsilon) {
  return this === other || defined_default(other) && Math.abs(this.red - other.red) <= epsilon && Math.abs(this.green - other.green) <= epsilon && Math.abs(this.blue - other.blue) <= epsilon && Math.abs(this.alpha - other.alpha) <= epsilon;
};
Color.prototype.toString = function() {
  return `(${this.red}, ${this.green}, ${this.blue}, ${this.alpha})`;
};
Color.prototype.toCssColorString = function() {
  const red = Color.floatToByte(this.red);
  const green = Color.floatToByte(this.green);
  const blue = Color.floatToByte(this.blue);
  if (this.alpha === 1) {
    return `rgb(${red},${green},${blue})`;
  }
  return `rgba(${red},${green},${blue},${this.alpha})`;
};
Color.prototype.toCssHexString = function() {
  let r2 = Color.floatToByte(this.red).toString(16);
  if (r2.length < 2) {
    r2 = `0${r2}`;
  }
  let g = Color.floatToByte(this.green).toString(16);
  if (g.length < 2) {
    g = `0${g}`;
  }
  let b = Color.floatToByte(this.blue).toString(16);
  if (b.length < 2) {
    b = `0${b}`;
  }
  if (this.alpha < 1) {
    let hexAlpha = Color.floatToByte(this.alpha).toString(16);
    if (hexAlpha.length < 2) {
      hexAlpha = `0${hexAlpha}`;
    }
    return `#${r2}${g}${b}${hexAlpha}`;
  }
  return `#${r2}${g}${b}`;
};
Color.prototype.toBytes = function(result) {
  const red = Color.floatToByte(this.red);
  const green = Color.floatToByte(this.green);
  const blue = Color.floatToByte(this.blue);
  const alpha = Color.floatToByte(this.alpha);
  if (!defined_default(result)) {
    return [red, green, blue, alpha];
  }
  result[0] = red;
  result[1] = green;
  result[2] = blue;
  result[3] = alpha;
  return result;
};
Color.prototype.toRgba = function() {
  scratchUint8Array[0] = Color.floatToByte(this.red);
  scratchUint8Array[1] = Color.floatToByte(this.green);
  scratchUint8Array[2] = Color.floatToByte(this.blue);
  scratchUint8Array[3] = Color.floatToByte(this.alpha);
  return scratchUint32Array[0];
};
Color.prototype.brighten = function(magnitude, result) {
  Check_default.typeOf.number("magnitude", magnitude);
  Check_default.typeOf.number.greaterThanOrEquals("magnitude", magnitude, 0);
  Check_default.typeOf.object("result", result);
  magnitude = 1 - magnitude;
  result.red = 1 - (1 - this.red) * magnitude;
  result.green = 1 - (1 - this.green) * magnitude;
  result.blue = 1 - (1 - this.blue) * magnitude;
  result.alpha = this.alpha;
  return result;
};
Color.prototype.darken = function(magnitude, result) {
  Check_default.typeOf.number("magnitude", magnitude);
  Check_default.typeOf.number.greaterThanOrEquals("magnitude", magnitude, 0);
  Check_default.typeOf.object("result", result);
  magnitude = 1 - magnitude;
  result.red = this.red * magnitude;
  result.green = this.green * magnitude;
  result.blue = this.blue * magnitude;
  result.alpha = this.alpha;
  return result;
};
Color.prototype.withAlpha = function(alpha, result) {
  return Color.fromAlpha(this, alpha, result);
};
Color.add = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.red = left.red + right.red;
  result.green = left.green + right.green;
  result.blue = left.blue + right.blue;
  result.alpha = left.alpha + right.alpha;
  return result;
};
Color.subtract = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.red = left.red - right.red;
  result.green = left.green - right.green;
  result.blue = left.blue - right.blue;
  result.alpha = left.alpha - right.alpha;
  return result;
};
Color.multiply = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.red = left.red * right.red;
  result.green = left.green * right.green;
  result.blue = left.blue * right.blue;
  result.alpha = left.alpha * right.alpha;
  return result;
};
Color.divide = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.red = left.red / right.red;
  result.green = left.green / right.green;
  result.blue = left.blue / right.blue;
  result.alpha = left.alpha / right.alpha;
  return result;
};
Color.mod = function(left, right, result) {
  Check_default.typeOf.object("left", left);
  Check_default.typeOf.object("right", right);
  Check_default.typeOf.object("result", result);
  result.red = left.red % right.red;
  result.green = left.green % right.green;
  result.blue = left.blue % right.blue;
  result.alpha = left.alpha % right.alpha;
  return result;
};
Color.lerp = function(start, end, t, result) {
  Check_default.typeOf.object("start", start);
  Check_default.typeOf.object("end", end);
  Check_default.typeOf.number("t", t);
  Check_default.typeOf.object("result", result);
  result.red = Math_default.lerp(start.red, end.red, t);
  result.green = Math_default.lerp(start.green, end.green, t);
  result.blue = Math_default.lerp(start.blue, end.blue, t);
  result.alpha = Math_default.lerp(start.alpha, end.alpha, t);
  return result;
};
Color.multiplyByScalar = function(color, scalar, result) {
  Check_default.typeOf.object("color", color);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.red = color.red * scalar;
  result.green = color.green * scalar;
  result.blue = color.blue * scalar;
  result.alpha = color.alpha * scalar;
  return result;
};
Color.divideByScalar = function(color, scalar, result) {
  Check_default.typeOf.object("color", color);
  Check_default.typeOf.number("scalar", scalar);
  Check_default.typeOf.object("result", result);
  result.red = color.red / scalar;
  result.green = color.green / scalar;
  result.blue = color.blue / scalar;
  result.alpha = color.alpha / scalar;
  return result;
};
Color.ALICEBLUE = Object.freeze(Color.fromCssColorString("#F0F8FF"));
Color.ANTIQUEWHITE = Object.freeze(Color.fromCssColorString("#FAEBD7"));
Color.AQUA = Object.freeze(Color.fromCssColorString("#00FFFF"));
Color.AQUAMARINE = Object.freeze(Color.fromCssColorString("#7FFFD4"));
Color.AZURE = Object.freeze(Color.fromCssColorString("#F0FFFF"));
Color.BEIGE = Object.freeze(Color.fromCssColorString("#F5F5DC"));
Color.BISQUE = Object.freeze(Color.fromCssColorString("#FFE4C4"));
Color.BLACK = Object.freeze(Color.fromCssColorString("#000000"));
Color.BLANCHEDALMOND = Object.freeze(Color.fromCssColorString("#FFEBCD"));
Color.BLUE = Object.freeze(Color.fromCssColorString("#0000FF"));
Color.BLUEVIOLET = Object.freeze(Color.fromCssColorString("#8A2BE2"));
Color.BROWN = Object.freeze(Color.fromCssColorString("#A52A2A"));
Color.BURLYWOOD = Object.freeze(Color.fromCssColorString("#DEB887"));
Color.CADETBLUE = Object.freeze(Color.fromCssColorString("#5F9EA0"));
Color.CHARTREUSE = Object.freeze(Color.fromCssColorString("#7FFF00"));
Color.CHOCOLATE = Object.freeze(Color.fromCssColorString("#D2691E"));
Color.CORAL = Object.freeze(Color.fromCssColorString("#FF7F50"));
Color.CORNFLOWERBLUE = Object.freeze(Color.fromCssColorString("#6495ED"));
Color.CORNSILK = Object.freeze(Color.fromCssColorString("#FFF8DC"));
Color.CRIMSON = Object.freeze(Color.fromCssColorString("#DC143C"));
Color.CYAN = Object.freeze(Color.fromCssColorString("#00FFFF"));
Color.DARKBLUE = Object.freeze(Color.fromCssColorString("#00008B"));
Color.DARKCYAN = Object.freeze(Color.fromCssColorString("#008B8B"));
Color.DARKGOLDENROD = Object.freeze(Color.fromCssColorString("#B8860B"));
Color.DARKGRAY = Object.freeze(Color.fromCssColorString("#A9A9A9"));
Color.DARKGREEN = Object.freeze(Color.fromCssColorString("#006400"));
Color.DARKGREY = Color.DARKGRAY;
Color.DARKKHAKI = Object.freeze(Color.fromCssColorString("#BDB76B"));
Color.DARKMAGENTA = Object.freeze(Color.fromCssColorString("#8B008B"));
Color.DARKOLIVEGREEN = Object.freeze(Color.fromCssColorString("#556B2F"));
Color.DARKORANGE = Object.freeze(Color.fromCssColorString("#FF8C00"));
Color.DARKORCHID = Object.freeze(Color.fromCssColorString("#9932CC"));
Color.DARKRED = Object.freeze(Color.fromCssColorString("#8B0000"));
Color.DARKSALMON = Object.freeze(Color.fromCssColorString("#E9967A"));
Color.DARKSEAGREEN = Object.freeze(Color.fromCssColorString("#8FBC8F"));
Color.DARKSLATEBLUE = Object.freeze(Color.fromCssColorString("#483D8B"));
Color.DARKSLATEGRAY = Object.freeze(Color.fromCssColorString("#2F4F4F"));
Color.DARKSLATEGREY = Color.DARKSLATEGRAY;
Color.DARKTURQUOISE = Object.freeze(Color.fromCssColorString("#00CED1"));
Color.DARKVIOLET = Object.freeze(Color.fromCssColorString("#9400D3"));
Color.DEEPPINK = Object.freeze(Color.fromCssColorString("#FF1493"));
Color.DEEPSKYBLUE = Object.freeze(Color.fromCssColorString("#00BFFF"));
Color.DIMGRAY = Object.freeze(Color.fromCssColorString("#696969"));
Color.DIMGREY = Color.DIMGRAY;
Color.DODGERBLUE = Object.freeze(Color.fromCssColorString("#1E90FF"));
Color.FIREBRICK = Object.freeze(Color.fromCssColorString("#B22222"));
Color.FLORALWHITE = Object.freeze(Color.fromCssColorString("#FFFAF0"));
Color.FORESTGREEN = Object.freeze(Color.fromCssColorString("#228B22"));
Color.FUCHSIA = Object.freeze(Color.fromCssColorString("#FF00FF"));
Color.GAINSBORO = Object.freeze(Color.fromCssColorString("#DCDCDC"));
Color.GHOSTWHITE = Object.freeze(Color.fromCssColorString("#F8F8FF"));
Color.GOLD = Object.freeze(Color.fromCssColorString("#FFD700"));
Color.GOLDENROD = Object.freeze(Color.fromCssColorString("#DAA520"));
Color.GRAY = Object.freeze(Color.fromCssColorString("#808080"));
Color.GREEN = Object.freeze(Color.fromCssColorString("#008000"));
Color.GREENYELLOW = Object.freeze(Color.fromCssColorString("#ADFF2F"));
Color.GREY = Color.GRAY;
Color.HONEYDEW = Object.freeze(Color.fromCssColorString("#F0FFF0"));
Color.HOTPINK = Object.freeze(Color.fromCssColorString("#FF69B4"));
Color.INDIANRED = Object.freeze(Color.fromCssColorString("#CD5C5C"));
Color.INDIGO = Object.freeze(Color.fromCssColorString("#4B0082"));
Color.IVORY = Object.freeze(Color.fromCssColorString("#FFFFF0"));
Color.KHAKI = Object.freeze(Color.fromCssColorString("#F0E68C"));
Color.LAVENDER = Object.freeze(Color.fromCssColorString("#E6E6FA"));
Color.LAVENDAR_BLUSH = Object.freeze(Color.fromCssColorString("#FFF0F5"));
Color.LAWNGREEN = Object.freeze(Color.fromCssColorString("#7CFC00"));
Color.LEMONCHIFFON = Object.freeze(Color.fromCssColorString("#FFFACD"));
Color.LIGHTBLUE = Object.freeze(Color.fromCssColorString("#ADD8E6"));
Color.LIGHTCORAL = Object.freeze(Color.fromCssColorString("#F08080"));
Color.LIGHTCYAN = Object.freeze(Color.fromCssColorString("#E0FFFF"));
Color.LIGHTGOLDENRODYELLOW = Object.freeze(Color.fromCssColorString("#FAFAD2"));
Color.LIGHTGRAY = Object.freeze(Color.fromCssColorString("#D3D3D3"));
Color.LIGHTGREEN = Object.freeze(Color.fromCssColorString("#90EE90"));
Color.LIGHTGREY = Color.LIGHTGRAY;
Color.LIGHTPINK = Object.freeze(Color.fromCssColorString("#FFB6C1"));
Color.LIGHTSEAGREEN = Object.freeze(Color.fromCssColorString("#20B2AA"));
Color.LIGHTSKYBLUE = Object.freeze(Color.fromCssColorString("#87CEFA"));
Color.LIGHTSLATEGRAY = Object.freeze(Color.fromCssColorString("#778899"));
Color.LIGHTSLATEGREY = Color.LIGHTSLATEGRAY;
Color.LIGHTSTEELBLUE = Object.freeze(Color.fromCssColorString("#B0C4DE"));
Color.LIGHTYELLOW = Object.freeze(Color.fromCssColorString("#FFFFE0"));
Color.LIME = Object.freeze(Color.fromCssColorString("#00FF00"));
Color.LIMEGREEN = Object.freeze(Color.fromCssColorString("#32CD32"));
Color.LINEN = Object.freeze(Color.fromCssColorString("#FAF0E6"));
Color.MAGENTA = Object.freeze(Color.fromCssColorString("#FF00FF"));
Color.MAROON = Object.freeze(Color.fromCssColorString("#800000"));
Color.MEDIUMAQUAMARINE = Object.freeze(Color.fromCssColorString("#66CDAA"));
Color.MEDIUMBLUE = Object.freeze(Color.fromCssColorString("#0000CD"));
Color.MEDIUMORCHID = Object.freeze(Color.fromCssColorString("#BA55D3"));
Color.MEDIUMPURPLE = Object.freeze(Color.fromCssColorString("#9370DB"));
Color.MEDIUMSEAGREEN = Object.freeze(Color.fromCssColorString("#3CB371"));
Color.MEDIUMSLATEBLUE = Object.freeze(Color.fromCssColorString("#7B68EE"));
Color.MEDIUMSPRINGGREEN = Object.freeze(Color.fromCssColorString("#00FA9A"));
Color.MEDIUMTURQUOISE = Object.freeze(Color.fromCssColorString("#48D1CC"));
Color.MEDIUMVIOLETRED = Object.freeze(Color.fromCssColorString("#C71585"));
Color.MIDNIGHTBLUE = Object.freeze(Color.fromCssColorString("#191970"));
Color.MINTCREAM = Object.freeze(Color.fromCssColorString("#F5FFFA"));
Color.MISTYROSE = Object.freeze(Color.fromCssColorString("#FFE4E1"));
Color.MOCCASIN = Object.freeze(Color.fromCssColorString("#FFE4B5"));
Color.NAVAJOWHITE = Object.freeze(Color.fromCssColorString("#FFDEAD"));
Color.NAVY = Object.freeze(Color.fromCssColorString("#000080"));
Color.OLDLACE = Object.freeze(Color.fromCssColorString("#FDF5E6"));
Color.OLIVE = Object.freeze(Color.fromCssColorString("#808000"));
Color.OLIVEDRAB = Object.freeze(Color.fromCssColorString("#6B8E23"));
Color.ORANGE = Object.freeze(Color.fromCssColorString("#FFA500"));
Color.ORANGERED = Object.freeze(Color.fromCssColorString("#FF4500"));
Color.ORCHID = Object.freeze(Color.fromCssColorString("#DA70D6"));
Color.PALEGOLDENROD = Object.freeze(Color.fromCssColorString("#EEE8AA"));
Color.PALEGREEN = Object.freeze(Color.fromCssColorString("#98FB98"));
Color.PALETURQUOISE = Object.freeze(Color.fromCssColorString("#AFEEEE"));
Color.PALEVIOLETRED = Object.freeze(Color.fromCssColorString("#DB7093"));
Color.PAPAYAWHIP = Object.freeze(Color.fromCssColorString("#FFEFD5"));
Color.PEACHPUFF = Object.freeze(Color.fromCssColorString("#FFDAB9"));
Color.PERU = Object.freeze(Color.fromCssColorString("#CD853F"));
Color.PINK = Object.freeze(Color.fromCssColorString("#FFC0CB"));
Color.PLUM = Object.freeze(Color.fromCssColorString("#DDA0DD"));
Color.POWDERBLUE = Object.freeze(Color.fromCssColorString("#B0E0E6"));
Color.PURPLE = Object.freeze(Color.fromCssColorString("#800080"));
Color.RED = Object.freeze(Color.fromCssColorString("#FF0000"));
Color.ROSYBROWN = Object.freeze(Color.fromCssColorString("#BC8F8F"));
Color.ROYALBLUE = Object.freeze(Color.fromCssColorString("#4169E1"));
Color.SADDLEBROWN = Object.freeze(Color.fromCssColorString("#8B4513"));
Color.SALMON = Object.freeze(Color.fromCssColorString("#FA8072"));
Color.SANDYBROWN = Object.freeze(Color.fromCssColorString("#F4A460"));
Color.SEAGREEN = Object.freeze(Color.fromCssColorString("#2E8B57"));
Color.SEASHELL = Object.freeze(Color.fromCssColorString("#FFF5EE"));
Color.SIENNA = Object.freeze(Color.fromCssColorString("#A0522D"));
Color.SILVER = Object.freeze(Color.fromCssColorString("#C0C0C0"));
Color.SKYBLUE = Object.freeze(Color.fromCssColorString("#87CEEB"));
Color.SLATEBLUE = Object.freeze(Color.fromCssColorString("#6A5ACD"));
Color.SLATEGRAY = Object.freeze(Color.fromCssColorString("#708090"));
Color.SLATEGREY = Color.SLATEGRAY;
Color.SNOW = Object.freeze(Color.fromCssColorString("#FFFAFA"));
Color.SPRINGGREEN = Object.freeze(Color.fromCssColorString("#00FF7F"));
Color.STEELBLUE = Object.freeze(Color.fromCssColorString("#4682B4"));
Color.TAN = Object.freeze(Color.fromCssColorString("#D2B48C"));
Color.TEAL = Object.freeze(Color.fromCssColorString("#008080"));
Color.THISTLE = Object.freeze(Color.fromCssColorString("#D8BFD8"));
Color.TOMATO = Object.freeze(Color.fromCssColorString("#FF6347"));
Color.TURQUOISE = Object.freeze(Color.fromCssColorString("#40E0D0"));
Color.VIOLET = Object.freeze(Color.fromCssColorString("#EE82EE"));
Color.WHEAT = Object.freeze(Color.fromCssColorString("#F5DEB3"));
Color.WHITE = Object.freeze(Color.fromCssColorString("#FFFFFF"));
Color.WHITESMOKE = Object.freeze(Color.fromCssColorString("#F5F5F5"));
Color.YELLOW = Object.freeze(Color.fromCssColorString("#FFFF00"));
Color.YELLOWGREEN = Object.freeze(Color.fromCssColorString("#9ACD32"));
Color.TRANSPARENT = Object.freeze(new Color(0, 0, 0, 0));
var Color_default = Color;

// node_modules/cesium/Source/Core/ColorGeometryInstanceAttribute.js
function ColorGeometryInstanceAttribute(red, green, blue, alpha) {
  red = defaultValue_default(red, 1);
  green = defaultValue_default(green, 1);
  blue = defaultValue_default(blue, 1);
  alpha = defaultValue_default(alpha, 1);
  this.value = new Uint8Array([
    Color_default.floatToByte(red),
    Color_default.floatToByte(green),
    Color_default.floatToByte(blue),
    Color_default.floatToByte(alpha)
  ]);
}
Object.defineProperties(ColorGeometryInstanceAttribute.prototype, {
  componentDatatype: {
    get: function() {
      return ComponentDatatype_default.UNSIGNED_BYTE;
    }
  },
  componentsPerAttribute: {
    get: function() {
      return 4;
    }
  },
  normalize: {
    get: function() {
      return true;
    }
  }
});
ColorGeometryInstanceAttribute.fromColor = function(color) {
  if (!defined_default(color)) {
    throw new DeveloperError_default("color is required.");
  }
  return new ColorGeometryInstanceAttribute(
    color.red,
    color.green,
    color.blue,
    color.alpha
  );
};
ColorGeometryInstanceAttribute.toValue = function(color, result) {
  if (!defined_default(color)) {
    throw new DeveloperError_default("color is required.");
  }
  if (!defined_default(result)) {
    return new Uint8Array(color.toBytes());
  }
  return color.toBytes(result);
};
ColorGeometryInstanceAttribute.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.value[0] === right.value[0] && left.value[1] === right.value[1] && left.value[2] === right.value[2] && left.value[3] === right.value[3];
};
var ColorGeometryInstanceAttribute_default = ColorGeometryInstanceAttribute;

// node_modules/cesium/Source/Core/CompressedTextureBuffer.js
function CompressedTextureBuffer(internalFormat, pixelDatatype, width, height, buffer) {
  this._format = internalFormat;
  this._datatype = pixelDatatype;
  this._width = width;
  this._height = height;
  this._buffer = buffer;
}
Object.defineProperties(CompressedTextureBuffer.prototype, {
  internalFormat: {
    get: function() {
      return this._format;
    }
  },
  pixelDatatype: {
    get: function() {
      return this._datatype;
    }
  },
  width: {
    get: function() {
      return this._width;
    }
  },
  height: {
    get: function() {
      return this._height;
    }
  },
  bufferView: {
    get: function() {
      return this._buffer;
    }
  }
});
CompressedTextureBuffer.clone = function(object2) {
  if (!defined_default(object2)) {
    return void 0;
  }
  return new CompressedTextureBuffer(
    object2._format,
    object2._datatype,
    object2._width,
    object2._height,
    object2._buffer
  );
};
CompressedTextureBuffer.prototype.clone = function() {
  return CompressedTextureBuffer.clone(this);
};
var CompressedTextureBuffer_default = CompressedTextureBuffer;

// node_modules/cesium/Source/Core/ConstantSpline.js
function ConstantSpline(value) {
  this._value = value;
  this._valueType = Spline_default.getPointType(value);
}
Object.defineProperties(ConstantSpline.prototype, {
  value: {
    get: function() {
      return this._value;
    }
  }
});
ConstantSpline.prototype.findTimeInterval = function(time) {
  throw new DeveloperError_default(
    "findTimeInterval cannot be called on a ConstantSpline."
  );
};
ConstantSpline.prototype.wrapTime = function(time) {
  Check_default.typeOf.number("time", time);
  return 0;
};
ConstantSpline.prototype.clampTime = function(time) {
  Check_default.typeOf.number("time", time);
  return 0;
};
ConstantSpline.prototype.evaluate = function(time, result) {
  Check_default.typeOf.number("time", time);
  const value = this._value;
  const ValueType = this._valueType;
  if (ValueType === Number) {
    return value;
  }
  return ValueType.clone(value, result);
};
var ConstantSpline_default = ConstantSpline;

// node_modules/cesium/Source/Core/arrayRemoveDuplicates.js
var removeDuplicatesEpsilon = Math_default.EPSILON10;
function arrayRemoveDuplicates(values, equalsEpsilon, wrapAround, removedIndices) {
  Check_default.defined("equalsEpsilon", equalsEpsilon);
  if (!defined_default(values)) {
    return void 0;
  }
  wrapAround = defaultValue_default(wrapAround, false);
  const storeRemovedIndices = defined_default(removedIndices);
  const length3 = values.length;
  if (length3 < 2) {
    return values;
  }
  let i2;
  let v02 = values[0];
  let v13;
  let cleanedValues;
  let lastCleanIndex = 0;
  let removedIndexLCI = -1;
  for (i2 = 1; i2 < length3; ++i2) {
    v13 = values[i2];
    if (equalsEpsilon(v02, v13, removeDuplicatesEpsilon)) {
      if (!defined_default(cleanedValues)) {
        cleanedValues = values.slice(0, i2);
        lastCleanIndex = i2 - 1;
        removedIndexLCI = 0;
      }
      if (storeRemovedIndices) {
        removedIndices.push(i2);
      }
    } else {
      if (defined_default(cleanedValues)) {
        cleanedValues.push(v13);
        lastCleanIndex = i2;
        if (storeRemovedIndices) {
          removedIndexLCI = removedIndices.length;
        }
      }
      v02 = v13;
    }
  }
  if (wrapAround && equalsEpsilon(values[0], values[length3 - 1], removeDuplicatesEpsilon)) {
    if (storeRemovedIndices) {
      if (defined_default(cleanedValues)) {
        removedIndices.splice(removedIndexLCI, 0, lastCleanIndex);
      } else {
        removedIndices.push(length3 - 1);
      }
    }
    if (defined_default(cleanedValues)) {
      cleanedValues.length -= 1;
    } else {
      cleanedValues = values.slice(0, -1);
    }
  }
  return defined_default(cleanedValues) ? cleanedValues : values;
}
var arrayRemoveDuplicates_default = arrayRemoveDuplicates;

// node_modules/cesium/Source/Core/CoplanarPolygonGeometryLibrary.js
var CoplanarPolygonGeometryLibrary = {};
var scratchIntersectionPoint = new Cartesian3_default();
var scratchXAxis2 = new Cartesian3_default();
var scratchYAxis2 = new Cartesian3_default();
var scratchZAxis2 = new Cartesian3_default();
var obbScratch = new OrientedBoundingBox_default();
CoplanarPolygonGeometryLibrary.validOutline = function(positions) {
  Check_default.defined("positions", positions);
  const orientedBoundingBox = OrientedBoundingBox_default.fromPoints(
    positions,
    obbScratch
  );
  const halfAxes = orientedBoundingBox.halfAxes;
  const xAxis = Matrix3_default.getColumn(halfAxes, 0, scratchXAxis2);
  const yAxis = Matrix3_default.getColumn(halfAxes, 1, scratchYAxis2);
  const zAxis = Matrix3_default.getColumn(halfAxes, 2, scratchZAxis2);
  const xMag = Cartesian3_default.magnitude(xAxis);
  const yMag = Cartesian3_default.magnitude(yAxis);
  const zMag = Cartesian3_default.magnitude(zAxis);
  return !(xMag === 0 && (yMag === 0 || zMag === 0) || yMag === 0 && zMag === 0);
};
CoplanarPolygonGeometryLibrary.computeProjectTo2DArguments = function(positions, centerResult, planeAxis1Result, planeAxis2Result) {
  Check_default.defined("positions", positions);
  Check_default.defined("centerResult", centerResult);
  Check_default.defined("planeAxis1Result", planeAxis1Result);
  Check_default.defined("planeAxis2Result", planeAxis2Result);
  const orientedBoundingBox = OrientedBoundingBox_default.fromPoints(
    positions,
    obbScratch
  );
  const halfAxes = orientedBoundingBox.halfAxes;
  const xAxis = Matrix3_default.getColumn(halfAxes, 0, scratchXAxis2);
  const yAxis = Matrix3_default.getColumn(halfAxes, 1, scratchYAxis2);
  const zAxis = Matrix3_default.getColumn(halfAxes, 2, scratchZAxis2);
  const xMag = Cartesian3_default.magnitude(xAxis);
  const yMag = Cartesian3_default.magnitude(yAxis);
  const zMag = Cartesian3_default.magnitude(zAxis);
  const min3 = Math.min(xMag, yMag, zMag);
  if (xMag === 0 && (yMag === 0 || zMag === 0) || yMag === 0 && zMag === 0) {
    return false;
  }
  let planeAxis1;
  let planeAxis2;
  if (min3 === yMag || min3 === zMag) {
    planeAxis1 = xAxis;
  }
  if (min3 === xMag) {
    planeAxis1 = yAxis;
  } else if (min3 === zMag) {
    planeAxis2 = yAxis;
  }
  if (min3 === xMag || min3 === yMag) {
    planeAxis2 = zAxis;
  }
  Cartesian3_default.normalize(planeAxis1, planeAxis1Result);
  Cartesian3_default.normalize(planeAxis2, planeAxis2Result);
  Cartesian3_default.clone(orientedBoundingBox.center, centerResult);
  return true;
};
function projectTo2D(position, center, axis1, axis2, result) {
  const v7 = Cartesian3_default.subtract(position, center, scratchIntersectionPoint);
  const x = Cartesian3_default.dot(axis1, v7);
  const y = Cartesian3_default.dot(axis2, v7);
  return Cartesian2_default.fromElements(x, y, result);
}
CoplanarPolygonGeometryLibrary.createProjectPointsTo2DFunction = function(center, axis1, axis2) {
  return function(positions) {
    const positionResults = new Array(positions.length);
    for (let i2 = 0; i2 < positions.length; i2++) {
      positionResults[i2] = projectTo2D(positions[i2], center, axis1, axis2);
    }
    return positionResults;
  };
};
CoplanarPolygonGeometryLibrary.createProjectPointTo2DFunction = function(center, axis1, axis2) {
  return function(position, result) {
    return projectTo2D(position, center, axis1, axis2, result);
  };
};
var CoplanarPolygonGeometryLibrary_default = CoplanarPolygonGeometryLibrary;

// node_modules/cesium/Source/Core/EllipsoidRhumbLine.js
function calculateM(ellipticity, major, latitude) {
  if (ellipticity === 0) {
    return major * latitude;
  }
  const e2 = ellipticity * ellipticity;
  const e4 = e2 * e2;
  const e6 = e4 * e2;
  const e8 = e6 * e2;
  const e10 = e8 * e2;
  const e12 = e10 * e2;
  const phi = latitude;
  const sin2Phi = Math.sin(2 * phi);
  const sin4Phi = Math.sin(4 * phi);
  const sin6Phi = Math.sin(6 * phi);
  const sin8Phi = Math.sin(8 * phi);
  const sin10Phi = Math.sin(10 * phi);
  const sin12Phi = Math.sin(12 * phi);
  return major * ((1 - e2 / 4 - 3 * e4 / 64 - 5 * e6 / 256 - 175 * e8 / 16384 - 441 * e10 / 65536 - 4851 * e12 / 1048576) * phi - (3 * e2 / 8 + 3 * e4 / 32 + 45 * e6 / 1024 + 105 * e8 / 4096 + 2205 * e10 / 131072 + 6237 * e12 / 524288) * sin2Phi + (15 * e4 / 256 + 45 * e6 / 1024 + 525 * e8 / 16384 + 1575 * e10 / 65536 + 155925 * e12 / 8388608) * sin4Phi - (35 * e6 / 3072 + 175 * e8 / 12288 + 3675 * e10 / 262144 + 13475 * e12 / 1048576) * sin6Phi + (315 * e8 / 131072 + 2205 * e10 / 524288 + 43659 * e12 / 8388608) * sin8Phi - (693 * e10 / 1310720 + 6237 * e12 / 5242880) * sin10Phi + 1001 * e12 / 8388608 * sin12Phi);
}
function calculateInverseM(M, ellipticity, major) {
  const d = M / major;
  if (ellipticity === 0) {
    return d;
  }
  const d2 = d * d;
  const d3 = d2 * d;
  const d4 = d3 * d;
  const e2 = ellipticity;
  const e22 = e2 * e2;
  const e4 = e22 * e22;
  const e6 = e4 * e22;
  const e8 = e6 * e22;
  const e10 = e8 * e22;
  const e12 = e10 * e22;
  const sin2D = Math.sin(2 * d);
  const cos2D = Math.cos(2 * d);
  const sin4D = Math.sin(4 * d);
  const cos4D = Math.cos(4 * d);
  const sin6D = Math.sin(6 * d);
  const cos6D = Math.cos(6 * d);
  const sin8D = Math.sin(8 * d);
  const cos8D = Math.cos(8 * d);
  const sin10D = Math.sin(10 * d);
  const cos10D = Math.cos(10 * d);
  const sin12D = Math.sin(12 * d);
  return d + d * e22 / 4 + 7 * d * e4 / 64 + 15 * d * e6 / 256 + 579 * d * e8 / 16384 + 1515 * d * e10 / 65536 + 16837 * d * e12 / 1048576 + (3 * d * e4 / 16 + 45 * d * e6 / 256 - d * (32 * d2 - 561) * e8 / 4096 - d * (232 * d2 - 1677) * e10 / 16384 + d * (399985 - 90560 * d2 + 512 * d4) * e12 / 5242880) * cos2D + (21 * d * e6 / 256 + 483 * d * e8 / 4096 - d * (224 * d2 - 1969) * e10 / 16384 - d * (33152 * d2 - 112599) * e12 / 1048576) * cos4D + (151 * d * e8 / 4096 + 4681 * d * e10 / 65536 + 1479 * d * e12 / 16384 - 453 * d3 * e12 / 32768) * cos6D + (1097 * d * e10 / 65536 + 42783 * d * e12 / 1048576) * cos8D + 8011 * d * e12 / 1048576 * cos10D + (3 * e22 / 8 + 3 * e4 / 16 + 213 * e6 / 2048 - 3 * d2 * e6 / 64 + 255 * e8 / 4096 - 33 * d2 * e8 / 512 + 20861 * e10 / 524288 - 33 * d2 * e10 / 512 + d4 * e10 / 1024 + 28273 * e12 / 1048576 - 471 * d2 * e12 / 8192 + 9 * d4 * e12 / 4096) * sin2D + (21 * e4 / 256 + 21 * e6 / 256 + 533 * e8 / 8192 - 21 * d2 * e8 / 512 + 197 * e10 / 4096 - 315 * d2 * e10 / 4096 + 584039 * e12 / 16777216 - 12517 * d2 * e12 / 131072 + 7 * d4 * e12 / 2048) * sin4D + (151 * e6 / 6144 + 151 * e8 / 4096 + 5019 * e10 / 131072 - 453 * d2 * e10 / 16384 + 26965 * e12 / 786432 - 8607 * d2 * e12 / 131072) * sin6D + (1097 * e8 / 131072 + 1097 * e10 / 65536 + 225797 * e12 / 10485760 - 1097 * d2 * e12 / 65536) * sin8D + (8011 * e10 / 2621440 + 8011 * e12 / 1048576) * sin10D + 293393 * e12 / 251658240 * sin12D;
}
function calculateSigma(ellipticity, latitude) {
  if (ellipticity === 0) {
    return Math.log(Math.tan(0.5 * (Math_default.PI_OVER_TWO + latitude)));
  }
  const eSinL = ellipticity * Math.sin(latitude);
  return Math.log(Math.tan(0.5 * (Math_default.PI_OVER_TWO + latitude))) - ellipticity / 2 * Math.log((1 + eSinL) / (1 - eSinL));
}
function calculateHeading(ellipsoidRhumbLine, firstLongitude, firstLatitude, secondLongitude, secondLatitude) {
  const sigma1 = calculateSigma(ellipsoidRhumbLine._ellipticity, firstLatitude);
  const sigma2 = calculateSigma(
    ellipsoidRhumbLine._ellipticity,
    secondLatitude
  );
  return Math.atan2(
    Math_default.negativePiToPi(secondLongitude - firstLongitude),
    sigma2 - sigma1
  );
}
function calculateArcLength(ellipsoidRhumbLine, major, minor, firstLongitude, firstLatitude, secondLongitude, secondLatitude) {
  const heading = ellipsoidRhumbLine._heading;
  const deltaLongitude = secondLongitude - firstLongitude;
  let distance2 = 0;
  if (Math_default.equalsEpsilon(
    Math.abs(heading),
    Math_default.PI_OVER_TWO,
    Math_default.EPSILON8
  )) {
    if (major === minor) {
      distance2 = major * Math.cos(firstLatitude) * Math_default.negativePiToPi(deltaLongitude);
    } else {
      const sinPhi = Math.sin(firstLatitude);
      distance2 = major * Math.cos(firstLatitude) * Math_default.negativePiToPi(deltaLongitude) / Math.sqrt(1 - ellipsoidRhumbLine._ellipticitySquared * sinPhi * sinPhi);
    }
  } else {
    const M1 = calculateM(
      ellipsoidRhumbLine._ellipticity,
      major,
      firstLatitude
    );
    const M2 = calculateM(
      ellipsoidRhumbLine._ellipticity,
      major,
      secondLatitude
    );
    distance2 = (M2 - M1) / Math.cos(heading);
  }
  return Math.abs(distance2);
}
var scratchCart1 = new Cartesian3_default();
var scratchCart2 = new Cartesian3_default();
function computeProperties(ellipsoidRhumbLine, start, end, ellipsoid) {
  const firstCartesian = Cartesian3_default.normalize(
    ellipsoid.cartographicToCartesian(start, scratchCart2),
    scratchCart1
  );
  const lastCartesian = Cartesian3_default.normalize(
    ellipsoid.cartographicToCartesian(end, scratchCart2),
    scratchCart2
  );
  Check_default.typeOf.number.greaterThanOrEquals(
    "value",
    Math.abs(
      Math.abs(Cartesian3_default.angleBetween(firstCartesian, lastCartesian)) - Math.PI
    ),
    0.0125
  );
  const major = ellipsoid.maximumRadius;
  const minor = ellipsoid.minimumRadius;
  const majorSquared = major * major;
  const minorSquared = minor * minor;
  ellipsoidRhumbLine._ellipticitySquared = (majorSquared - minorSquared) / majorSquared;
  ellipsoidRhumbLine._ellipticity = Math.sqrt(
    ellipsoidRhumbLine._ellipticitySquared
  );
  ellipsoidRhumbLine._start = Cartographic_default.clone(
    start,
    ellipsoidRhumbLine._start
  );
  ellipsoidRhumbLine._start.height = 0;
  ellipsoidRhumbLine._end = Cartographic_default.clone(end, ellipsoidRhumbLine._end);
  ellipsoidRhumbLine._end.height = 0;
  ellipsoidRhumbLine._heading = calculateHeading(
    ellipsoidRhumbLine,
    start.longitude,
    start.latitude,
    end.longitude,
    end.latitude
  );
  ellipsoidRhumbLine._distance = calculateArcLength(
    ellipsoidRhumbLine,
    ellipsoid.maximumRadius,
    ellipsoid.minimumRadius,
    start.longitude,
    start.latitude,
    end.longitude,
    end.latitude
  );
}
function interpolateUsingSurfaceDistance(start, heading, distance2, major, ellipticity, result) {
  if (distance2 === 0) {
    return Cartographic_default.clone(start, result);
  }
  const ellipticitySquared = ellipticity * ellipticity;
  let longitude;
  let latitude;
  let deltaLongitude;
  if (Math.abs(Math_default.PI_OVER_TWO - Math.abs(heading)) > Math_default.EPSILON8) {
    const M1 = calculateM(ellipticity, major, start.latitude);
    const deltaM = distance2 * Math.cos(heading);
    const M2 = M1 + deltaM;
    latitude = calculateInverseM(M2, ellipticity, major);
    const sigma1 = calculateSigma(ellipticity, start.latitude);
    const sigma2 = calculateSigma(ellipticity, latitude);
    deltaLongitude = Math.tan(heading) * (sigma2 - sigma1);
    longitude = Math_default.negativePiToPi(start.longitude + deltaLongitude);
  } else {
    latitude = start.latitude;
    let localRad;
    if (ellipticity === 0) {
      localRad = major * Math.cos(start.latitude);
    } else {
      const sinPhi = Math.sin(start.latitude);
      localRad = major * Math.cos(start.latitude) / Math.sqrt(1 - ellipticitySquared * sinPhi * sinPhi);
    }
    deltaLongitude = distance2 / localRad;
    if (heading > 0) {
      longitude = Math_default.negativePiToPi(start.longitude + deltaLongitude);
    } else {
      longitude = Math_default.negativePiToPi(start.longitude - deltaLongitude);
    }
  }
  if (defined_default(result)) {
    result.longitude = longitude;
    result.latitude = latitude;
    result.height = 0;
    return result;
  }
  return new Cartographic_default(longitude, latitude, 0);
}
function EllipsoidRhumbLine(start, end, ellipsoid) {
  const e2 = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  this._ellipsoid = e2;
  this._start = new Cartographic_default();
  this._end = new Cartographic_default();
  this._heading = void 0;
  this._distance = void 0;
  this._ellipticity = void 0;
  this._ellipticitySquared = void 0;
  if (defined_default(start) && defined_default(end)) {
    computeProperties(this, start, end, e2);
  }
}
Object.defineProperties(EllipsoidRhumbLine.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  },
  surfaceDistance: {
    get: function() {
      Check_default.defined("distance", this._distance);
      return this._distance;
    }
  },
  start: {
    get: function() {
      return this._start;
    }
  },
  end: {
    get: function() {
      return this._end;
    }
  },
  heading: {
    get: function() {
      Check_default.defined("distance", this._distance);
      return this._heading;
    }
  }
});
EllipsoidRhumbLine.fromStartHeadingDistance = function(start, heading, distance2, ellipsoid, result) {
  Check_default.defined("start", start);
  Check_default.defined("heading", heading);
  Check_default.defined("distance", distance2);
  Check_default.typeOf.number.greaterThan("distance", distance2, 0);
  const e2 = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  const major = e2.maximumRadius;
  const minor = e2.minimumRadius;
  const majorSquared = major * major;
  const minorSquared = minor * minor;
  const ellipticity = Math.sqrt((majorSquared - minorSquared) / majorSquared);
  heading = Math_default.negativePiToPi(heading);
  const end = interpolateUsingSurfaceDistance(
    start,
    heading,
    distance2,
    e2.maximumRadius,
    ellipticity
  );
  if (!defined_default(result) || defined_default(ellipsoid) && !ellipsoid.equals(result.ellipsoid)) {
    return new EllipsoidRhumbLine(start, end, e2);
  }
  result.setEndPoints(start, end);
  return result;
};
EllipsoidRhumbLine.prototype.setEndPoints = function(start, end) {
  Check_default.defined("start", start);
  Check_default.defined("end", end);
  computeProperties(this, start, end, this._ellipsoid);
};
EllipsoidRhumbLine.prototype.interpolateUsingFraction = function(fraction, result) {
  return this.interpolateUsingSurfaceDistance(
    fraction * this._distance,
    result
  );
};
EllipsoidRhumbLine.prototype.interpolateUsingSurfaceDistance = function(distance2, result) {
  Check_default.typeOf.number("distance", distance2);
  if (!defined_default(this._distance) || this._distance === 0) {
    throw new DeveloperError_default(
      "EllipsoidRhumbLine must have distinct start and end set."
    );
  }
  return interpolateUsingSurfaceDistance(
    this._start,
    this._heading,
    distance2,
    this._ellipsoid.maximumRadius,
    this._ellipticity,
    result
  );
};
EllipsoidRhumbLine.prototype.findIntersectionWithLongitude = function(intersectionLongitude, result) {
  Check_default.typeOf.number("intersectionLongitude", intersectionLongitude);
  if (!defined_default(this._distance) || this._distance === 0) {
    throw new DeveloperError_default(
      "EllipsoidRhumbLine must have distinct start and end set."
    );
  }
  const ellipticity = this._ellipticity;
  const heading = this._heading;
  const absHeading = Math.abs(heading);
  const start = this._start;
  intersectionLongitude = Math_default.negativePiToPi(intersectionLongitude);
  if (Math_default.equalsEpsilon(
    Math.abs(intersectionLongitude),
    Math.PI,
    Math_default.EPSILON14
  )) {
    intersectionLongitude = Math_default.sign(start.longitude) * Math.PI;
  }
  if (!defined_default(result)) {
    result = new Cartographic_default();
  }
  if (Math.abs(Math_default.PI_OVER_TWO - absHeading) <= Math_default.EPSILON8) {
    result.longitude = intersectionLongitude;
    result.latitude = start.latitude;
    result.height = 0;
    return result;
  } else if (Math_default.equalsEpsilon(
    Math.abs(Math_default.PI_OVER_TWO - absHeading),
    Math_default.PI_OVER_TWO,
    Math_default.EPSILON8
  )) {
    if (Math_default.equalsEpsilon(
      intersectionLongitude,
      start.longitude,
      Math_default.EPSILON12
    )) {
      return void 0;
    }
    result.longitude = intersectionLongitude;
    result.latitude = Math_default.PI_OVER_TWO * Math_default.sign(Math_default.PI_OVER_TWO - heading);
    result.height = 0;
    return result;
  }
  const phi1 = start.latitude;
  const eSinPhi1 = ellipticity * Math.sin(phi1);
  const leftComponent = Math.tan(0.5 * (Math_default.PI_OVER_TWO + phi1)) * Math.exp((intersectionLongitude - start.longitude) / Math.tan(heading));
  const denominator = (1 + eSinPhi1) / (1 - eSinPhi1);
  let newPhi = start.latitude;
  let phi;
  do {
    phi = newPhi;
    const eSinPhi = ellipticity * Math.sin(phi);
    const numerator = (1 + eSinPhi) / (1 - eSinPhi);
    newPhi = 2 * Math.atan(
      leftComponent * Math.pow(numerator / denominator, ellipticity / 2)
    ) - Math_default.PI_OVER_TWO;
  } while (!Math_default.equalsEpsilon(newPhi, phi, Math_default.EPSILON12));
  result.longitude = intersectionLongitude;
  result.latitude = newPhi;
  result.height = 0;
  return result;
};
EllipsoidRhumbLine.prototype.findIntersectionWithLatitude = function(intersectionLatitude, result) {
  Check_default.typeOf.number("intersectionLatitude", intersectionLatitude);
  if (!defined_default(this._distance) || this._distance === 0) {
    throw new DeveloperError_default(
      "EllipsoidRhumbLine must have distinct start and end set."
    );
  }
  const ellipticity = this._ellipticity;
  const heading = this._heading;
  const start = this._start;
  if (Math_default.equalsEpsilon(
    Math.abs(heading),
    Math_default.PI_OVER_TWO,
    Math_default.EPSILON8
  )) {
    return;
  }
  const sigma1 = calculateSigma(ellipticity, start.latitude);
  const sigma2 = calculateSigma(ellipticity, intersectionLatitude);
  const deltaLongitude = Math.tan(heading) * (sigma2 - sigma1);
  const longitude = Math_default.negativePiToPi(start.longitude + deltaLongitude);
  if (defined_default(result)) {
    result.longitude = longitude;
    result.latitude = intersectionLatitude;
    result.height = 0;
    return result;
  }
  return new Cartographic_default(longitude, intersectionLatitude, 0);
};
var EllipsoidRhumbLine_default = EllipsoidRhumbLine;

// node_modules/cesium/Source/ThirdParty/earcut.js
var earcut_1 = earcut;
var _default = earcut;
function earcut(data, holeIndices, dim) {
  dim = dim || 2;
  var hasHoles = holeIndices && holeIndices.length, outerLen = hasHoles ? holeIndices[0] * dim : data.length, outerNode = linkedList(data, 0, outerLen, dim, true), triangles = [];
  if (!outerNode || outerNode.next === outerNode.prev)
    return triangles;
  var minX, minY, maxX, maxY, x, y, invSize;
  if (hasHoles)
    outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
  if (data.length > 80 * dim) {
    minX = maxX = data[0];
    minY = maxY = data[1];
    for (var i2 = dim; i2 < outerLen; i2 += dim) {
      x = data[i2];
      y = data[i2 + 1];
      if (x < minX)
        minX = x;
      if (y < minY)
        minY = y;
      if (x > maxX)
        maxX = x;
      if (y > maxY)
        maxY = y;
    }
    invSize = Math.max(maxX - minX, maxY - minY);
    invSize = invSize !== 0 ? 1 / invSize : 0;
  }
  earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
  return triangles;
}
function linkedList(data, start, end, dim, clockwise) {
  var i2, last;
  if (clockwise === signedArea(data, start, end, dim) > 0) {
    for (i2 = start; i2 < end; i2 += dim)
      last = insertNode(i2, data[i2], data[i2 + 1], last);
  } else {
    for (i2 = end - dim; i2 >= start; i2 -= dim)
      last = insertNode(i2, data[i2], data[i2 + 1], last);
  }
  if (last && equals(last, last.next)) {
    removeNode(last);
    last = last.next;
  }
  return last;
}
function filterPoints(start, end) {
  if (!start)
    return start;
  if (!end)
    end = start;
  var p2 = start, again;
  do {
    again = false;
    if (!p2.steiner && (equals(p2, p2.next) || area(p2.prev, p2, p2.next) === 0)) {
      removeNode(p2);
      p2 = end = p2.prev;
      if (p2 === p2.next)
        break;
      again = true;
    } else {
      p2 = p2.next;
    }
  } while (again || p2 !== end);
  return end;
}
function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
  if (!ear)
    return;
  if (!pass && invSize)
    indexCurve(ear, minX, minY, invSize);
  var stop2 = ear, prev, next;
  while (ear.prev !== ear.next) {
    prev = ear.prev;
    next = ear.next;
    if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
      triangles.push(prev.i / dim);
      triangles.push(ear.i / dim);
      triangles.push(next.i / dim);
      removeNode(ear);
      ear = next.next;
      stop2 = next.next;
      continue;
    }
    ear = next;
    if (ear === stop2) {
      if (!pass) {
        earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
      } else if (pass === 1) {
        ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
        earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
      } else if (pass === 2) {
        splitEarcut(ear, triangles, dim, minX, minY, invSize);
      }
      break;
    }
  }
}
function isEar(ear) {
  var a4 = ear.prev, b = ear, c14 = ear.next;
  if (area(a4, b, c14) >= 0)
    return false;
  var p2 = ear.next.next;
  while (p2 !== ear.prev) {
    if (pointInTriangle(a4.x, a4.y, b.x, b.y, c14.x, c14.y, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0)
      return false;
    p2 = p2.next;
  }
  return true;
}
function isEarHashed(ear, minX, minY, invSize) {
  var a4 = ear.prev, b = ear, c14 = ear.next;
  if (area(a4, b, c14) >= 0)
    return false;
  var minTX = a4.x < b.x ? a4.x < c14.x ? a4.x : c14.x : b.x < c14.x ? b.x : c14.x, minTY = a4.y < b.y ? a4.y < c14.y ? a4.y : c14.y : b.y < c14.y ? b.y : c14.y, maxTX = a4.x > b.x ? a4.x > c14.x ? a4.x : c14.x : b.x > c14.x ? b.x : c14.x, maxTY = a4.y > b.y ? a4.y > c14.y ? a4.y : c14.y : b.y > c14.y ? b.y : c14.y;
  var minZ = zOrder(minTX, minTY, minX, minY, invSize), maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
  var p2 = ear.prevZ, n2 = ear.nextZ;
  while (p2 && p2.z >= minZ && n2 && n2.z <= maxZ) {
    if (p2 !== ear.prev && p2 !== ear.next && pointInTriangle(a4.x, a4.y, b.x, b.y, c14.x, c14.y, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0)
      return false;
    p2 = p2.prevZ;
    if (n2 !== ear.prev && n2 !== ear.next && pointInTriangle(a4.x, a4.y, b.x, b.y, c14.x, c14.y, n2.x, n2.y) && area(n2.prev, n2, n2.next) >= 0)
      return false;
    n2 = n2.nextZ;
  }
  while (p2 && p2.z >= minZ) {
    if (p2 !== ear.prev && p2 !== ear.next && pointInTriangle(a4.x, a4.y, b.x, b.y, c14.x, c14.y, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0)
      return false;
    p2 = p2.prevZ;
  }
  while (n2 && n2.z <= maxZ) {
    if (n2 !== ear.prev && n2 !== ear.next && pointInTriangle(a4.x, a4.y, b.x, b.y, c14.x, c14.y, n2.x, n2.y) && area(n2.prev, n2, n2.next) >= 0)
      return false;
    n2 = n2.nextZ;
  }
  return true;
}
function cureLocalIntersections(start, triangles, dim) {
  var p2 = start;
  do {
    var a4 = p2.prev, b = p2.next.next;
    if (!equals(a4, b) && intersects(a4, p2, p2.next, b) && locallyInside(a4, b) && locallyInside(b, a4)) {
      triangles.push(a4.i / dim);
      triangles.push(p2.i / dim);
      triangles.push(b.i / dim);
      removeNode(p2);
      removeNode(p2.next);
      p2 = start = b;
    }
    p2 = p2.next;
  } while (p2 !== start);
  return filterPoints(p2);
}
function splitEarcut(start, triangles, dim, minX, minY, invSize) {
  var a4 = start;
  do {
    var b = a4.next.next;
    while (b !== a4.prev) {
      if (a4.i !== b.i && isValidDiagonal(a4, b)) {
        var c14 = splitPolygon(a4, b);
        a4 = filterPoints(a4, a4.next);
        c14 = filterPoints(c14, c14.next);
        earcutLinked(a4, triangles, dim, minX, minY, invSize);
        earcutLinked(c14, triangles, dim, minX, minY, invSize);
        return;
      }
      b = b.next;
    }
    a4 = a4.next;
  } while (a4 !== start);
}
function eliminateHoles(data, holeIndices, outerNode, dim) {
  var queue = [], i2, len, start, end, list;
  for (i2 = 0, len = holeIndices.length; i2 < len; i2++) {
    start = holeIndices[i2] * dim;
    end = i2 < len - 1 ? holeIndices[i2 + 1] * dim : data.length;
    list = linkedList(data, start, end, dim, false);
    if (list === list.next)
      list.steiner = true;
    queue.push(getLeftmost(list));
  }
  queue.sort(compareX);
  for (i2 = 0; i2 < queue.length; i2++) {
    outerNode = eliminateHole(queue[i2], outerNode);
    outerNode = filterPoints(outerNode, outerNode.next);
  }
  return outerNode;
}
function compareX(a4, b) {
  return a4.x - b.x;
}
function eliminateHole(hole, outerNode) {
  var bridge = findHoleBridge(hole, outerNode);
  if (!bridge) {
    return outerNode;
  }
  var bridgeReverse = splitPolygon(bridge, hole);
  var filteredBridge = filterPoints(bridge, bridge.next);
  filterPoints(bridgeReverse, bridgeReverse.next);
  return outerNode === bridge ? filteredBridge : outerNode;
}
function findHoleBridge(hole, outerNode) {
  var p2 = outerNode, hx = hole.x, hy = hole.y, qx = -Infinity, m;
  do {
    if (hy <= p2.y && hy >= p2.next.y && p2.next.y !== p2.y) {
      var x = p2.x + (hy - p2.y) * (p2.next.x - p2.x) / (p2.next.y - p2.y);
      if (x <= hx && x > qx) {
        qx = x;
        if (x === hx) {
          if (hy === p2.y)
            return p2;
          if (hy === p2.next.y)
            return p2.next;
        }
        m = p2.x < p2.next.x ? p2 : p2.next;
      }
    }
    p2 = p2.next;
  } while (p2 !== outerNode);
  if (!m)
    return null;
  if (hx === qx)
    return m;
  var stop2 = m, mx = m.x, my = m.y, tanMin = Infinity, tan;
  p2 = m;
  do {
    if (hx >= p2.x && p2.x >= mx && hx !== p2.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p2.x, p2.y)) {
      tan = Math.abs(hy - p2.y) / (hx - p2.x);
      if (locallyInside(p2, hole) && (tan < tanMin || tan === tanMin && (p2.x > m.x || p2.x === m.x && sectorContainsSector(m, p2)))) {
        m = p2;
        tanMin = tan;
      }
    }
    p2 = p2.next;
  } while (p2 !== stop2);
  return m;
}
function sectorContainsSector(m, p2) {
  return area(m.prev, m, p2.prev) < 0 && area(p2.next, m, m.next) < 0;
}
function indexCurve(start, minX, minY, invSize) {
  var p2 = start;
  do {
    if (p2.z === null)
      p2.z = zOrder(p2.x, p2.y, minX, minY, invSize);
    p2.prevZ = p2.prev;
    p2.nextZ = p2.next;
    p2 = p2.next;
  } while (p2 !== start);
  p2.prevZ.nextZ = null;
  p2.prevZ = null;
  sortLinked(p2);
}
function sortLinked(list) {
  var i2, p2, q, e2, tail, numMerges, pSize, qSize, inSize = 1;
  do {
    p2 = list;
    list = null;
    tail = null;
    numMerges = 0;
    while (p2) {
      numMerges++;
      q = p2;
      pSize = 0;
      for (i2 = 0; i2 < inSize; i2++) {
        pSize++;
        q = q.nextZ;
        if (!q)
          break;
      }
      qSize = inSize;
      while (pSize > 0 || qSize > 0 && q) {
        if (pSize !== 0 && (qSize === 0 || !q || p2.z <= q.z)) {
          e2 = p2;
          p2 = p2.nextZ;
          pSize--;
        } else {
          e2 = q;
          q = q.nextZ;
          qSize--;
        }
        if (tail)
          tail.nextZ = e2;
        else
          list = e2;
        e2.prevZ = tail;
        tail = e2;
      }
      p2 = q;
    }
    tail.nextZ = null;
    inSize *= 2;
  } while (numMerges > 1);
  return list;
}
function zOrder(x, y, minX, minY, invSize) {
  x = 32767 * (x - minX) * invSize;
  y = 32767 * (y - minY) * invSize;
  x = (x | x << 8) & 16711935;
  x = (x | x << 4) & 252645135;
  x = (x | x << 2) & 858993459;
  x = (x | x << 1) & 1431655765;
  y = (y | y << 8) & 16711935;
  y = (y | y << 4) & 252645135;
  y = (y | y << 2) & 858993459;
  y = (y | y << 1) & 1431655765;
  return x | y << 1;
}
function getLeftmost(start) {
  var p2 = start, leftmost = start;
  do {
    if (p2.x < leftmost.x || p2.x === leftmost.x && p2.y < leftmost.y)
      leftmost = p2;
    p2 = p2.next;
  } while (p2 !== start);
  return leftmost;
}
function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
  return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
}
function isValidDiagonal(a4, b) {
  return a4.next.i !== b.i && a4.prev.i !== b.i && !intersectsPolygon(a4, b) && (locallyInside(a4, b) && locallyInside(b, a4) && middleInside(a4, b) && (area(a4.prev, a4, b.prev) || area(a4, b.prev, b)) || equals(a4, b) && area(a4.prev, a4, a4.next) > 0 && area(b.prev, b, b.next) > 0);
}
function area(p2, q, r2) {
  return (q.y - p2.y) * (r2.x - q.x) - (q.x - p2.x) * (r2.y - q.y);
}
function equals(p1, p2) {
  return p1.x === p2.x && p1.y === p2.y;
}
function intersects(p1, q12, p2, q22) {
  var o1 = sign2(area(p1, q12, p2));
  var o2 = sign2(area(p1, q12, q22));
  var o3 = sign2(area(p2, q22, p1));
  var o4 = sign2(area(p2, q22, q12));
  if (o1 !== o2 && o3 !== o4)
    return true;
  if (o1 === 0 && onSegment(p1, p2, q12))
    return true;
  if (o2 === 0 && onSegment(p1, q22, q12))
    return true;
  if (o3 === 0 && onSegment(p2, p1, q22))
    return true;
  if (o4 === 0 && onSegment(p2, q12, q22))
    return true;
  return false;
}
function onSegment(p2, q, r2) {
  return q.x <= Math.max(p2.x, r2.x) && q.x >= Math.min(p2.x, r2.x) && q.y <= Math.max(p2.y, r2.y) && q.y >= Math.min(p2.y, r2.y);
}
function sign2(num) {
  return num > 0 ? 1 : num < 0 ? -1 : 0;
}
function intersectsPolygon(a4, b) {
  var p2 = a4;
  do {
    if (p2.i !== a4.i && p2.next.i !== a4.i && p2.i !== b.i && p2.next.i !== b.i && intersects(p2, p2.next, a4, b))
      return true;
    p2 = p2.next;
  } while (p2 !== a4);
  return false;
}
function locallyInside(a4, b) {
  return area(a4.prev, a4, a4.next) < 0 ? area(a4, b, a4.next) >= 0 && area(a4, a4.prev, b) >= 0 : area(a4, b, a4.prev) < 0 || area(a4, a4.next, b) < 0;
}
function middleInside(a4, b) {
  var p2 = a4, inside = false, px = (a4.x + b.x) / 2, py = (a4.y + b.y) / 2;
  do {
    if (p2.y > py !== p2.next.y > py && p2.next.y !== p2.y && px < (p2.next.x - p2.x) * (py - p2.y) / (p2.next.y - p2.y) + p2.x)
      inside = !inside;
    p2 = p2.next;
  } while (p2 !== a4);
  return inside;
}
function splitPolygon(a4, b) {
  var a22 = new Node2(a4.i, a4.x, a4.y), b2 = new Node2(b.i, b.x, b.y), an = a4.next, bp = b.prev;
  a4.next = b;
  b.prev = a4;
  a22.next = an;
  an.prev = a22;
  b2.next = a22;
  a22.prev = b2;
  bp.next = b2;
  b2.prev = bp;
  return b2;
}
function insertNode(i2, x, y, last) {
  var p2 = new Node2(i2, x, y);
  if (!last) {
    p2.prev = p2;
    p2.next = p2;
  } else {
    p2.next = last.next;
    p2.prev = last;
    last.next.prev = p2;
    last.next = p2;
  }
  return p2;
}
function removeNode(p2) {
  p2.next.prev = p2.prev;
  p2.prev.next = p2.next;
  if (p2.prevZ)
    p2.prevZ.nextZ = p2.nextZ;
  if (p2.nextZ)
    p2.nextZ.prevZ = p2.prevZ;
}
function Node2(i2, x, y) {
  this.i = i2;
  this.x = x;
  this.y = y;
  this.prev = null;
  this.next = null;
  this.z = null;
  this.prevZ = null;
  this.nextZ = null;
  this.steiner = false;
}
earcut.deviation = function(data, holeIndices, dim, triangles) {
  var hasHoles = holeIndices && holeIndices.length;
  var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
  var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
  if (hasHoles) {
    for (var i2 = 0, len = holeIndices.length; i2 < len; i2++) {
      var start = holeIndices[i2] * dim;
      var end = i2 < len - 1 ? holeIndices[i2 + 1] * dim : data.length;
      polygonArea -= Math.abs(signedArea(data, start, end, dim));
    }
  }
  var trianglesArea = 0;
  for (i2 = 0; i2 < triangles.length; i2 += 3) {
    var a4 = triangles[i2] * dim;
    var b = triangles[i2 + 1] * dim;
    var c14 = triangles[i2 + 2] * dim;
    trianglesArea += Math.abs(
      (data[a4] - data[c14]) * (data[b + 1] - data[a4 + 1]) - (data[a4] - data[b]) * (data[c14 + 1] - data[a4 + 1])
    );
  }
  return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea);
};
function signedArea(data, start, end, dim) {
  var sum = 0;
  for (var i2 = start, j = end - dim; i2 < end; i2 += dim) {
    sum += (data[j] - data[i2]) * (data[i2 + 1] + data[j + 1]);
    j = i2;
  }
  return sum;
}
earcut.flatten = function(data) {
  var dim = data[0][0].length, result = { vertices: [], holes: [], dimensions: dim }, holeIndex = 0;
  for (var i2 = 0; i2 < data.length; i2++) {
    for (var j = 0; j < data[i2].length; j++) {
      for (var d = 0; d < dim; d++)
        result.vertices.push(data[i2][j][d]);
    }
    if (i2 > 0) {
      holeIndex += data[i2 - 1].length;
      result.holes.push(holeIndex);
    }
  }
  return result;
};
earcut_1.default = _default;

// node_modules/cesium/Source/Core/WindingOrder.js
var WindingOrder = {
  CLOCKWISE: WebGLConstants_default.CW,
  COUNTER_CLOCKWISE: WebGLConstants_default.CCW
};
WindingOrder.validate = function(windingOrder) {
  return windingOrder === WindingOrder.CLOCKWISE || windingOrder === WindingOrder.COUNTER_CLOCKWISE;
};
var WindingOrder_default = Object.freeze(WindingOrder);

// node_modules/cesium/Source/Core/PolygonPipeline.js
var scaleToGeodeticHeightN = new Cartesian3_default();
var scaleToGeodeticHeightP = new Cartesian3_default();
var PolygonPipeline = {};
PolygonPipeline.computeArea2D = function(positions) {
  Check_default.defined("positions", positions);
  Check_default.typeOf.number.greaterThanOrEquals(
    "positions.length",
    positions.length,
    3
  );
  const length3 = positions.length;
  let area2 = 0;
  for (let i0 = length3 - 1, i1 = 0; i1 < length3; i0 = i1++) {
    const v02 = positions[i0];
    const v13 = positions[i1];
    area2 += v02.x * v13.y - v13.x * v02.y;
  }
  return area2 * 0.5;
};
PolygonPipeline.computeWindingOrder2D = function(positions) {
  const area2 = PolygonPipeline.computeArea2D(positions);
  return area2 > 0 ? WindingOrder_default.COUNTER_CLOCKWISE : WindingOrder_default.CLOCKWISE;
};
PolygonPipeline.triangulate = function(positions, holes) {
  Check_default.defined("positions", positions);
  const flattenedPositions = Cartesian2_default.packArray(positions);
  return earcut_1(flattenedPositions, holes, 2);
};
var subdivisionV0Scratch = new Cartesian3_default();
var subdivisionV1Scratch = new Cartesian3_default();
var subdivisionV2Scratch = new Cartesian3_default();
var subdivisionS0Scratch = new Cartesian3_default();
var subdivisionS1Scratch = new Cartesian3_default();
var subdivisionS2Scratch = new Cartesian3_default();
var subdivisionMidScratch = new Cartesian3_default();
PolygonPipeline.computeSubdivision = function(ellipsoid, positions, indices2, granularity) {
  granularity = defaultValue_default(granularity, Math_default.RADIANS_PER_DEGREE);
  Check_default.typeOf.object("ellipsoid", ellipsoid);
  Check_default.defined("positions", positions);
  Check_default.defined("indices", indices2);
  Check_default.typeOf.number.greaterThanOrEquals("indices.length", indices2.length, 3);
  Check_default.typeOf.number.equals("indices.length % 3", "0", indices2.length % 3, 0);
  Check_default.typeOf.number.greaterThan("granularity", granularity, 0);
  const triangles = indices2.slice(0);
  let i2;
  const length3 = positions.length;
  const subdividedPositions = new Array(length3 * 3);
  let q = 0;
  for (i2 = 0; i2 < length3; i2++) {
    const item = positions[i2];
    subdividedPositions[q++] = item.x;
    subdividedPositions[q++] = item.y;
    subdividedPositions[q++] = item.z;
  }
  const subdividedIndices = [];
  const edges = {};
  const radius = ellipsoid.maximumRadius;
  const minDistance = Math_default.chordLength(granularity, radius);
  const minDistanceSqrd = minDistance * minDistance;
  while (triangles.length > 0) {
    const i22 = triangles.pop();
    const i1 = triangles.pop();
    const i0 = triangles.pop();
    const v02 = Cartesian3_default.fromArray(
      subdividedPositions,
      i0 * 3,
      subdivisionV0Scratch
    );
    const v13 = Cartesian3_default.fromArray(
      subdividedPositions,
      i1 * 3,
      subdivisionV1Scratch
    );
    const v23 = Cartesian3_default.fromArray(
      subdividedPositions,
      i22 * 3,
      subdivisionV2Scratch
    );
    const s0 = Cartesian3_default.multiplyByScalar(
      Cartesian3_default.normalize(v02, subdivisionS0Scratch),
      radius,
      subdivisionS0Scratch
    );
    const s1 = Cartesian3_default.multiplyByScalar(
      Cartesian3_default.normalize(v13, subdivisionS1Scratch),
      radius,
      subdivisionS1Scratch
    );
    const s2 = Cartesian3_default.multiplyByScalar(
      Cartesian3_default.normalize(v23, subdivisionS2Scratch),
      radius,
      subdivisionS2Scratch
    );
    const g0 = Cartesian3_default.magnitudeSquared(
      Cartesian3_default.subtract(s0, s1, subdivisionMidScratch)
    );
    const g1 = Cartesian3_default.magnitudeSquared(
      Cartesian3_default.subtract(s1, s2, subdivisionMidScratch)
    );
    const g2 = Cartesian3_default.magnitudeSquared(
      Cartesian3_default.subtract(s2, s0, subdivisionMidScratch)
    );
    const max3 = Math.max(g0, g1, g2);
    let edge;
    let mid;
    if (max3 > minDistanceSqrd) {
      if (g0 === max3) {
        edge = `${Math.min(i0, i1)} ${Math.max(i0, i1)}`;
        i2 = edges[edge];
        if (!defined_default(i2)) {
          mid = Cartesian3_default.add(v02, v13, subdivisionMidScratch);
          Cartesian3_default.multiplyByScalar(mid, 0.5, mid);
          subdividedPositions.push(mid.x, mid.y, mid.z);
          i2 = subdividedPositions.length / 3 - 1;
          edges[edge] = i2;
        }
        triangles.push(i0, i2, i22);
        triangles.push(i2, i1, i22);
      } else if (g1 === max3) {
        edge = `${Math.min(i1, i22)} ${Math.max(i1, i22)}`;
        i2 = edges[edge];
        if (!defined_default(i2)) {
          mid = Cartesian3_default.add(v13, v23, subdivisionMidScratch);
          Cartesian3_default.multiplyByScalar(mid, 0.5, mid);
          subdividedPositions.push(mid.x, mid.y, mid.z);
          i2 = subdividedPositions.length / 3 - 1;
          edges[edge] = i2;
        }
        triangles.push(i1, i2, i0);
        triangles.push(i2, i22, i0);
      } else if (g2 === max3) {
        edge = `${Math.min(i22, i0)} ${Math.max(i22, i0)}`;
        i2 = edges[edge];
        if (!defined_default(i2)) {
          mid = Cartesian3_default.add(v23, v02, subdivisionMidScratch);
          Cartesian3_default.multiplyByScalar(mid, 0.5, mid);
          subdividedPositions.push(mid.x, mid.y, mid.z);
          i2 = subdividedPositions.length / 3 - 1;
          edges[edge] = i2;
        }
        triangles.push(i22, i2, i1);
        triangles.push(i2, i0, i1);
      }
    } else {
      subdividedIndices.push(i0);
      subdividedIndices.push(i1);
      subdividedIndices.push(i22);
    }
  }
  return new Geometry_default({
    attributes: {
      position: new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.DOUBLE,
        componentsPerAttribute: 3,
        values: subdividedPositions
      })
    },
    indices: subdividedIndices,
    primitiveType: PrimitiveType_default.TRIANGLES
  });
};
var subdivisionC0Scratch = new Cartographic_default();
var subdivisionC1Scratch = new Cartographic_default();
var subdivisionC2Scratch = new Cartographic_default();
var subdivisionCartographicScratch = new Cartographic_default();
PolygonPipeline.computeRhumbLineSubdivision = function(ellipsoid, positions, indices2, granularity) {
  granularity = defaultValue_default(granularity, Math_default.RADIANS_PER_DEGREE);
  Check_default.typeOf.object("ellipsoid", ellipsoid);
  Check_default.defined("positions", positions);
  Check_default.defined("indices", indices2);
  Check_default.typeOf.number.greaterThanOrEquals("indices.length", indices2.length, 3);
  Check_default.typeOf.number.equals("indices.length % 3", "0", indices2.length % 3, 0);
  Check_default.typeOf.number.greaterThan("granularity", granularity, 0);
  const triangles = indices2.slice(0);
  let i2;
  const length3 = positions.length;
  const subdividedPositions = new Array(length3 * 3);
  let q = 0;
  for (i2 = 0; i2 < length3; i2++) {
    const item = positions[i2];
    subdividedPositions[q++] = item.x;
    subdividedPositions[q++] = item.y;
    subdividedPositions[q++] = item.z;
  }
  const subdividedIndices = [];
  const edges = {};
  const radius = ellipsoid.maximumRadius;
  const minDistance = Math_default.chordLength(granularity, radius);
  const rhumb0 = new EllipsoidRhumbLine_default(void 0, void 0, ellipsoid);
  const rhumb1 = new EllipsoidRhumbLine_default(void 0, void 0, ellipsoid);
  const rhumb2 = new EllipsoidRhumbLine_default(void 0, void 0, ellipsoid);
  while (triangles.length > 0) {
    const i22 = triangles.pop();
    const i1 = triangles.pop();
    const i0 = triangles.pop();
    const v02 = Cartesian3_default.fromArray(
      subdividedPositions,
      i0 * 3,
      subdivisionV0Scratch
    );
    const v13 = Cartesian3_default.fromArray(
      subdividedPositions,
      i1 * 3,
      subdivisionV1Scratch
    );
    const v23 = Cartesian3_default.fromArray(
      subdividedPositions,
      i22 * 3,
      subdivisionV2Scratch
    );
    const c0 = ellipsoid.cartesianToCartographic(v02, subdivisionC0Scratch);
    const c14 = ellipsoid.cartesianToCartographic(v13, subdivisionC1Scratch);
    const c22 = ellipsoid.cartesianToCartographic(v23, subdivisionC2Scratch);
    rhumb0.setEndPoints(c0, c14);
    const g0 = rhumb0.surfaceDistance;
    rhumb1.setEndPoints(c14, c22);
    const g1 = rhumb1.surfaceDistance;
    rhumb2.setEndPoints(c22, c0);
    const g2 = rhumb2.surfaceDistance;
    const max3 = Math.max(g0, g1, g2);
    let edge;
    let mid;
    let midHeight;
    let midCartesian3;
    if (max3 > minDistance) {
      if (g0 === max3) {
        edge = `${Math.min(i0, i1)} ${Math.max(i0, i1)}`;
        i2 = edges[edge];
        if (!defined_default(i2)) {
          mid = rhumb0.interpolateUsingFraction(
            0.5,
            subdivisionCartographicScratch
          );
          midHeight = (c0.height + c14.height) * 0.5;
          midCartesian3 = Cartesian3_default.fromRadians(
            mid.longitude,
            mid.latitude,
            midHeight,
            ellipsoid,
            subdivisionMidScratch
          );
          subdividedPositions.push(
            midCartesian3.x,
            midCartesian3.y,
            midCartesian3.z
          );
          i2 = subdividedPositions.length / 3 - 1;
          edges[edge] = i2;
        }
        triangles.push(i0, i2, i22);
        triangles.push(i2, i1, i22);
      } else if (g1 === max3) {
        edge = `${Math.min(i1, i22)} ${Math.max(i1, i22)}`;
        i2 = edges[edge];
        if (!defined_default(i2)) {
          mid = rhumb1.interpolateUsingFraction(
            0.5,
            subdivisionCartographicScratch
          );
          midHeight = (c14.height + c22.height) * 0.5;
          midCartesian3 = Cartesian3_default.fromRadians(
            mid.longitude,
            mid.latitude,
            midHeight,
            ellipsoid,
            subdivisionMidScratch
          );
          subdividedPositions.push(
            midCartesian3.x,
            midCartesian3.y,
            midCartesian3.z
          );
          i2 = subdividedPositions.length / 3 - 1;
          edges[edge] = i2;
        }
        triangles.push(i1, i2, i0);
        triangles.push(i2, i22, i0);
      } else if (g2 === max3) {
        edge = `${Math.min(i22, i0)} ${Math.max(i22, i0)}`;
        i2 = edges[edge];
        if (!defined_default(i2)) {
          mid = rhumb2.interpolateUsingFraction(
            0.5,
            subdivisionCartographicScratch
          );
          midHeight = (c22.height + c0.height) * 0.5;
          midCartesian3 = Cartesian3_default.fromRadians(
            mid.longitude,
            mid.latitude,
            midHeight,
            ellipsoid,
            subdivisionMidScratch
          );
          subdividedPositions.push(
            midCartesian3.x,
            midCartesian3.y,
            midCartesian3.z
          );
          i2 = subdividedPositions.length / 3 - 1;
          edges[edge] = i2;
        }
        triangles.push(i22, i2, i1);
        triangles.push(i2, i0, i1);
      }
    } else {
      subdividedIndices.push(i0);
      subdividedIndices.push(i1);
      subdividedIndices.push(i22);
    }
  }
  return new Geometry_default({
    attributes: {
      position: new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.DOUBLE,
        componentsPerAttribute: 3,
        values: subdividedPositions
      })
    },
    indices: subdividedIndices,
    primitiveType: PrimitiveType_default.TRIANGLES
  });
};
PolygonPipeline.scaleToGeodeticHeight = function(positions, height, ellipsoid, scaleToSurface4) {
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  let n2 = scaleToGeodeticHeightN;
  let p2 = scaleToGeodeticHeightP;
  height = defaultValue_default(height, 0);
  scaleToSurface4 = defaultValue_default(scaleToSurface4, true);
  if (defined_default(positions)) {
    const length3 = positions.length;
    for (let i2 = 0; i2 < length3; i2 += 3) {
      Cartesian3_default.fromArray(positions, i2, p2);
      if (scaleToSurface4) {
        p2 = ellipsoid.scaleToGeodeticSurface(p2, p2);
      }
      if (height !== 0) {
        n2 = ellipsoid.geodeticSurfaceNormal(p2, n2);
        Cartesian3_default.multiplyByScalar(n2, height, n2);
        Cartesian3_default.add(p2, n2, p2);
      }
      positions[i2] = p2.x;
      positions[i2 + 1] = p2.y;
      positions[i2 + 2] = p2.z;
    }
  }
  return positions;
};
var PolygonPipeline_default = PolygonPipeline;

// node_modules/cesium/Source/Core/Queue.js
function Queue() {
  this._array = [];
  this._offset = 0;
  this._length = 0;
}
Object.defineProperties(Queue.prototype, {
  length: {
    get: function() {
      return this._length;
    }
  }
});
Queue.prototype.enqueue = function(item) {
  this._array.push(item);
  this._length++;
};
Queue.prototype.dequeue = function() {
  if (this._length === 0) {
    return void 0;
  }
  const array = this._array;
  let offset2 = this._offset;
  const item = array[offset2];
  array[offset2] = void 0;
  offset2++;
  if (offset2 > 10 && offset2 * 2 > array.length) {
    this._array = array.slice(offset2);
    offset2 = 0;
  }
  this._offset = offset2;
  this._length--;
  return item;
};
Queue.prototype.peek = function() {
  if (this._length === 0) {
    return void 0;
  }
  return this._array[this._offset];
};
Queue.prototype.contains = function(item) {
  return this._array.indexOf(item) !== -1;
};
Queue.prototype.clear = function() {
  this._array.length = this._offset = this._length = 0;
};
Queue.prototype.sort = function(compareFunction) {
  if (this._offset > 0) {
    this._array = this._array.slice(this._offset);
    this._offset = 0;
  }
  this._array.sort(compareFunction);
};
var Queue_default = Queue;

// node_modules/cesium/Source/Core/PolygonGeometryLibrary.js
var PolygonGeometryLibrary = {};
PolygonGeometryLibrary.computeHierarchyPackedLength = function(polygonHierarchy) {
  let numComponents = 0;
  const stack = [polygonHierarchy];
  while (stack.length > 0) {
    const hierarchy = stack.pop();
    if (!defined_default(hierarchy)) {
      continue;
    }
    numComponents += 2;
    const positions = hierarchy.positions;
    const holes = hierarchy.holes;
    if (defined_default(positions)) {
      numComponents += positions.length * Cartesian3_default.packedLength;
    }
    if (defined_default(holes)) {
      const length3 = holes.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        stack.push(holes[i2]);
      }
    }
  }
  return numComponents;
};
PolygonGeometryLibrary.packPolygonHierarchy = function(polygonHierarchy, array, startingIndex) {
  const stack = [polygonHierarchy];
  while (stack.length > 0) {
    const hierarchy = stack.pop();
    if (!defined_default(hierarchy)) {
      continue;
    }
    const positions = hierarchy.positions;
    const holes = hierarchy.holes;
    array[startingIndex++] = defined_default(positions) ? positions.length : 0;
    array[startingIndex++] = defined_default(holes) ? holes.length : 0;
    if (defined_default(positions)) {
      const positionsLength = positions.length;
      for (let i2 = 0; i2 < positionsLength; ++i2, startingIndex += 3) {
        Cartesian3_default.pack(positions[i2], array, startingIndex);
      }
    }
    if (defined_default(holes)) {
      const holesLength = holes.length;
      for (let j = 0; j < holesLength; ++j) {
        stack.push(holes[j]);
      }
    }
  }
  return startingIndex;
};
PolygonGeometryLibrary.unpackPolygonHierarchy = function(array, startingIndex) {
  const positionsLength = array[startingIndex++];
  const holesLength = array[startingIndex++];
  const positions = new Array(positionsLength);
  const holes = holesLength > 0 ? new Array(holesLength) : void 0;
  for (let i2 = 0; i2 < positionsLength; ++i2, startingIndex += Cartesian3_default.packedLength) {
    positions[i2] = Cartesian3_default.unpack(array, startingIndex);
  }
  for (let j = 0; j < holesLength; ++j) {
    holes[j] = PolygonGeometryLibrary.unpackPolygonHierarchy(
      array,
      startingIndex
    );
    startingIndex = holes[j].startingIndex;
    delete holes[j].startingIndex;
  }
  return {
    positions,
    holes,
    startingIndex
  };
};
var distanceScratch4 = new Cartesian3_default();
function getPointAtDistance(p0, p1, distance2, length3) {
  Cartesian3_default.subtract(p1, p0, distanceScratch4);
  Cartesian3_default.multiplyByScalar(
    distanceScratch4,
    distance2 / length3,
    distanceScratch4
  );
  Cartesian3_default.add(p0, distanceScratch4, distanceScratch4);
  return [distanceScratch4.x, distanceScratch4.y, distanceScratch4.z];
}
PolygonGeometryLibrary.subdivideLineCount = function(p0, p1, minDistance) {
  const distance2 = Cartesian3_default.distance(p0, p1);
  const n2 = distance2 / minDistance;
  const countDivide = Math.max(0, Math.ceil(Math_default.log2(n2)));
  return Math.pow(2, countDivide);
};
var scratchCartographic0 = new Cartographic_default();
var scratchCartographic1 = new Cartographic_default();
var scratchCartographic22 = new Cartographic_default();
var scratchCartesian0 = new Cartesian3_default();
PolygonGeometryLibrary.subdivideRhumbLineCount = function(ellipsoid, p0, p1, minDistance) {
  const c0 = ellipsoid.cartesianToCartographic(p0, scratchCartographic0);
  const c14 = ellipsoid.cartesianToCartographic(p1, scratchCartographic1);
  const rhumb = new EllipsoidRhumbLine_default(c0, c14, ellipsoid);
  const n2 = rhumb.surfaceDistance / minDistance;
  const countDivide = Math.max(0, Math.ceil(Math_default.log2(n2)));
  return Math.pow(2, countDivide);
};
PolygonGeometryLibrary.subdivideLine = function(p0, p1, minDistance, result) {
  const numVertices = PolygonGeometryLibrary.subdivideLineCount(
    p0,
    p1,
    minDistance
  );
  const length3 = Cartesian3_default.distance(p0, p1);
  const distanceBetweenVertices = length3 / numVertices;
  if (!defined_default(result)) {
    result = [];
  }
  const positions = result;
  positions.length = numVertices * 3;
  let index2 = 0;
  for (let i2 = 0; i2 < numVertices; i2++) {
    const p2 = getPointAtDistance(p0, p1, i2 * distanceBetweenVertices, length3);
    positions[index2++] = p2[0];
    positions[index2++] = p2[1];
    positions[index2++] = p2[2];
  }
  return positions;
};
PolygonGeometryLibrary.subdivideRhumbLine = function(ellipsoid, p0, p1, minDistance, result) {
  const c0 = ellipsoid.cartesianToCartographic(p0, scratchCartographic0);
  const c14 = ellipsoid.cartesianToCartographic(p1, scratchCartographic1);
  const rhumb = new EllipsoidRhumbLine_default(c0, c14, ellipsoid);
  const n2 = rhumb.surfaceDistance / minDistance;
  const countDivide = Math.max(0, Math.ceil(Math_default.log2(n2)));
  const numVertices = Math.pow(2, countDivide);
  const distanceBetweenVertices = rhumb.surfaceDistance / numVertices;
  if (!defined_default(result)) {
    result = [];
  }
  const positions = result;
  positions.length = numVertices * 3;
  let index2 = 0;
  for (let i2 = 0; i2 < numVertices; i2++) {
    const c15 = rhumb.interpolateUsingSurfaceDistance(
      i2 * distanceBetweenVertices,
      scratchCartographic22
    );
    const p2 = ellipsoid.cartographicToCartesian(c15, scratchCartesian0);
    positions[index2++] = p2.x;
    positions[index2++] = p2.y;
    positions[index2++] = p2.z;
  }
  return positions;
};
var scaleToGeodeticHeightN1 = new Cartesian3_default();
var scaleToGeodeticHeightN2 = new Cartesian3_default();
var scaleToGeodeticHeightP1 = new Cartesian3_default();
var scaleToGeodeticHeightP2 = new Cartesian3_default();
PolygonGeometryLibrary.scaleToGeodeticHeightExtruded = function(geometry, maxHeight, minHeight, ellipsoid, perPositionHeight) {
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  const n1 = scaleToGeodeticHeightN1;
  let n2 = scaleToGeodeticHeightN2;
  const p2 = scaleToGeodeticHeightP1;
  let p22 = scaleToGeodeticHeightP2;
  if (defined_default(geometry) && defined_default(geometry.attributes) && defined_default(geometry.attributes.position)) {
    const positions = geometry.attributes.position.values;
    const length3 = positions.length / 2;
    for (let i2 = 0; i2 < length3; i2 += 3) {
      Cartesian3_default.fromArray(positions, i2, p2);
      ellipsoid.geodeticSurfaceNormal(p2, n1);
      p22 = ellipsoid.scaleToGeodeticSurface(p2, p22);
      n2 = Cartesian3_default.multiplyByScalar(n1, minHeight, n2);
      n2 = Cartesian3_default.add(p22, n2, n2);
      positions[i2 + length3] = n2.x;
      positions[i2 + 1 + length3] = n2.y;
      positions[i2 + 2 + length3] = n2.z;
      if (perPositionHeight) {
        p22 = Cartesian3_default.clone(p2, p22);
      }
      n2 = Cartesian3_default.multiplyByScalar(n1, maxHeight, n2);
      n2 = Cartesian3_default.add(p22, n2, n2);
      positions[i2] = n2.x;
      positions[i2 + 1] = n2.y;
      positions[i2 + 2] = n2.z;
    }
  }
  return geometry;
};
PolygonGeometryLibrary.polygonOutlinesFromHierarchy = function(polygonHierarchy, scaleToEllipsoidSurface, ellipsoid) {
  const polygons = [];
  const queue = new Queue_default();
  queue.enqueue(polygonHierarchy);
  let i2;
  let j;
  let length3;
  while (queue.length !== 0) {
    const outerNode = queue.dequeue();
    let outerRing = outerNode.positions;
    if (scaleToEllipsoidSurface) {
      length3 = outerRing.length;
      for (i2 = 0; i2 < length3; i2++) {
        ellipsoid.scaleToGeodeticSurface(outerRing[i2], outerRing[i2]);
      }
    }
    outerRing = arrayRemoveDuplicates_default(
      outerRing,
      Cartesian3_default.equalsEpsilon,
      true
    );
    if (outerRing.length < 3) {
      continue;
    }
    const numChildren = outerNode.holes ? outerNode.holes.length : 0;
    for (i2 = 0; i2 < numChildren; i2++) {
      const hole = outerNode.holes[i2];
      let holePositions = hole.positions;
      if (scaleToEllipsoidSurface) {
        length3 = holePositions.length;
        for (j = 0; j < length3; ++j) {
          ellipsoid.scaleToGeodeticSurface(holePositions[j], holePositions[j]);
        }
      }
      holePositions = arrayRemoveDuplicates_default(
        holePositions,
        Cartesian3_default.equalsEpsilon,
        true
      );
      if (holePositions.length < 3) {
        continue;
      }
      polygons.push(holePositions);
      let numGrandchildren = 0;
      if (defined_default(hole.holes)) {
        numGrandchildren = hole.holes.length;
      }
      for (j = 0; j < numGrandchildren; j++) {
        queue.enqueue(hole.holes[j]);
      }
    }
    polygons.push(outerRing);
  }
  return polygons;
};
PolygonGeometryLibrary.polygonsFromHierarchy = function(polygonHierarchy, projectPointsTo2D, scaleToEllipsoidSurface, ellipsoid) {
  const hierarchy = [];
  const polygons = [];
  const queue = new Queue_default();
  queue.enqueue(polygonHierarchy);
  while (queue.length !== 0) {
    const outerNode = queue.dequeue();
    let outerRing = outerNode.positions;
    const holes = outerNode.holes;
    let i2;
    let length3;
    if (scaleToEllipsoidSurface) {
      length3 = outerRing.length;
      for (i2 = 0; i2 < length3; i2++) {
        ellipsoid.scaleToGeodeticSurface(outerRing[i2], outerRing[i2]);
      }
    }
    outerRing = arrayRemoveDuplicates_default(
      outerRing,
      Cartesian3_default.equalsEpsilon,
      true
    );
    if (outerRing.length < 3) {
      continue;
    }
    let positions2D = projectPointsTo2D(outerRing);
    if (!defined_default(positions2D)) {
      continue;
    }
    const holeIndices = [];
    let originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
      positions2D
    );
    if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
      positions2D.reverse();
      outerRing = outerRing.slice().reverse();
    }
    let positions = outerRing.slice();
    const numChildren = defined_default(holes) ? holes.length : 0;
    const polygonHoles = [];
    let j;
    for (i2 = 0; i2 < numChildren; i2++) {
      const hole = holes[i2];
      let holePositions = hole.positions;
      if (scaleToEllipsoidSurface) {
        length3 = holePositions.length;
        for (j = 0; j < length3; ++j) {
          ellipsoid.scaleToGeodeticSurface(holePositions[j], holePositions[j]);
        }
      }
      holePositions = arrayRemoveDuplicates_default(
        holePositions,
        Cartesian3_default.equalsEpsilon,
        true
      );
      if (holePositions.length < 3) {
        continue;
      }
      const holePositions2D = projectPointsTo2D(holePositions);
      if (!defined_default(holePositions2D)) {
        continue;
      }
      originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
        holePositions2D
      );
      if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
        holePositions2D.reverse();
        holePositions = holePositions.slice().reverse();
      }
      polygonHoles.push(holePositions);
      holeIndices.push(positions.length);
      positions = positions.concat(holePositions);
      positions2D = positions2D.concat(holePositions2D);
      let numGrandchildren = 0;
      if (defined_default(hole.holes)) {
        numGrandchildren = hole.holes.length;
      }
      for (j = 0; j < numGrandchildren; j++) {
        queue.enqueue(hole.holes[j]);
      }
    }
    hierarchy.push({
      outerRing,
      holes: polygonHoles
    });
    polygons.push({
      positions,
      positions2D,
      holes: holeIndices
    });
  }
  return {
    hierarchy,
    polygons
  };
};
var computeBoundingRectangleCartesian2 = new Cartesian2_default();
var computeBoundingRectangleCartesian3 = new Cartesian3_default();
var computeBoundingRectangleQuaternion = new Quaternion_default();
var computeBoundingRectangleMatrix3 = new Matrix3_default();
PolygonGeometryLibrary.computeBoundingRectangle = function(planeNormal, projectPointTo2D, positions, angle, result) {
  const rotation = Quaternion_default.fromAxisAngle(
    planeNormal,
    angle,
    computeBoundingRectangleQuaternion
  );
  const textureMatrix = Matrix3_default.fromQuaternion(
    rotation,
    computeBoundingRectangleMatrix3
  );
  let minX = Number.POSITIVE_INFINITY;
  let maxX = Number.NEGATIVE_INFINITY;
  let minY = Number.POSITIVE_INFINITY;
  let maxY = Number.NEGATIVE_INFINITY;
  const length3 = positions.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const p2 = Cartesian3_default.clone(
      positions[i2],
      computeBoundingRectangleCartesian3
    );
    Matrix3_default.multiplyByVector(textureMatrix, p2, p2);
    const st = projectPointTo2D(p2, computeBoundingRectangleCartesian2);
    if (defined_default(st)) {
      minX = Math.min(minX, st.x);
      maxX = Math.max(maxX, st.x);
      minY = Math.min(minY, st.y);
      maxY = Math.max(maxY, st.y);
    }
  }
  result.x = minX;
  result.y = minY;
  result.width = maxX - minX;
  result.height = maxY - minY;
  return result;
};
PolygonGeometryLibrary.createGeometryFromPositions = function(ellipsoid, polygon, granularity, perPositionHeight, vertexFormat, arcType) {
  let indices2 = PolygonPipeline_default.triangulate(polygon.positions2D, polygon.holes);
  if (indices2.length < 3) {
    indices2 = [0, 1, 2];
  }
  const positions = polygon.positions;
  if (perPositionHeight) {
    const length3 = positions.length;
    const flattenedPositions = new Array(length3 * 3);
    let index2 = 0;
    for (let i2 = 0; i2 < length3; i2++) {
      const p2 = positions[i2];
      flattenedPositions[index2++] = p2.x;
      flattenedPositions[index2++] = p2.y;
      flattenedPositions[index2++] = p2.z;
    }
    const geometry = new Geometry_default({
      attributes: {
        position: new GeometryAttribute_default({
          componentDatatype: ComponentDatatype_default.DOUBLE,
          componentsPerAttribute: 3,
          values: flattenedPositions
        })
      },
      indices: indices2,
      primitiveType: PrimitiveType_default.TRIANGLES
    });
    if (vertexFormat.normal) {
      return GeometryPipeline_default.computeNormal(geometry);
    }
    return geometry;
  }
  if (arcType === ArcType_default.GEODESIC) {
    return PolygonPipeline_default.computeSubdivision(
      ellipsoid,
      positions,
      indices2,
      granularity
    );
  } else if (arcType === ArcType_default.RHUMB) {
    return PolygonPipeline_default.computeRhumbLineSubdivision(
      ellipsoid,
      positions,
      indices2,
      granularity
    );
  }
};
var computeWallIndicesSubdivided = [];
var p1Scratch2 = new Cartesian3_default();
var p2Scratch2 = new Cartesian3_default();
PolygonGeometryLibrary.computeWallGeometry = function(positions, ellipsoid, granularity, perPositionHeight, arcType) {
  let edgePositions;
  let topEdgeLength;
  let i2;
  let p1;
  let p2;
  let length3 = positions.length;
  let index2 = 0;
  if (!perPositionHeight) {
    const minDistance = Math_default.chordLength(
      granularity,
      ellipsoid.maximumRadius
    );
    let numVertices = 0;
    if (arcType === ArcType_default.GEODESIC) {
      for (i2 = 0; i2 < length3; i2++) {
        numVertices += PolygonGeometryLibrary.subdivideLineCount(
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance
        );
      }
    } else if (arcType === ArcType_default.RHUMB) {
      for (i2 = 0; i2 < length3; i2++) {
        numVertices += PolygonGeometryLibrary.subdivideRhumbLineCount(
          ellipsoid,
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance
        );
      }
    }
    topEdgeLength = (numVertices + length3) * 3;
    edgePositions = new Array(topEdgeLength * 2);
    for (i2 = 0; i2 < length3; i2++) {
      p1 = positions[i2];
      p2 = positions[(i2 + 1) % length3];
      let tempPositions;
      if (arcType === ArcType_default.GEODESIC) {
        tempPositions = PolygonGeometryLibrary.subdivideLine(
          p1,
          p2,
          minDistance,
          computeWallIndicesSubdivided
        );
      } else if (arcType === ArcType_default.RHUMB) {
        tempPositions = PolygonGeometryLibrary.subdivideRhumbLine(
          ellipsoid,
          p1,
          p2,
          minDistance,
          computeWallIndicesSubdivided
        );
      }
      const tempPositionsLength = tempPositions.length;
      for (let j = 0; j < tempPositionsLength; ++j, ++index2) {
        edgePositions[index2] = tempPositions[j];
        edgePositions[index2 + topEdgeLength] = tempPositions[j];
      }
      edgePositions[index2] = p2.x;
      edgePositions[index2 + topEdgeLength] = p2.x;
      ++index2;
      edgePositions[index2] = p2.y;
      edgePositions[index2 + topEdgeLength] = p2.y;
      ++index2;
      edgePositions[index2] = p2.z;
      edgePositions[index2 + topEdgeLength] = p2.z;
      ++index2;
    }
  } else {
    topEdgeLength = length3 * 3 * 2;
    edgePositions = new Array(topEdgeLength * 2);
    for (i2 = 0; i2 < length3; i2++) {
      p1 = positions[i2];
      p2 = positions[(i2 + 1) % length3];
      edgePositions[index2] = edgePositions[index2 + topEdgeLength] = p1.x;
      ++index2;
      edgePositions[index2] = edgePositions[index2 + topEdgeLength] = p1.y;
      ++index2;
      edgePositions[index2] = edgePositions[index2 + topEdgeLength] = p1.z;
      ++index2;
      edgePositions[index2] = edgePositions[index2 + topEdgeLength] = p2.x;
      ++index2;
      edgePositions[index2] = edgePositions[index2 + topEdgeLength] = p2.y;
      ++index2;
      edgePositions[index2] = edgePositions[index2 + topEdgeLength] = p2.z;
      ++index2;
    }
  }
  length3 = edgePositions.length;
  const indices2 = IndexDatatype_default.createTypedArray(
    length3 / 3,
    length3 - positions.length * 6
  );
  let edgeIndex = 0;
  length3 /= 6;
  for (i2 = 0; i2 < length3; i2++) {
    const UL = i2;
    const UR = UL + 1;
    const LL = UL + length3;
    const LR = LL + 1;
    p1 = Cartesian3_default.fromArray(edgePositions, UL * 3, p1Scratch2);
    p2 = Cartesian3_default.fromArray(edgePositions, UR * 3, p2Scratch2);
    if (Cartesian3_default.equalsEpsilon(
      p1,
      p2,
      Math_default.EPSILON10,
      Math_default.EPSILON10
    )) {
      continue;
    }
    indices2[edgeIndex++] = UL;
    indices2[edgeIndex++] = LL;
    indices2[edgeIndex++] = UR;
    indices2[edgeIndex++] = UR;
    indices2[edgeIndex++] = LL;
    indices2[edgeIndex++] = LR;
  }
  return new Geometry_default({
    attributes: new GeometryAttributes_default({
      position: new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.DOUBLE,
        componentsPerAttribute: 3,
        values: edgePositions
      })
    }),
    indices: indices2,
    primitiveType: PrimitiveType_default.TRIANGLES
  });
};
var PolygonGeometryLibrary_default = PolygonGeometryLibrary;

// node_modules/cesium/Source/Core/CoplanarPolygonGeometry.js
var scratchPosition2 = new Cartesian3_default();
var scratchBR = new BoundingRectangle_default();
var stScratch = new Cartesian2_default();
var textureCoordinatesOrigin = new Cartesian2_default();
var scratchNormal4 = new Cartesian3_default();
var scratchTangent2 = new Cartesian3_default();
var scratchBitangent2 = new Cartesian3_default();
var centerScratch = new Cartesian3_default();
var axis1Scratch = new Cartesian3_default();
var axis2Scratch = new Cartesian3_default();
var quaternionScratch2 = new Quaternion_default();
var textureMatrixScratch2 = new Matrix3_default();
var tangentRotationScratch = new Matrix3_default();
var surfaceNormalScratch = new Cartesian3_default();
function createGeometryFromPolygon(polygon, vertexFormat, boundingRectangle, stRotation, projectPointTo2D, normal2, tangent, bitangent) {
  const positions = polygon.positions;
  let indices2 = PolygonPipeline_default.triangulate(polygon.positions2D, polygon.holes);
  if (indices2.length < 3) {
    indices2 = [0, 1, 2];
  }
  const newIndices = IndexDatatype_default.createTypedArray(
    positions.length,
    indices2.length
  );
  newIndices.set(indices2);
  let textureMatrix = textureMatrixScratch2;
  if (stRotation !== 0) {
    let rotation = Quaternion_default.fromAxisAngle(
      normal2,
      stRotation,
      quaternionScratch2
    );
    textureMatrix = Matrix3_default.fromQuaternion(rotation, textureMatrix);
    if (vertexFormat.tangent || vertexFormat.bitangent) {
      rotation = Quaternion_default.fromAxisAngle(
        normal2,
        -stRotation,
        quaternionScratch2
      );
      const tangentRotation = Matrix3_default.fromQuaternion(
        rotation,
        tangentRotationScratch
      );
      tangent = Cartesian3_default.normalize(
        Matrix3_default.multiplyByVector(tangentRotation, tangent, tangent),
        tangent
      );
      if (vertexFormat.bitangent) {
        bitangent = Cartesian3_default.normalize(
          Cartesian3_default.cross(normal2, tangent, bitangent),
          bitangent
        );
      }
    }
  } else {
    textureMatrix = Matrix3_default.clone(Matrix3_default.IDENTITY, textureMatrix);
  }
  const stOrigin = textureCoordinatesOrigin;
  if (vertexFormat.st) {
    stOrigin.x = boundingRectangle.x;
    stOrigin.y = boundingRectangle.y;
  }
  const length3 = positions.length;
  const size = length3 * 3;
  const flatPositions2 = new Float64Array(size);
  const normals = vertexFormat.normal ? new Float32Array(size) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(size) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(size) : void 0;
  const textureCoordinates = vertexFormat.st ? new Float32Array(length3 * 2) : void 0;
  let positionIndex = 0;
  let normalIndex = 0;
  let bitangentIndex = 0;
  let tangentIndex = 0;
  let stIndex = 0;
  for (let i2 = 0; i2 < length3; i2++) {
    const position = positions[i2];
    flatPositions2[positionIndex++] = position.x;
    flatPositions2[positionIndex++] = position.y;
    flatPositions2[positionIndex++] = position.z;
    if (vertexFormat.st) {
      const p2 = Matrix3_default.multiplyByVector(
        textureMatrix,
        position,
        scratchPosition2
      );
      const st = projectPointTo2D(p2, stScratch);
      Cartesian2_default.subtract(st, stOrigin, st);
      const stx = Math_default.clamp(st.x / boundingRectangle.width, 0, 1);
      const sty = Math_default.clamp(st.y / boundingRectangle.height, 0, 1);
      textureCoordinates[stIndex++] = stx;
      textureCoordinates[stIndex++] = sty;
    }
    if (vertexFormat.normal) {
      normals[normalIndex++] = normal2.x;
      normals[normalIndex++] = normal2.y;
      normals[normalIndex++] = normal2.z;
    }
    if (vertexFormat.tangent) {
      tangents[tangentIndex++] = tangent.x;
      tangents[tangentIndex++] = tangent.y;
      tangents[tangentIndex++] = tangent.z;
    }
    if (vertexFormat.bitangent) {
      bitangents[bitangentIndex++] = bitangent.x;
      bitangents[bitangentIndex++] = bitangent.y;
      bitangents[bitangentIndex++] = bitangent.z;
    }
  }
  const attributes = new GeometryAttributes_default();
  if (vertexFormat.position) {
    attributes.position = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: flatPositions2
    });
  }
  if (vertexFormat.normal) {
    attributes.normal = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: normals
    });
  }
  if (vertexFormat.tangent) {
    attributes.tangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: tangents
    });
  }
  if (vertexFormat.bitangent) {
    attributes.bitangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: bitangents
    });
  }
  if (vertexFormat.st) {
    attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: textureCoordinates
    });
  }
  return new Geometry_default({
    attributes,
    indices: newIndices,
    primitiveType: PrimitiveType_default.TRIANGLES
  });
}
function CoplanarPolygonGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const polygonHierarchy = options.polygonHierarchy;
  Check_default.defined("options.polygonHierarchy", polygonHierarchy);
  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
  this._polygonHierarchy = polygonHierarchy;
  this._stRotation = defaultValue_default(options.stRotation, 0);
  this._ellipsoid = Ellipsoid_default.clone(
    defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
  );
  this._workerName = "createCoplanarPolygonGeometry";
  this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(polygonHierarchy) + VertexFormat_default.packedLength + Ellipsoid_default.packedLength + 2;
}
CoplanarPolygonGeometry.fromPositions = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.positions", options.positions);
  const newOptions2 = {
    polygonHierarchy: {
      positions: options.positions
    },
    vertexFormat: options.vertexFormat,
    stRotation: options.stRotation,
    ellipsoid: options.ellipsoid
  };
  return new CoplanarPolygonGeometry(newOptions2);
};
CoplanarPolygonGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
    value._polygonHierarchy,
    array,
    startingIndex
  );
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex++] = value._stRotation;
  array[startingIndex] = value.packedLength;
  return array;
};
var scratchEllipsoid3 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchVertexFormat3 = new VertexFormat_default();
var scratchOptions7 = {
  polygonHierarchy: {}
};
CoplanarPolygonGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
    array,
    startingIndex
  );
  startingIndex = polygonHierarchy.startingIndex;
  delete polygonHierarchy.startingIndex;
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid3);
  startingIndex += Ellipsoid_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat3
  );
  startingIndex += VertexFormat_default.packedLength;
  const stRotation = array[startingIndex++];
  const packedLength = array[startingIndex];
  if (!defined_default(result)) {
    result = new CoplanarPolygonGeometry(scratchOptions7);
  }
  result._polygonHierarchy = polygonHierarchy;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._stRotation = stRotation;
  result.packedLength = packedLength;
  return result;
};
CoplanarPolygonGeometry.createGeometry = function(polygonGeometry) {
  const vertexFormat = polygonGeometry._vertexFormat;
  const polygonHierarchy = polygonGeometry._polygonHierarchy;
  const stRotation = polygonGeometry._stRotation;
  let outerPositions = polygonHierarchy.positions;
  outerPositions = arrayRemoveDuplicates_default(
    outerPositions,
    Cartesian3_default.equalsEpsilon,
    true
  );
  if (outerPositions.length < 3) {
    return;
  }
  let normal2 = scratchNormal4;
  let tangent = scratchTangent2;
  let bitangent = scratchBitangent2;
  let axis1 = axis1Scratch;
  const axis2 = axis2Scratch;
  const validGeometry = CoplanarPolygonGeometryLibrary_default.computeProjectTo2DArguments(
    outerPositions,
    centerScratch,
    axis1,
    axis2
  );
  if (!validGeometry) {
    return void 0;
  }
  normal2 = Cartesian3_default.cross(axis1, axis2, normal2);
  normal2 = Cartesian3_default.normalize(normal2, normal2);
  if (!Cartesian3_default.equalsEpsilon(
    centerScratch,
    Cartesian3_default.ZERO,
    Math_default.EPSILON6
  )) {
    const surfaceNormal = polygonGeometry._ellipsoid.geodeticSurfaceNormal(
      centerScratch,
      surfaceNormalScratch
    );
    if (Cartesian3_default.dot(normal2, surfaceNormal) < 0) {
      normal2 = Cartesian3_default.negate(normal2, normal2);
      axis1 = Cartesian3_default.negate(axis1, axis1);
    }
  }
  const projectPoints = CoplanarPolygonGeometryLibrary_default.createProjectPointsTo2DFunction(
    centerScratch,
    axis1,
    axis2
  );
  const projectPoint = CoplanarPolygonGeometryLibrary_default.createProjectPointTo2DFunction(
    centerScratch,
    axis1,
    axis2
  );
  if (vertexFormat.tangent) {
    tangent = Cartesian3_default.clone(axis1, tangent);
  }
  if (vertexFormat.bitangent) {
    bitangent = Cartesian3_default.clone(axis2, bitangent);
  }
  const results = PolygonGeometryLibrary_default.polygonsFromHierarchy(
    polygonHierarchy,
    projectPoints,
    false
  );
  const hierarchy = results.hierarchy;
  const polygons = results.polygons;
  if (hierarchy.length === 0) {
    return;
  }
  outerPositions = hierarchy[0].outerRing;
  const boundingSphere = BoundingSphere_default.fromPoints(outerPositions);
  const boundingRectangle = PolygonGeometryLibrary_default.computeBoundingRectangle(
    normal2,
    projectPoint,
    outerPositions,
    stRotation,
    scratchBR
  );
  const geometries = [];
  for (let i2 = 0; i2 < polygons.length; i2++) {
    const geometryInstance = new GeometryInstance_default({
      geometry: createGeometryFromPolygon(
        polygons[i2],
        vertexFormat,
        boundingRectangle,
        stRotation,
        projectPoint,
        normal2,
        tangent,
        bitangent
      )
    });
    geometries.push(geometryInstance);
  }
  const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
  geometry.attributes.position.values = new Float64Array(
    geometry.attributes.position.values
  );
  geometry.indices = IndexDatatype_default.createTypedArray(
    geometry.attributes.position.values.length / 3,
    geometry.indices
  );
  const attributes = geometry.attributes;
  if (!vertexFormat.position) {
    delete attributes.position;
  }
  return new Geometry_default({
    attributes,
    indices: geometry.indices,
    primitiveType: geometry.primitiveType,
    boundingSphere
  });
};
var CoplanarPolygonGeometry_default = CoplanarPolygonGeometry;

// node_modules/cesium/Source/Core/CoplanarPolygonOutlineGeometry.js
function createGeometryFromPositions(positions) {
  const length3 = positions.length;
  const flatPositions2 = new Float64Array(length3 * 3);
  const indices2 = IndexDatatype_default.createTypedArray(length3, length3 * 2);
  let positionIndex = 0;
  let index2 = 0;
  for (let i2 = 0; i2 < length3; i2++) {
    const position = positions[i2];
    flatPositions2[positionIndex++] = position.x;
    flatPositions2[positionIndex++] = position.y;
    flatPositions2[positionIndex++] = position.z;
    indices2[index2++] = i2;
    indices2[index2++] = (i2 + 1) % length3;
  }
  const attributes = new GeometryAttributes_default({
    position: new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: flatPositions2
    })
  });
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.LINES
  });
}
function CoplanarPolygonOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const polygonHierarchy = options.polygonHierarchy;
  Check_default.defined("options.polygonHierarchy", polygonHierarchy);
  this._polygonHierarchy = polygonHierarchy;
  this._workerName = "createCoplanarPolygonOutlineGeometry";
  this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(polygonHierarchy) + 1;
}
CoplanarPolygonOutlineGeometry.fromPositions = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.positions", options.positions);
  const newOptions2 = {
    polygonHierarchy: {
      positions: options.positions
    }
  };
  return new CoplanarPolygonOutlineGeometry(newOptions2);
};
CoplanarPolygonOutlineGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
    value._polygonHierarchy,
    array,
    startingIndex
  );
  array[startingIndex] = value.packedLength;
  return array;
};
var scratchOptions8 = {
  polygonHierarchy: {}
};
CoplanarPolygonOutlineGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
    array,
    startingIndex
  );
  startingIndex = polygonHierarchy.startingIndex;
  delete polygonHierarchy.startingIndex;
  const packedLength = array[startingIndex];
  if (!defined_default(result)) {
    result = new CoplanarPolygonOutlineGeometry(scratchOptions8);
  }
  result._polygonHierarchy = polygonHierarchy;
  result.packedLength = packedLength;
  return result;
};
CoplanarPolygonOutlineGeometry.createGeometry = function(polygonGeometry) {
  const polygonHierarchy = polygonGeometry._polygonHierarchy;
  let outerPositions = polygonHierarchy.positions;
  outerPositions = arrayRemoveDuplicates_default(
    outerPositions,
    Cartesian3_default.equalsEpsilon,
    true
  );
  if (outerPositions.length < 3) {
    return;
  }
  const isValid = CoplanarPolygonGeometryLibrary_default.validOutline(outerPositions);
  if (!isValid) {
    return void 0;
  }
  const polygons = PolygonGeometryLibrary_default.polygonOutlinesFromHierarchy(
    polygonHierarchy,
    false
  );
  if (polygons.length === 0) {
    return void 0;
  }
  const geometries = [];
  for (let i2 = 0; i2 < polygons.length; i2++) {
    const geometryInstance = new GeometryInstance_default({
      geometry: createGeometryFromPositions(polygons[i2])
    });
    geometries.push(geometryInstance);
  }
  const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
  const boundingSphere = BoundingSphere_default.fromPoints(polygonHierarchy.positions);
  return new Geometry_default({
    attributes: geometry.attributes,
    indices: geometry.indices,
    primitiveType: geometry.primitiveType,
    boundingSphere
  });
};
var CoplanarPolygonOutlineGeometry_default = CoplanarPolygonOutlineGeometry;

// node_modules/cesium/Source/Core/CornerType.js
var CornerType = {
  ROUNDED: 0,
  MITERED: 1,
  BEVELED: 2
};
var CornerType_default = Object.freeze(CornerType);

// node_modules/cesium/Source/Core/EllipsoidGeodesic.js
function setConstants(ellipsoidGeodesic3) {
  const uSquared = ellipsoidGeodesic3._uSquared;
  const a4 = ellipsoidGeodesic3._ellipsoid.maximumRadius;
  const b = ellipsoidGeodesic3._ellipsoid.minimumRadius;
  const f2 = (a4 - b) / a4;
  const cosineHeading = Math.cos(ellipsoidGeodesic3._startHeading);
  const sineHeading = Math.sin(ellipsoidGeodesic3._startHeading);
  const tanU = (1 - f2) * Math.tan(ellipsoidGeodesic3._start.latitude);
  const cosineU = 1 / Math.sqrt(1 + tanU * tanU);
  const sineU = cosineU * tanU;
  const sigma = Math.atan2(tanU, cosineHeading);
  const sineAlpha = cosineU * sineHeading;
  const sineSquaredAlpha = sineAlpha * sineAlpha;
  const cosineSquaredAlpha = 1 - sineSquaredAlpha;
  const cosineAlpha = Math.sqrt(cosineSquaredAlpha);
  const u2Over4 = uSquared / 4;
  const u4Over16 = u2Over4 * u2Over4;
  const u6Over64 = u4Over16 * u2Over4;
  const u8Over256 = u4Over16 * u4Over16;
  const a0 = 1 + u2Over4 - 3 * u4Over16 / 4 + 5 * u6Over64 / 4 - 175 * u8Over256 / 64;
  const a1 = 1 - u2Over4 + 15 * u4Over16 / 8 - 35 * u6Over64 / 8;
  const a22 = 1 - 3 * u2Over4 + 35 * u4Over16 / 4;
  const a32 = 1 - 5 * u2Over4;
  const distanceRatio = a0 * sigma - a1 * Math.sin(2 * sigma) * u2Over4 / 2 - a22 * Math.sin(4 * sigma) * u4Over16 / 16 - a32 * Math.sin(6 * sigma) * u6Over64 / 48 - Math.sin(8 * sigma) * 5 * u8Over256 / 512;
  const constants2 = ellipsoidGeodesic3._constants;
  constants2.a = a4;
  constants2.b = b;
  constants2.f = f2;
  constants2.cosineHeading = cosineHeading;
  constants2.sineHeading = sineHeading;
  constants2.tanU = tanU;
  constants2.cosineU = cosineU;
  constants2.sineU = sineU;
  constants2.sigma = sigma;
  constants2.sineAlpha = sineAlpha;
  constants2.sineSquaredAlpha = sineSquaredAlpha;
  constants2.cosineSquaredAlpha = cosineSquaredAlpha;
  constants2.cosineAlpha = cosineAlpha;
  constants2.u2Over4 = u2Over4;
  constants2.u4Over16 = u4Over16;
  constants2.u6Over64 = u6Over64;
  constants2.u8Over256 = u8Over256;
  constants2.a0 = a0;
  constants2.a1 = a1;
  constants2.a2 = a22;
  constants2.a3 = a32;
  constants2.distanceRatio = distanceRatio;
}
function computeC(f2, cosineSquaredAlpha) {
  return f2 * cosineSquaredAlpha * (4 + f2 * (4 - 3 * cosineSquaredAlpha)) / 16;
}
function computeDeltaLambda(f2, sineAlpha, cosineSquaredAlpha, sigma, sineSigma, cosineSigma, cosineTwiceSigmaMidpoint) {
  const C = computeC(f2, cosineSquaredAlpha);
  return (1 - C) * f2 * sineAlpha * (sigma + C * sineSigma * (cosineTwiceSigmaMidpoint + C * cosineSigma * (2 * cosineTwiceSigmaMidpoint * cosineTwiceSigmaMidpoint - 1)));
}
function vincentyInverseFormula(ellipsoidGeodesic3, major, minor, firstLongitude, firstLatitude, secondLongitude, secondLatitude) {
  const eff = (major - minor) / major;
  const l2 = secondLongitude - firstLongitude;
  const u12 = Math.atan((1 - eff) * Math.tan(firstLatitude));
  const u22 = Math.atan((1 - eff) * Math.tan(secondLatitude));
  const cosineU1 = Math.cos(u12);
  const sineU1 = Math.sin(u12);
  const cosineU2 = Math.cos(u22);
  const sineU2 = Math.sin(u22);
  const cc = cosineU1 * cosineU2;
  const cs = cosineU1 * sineU2;
  const ss = sineU1 * sineU2;
  const sc = sineU1 * cosineU2;
  let lambda = l2;
  let lambdaDot = Math_default.TWO_PI;
  let cosineLambda = Math.cos(lambda);
  let sineLambda = Math.sin(lambda);
  let sigma;
  let cosineSigma;
  let sineSigma;
  let cosineSquaredAlpha;
  let cosineTwiceSigmaMidpoint;
  do {
    cosineLambda = Math.cos(lambda);
    sineLambda = Math.sin(lambda);
    const temp = cs - sc * cosineLambda;
    sineSigma = Math.sqrt(
      cosineU2 * cosineU2 * sineLambda * sineLambda + temp * temp
    );
    cosineSigma = ss + cc * cosineLambda;
    sigma = Math.atan2(sineSigma, cosineSigma);
    let sineAlpha;
    if (sineSigma === 0) {
      sineAlpha = 0;
      cosineSquaredAlpha = 1;
    } else {
      sineAlpha = cc * sineLambda / sineSigma;
      cosineSquaredAlpha = 1 - sineAlpha * sineAlpha;
    }
    lambdaDot = lambda;
    cosineTwiceSigmaMidpoint = cosineSigma - 2 * ss / cosineSquaredAlpha;
    if (!isFinite(cosineTwiceSigmaMidpoint)) {
      cosineTwiceSigmaMidpoint = 0;
    }
    lambda = l2 + computeDeltaLambda(
      eff,
      sineAlpha,
      cosineSquaredAlpha,
      sigma,
      sineSigma,
      cosineSigma,
      cosineTwiceSigmaMidpoint
    );
  } while (Math.abs(lambda - lambdaDot) > Math_default.EPSILON12);
  const uSquared = cosineSquaredAlpha * (major * major - minor * minor) / (minor * minor);
  const A = 1 + uSquared * (4096 + uSquared * (uSquared * (320 - 175 * uSquared) - 768)) / 16384;
  const B = uSquared * (256 + uSquared * (uSquared * (74 - 47 * uSquared) - 128)) / 1024;
  const cosineSquaredTwiceSigmaMidpoint = cosineTwiceSigmaMidpoint * cosineTwiceSigmaMidpoint;
  const deltaSigma = B * sineSigma * (cosineTwiceSigmaMidpoint + B * (cosineSigma * (2 * cosineSquaredTwiceSigmaMidpoint - 1) - B * cosineTwiceSigmaMidpoint * (4 * sineSigma * sineSigma - 3) * (4 * cosineSquaredTwiceSigmaMidpoint - 3) / 6) / 4);
  const distance2 = minor * A * (sigma - deltaSigma);
  const startHeading = Math.atan2(
    cosineU2 * sineLambda,
    cs - sc * cosineLambda
  );
  const endHeading = Math.atan2(cosineU1 * sineLambda, cs * cosineLambda - sc);
  ellipsoidGeodesic3._distance = distance2;
  ellipsoidGeodesic3._startHeading = startHeading;
  ellipsoidGeodesic3._endHeading = endHeading;
  ellipsoidGeodesic3._uSquared = uSquared;
}
var scratchCart12 = new Cartesian3_default();
var scratchCart22 = new Cartesian3_default();
function computeProperties2(ellipsoidGeodesic3, start, end, ellipsoid) {
  const firstCartesian = Cartesian3_default.normalize(
    ellipsoid.cartographicToCartesian(start, scratchCart22),
    scratchCart12
  );
  const lastCartesian = Cartesian3_default.normalize(
    ellipsoid.cartographicToCartesian(end, scratchCart22),
    scratchCart22
  );
  Check_default.typeOf.number.greaterThanOrEquals(
    "value",
    Math.abs(
      Math.abs(Cartesian3_default.angleBetween(firstCartesian, lastCartesian)) - Math.PI
    ),
    0.0125
  );
  vincentyInverseFormula(
    ellipsoidGeodesic3,
    ellipsoid.maximumRadius,
    ellipsoid.minimumRadius,
    start.longitude,
    start.latitude,
    end.longitude,
    end.latitude
  );
  ellipsoidGeodesic3._start = Cartographic_default.clone(
    start,
    ellipsoidGeodesic3._start
  );
  ellipsoidGeodesic3._end = Cartographic_default.clone(end, ellipsoidGeodesic3._end);
  ellipsoidGeodesic3._start.height = 0;
  ellipsoidGeodesic3._end.height = 0;
  setConstants(ellipsoidGeodesic3);
}
function EllipsoidGeodesic(start, end, ellipsoid) {
  const e2 = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  this._ellipsoid = e2;
  this._start = new Cartographic_default();
  this._end = new Cartographic_default();
  this._constants = {};
  this._startHeading = void 0;
  this._endHeading = void 0;
  this._distance = void 0;
  this._uSquared = void 0;
  if (defined_default(start) && defined_default(end)) {
    computeProperties2(this, start, end, e2);
  }
}
Object.defineProperties(EllipsoidGeodesic.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  },
  surfaceDistance: {
    get: function() {
      Check_default.defined("distance", this._distance);
      return this._distance;
    }
  },
  start: {
    get: function() {
      return this._start;
    }
  },
  end: {
    get: function() {
      return this._end;
    }
  },
  startHeading: {
    get: function() {
      Check_default.defined("distance", this._distance);
      return this._startHeading;
    }
  },
  endHeading: {
    get: function() {
      Check_default.defined("distance", this._distance);
      return this._endHeading;
    }
  }
});
EllipsoidGeodesic.prototype.setEndPoints = function(start, end) {
  Check_default.defined("start", start);
  Check_default.defined("end", end);
  computeProperties2(this, start, end, this._ellipsoid);
};
EllipsoidGeodesic.prototype.interpolateUsingFraction = function(fraction, result) {
  return this.interpolateUsingSurfaceDistance(
    this._distance * fraction,
    result
  );
};
EllipsoidGeodesic.prototype.interpolateUsingSurfaceDistance = function(distance2, result) {
  Check_default.defined("distance", this._distance);
  const constants2 = this._constants;
  const s2 = constants2.distanceRatio + distance2 / constants2.b;
  const cosine2S = Math.cos(2 * s2);
  const cosine4S = Math.cos(4 * s2);
  const cosine6S = Math.cos(6 * s2);
  const sine2S = Math.sin(2 * s2);
  const sine4S = Math.sin(4 * s2);
  const sine6S = Math.sin(6 * s2);
  const sine8S = Math.sin(8 * s2);
  const s22 = s2 * s2;
  const s3 = s2 * s22;
  const u8Over256 = constants2.u8Over256;
  const u2Over4 = constants2.u2Over4;
  const u6Over64 = constants2.u6Over64;
  const u4Over16 = constants2.u4Over16;
  let sigma = 2 * s3 * u8Over256 * cosine2S / 3 + s2 * (1 - u2Over4 + 7 * u4Over16 / 4 - 15 * u6Over64 / 4 + 579 * u8Over256 / 64 - (u4Over16 - 15 * u6Over64 / 4 + 187 * u8Over256 / 16) * cosine2S - (5 * u6Over64 / 4 - 115 * u8Over256 / 16) * cosine4S - 29 * u8Over256 * cosine6S / 16) + (u2Over4 / 2 - u4Over16 + 71 * u6Over64 / 32 - 85 * u8Over256 / 16) * sine2S + (5 * u4Over16 / 16 - 5 * u6Over64 / 4 + 383 * u8Over256 / 96) * sine4S - s22 * ((u6Over64 - 11 * u8Over256 / 2) * sine2S + 5 * u8Over256 * sine4S / 2) + (29 * u6Over64 / 96 - 29 * u8Over256 / 16) * sine6S + 539 * u8Over256 * sine8S / 1536;
  const theta = Math.asin(Math.sin(sigma) * constants2.cosineAlpha);
  const latitude = Math.atan(constants2.a / constants2.b * Math.tan(theta));
  sigma = sigma - constants2.sigma;
  const cosineTwiceSigmaMidpoint = Math.cos(2 * constants2.sigma + sigma);
  const sineSigma = Math.sin(sigma);
  const cosineSigma = Math.cos(sigma);
  const cc = constants2.cosineU * cosineSigma;
  const ss = constants2.sineU * sineSigma;
  const lambda = Math.atan2(
    sineSigma * constants2.sineHeading,
    cc - ss * constants2.cosineHeading
  );
  const l2 = lambda - computeDeltaLambda(
    constants2.f,
    constants2.sineAlpha,
    constants2.cosineSquaredAlpha,
    sigma,
    sineSigma,
    cosineSigma,
    cosineTwiceSigmaMidpoint
  );
  if (defined_default(result)) {
    result.longitude = this._start.longitude + l2;
    result.latitude = latitude;
    result.height = 0;
    return result;
  }
  return new Cartographic_default(this._start.longitude + l2, latitude, 0);
};
var EllipsoidGeodesic_default = EllipsoidGeodesic;

// node_modules/cesium/Source/Core/PolylinePipeline.js
var PolylinePipeline = {};
PolylinePipeline.numberOfPoints = function(p0, p1, minDistance) {
  const distance2 = Cartesian3_default.distance(p0, p1);
  return Math.ceil(distance2 / minDistance);
};
PolylinePipeline.numberOfPointsRhumbLine = function(p0, p1, granularity) {
  const radiansDistanceSquared = Math.pow(p0.longitude - p1.longitude, 2) + Math.pow(p0.latitude - p1.latitude, 2);
  return Math.max(
    1,
    Math.ceil(Math.sqrt(radiansDistanceSquared / (granularity * granularity)))
  );
};
var cartoScratch = new Cartographic_default();
PolylinePipeline.extractHeights = function(positions, ellipsoid) {
  const length3 = positions.length;
  const heights = new Array(length3);
  for (let i2 = 0; i2 < length3; i2++) {
    const p2 = positions[i2];
    heights[i2] = ellipsoid.cartesianToCartographic(p2, cartoScratch).height;
  }
  return heights;
};
var wrapLongitudeInversMatrix = new Matrix4_default();
var wrapLongitudeOrigin = new Cartesian3_default();
var wrapLongitudeXZNormal = new Cartesian3_default();
var wrapLongitudeXZPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
var wrapLongitudeYZNormal = new Cartesian3_default();
var wrapLongitudeYZPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
var wrapLongitudeIntersection = new Cartesian3_default();
var wrapLongitudeOffset = new Cartesian3_default();
var subdivideHeightsScratchArray = [];
function subdivideHeights(numPoints, h0, h1) {
  const heights = subdivideHeightsScratchArray;
  heights.length = numPoints;
  let i2;
  if (h0 === h1) {
    for (i2 = 0; i2 < numPoints; i2++) {
      heights[i2] = h0;
    }
    return heights;
  }
  const dHeight = h1 - h0;
  const heightPerVertex = dHeight / numPoints;
  for (i2 = 0; i2 < numPoints; i2++) {
    const h = h0 + i2 * heightPerVertex;
    heights[i2] = h;
  }
  return heights;
}
var carto1 = new Cartographic_default();
var carto2 = new Cartographic_default();
var cartesian = new Cartesian3_default();
var scaleFirst = new Cartesian3_default();
var scaleLast = new Cartesian3_default();
var ellipsoidGeodesic = new EllipsoidGeodesic_default();
var ellipsoidRhumb = new EllipsoidRhumbLine_default();
function generateCartesianArc(p0, p1, minDistance, ellipsoid, h0, h1, array, offset2) {
  const first = ellipsoid.scaleToGeodeticSurface(p0, scaleFirst);
  const last = ellipsoid.scaleToGeodeticSurface(p1, scaleLast);
  const numPoints = PolylinePipeline.numberOfPoints(p0, p1, minDistance);
  const start = ellipsoid.cartesianToCartographic(first, carto1);
  const end = ellipsoid.cartesianToCartographic(last, carto2);
  const heights = subdivideHeights(numPoints, h0, h1);
  ellipsoidGeodesic.setEndPoints(start, end);
  const surfaceDistanceBetweenPoints = ellipsoidGeodesic.surfaceDistance / numPoints;
  let index2 = offset2;
  start.height = h0;
  let cart = ellipsoid.cartographicToCartesian(start, cartesian);
  Cartesian3_default.pack(cart, array, index2);
  index2 += 3;
  for (let i2 = 1; i2 < numPoints; i2++) {
    const carto = ellipsoidGeodesic.interpolateUsingSurfaceDistance(
      i2 * surfaceDistanceBetweenPoints,
      carto2
    );
    carto.height = heights[i2];
    cart = ellipsoid.cartographicToCartesian(carto, cartesian);
    Cartesian3_default.pack(cart, array, index2);
    index2 += 3;
  }
  return index2;
}
function generateCartesianRhumbArc(p0, p1, granularity, ellipsoid, h0, h1, array, offset2) {
  const start = ellipsoid.cartesianToCartographic(p0, carto1);
  const end = ellipsoid.cartesianToCartographic(p1, carto2);
  const numPoints = PolylinePipeline.numberOfPointsRhumbLine(
    start,
    end,
    granularity
  );
  start.height = 0;
  end.height = 0;
  const heights = subdivideHeights(numPoints, h0, h1);
  if (!ellipsoidRhumb.ellipsoid.equals(ellipsoid)) {
    ellipsoidRhumb = new EllipsoidRhumbLine_default(void 0, void 0, ellipsoid);
  }
  ellipsoidRhumb.setEndPoints(start, end);
  const surfaceDistanceBetweenPoints = ellipsoidRhumb.surfaceDistance / numPoints;
  let index2 = offset2;
  start.height = h0;
  let cart = ellipsoid.cartographicToCartesian(start, cartesian);
  Cartesian3_default.pack(cart, array, index2);
  index2 += 3;
  for (let i2 = 1; i2 < numPoints; i2++) {
    const carto = ellipsoidRhumb.interpolateUsingSurfaceDistance(
      i2 * surfaceDistanceBetweenPoints,
      carto2
    );
    carto.height = heights[i2];
    cart = ellipsoid.cartographicToCartesian(carto, cartesian);
    Cartesian3_default.pack(cart, array, index2);
    index2 += 3;
  }
  return index2;
}
PolylinePipeline.wrapLongitude = function(positions, modelMatrix) {
  const cartesians = [];
  const segments = [];
  if (defined_default(positions) && positions.length > 0) {
    modelMatrix = defaultValue_default(modelMatrix, Matrix4_default.IDENTITY);
    const inverseModelMatrix = Matrix4_default.inverseTransformation(
      modelMatrix,
      wrapLongitudeInversMatrix
    );
    const origin = Matrix4_default.multiplyByPoint(
      inverseModelMatrix,
      Cartesian3_default.ZERO,
      wrapLongitudeOrigin
    );
    const xzNormal = Cartesian3_default.normalize(
      Matrix4_default.multiplyByPointAsVector(
        inverseModelMatrix,
        Cartesian3_default.UNIT_Y,
        wrapLongitudeXZNormal
      ),
      wrapLongitudeXZNormal
    );
    const xzPlane2 = Plane_default.fromPointNormal(
      origin,
      xzNormal,
      wrapLongitudeXZPlane
    );
    const yzNormal = Cartesian3_default.normalize(
      Matrix4_default.multiplyByPointAsVector(
        inverseModelMatrix,
        Cartesian3_default.UNIT_X,
        wrapLongitudeYZNormal
      ),
      wrapLongitudeYZNormal
    );
    const yzPlane = Plane_default.fromPointNormal(
      origin,
      yzNormal,
      wrapLongitudeYZPlane
    );
    let count = 1;
    cartesians.push(Cartesian3_default.clone(positions[0]));
    let prev = cartesians[0];
    const length3 = positions.length;
    for (let i2 = 1; i2 < length3; ++i2) {
      const cur = positions[i2];
      if (Plane_default.getPointDistance(yzPlane, prev) < 0 || Plane_default.getPointDistance(yzPlane, cur) < 0) {
        const intersection = IntersectionTests_default.lineSegmentPlane(
          prev,
          cur,
          xzPlane2,
          wrapLongitudeIntersection
        );
        if (defined_default(intersection)) {
          const offset2 = Cartesian3_default.multiplyByScalar(
            xzNormal,
            5e-9,
            wrapLongitudeOffset
          );
          if (Plane_default.getPointDistance(xzPlane2, prev) < 0) {
            Cartesian3_default.negate(offset2, offset2);
          }
          cartesians.push(
            Cartesian3_default.add(intersection, offset2, new Cartesian3_default())
          );
          segments.push(count + 1);
          Cartesian3_default.negate(offset2, offset2);
          cartesians.push(
            Cartesian3_default.add(intersection, offset2, new Cartesian3_default())
          );
          count = 1;
        }
      }
      cartesians.push(Cartesian3_default.clone(positions[i2]));
      count++;
      prev = cur;
    }
    segments.push(count);
  }
  return {
    positions: cartesians,
    lengths: segments
  };
};
PolylinePipeline.generateArc = function(options) {
  if (!defined_default(options)) {
    options = {};
  }
  const positions = options.positions;
  if (!defined_default(positions)) {
    throw new DeveloperError_default("options.positions is required.");
  }
  const length3 = positions.length;
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  let height = defaultValue_default(options.height, 0);
  const hasHeightArray = Array.isArray(height);
  if (length3 < 1) {
    return [];
  } else if (length3 === 1) {
    const p2 = ellipsoid.scaleToGeodeticSurface(positions[0], scaleFirst);
    height = hasHeightArray ? height[0] : height;
    if (height !== 0) {
      const n2 = ellipsoid.geodeticSurfaceNormal(p2, cartesian);
      Cartesian3_default.multiplyByScalar(n2, height, n2);
      Cartesian3_default.add(p2, n2, p2);
    }
    return [p2.x, p2.y, p2.z];
  }
  let minDistance = options.minDistance;
  if (!defined_default(minDistance)) {
    const granularity = defaultValue_default(
      options.granularity,
      Math_default.RADIANS_PER_DEGREE
    );
    minDistance = Math_default.chordLength(granularity, ellipsoid.maximumRadius);
  }
  let numPoints = 0;
  let i2;
  for (i2 = 0; i2 < length3 - 1; i2++) {
    numPoints += PolylinePipeline.numberOfPoints(
      positions[i2],
      positions[i2 + 1],
      minDistance
    );
  }
  const arrayLength = (numPoints + 1) * 3;
  const newPositions = new Array(arrayLength);
  let offset2 = 0;
  for (i2 = 0; i2 < length3 - 1; i2++) {
    const p0 = positions[i2];
    const p1 = positions[i2 + 1];
    const h0 = hasHeightArray ? height[i2] : height;
    const h1 = hasHeightArray ? height[i2 + 1] : height;
    offset2 = generateCartesianArc(
      p0,
      p1,
      minDistance,
      ellipsoid,
      h0,
      h1,
      newPositions,
      offset2
    );
  }
  subdivideHeightsScratchArray.length = 0;
  const lastPoint = positions[length3 - 1];
  const carto = ellipsoid.cartesianToCartographic(lastPoint, carto1);
  carto.height = hasHeightArray ? height[length3 - 1] : height;
  const cart = ellipsoid.cartographicToCartesian(carto, cartesian);
  Cartesian3_default.pack(cart, newPositions, arrayLength - 3);
  return newPositions;
};
var scratchCartographic02 = new Cartographic_default();
var scratchCartographic12 = new Cartographic_default();
PolylinePipeline.generateRhumbArc = function(options) {
  if (!defined_default(options)) {
    options = {};
  }
  const positions = options.positions;
  if (!defined_default(positions)) {
    throw new DeveloperError_default("options.positions is required.");
  }
  const length3 = positions.length;
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  let height = defaultValue_default(options.height, 0);
  const hasHeightArray = Array.isArray(height);
  if (length3 < 1) {
    return [];
  } else if (length3 === 1) {
    const p2 = ellipsoid.scaleToGeodeticSurface(positions[0], scaleFirst);
    height = hasHeightArray ? height[0] : height;
    if (height !== 0) {
      const n2 = ellipsoid.geodeticSurfaceNormal(p2, cartesian);
      Cartesian3_default.multiplyByScalar(n2, height, n2);
      Cartesian3_default.add(p2, n2, p2);
    }
    return [p2.x, p2.y, p2.z];
  }
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  let numPoints = 0;
  let i2;
  let c0 = ellipsoid.cartesianToCartographic(
    positions[0],
    scratchCartographic02
  );
  let c14;
  for (i2 = 0; i2 < length3 - 1; i2++) {
    c14 = ellipsoid.cartesianToCartographic(
      positions[i2 + 1],
      scratchCartographic12
    );
    numPoints += PolylinePipeline.numberOfPointsRhumbLine(c0, c14, granularity);
    c0 = Cartographic_default.clone(c14, scratchCartographic02);
  }
  const arrayLength = (numPoints + 1) * 3;
  const newPositions = new Array(arrayLength);
  let offset2 = 0;
  for (i2 = 0; i2 < length3 - 1; i2++) {
    const p0 = positions[i2];
    const p1 = positions[i2 + 1];
    const h0 = hasHeightArray ? height[i2] : height;
    const h1 = hasHeightArray ? height[i2 + 1] : height;
    offset2 = generateCartesianRhumbArc(
      p0,
      p1,
      granularity,
      ellipsoid,
      h0,
      h1,
      newPositions,
      offset2
    );
  }
  subdivideHeightsScratchArray.length = 0;
  const lastPoint = positions[length3 - 1];
  const carto = ellipsoid.cartesianToCartographic(lastPoint, carto1);
  carto.height = hasHeightArray ? height[length3 - 1] : height;
  const cart = ellipsoid.cartographicToCartesian(carto, cartesian);
  Cartesian3_default.pack(cart, newPositions, arrayLength - 3);
  return newPositions;
};
PolylinePipeline.generateCartesianArc = function(options) {
  const numberArray = PolylinePipeline.generateArc(options);
  const size = numberArray.length / 3;
  const newPositions = new Array(size);
  for (let i2 = 0; i2 < size; i2++) {
    newPositions[i2] = Cartesian3_default.unpack(numberArray, i2 * 3);
  }
  return newPositions;
};
PolylinePipeline.generateCartesianRhumbArc = function(options) {
  const numberArray = PolylinePipeline.generateRhumbArc(options);
  const size = numberArray.length / 3;
  const newPositions = new Array(size);
  for (let i2 = 0; i2 < size; i2++) {
    newPositions[i2] = Cartesian3_default.unpack(numberArray, i2 * 3);
  }
  return newPositions;
};
var PolylinePipeline_default = PolylinePipeline;

// node_modules/cesium/Source/Core/oneTimeWarning.js
var warnings = {};
function oneTimeWarning(identifier, message) {
  if (!defined_default(identifier)) {
    throw new DeveloperError_default("identifier is required.");
  }
  if (!defined_default(warnings[identifier])) {
    warnings[identifier] = true;
    console.warn(defaultValue_default(message, identifier));
  }
}
oneTimeWarning.geometryOutlines = "Entity geometry outlines are unsupported on terrain. Outlines will be disabled. To enable outlines, disable geometry terrain clamping by explicitly setting height to 0.";
oneTimeWarning.geometryZIndex = "Entity geometry with zIndex are unsupported when height or extrudedHeight are defined.  zIndex will be ignored";
oneTimeWarning.geometryHeightReference = "Entity corridor, ellipse, polygon or rectangle with heightReference must also have a defined height.  heightReference will be ignored";
oneTimeWarning.geometryExtrudedHeightReference = "Entity corridor, ellipse, polygon or rectangle with extrudedHeightReference must also have a defined extrudedHeight.  extrudedHeightReference will be ignored";
var oneTimeWarning_default = oneTimeWarning;

// node_modules/cesium/Source/Core/PolylineVolumeGeometryLibrary.js
var scratch2Array = [new Cartesian3_default(), new Cartesian3_default()];
var scratchCartesian16 = new Cartesian3_default();
var scratchCartesian27 = new Cartesian3_default();
var scratchCartesian37 = new Cartesian3_default();
var scratchCartesian43 = new Cartesian3_default();
var scratchCartesian52 = new Cartesian3_default();
var scratchCartesian62 = new Cartesian3_default();
var scratchCartesian7 = new Cartesian3_default();
var scratchCartesian8 = new Cartesian3_default();
var scratchCartesian9 = new Cartesian3_default();
var scratch1 = new Cartesian3_default();
var scratch2 = new Cartesian3_default();
var PolylineVolumeGeometryLibrary = {};
var cartographic = new Cartographic_default();
function scaleToSurface(positions, ellipsoid) {
  const heights = new Array(positions.length);
  for (let i2 = 0; i2 < positions.length; i2++) {
    const pos = positions[i2];
    cartographic = ellipsoid.cartesianToCartographic(pos, cartographic);
    heights[i2] = cartographic.height;
    positions[i2] = ellipsoid.scaleToGeodeticSurface(pos, pos);
  }
  return heights;
}
function subdivideHeights2(points, h0, h1, granularity) {
  const p0 = points[0];
  const p1 = points[1];
  const angleBetween = Cartesian3_default.angleBetween(p0, p1);
  const numPoints = Math.ceil(angleBetween / granularity);
  const heights = new Array(numPoints);
  let i2;
  if (h0 === h1) {
    for (i2 = 0; i2 < numPoints; i2++) {
      heights[i2] = h0;
    }
    heights.push(h1);
    return heights;
  }
  const dHeight = h1 - h0;
  const heightPerVertex = dHeight / numPoints;
  for (i2 = 1; i2 < numPoints; i2++) {
    const h = h0 + i2 * heightPerVertex;
    heights[i2] = h;
  }
  heights[0] = h0;
  heights.push(h1);
  return heights;
}
var nextScratch = new Cartesian3_default();
var prevScratch = new Cartesian3_default();
function computeRotationAngle(start, end, position, ellipsoid) {
  const tangentPlane = new EllipsoidTangentPlane_default(position, ellipsoid);
  const next = tangentPlane.projectPointOntoPlane(
    Cartesian3_default.add(position, start, nextScratch),
    nextScratch
  );
  const prev = tangentPlane.projectPointOntoPlane(
    Cartesian3_default.add(position, end, prevScratch),
    prevScratch
  );
  const angle = Cartesian2_default.angleBetween(next, prev);
  return prev.x * next.y - prev.y * next.x >= 0 ? -angle : angle;
}
var negativeX = new Cartesian3_default(-1, 0, 0);
var transform = new Matrix4_default();
var translation = new Matrix4_default();
var rotationZ = new Matrix3_default();
var scaleMatrix = Matrix3_default.IDENTITY.clone();
var westScratch2 = new Cartesian3_default();
var finalPosScratch = new Cartesian4_default();
var heightCartesian = new Cartesian3_default();
function addPosition(center, left, shape, finalPositions, ellipsoid, height, xScalar, repeat) {
  let west = westScratch2;
  let finalPosition = finalPosScratch;
  transform = Transforms_default.eastNorthUpToFixedFrame(center, ellipsoid, transform);
  west = Matrix4_default.multiplyByPointAsVector(transform, negativeX, west);
  west = Cartesian3_default.normalize(west, west);
  const angle = computeRotationAngle(west, left, center, ellipsoid);
  rotationZ = Matrix3_default.fromRotationZ(angle, rotationZ);
  heightCartesian.z = height;
  transform = Matrix4_default.multiplyTransformation(
    transform,
    Matrix4_default.fromRotationTranslation(rotationZ, heightCartesian, translation),
    transform
  );
  const scale = scaleMatrix;
  scale[0] = xScalar;
  for (let j = 0; j < repeat; j++) {
    for (let i2 = 0; i2 < shape.length; i2 += 3) {
      finalPosition = Cartesian3_default.fromArray(shape, i2, finalPosition);
      finalPosition = Matrix3_default.multiplyByVector(
        scale,
        finalPosition,
        finalPosition
      );
      finalPosition = Matrix4_default.multiplyByPoint(
        transform,
        finalPosition,
        finalPosition
      );
      finalPositions.push(finalPosition.x, finalPosition.y, finalPosition.z);
    }
  }
  return finalPositions;
}
var centerScratch2 = new Cartesian3_default();
function addPositions(centers, left, shape, finalPositions, ellipsoid, heights, xScalar) {
  for (let i2 = 0; i2 < centers.length; i2 += 3) {
    const center = Cartesian3_default.fromArray(centers, i2, centerScratch2);
    finalPositions = addPosition(
      center,
      left,
      shape,
      finalPositions,
      ellipsoid,
      heights[i2 / 3],
      xScalar,
      1
    );
  }
  return finalPositions;
}
function convertShapeTo3DDuplicate(shape2D, boundingRectangle) {
  const length3 = shape2D.length;
  const shape = new Array(length3 * 6);
  let index2 = 0;
  const xOffset = boundingRectangle.x + boundingRectangle.width / 2;
  const yOffset = boundingRectangle.y + boundingRectangle.height / 2;
  let point = shape2D[0];
  shape[index2++] = point.x - xOffset;
  shape[index2++] = 0;
  shape[index2++] = point.y - yOffset;
  for (let i2 = 1; i2 < length3; i2++) {
    point = shape2D[i2];
    const x = point.x - xOffset;
    const z = point.y - yOffset;
    shape[index2++] = x;
    shape[index2++] = 0;
    shape[index2++] = z;
    shape[index2++] = x;
    shape[index2++] = 0;
    shape[index2++] = z;
  }
  point = shape2D[0];
  shape[index2++] = point.x - xOffset;
  shape[index2++] = 0;
  shape[index2++] = point.y - yOffset;
  return shape;
}
function convertShapeTo3D(shape2D, boundingRectangle) {
  const length3 = shape2D.length;
  const shape = new Array(length3 * 3);
  let index2 = 0;
  const xOffset = boundingRectangle.x + boundingRectangle.width / 2;
  const yOffset = boundingRectangle.y + boundingRectangle.height / 2;
  for (let i2 = 0; i2 < length3; i2++) {
    shape[index2++] = shape2D[i2].x - xOffset;
    shape[index2++] = 0;
    shape[index2++] = shape2D[i2].y - yOffset;
  }
  return shape;
}
var quaterion = new Quaternion_default();
var startPointScratch = new Cartesian3_default();
var rotMatrix = new Matrix3_default();
function computeRoundCorner(pivot, startPoint, endPoint, cornerType, leftIsOutside, ellipsoid, finalPositions, shape, height, duplicatePoints) {
  const angle = Cartesian3_default.angleBetween(
    Cartesian3_default.subtract(startPoint, pivot, scratch1),
    Cartesian3_default.subtract(endPoint, pivot, scratch2)
  );
  const granularity = cornerType === CornerType_default.BEVELED ? 0 : Math.ceil(angle / Math_default.toRadians(5));
  let m;
  if (leftIsOutside) {
    m = Matrix3_default.fromQuaternion(
      Quaternion_default.fromAxisAngle(
        Cartesian3_default.negate(pivot, scratch1),
        angle / (granularity + 1),
        quaterion
      ),
      rotMatrix
    );
  } else {
    m = Matrix3_default.fromQuaternion(
      Quaternion_default.fromAxisAngle(pivot, angle / (granularity + 1), quaterion),
      rotMatrix
    );
  }
  let left;
  let surfacePoint;
  startPoint = Cartesian3_default.clone(startPoint, startPointScratch);
  if (granularity > 0) {
    const repeat = duplicatePoints ? 2 : 1;
    for (let i2 = 0; i2 < granularity; i2++) {
      startPoint = Matrix3_default.multiplyByVector(m, startPoint, startPoint);
      left = Cartesian3_default.subtract(startPoint, pivot, scratch1);
      left = Cartesian3_default.normalize(left, left);
      if (!leftIsOutside) {
        left = Cartesian3_default.negate(left, left);
      }
      surfacePoint = ellipsoid.scaleToGeodeticSurface(startPoint, scratch2);
      finalPositions = addPosition(
        surfacePoint,
        left,
        shape,
        finalPositions,
        ellipsoid,
        height,
        1,
        repeat
      );
    }
  } else {
    left = Cartesian3_default.subtract(startPoint, pivot, scratch1);
    left = Cartesian3_default.normalize(left, left);
    if (!leftIsOutside) {
      left = Cartesian3_default.negate(left, left);
    }
    surfacePoint = ellipsoid.scaleToGeodeticSurface(startPoint, scratch2);
    finalPositions = addPosition(
      surfacePoint,
      left,
      shape,
      finalPositions,
      ellipsoid,
      height,
      1,
      1
    );
    endPoint = Cartesian3_default.clone(endPoint, startPointScratch);
    left = Cartesian3_default.subtract(endPoint, pivot, scratch1);
    left = Cartesian3_default.normalize(left, left);
    if (!leftIsOutside) {
      left = Cartesian3_default.negate(left, left);
    }
    surfacePoint = ellipsoid.scaleToGeodeticSurface(endPoint, scratch2);
    finalPositions = addPosition(
      surfacePoint,
      left,
      shape,
      finalPositions,
      ellipsoid,
      height,
      1,
      1
    );
  }
  return finalPositions;
}
PolylineVolumeGeometryLibrary.removeDuplicatesFromShape = function(shapePositions) {
  const length3 = shapePositions.length;
  const cleanedPositions = [];
  for (let i0 = length3 - 1, i1 = 0; i1 < length3; i0 = i1++) {
    const v02 = shapePositions[i0];
    const v13 = shapePositions[i1];
    if (!Cartesian2_default.equals(v02, v13)) {
      cleanedPositions.push(v13);
    }
  }
  return cleanedPositions;
};
PolylineVolumeGeometryLibrary.angleIsGreaterThanPi = function(forward, backward, position, ellipsoid) {
  const tangentPlane = new EllipsoidTangentPlane_default(position, ellipsoid);
  const next = tangentPlane.projectPointOntoPlane(
    Cartesian3_default.add(position, forward, nextScratch),
    nextScratch
  );
  const prev = tangentPlane.projectPointOntoPlane(
    Cartesian3_default.add(position, backward, prevScratch),
    prevScratch
  );
  return prev.x * next.y - prev.y * next.x >= 0;
};
var scratchForwardProjection = new Cartesian3_default();
var scratchBackwardProjection = new Cartesian3_default();
PolylineVolumeGeometryLibrary.computePositions = function(positions, shape2D, boundingRectangle, geometry, duplicatePoints) {
  const ellipsoid = geometry._ellipsoid;
  const heights = scaleToSurface(positions, ellipsoid);
  const granularity = geometry._granularity;
  const cornerType = geometry._cornerType;
  const shapeForSides = duplicatePoints ? convertShapeTo3DDuplicate(shape2D, boundingRectangle) : convertShapeTo3D(shape2D, boundingRectangle);
  const shapeForEnds = duplicatePoints ? convertShapeTo3D(shape2D, boundingRectangle) : void 0;
  const heightOffset = boundingRectangle.height / 2;
  const width = boundingRectangle.width / 2;
  let length3 = positions.length;
  let finalPositions = [];
  let ends = duplicatePoints ? [] : void 0;
  let forward = scratchCartesian16;
  let backward = scratchCartesian27;
  let cornerDirection = scratchCartesian37;
  let surfaceNormal = scratchCartesian43;
  let pivot = scratchCartesian52;
  let start = scratchCartesian62;
  let end = scratchCartesian7;
  let left = scratchCartesian8;
  let previousPosition = scratchCartesian9;
  let position = positions[0];
  let nextPosition = positions[1];
  surfaceNormal = ellipsoid.geodeticSurfaceNormal(position, surfaceNormal);
  forward = Cartesian3_default.subtract(nextPosition, position, forward);
  forward = Cartesian3_default.normalize(forward, forward);
  left = Cartesian3_default.cross(surfaceNormal, forward, left);
  left = Cartesian3_default.normalize(left, left);
  let h0 = heights[0];
  let h1 = heights[1];
  if (duplicatePoints) {
    ends = addPosition(
      position,
      left,
      shapeForEnds,
      ends,
      ellipsoid,
      h0 + heightOffset,
      1,
      1
    );
  }
  previousPosition = Cartesian3_default.clone(position, previousPosition);
  position = nextPosition;
  backward = Cartesian3_default.negate(forward, backward);
  let subdividedHeights;
  let subdividedPositions;
  for (let i2 = 1; i2 < length3 - 1; i2++) {
    const repeat = duplicatePoints ? 2 : 1;
    nextPosition = positions[i2 + 1];
    if (position.equals(nextPosition)) {
      oneTimeWarning_default(
        "Positions are too close and are considered equivalent with rounding error."
      );
      continue;
    }
    forward = Cartesian3_default.subtract(nextPosition, position, forward);
    forward = Cartesian3_default.normalize(forward, forward);
    cornerDirection = Cartesian3_default.add(forward, backward, cornerDirection);
    cornerDirection = Cartesian3_default.normalize(cornerDirection, cornerDirection);
    surfaceNormal = ellipsoid.geodeticSurfaceNormal(position, surfaceNormal);
    const forwardProjection = Cartesian3_default.multiplyByScalar(
      surfaceNormal,
      Cartesian3_default.dot(forward, surfaceNormal),
      scratchForwardProjection
    );
    Cartesian3_default.subtract(forward, forwardProjection, forwardProjection);
    Cartesian3_default.normalize(forwardProjection, forwardProjection);
    const backwardProjection = Cartesian3_default.multiplyByScalar(
      surfaceNormal,
      Cartesian3_default.dot(backward, surfaceNormal),
      scratchBackwardProjection
    );
    Cartesian3_default.subtract(backward, backwardProjection, backwardProjection);
    Cartesian3_default.normalize(backwardProjection, backwardProjection);
    const doCorner = !Math_default.equalsEpsilon(
      Math.abs(Cartesian3_default.dot(forwardProjection, backwardProjection)),
      1,
      Math_default.EPSILON7
    );
    if (doCorner) {
      cornerDirection = Cartesian3_default.cross(
        cornerDirection,
        surfaceNormal,
        cornerDirection
      );
      cornerDirection = Cartesian3_default.cross(
        surfaceNormal,
        cornerDirection,
        cornerDirection
      );
      cornerDirection = Cartesian3_default.normalize(cornerDirection, cornerDirection);
      const scalar = 1 / Math.max(
        0.25,
        Cartesian3_default.magnitude(
          Cartesian3_default.cross(cornerDirection, backward, scratch1)
        )
      );
      const leftIsOutside = PolylineVolumeGeometryLibrary.angleIsGreaterThanPi(
        forward,
        backward,
        position,
        ellipsoid
      );
      if (leftIsOutside) {
        pivot = Cartesian3_default.add(
          position,
          Cartesian3_default.multiplyByScalar(
            cornerDirection,
            scalar * width,
            cornerDirection
          ),
          pivot
        );
        start = Cartesian3_default.add(
          pivot,
          Cartesian3_default.multiplyByScalar(left, width, start),
          start
        );
        scratch2Array[0] = Cartesian3_default.clone(previousPosition, scratch2Array[0]);
        scratch2Array[1] = Cartesian3_default.clone(start, scratch2Array[1]);
        subdividedHeights = subdivideHeights2(
          scratch2Array,
          h0 + heightOffset,
          h1 + heightOffset,
          granularity
        );
        subdividedPositions = PolylinePipeline_default.generateArc({
          positions: scratch2Array,
          granularity,
          ellipsoid
        });
        finalPositions = addPositions(
          subdividedPositions,
          left,
          shapeForSides,
          finalPositions,
          ellipsoid,
          subdividedHeights,
          1
        );
        left = Cartesian3_default.cross(surfaceNormal, forward, left);
        left = Cartesian3_default.normalize(left, left);
        end = Cartesian3_default.add(
          pivot,
          Cartesian3_default.multiplyByScalar(left, width, end),
          end
        );
        if (cornerType === CornerType_default.ROUNDED || cornerType === CornerType_default.BEVELED) {
          computeRoundCorner(
            pivot,
            start,
            end,
            cornerType,
            leftIsOutside,
            ellipsoid,
            finalPositions,
            shapeForSides,
            h1 + heightOffset,
            duplicatePoints
          );
        } else {
          cornerDirection = Cartesian3_default.negate(cornerDirection, cornerDirection);
          finalPositions = addPosition(
            position,
            cornerDirection,
            shapeForSides,
            finalPositions,
            ellipsoid,
            h1 + heightOffset,
            scalar,
            repeat
          );
        }
        previousPosition = Cartesian3_default.clone(end, previousPosition);
      } else {
        pivot = Cartesian3_default.add(
          position,
          Cartesian3_default.multiplyByScalar(
            cornerDirection,
            scalar * width,
            cornerDirection
          ),
          pivot
        );
        start = Cartesian3_default.add(
          pivot,
          Cartesian3_default.multiplyByScalar(left, -width, start),
          start
        );
        scratch2Array[0] = Cartesian3_default.clone(previousPosition, scratch2Array[0]);
        scratch2Array[1] = Cartesian3_default.clone(start, scratch2Array[1]);
        subdividedHeights = subdivideHeights2(
          scratch2Array,
          h0 + heightOffset,
          h1 + heightOffset,
          granularity
        );
        subdividedPositions = PolylinePipeline_default.generateArc({
          positions: scratch2Array,
          granularity,
          ellipsoid
        });
        finalPositions = addPositions(
          subdividedPositions,
          left,
          shapeForSides,
          finalPositions,
          ellipsoid,
          subdividedHeights,
          1
        );
        left = Cartesian3_default.cross(surfaceNormal, forward, left);
        left = Cartesian3_default.normalize(left, left);
        end = Cartesian3_default.add(
          pivot,
          Cartesian3_default.multiplyByScalar(left, -width, end),
          end
        );
        if (cornerType === CornerType_default.ROUNDED || cornerType === CornerType_default.BEVELED) {
          computeRoundCorner(
            pivot,
            start,
            end,
            cornerType,
            leftIsOutside,
            ellipsoid,
            finalPositions,
            shapeForSides,
            h1 + heightOffset,
            duplicatePoints
          );
        } else {
          finalPositions = addPosition(
            position,
            cornerDirection,
            shapeForSides,
            finalPositions,
            ellipsoid,
            h1 + heightOffset,
            scalar,
            repeat
          );
        }
        previousPosition = Cartesian3_default.clone(end, previousPosition);
      }
      backward = Cartesian3_default.negate(forward, backward);
    } else {
      finalPositions = addPosition(
        previousPosition,
        left,
        shapeForSides,
        finalPositions,
        ellipsoid,
        h0 + heightOffset,
        1,
        1
      );
      previousPosition = position;
    }
    h0 = h1;
    h1 = heights[i2 + 1];
    position = nextPosition;
  }
  scratch2Array[0] = Cartesian3_default.clone(previousPosition, scratch2Array[0]);
  scratch2Array[1] = Cartesian3_default.clone(position, scratch2Array[1]);
  subdividedHeights = subdivideHeights2(
    scratch2Array,
    h0 + heightOffset,
    h1 + heightOffset,
    granularity
  );
  subdividedPositions = PolylinePipeline_default.generateArc({
    positions: scratch2Array,
    granularity,
    ellipsoid
  });
  finalPositions = addPositions(
    subdividedPositions,
    left,
    shapeForSides,
    finalPositions,
    ellipsoid,
    subdividedHeights,
    1
  );
  if (duplicatePoints) {
    ends = addPosition(
      position,
      left,
      shapeForEnds,
      ends,
      ellipsoid,
      h1 + heightOffset,
      1,
      1
    );
  }
  length3 = finalPositions.length;
  const posLength = duplicatePoints ? length3 + ends.length : length3;
  const combinedPositions = new Float64Array(posLength);
  combinedPositions.set(finalPositions);
  if (duplicatePoints) {
    combinedPositions.set(ends, length3);
  }
  return combinedPositions;
};
var PolylineVolumeGeometryLibrary_default = PolylineVolumeGeometryLibrary;

// node_modules/cesium/Source/Core/CorridorGeometryLibrary.js
var CorridorGeometryLibrary = {};
var scratch12 = new Cartesian3_default();
var scratch22 = new Cartesian3_default();
var scratch3 = new Cartesian3_default();
var scratch4 = new Cartesian3_default();
var scaleArray2 = [new Cartesian3_default(), new Cartesian3_default()];
var cartesian1 = new Cartesian3_default();
var cartesian2 = new Cartesian3_default();
var cartesian3 = new Cartesian3_default();
var cartesian4 = new Cartesian3_default();
var cartesian5 = new Cartesian3_default();
var cartesian6 = new Cartesian3_default();
var cartesian7 = new Cartesian3_default();
var cartesian8 = new Cartesian3_default();
var cartesian9 = new Cartesian3_default();
var cartesian10 = new Cartesian3_default();
var quaterion2 = new Quaternion_default();
var rotMatrix2 = new Matrix3_default();
function computeRoundCorner2(cornerPoint, startPoint, endPoint, cornerType, leftIsOutside) {
  const angle = Cartesian3_default.angleBetween(
    Cartesian3_default.subtract(startPoint, cornerPoint, scratch12),
    Cartesian3_default.subtract(endPoint, cornerPoint, scratch22)
  );
  const granularity = cornerType === CornerType_default.BEVELED ? 1 : Math.ceil(angle / Math_default.toRadians(5)) + 1;
  const size = granularity * 3;
  const array = new Array(size);
  array[size - 3] = endPoint.x;
  array[size - 2] = endPoint.y;
  array[size - 1] = endPoint.z;
  let m;
  if (leftIsOutside) {
    m = Matrix3_default.fromQuaternion(
      Quaternion_default.fromAxisAngle(
        Cartesian3_default.negate(cornerPoint, scratch12),
        angle / granularity,
        quaterion2
      ),
      rotMatrix2
    );
  } else {
    m = Matrix3_default.fromQuaternion(
      Quaternion_default.fromAxisAngle(cornerPoint, angle / granularity, quaterion2),
      rotMatrix2
    );
  }
  let index2 = 0;
  startPoint = Cartesian3_default.clone(startPoint, scratch12);
  for (let i2 = 0; i2 < granularity; i2++) {
    startPoint = Matrix3_default.multiplyByVector(m, startPoint, startPoint);
    array[index2++] = startPoint.x;
    array[index2++] = startPoint.y;
    array[index2++] = startPoint.z;
  }
  return array;
}
function addEndCaps(calculatedPositions) {
  let cornerPoint = cartesian1;
  let startPoint = cartesian2;
  let endPoint = cartesian3;
  let leftEdge = calculatedPositions[1];
  startPoint = Cartesian3_default.fromArray(
    calculatedPositions[1],
    leftEdge.length - 3,
    startPoint
  );
  endPoint = Cartesian3_default.fromArray(calculatedPositions[0], 0, endPoint);
  cornerPoint = Cartesian3_default.midpoint(startPoint, endPoint, cornerPoint);
  const firstEndCap = computeRoundCorner2(
    cornerPoint,
    startPoint,
    endPoint,
    CornerType_default.ROUNDED,
    false
  );
  const length3 = calculatedPositions.length - 1;
  const rightEdge = calculatedPositions[length3 - 1];
  leftEdge = calculatedPositions[length3];
  startPoint = Cartesian3_default.fromArray(
    rightEdge,
    rightEdge.length - 3,
    startPoint
  );
  endPoint = Cartesian3_default.fromArray(leftEdge, 0, endPoint);
  cornerPoint = Cartesian3_default.midpoint(startPoint, endPoint, cornerPoint);
  const lastEndCap = computeRoundCorner2(
    cornerPoint,
    startPoint,
    endPoint,
    CornerType_default.ROUNDED,
    false
  );
  return [firstEndCap, lastEndCap];
}
function computeMiteredCorner(position, leftCornerDirection, lastPoint, leftIsOutside) {
  let cornerPoint = scratch12;
  if (leftIsOutside) {
    cornerPoint = Cartesian3_default.add(position, leftCornerDirection, cornerPoint);
  } else {
    leftCornerDirection = Cartesian3_default.negate(
      leftCornerDirection,
      leftCornerDirection
    );
    cornerPoint = Cartesian3_default.add(position, leftCornerDirection, cornerPoint);
  }
  return [
    cornerPoint.x,
    cornerPoint.y,
    cornerPoint.z,
    lastPoint.x,
    lastPoint.y,
    lastPoint.z
  ];
}
function addShiftedPositions(positions, left, scalar, calculatedPositions) {
  const rightPositions = new Array(positions.length);
  const leftPositions = new Array(positions.length);
  const scaledLeft = Cartesian3_default.multiplyByScalar(left, scalar, scratch12);
  const scaledRight = Cartesian3_default.negate(scaledLeft, scratch22);
  let rightIndex = 0;
  let leftIndex = positions.length - 1;
  for (let i2 = 0; i2 < positions.length; i2 += 3) {
    const pos = Cartesian3_default.fromArray(positions, i2, scratch3);
    const rightPos = Cartesian3_default.add(pos, scaledRight, scratch4);
    rightPositions[rightIndex++] = rightPos.x;
    rightPositions[rightIndex++] = rightPos.y;
    rightPositions[rightIndex++] = rightPos.z;
    const leftPos = Cartesian3_default.add(pos, scaledLeft, scratch4);
    leftPositions[leftIndex--] = leftPos.z;
    leftPositions[leftIndex--] = leftPos.y;
    leftPositions[leftIndex--] = leftPos.x;
  }
  calculatedPositions.push(rightPositions, leftPositions);
  return calculatedPositions;
}
CorridorGeometryLibrary.addAttribute = function(attribute, value, front, back) {
  const x = value.x;
  const y = value.y;
  const z = value.z;
  if (defined_default(front)) {
    attribute[front] = x;
    attribute[front + 1] = y;
    attribute[front + 2] = z;
  }
  if (defined_default(back)) {
    attribute[back] = z;
    attribute[back - 1] = y;
    attribute[back - 2] = x;
  }
};
var scratchForwardProjection2 = new Cartesian3_default();
var scratchBackwardProjection2 = new Cartesian3_default();
CorridorGeometryLibrary.computePositions = function(params) {
  const granularity = params.granularity;
  const positions = params.positions;
  const ellipsoid = params.ellipsoid;
  const width = params.width / 2;
  const cornerType = params.cornerType;
  const saveAttributes = params.saveAttributes;
  let normal2 = cartesian1;
  let forward = cartesian2;
  let backward = cartesian3;
  let left = cartesian4;
  let cornerDirection = cartesian5;
  let startPoint = cartesian6;
  let previousPos = cartesian7;
  let rightPos = cartesian8;
  let leftPos = cartesian9;
  let center = cartesian10;
  let calculatedPositions = [];
  const calculatedLefts = saveAttributes ? [] : void 0;
  const calculatedNormals = saveAttributes ? [] : void 0;
  let position = positions[0];
  let nextPosition = positions[1];
  forward = Cartesian3_default.normalize(
    Cartesian3_default.subtract(nextPosition, position, forward),
    forward
  );
  normal2 = ellipsoid.geodeticSurfaceNormal(position, normal2);
  left = Cartesian3_default.normalize(Cartesian3_default.cross(normal2, forward, left), left);
  if (saveAttributes) {
    calculatedLefts.push(left.x, left.y, left.z);
    calculatedNormals.push(normal2.x, normal2.y, normal2.z);
  }
  previousPos = Cartesian3_default.clone(position, previousPos);
  position = nextPosition;
  backward = Cartesian3_default.negate(forward, backward);
  let subdividedPositions;
  const corners = [];
  let i2;
  const length3 = positions.length;
  for (i2 = 1; i2 < length3 - 1; i2++) {
    normal2 = ellipsoid.geodeticSurfaceNormal(position, normal2);
    nextPosition = positions[i2 + 1];
    forward = Cartesian3_default.normalize(
      Cartesian3_default.subtract(nextPosition, position, forward),
      forward
    );
    cornerDirection = Cartesian3_default.normalize(
      Cartesian3_default.add(forward, backward, cornerDirection),
      cornerDirection
    );
    const forwardProjection = Cartesian3_default.multiplyByScalar(
      normal2,
      Cartesian3_default.dot(forward, normal2),
      scratchForwardProjection2
    );
    Cartesian3_default.subtract(forward, forwardProjection, forwardProjection);
    Cartesian3_default.normalize(forwardProjection, forwardProjection);
    const backwardProjection = Cartesian3_default.multiplyByScalar(
      normal2,
      Cartesian3_default.dot(backward, normal2),
      scratchBackwardProjection2
    );
    Cartesian3_default.subtract(backward, backwardProjection, backwardProjection);
    Cartesian3_default.normalize(backwardProjection, backwardProjection);
    const doCorner = !Math_default.equalsEpsilon(
      Math.abs(Cartesian3_default.dot(forwardProjection, backwardProjection)),
      1,
      Math_default.EPSILON7
    );
    if (doCorner) {
      cornerDirection = Cartesian3_default.cross(
        cornerDirection,
        normal2,
        cornerDirection
      );
      cornerDirection = Cartesian3_default.cross(
        normal2,
        cornerDirection,
        cornerDirection
      );
      cornerDirection = Cartesian3_default.normalize(cornerDirection, cornerDirection);
      const scalar = width / Math.max(
        0.25,
        Cartesian3_default.magnitude(
          Cartesian3_default.cross(cornerDirection, backward, scratch12)
        )
      );
      const leftIsOutside = PolylineVolumeGeometryLibrary_default.angleIsGreaterThanPi(
        forward,
        backward,
        position,
        ellipsoid
      );
      cornerDirection = Cartesian3_default.multiplyByScalar(
        cornerDirection,
        scalar,
        cornerDirection
      );
      if (leftIsOutside) {
        rightPos = Cartesian3_default.add(position, cornerDirection, rightPos);
        center = Cartesian3_default.add(
          rightPos,
          Cartesian3_default.multiplyByScalar(left, width, center),
          center
        );
        leftPos = Cartesian3_default.add(
          rightPos,
          Cartesian3_default.multiplyByScalar(left, width * 2, leftPos),
          leftPos
        );
        scaleArray2[0] = Cartesian3_default.clone(previousPos, scaleArray2[0]);
        scaleArray2[1] = Cartesian3_default.clone(center, scaleArray2[1]);
        subdividedPositions = PolylinePipeline_default.generateArc({
          positions: scaleArray2,
          granularity,
          ellipsoid
        });
        calculatedPositions = addShiftedPositions(
          subdividedPositions,
          left,
          width,
          calculatedPositions
        );
        if (saveAttributes) {
          calculatedLefts.push(left.x, left.y, left.z);
          calculatedNormals.push(normal2.x, normal2.y, normal2.z);
        }
        startPoint = Cartesian3_default.clone(leftPos, startPoint);
        left = Cartesian3_default.normalize(
          Cartesian3_default.cross(normal2, forward, left),
          left
        );
        leftPos = Cartesian3_default.add(
          rightPos,
          Cartesian3_default.multiplyByScalar(left, width * 2, leftPos),
          leftPos
        );
        previousPos = Cartesian3_default.add(
          rightPos,
          Cartesian3_default.multiplyByScalar(left, width, previousPos),
          previousPos
        );
        if (cornerType === CornerType_default.ROUNDED || cornerType === CornerType_default.BEVELED) {
          corners.push({
            leftPositions: computeRoundCorner2(
              rightPos,
              startPoint,
              leftPos,
              cornerType,
              leftIsOutside
            )
          });
        } else {
          corners.push({
            leftPositions: computeMiteredCorner(
              position,
              Cartesian3_default.negate(cornerDirection, cornerDirection),
              leftPos,
              leftIsOutside
            )
          });
        }
      } else {
        leftPos = Cartesian3_default.add(position, cornerDirection, leftPos);
        center = Cartesian3_default.add(
          leftPos,
          Cartesian3_default.negate(
            Cartesian3_default.multiplyByScalar(left, width, center),
            center
          ),
          center
        );
        rightPos = Cartesian3_default.add(
          leftPos,
          Cartesian3_default.negate(
            Cartesian3_default.multiplyByScalar(left, width * 2, rightPos),
            rightPos
          ),
          rightPos
        );
        scaleArray2[0] = Cartesian3_default.clone(previousPos, scaleArray2[0]);
        scaleArray2[1] = Cartesian3_default.clone(center, scaleArray2[1]);
        subdividedPositions = PolylinePipeline_default.generateArc({
          positions: scaleArray2,
          granularity,
          ellipsoid
        });
        calculatedPositions = addShiftedPositions(
          subdividedPositions,
          left,
          width,
          calculatedPositions
        );
        if (saveAttributes) {
          calculatedLefts.push(left.x, left.y, left.z);
          calculatedNormals.push(normal2.x, normal2.y, normal2.z);
        }
        startPoint = Cartesian3_default.clone(rightPos, startPoint);
        left = Cartesian3_default.normalize(
          Cartesian3_default.cross(normal2, forward, left),
          left
        );
        rightPos = Cartesian3_default.add(
          leftPos,
          Cartesian3_default.negate(
            Cartesian3_default.multiplyByScalar(left, width * 2, rightPos),
            rightPos
          ),
          rightPos
        );
        previousPos = Cartesian3_default.add(
          leftPos,
          Cartesian3_default.negate(
            Cartesian3_default.multiplyByScalar(left, width, previousPos),
            previousPos
          ),
          previousPos
        );
        if (cornerType === CornerType_default.ROUNDED || cornerType === CornerType_default.BEVELED) {
          corners.push({
            rightPositions: computeRoundCorner2(
              leftPos,
              startPoint,
              rightPos,
              cornerType,
              leftIsOutside
            )
          });
        } else {
          corners.push({
            rightPositions: computeMiteredCorner(
              position,
              cornerDirection,
              rightPos,
              leftIsOutside
            )
          });
        }
      }
      backward = Cartesian3_default.negate(forward, backward);
    }
    position = nextPosition;
  }
  normal2 = ellipsoid.geodeticSurfaceNormal(position, normal2);
  scaleArray2[0] = Cartesian3_default.clone(previousPos, scaleArray2[0]);
  scaleArray2[1] = Cartesian3_default.clone(position, scaleArray2[1]);
  subdividedPositions = PolylinePipeline_default.generateArc({
    positions: scaleArray2,
    granularity,
    ellipsoid
  });
  calculatedPositions = addShiftedPositions(
    subdividedPositions,
    left,
    width,
    calculatedPositions
  );
  if (saveAttributes) {
    calculatedLefts.push(left.x, left.y, left.z);
    calculatedNormals.push(normal2.x, normal2.y, normal2.z);
  }
  let endPositions;
  if (cornerType === CornerType_default.ROUNDED) {
    endPositions = addEndCaps(calculatedPositions);
  }
  return {
    positions: calculatedPositions,
    corners,
    lefts: calculatedLefts,
    normals: calculatedNormals,
    endPositions
  };
};
var CorridorGeometryLibrary_default = CorridorGeometryLibrary;

// node_modules/cesium/Source/Core/CorridorGeometry.js
var cartesian12 = new Cartesian3_default();
var cartesian22 = new Cartesian3_default();
var cartesian32 = new Cartesian3_default();
var cartesian42 = new Cartesian3_default();
var cartesian52 = new Cartesian3_default();
var cartesian62 = new Cartesian3_default();
var scratch13 = new Cartesian3_default();
var scratch23 = new Cartesian3_default();
function scaleToSurface2(positions, ellipsoid) {
  for (let i2 = 0; i2 < positions.length; i2++) {
    positions[i2] = ellipsoid.scaleToGeodeticSurface(positions[i2], positions[i2]);
  }
  return positions;
}
function addNormals(attr, normal2, left, front, back, vertexFormat) {
  const normals = attr.normals;
  const tangents = attr.tangents;
  const bitangents = attr.bitangents;
  const forward = Cartesian3_default.normalize(
    Cartesian3_default.cross(left, normal2, scratch13),
    scratch13
  );
  if (vertexFormat.normal) {
    CorridorGeometryLibrary_default.addAttribute(normals, normal2, front, back);
  }
  if (vertexFormat.tangent) {
    CorridorGeometryLibrary_default.addAttribute(tangents, forward, front, back);
  }
  if (vertexFormat.bitangent) {
    CorridorGeometryLibrary_default.addAttribute(bitangents, left, front, back);
  }
}
function combine2(computedPositions, vertexFormat, ellipsoid) {
  const positions = computedPositions.positions;
  const corners = computedPositions.corners;
  const endPositions = computedPositions.endPositions;
  const computedLefts = computedPositions.lefts;
  const computedNormals = computedPositions.normals;
  const attributes = new GeometryAttributes_default();
  let corner;
  let leftCount = 0;
  let rightCount = 0;
  let i2;
  let indicesLength = 0;
  let length3;
  for (i2 = 0; i2 < positions.length; i2 += 2) {
    length3 = positions[i2].length - 3;
    leftCount += length3;
    indicesLength += length3 * 2;
    rightCount += positions[i2 + 1].length - 3;
  }
  leftCount += 3;
  rightCount += 3;
  for (i2 = 0; i2 < corners.length; i2++) {
    corner = corners[i2];
    const leftSide = corners[i2].leftPositions;
    if (defined_default(leftSide)) {
      length3 = leftSide.length;
      leftCount += length3;
      indicesLength += length3;
    } else {
      length3 = corners[i2].rightPositions.length;
      rightCount += length3;
      indicesLength += length3;
    }
  }
  const addEndPositions = defined_default(endPositions);
  let endPositionLength;
  if (addEndPositions) {
    endPositionLength = endPositions[0].length - 3;
    leftCount += endPositionLength;
    rightCount += endPositionLength;
    endPositionLength /= 3;
    indicesLength += endPositionLength * 6;
  }
  const size = leftCount + rightCount;
  const finalPositions = new Float64Array(size);
  const normals = vertexFormat.normal ? new Float32Array(size) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(size) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(size) : void 0;
  const attr = {
    normals,
    tangents,
    bitangents
  };
  let front = 0;
  let back = size - 1;
  let UL, LL, UR, LR;
  let normal2 = cartesian12;
  let left = cartesian22;
  let rightPos, leftPos;
  const halfLength = endPositionLength / 2;
  const indices2 = IndexDatatype_default.createTypedArray(size / 3, indicesLength);
  let index2 = 0;
  if (addEndPositions) {
    leftPos = cartesian32;
    rightPos = cartesian42;
    const firstEndPositions = endPositions[0];
    normal2 = Cartesian3_default.fromArray(computedNormals, 0, normal2);
    left = Cartesian3_default.fromArray(computedLefts, 0, left);
    for (i2 = 0; i2 < halfLength; i2++) {
      leftPos = Cartesian3_default.fromArray(
        firstEndPositions,
        (halfLength - 1 - i2) * 3,
        leftPos
      );
      rightPos = Cartesian3_default.fromArray(
        firstEndPositions,
        (halfLength + i2) * 3,
        rightPos
      );
      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
      CorridorGeometryLibrary_default.addAttribute(
        finalPositions,
        leftPos,
        void 0,
        back
      );
      addNormals(attr, normal2, left, front, back, vertexFormat);
      LL = front / 3;
      LR = LL + 1;
      UL = (back - 2) / 3;
      UR = UL - 1;
      indices2[index2++] = UL;
      indices2[index2++] = LL;
      indices2[index2++] = UR;
      indices2[index2++] = UR;
      indices2[index2++] = LL;
      indices2[index2++] = LR;
      front += 3;
      back -= 3;
    }
  }
  let posIndex = 0;
  let compIndex = 0;
  let rightEdge = positions[posIndex++];
  let leftEdge = positions[posIndex++];
  finalPositions.set(rightEdge, front);
  finalPositions.set(leftEdge, back - leftEdge.length + 1);
  left = Cartesian3_default.fromArray(computedLefts, compIndex, left);
  let rightNormal;
  let leftNormal;
  length3 = leftEdge.length - 3;
  for (i2 = 0; i2 < length3; i2 += 3) {
    rightNormal = ellipsoid.geodeticSurfaceNormal(
      Cartesian3_default.fromArray(rightEdge, i2, scratch13),
      scratch13
    );
    leftNormal = ellipsoid.geodeticSurfaceNormal(
      Cartesian3_default.fromArray(leftEdge, length3 - i2, scratch23),
      scratch23
    );
    normal2 = Cartesian3_default.normalize(
      Cartesian3_default.add(rightNormal, leftNormal, normal2),
      normal2
    );
    addNormals(attr, normal2, left, front, back, vertexFormat);
    LL = front / 3;
    LR = LL + 1;
    UL = (back - 2) / 3;
    UR = UL - 1;
    indices2[index2++] = UL;
    indices2[index2++] = LL;
    indices2[index2++] = UR;
    indices2[index2++] = UR;
    indices2[index2++] = LL;
    indices2[index2++] = LR;
    front += 3;
    back -= 3;
  }
  rightNormal = ellipsoid.geodeticSurfaceNormal(
    Cartesian3_default.fromArray(rightEdge, length3, scratch13),
    scratch13
  );
  leftNormal = ellipsoid.geodeticSurfaceNormal(
    Cartesian3_default.fromArray(leftEdge, length3, scratch23),
    scratch23
  );
  normal2 = Cartesian3_default.normalize(
    Cartesian3_default.add(rightNormal, leftNormal, normal2),
    normal2
  );
  compIndex += 3;
  for (i2 = 0; i2 < corners.length; i2++) {
    let j;
    corner = corners[i2];
    const l2 = corner.leftPositions;
    const r2 = corner.rightPositions;
    let pivot;
    let start;
    let outsidePoint = cartesian62;
    let previousPoint = cartesian32;
    let nextPoint = cartesian42;
    normal2 = Cartesian3_default.fromArray(computedNormals, compIndex, normal2);
    if (defined_default(l2)) {
      addNormals(attr, normal2, left, void 0, back, vertexFormat);
      back -= 3;
      pivot = LR;
      start = UR;
      for (j = 0; j < l2.length / 3; j++) {
        outsidePoint = Cartesian3_default.fromArray(l2, j * 3, outsidePoint);
        indices2[index2++] = pivot;
        indices2[index2++] = start - j - 1;
        indices2[index2++] = start - j;
        CorridorGeometryLibrary_default.addAttribute(
          finalPositions,
          outsidePoint,
          void 0,
          back
        );
        previousPoint = Cartesian3_default.fromArray(
          finalPositions,
          (start - j - 1) * 3,
          previousPoint
        );
        nextPoint = Cartesian3_default.fromArray(finalPositions, pivot * 3, nextPoint);
        left = Cartesian3_default.normalize(
          Cartesian3_default.subtract(previousPoint, nextPoint, left),
          left
        );
        addNormals(attr, normal2, left, void 0, back, vertexFormat);
        back -= 3;
      }
      outsidePoint = Cartesian3_default.fromArray(
        finalPositions,
        pivot * 3,
        outsidePoint
      );
      previousPoint = Cartesian3_default.subtract(
        Cartesian3_default.fromArray(finalPositions, start * 3, previousPoint),
        outsidePoint,
        previousPoint
      );
      nextPoint = Cartesian3_default.subtract(
        Cartesian3_default.fromArray(finalPositions, (start - j) * 3, nextPoint),
        outsidePoint,
        nextPoint
      );
      left = Cartesian3_default.normalize(
        Cartesian3_default.add(previousPoint, nextPoint, left),
        left
      );
      addNormals(attr, normal2, left, front, void 0, vertexFormat);
      front += 3;
    } else {
      addNormals(attr, normal2, left, front, void 0, vertexFormat);
      front += 3;
      pivot = UR;
      start = LR;
      for (j = 0; j < r2.length / 3; j++) {
        outsidePoint = Cartesian3_default.fromArray(r2, j * 3, outsidePoint);
        indices2[index2++] = pivot;
        indices2[index2++] = start + j;
        indices2[index2++] = start + j + 1;
        CorridorGeometryLibrary_default.addAttribute(
          finalPositions,
          outsidePoint,
          front
        );
        previousPoint = Cartesian3_default.fromArray(
          finalPositions,
          pivot * 3,
          previousPoint
        );
        nextPoint = Cartesian3_default.fromArray(
          finalPositions,
          (start + j) * 3,
          nextPoint
        );
        left = Cartesian3_default.normalize(
          Cartesian3_default.subtract(previousPoint, nextPoint, left),
          left
        );
        addNormals(attr, normal2, left, front, void 0, vertexFormat);
        front += 3;
      }
      outsidePoint = Cartesian3_default.fromArray(
        finalPositions,
        pivot * 3,
        outsidePoint
      );
      previousPoint = Cartesian3_default.subtract(
        Cartesian3_default.fromArray(finalPositions, (start + j) * 3, previousPoint),
        outsidePoint,
        previousPoint
      );
      nextPoint = Cartesian3_default.subtract(
        Cartesian3_default.fromArray(finalPositions, start * 3, nextPoint),
        outsidePoint,
        nextPoint
      );
      left = Cartesian3_default.normalize(
        Cartesian3_default.negate(Cartesian3_default.add(nextPoint, previousPoint, left), left),
        left
      );
      addNormals(attr, normal2, left, void 0, back, vertexFormat);
      back -= 3;
    }
    rightEdge = positions[posIndex++];
    leftEdge = positions[posIndex++];
    rightEdge.splice(0, 3);
    leftEdge.splice(leftEdge.length - 3, 3);
    finalPositions.set(rightEdge, front);
    finalPositions.set(leftEdge, back - leftEdge.length + 1);
    length3 = leftEdge.length - 3;
    compIndex += 3;
    left = Cartesian3_default.fromArray(computedLefts, compIndex, left);
    for (j = 0; j < leftEdge.length; j += 3) {
      rightNormal = ellipsoid.geodeticSurfaceNormal(
        Cartesian3_default.fromArray(rightEdge, j, scratch13),
        scratch13
      );
      leftNormal = ellipsoid.geodeticSurfaceNormal(
        Cartesian3_default.fromArray(leftEdge, length3 - j, scratch23),
        scratch23
      );
      normal2 = Cartesian3_default.normalize(
        Cartesian3_default.add(rightNormal, leftNormal, normal2),
        normal2
      );
      addNormals(attr, normal2, left, front, back, vertexFormat);
      LR = front / 3;
      LL = LR - 1;
      UR = (back - 2) / 3;
      UL = UR + 1;
      indices2[index2++] = UL;
      indices2[index2++] = LL;
      indices2[index2++] = UR;
      indices2[index2++] = UR;
      indices2[index2++] = LL;
      indices2[index2++] = LR;
      front += 3;
      back -= 3;
    }
    front -= 3;
    back += 3;
  }
  normal2 = Cartesian3_default.fromArray(
    computedNormals,
    computedNormals.length - 3,
    normal2
  );
  addNormals(attr, normal2, left, front, back, vertexFormat);
  if (addEndPositions) {
    front += 3;
    back -= 3;
    leftPos = cartesian32;
    rightPos = cartesian42;
    const lastEndPositions = endPositions[1];
    for (i2 = 0; i2 < halfLength; i2++) {
      leftPos = Cartesian3_default.fromArray(
        lastEndPositions,
        (endPositionLength - i2 - 1) * 3,
        leftPos
      );
      rightPos = Cartesian3_default.fromArray(lastEndPositions, i2 * 3, rightPos);
      CorridorGeometryLibrary_default.addAttribute(
        finalPositions,
        leftPos,
        void 0,
        back
      );
      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
      addNormals(attr, normal2, left, front, back, vertexFormat);
      LR = front / 3;
      LL = LR - 1;
      UR = (back - 2) / 3;
      UL = UR + 1;
      indices2[index2++] = UL;
      indices2[index2++] = LL;
      indices2[index2++] = UR;
      indices2[index2++] = UR;
      indices2[index2++] = LL;
      indices2[index2++] = LR;
      front += 3;
      back -= 3;
    }
  }
  attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: finalPositions
  });
  if (vertexFormat.st) {
    const st = new Float32Array(size / 3 * 2);
    let rightSt;
    let leftSt;
    let stIndex = 0;
    if (addEndPositions) {
      leftCount /= 3;
      rightCount /= 3;
      const theta = Math.PI / (endPositionLength + 1);
      leftSt = 1 / (leftCount - endPositionLength + 1);
      rightSt = 1 / (rightCount - endPositionLength + 1);
      let a4;
      const halfEndPos = endPositionLength / 2;
      for (i2 = halfEndPos + 1; i2 < endPositionLength + 1; i2++) {
        a4 = Math_default.PI_OVER_TWO + theta * i2;
        st[stIndex++] = rightSt * (1 + Math.cos(a4));
        st[stIndex++] = 0.5 * (1 + Math.sin(a4));
      }
      for (i2 = 1; i2 < rightCount - endPositionLength + 1; i2++) {
        st[stIndex++] = i2 * rightSt;
        st[stIndex++] = 0;
      }
      for (i2 = endPositionLength; i2 > halfEndPos; i2--) {
        a4 = Math_default.PI_OVER_TWO - i2 * theta;
        st[stIndex++] = 1 - rightSt * (1 + Math.cos(a4));
        st[stIndex++] = 0.5 * (1 + Math.sin(a4));
      }
      for (i2 = halfEndPos; i2 > 0; i2--) {
        a4 = Math_default.PI_OVER_TWO - theta * i2;
        st[stIndex++] = 1 - leftSt * (1 + Math.cos(a4));
        st[stIndex++] = 0.5 * (1 + Math.sin(a4));
      }
      for (i2 = leftCount - endPositionLength; i2 > 0; i2--) {
        st[stIndex++] = i2 * leftSt;
        st[stIndex++] = 1;
      }
      for (i2 = 1; i2 < halfEndPos + 1; i2++) {
        a4 = Math_default.PI_OVER_TWO + theta * i2;
        st[stIndex++] = leftSt * (1 + Math.cos(a4));
        st[stIndex++] = 0.5 * (1 + Math.sin(a4));
      }
    } else {
      leftCount /= 3;
      rightCount /= 3;
      leftSt = 1 / (leftCount - 1);
      rightSt = 1 / (rightCount - 1);
      for (i2 = 0; i2 < rightCount; i2++) {
        st[stIndex++] = i2 * rightSt;
        st[stIndex++] = 0;
      }
      for (i2 = leftCount; i2 > 0; i2--) {
        st[stIndex++] = (i2 - 1) * leftSt;
        st[stIndex++] = 1;
      }
    }
    attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: st
    });
  }
  if (vertexFormat.normal) {
    attributes.normal = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: attr.normals
    });
  }
  if (vertexFormat.tangent) {
    attributes.tangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: attr.tangents
    });
  }
  if (vertexFormat.bitangent) {
    attributes.bitangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: attr.bitangents
    });
  }
  return {
    attributes,
    indices: indices2
  };
}
function extrudedAttributes(attributes, vertexFormat) {
  if (!vertexFormat.normal && !vertexFormat.tangent && !vertexFormat.bitangent && !vertexFormat.st) {
    return attributes;
  }
  const positions = attributes.position.values;
  let topNormals;
  let topBitangents;
  if (vertexFormat.normal || vertexFormat.bitangent) {
    topNormals = attributes.normal.values;
    topBitangents = attributes.bitangent.values;
  }
  const size = attributes.position.values.length / 18;
  const threeSize = size * 3;
  const twoSize = size * 2;
  const sixSize = threeSize * 2;
  let i2;
  if (vertexFormat.normal || vertexFormat.bitangent || vertexFormat.tangent) {
    const normals = vertexFormat.normal ? new Float32Array(threeSize * 6) : void 0;
    const tangents = vertexFormat.tangent ? new Float32Array(threeSize * 6) : void 0;
    const bitangents = vertexFormat.bitangent ? new Float32Array(threeSize * 6) : void 0;
    let topPosition = cartesian12;
    let bottomPosition = cartesian22;
    let previousPosition = cartesian32;
    let normal2 = cartesian42;
    let tangent = cartesian52;
    let bitangent = cartesian62;
    let attrIndex = sixSize;
    for (i2 = 0; i2 < threeSize; i2 += 3) {
      const attrIndexOffset = attrIndex + sixSize;
      topPosition = Cartesian3_default.fromArray(positions, i2, topPosition);
      bottomPosition = Cartesian3_default.fromArray(
        positions,
        i2 + threeSize,
        bottomPosition
      );
      previousPosition = Cartesian3_default.fromArray(
        positions,
        (i2 + 3) % threeSize,
        previousPosition
      );
      bottomPosition = Cartesian3_default.subtract(
        bottomPosition,
        topPosition,
        bottomPosition
      );
      previousPosition = Cartesian3_default.subtract(
        previousPosition,
        topPosition,
        previousPosition
      );
      normal2 = Cartesian3_default.normalize(
        Cartesian3_default.cross(bottomPosition, previousPosition, normal2),
        normal2
      );
      if (vertexFormat.normal) {
        CorridorGeometryLibrary_default.addAttribute(normals, normal2, attrIndexOffset);
        CorridorGeometryLibrary_default.addAttribute(
          normals,
          normal2,
          attrIndexOffset + 3
        );
        CorridorGeometryLibrary_default.addAttribute(normals, normal2, attrIndex);
        CorridorGeometryLibrary_default.addAttribute(normals, normal2, attrIndex + 3);
      }
      if (vertexFormat.tangent || vertexFormat.bitangent) {
        bitangent = Cartesian3_default.fromArray(topNormals, i2, bitangent);
        if (vertexFormat.bitangent) {
          CorridorGeometryLibrary_default.addAttribute(
            bitangents,
            bitangent,
            attrIndexOffset
          );
          CorridorGeometryLibrary_default.addAttribute(
            bitangents,
            bitangent,
            attrIndexOffset + 3
          );
          CorridorGeometryLibrary_default.addAttribute(
            bitangents,
            bitangent,
            attrIndex
          );
          CorridorGeometryLibrary_default.addAttribute(
            bitangents,
            bitangent,
            attrIndex + 3
          );
        }
        if (vertexFormat.tangent) {
          tangent = Cartesian3_default.normalize(
            Cartesian3_default.cross(bitangent, normal2, tangent),
            tangent
          );
          CorridorGeometryLibrary_default.addAttribute(
            tangents,
            tangent,
            attrIndexOffset
          );
          CorridorGeometryLibrary_default.addAttribute(
            tangents,
            tangent,
            attrIndexOffset + 3
          );
          CorridorGeometryLibrary_default.addAttribute(tangents, tangent, attrIndex);
          CorridorGeometryLibrary_default.addAttribute(
            tangents,
            tangent,
            attrIndex + 3
          );
        }
      }
      attrIndex += 6;
    }
    if (vertexFormat.normal) {
      normals.set(topNormals);
      for (i2 = 0; i2 < threeSize; i2 += 3) {
        normals[i2 + threeSize] = -topNormals[i2];
        normals[i2 + threeSize + 1] = -topNormals[i2 + 1];
        normals[i2 + threeSize + 2] = -topNormals[i2 + 2];
      }
      attributes.normal.values = normals;
    } else {
      attributes.normal = void 0;
    }
    if (vertexFormat.bitangent) {
      bitangents.set(topBitangents);
      bitangents.set(topBitangents, threeSize);
      attributes.bitangent.values = bitangents;
    } else {
      attributes.bitangent = void 0;
    }
    if (vertexFormat.tangent) {
      const topTangents = attributes.tangent.values;
      tangents.set(topTangents);
      tangents.set(topTangents, threeSize);
      attributes.tangent.values = tangents;
    }
  }
  if (vertexFormat.st) {
    const topSt = attributes.st.values;
    const st = new Float32Array(twoSize * 6);
    st.set(topSt);
    st.set(topSt, twoSize);
    let index2 = twoSize * 2;
    for (let j = 0; j < 2; j++) {
      st[index2++] = topSt[0];
      st[index2++] = topSt[1];
      for (i2 = 2; i2 < twoSize; i2 += 2) {
        const s2 = topSt[i2];
        const t = topSt[i2 + 1];
        st[index2++] = s2;
        st[index2++] = t;
        st[index2++] = s2;
        st[index2++] = t;
      }
      st[index2++] = topSt[0];
      st[index2++] = topSt[1];
    }
    attributes.st.values = st;
  }
  return attributes;
}
function addWallPositions(positions, index2, wallPositions) {
  wallPositions[index2++] = positions[0];
  wallPositions[index2++] = positions[1];
  wallPositions[index2++] = positions[2];
  for (let i2 = 3; i2 < positions.length; i2 += 3) {
    const x = positions[i2];
    const y = positions[i2 + 1];
    const z = positions[i2 + 2];
    wallPositions[index2++] = x;
    wallPositions[index2++] = y;
    wallPositions[index2++] = z;
    wallPositions[index2++] = x;
    wallPositions[index2++] = y;
    wallPositions[index2++] = z;
  }
  wallPositions[index2++] = positions[0];
  wallPositions[index2++] = positions[1];
  wallPositions[index2++] = positions[2];
  return wallPositions;
}
function computePositionsExtruded(params, vertexFormat) {
  const topVertexFormat = new VertexFormat_default({
    position: vertexFormat.position,
    normal: vertexFormat.normal || vertexFormat.bitangent || params.shadowVolume,
    tangent: vertexFormat.tangent,
    bitangent: vertexFormat.normal || vertexFormat.bitangent,
    st: vertexFormat.st
  });
  const ellipsoid = params.ellipsoid;
  const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
  const attr = combine2(computedPositions, topVertexFormat, ellipsoid);
  const height = params.height;
  const extrudedHeight = params.extrudedHeight;
  let attributes = attr.attributes;
  const indices2 = attr.indices;
  let positions = attributes.position.values;
  let length3 = positions.length;
  const newPositions = new Float64Array(length3 * 6);
  let extrudedPositions = new Float64Array(length3);
  extrudedPositions.set(positions);
  let wallPositions = new Float64Array(length3 * 4);
  positions = PolygonPipeline_default.scaleToGeodeticHeight(
    positions,
    height,
    ellipsoid
  );
  wallPositions = addWallPositions(positions, 0, wallPositions);
  extrudedPositions = PolygonPipeline_default.scaleToGeodeticHeight(
    extrudedPositions,
    extrudedHeight,
    ellipsoid
  );
  wallPositions = addWallPositions(
    extrudedPositions,
    length3 * 2,
    wallPositions
  );
  newPositions.set(positions);
  newPositions.set(extrudedPositions, length3);
  newPositions.set(wallPositions, length3 * 2);
  attributes.position.values = newPositions;
  attributes = extrudedAttributes(attributes, vertexFormat);
  let i2;
  const size = length3 / 3;
  if (params.shadowVolume) {
    const topNormals = attributes.normal.values;
    length3 = topNormals.length;
    let extrudeNormals = new Float32Array(length3 * 6);
    for (i2 = 0; i2 < length3; i2++) {
      topNormals[i2] = -topNormals[i2];
    }
    extrudeNormals.set(topNormals, length3);
    extrudeNormals = addWallPositions(topNormals, length3 * 4, extrudeNormals);
    attributes.extrudeDirection = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: extrudeNormals
    });
    if (!vertexFormat.normal) {
      attributes.normal = void 0;
    }
  }
  if (defined_default(params.offsetAttribute)) {
    let applyOffset = new Uint8Array(size * 6);
    if (params.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
      applyOffset = arrayFill_default(applyOffset, 1, 0, size);
      applyOffset = arrayFill_default(applyOffset, 1, size * 2, size * 4);
    } else {
      const applyOffsetValue = params.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      applyOffset = arrayFill_default(applyOffset, applyOffsetValue);
    }
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: applyOffset
    });
  }
  const iLength = indices2.length;
  const twoSize = size + size;
  const newIndices = IndexDatatype_default.createTypedArray(
    newPositions.length / 3,
    iLength * 2 + twoSize * 3
  );
  newIndices.set(indices2);
  let index2 = iLength;
  for (i2 = 0; i2 < iLength; i2 += 3) {
    const v02 = indices2[i2];
    const v13 = indices2[i2 + 1];
    const v23 = indices2[i2 + 2];
    newIndices[index2++] = v23 + size;
    newIndices[index2++] = v13 + size;
    newIndices[index2++] = v02 + size;
  }
  let UL, LL, UR, LR;
  for (i2 = 0; i2 < twoSize; i2 += 2) {
    UL = i2 + twoSize;
    LL = UL + twoSize;
    UR = UL + 1;
    LR = LL + 1;
    newIndices[index2++] = UL;
    newIndices[index2++] = LL;
    newIndices[index2++] = UR;
    newIndices[index2++] = UR;
    newIndices[index2++] = LL;
    newIndices[index2++] = LR;
  }
  return {
    attributes,
    indices: newIndices
  };
}
var scratchCartesian17 = new Cartesian3_default();
var scratchCartesian28 = new Cartesian3_default();
var scratchCartographic4 = new Cartographic_default();
function computeOffsetPoints(position1, position2, ellipsoid, halfWidth, min3, max3) {
  const direction2 = Cartesian3_default.subtract(
    position2,
    position1,
    scratchCartesian17
  );
  Cartesian3_default.normalize(direction2, direction2);
  const normal2 = ellipsoid.geodeticSurfaceNormal(position1, scratchCartesian28);
  const offsetDirection = Cartesian3_default.cross(
    direction2,
    normal2,
    scratchCartesian17
  );
  Cartesian3_default.multiplyByScalar(offsetDirection, halfWidth, offsetDirection);
  let minLat = min3.latitude;
  let minLon = min3.longitude;
  let maxLat = max3.latitude;
  let maxLon = max3.longitude;
  Cartesian3_default.add(position1, offsetDirection, scratchCartesian28);
  ellipsoid.cartesianToCartographic(scratchCartesian28, scratchCartographic4);
  let lat = scratchCartographic4.latitude;
  let lon = scratchCartographic4.longitude;
  minLat = Math.min(minLat, lat);
  minLon = Math.min(minLon, lon);
  maxLat = Math.max(maxLat, lat);
  maxLon = Math.max(maxLon, lon);
  Cartesian3_default.subtract(position1, offsetDirection, scratchCartesian28);
  ellipsoid.cartesianToCartographic(scratchCartesian28, scratchCartographic4);
  lat = scratchCartographic4.latitude;
  lon = scratchCartographic4.longitude;
  minLat = Math.min(minLat, lat);
  minLon = Math.min(minLon, lon);
  maxLat = Math.max(maxLat, lat);
  maxLon = Math.max(maxLon, lon);
  min3.latitude = minLat;
  min3.longitude = minLon;
  max3.latitude = maxLat;
  max3.longitude = maxLon;
}
var scratchCartesianOffset = new Cartesian3_default();
var scratchCartesianEnds = new Cartesian3_default();
var scratchCartographicMin = new Cartographic_default();
var scratchCartographicMax = new Cartographic_default();
function computeRectangle2(positions, ellipsoid, width, cornerType, result) {
  positions = scaleToSurface2(positions, ellipsoid);
  const cleanPositions = arrayRemoveDuplicates_default(
    positions,
    Cartesian3_default.equalsEpsilon
  );
  const length3 = cleanPositions.length;
  if (length3 < 2 || width <= 0) {
    return new Rectangle_default();
  }
  const halfWidth = width * 0.5;
  scratchCartographicMin.latitude = Number.POSITIVE_INFINITY;
  scratchCartographicMin.longitude = Number.POSITIVE_INFINITY;
  scratchCartographicMax.latitude = Number.NEGATIVE_INFINITY;
  scratchCartographicMax.longitude = Number.NEGATIVE_INFINITY;
  let lat, lon;
  if (cornerType === CornerType_default.ROUNDED) {
    const first = cleanPositions[0];
    Cartesian3_default.subtract(first, cleanPositions[1], scratchCartesianOffset);
    Cartesian3_default.normalize(scratchCartesianOffset, scratchCartesianOffset);
    Cartesian3_default.multiplyByScalar(
      scratchCartesianOffset,
      halfWidth,
      scratchCartesianOffset
    );
    Cartesian3_default.add(first, scratchCartesianOffset, scratchCartesianEnds);
    ellipsoid.cartesianToCartographic(
      scratchCartesianEnds,
      scratchCartographic4
    );
    lat = scratchCartographic4.latitude;
    lon = scratchCartographic4.longitude;
    scratchCartographicMin.latitude = Math.min(
      scratchCartographicMin.latitude,
      lat
    );
    scratchCartographicMin.longitude = Math.min(
      scratchCartographicMin.longitude,
      lon
    );
    scratchCartographicMax.latitude = Math.max(
      scratchCartographicMax.latitude,
      lat
    );
    scratchCartographicMax.longitude = Math.max(
      scratchCartographicMax.longitude,
      lon
    );
  }
  for (let i2 = 0; i2 < length3 - 1; ++i2) {
    computeOffsetPoints(
      cleanPositions[i2],
      cleanPositions[i2 + 1],
      ellipsoid,
      halfWidth,
      scratchCartographicMin,
      scratchCartographicMax
    );
  }
  const last = cleanPositions[length3 - 1];
  Cartesian3_default.subtract(last, cleanPositions[length3 - 2], scratchCartesianOffset);
  Cartesian3_default.normalize(scratchCartesianOffset, scratchCartesianOffset);
  Cartesian3_default.multiplyByScalar(
    scratchCartesianOffset,
    halfWidth,
    scratchCartesianOffset
  );
  Cartesian3_default.add(last, scratchCartesianOffset, scratchCartesianEnds);
  computeOffsetPoints(
    last,
    scratchCartesianEnds,
    ellipsoid,
    halfWidth,
    scratchCartographicMin,
    scratchCartographicMax
  );
  if (cornerType === CornerType_default.ROUNDED) {
    ellipsoid.cartesianToCartographic(
      scratchCartesianEnds,
      scratchCartographic4
    );
    lat = scratchCartographic4.latitude;
    lon = scratchCartographic4.longitude;
    scratchCartographicMin.latitude = Math.min(
      scratchCartographicMin.latitude,
      lat
    );
    scratchCartographicMin.longitude = Math.min(
      scratchCartographicMin.longitude,
      lon
    );
    scratchCartographicMax.latitude = Math.max(
      scratchCartographicMax.latitude,
      lat
    );
    scratchCartographicMax.longitude = Math.max(
      scratchCartographicMax.longitude,
      lon
    );
  }
  const rectangle = defined_default(result) ? result : new Rectangle_default();
  rectangle.north = scratchCartographicMax.latitude;
  rectangle.south = scratchCartographicMin.latitude;
  rectangle.east = scratchCartographicMax.longitude;
  rectangle.west = scratchCartographicMin.longitude;
  return rectangle;
}
function CorridorGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.positions;
  const width = options.width;
  Check_default.defined("options.positions", positions);
  Check_default.defined("options.width", width);
  const height = defaultValue_default(options.height, 0);
  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
  this._positions = positions;
  this._ellipsoid = Ellipsoid_default.clone(
    defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
  );
  this._vertexFormat = VertexFormat_default.clone(
    defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT)
  );
  this._width = width;
  this._height = Math.max(height, extrudedHeight);
  this._extrudedHeight = Math.min(height, extrudedHeight);
  this._cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
  this._granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  this._shadowVolume = defaultValue_default(options.shadowVolume, false);
  this._workerName = "createCorridorGeometry";
  this._offsetAttribute = options.offsetAttribute;
  this._rectangle = void 0;
  this.packedLength = 1 + positions.length * Cartesian3_default.packedLength + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 7;
}
CorridorGeometry.pack = function(value, array, startingIndex) {
  Check_default.defined("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const positions = value._positions;
  const length3 = positions.length;
  array[startingIndex++] = length3;
  for (let i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    Cartesian3_default.pack(positions[i2], array, startingIndex);
  }
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex++] = value._width;
  array[startingIndex++] = value._height;
  array[startingIndex++] = value._extrudedHeight;
  array[startingIndex++] = value._cornerType;
  array[startingIndex++] = value._granularity;
  array[startingIndex++] = value._shadowVolume ? 1 : 0;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchEllipsoid4 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchVertexFormat4 = new VertexFormat_default();
var scratchOptions9 = {
  positions: void 0,
  ellipsoid: scratchEllipsoid4,
  vertexFormat: scratchVertexFormat4,
  width: void 0,
  height: void 0,
  extrudedHeight: void 0,
  cornerType: void 0,
  granularity: void 0,
  shadowVolume: void 0,
  offsetAttribute: void 0
};
CorridorGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const length3 = array[startingIndex++];
  const positions = new Array(length3);
  for (let i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    positions[i2] = Cartesian3_default.unpack(array, startingIndex);
  }
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid4);
  startingIndex += Ellipsoid_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat4
  );
  startingIndex += VertexFormat_default.packedLength;
  const width = array[startingIndex++];
  const height = array[startingIndex++];
  const extrudedHeight = array[startingIndex++];
  const cornerType = array[startingIndex++];
  const granularity = array[startingIndex++];
  const shadowVolume = array[startingIndex++] === 1;
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions9.positions = positions;
    scratchOptions9.width = width;
    scratchOptions9.height = height;
    scratchOptions9.extrudedHeight = extrudedHeight;
    scratchOptions9.cornerType = cornerType;
    scratchOptions9.granularity = granularity;
    scratchOptions9.shadowVolume = shadowVolume;
    scratchOptions9.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new CorridorGeometry(scratchOptions9);
  }
  result._positions = positions;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._width = width;
  result._height = height;
  result._extrudedHeight = extrudedHeight;
  result._cornerType = cornerType;
  result._granularity = granularity;
  result._shadowVolume = shadowVolume;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
CorridorGeometry.computeRectangle = function(options, result) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.positions;
  const width = options.width;
  Check_default.defined("options.positions", positions);
  Check_default.defined("options.width", width);
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  const cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
  return computeRectangle2(positions, ellipsoid, width, cornerType, result);
};
CorridorGeometry.createGeometry = function(corridorGeometry) {
  let positions = corridorGeometry._positions;
  const width = corridorGeometry._width;
  const ellipsoid = corridorGeometry._ellipsoid;
  positions = scaleToSurface2(positions, ellipsoid);
  const cleanPositions = arrayRemoveDuplicates_default(
    positions,
    Cartesian3_default.equalsEpsilon
  );
  if (cleanPositions.length < 2 || width <= 0) {
    return;
  }
  const height = corridorGeometry._height;
  const extrudedHeight = corridorGeometry._extrudedHeight;
  const extrude = !Math_default.equalsEpsilon(
    height,
    extrudedHeight,
    0,
    Math_default.EPSILON2
  );
  const vertexFormat = corridorGeometry._vertexFormat;
  const params = {
    ellipsoid,
    positions: cleanPositions,
    width,
    cornerType: corridorGeometry._cornerType,
    granularity: corridorGeometry._granularity,
    saveAttributes: true
  };
  let attr;
  if (extrude) {
    params.height = height;
    params.extrudedHeight = extrudedHeight;
    params.shadowVolume = corridorGeometry._shadowVolume;
    params.offsetAttribute = corridorGeometry._offsetAttribute;
    attr = computePositionsExtruded(params, vertexFormat);
  } else {
    const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
    attr = combine2(computedPositions, vertexFormat, ellipsoid);
    attr.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
      attr.attributes.position.values,
      height,
      ellipsoid
    );
    if (defined_default(corridorGeometry._offsetAttribute)) {
      const applyOffsetValue = corridorGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      const length3 = attr.attributes.position.values.length;
      const applyOffset = new Uint8Array(length3 / 3);
      arrayFill_default(applyOffset, applyOffsetValue);
      attr.attributes.applyOffset = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
        componentsPerAttribute: 1,
        values: applyOffset
      });
    }
  }
  const attributes = attr.attributes;
  const boundingSphere = BoundingSphere_default.fromVertices(
    attributes.position.values,
    void 0,
    3
  );
  if (!vertexFormat.position) {
    attr.attributes.position.values = void 0;
  }
  return new Geometry_default({
    attributes,
    indices: attr.indices,
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingSphere,
    offsetAttribute: corridorGeometry._offsetAttribute
  });
};
CorridorGeometry.createShadowVolume = function(corridorGeometry, minHeightFunc, maxHeightFunc) {
  const granularity = corridorGeometry._granularity;
  const ellipsoid = corridorGeometry._ellipsoid;
  const minHeight = minHeightFunc(granularity, ellipsoid);
  const maxHeight = maxHeightFunc(granularity, ellipsoid);
  return new CorridorGeometry({
    positions: corridorGeometry._positions,
    width: corridorGeometry._width,
    cornerType: corridorGeometry._cornerType,
    ellipsoid,
    granularity,
    extrudedHeight: minHeight,
    height: maxHeight,
    vertexFormat: VertexFormat_default.POSITION_ONLY,
    shadowVolume: true
  });
};
Object.defineProperties(CorridorGeometry.prototype, {
  rectangle: {
    get: function() {
      if (!defined_default(this._rectangle)) {
        this._rectangle = computeRectangle2(
          this._positions,
          this._ellipsoid,
          this._width,
          this._cornerType
        );
      }
      return this._rectangle;
    }
  },
  textureCoordinateRotationPoints: {
    get: function() {
      return [0, 0, 0, 1, 1, 0];
    }
  }
});
var CorridorGeometry_default = CorridorGeometry;

// node_modules/cesium/Source/Core/CorridorOutlineGeometry.js
var cartesian13 = new Cartesian3_default();
var cartesian23 = new Cartesian3_default();
var cartesian33 = new Cartesian3_default();
function scaleToSurface3(positions, ellipsoid) {
  for (let i2 = 0; i2 < positions.length; i2++) {
    positions[i2] = ellipsoid.scaleToGeodeticSurface(positions[i2], positions[i2]);
  }
  return positions;
}
function combine3(computedPositions, cornerType) {
  const wallIndices = [];
  const positions = computedPositions.positions;
  const corners = computedPositions.corners;
  const endPositions = computedPositions.endPositions;
  const attributes = new GeometryAttributes_default();
  let corner;
  let leftCount = 0;
  let rightCount = 0;
  let i2;
  let indicesLength = 0;
  let length3;
  for (i2 = 0; i2 < positions.length; i2 += 2) {
    length3 = positions[i2].length - 3;
    leftCount += length3;
    indicesLength += length3 / 3 * 4;
    rightCount += positions[i2 + 1].length - 3;
  }
  leftCount += 3;
  rightCount += 3;
  for (i2 = 0; i2 < corners.length; i2++) {
    corner = corners[i2];
    const leftSide = corners[i2].leftPositions;
    if (defined_default(leftSide)) {
      length3 = leftSide.length;
      leftCount += length3;
      indicesLength += length3 / 3 * 2;
    } else {
      length3 = corners[i2].rightPositions.length;
      rightCount += length3;
      indicesLength += length3 / 3 * 2;
    }
  }
  const addEndPositions = defined_default(endPositions);
  let endPositionLength;
  if (addEndPositions) {
    endPositionLength = endPositions[0].length - 3;
    leftCount += endPositionLength;
    rightCount += endPositionLength;
    endPositionLength /= 3;
    indicesLength += endPositionLength * 4;
  }
  const size = leftCount + rightCount;
  const finalPositions = new Float64Array(size);
  let front = 0;
  let back = size - 1;
  let UL, LL, UR, LR;
  let rightPos, leftPos;
  const halfLength = endPositionLength / 2;
  const indices2 = IndexDatatype_default.createTypedArray(size / 3, indicesLength + 4);
  let index2 = 0;
  indices2[index2++] = front / 3;
  indices2[index2++] = (back - 2) / 3;
  if (addEndPositions) {
    wallIndices.push(front / 3);
    leftPos = cartesian13;
    rightPos = cartesian23;
    const firstEndPositions = endPositions[0];
    for (i2 = 0; i2 < halfLength; i2++) {
      leftPos = Cartesian3_default.fromArray(
        firstEndPositions,
        (halfLength - 1 - i2) * 3,
        leftPos
      );
      rightPos = Cartesian3_default.fromArray(
        firstEndPositions,
        (halfLength + i2) * 3,
        rightPos
      );
      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
      CorridorGeometryLibrary_default.addAttribute(
        finalPositions,
        leftPos,
        void 0,
        back
      );
      LL = front / 3;
      LR = LL + 1;
      UL = (back - 2) / 3;
      UR = UL - 1;
      indices2[index2++] = UL;
      indices2[index2++] = UR;
      indices2[index2++] = LL;
      indices2[index2++] = LR;
      front += 3;
      back -= 3;
    }
  }
  let posIndex = 0;
  let rightEdge = positions[posIndex++];
  let leftEdge = positions[posIndex++];
  finalPositions.set(rightEdge, front);
  finalPositions.set(leftEdge, back - leftEdge.length + 1);
  length3 = leftEdge.length - 3;
  wallIndices.push(front / 3, (back - 2) / 3);
  for (i2 = 0; i2 < length3; i2 += 3) {
    LL = front / 3;
    LR = LL + 1;
    UL = (back - 2) / 3;
    UR = UL - 1;
    indices2[index2++] = UL;
    indices2[index2++] = UR;
    indices2[index2++] = LL;
    indices2[index2++] = LR;
    front += 3;
    back -= 3;
  }
  for (i2 = 0; i2 < corners.length; i2++) {
    let j;
    corner = corners[i2];
    const l2 = corner.leftPositions;
    const r2 = corner.rightPositions;
    let start;
    let outsidePoint = cartesian33;
    if (defined_default(l2)) {
      back -= 3;
      start = UR;
      wallIndices.push(LR);
      for (j = 0; j < l2.length / 3; j++) {
        outsidePoint = Cartesian3_default.fromArray(l2, j * 3, outsidePoint);
        indices2[index2++] = start - j - 1;
        indices2[index2++] = start - j;
        CorridorGeometryLibrary_default.addAttribute(
          finalPositions,
          outsidePoint,
          void 0,
          back
        );
        back -= 3;
      }
      wallIndices.push(start - Math.floor(l2.length / 6));
      if (cornerType === CornerType_default.BEVELED) {
        wallIndices.push((back - 2) / 3 + 1);
      }
      front += 3;
    } else {
      front += 3;
      start = LR;
      wallIndices.push(UR);
      for (j = 0; j < r2.length / 3; j++) {
        outsidePoint = Cartesian3_default.fromArray(r2, j * 3, outsidePoint);
        indices2[index2++] = start + j;
        indices2[index2++] = start + j + 1;
        CorridorGeometryLibrary_default.addAttribute(
          finalPositions,
          outsidePoint,
          front
        );
        front += 3;
      }
      wallIndices.push(start + Math.floor(r2.length / 6));
      if (cornerType === CornerType_default.BEVELED) {
        wallIndices.push(front / 3 - 1);
      }
      back -= 3;
    }
    rightEdge = positions[posIndex++];
    leftEdge = positions[posIndex++];
    rightEdge.splice(0, 3);
    leftEdge.splice(leftEdge.length - 3, 3);
    finalPositions.set(rightEdge, front);
    finalPositions.set(leftEdge, back - leftEdge.length + 1);
    length3 = leftEdge.length - 3;
    for (j = 0; j < leftEdge.length; j += 3) {
      LR = front / 3;
      LL = LR - 1;
      UR = (back - 2) / 3;
      UL = UR + 1;
      indices2[index2++] = UL;
      indices2[index2++] = UR;
      indices2[index2++] = LL;
      indices2[index2++] = LR;
      front += 3;
      back -= 3;
    }
    front -= 3;
    back += 3;
    wallIndices.push(front / 3, (back - 2) / 3);
  }
  if (addEndPositions) {
    front += 3;
    back -= 3;
    leftPos = cartesian13;
    rightPos = cartesian23;
    const lastEndPositions = endPositions[1];
    for (i2 = 0; i2 < halfLength; i2++) {
      leftPos = Cartesian3_default.fromArray(
        lastEndPositions,
        (endPositionLength - i2 - 1) * 3,
        leftPos
      );
      rightPos = Cartesian3_default.fromArray(lastEndPositions, i2 * 3, rightPos);
      CorridorGeometryLibrary_default.addAttribute(
        finalPositions,
        leftPos,
        void 0,
        back
      );
      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
      LR = front / 3;
      LL = LR - 1;
      UR = (back - 2) / 3;
      UL = UR + 1;
      indices2[index2++] = UL;
      indices2[index2++] = UR;
      indices2[index2++] = LL;
      indices2[index2++] = LR;
      front += 3;
      back -= 3;
    }
    wallIndices.push(front / 3);
  } else {
    wallIndices.push(front / 3, (back - 2) / 3);
  }
  indices2[index2++] = front / 3;
  indices2[index2++] = (back - 2) / 3;
  attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: finalPositions
  });
  return {
    attributes,
    indices: indices2,
    wallIndices
  };
}
function computePositionsExtruded2(params) {
  const ellipsoid = params.ellipsoid;
  const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
  const attr = combine3(computedPositions, params.cornerType);
  const wallIndices = attr.wallIndices;
  const height = params.height;
  const extrudedHeight = params.extrudedHeight;
  const attributes = attr.attributes;
  const indices2 = attr.indices;
  let positions = attributes.position.values;
  let length3 = positions.length;
  let extrudedPositions = new Float64Array(length3);
  extrudedPositions.set(positions);
  const newPositions = new Float64Array(length3 * 2);
  positions = PolygonPipeline_default.scaleToGeodeticHeight(
    positions,
    height,
    ellipsoid
  );
  extrudedPositions = PolygonPipeline_default.scaleToGeodeticHeight(
    extrudedPositions,
    extrudedHeight,
    ellipsoid
  );
  newPositions.set(positions);
  newPositions.set(extrudedPositions, length3);
  attributes.position.values = newPositions;
  length3 /= 3;
  if (defined_default(params.offsetAttribute)) {
    let applyOffset = new Uint8Array(length3 * 2);
    if (params.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
      applyOffset = arrayFill_default(applyOffset, 1, 0, length3);
    } else {
      const applyOffsetValue = params.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      applyOffset = arrayFill_default(applyOffset, applyOffsetValue);
    }
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: applyOffset
    });
  }
  let i2;
  const iLength = indices2.length;
  const newIndices = IndexDatatype_default.createTypedArray(
    newPositions.length / 3,
    (iLength + wallIndices.length) * 2
  );
  newIndices.set(indices2);
  let index2 = iLength;
  for (i2 = 0; i2 < iLength; i2 += 2) {
    const v02 = indices2[i2];
    const v13 = indices2[i2 + 1];
    newIndices[index2++] = v02 + length3;
    newIndices[index2++] = v13 + length3;
  }
  let UL, LL;
  for (i2 = 0; i2 < wallIndices.length; i2++) {
    UL = wallIndices[i2];
    LL = UL + length3;
    newIndices[index2++] = UL;
    newIndices[index2++] = LL;
  }
  return {
    attributes,
    indices: newIndices
  };
}
function CorridorOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.positions;
  const width = options.width;
  Check_default.typeOf.object("options.positions", positions);
  Check_default.typeOf.number("options.width", width);
  const height = defaultValue_default(options.height, 0);
  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
  this._positions = positions;
  this._ellipsoid = Ellipsoid_default.clone(
    defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
  );
  this._width = width;
  this._height = Math.max(height, extrudedHeight);
  this._extrudedHeight = Math.min(height, extrudedHeight);
  this._cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
  this._granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createCorridorOutlineGeometry";
  this.packedLength = 1 + positions.length * Cartesian3_default.packedLength + Ellipsoid_default.packedLength + 6;
}
CorridorOutlineGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.typeOf.object("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const positions = value._positions;
  const length3 = positions.length;
  array[startingIndex++] = length3;
  for (let i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    Cartesian3_default.pack(positions[i2], array, startingIndex);
  }
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  array[startingIndex++] = value._width;
  array[startingIndex++] = value._height;
  array[startingIndex++] = value._extrudedHeight;
  array[startingIndex++] = value._cornerType;
  array[startingIndex++] = value._granularity;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchEllipsoid5 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchOptions10 = {
  positions: void 0,
  ellipsoid: scratchEllipsoid5,
  width: void 0,
  height: void 0,
  extrudedHeight: void 0,
  cornerType: void 0,
  granularity: void 0,
  offsetAttribute: void 0
};
CorridorOutlineGeometry.unpack = function(array, startingIndex, result) {
  Check_default.typeOf.object("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const length3 = array[startingIndex++];
  const positions = new Array(length3);
  for (let i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    positions[i2] = Cartesian3_default.unpack(array, startingIndex);
  }
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid5);
  startingIndex += Ellipsoid_default.packedLength;
  const width = array[startingIndex++];
  const height = array[startingIndex++];
  const extrudedHeight = array[startingIndex++];
  const cornerType = array[startingIndex++];
  const granularity = array[startingIndex++];
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions10.positions = positions;
    scratchOptions10.width = width;
    scratchOptions10.height = height;
    scratchOptions10.extrudedHeight = extrudedHeight;
    scratchOptions10.cornerType = cornerType;
    scratchOptions10.granularity = granularity;
    scratchOptions10.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new CorridorOutlineGeometry(scratchOptions10);
  }
  result._positions = positions;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._width = width;
  result._height = height;
  result._extrudedHeight = extrudedHeight;
  result._cornerType = cornerType;
  result._granularity = granularity;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
CorridorOutlineGeometry.createGeometry = function(corridorOutlineGeometry) {
  let positions = corridorOutlineGeometry._positions;
  const width = corridorOutlineGeometry._width;
  const ellipsoid = corridorOutlineGeometry._ellipsoid;
  positions = scaleToSurface3(positions, ellipsoid);
  const cleanPositions = arrayRemoveDuplicates_default(
    positions,
    Cartesian3_default.equalsEpsilon
  );
  if (cleanPositions.length < 2 || width <= 0) {
    return;
  }
  const height = corridorOutlineGeometry._height;
  const extrudedHeight = corridorOutlineGeometry._extrudedHeight;
  const extrude = !Math_default.equalsEpsilon(
    height,
    extrudedHeight,
    0,
    Math_default.EPSILON2
  );
  const params = {
    ellipsoid,
    positions: cleanPositions,
    width,
    cornerType: corridorOutlineGeometry._cornerType,
    granularity: corridorOutlineGeometry._granularity,
    saveAttributes: false
  };
  let attr;
  if (extrude) {
    params.height = height;
    params.extrudedHeight = extrudedHeight;
    params.offsetAttribute = corridorOutlineGeometry._offsetAttribute;
    attr = computePositionsExtruded2(params);
  } else {
    const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
    attr = combine3(computedPositions, params.cornerType);
    attr.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
      attr.attributes.position.values,
      height,
      ellipsoid
    );
    if (defined_default(corridorOutlineGeometry._offsetAttribute)) {
      const length3 = attr.attributes.position.values.length;
      const applyOffset = new Uint8Array(length3 / 3);
      const offsetValue = corridorOutlineGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      arrayFill_default(applyOffset, offsetValue);
      attr.attributes.applyOffset = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
        componentsPerAttribute: 1,
        values: applyOffset
      });
    }
  }
  const attributes = attr.attributes;
  const boundingSphere = BoundingSphere_default.fromVertices(
    attributes.position.values,
    void 0,
    3
  );
  return new Geometry_default({
    attributes,
    indices: attr.indices,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere,
    offsetAttribute: corridorOutlineGeometry._offsetAttribute
  });
};
var CorridorOutlineGeometry_default = CorridorOutlineGeometry;

// node_modules/cesium/Source/Core/CullingVolume.js
function CullingVolume(planes) {
  this.planes = defaultValue_default(planes, []);
}
var faces = [new Cartesian3_default(), new Cartesian3_default(), new Cartesian3_default()];
Cartesian3_default.clone(Cartesian3_default.UNIT_X, faces[0]);
Cartesian3_default.clone(Cartesian3_default.UNIT_Y, faces[1]);
Cartesian3_default.clone(Cartesian3_default.UNIT_Z, faces[2]);
var scratchPlaneCenter = new Cartesian3_default();
var scratchPlaneNormal2 = new Cartesian3_default();
var scratchPlane2 = new Plane_default(new Cartesian3_default(1, 0, 0), 0);
CullingVolume.fromBoundingSphere = function(boundingSphere, result) {
  if (!defined_default(boundingSphere)) {
    throw new DeveloperError_default("boundingSphere is required.");
  }
  if (!defined_default(result)) {
    result = new CullingVolume();
  }
  const length3 = faces.length;
  const planes = result.planes;
  planes.length = 2 * length3;
  const center = boundingSphere.center;
  const radius = boundingSphere.radius;
  let planeIndex = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const faceNormal = faces[i2];
    let plane0 = planes[planeIndex];
    let plane1 = planes[planeIndex + 1];
    if (!defined_default(plane0)) {
      plane0 = planes[planeIndex] = new Cartesian4_default();
    }
    if (!defined_default(plane1)) {
      plane1 = planes[planeIndex + 1] = new Cartesian4_default();
    }
    Cartesian3_default.multiplyByScalar(faceNormal, -radius, scratchPlaneCenter);
    Cartesian3_default.add(center, scratchPlaneCenter, scratchPlaneCenter);
    plane0.x = faceNormal.x;
    plane0.y = faceNormal.y;
    plane0.z = faceNormal.z;
    plane0.w = -Cartesian3_default.dot(faceNormal, scratchPlaneCenter);
    Cartesian3_default.multiplyByScalar(faceNormal, radius, scratchPlaneCenter);
    Cartesian3_default.add(center, scratchPlaneCenter, scratchPlaneCenter);
    plane1.x = -faceNormal.x;
    plane1.y = -faceNormal.y;
    plane1.z = -faceNormal.z;
    plane1.w = -Cartesian3_default.dot(
      Cartesian3_default.negate(faceNormal, scratchPlaneNormal2),
      scratchPlaneCenter
    );
    planeIndex += 2;
  }
  return result;
};
CullingVolume.prototype.computeVisibility = function(boundingVolume) {
  if (!defined_default(boundingVolume)) {
    throw new DeveloperError_default("boundingVolume is required.");
  }
  const planes = this.planes;
  let intersecting = false;
  for (let k = 0, len = planes.length; k < len; ++k) {
    const result = boundingVolume.intersectPlane(
      Plane_default.fromCartesian4(planes[k], scratchPlane2)
    );
    if (result === Intersect_default.OUTSIDE) {
      return Intersect_default.OUTSIDE;
    } else if (result === Intersect_default.INTERSECTING) {
      intersecting = true;
    }
  }
  return intersecting ? Intersect_default.INTERSECTING : Intersect_default.INSIDE;
};
CullingVolume.prototype.computeVisibilityWithPlaneMask = function(boundingVolume, parentPlaneMask) {
  if (!defined_default(boundingVolume)) {
    throw new DeveloperError_default("boundingVolume is required.");
  }
  if (!defined_default(parentPlaneMask)) {
    throw new DeveloperError_default("parentPlaneMask is required.");
  }
  if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
    return parentPlaneMask;
  }
  let mask = CullingVolume.MASK_INSIDE;
  const planes = this.planes;
  for (let k = 0, len = planes.length; k < len; ++k) {
    const flag = k < 31 ? 1 << k : 0;
    if (k < 31 && (parentPlaneMask & flag) === 0) {
      continue;
    }
    const result = boundingVolume.intersectPlane(
      Plane_default.fromCartesian4(planes[k], scratchPlane2)
    );
    if (result === Intersect_default.OUTSIDE) {
      return CullingVolume.MASK_OUTSIDE;
    } else if (result === Intersect_default.INTERSECTING) {
      mask |= flag;
    }
  }
  return mask;
};
CullingVolume.MASK_OUTSIDE = 4294967295;
CullingVolume.MASK_INSIDE = 0;
CullingVolume.MASK_INDETERMINATE = 2147483647;
var CullingVolume_default = CullingVolume;

// node_modules/cesium/Source/Core/CustomHeightmapTerrainProvider.js
function CustomHeightmapTerrainProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.callback", options.callback);
  Check_default.defined("options.width", options.width);
  Check_default.defined("options.height", options.height);
  this._callback = options.callback;
  this._tilingScheme = options.tilingScheme;
  if (!defined_default(this._tilingScheme)) {
    this._tilingScheme = new GeographicTilingScheme_default({
      ellipsoid: defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
    });
  }
  this._width = options.width;
  this._height = options.height;
  const maxTileDimensions = Math.max(this._width, this._height);
  this._levelZeroMaximumGeometricError = TerrainProvider_default.getEstimatedLevelZeroGeometricErrorForAHeightmap(
    this._tilingScheme.ellipsoid,
    maxTileDimensions,
    this._tilingScheme.getNumberOfXTilesAtLevel(0)
  );
  this._errorEvent = new Event_default();
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  this._credit = credit;
  this._readyPromise = Promise.resolve(true);
}
Object.defineProperties(CustomHeightmapTerrainProvider.prototype, {
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  tilingScheme: {
    get: function() {
      return this._tilingScheme;
    }
  },
  ready: {
    get: function() {
      return true;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  hasWaterMask: {
    get: function() {
      return false;
    }
  },
  hasVertexNormals: {
    get: function() {
      return false;
    }
  },
  width: {
    get: function() {
      return this._width;
    }
  },
  height: {
    get: function() {
      return this._height;
    }
  }
});
CustomHeightmapTerrainProvider.prototype.requestTileGeometry = function(x, y, level, request) {
  const promise = this._callback(x, y, level);
  if (!defined_default(promise)) {
    return void 0;
  }
  const width = this._width;
  const height = this._height;
  return Promise.resolve(promise).then(function(heightmapData) {
    let buffer = heightmapData;
    if (Array.isArray(buffer)) {
      buffer = new Float64Array(buffer);
    }
    return new HeightmapTerrainData_default({
      buffer,
      width,
      height
    });
  });
};
CustomHeightmapTerrainProvider.prototype.getLevelMaximumGeometricError = function(level) {
  return this._levelZeroMaximumGeometricError / (1 << level);
};
CustomHeightmapTerrainProvider.prototype.getTileDataAvailable = function(x, y, level) {
  return void 0;
};
CustomHeightmapTerrainProvider.prototype.loadTileDataAvailability = function(x, y, level) {
  return void 0;
};
var CustomHeightmapTerrainProvider_default = CustomHeightmapTerrainProvider;

// node_modules/cesium/Source/Core/CylinderGeometryLibrary.js
var CylinderGeometryLibrary = {};
CylinderGeometryLibrary.computePositions = function(length3, topRadius, bottomRadius, slices, fill) {
  const topZ = length3 * 0.5;
  const bottomZ = -topZ;
  const twoSlice = slices + slices;
  const size = fill ? 2 * twoSlice : twoSlice;
  const positions = new Float64Array(size * 3);
  let i2;
  let index2 = 0;
  let tbIndex = 0;
  const bottomOffset = fill ? twoSlice * 3 : 0;
  const topOffset = fill ? (twoSlice + slices) * 3 : slices * 3;
  for (i2 = 0; i2 < slices; i2++) {
    const angle = i2 / slices * Math_default.TWO_PI;
    const x = Math.cos(angle);
    const y = Math.sin(angle);
    const bottomX = x * bottomRadius;
    const bottomY = y * bottomRadius;
    const topX = x * topRadius;
    const topY = y * topRadius;
    positions[tbIndex + bottomOffset] = bottomX;
    positions[tbIndex + bottomOffset + 1] = bottomY;
    positions[tbIndex + bottomOffset + 2] = bottomZ;
    positions[tbIndex + topOffset] = topX;
    positions[tbIndex + topOffset + 1] = topY;
    positions[tbIndex + topOffset + 2] = topZ;
    tbIndex += 3;
    if (fill) {
      positions[index2++] = bottomX;
      positions[index2++] = bottomY;
      positions[index2++] = bottomZ;
      positions[index2++] = topX;
      positions[index2++] = topY;
      positions[index2++] = topZ;
    }
  }
  return positions;
};
var CylinderGeometryLibrary_default = CylinderGeometryLibrary;

// node_modules/cesium/Source/Core/CylinderGeometry.js
var radiusScratch = new Cartesian2_default();
var normalScratch3 = new Cartesian3_default();
var bitangentScratch = new Cartesian3_default();
var tangentScratch = new Cartesian3_default();
var positionScratch2 = new Cartesian3_default();
function CylinderGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const length3 = options.length;
  const topRadius = options.topRadius;
  const bottomRadius = options.bottomRadius;
  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
  const slices = defaultValue_default(options.slices, 128);
  if (!defined_default(length3)) {
    throw new DeveloperError_default("options.length must be defined.");
  }
  if (!defined_default(topRadius)) {
    throw new DeveloperError_default("options.topRadius must be defined.");
  }
  if (!defined_default(bottomRadius)) {
    throw new DeveloperError_default("options.bottomRadius must be defined.");
  }
  if (slices < 3) {
    throw new DeveloperError_default(
      "options.slices must be greater than or equal to 3."
    );
  }
  if (defined_default(options.offsetAttribute) && options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
    throw new DeveloperError_default(
      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
    );
  }
  this._length = length3;
  this._topRadius = topRadius;
  this._bottomRadius = bottomRadius;
  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
  this._slices = slices;
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createCylinderGeometry";
}
CylinderGeometry.packedLength = VertexFormat_default.packedLength + 5;
CylinderGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex++] = value._length;
  array[startingIndex++] = value._topRadius;
  array[startingIndex++] = value._bottomRadius;
  array[startingIndex++] = value._slices;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchVertexFormat5 = new VertexFormat_default();
var scratchOptions11 = {
  vertexFormat: scratchVertexFormat5,
  length: void 0,
  topRadius: void 0,
  bottomRadius: void 0,
  slices: void 0,
  offsetAttribute: void 0
};
CylinderGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat5
  );
  startingIndex += VertexFormat_default.packedLength;
  const length3 = array[startingIndex++];
  const topRadius = array[startingIndex++];
  const bottomRadius = array[startingIndex++];
  const slices = array[startingIndex++];
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions11.length = length3;
    scratchOptions11.topRadius = topRadius;
    scratchOptions11.bottomRadius = bottomRadius;
    scratchOptions11.slices = slices;
    scratchOptions11.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new CylinderGeometry(scratchOptions11);
  }
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._length = length3;
  result._topRadius = topRadius;
  result._bottomRadius = bottomRadius;
  result._slices = slices;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
CylinderGeometry.createGeometry = function(cylinderGeometry) {
  let length3 = cylinderGeometry._length;
  const topRadius = cylinderGeometry._topRadius;
  const bottomRadius = cylinderGeometry._bottomRadius;
  const vertexFormat = cylinderGeometry._vertexFormat;
  const slices = cylinderGeometry._slices;
  if (length3 <= 0 || topRadius < 0 || bottomRadius < 0 || topRadius === 0 && bottomRadius === 0) {
    return;
  }
  const twoSlices = slices + slices;
  const threeSlices = slices + twoSlices;
  const numVertices = twoSlices + twoSlices;
  const positions = CylinderGeometryLibrary_default.computePositions(
    length3,
    topRadius,
    bottomRadius,
    slices,
    true
  );
  const st = vertexFormat.st ? new Float32Array(numVertices * 2) : void 0;
  const normals = vertexFormat.normal ? new Float32Array(numVertices * 3) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(numVertices * 3) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(numVertices * 3) : void 0;
  let i2;
  const computeNormal = vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent;
  if (computeNormal) {
    const computeTangent = vertexFormat.tangent || vertexFormat.bitangent;
    let normalIndex = 0;
    let tangentIndex = 0;
    let bitangentIndex = 0;
    const theta = Math.atan2(bottomRadius - topRadius, length3);
    const normal2 = normalScratch3;
    normal2.z = Math.sin(theta);
    const normalScale2 = Math.cos(theta);
    let tangent = tangentScratch;
    let bitangent = bitangentScratch;
    for (i2 = 0; i2 < slices; i2++) {
      const angle = i2 / slices * Math_default.TWO_PI;
      const x = normalScale2 * Math.cos(angle);
      const y = normalScale2 * Math.sin(angle);
      if (computeNormal) {
        normal2.x = x;
        normal2.y = y;
        if (computeTangent) {
          tangent = Cartesian3_default.normalize(
            Cartesian3_default.cross(Cartesian3_default.UNIT_Z, normal2, tangent),
            tangent
          );
        }
        if (vertexFormat.normal) {
          normals[normalIndex++] = normal2.x;
          normals[normalIndex++] = normal2.y;
          normals[normalIndex++] = normal2.z;
          normals[normalIndex++] = normal2.x;
          normals[normalIndex++] = normal2.y;
          normals[normalIndex++] = normal2.z;
        }
        if (vertexFormat.tangent) {
          tangents[tangentIndex++] = tangent.x;
          tangents[tangentIndex++] = tangent.y;
          tangents[tangentIndex++] = tangent.z;
          tangents[tangentIndex++] = tangent.x;
          tangents[tangentIndex++] = tangent.y;
          tangents[tangentIndex++] = tangent.z;
        }
        if (vertexFormat.bitangent) {
          bitangent = Cartesian3_default.normalize(
            Cartesian3_default.cross(normal2, tangent, bitangent),
            bitangent
          );
          bitangents[bitangentIndex++] = bitangent.x;
          bitangents[bitangentIndex++] = bitangent.y;
          bitangents[bitangentIndex++] = bitangent.z;
          bitangents[bitangentIndex++] = bitangent.x;
          bitangents[bitangentIndex++] = bitangent.y;
          bitangents[bitangentIndex++] = bitangent.z;
        }
      }
    }
    for (i2 = 0; i2 < slices; i2++) {
      if (vertexFormat.normal) {
        normals[normalIndex++] = 0;
        normals[normalIndex++] = 0;
        normals[normalIndex++] = -1;
      }
      if (vertexFormat.tangent) {
        tangents[tangentIndex++] = 1;
        tangents[tangentIndex++] = 0;
        tangents[tangentIndex++] = 0;
      }
      if (vertexFormat.bitangent) {
        bitangents[bitangentIndex++] = 0;
        bitangents[bitangentIndex++] = -1;
        bitangents[bitangentIndex++] = 0;
      }
    }
    for (i2 = 0; i2 < slices; i2++) {
      if (vertexFormat.normal) {
        normals[normalIndex++] = 0;
        normals[normalIndex++] = 0;
        normals[normalIndex++] = 1;
      }
      if (vertexFormat.tangent) {
        tangents[tangentIndex++] = 1;
        tangents[tangentIndex++] = 0;
        tangents[tangentIndex++] = 0;
      }
      if (vertexFormat.bitangent) {
        bitangents[bitangentIndex++] = 0;
        bitangents[bitangentIndex++] = 1;
        bitangents[bitangentIndex++] = 0;
      }
    }
  }
  const numIndices = 12 * slices - 12;
  const indices2 = IndexDatatype_default.createTypedArray(numVertices, numIndices);
  let index2 = 0;
  let j = 0;
  for (i2 = 0; i2 < slices - 1; i2++) {
    indices2[index2++] = j;
    indices2[index2++] = j + 2;
    indices2[index2++] = j + 3;
    indices2[index2++] = j;
    indices2[index2++] = j + 3;
    indices2[index2++] = j + 1;
    j += 2;
  }
  indices2[index2++] = twoSlices - 2;
  indices2[index2++] = 0;
  indices2[index2++] = 1;
  indices2[index2++] = twoSlices - 2;
  indices2[index2++] = 1;
  indices2[index2++] = twoSlices - 1;
  for (i2 = 1; i2 < slices - 1; i2++) {
    indices2[index2++] = twoSlices + i2 + 1;
    indices2[index2++] = twoSlices + i2;
    indices2[index2++] = twoSlices;
  }
  for (i2 = 1; i2 < slices - 1; i2++) {
    indices2[index2++] = threeSlices;
    indices2[index2++] = threeSlices + i2;
    indices2[index2++] = threeSlices + i2 + 1;
  }
  let textureCoordIndex = 0;
  if (vertexFormat.st) {
    const rad = Math.max(topRadius, bottomRadius);
    for (i2 = 0; i2 < numVertices; i2++) {
      const position = Cartesian3_default.fromArray(positions, i2 * 3, positionScratch2);
      st[textureCoordIndex++] = (position.x + rad) / (2 * rad);
      st[textureCoordIndex++] = (position.y + rad) / (2 * rad);
    }
  }
  const attributes = new GeometryAttributes_default();
  if (vertexFormat.position) {
    attributes.position = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: positions
    });
  }
  if (vertexFormat.normal) {
    attributes.normal = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: normals
    });
  }
  if (vertexFormat.tangent) {
    attributes.tangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: tangents
    });
  }
  if (vertexFormat.bitangent) {
    attributes.bitangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: bitangents
    });
  }
  if (vertexFormat.st) {
    attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: st
    });
  }
  radiusScratch.x = length3 * 0.5;
  radiusScratch.y = Math.max(bottomRadius, topRadius);
  const boundingSphere = new BoundingSphere_default(
    Cartesian3_default.ZERO,
    Cartesian2_default.magnitude(radiusScratch)
  );
  if (defined_default(cylinderGeometry._offsetAttribute)) {
    length3 = positions.length;
    const applyOffset = new Uint8Array(length3 / 3);
    const offsetValue = cylinderGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
    arrayFill_default(applyOffset, offsetValue);
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: applyOffset
    });
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingSphere,
    offsetAttribute: cylinderGeometry._offsetAttribute
  });
};
var unitCylinderGeometry;
CylinderGeometry.getUnitCylinder = function() {
  if (!defined_default(unitCylinderGeometry)) {
    unitCylinderGeometry = CylinderGeometry.createGeometry(
      new CylinderGeometry({
        topRadius: 1,
        bottomRadius: 1,
        length: 1,
        vertexFormat: VertexFormat_default.POSITION_ONLY
      })
    );
  }
  return unitCylinderGeometry;
};
var CylinderGeometry_default = CylinderGeometry;

// node_modules/cesium/Source/Core/CylinderOutlineGeometry.js
var radiusScratch2 = new Cartesian2_default();
function CylinderOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const length3 = options.length;
  const topRadius = options.topRadius;
  const bottomRadius = options.bottomRadius;
  const slices = defaultValue_default(options.slices, 128);
  const numberOfVerticalLines = Math.max(
    defaultValue_default(options.numberOfVerticalLines, 16),
    0
  );
  Check_default.typeOf.number("options.positions", length3);
  Check_default.typeOf.number("options.topRadius", topRadius);
  Check_default.typeOf.number("options.bottomRadius", bottomRadius);
  Check_default.typeOf.number.greaterThanOrEquals("options.slices", slices, 3);
  if (defined_default(options.offsetAttribute) && options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
    throw new DeveloperError_default(
      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
    );
  }
  this._length = length3;
  this._topRadius = topRadius;
  this._bottomRadius = bottomRadius;
  this._slices = slices;
  this._numberOfVerticalLines = numberOfVerticalLines;
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createCylinderOutlineGeometry";
}
CylinderOutlineGeometry.packedLength = 6;
CylinderOutlineGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value._length;
  array[startingIndex++] = value._topRadius;
  array[startingIndex++] = value._bottomRadius;
  array[startingIndex++] = value._slices;
  array[startingIndex++] = value._numberOfVerticalLines;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchOptions12 = {
  length: void 0,
  topRadius: void 0,
  bottomRadius: void 0,
  slices: void 0,
  numberOfVerticalLines: void 0,
  offsetAttribute: void 0
};
CylinderOutlineGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const length3 = array[startingIndex++];
  const topRadius = array[startingIndex++];
  const bottomRadius = array[startingIndex++];
  const slices = array[startingIndex++];
  const numberOfVerticalLines = array[startingIndex++];
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions12.length = length3;
    scratchOptions12.topRadius = topRadius;
    scratchOptions12.bottomRadius = bottomRadius;
    scratchOptions12.slices = slices;
    scratchOptions12.numberOfVerticalLines = numberOfVerticalLines;
    scratchOptions12.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new CylinderOutlineGeometry(scratchOptions12);
  }
  result._length = length3;
  result._topRadius = topRadius;
  result._bottomRadius = bottomRadius;
  result._slices = slices;
  result._numberOfVerticalLines = numberOfVerticalLines;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
CylinderOutlineGeometry.createGeometry = function(cylinderGeometry) {
  let length3 = cylinderGeometry._length;
  const topRadius = cylinderGeometry._topRadius;
  const bottomRadius = cylinderGeometry._bottomRadius;
  const slices = cylinderGeometry._slices;
  const numberOfVerticalLines = cylinderGeometry._numberOfVerticalLines;
  if (length3 <= 0 || topRadius < 0 || bottomRadius < 0 || topRadius === 0 && bottomRadius === 0) {
    return;
  }
  const numVertices = slices * 2;
  const positions = CylinderGeometryLibrary_default.computePositions(
    length3,
    topRadius,
    bottomRadius,
    slices,
    false
  );
  let numIndices = slices * 2;
  let numSide;
  if (numberOfVerticalLines > 0) {
    const numSideLines = Math.min(numberOfVerticalLines, slices);
    numSide = Math.round(slices / numSideLines);
    numIndices += numSideLines;
  }
  const indices2 = IndexDatatype_default.createTypedArray(numVertices, numIndices * 2);
  let index2 = 0;
  let i2;
  for (i2 = 0; i2 < slices - 1; i2++) {
    indices2[index2++] = i2;
    indices2[index2++] = i2 + 1;
    indices2[index2++] = i2 + slices;
    indices2[index2++] = i2 + 1 + slices;
  }
  indices2[index2++] = slices - 1;
  indices2[index2++] = 0;
  indices2[index2++] = slices + slices - 1;
  indices2[index2++] = slices;
  if (numberOfVerticalLines > 0) {
    for (i2 = 0; i2 < slices; i2 += numSide) {
      indices2[index2++] = i2;
      indices2[index2++] = i2 + slices;
    }
  }
  const attributes = new GeometryAttributes_default();
  attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: positions
  });
  radiusScratch2.x = length3 * 0.5;
  radiusScratch2.y = Math.max(bottomRadius, topRadius);
  const boundingSphere = new BoundingSphere_default(
    Cartesian3_default.ZERO,
    Cartesian2_default.magnitude(radiusScratch2)
  );
  if (defined_default(cylinderGeometry._offsetAttribute)) {
    length3 = positions.length;
    const applyOffset = new Uint8Array(length3 / 3);
    const offsetValue = cylinderGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
    arrayFill_default(applyOffset, offsetValue);
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: applyOffset
    });
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere,
    offsetAttribute: cylinderGeometry._offsetAttribute
  });
};
var CylinderOutlineGeometry_default = CylinderOutlineGeometry;

// node_modules/cesium/Source/Core/DefaultProxy.js
function DefaultProxy(proxy) {
  this.proxy = proxy;
}
DefaultProxy.prototype.getURL = function(resource) {
  const prefix = this.proxy.indexOf("?") === -1 ? "?" : "";
  return this.proxy + prefix + encodeURIComponent(resource);
};
var DefaultProxy_default = DefaultProxy;

// node_modules/cesium/Source/Core/DistanceDisplayCondition.js
function DistanceDisplayCondition(near, far) {
  near = defaultValue_default(near, 0);
  this._near = near;
  far = defaultValue_default(far, Number.MAX_VALUE);
  this._far = far;
}
Object.defineProperties(DistanceDisplayCondition.prototype, {
  near: {
    get: function() {
      return this._near;
    },
    set: function(value) {
      this._near = value;
    }
  },
  far: {
    get: function() {
      return this._far;
    },
    set: function(value) {
      this._far = value;
    }
  }
});
DistanceDisplayCondition.packedLength = 2;
DistanceDisplayCondition.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.near;
  array[startingIndex] = value.far;
  return array;
};
DistanceDisplayCondition.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new DistanceDisplayCondition();
  }
  result.near = array[startingIndex++];
  result.far = array[startingIndex];
  return result;
};
DistanceDisplayCondition.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.near === right.near && left.far === right.far;
};
DistanceDisplayCondition.clone = function(value, result) {
  if (!defined_default(value)) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new DistanceDisplayCondition();
  }
  result.near = value.near;
  result.far = value.far;
  return result;
};
DistanceDisplayCondition.prototype.clone = function(result) {
  return DistanceDisplayCondition.clone(this, result);
};
DistanceDisplayCondition.prototype.equals = function(other) {
  return DistanceDisplayCondition.equals(this, other);
};
var DistanceDisplayCondition_default = DistanceDisplayCondition;

// node_modules/cesium/Source/Core/DistanceDisplayConditionGeometryInstanceAttribute.js
function DistanceDisplayConditionGeometryInstanceAttribute(near, far) {
  near = defaultValue_default(near, 0);
  far = defaultValue_default(far, Number.MAX_VALUE);
  if (far <= near) {
    throw new DeveloperError_default(
      "far distance must be greater than near distance."
    );
  }
  this.value = new Float32Array([near, far]);
}
Object.defineProperties(
  DistanceDisplayConditionGeometryInstanceAttribute.prototype,
  {
    componentDatatype: {
      get: function() {
        return ComponentDatatype_default.FLOAT;
      }
    },
    componentsPerAttribute: {
      get: function() {
        return 2;
      }
    },
    normalize: {
      get: function() {
        return false;
      }
    }
  }
);
DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition = function(distanceDisplayCondition) {
  if (!defined_default(distanceDisplayCondition)) {
    throw new DeveloperError_default("distanceDisplayCondition is required.");
  }
  if (distanceDisplayCondition.far <= distanceDisplayCondition.near) {
    throw new DeveloperError_default(
      "distanceDisplayCondition.far distance must be greater than distanceDisplayCondition.near distance."
    );
  }
  return new DistanceDisplayConditionGeometryInstanceAttribute(
    distanceDisplayCondition.near,
    distanceDisplayCondition.far
  );
};
DistanceDisplayConditionGeometryInstanceAttribute.toValue = function(distanceDisplayCondition, result) {
  if (!defined_default(distanceDisplayCondition)) {
    throw new DeveloperError_default("distanceDisplayCondition is required.");
  }
  if (!defined_default(result)) {
    return new Float32Array([
      distanceDisplayCondition.near,
      distanceDisplayCondition.far
    ]);
  }
  result[0] = distanceDisplayCondition.near;
  result[1] = distanceDisplayCondition.far;
  return result;
};
var DistanceDisplayConditionGeometryInstanceAttribute_default = DistanceDisplayConditionGeometryInstanceAttribute;

// node_modules/cesium/Source/Core/DoubleEndedPriorityQueue.js
function DoubleEndedPriorityQueue(options) {
  Check_default.typeOf.object("options", options);
  Check_default.defined("options.comparator", options.comparator);
  if (defined_default(options.maximumLength)) {
    Check_default.typeOf.number.greaterThanOrEquals(
      "options.maximumLength",
      options.maximumLength,
      0
    );
  }
  this._comparator = options.comparator;
  this._maximumLength = options.maximumLength;
  this._array = defined_default(options.maximumLength) ? new Array(options.maximumLength) : [];
  this._length = 0;
}
Object.defineProperties(DoubleEndedPriorityQueue.prototype, {
  length: {
    get: function() {
      return this._length;
    }
  },
  maximumLength: {
    get: function() {
      return this._maximumLength;
    },
    set: function(value) {
      if (defined_default(value)) {
        Check_default.typeOf.number.greaterThanOrEquals("maximumLength", value, 0);
        while (this._length > value) {
          this.removeMinimum();
        }
        this._array.length = value;
      }
      this._maximumLength = value;
    }
  },
  internalArray: {
    get: function() {
      return this._array;
    }
  },
  comparator: {
    get: function() {
      return this._comparator;
    }
  }
});
DoubleEndedPriorityQueue.prototype.clone = function() {
  const maximumLength = this._maximumLength;
  const comparator = this._comparator;
  const array = this._array;
  const length3 = this._length;
  const result = new DoubleEndedPriorityQueue({
    comparator,
    maximumLength
  });
  result._length = length3;
  for (let i2 = 0; i2 < length3; i2++) {
    result._array[i2] = array[i2];
  }
  return result;
};
DoubleEndedPriorityQueue.prototype.reset = function() {
  this._length = 0;
  const maximumLength = this._maximumLength;
  if (defined_default(maximumLength)) {
    for (let i2 = 0; i2 < maximumLength; i2++) {
      this._array[i2] = void 0;
    }
  } else {
    this._array.length = 0;
  }
};
DoubleEndedPriorityQueue.prototype.resort = function() {
  const length3 = this._length;
  for (let i2 = 0; i2 < length3; i2++) {
    pushUp(this, i2);
  }
};
DoubleEndedPriorityQueue.prototype.insert = function(element) {
  let removedElement;
  const maximumLength = this._maximumLength;
  if (defined_default(maximumLength)) {
    if (maximumLength === 0) {
      return void 0;
    } else if (this._length === maximumLength) {
      const minimumElement = this._array[0];
      if (this._comparator(element, minimumElement) <= 0) {
        return element;
      }
      removedElement = this.removeMinimum();
    }
  }
  const index2 = this._length;
  this._array[index2] = element;
  this._length++;
  pushUp(this, index2);
  return removedElement;
};
DoubleEndedPriorityQueue.prototype.removeMinimum = function() {
  const length3 = this._length;
  if (length3 === 0) {
    return void 0;
  }
  this._length--;
  const minimumElement = this._array[0];
  if (length3 >= 2) {
    this._array[0] = this._array[length3 - 1];
    pushDown(this, 0);
  }
  this._array[length3 - 1] = void 0;
  return minimumElement;
};
DoubleEndedPriorityQueue.prototype.removeMaximum = function() {
  const length3 = this._length;
  if (length3 === 0) {
    return void 0;
  }
  this._length--;
  let maximumElement;
  if (length3 <= 2) {
    maximumElement = this._array[length3 - 1];
  } else {
    const maximumElementIndex = greaterThan(this, 1, 2) ? 1 : 2;
    maximumElement = this._array[maximumElementIndex];
    this._array[maximumElementIndex] = this._array[length3 - 1];
    if (length3 >= 4) {
      pushDown(this, maximumElementIndex);
    }
  }
  this._array[length3 - 1] = void 0;
  return maximumElement;
};
DoubleEndedPriorityQueue.prototype.getMinimum = function() {
  const length3 = this._length;
  if (length3 === 0) {
    return void 0;
  }
  return this._array[0];
};
DoubleEndedPriorityQueue.prototype.getMaximum = function() {
  const length3 = this._length;
  if (length3 === 0) {
    return void 0;
  }
  if (length3 <= 2) {
    return this._array[length3 - 1];
  }
  return this._array[greaterThan(this, 1, 2) ? 1 : 2];
};
function swap2(that, indexA, indexB) {
  const array = that._array;
  const temp = array[indexA];
  array[indexA] = array[indexB];
  array[indexB] = temp;
}
function lessThan(that, indexA, indexB) {
  return that._comparator(that._array[indexA], that._array[indexB]) < 0;
}
function greaterThan(that, indexA, indexB) {
  return that._comparator(that._array[indexA], that._array[indexB]) > 0;
}
function pushUp(that, index2) {
  if (index2 === 0) {
    return;
  }
  const onMinLevel = Math.floor(Math_default.log2(index2 + 1)) % 2 === 0;
  const parentIndex = Math.floor((index2 - 1) / 2);
  const lessThanParent = lessThan(that, index2, parentIndex);
  if (lessThanParent !== onMinLevel) {
    swap2(that, index2, parentIndex);
    index2 = parentIndex;
  }
  while (index2 >= 3) {
    const grandparentIndex = Math.floor((index2 - 3) / 4);
    if (lessThan(that, index2, grandparentIndex) !== lessThanParent) {
      break;
    }
    swap2(that, index2, grandparentIndex);
    index2 = grandparentIndex;
  }
}
function pushDown(that, index2) {
  const length3 = that._length;
  const onMinLevel = Math.floor(Math_default.log2(index2 + 1)) % 2 === 0;
  let leftChildIndex;
  while ((leftChildIndex = 2 * index2 + 1) < length3) {
    let target = leftChildIndex;
    const rightChildIndex = leftChildIndex + 1;
    if (rightChildIndex < length3) {
      if (lessThan(that, rightChildIndex, target) === onMinLevel) {
        target = rightChildIndex;
      }
      const grandChildStart = 2 * leftChildIndex + 1;
      const grandChildCount = Math.max(
        Math.min(length3 - grandChildStart, 4),
        0
      );
      for (let i2 = 0; i2 < grandChildCount; i2++) {
        const grandChildIndex = grandChildStart + i2;
        if (lessThan(that, grandChildIndex, target) === onMinLevel) {
          target = grandChildIndex;
        }
      }
    }
    if (lessThan(that, target, index2) === onMinLevel) {
      swap2(that, target, index2);
      if (target !== leftChildIndex && target !== rightChildIndex) {
        const parentOfGrandchildIndex = Math.floor((target - 1) / 2);
        if (greaterThan(that, target, parentOfGrandchildIndex) === onMinLevel) {
          swap2(that, target, parentOfGrandchildIndex);
        }
      }
    }
    index2 = target;
  }
}
var DoubleEndedPriorityQueue_default = DoubleEndedPriorityQueue;

// node_modules/cesium/Source/Core/DoublyLinkedList.js
function DoublyLinkedList() {
  this.head = void 0;
  this.tail = void 0;
  this._length = 0;
}
Object.defineProperties(DoublyLinkedList.prototype, {
  length: {
    get: function() {
      return this._length;
    }
  }
});
function DoublyLinkedListNode(item, previous, next) {
  this.item = item;
  this.previous = previous;
  this.next = next;
}
DoublyLinkedList.prototype.add = function(item) {
  const node = new DoublyLinkedListNode(item, this.tail, void 0);
  if (defined_default(this.tail)) {
    this.tail.next = node;
    this.tail = node;
  } else {
    this.head = node;
    this.tail = node;
  }
  ++this._length;
  return node;
};
function remove(list, node) {
  if (defined_default(node.previous) && defined_default(node.next)) {
    node.previous.next = node.next;
    node.next.previous = node.previous;
  } else if (defined_default(node.previous)) {
    node.previous.next = void 0;
    list.tail = node.previous;
  } else if (defined_default(node.next)) {
    node.next.previous = void 0;
    list.head = node.next;
  } else {
    list.head = void 0;
    list.tail = void 0;
  }
  node.next = void 0;
  node.previous = void 0;
}
DoublyLinkedList.prototype.remove = function(node) {
  if (!defined_default(node)) {
    return;
  }
  remove(this, node);
  --this._length;
};
DoublyLinkedList.prototype.splice = function(node, nextNode) {
  if (node === nextNode) {
    return;
  }
  remove(this, nextNode);
  const oldNodeNext = node.next;
  node.next = nextNode;
  if (this.tail === node) {
    this.tail = nextNode;
  } else {
    oldNodeNext.previous = nextNode;
  }
  nextNode.next = oldNodeNext;
  nextNode.previous = node;
};
var DoublyLinkedList_default = DoublyLinkedList;

// node_modules/cesium/Source/ThirdParty/Tween.js
var Tween = createCommonjsModule(function(module2, exports2) {
  var TWEEN = TWEEN || function() {
    var _tweens = [];
    return {
      getAll: function() {
        return _tweens;
      },
      removeAll: function() {
        _tweens = [];
      },
      add: function(tween) {
        _tweens.push(tween);
      },
      remove: function(tween) {
        var i2 = _tweens.indexOf(tween);
        if (i2 !== -1) {
          _tweens.splice(i2, 1);
        }
      },
      update: function(time, preserve) {
        if (_tweens.length === 0) {
          return false;
        }
        var i2 = 0;
        time = time !== void 0 ? time : TWEEN.now();
        while (i2 < _tweens.length) {
          if (_tweens[i2].update(time) || preserve) {
            i2++;
          } else {
            _tweens.splice(i2, 1);
          }
        }
        return true;
      }
    };
  }();
  if (typeof window === "undefined" && typeof process !== "undefined") {
    TWEEN.now = function() {
      var time = process.hrtime();
      return time[0] * 1e3 + time[1] / 1e6;
    };
  } else if (typeof window !== "undefined" && window.performance !== void 0 && window.performance.now !== void 0) {
    TWEEN.now = window.performance.now.bind(window.performance);
  } else if (Date.now !== void 0) {
    TWEEN.now = Date.now;
  } else {
    TWEEN.now = function() {
      return new Date().getTime();
    };
  }
  TWEEN.Tween = function(object2) {
    var _object = object2;
    var _valuesStart = {};
    var _valuesEnd = {};
    var _valuesStartRepeat = {};
    var _duration = 1e3;
    var _repeat = 0;
    var _repeatDelayTime;
    var _yoyo = false;
    var _isPlaying = false;
    var _delayTime = 0;
    var _startTime = null;
    var _easingFunction = TWEEN.Easing.Linear.None;
    var _interpolationFunction = TWEEN.Interpolation.Linear;
    var _chainedTweens = [];
    var _onStartCallback = null;
    var _onStartCallbackFired = false;
    var _onUpdateCallback = null;
    var _onCompleteCallback = null;
    var _onStopCallback = null;
    this.to = function(properties, duration) {
      _valuesEnd = properties;
      if (duration !== void 0) {
        _duration = duration;
      }
      return this;
    };
    this.start = function(time) {
      TWEEN.add(this);
      _isPlaying = true;
      _onStartCallbackFired = false;
      _startTime = time !== void 0 ? time : TWEEN.now();
      _startTime += _delayTime;
      for (var property in _valuesEnd) {
        if (_valuesEnd[property] instanceof Array) {
          if (_valuesEnd[property].length === 0) {
            continue;
          }
          _valuesEnd[property] = [_object[property]].concat(_valuesEnd[property]);
        }
        if (_object[property] === void 0) {
          continue;
        }
        _valuesStart[property] = _object[property];
        if (_valuesStart[property] instanceof Array === false) {
          _valuesStart[property] *= 1;
        }
        _valuesStartRepeat[property] = _valuesStart[property] || 0;
      }
      return this;
    };
    this.stop = function() {
      if (!_isPlaying) {
        return this;
      }
      TWEEN.remove(this);
      _isPlaying = false;
      if (_onStopCallback !== null) {
        _onStopCallback.call(_object, _object);
      }
      this.stopChainedTweens();
      return this;
    };
    this.end = function() {
      this.update(_startTime + _duration);
      return this;
    };
    this.stopChainedTweens = function() {
      for (var i2 = 0, numChainedTweens = _chainedTweens.length; i2 < numChainedTweens; i2++) {
        _chainedTweens[i2].stop();
      }
    };
    this.delay = function(amount) {
      _delayTime = amount;
      return this;
    };
    this.repeat = function(times) {
      _repeat = times;
      return this;
    };
    this.repeatDelay = function(amount) {
      _repeatDelayTime = amount;
      return this;
    };
    this.yoyo = function(yoyo) {
      _yoyo = yoyo;
      return this;
    };
    this.easing = function(easing) {
      _easingFunction = easing;
      return this;
    };
    this.interpolation = function(interpolation) {
      _interpolationFunction = interpolation;
      return this;
    };
    this.chain = function() {
      _chainedTweens = arguments;
      return this;
    };
    this.onStart = function(callback) {
      _onStartCallback = callback;
      return this;
    };
    this.onUpdate = function(callback) {
      _onUpdateCallback = callback;
      return this;
    };
    this.onComplete = function(callback) {
      _onCompleteCallback = callback;
      return this;
    };
    this.onStop = function(callback) {
      _onStopCallback = callback;
      return this;
    };
    this.update = function(time) {
      var property;
      var elapsed;
      var value;
      if (time < _startTime) {
        return true;
      }
      if (_onStartCallbackFired === false) {
        if (_onStartCallback !== null) {
          _onStartCallback.call(_object, _object);
        }
        _onStartCallbackFired = true;
      }
      elapsed = (time - _startTime) / _duration;
      elapsed = elapsed > 1 ? 1 : elapsed;
      value = _easingFunction(elapsed);
      for (property in _valuesEnd) {
        if (_valuesStart[property] === void 0) {
          continue;
        }
        var start = _valuesStart[property] || 0;
        var end = _valuesEnd[property];
        if (end instanceof Array) {
          _object[property] = _interpolationFunction(end, value);
        } else {
          if (typeof end === "string") {
            if (end.charAt(0) === "+" || end.charAt(0) === "-") {
              end = start + parseFloat(end);
            } else {
              end = parseFloat(end);
            }
          }
          if (typeof end === "number") {
            _object[property] = start + (end - start) * value;
          }
        }
      }
      if (_onUpdateCallback !== null) {
        _onUpdateCallback.call(_object, value);
      }
      if (elapsed === 1) {
        if (_repeat > 0) {
          if (isFinite(_repeat)) {
            _repeat--;
          }
          for (property in _valuesStartRepeat) {
            if (typeof _valuesEnd[property] === "string") {
              _valuesStartRepeat[property] = _valuesStartRepeat[property] + parseFloat(_valuesEnd[property]);
            }
            if (_yoyo) {
              var tmp2 = _valuesStartRepeat[property];
              _valuesStartRepeat[property] = _valuesEnd[property];
              _valuesEnd[property] = tmp2;
            }
            _valuesStart[property] = _valuesStartRepeat[property];
          }
          if (_repeatDelayTime !== void 0) {
            _startTime = time + _repeatDelayTime;
          } else {
            _startTime = time + _delayTime;
          }
          return true;
        } else {
          if (_onCompleteCallback !== null) {
            _onCompleteCallback.call(_object, _object);
          }
          for (var i2 = 0, numChainedTweens = _chainedTweens.length; i2 < numChainedTweens; i2++) {
            _chainedTweens[i2].start(_startTime + _duration);
          }
          return false;
        }
      }
      return true;
    };
  };
  TWEEN.Easing = {
    Linear: {
      None: function(k) {
        return k;
      }
    },
    Quadratic: {
      In: function(k) {
        return k * k;
      },
      Out: function(k) {
        return k * (2 - k);
      },
      InOut: function(k) {
        if ((k *= 2) < 1) {
          return 0.5 * k * k;
        }
        return -0.5 * (--k * (k - 2) - 1);
      }
    },
    Cubic: {
      In: function(k) {
        return k * k * k;
      },
      Out: function(k) {
        return --k * k * k + 1;
      },
      InOut: function(k) {
        if ((k *= 2) < 1) {
          return 0.5 * k * k * k;
        }
        return 0.5 * ((k -= 2) * k * k + 2);
      }
    },
    Quartic: {
      In: function(k) {
        return k * k * k * k;
      },
      Out: function(k) {
        return 1 - --k * k * k * k;
      },
      InOut: function(k) {
        if ((k *= 2) < 1) {
          return 0.5 * k * k * k * k;
        }
        return -0.5 * ((k -= 2) * k * k * k - 2);
      }
    },
    Quintic: {
      In: function(k) {
        return k * k * k * k * k;
      },
      Out: function(k) {
        return --k * k * k * k * k + 1;
      },
      InOut: function(k) {
        if ((k *= 2) < 1) {
          return 0.5 * k * k * k * k * k;
        }
        return 0.5 * ((k -= 2) * k * k * k * k + 2);
      }
    },
    Sinusoidal: {
      In: function(k) {
        return 1 - Math.cos(k * Math.PI / 2);
      },
      Out: function(k) {
        return Math.sin(k * Math.PI / 2);
      },
      InOut: function(k) {
        return 0.5 * (1 - Math.cos(Math.PI * k));
      }
    },
    Exponential: {
      In: function(k) {
        return k === 0 ? 0 : Math.pow(1024, k - 1);
      },
      Out: function(k) {
        return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);
      },
      InOut: function(k) {
        if (k === 0) {
          return 0;
        }
        if (k === 1) {
          return 1;
        }
        if ((k *= 2) < 1) {
          return 0.5 * Math.pow(1024, k - 1);
        }
        return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);
      }
    },
    Circular: {
      In: function(k) {
        return 1 - Math.sqrt(1 - k * k);
      },
      Out: function(k) {
        return Math.sqrt(1 - --k * k);
      },
      InOut: function(k) {
        if ((k *= 2) < 1) {
          return -0.5 * (Math.sqrt(1 - k * k) - 1);
        }
        return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
      }
    },
    Elastic: {
      In: function(k) {
        if (k === 0) {
          return 0;
        }
        if (k === 1) {
          return 1;
        }
        return -Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI);
      },
      Out: function(k) {
        if (k === 0) {
          return 0;
        }
        if (k === 1) {
          return 1;
        }
        return Math.pow(2, -10 * k) * Math.sin((k - 0.1) * 5 * Math.PI) + 1;
      },
      InOut: function(k) {
        if (k === 0) {
          return 0;
        }
        if (k === 1) {
          return 1;
        }
        k *= 2;
        if (k < 1) {
          return -0.5 * Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI);
        }
        return 0.5 * Math.pow(2, -10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI) + 1;
      }
    },
    Back: {
      In: function(k) {
        var s2 = 1.70158;
        return k * k * ((s2 + 1) * k - s2);
      },
      Out: function(k) {
        var s2 = 1.70158;
        return --k * k * ((s2 + 1) * k + s2) + 1;
      },
      InOut: function(k) {
        var s2 = 1.70158 * 1.525;
        if ((k *= 2) < 1) {
          return 0.5 * (k * k * ((s2 + 1) * k - s2));
        }
        return 0.5 * ((k -= 2) * k * ((s2 + 1) * k + s2) + 2);
      }
    },
    Bounce: {
      In: function(k) {
        return 1 - TWEEN.Easing.Bounce.Out(1 - k);
      },
      Out: function(k) {
        if (k < 1 / 2.75) {
          return 7.5625 * k * k;
        } else if (k < 2 / 2.75) {
          return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75;
        } else if (k < 2.5 / 2.75) {
          return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375;
        } else {
          return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375;
        }
      },
      InOut: function(k) {
        if (k < 0.5) {
          return TWEEN.Easing.Bounce.In(k * 2) * 0.5;
        }
        return TWEEN.Easing.Bounce.Out(k * 2 - 1) * 0.5 + 0.5;
      }
    }
  };
  TWEEN.Interpolation = {
    Linear: function(v7, k) {
      var m = v7.length - 1;
      var f2 = m * k;
      var i2 = Math.floor(f2);
      var fn = TWEEN.Interpolation.Utils.Linear;
      if (k < 0) {
        return fn(v7[0], v7[1], f2);
      }
      if (k > 1) {
        return fn(v7[m], v7[m - 1], m - f2);
      }
      return fn(v7[i2], v7[i2 + 1 > m ? m : i2 + 1], f2 - i2);
    },
    Bezier: function(v7, k) {
      var b = 0;
      var n2 = v7.length - 1;
      var pw = Math.pow;
      var bn = TWEEN.Interpolation.Utils.Bernstein;
      for (var i2 = 0; i2 <= n2; i2++) {
        b += pw(1 - k, n2 - i2) * pw(k, i2) * v7[i2] * bn(n2, i2);
      }
      return b;
    },
    CatmullRom: function(v7, k) {
      var m = v7.length - 1;
      var f2 = m * k;
      var i2 = Math.floor(f2);
      var fn = TWEEN.Interpolation.Utils.CatmullRom;
      if (v7[0] === v7[m]) {
        if (k < 0) {
          i2 = Math.floor(f2 = m * (1 + k));
        }
        return fn(v7[(i2 - 1 + m) % m], v7[i2], v7[(i2 + 1) % m], v7[(i2 + 2) % m], f2 - i2);
      } else {
        if (k < 0) {
          return v7[0] - (fn(v7[0], v7[0], v7[1], v7[1], -f2) - v7[0]);
        }
        if (k > 1) {
          return v7[m] - (fn(v7[m], v7[m], v7[m - 1], v7[m - 1], f2 - m) - v7[m]);
        }
        return fn(v7[i2 ? i2 - 1 : 0], v7[i2], v7[m < i2 + 1 ? m : i2 + 1], v7[m < i2 + 2 ? m : i2 + 2], f2 - i2);
      }
    },
    Utils: {
      Linear: function(p0, p1, t) {
        return (p1 - p0) * t + p0;
      },
      Bernstein: function(n2, i2) {
        var fc = TWEEN.Interpolation.Utils.Factorial;
        return fc(n2) / fc(i2) / fc(n2 - i2);
      },
      Factorial: function() {
        var a4 = [1];
        return function(n2) {
          var s2 = 1;
          if (a4[n2]) {
            return a4[n2];
          }
          for (var i2 = n2; i2 > 1; i2--) {
            s2 *= i2;
          }
          a4[n2] = s2;
          return s2;
        };
      }(),
      CatmullRom: function(p0, p1, p2, p3, t) {
        var v02 = (p2 - p0) * 0.5;
        var v13 = (p3 - p1) * 0.5;
        var t2 = t * t;
        var t3 = t * t2;
        return (2 * p1 - 2 * p2 + v02 + v13) * t3 + (-3 * p1 + 3 * p2 - 2 * v02 - v13) * t2 + v02 * t + p1;
      }
    }
  };
  (function(root) {
    {
      module2.exports = TWEEN;
    }
  })();
});

// node_modules/cesium/Source/Core/EasingFunction.js
var EasingFunction = {
  LINEAR_NONE: Tween.Easing.Linear.None,
  QUADRATIC_IN: Tween.Easing.Quadratic.In,
  QUADRATIC_OUT: Tween.Easing.Quadratic.Out,
  QUADRATIC_IN_OUT: Tween.Easing.Quadratic.InOut,
  CUBIC_IN: Tween.Easing.Cubic.In,
  CUBIC_OUT: Tween.Easing.Cubic.Out,
  CUBIC_IN_OUT: Tween.Easing.Cubic.InOut,
  QUARTIC_IN: Tween.Easing.Quartic.In,
  QUARTIC_OUT: Tween.Easing.Quartic.Out,
  QUARTIC_IN_OUT: Tween.Easing.Quartic.InOut,
  QUINTIC_IN: Tween.Easing.Quintic.In,
  QUINTIC_OUT: Tween.Easing.Quintic.Out,
  QUINTIC_IN_OUT: Tween.Easing.Quintic.InOut,
  SINUSOIDAL_IN: Tween.Easing.Sinusoidal.In,
  SINUSOIDAL_OUT: Tween.Easing.Sinusoidal.Out,
  SINUSOIDAL_IN_OUT: Tween.Easing.Sinusoidal.InOut,
  EXPONENTIAL_IN: Tween.Easing.Exponential.In,
  EXPONENTIAL_OUT: Tween.Easing.Exponential.Out,
  EXPONENTIAL_IN_OUT: Tween.Easing.Exponential.InOut,
  CIRCULAR_IN: Tween.Easing.Circular.In,
  CIRCULAR_OUT: Tween.Easing.Circular.Out,
  CIRCULAR_IN_OUT: Tween.Easing.Circular.InOut,
  ELASTIC_IN: Tween.Easing.Elastic.In,
  ELASTIC_OUT: Tween.Easing.Elastic.Out,
  ELASTIC_IN_OUT: Tween.Easing.Elastic.InOut,
  BACK_IN: Tween.Easing.Back.In,
  BACK_OUT: Tween.Easing.Back.Out,
  BACK_IN_OUT: Tween.Easing.Back.InOut,
  BOUNCE_IN: Tween.Easing.Bounce.In,
  BOUNCE_OUT: Tween.Easing.Bounce.Out,
  BOUNCE_IN_OUT: Tween.Easing.Bounce.InOut
};
var EasingFunction_default = Object.freeze(EasingFunction);

// node_modules/cesium/Source/Core/EllipsoidGeometry.js
var scratchPosition3 = new Cartesian3_default();
var scratchNormal5 = new Cartesian3_default();
var scratchTangent3 = new Cartesian3_default();
var scratchBitangent3 = new Cartesian3_default();
var scratchNormalST = new Cartesian3_default();
var defaultRadii = new Cartesian3_default(1, 1, 1);
var cos = Math.cos;
var sin = Math.sin;
function EllipsoidGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const radii = defaultValue_default(options.radii, defaultRadii);
  const innerRadii = defaultValue_default(options.innerRadii, radii);
  const minimumClock = defaultValue_default(options.minimumClock, 0);
  const maximumClock = defaultValue_default(options.maximumClock, Math_default.TWO_PI);
  const minimumCone = defaultValue_default(options.minimumCone, 0);
  const maximumCone = defaultValue_default(options.maximumCone, Math_default.PI);
  const stackPartitions = Math.round(defaultValue_default(options.stackPartitions, 64));
  const slicePartitions = Math.round(defaultValue_default(options.slicePartitions, 64));
  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
  if (slicePartitions < 3) {
    throw new DeveloperError_default(
      "options.slicePartitions cannot be less than three."
    );
  }
  if (stackPartitions < 3) {
    throw new DeveloperError_default(
      "options.stackPartitions cannot be less than three."
    );
  }
  this._radii = Cartesian3_default.clone(radii);
  this._innerRadii = Cartesian3_default.clone(innerRadii);
  this._minimumClock = minimumClock;
  this._maximumClock = maximumClock;
  this._minimumCone = minimumCone;
  this._maximumCone = maximumCone;
  this._stackPartitions = stackPartitions;
  this._slicePartitions = slicePartitions;
  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createEllipsoidGeometry";
}
EllipsoidGeometry.packedLength = 2 * Cartesian3_default.packedLength + VertexFormat_default.packedLength + 7;
EllipsoidGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  Cartesian3_default.pack(value._radii, array, startingIndex);
  startingIndex += Cartesian3_default.packedLength;
  Cartesian3_default.pack(value._innerRadii, array, startingIndex);
  startingIndex += Cartesian3_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex++] = value._minimumClock;
  array[startingIndex++] = value._maximumClock;
  array[startingIndex++] = value._minimumCone;
  array[startingIndex++] = value._maximumCone;
  array[startingIndex++] = value._stackPartitions;
  array[startingIndex++] = value._slicePartitions;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchRadii = new Cartesian3_default();
var scratchInnerRadii = new Cartesian3_default();
var scratchVertexFormat6 = new VertexFormat_default();
var scratchOptions13 = {
  radii: scratchRadii,
  innerRadii: scratchInnerRadii,
  vertexFormat: scratchVertexFormat6,
  minimumClock: void 0,
  maximumClock: void 0,
  minimumCone: void 0,
  maximumCone: void 0,
  stackPartitions: void 0,
  slicePartitions: void 0,
  offsetAttribute: void 0
};
EllipsoidGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  const radii = Cartesian3_default.unpack(array, startingIndex, scratchRadii);
  startingIndex += Cartesian3_default.packedLength;
  const innerRadii = Cartesian3_default.unpack(array, startingIndex, scratchInnerRadii);
  startingIndex += Cartesian3_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat6
  );
  startingIndex += VertexFormat_default.packedLength;
  const minimumClock = array[startingIndex++];
  const maximumClock = array[startingIndex++];
  const minimumCone = array[startingIndex++];
  const maximumCone = array[startingIndex++];
  const stackPartitions = array[startingIndex++];
  const slicePartitions = array[startingIndex++];
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions13.minimumClock = minimumClock;
    scratchOptions13.maximumClock = maximumClock;
    scratchOptions13.minimumCone = minimumCone;
    scratchOptions13.maximumCone = maximumCone;
    scratchOptions13.stackPartitions = stackPartitions;
    scratchOptions13.slicePartitions = slicePartitions;
    scratchOptions13.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new EllipsoidGeometry(scratchOptions13);
  }
  result._radii = Cartesian3_default.clone(radii, result._radii);
  result._innerRadii = Cartesian3_default.clone(innerRadii, result._innerRadii);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._minimumClock = minimumClock;
  result._maximumClock = maximumClock;
  result._minimumCone = minimumCone;
  result._maximumCone = maximumCone;
  result._stackPartitions = stackPartitions;
  result._slicePartitions = slicePartitions;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
EllipsoidGeometry.createGeometry = function(ellipsoidGeometry) {
  const radii = ellipsoidGeometry._radii;
  if (radii.x <= 0 || radii.y <= 0 || radii.z <= 0) {
    return;
  }
  const innerRadii = ellipsoidGeometry._innerRadii;
  if (innerRadii.x <= 0 || innerRadii.y <= 0 || innerRadii.z <= 0) {
    return;
  }
  const minimumClock = ellipsoidGeometry._minimumClock;
  const maximumClock = ellipsoidGeometry._maximumClock;
  const minimumCone = ellipsoidGeometry._minimumCone;
  const maximumCone = ellipsoidGeometry._maximumCone;
  const vertexFormat = ellipsoidGeometry._vertexFormat;
  let slicePartitions = ellipsoidGeometry._slicePartitions + 1;
  let stackPartitions = ellipsoidGeometry._stackPartitions + 1;
  slicePartitions = Math.round(
    slicePartitions * Math.abs(maximumClock - minimumClock) / Math_default.TWO_PI
  );
  stackPartitions = Math.round(
    stackPartitions * Math.abs(maximumCone - minimumCone) / Math_default.PI
  );
  if (slicePartitions < 2) {
    slicePartitions = 2;
  }
  if (stackPartitions < 2) {
    stackPartitions = 2;
  }
  let i2;
  let j;
  let index2 = 0;
  const phis = [minimumCone];
  const thetas = [minimumClock];
  for (i2 = 0; i2 < stackPartitions; i2++) {
    phis.push(
      minimumCone + i2 * (maximumCone - minimumCone) / (stackPartitions - 1)
    );
  }
  phis.push(maximumCone);
  for (j = 0; j < slicePartitions; j++) {
    thetas.push(
      minimumClock + j * (maximumClock - minimumClock) / (slicePartitions - 1)
    );
  }
  thetas.push(maximumClock);
  const numPhis = phis.length;
  const numThetas = thetas.length;
  let extraIndices = 0;
  let vertexMultiplier = 1;
  const hasInnerSurface = innerRadii.x !== radii.x || innerRadii.y !== radii.y || innerRadii.z !== radii.z;
  let isTopOpen = false;
  let isBotOpen = false;
  let isClockOpen = false;
  if (hasInnerSurface) {
    vertexMultiplier = 2;
    if (minimumCone > 0) {
      isTopOpen = true;
      extraIndices += slicePartitions - 1;
    }
    if (maximumCone < Math.PI) {
      isBotOpen = true;
      extraIndices += slicePartitions - 1;
    }
    if ((maximumClock - minimumClock) % Math_default.TWO_PI) {
      isClockOpen = true;
      extraIndices += (stackPartitions - 1) * 2 + 1;
    } else {
      extraIndices += 1;
    }
  }
  const vertexCount = numThetas * numPhis * vertexMultiplier;
  const positions = new Float64Array(vertexCount * 3);
  const isInner = arrayFill_default(new Array(vertexCount), false);
  const negateNormal = arrayFill_default(new Array(vertexCount), false);
  const indexCount = slicePartitions * stackPartitions * vertexMultiplier;
  const numIndices = 6 * (indexCount + extraIndices + 1 - (slicePartitions + stackPartitions) * vertexMultiplier);
  const indices2 = IndexDatatype_default.createTypedArray(indexCount, numIndices);
  const normals = vertexFormat.normal ? new Float32Array(vertexCount * 3) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(vertexCount * 3) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(vertexCount * 3) : void 0;
  const st = vertexFormat.st ? new Float32Array(vertexCount * 2) : void 0;
  const sinPhi = new Array(numPhis);
  const cosPhi = new Array(numPhis);
  for (i2 = 0; i2 < numPhis; i2++) {
    sinPhi[i2] = sin(phis[i2]);
    cosPhi[i2] = cos(phis[i2]);
  }
  const sinTheta = new Array(numThetas);
  const cosTheta = new Array(numThetas);
  for (j = 0; j < numThetas; j++) {
    cosTheta[j] = cos(thetas[j]);
    sinTheta[j] = sin(thetas[j]);
  }
  for (i2 = 0; i2 < numPhis; i2++) {
    for (j = 0; j < numThetas; j++) {
      positions[index2++] = radii.x * sinPhi[i2] * cosTheta[j];
      positions[index2++] = radii.y * sinPhi[i2] * sinTheta[j];
      positions[index2++] = radii.z * cosPhi[i2];
    }
  }
  let vertexIndex = vertexCount / 2;
  if (hasInnerSurface) {
    for (i2 = 0; i2 < numPhis; i2++) {
      for (j = 0; j < numThetas; j++) {
        positions[index2++] = innerRadii.x * sinPhi[i2] * cosTheta[j];
        positions[index2++] = innerRadii.y * sinPhi[i2] * sinTheta[j];
        positions[index2++] = innerRadii.z * cosPhi[i2];
        isInner[vertexIndex] = true;
        if (i2 > 0 && i2 !== numPhis - 1 && j !== 0 && j !== numThetas - 1) {
          negateNormal[vertexIndex] = true;
        }
        vertexIndex++;
      }
    }
  }
  index2 = 0;
  let topOffset;
  let bottomOffset;
  for (i2 = 1; i2 < numPhis - 2; i2++) {
    topOffset = i2 * numThetas;
    bottomOffset = (i2 + 1) * numThetas;
    for (j = 1; j < numThetas - 2; j++) {
      indices2[index2++] = bottomOffset + j;
      indices2[index2++] = bottomOffset + j + 1;
      indices2[index2++] = topOffset + j + 1;
      indices2[index2++] = bottomOffset + j;
      indices2[index2++] = topOffset + j + 1;
      indices2[index2++] = topOffset + j;
    }
  }
  if (hasInnerSurface) {
    const offset2 = numPhis * numThetas;
    for (i2 = 1; i2 < numPhis - 2; i2++) {
      topOffset = offset2 + i2 * numThetas;
      bottomOffset = offset2 + (i2 + 1) * numThetas;
      for (j = 1; j < numThetas - 2; j++) {
        indices2[index2++] = bottomOffset + j;
        indices2[index2++] = topOffset + j;
        indices2[index2++] = topOffset + j + 1;
        indices2[index2++] = bottomOffset + j;
        indices2[index2++] = topOffset + j + 1;
        indices2[index2++] = bottomOffset + j + 1;
      }
    }
  }
  let outerOffset;
  let innerOffset;
  if (hasInnerSurface) {
    if (isTopOpen) {
      innerOffset = numPhis * numThetas;
      for (i2 = 1; i2 < numThetas - 2; i2++) {
        indices2[index2++] = i2;
        indices2[index2++] = i2 + 1;
        indices2[index2++] = innerOffset + i2 + 1;
        indices2[index2++] = i2;
        indices2[index2++] = innerOffset + i2 + 1;
        indices2[index2++] = innerOffset + i2;
      }
    }
    if (isBotOpen) {
      outerOffset = numPhis * numThetas - numThetas;
      innerOffset = numPhis * numThetas * vertexMultiplier - numThetas;
      for (i2 = 1; i2 < numThetas - 2; i2++) {
        indices2[index2++] = outerOffset + i2 + 1;
        indices2[index2++] = outerOffset + i2;
        indices2[index2++] = innerOffset + i2;
        indices2[index2++] = outerOffset + i2 + 1;
        indices2[index2++] = innerOffset + i2;
        indices2[index2++] = innerOffset + i2 + 1;
      }
    }
  }
  if (isClockOpen) {
    for (i2 = 1; i2 < numPhis - 2; i2++) {
      innerOffset = numThetas * numPhis + numThetas * i2;
      outerOffset = numThetas * i2;
      indices2[index2++] = innerOffset;
      indices2[index2++] = outerOffset + numThetas;
      indices2[index2++] = outerOffset;
      indices2[index2++] = innerOffset;
      indices2[index2++] = innerOffset + numThetas;
      indices2[index2++] = outerOffset + numThetas;
    }
    for (i2 = 1; i2 < numPhis - 2; i2++) {
      innerOffset = numThetas * numPhis + numThetas * (i2 + 1) - 1;
      outerOffset = numThetas * (i2 + 1) - 1;
      indices2[index2++] = outerOffset + numThetas;
      indices2[index2++] = innerOffset;
      indices2[index2++] = outerOffset;
      indices2[index2++] = outerOffset + numThetas;
      indices2[index2++] = innerOffset + numThetas;
      indices2[index2++] = innerOffset;
    }
  }
  const attributes = new GeometryAttributes_default();
  if (vertexFormat.position) {
    attributes.position = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: positions
    });
  }
  let stIndex = 0;
  let normalIndex = 0;
  let tangentIndex = 0;
  let bitangentIndex = 0;
  const vertexCountHalf = vertexCount / 2;
  let ellipsoid;
  const ellipsoidOuter = Ellipsoid_default.fromCartesian3(radii);
  const ellipsoidInner = Ellipsoid_default.fromCartesian3(innerRadii);
  if (vertexFormat.st || vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent) {
    for (i2 = 0; i2 < vertexCount; i2++) {
      ellipsoid = isInner[i2] ? ellipsoidInner : ellipsoidOuter;
      const position = Cartesian3_default.fromArray(positions, i2 * 3, scratchPosition3);
      const normal2 = ellipsoid.geodeticSurfaceNormal(position, scratchNormal5);
      if (negateNormal[i2]) {
        Cartesian3_default.negate(normal2, normal2);
      }
      if (vertexFormat.st) {
        const normalST = Cartesian2_default.negate(normal2, scratchNormalST);
        st[stIndex++] = Math.atan2(normalST.y, normalST.x) / Math_default.TWO_PI + 0.5;
        st[stIndex++] = Math.asin(normal2.z) / Math.PI + 0.5;
      }
      if (vertexFormat.normal) {
        normals[normalIndex++] = normal2.x;
        normals[normalIndex++] = normal2.y;
        normals[normalIndex++] = normal2.z;
      }
      if (vertexFormat.tangent || vertexFormat.bitangent) {
        const tangent = scratchTangent3;
        let tangetOffset = 0;
        let unit;
        if (isInner[i2]) {
          tangetOffset = vertexCountHalf;
        }
        if (!isTopOpen && i2 >= tangetOffset && i2 < tangetOffset + numThetas * 2) {
          unit = Cartesian3_default.UNIT_X;
        } else {
          unit = Cartesian3_default.UNIT_Z;
        }
        Cartesian3_default.cross(unit, normal2, tangent);
        Cartesian3_default.normalize(tangent, tangent);
        if (vertexFormat.tangent) {
          tangents[tangentIndex++] = tangent.x;
          tangents[tangentIndex++] = tangent.y;
          tangents[tangentIndex++] = tangent.z;
        }
        if (vertexFormat.bitangent) {
          const bitangent = Cartesian3_default.cross(normal2, tangent, scratchBitangent3);
          Cartesian3_default.normalize(bitangent, bitangent);
          bitangents[bitangentIndex++] = bitangent.x;
          bitangents[bitangentIndex++] = bitangent.y;
          bitangents[bitangentIndex++] = bitangent.z;
        }
      }
    }
    if (vertexFormat.st) {
      attributes.st = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 2,
        values: st
      });
    }
    if (vertexFormat.normal) {
      attributes.normal = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: normals
      });
    }
    if (vertexFormat.tangent) {
      attributes.tangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: tangents
      });
    }
    if (vertexFormat.bitangent) {
      attributes.bitangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: bitangents
      });
    }
  }
  if (defined_default(ellipsoidGeometry._offsetAttribute)) {
    const length3 = positions.length;
    const applyOffset = new Uint8Array(length3 / 3);
    const offsetValue = ellipsoidGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
    arrayFill_default(applyOffset, offsetValue);
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: applyOffset
    });
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingSphere: BoundingSphere_default.fromEllipsoid(ellipsoidOuter),
    offsetAttribute: ellipsoidGeometry._offsetAttribute
  });
};
var unitEllipsoidGeometry;
EllipsoidGeometry.getUnitEllipsoid = function() {
  if (!defined_default(unitEllipsoidGeometry)) {
    unitEllipsoidGeometry = EllipsoidGeometry.createGeometry(
      new EllipsoidGeometry({
        radii: new Cartesian3_default(1, 1, 1),
        vertexFormat: VertexFormat_default.POSITION_ONLY
      })
    );
  }
  return unitEllipsoidGeometry;
};
var EllipsoidGeometry_default = EllipsoidGeometry;

// node_modules/cesium/Source/Core/EllipsoidOutlineGeometry.js
var defaultRadii2 = new Cartesian3_default(1, 1, 1);
var cos2 = Math.cos;
var sin2 = Math.sin;
function EllipsoidOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const radii = defaultValue_default(options.radii, defaultRadii2);
  const innerRadii = defaultValue_default(options.innerRadii, radii);
  const minimumClock = defaultValue_default(options.minimumClock, 0);
  const maximumClock = defaultValue_default(options.maximumClock, Math_default.TWO_PI);
  const minimumCone = defaultValue_default(options.minimumCone, 0);
  const maximumCone = defaultValue_default(options.maximumCone, Math_default.PI);
  const stackPartitions = Math.round(defaultValue_default(options.stackPartitions, 10));
  const slicePartitions = Math.round(defaultValue_default(options.slicePartitions, 8));
  const subdivisions = Math.round(defaultValue_default(options.subdivisions, 128));
  if (stackPartitions < 1) {
    throw new DeveloperError_default("options.stackPartitions cannot be less than 1");
  }
  if (slicePartitions < 0) {
    throw new DeveloperError_default("options.slicePartitions cannot be less than 0");
  }
  if (subdivisions < 0) {
    throw new DeveloperError_default(
      "options.subdivisions must be greater than or equal to zero."
    );
  }
  if (defined_default(options.offsetAttribute) && options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
    throw new DeveloperError_default(
      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
    );
  }
  this._radii = Cartesian3_default.clone(radii);
  this._innerRadii = Cartesian3_default.clone(innerRadii);
  this._minimumClock = minimumClock;
  this._maximumClock = maximumClock;
  this._minimumCone = minimumCone;
  this._maximumCone = maximumCone;
  this._stackPartitions = stackPartitions;
  this._slicePartitions = slicePartitions;
  this._subdivisions = subdivisions;
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createEllipsoidOutlineGeometry";
}
EllipsoidOutlineGeometry.packedLength = 2 * Cartesian3_default.packedLength + 8;
EllipsoidOutlineGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  Cartesian3_default.pack(value._radii, array, startingIndex);
  startingIndex += Cartesian3_default.packedLength;
  Cartesian3_default.pack(value._innerRadii, array, startingIndex);
  startingIndex += Cartesian3_default.packedLength;
  array[startingIndex++] = value._minimumClock;
  array[startingIndex++] = value._maximumClock;
  array[startingIndex++] = value._minimumCone;
  array[startingIndex++] = value._maximumCone;
  array[startingIndex++] = value._stackPartitions;
  array[startingIndex++] = value._slicePartitions;
  array[startingIndex++] = value._subdivisions;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchRadii2 = new Cartesian3_default();
var scratchInnerRadii2 = new Cartesian3_default();
var scratchOptions14 = {
  radii: scratchRadii2,
  innerRadii: scratchInnerRadii2,
  minimumClock: void 0,
  maximumClock: void 0,
  minimumCone: void 0,
  maximumCone: void 0,
  stackPartitions: void 0,
  slicePartitions: void 0,
  subdivisions: void 0,
  offsetAttribute: void 0
};
EllipsoidOutlineGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  const radii = Cartesian3_default.unpack(array, startingIndex, scratchRadii2);
  startingIndex += Cartesian3_default.packedLength;
  const innerRadii = Cartesian3_default.unpack(array, startingIndex, scratchInnerRadii2);
  startingIndex += Cartesian3_default.packedLength;
  const minimumClock = array[startingIndex++];
  const maximumClock = array[startingIndex++];
  const minimumCone = array[startingIndex++];
  const maximumCone = array[startingIndex++];
  const stackPartitions = array[startingIndex++];
  const slicePartitions = array[startingIndex++];
  const subdivisions = array[startingIndex++];
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions14.minimumClock = minimumClock;
    scratchOptions14.maximumClock = maximumClock;
    scratchOptions14.minimumCone = minimumCone;
    scratchOptions14.maximumCone = maximumCone;
    scratchOptions14.stackPartitions = stackPartitions;
    scratchOptions14.slicePartitions = slicePartitions;
    scratchOptions14.subdivisions = subdivisions;
    scratchOptions14.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new EllipsoidOutlineGeometry(scratchOptions14);
  }
  result._radii = Cartesian3_default.clone(radii, result._radii);
  result._innerRadii = Cartesian3_default.clone(innerRadii, result._innerRadii);
  result._minimumClock = minimumClock;
  result._maximumClock = maximumClock;
  result._minimumCone = minimumCone;
  result._maximumCone = maximumCone;
  result._stackPartitions = stackPartitions;
  result._slicePartitions = slicePartitions;
  result._subdivisions = subdivisions;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
EllipsoidOutlineGeometry.createGeometry = function(ellipsoidGeometry) {
  const radii = ellipsoidGeometry._radii;
  if (radii.x <= 0 || radii.y <= 0 || radii.z <= 0) {
    return;
  }
  const innerRadii = ellipsoidGeometry._innerRadii;
  if (innerRadii.x <= 0 || innerRadii.y <= 0 || innerRadii.z <= 0) {
    return;
  }
  const minimumClock = ellipsoidGeometry._minimumClock;
  const maximumClock = ellipsoidGeometry._maximumClock;
  const minimumCone = ellipsoidGeometry._minimumCone;
  const maximumCone = ellipsoidGeometry._maximumCone;
  const subdivisions = ellipsoidGeometry._subdivisions;
  const ellipsoid = Ellipsoid_default.fromCartesian3(radii);
  let slicePartitions = ellipsoidGeometry._slicePartitions + 1;
  let stackPartitions = ellipsoidGeometry._stackPartitions + 1;
  slicePartitions = Math.round(
    slicePartitions * Math.abs(maximumClock - minimumClock) / Math_default.TWO_PI
  );
  stackPartitions = Math.round(
    stackPartitions * Math.abs(maximumCone - minimumCone) / Math_default.PI
  );
  if (slicePartitions < 2) {
    slicePartitions = 2;
  }
  if (stackPartitions < 2) {
    stackPartitions = 2;
  }
  let extraIndices = 0;
  let vertexMultiplier = 1;
  const hasInnerSurface = innerRadii.x !== radii.x || innerRadii.y !== radii.y || innerRadii.z !== radii.z;
  let isTopOpen = false;
  let isBotOpen = false;
  if (hasInnerSurface) {
    vertexMultiplier = 2;
    if (minimumCone > 0) {
      isTopOpen = true;
      extraIndices += slicePartitions;
    }
    if (maximumCone < Math.PI) {
      isBotOpen = true;
      extraIndices += slicePartitions;
    }
  }
  const vertexCount = subdivisions * vertexMultiplier * (stackPartitions + slicePartitions);
  const positions = new Float64Array(vertexCount * 3);
  const numIndices = 2 * (vertexCount + extraIndices - (slicePartitions + stackPartitions) * vertexMultiplier);
  const indices2 = IndexDatatype_default.createTypedArray(vertexCount, numIndices);
  let i2;
  let j;
  let theta;
  let phi;
  let index2 = 0;
  const sinPhi = new Array(stackPartitions);
  const cosPhi = new Array(stackPartitions);
  for (i2 = 0; i2 < stackPartitions; i2++) {
    phi = minimumCone + i2 * (maximumCone - minimumCone) / (stackPartitions - 1);
    sinPhi[i2] = sin2(phi);
    cosPhi[i2] = cos2(phi);
  }
  const sinTheta = new Array(subdivisions);
  const cosTheta = new Array(subdivisions);
  for (i2 = 0; i2 < subdivisions; i2++) {
    theta = minimumClock + i2 * (maximumClock - minimumClock) / (subdivisions - 1);
    sinTheta[i2] = sin2(theta);
    cosTheta[i2] = cos2(theta);
  }
  for (i2 = 0; i2 < stackPartitions; i2++) {
    for (j = 0; j < subdivisions; j++) {
      positions[index2++] = radii.x * sinPhi[i2] * cosTheta[j];
      positions[index2++] = radii.y * sinPhi[i2] * sinTheta[j];
      positions[index2++] = radii.z * cosPhi[i2];
    }
  }
  if (hasInnerSurface) {
    for (i2 = 0; i2 < stackPartitions; i2++) {
      for (j = 0; j < subdivisions; j++) {
        positions[index2++] = innerRadii.x * sinPhi[i2] * cosTheta[j];
        positions[index2++] = innerRadii.y * sinPhi[i2] * sinTheta[j];
        positions[index2++] = innerRadii.z * cosPhi[i2];
      }
    }
  }
  sinPhi.length = subdivisions;
  cosPhi.length = subdivisions;
  for (i2 = 0; i2 < subdivisions; i2++) {
    phi = minimumCone + i2 * (maximumCone - minimumCone) / (subdivisions - 1);
    sinPhi[i2] = sin2(phi);
    cosPhi[i2] = cos2(phi);
  }
  sinTheta.length = slicePartitions;
  cosTheta.length = slicePartitions;
  for (i2 = 0; i2 < slicePartitions; i2++) {
    theta = minimumClock + i2 * (maximumClock - minimumClock) / (slicePartitions - 1);
    sinTheta[i2] = sin2(theta);
    cosTheta[i2] = cos2(theta);
  }
  for (i2 = 0; i2 < subdivisions; i2++) {
    for (j = 0; j < slicePartitions; j++) {
      positions[index2++] = radii.x * sinPhi[i2] * cosTheta[j];
      positions[index2++] = radii.y * sinPhi[i2] * sinTheta[j];
      positions[index2++] = radii.z * cosPhi[i2];
    }
  }
  if (hasInnerSurface) {
    for (i2 = 0; i2 < subdivisions; i2++) {
      for (j = 0; j < slicePartitions; j++) {
        positions[index2++] = innerRadii.x * sinPhi[i2] * cosTheta[j];
        positions[index2++] = innerRadii.y * sinPhi[i2] * sinTheta[j];
        positions[index2++] = innerRadii.z * cosPhi[i2];
      }
    }
  }
  index2 = 0;
  for (i2 = 0; i2 < stackPartitions * vertexMultiplier; i2++) {
    const topOffset = i2 * subdivisions;
    for (j = 0; j < subdivisions - 1; j++) {
      indices2[index2++] = topOffset + j;
      indices2[index2++] = topOffset + j + 1;
    }
  }
  let offset2 = stackPartitions * subdivisions * vertexMultiplier;
  for (i2 = 0; i2 < slicePartitions; i2++) {
    for (j = 0; j < subdivisions - 1; j++) {
      indices2[index2++] = offset2 + i2 + j * slicePartitions;
      indices2[index2++] = offset2 + i2 + (j + 1) * slicePartitions;
    }
  }
  if (hasInnerSurface) {
    offset2 = stackPartitions * subdivisions * vertexMultiplier + slicePartitions * subdivisions;
    for (i2 = 0; i2 < slicePartitions; i2++) {
      for (j = 0; j < subdivisions - 1; j++) {
        indices2[index2++] = offset2 + i2 + j * slicePartitions;
        indices2[index2++] = offset2 + i2 + (j + 1) * slicePartitions;
      }
    }
  }
  if (hasInnerSurface) {
    let outerOffset = stackPartitions * subdivisions * vertexMultiplier;
    let innerOffset = outerOffset + subdivisions * slicePartitions;
    if (isTopOpen) {
      for (i2 = 0; i2 < slicePartitions; i2++) {
        indices2[index2++] = outerOffset + i2;
        indices2[index2++] = innerOffset + i2;
      }
    }
    if (isBotOpen) {
      outerOffset += subdivisions * slicePartitions - slicePartitions;
      innerOffset += subdivisions * slicePartitions - slicePartitions;
      for (i2 = 0; i2 < slicePartitions; i2++) {
        indices2[index2++] = outerOffset + i2;
        indices2[index2++] = innerOffset + i2;
      }
    }
  }
  const attributes = new GeometryAttributes_default({
    position: new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: positions
    })
  });
  if (defined_default(ellipsoidGeometry._offsetAttribute)) {
    const length3 = positions.length;
    const applyOffset = new Uint8Array(length3 / 3);
    const offsetValue = ellipsoidGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
    arrayFill_default(applyOffset, offsetValue);
    attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: applyOffset
    });
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere: BoundingSphere_default.fromEllipsoid(ellipsoid),
    offsetAttribute: ellipsoidGeometry._offsetAttribute
  });
};
var EllipsoidOutlineGeometry_default = EllipsoidOutlineGeometry;

// node_modules/cesium/Source/Core/EllipsoidTerrainProvider.js
function EllipsoidTerrainProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._tilingScheme = options.tilingScheme;
  if (!defined_default(this._tilingScheme)) {
    this._tilingScheme = new GeographicTilingScheme_default({
      ellipsoid: defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
    });
  }
  this._levelZeroMaximumGeometricError = TerrainProvider_default.getEstimatedLevelZeroGeometricErrorForAHeightmap(
    this._tilingScheme.ellipsoid,
    64,
    this._tilingScheme.getNumberOfXTilesAtLevel(0)
  );
  this._errorEvent = new Event_default();
  this._readyPromise = Promise.resolve(true);
}
Object.defineProperties(EllipsoidTerrainProvider.prototype, {
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  credit: {
    get: function() {
      return void 0;
    }
  },
  tilingScheme: {
    get: function() {
      return this._tilingScheme;
    }
  },
  ready: {
    get: function() {
      return true;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  hasWaterMask: {
    get: function() {
      return false;
    }
  },
  hasVertexNormals: {
    get: function() {
      return false;
    }
  },
  availability: {
    get: function() {
      return void 0;
    }
  }
});
EllipsoidTerrainProvider.prototype.requestTileGeometry = function(x, y, level, request) {
  const width = 16;
  const height = 16;
  return Promise.resolve(
    new HeightmapTerrainData_default({
      buffer: new Uint8Array(width * height),
      width,
      height
    })
  );
};
EllipsoidTerrainProvider.prototype.getLevelMaximumGeometricError = function(level) {
  return this._levelZeroMaximumGeometricError / (1 << level);
};
EllipsoidTerrainProvider.prototype.getTileDataAvailable = function(x, y, level) {
  return void 0;
};
EllipsoidTerrainProvider.prototype.loadTileDataAvailability = function(x, y, level) {
  return void 0;
};
var EllipsoidTerrainProvider_default = EllipsoidTerrainProvider;

// node_modules/cesium/Source/Core/EventHelper.js
function EventHelper() {
  this._removalFunctions = [];
}
EventHelper.prototype.add = function(event, listener, scope) {
  if (!defined_default(event)) {
    throw new DeveloperError_default("event is required");
  }
  const removalFunction = event.addEventListener(listener, scope);
  this._removalFunctions.push(removalFunction);
  const that = this;
  return function() {
    removalFunction();
    const removalFunctions = that._removalFunctions;
    removalFunctions.splice(removalFunctions.indexOf(removalFunction), 1);
  };
};
EventHelper.prototype.removeAll = function() {
  const removalFunctions = this._removalFunctions;
  for (let i2 = 0, len = removalFunctions.length; i2 < len; ++i2) {
    removalFunctions[i2]();
  }
  removalFunctions.length = 0;
};
var EventHelper_default = EventHelper;

// node_modules/cesium/Source/Core/ExperimentalFeatures.js
var ExperimentalFeatures = {
  enableModelExperimental: false
};
var ExperimentalFeatures_default = ExperimentalFeatures;

// node_modules/cesium/Source/Core/ExtrapolationType.js
var ExtrapolationType = {
  NONE: 0,
  HOLD: 1,
  EXTRAPOLATE: 2
};
var ExtrapolationType_default = Object.freeze(ExtrapolationType);

// node_modules/cesium/Source/Core/OrthographicOffCenterFrustum.js
function OrthographicOffCenterFrustum(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.left = options.left;
  this._left = void 0;
  this.right = options.right;
  this._right = void 0;
  this.top = options.top;
  this._top = void 0;
  this.bottom = options.bottom;
  this._bottom = void 0;
  this.near = defaultValue_default(options.near, 1);
  this._near = this.near;
  this.far = defaultValue_default(options.far, 5e8);
  this._far = this.far;
  this._cullingVolume = new CullingVolume_default();
  this._orthographicMatrix = new Matrix4_default();
}
function update(frustum) {
  if (!defined_default(frustum.right) || !defined_default(frustum.left) || !defined_default(frustum.top) || !defined_default(frustum.bottom) || !defined_default(frustum.near) || !defined_default(frustum.far)) {
    throw new DeveloperError_default(
      "right, left, top, bottom, near, or far parameters are not set."
    );
  }
  if (frustum.top !== frustum._top || frustum.bottom !== frustum._bottom || frustum.left !== frustum._left || frustum.right !== frustum._right || frustum.near !== frustum._near || frustum.far !== frustum._far) {
    if (frustum.left > frustum.right) {
      throw new DeveloperError_default("right must be greater than left.");
    }
    if (frustum.bottom > frustum.top) {
      throw new DeveloperError_default("top must be greater than bottom.");
    }
    if (frustum.near <= 0 || frustum.near > frustum.far) {
      throw new DeveloperError_default(
        "near must be greater than zero and less than far."
      );
    }
    frustum._left = frustum.left;
    frustum._right = frustum.right;
    frustum._top = frustum.top;
    frustum._bottom = frustum.bottom;
    frustum._near = frustum.near;
    frustum._far = frustum.far;
    frustum._orthographicMatrix = Matrix4_default.computeOrthographicOffCenter(
      frustum.left,
      frustum.right,
      frustum.bottom,
      frustum.top,
      frustum.near,
      frustum.far,
      frustum._orthographicMatrix
    );
  }
}
Object.defineProperties(OrthographicOffCenterFrustum.prototype, {
  projectionMatrix: {
    get: function() {
      update(this);
      return this._orthographicMatrix;
    }
  }
});
var getPlanesRight = new Cartesian3_default();
var getPlanesNearCenter = new Cartesian3_default();
var getPlanesPoint = new Cartesian3_default();
var negateScratch = new Cartesian3_default();
OrthographicOffCenterFrustum.prototype.computeCullingVolume = function(position, direction2, up) {
  if (!defined_default(position)) {
    throw new DeveloperError_default("position is required.");
  }
  if (!defined_default(direction2)) {
    throw new DeveloperError_default("direction is required.");
  }
  if (!defined_default(up)) {
    throw new DeveloperError_default("up is required.");
  }
  const planes = this._cullingVolume.planes;
  const t = this.top;
  const b = this.bottom;
  const r2 = this.right;
  const l2 = this.left;
  const n2 = this.near;
  const f2 = this.far;
  const right = Cartesian3_default.cross(direction2, up, getPlanesRight);
  Cartesian3_default.normalize(right, right);
  const nearCenter = getPlanesNearCenter;
  Cartesian3_default.multiplyByScalar(direction2, n2, nearCenter);
  Cartesian3_default.add(position, nearCenter, nearCenter);
  const point = getPlanesPoint;
  Cartesian3_default.multiplyByScalar(right, l2, point);
  Cartesian3_default.add(nearCenter, point, point);
  let plane = planes[0];
  if (!defined_default(plane)) {
    plane = planes[0] = new Cartesian4_default();
  }
  plane.x = right.x;
  plane.y = right.y;
  plane.z = right.z;
  plane.w = -Cartesian3_default.dot(right, point);
  Cartesian3_default.multiplyByScalar(right, r2, point);
  Cartesian3_default.add(nearCenter, point, point);
  plane = planes[1];
  if (!defined_default(plane)) {
    plane = planes[1] = new Cartesian4_default();
  }
  plane.x = -right.x;
  plane.y = -right.y;
  plane.z = -right.z;
  plane.w = -Cartesian3_default.dot(Cartesian3_default.negate(right, negateScratch), point);
  Cartesian3_default.multiplyByScalar(up, b, point);
  Cartesian3_default.add(nearCenter, point, point);
  plane = planes[2];
  if (!defined_default(plane)) {
    plane = planes[2] = new Cartesian4_default();
  }
  plane.x = up.x;
  plane.y = up.y;
  plane.z = up.z;
  plane.w = -Cartesian3_default.dot(up, point);
  Cartesian3_default.multiplyByScalar(up, t, point);
  Cartesian3_default.add(nearCenter, point, point);
  plane = planes[3];
  if (!defined_default(plane)) {
    plane = planes[3] = new Cartesian4_default();
  }
  plane.x = -up.x;
  plane.y = -up.y;
  plane.z = -up.z;
  plane.w = -Cartesian3_default.dot(Cartesian3_default.negate(up, negateScratch), point);
  plane = planes[4];
  if (!defined_default(plane)) {
    plane = planes[4] = new Cartesian4_default();
  }
  plane.x = direction2.x;
  plane.y = direction2.y;
  plane.z = direction2.z;
  plane.w = -Cartesian3_default.dot(direction2, nearCenter);
  Cartesian3_default.multiplyByScalar(direction2, f2, point);
  Cartesian3_default.add(position, point, point);
  plane = planes[5];
  if (!defined_default(plane)) {
    plane = planes[5] = new Cartesian4_default();
  }
  plane.x = -direction2.x;
  plane.y = -direction2.y;
  plane.z = -direction2.z;
  plane.w = -Cartesian3_default.dot(Cartesian3_default.negate(direction2, negateScratch), point);
  return this._cullingVolume;
};
OrthographicOffCenterFrustum.prototype.getPixelDimensions = function(drawingBufferWidth, drawingBufferHeight, distance2, pixelRatio, result) {
  update(this);
  if (!defined_default(drawingBufferWidth) || !defined_default(drawingBufferHeight)) {
    throw new DeveloperError_default(
      "Both drawingBufferWidth and drawingBufferHeight are required."
    );
  }
  if (drawingBufferWidth <= 0) {
    throw new DeveloperError_default("drawingBufferWidth must be greater than zero.");
  }
  if (drawingBufferHeight <= 0) {
    throw new DeveloperError_default("drawingBufferHeight must be greater than zero.");
  }
  if (!defined_default(distance2)) {
    throw new DeveloperError_default("distance is required.");
  }
  if (!defined_default(pixelRatio)) {
    throw new DeveloperError_default("pixelRatio is required.");
  }
  if (pixelRatio <= 0) {
    throw new DeveloperError_default("pixelRatio must be greater than zero.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("A result object is required.");
  }
  const frustumWidth = this.right - this.left;
  const frustumHeight = this.top - this.bottom;
  const pixelWidth = pixelRatio * frustumWidth / drawingBufferWidth;
  const pixelHeight = pixelRatio * frustumHeight / drawingBufferHeight;
  result.x = pixelWidth;
  result.y = pixelHeight;
  return result;
};
OrthographicOffCenterFrustum.prototype.clone = function(result) {
  if (!defined_default(result)) {
    result = new OrthographicOffCenterFrustum();
  }
  result.left = this.left;
  result.right = this.right;
  result.top = this.top;
  result.bottom = this.bottom;
  result.near = this.near;
  result.far = this.far;
  result._left = void 0;
  result._right = void 0;
  result._top = void 0;
  result._bottom = void 0;
  result._near = void 0;
  result._far = void 0;
  return result;
};
OrthographicOffCenterFrustum.prototype.equals = function(other) {
  return defined_default(other) && other instanceof OrthographicOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;
};
OrthographicOffCenterFrustum.prototype.equalsEpsilon = function(other, relativeEpsilon, absoluteEpsilon) {
  return other === this || defined_default(other) && other instanceof OrthographicOffCenterFrustum && Math_default.equalsEpsilon(
    this.right,
    other.right,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.left,
    other.left,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.top,
    other.top,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.bottom,
    other.bottom,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.near,
    other.near,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.far,
    other.far,
    relativeEpsilon,
    absoluteEpsilon
  );
};
var OrthographicOffCenterFrustum_default = OrthographicOffCenterFrustum;

// node_modules/cesium/Source/Core/OrthographicFrustum.js
function OrthographicFrustum(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._offCenterFrustum = new OrthographicOffCenterFrustum_default();
  this.width = options.width;
  this._width = void 0;
  this.aspectRatio = options.aspectRatio;
  this._aspectRatio = void 0;
  this.near = defaultValue_default(options.near, 1);
  this._near = this.near;
  this.far = defaultValue_default(options.far, 5e8);
  this._far = this.far;
}
OrthographicFrustum.packedLength = 4;
OrthographicFrustum.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.width;
  array[startingIndex++] = value.aspectRatio;
  array[startingIndex++] = value.near;
  array[startingIndex] = value.far;
  return array;
};
OrthographicFrustum.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new OrthographicFrustum();
  }
  result.width = array[startingIndex++];
  result.aspectRatio = array[startingIndex++];
  result.near = array[startingIndex++];
  result.far = array[startingIndex];
  return result;
};
function update2(frustum) {
  if (!defined_default(frustum.width) || !defined_default(frustum.aspectRatio) || !defined_default(frustum.near) || !defined_default(frustum.far)) {
    throw new DeveloperError_default(
      "width, aspectRatio, near, or far parameters are not set."
    );
  }
  const f2 = frustum._offCenterFrustum;
  if (frustum.width !== frustum._width || frustum.aspectRatio !== frustum._aspectRatio || frustum.near !== frustum._near || frustum.far !== frustum._far) {
    if (frustum.aspectRatio < 0) {
      throw new DeveloperError_default("aspectRatio must be positive.");
    }
    if (frustum.near < 0 || frustum.near > frustum.far) {
      throw new DeveloperError_default(
        "near must be greater than zero and less than far."
      );
    }
    frustum._aspectRatio = frustum.aspectRatio;
    frustum._width = frustum.width;
    frustum._near = frustum.near;
    frustum._far = frustum.far;
    const ratio = 1 / frustum.aspectRatio;
    f2.right = frustum.width * 0.5;
    f2.left = -f2.right;
    f2.top = ratio * f2.right;
    f2.bottom = -f2.top;
    f2.near = frustum.near;
    f2.far = frustum.far;
  }
}
Object.defineProperties(OrthographicFrustum.prototype, {
  projectionMatrix: {
    get: function() {
      update2(this);
      return this._offCenterFrustum.projectionMatrix;
    }
  }
});
OrthographicFrustum.prototype.computeCullingVolume = function(position, direction2, up) {
  update2(this);
  return this._offCenterFrustum.computeCullingVolume(position, direction2, up);
};
OrthographicFrustum.prototype.getPixelDimensions = function(drawingBufferWidth, drawingBufferHeight, distance2, pixelRatio, result) {
  update2(this);
  return this._offCenterFrustum.getPixelDimensions(
    drawingBufferWidth,
    drawingBufferHeight,
    distance2,
    pixelRatio,
    result
  );
};
OrthographicFrustum.prototype.clone = function(result) {
  if (!defined_default(result)) {
    result = new OrthographicFrustum();
  }
  result.aspectRatio = this.aspectRatio;
  result.width = this.width;
  result.near = this.near;
  result.far = this.far;
  result._aspectRatio = void 0;
  result._width = void 0;
  result._near = void 0;
  result._far = void 0;
  this._offCenterFrustum.clone(result._offCenterFrustum);
  return result;
};
OrthographicFrustum.prototype.equals = function(other) {
  if (!defined_default(other) || !(other instanceof OrthographicFrustum)) {
    return false;
  }
  update2(this);
  update2(other);
  return this.width === other.width && this.aspectRatio === other.aspectRatio && this._offCenterFrustum.equals(other._offCenterFrustum);
};
OrthographicFrustum.prototype.equalsEpsilon = function(other, relativeEpsilon, absoluteEpsilon) {
  if (!defined_default(other) || !(other instanceof OrthographicFrustum)) {
    return false;
  }
  update2(this);
  update2(other);
  return Math_default.equalsEpsilon(
    this.width,
    other.width,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.aspectRatio,
    other.aspectRatio,
    relativeEpsilon,
    absoluteEpsilon
  ) && this._offCenterFrustum.equalsEpsilon(
    other._offCenterFrustum,
    relativeEpsilon,
    absoluteEpsilon
  );
};
var OrthographicFrustum_default = OrthographicFrustum;

// node_modules/cesium/Source/Core/PerspectiveOffCenterFrustum.js
function PerspectiveOffCenterFrustum(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.left = options.left;
  this._left = void 0;
  this.right = options.right;
  this._right = void 0;
  this.top = options.top;
  this._top = void 0;
  this.bottom = options.bottom;
  this._bottom = void 0;
  this.near = defaultValue_default(options.near, 1);
  this._near = this.near;
  this.far = defaultValue_default(options.far, 5e8);
  this._far = this.far;
  this._cullingVolume = new CullingVolume_default();
  this._perspectiveMatrix = new Matrix4_default();
  this._infinitePerspective = new Matrix4_default();
}
function update3(frustum) {
  if (!defined_default(frustum.right) || !defined_default(frustum.left) || !defined_default(frustum.top) || !defined_default(frustum.bottom) || !defined_default(frustum.near) || !defined_default(frustum.far)) {
    throw new DeveloperError_default(
      "right, left, top, bottom, near, or far parameters are not set."
    );
  }
  const t = frustum.top;
  const b = frustum.bottom;
  const r2 = frustum.right;
  const l2 = frustum.left;
  const n2 = frustum.near;
  const f2 = frustum.far;
  if (t !== frustum._top || b !== frustum._bottom || l2 !== frustum._left || r2 !== frustum._right || n2 !== frustum._near || f2 !== frustum._far) {
    if (frustum.near <= 0 || frustum.near > frustum.far) {
      throw new DeveloperError_default(
        "near must be greater than zero and less than far."
      );
    }
    frustum._left = l2;
    frustum._right = r2;
    frustum._top = t;
    frustum._bottom = b;
    frustum._near = n2;
    frustum._far = f2;
    frustum._perspectiveMatrix = Matrix4_default.computePerspectiveOffCenter(
      l2,
      r2,
      b,
      t,
      n2,
      f2,
      frustum._perspectiveMatrix
    );
    frustum._infinitePerspective = Matrix4_default.computeInfinitePerspectiveOffCenter(
      l2,
      r2,
      b,
      t,
      n2,
      frustum._infinitePerspective
    );
  }
}
Object.defineProperties(PerspectiveOffCenterFrustum.prototype, {
  projectionMatrix: {
    get: function() {
      update3(this);
      return this._perspectiveMatrix;
    }
  },
  infiniteProjectionMatrix: {
    get: function() {
      update3(this);
      return this._infinitePerspective;
    }
  }
});
var getPlanesRight2 = new Cartesian3_default();
var getPlanesNearCenter2 = new Cartesian3_default();
var getPlanesFarCenter = new Cartesian3_default();
var getPlanesNormal = new Cartesian3_default();
PerspectiveOffCenterFrustum.prototype.computeCullingVolume = function(position, direction2, up) {
  if (!defined_default(position)) {
    throw new DeveloperError_default("position is required.");
  }
  if (!defined_default(direction2)) {
    throw new DeveloperError_default("direction is required.");
  }
  if (!defined_default(up)) {
    throw new DeveloperError_default("up is required.");
  }
  const planes = this._cullingVolume.planes;
  const t = this.top;
  const b = this.bottom;
  const r2 = this.right;
  const l2 = this.left;
  const n2 = this.near;
  const f2 = this.far;
  const right = Cartesian3_default.cross(direction2, up, getPlanesRight2);
  const nearCenter = getPlanesNearCenter2;
  Cartesian3_default.multiplyByScalar(direction2, n2, nearCenter);
  Cartesian3_default.add(position, nearCenter, nearCenter);
  const farCenter = getPlanesFarCenter;
  Cartesian3_default.multiplyByScalar(direction2, f2, farCenter);
  Cartesian3_default.add(position, farCenter, farCenter);
  const normal2 = getPlanesNormal;
  Cartesian3_default.multiplyByScalar(right, l2, normal2);
  Cartesian3_default.add(nearCenter, normal2, normal2);
  Cartesian3_default.subtract(normal2, position, normal2);
  Cartesian3_default.normalize(normal2, normal2);
  Cartesian3_default.cross(normal2, up, normal2);
  Cartesian3_default.normalize(normal2, normal2);
  let plane = planes[0];
  if (!defined_default(plane)) {
    plane = planes[0] = new Cartesian4_default();
  }
  plane.x = normal2.x;
  plane.y = normal2.y;
  plane.z = normal2.z;
  plane.w = -Cartesian3_default.dot(normal2, position);
  Cartesian3_default.multiplyByScalar(right, r2, normal2);
  Cartesian3_default.add(nearCenter, normal2, normal2);
  Cartesian3_default.subtract(normal2, position, normal2);
  Cartesian3_default.cross(up, normal2, normal2);
  Cartesian3_default.normalize(normal2, normal2);
  plane = planes[1];
  if (!defined_default(plane)) {
    plane = planes[1] = new Cartesian4_default();
  }
  plane.x = normal2.x;
  plane.y = normal2.y;
  plane.z = normal2.z;
  plane.w = -Cartesian3_default.dot(normal2, position);
  Cartesian3_default.multiplyByScalar(up, b, normal2);
  Cartesian3_default.add(nearCenter, normal2, normal2);
  Cartesian3_default.subtract(normal2, position, normal2);
  Cartesian3_default.cross(right, normal2, normal2);
  Cartesian3_default.normalize(normal2, normal2);
  plane = planes[2];
  if (!defined_default(plane)) {
    plane = planes[2] = new Cartesian4_default();
  }
  plane.x = normal2.x;
  plane.y = normal2.y;
  plane.z = normal2.z;
  plane.w = -Cartesian3_default.dot(normal2, position);
  Cartesian3_default.multiplyByScalar(up, t, normal2);
  Cartesian3_default.add(nearCenter, normal2, normal2);
  Cartesian3_default.subtract(normal2, position, normal2);
  Cartesian3_default.cross(normal2, right, normal2);
  Cartesian3_default.normalize(normal2, normal2);
  plane = planes[3];
  if (!defined_default(plane)) {
    plane = planes[3] = new Cartesian4_default();
  }
  plane.x = normal2.x;
  plane.y = normal2.y;
  plane.z = normal2.z;
  plane.w = -Cartesian3_default.dot(normal2, position);
  plane = planes[4];
  if (!defined_default(plane)) {
    plane = planes[4] = new Cartesian4_default();
  }
  plane.x = direction2.x;
  plane.y = direction2.y;
  plane.z = direction2.z;
  plane.w = -Cartesian3_default.dot(direction2, nearCenter);
  Cartesian3_default.negate(direction2, normal2);
  plane = planes[5];
  if (!defined_default(plane)) {
    plane = planes[5] = new Cartesian4_default();
  }
  plane.x = normal2.x;
  plane.y = normal2.y;
  plane.z = normal2.z;
  plane.w = -Cartesian3_default.dot(normal2, farCenter);
  return this._cullingVolume;
};
PerspectiveOffCenterFrustum.prototype.getPixelDimensions = function(drawingBufferWidth, drawingBufferHeight, distance2, pixelRatio, result) {
  update3(this);
  if (!defined_default(drawingBufferWidth) || !defined_default(drawingBufferHeight)) {
    throw new DeveloperError_default(
      "Both drawingBufferWidth and drawingBufferHeight are required."
    );
  }
  if (drawingBufferWidth <= 0) {
    throw new DeveloperError_default("drawingBufferWidth must be greater than zero.");
  }
  if (drawingBufferHeight <= 0) {
    throw new DeveloperError_default("drawingBufferHeight must be greater than zero.");
  }
  if (!defined_default(distance2)) {
    throw new DeveloperError_default("distance is required.");
  }
  if (!defined_default(pixelRatio)) {
    throw new DeveloperError_default("pixelRatio is required");
  }
  if (pixelRatio <= 0) {
    throw new DeveloperError_default("pixelRatio must be greater than zero.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("A result object is required.");
  }
  const inverseNear = 1 / this.near;
  let tanTheta = this.top * inverseNear;
  const pixelHeight = 2 * pixelRatio * distance2 * tanTheta / drawingBufferHeight;
  tanTheta = this.right * inverseNear;
  const pixelWidth = 2 * pixelRatio * distance2 * tanTheta / drawingBufferWidth;
  result.x = pixelWidth;
  result.y = pixelHeight;
  return result;
};
PerspectiveOffCenterFrustum.prototype.clone = function(result) {
  if (!defined_default(result)) {
    result = new PerspectiveOffCenterFrustum();
  }
  result.right = this.right;
  result.left = this.left;
  result.top = this.top;
  result.bottom = this.bottom;
  result.near = this.near;
  result.far = this.far;
  result._left = void 0;
  result._right = void 0;
  result._top = void 0;
  result._bottom = void 0;
  result._near = void 0;
  result._far = void 0;
  return result;
};
PerspectiveOffCenterFrustum.prototype.equals = function(other) {
  return defined_default(other) && other instanceof PerspectiveOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;
};
PerspectiveOffCenterFrustum.prototype.equalsEpsilon = function(other, relativeEpsilon, absoluteEpsilon) {
  return other === this || defined_default(other) && other instanceof PerspectiveOffCenterFrustum && Math_default.equalsEpsilon(
    this.right,
    other.right,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.left,
    other.left,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.top,
    other.top,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.bottom,
    other.bottom,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.near,
    other.near,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.far,
    other.far,
    relativeEpsilon,
    absoluteEpsilon
  );
};
var PerspectiveOffCenterFrustum_default = PerspectiveOffCenterFrustum;

// node_modules/cesium/Source/Core/PerspectiveFrustum.js
function PerspectiveFrustum(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._offCenterFrustum = new PerspectiveOffCenterFrustum_default();
  this.fov = options.fov;
  this._fov = void 0;
  this._fovy = void 0;
  this._sseDenominator = void 0;
  this.aspectRatio = options.aspectRatio;
  this._aspectRatio = void 0;
  this.near = defaultValue_default(options.near, 1);
  this._near = this.near;
  this.far = defaultValue_default(options.far, 5e8);
  this._far = this.far;
  this.xOffset = defaultValue_default(options.xOffset, 0);
  this._xOffset = this.xOffset;
  this.yOffset = defaultValue_default(options.yOffset, 0);
  this._yOffset = this.yOffset;
}
PerspectiveFrustum.packedLength = 6;
PerspectiveFrustum.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.fov;
  array[startingIndex++] = value.aspectRatio;
  array[startingIndex++] = value.near;
  array[startingIndex++] = value.far;
  array[startingIndex++] = value.xOffset;
  array[startingIndex] = value.yOffset;
  return array;
};
PerspectiveFrustum.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new PerspectiveFrustum();
  }
  result.fov = array[startingIndex++];
  result.aspectRatio = array[startingIndex++];
  result.near = array[startingIndex++];
  result.far = array[startingIndex++];
  result.xOffset = array[startingIndex++];
  result.yOffset = array[startingIndex];
  return result;
};
function update4(frustum) {
  if (!defined_default(frustum.fov) || !defined_default(frustum.aspectRatio) || !defined_default(frustum.near) || !defined_default(frustum.far)) {
    throw new DeveloperError_default(
      "fov, aspectRatio, near, or far parameters are not set."
    );
  }
  const f2 = frustum._offCenterFrustum;
  if (frustum.fov !== frustum._fov || frustum.aspectRatio !== frustum._aspectRatio || frustum.near !== frustum._near || frustum.far !== frustum._far || frustum.xOffset !== frustum._xOffset || frustum.yOffset !== frustum._yOffset) {
    if (frustum.fov < 0 || frustum.fov >= Math.PI) {
      throw new DeveloperError_default("fov must be in the range [0, PI).");
    }
    if (frustum.aspectRatio < 0) {
      throw new DeveloperError_default("aspectRatio must be positive.");
    }
    if (frustum.near < 0 || frustum.near > frustum.far) {
      throw new DeveloperError_default(
        "near must be greater than zero and less than far."
      );
    }
    frustum._aspectRatio = frustum.aspectRatio;
    frustum._fov = frustum.fov;
    frustum._fovy = frustum.aspectRatio <= 1 ? frustum.fov : Math.atan(Math.tan(frustum.fov * 0.5) / frustum.aspectRatio) * 2;
    frustum._near = frustum.near;
    frustum._far = frustum.far;
    frustum._sseDenominator = 2 * Math.tan(0.5 * frustum._fovy);
    frustum._xOffset = frustum.xOffset;
    frustum._yOffset = frustum.yOffset;
    f2.top = frustum.near * Math.tan(0.5 * frustum._fovy);
    f2.bottom = -f2.top;
    f2.right = frustum.aspectRatio * f2.top;
    f2.left = -f2.right;
    f2.near = frustum.near;
    f2.far = frustum.far;
    f2.right += frustum.xOffset;
    f2.left += frustum.xOffset;
    f2.top += frustum.yOffset;
    f2.bottom += frustum.yOffset;
  }
}
Object.defineProperties(PerspectiveFrustum.prototype, {
  projectionMatrix: {
    get: function() {
      update4(this);
      return this._offCenterFrustum.projectionMatrix;
    }
  },
  infiniteProjectionMatrix: {
    get: function() {
      update4(this);
      return this._offCenterFrustum.infiniteProjectionMatrix;
    }
  },
  fovy: {
    get: function() {
      update4(this);
      return this._fovy;
    }
  },
  sseDenominator: {
    get: function() {
      update4(this);
      return this._sseDenominator;
    }
  }
});
PerspectiveFrustum.prototype.computeCullingVolume = function(position, direction2, up) {
  update4(this);
  return this._offCenterFrustum.computeCullingVolume(position, direction2, up);
};
PerspectiveFrustum.prototype.getPixelDimensions = function(drawingBufferWidth, drawingBufferHeight, distance2, pixelRatio, result) {
  update4(this);
  return this._offCenterFrustum.getPixelDimensions(
    drawingBufferWidth,
    drawingBufferHeight,
    distance2,
    pixelRatio,
    result
  );
};
PerspectiveFrustum.prototype.clone = function(result) {
  if (!defined_default(result)) {
    result = new PerspectiveFrustum();
  }
  result.aspectRatio = this.aspectRatio;
  result.fov = this.fov;
  result.near = this.near;
  result.far = this.far;
  result._aspectRatio = void 0;
  result._fov = void 0;
  result._near = void 0;
  result._far = void 0;
  this._offCenterFrustum.clone(result._offCenterFrustum);
  return result;
};
PerspectiveFrustum.prototype.equals = function(other) {
  if (!defined_default(other) || !(other instanceof PerspectiveFrustum)) {
    return false;
  }
  update4(this);
  update4(other);
  return this.fov === other.fov && this.aspectRatio === other.aspectRatio && this._offCenterFrustum.equals(other._offCenterFrustum);
};
PerspectiveFrustum.prototype.equalsEpsilon = function(other, relativeEpsilon, absoluteEpsilon) {
  if (!defined_default(other) || !(other instanceof PerspectiveFrustum)) {
    return false;
  }
  update4(this);
  update4(other);
  return Math_default.equalsEpsilon(
    this.fov,
    other.fov,
    relativeEpsilon,
    absoluteEpsilon
  ) && Math_default.equalsEpsilon(
    this.aspectRatio,
    other.aspectRatio,
    relativeEpsilon,
    absoluteEpsilon
  ) && this._offCenterFrustum.equalsEpsilon(
    other._offCenterFrustum,
    relativeEpsilon,
    absoluteEpsilon
  );
};
var PerspectiveFrustum_default = PerspectiveFrustum;

// node_modules/cesium/Source/Core/FrustumGeometry.js
var PERSPECTIVE = 0;
var ORTHOGRAPHIC = 1;
function FrustumGeometry(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.object("options.frustum", options.frustum);
  Check_default.typeOf.object("options.origin", options.origin);
  Check_default.typeOf.object("options.orientation", options.orientation);
  const frustum = options.frustum;
  const orientation = options.orientation;
  const origin = options.origin;
  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
  const drawNearPlane = defaultValue_default(options._drawNearPlane, true);
  let frustumType;
  let frustumPackedLength;
  if (frustum instanceof PerspectiveFrustum_default) {
    frustumType = PERSPECTIVE;
    frustumPackedLength = PerspectiveFrustum_default.packedLength;
  } else if (frustum instanceof OrthographicFrustum_default) {
    frustumType = ORTHOGRAPHIC;
    frustumPackedLength = OrthographicFrustum_default.packedLength;
  }
  this._frustumType = frustumType;
  this._frustum = frustum.clone();
  this._origin = Cartesian3_default.clone(origin);
  this._orientation = Quaternion_default.clone(orientation);
  this._drawNearPlane = drawNearPlane;
  this._vertexFormat = vertexFormat;
  this._workerName = "createFrustumGeometry";
  this.packedLength = 2 + frustumPackedLength + Cartesian3_default.packedLength + Quaternion_default.packedLength + VertexFormat_default.packedLength;
}
FrustumGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const frustumType = value._frustumType;
  const frustum = value._frustum;
  array[startingIndex++] = frustumType;
  if (frustumType === PERSPECTIVE) {
    PerspectiveFrustum_default.pack(frustum, array, startingIndex);
    startingIndex += PerspectiveFrustum_default.packedLength;
  } else {
    OrthographicFrustum_default.pack(frustum, array, startingIndex);
    startingIndex += OrthographicFrustum_default.packedLength;
  }
  Cartesian3_default.pack(value._origin, array, startingIndex);
  startingIndex += Cartesian3_default.packedLength;
  Quaternion_default.pack(value._orientation, array, startingIndex);
  startingIndex += Quaternion_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex] = value._drawNearPlane ? 1 : 0;
  return array;
};
var scratchPackPerspective = new PerspectiveFrustum_default();
var scratchPackOrthographic = new OrthographicFrustum_default();
var scratchPackQuaternion = new Quaternion_default();
var scratchPackorigin = new Cartesian3_default();
var scratchVertexFormat7 = new VertexFormat_default();
FrustumGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const frustumType = array[startingIndex++];
  let frustum;
  if (frustumType === PERSPECTIVE) {
    frustum = PerspectiveFrustum_default.unpack(
      array,
      startingIndex,
      scratchPackPerspective
    );
    startingIndex += PerspectiveFrustum_default.packedLength;
  } else {
    frustum = OrthographicFrustum_default.unpack(
      array,
      startingIndex,
      scratchPackOrthographic
    );
    startingIndex += OrthographicFrustum_default.packedLength;
  }
  const origin = Cartesian3_default.unpack(array, startingIndex, scratchPackorigin);
  startingIndex += Cartesian3_default.packedLength;
  const orientation = Quaternion_default.unpack(
    array,
    startingIndex,
    scratchPackQuaternion
  );
  startingIndex += Quaternion_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat7
  );
  startingIndex += VertexFormat_default.packedLength;
  const drawNearPlane = array[startingIndex] === 1;
  if (!defined_default(result)) {
    return new FrustumGeometry({
      frustum,
      origin,
      orientation,
      vertexFormat,
      _drawNearPlane: drawNearPlane
    });
  }
  const frustumResult = frustumType === result._frustumType ? result._frustum : void 0;
  result._frustum = frustum.clone(frustumResult);
  result._frustumType = frustumType;
  result._origin = Cartesian3_default.clone(origin, result._origin);
  result._orientation = Quaternion_default.clone(orientation, result._orientation);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._drawNearPlane = drawNearPlane;
  return result;
};
function getAttributes(offset2, normals, tangents, bitangents, st, normal2, tangent, bitangent) {
  const stOffset = offset2 / 3 * 2;
  for (let i2 = 0; i2 < 4; ++i2) {
    if (defined_default(normals)) {
      normals[offset2] = normal2.x;
      normals[offset2 + 1] = normal2.y;
      normals[offset2 + 2] = normal2.z;
    }
    if (defined_default(tangents)) {
      tangents[offset2] = tangent.x;
      tangents[offset2 + 1] = tangent.y;
      tangents[offset2 + 2] = tangent.z;
    }
    if (defined_default(bitangents)) {
      bitangents[offset2] = bitangent.x;
      bitangents[offset2 + 1] = bitangent.y;
      bitangents[offset2 + 2] = bitangent.z;
    }
    offset2 += 3;
  }
  st[stOffset] = 0;
  st[stOffset + 1] = 0;
  st[stOffset + 2] = 1;
  st[stOffset + 3] = 0;
  st[stOffset + 4] = 1;
  st[stOffset + 5] = 1;
  st[stOffset + 6] = 0;
  st[stOffset + 7] = 1;
}
var scratchRotationMatrix = new Matrix3_default();
var scratchViewMatrix = new Matrix4_default();
var scratchInverseMatrix = new Matrix4_default();
var scratchXDirection = new Cartesian3_default();
var scratchYDirection = new Cartesian3_default();
var scratchZDirection = new Cartesian3_default();
var scratchNegativeX = new Cartesian3_default();
var scratchNegativeY = new Cartesian3_default();
var scratchNegativeZ = new Cartesian3_default();
var frustumSplits = new Array(3);
var frustumCornersNDC = new Array(4);
frustumCornersNDC[0] = new Cartesian4_default(-1, -1, 1, 1);
frustumCornersNDC[1] = new Cartesian4_default(1, -1, 1, 1);
frustumCornersNDC[2] = new Cartesian4_default(1, 1, 1, 1);
frustumCornersNDC[3] = new Cartesian4_default(-1, 1, 1, 1);
var scratchFrustumCorners = new Array(4);
for (let i2 = 0; i2 < 4; ++i2) {
  scratchFrustumCorners[i2] = new Cartesian4_default();
}
FrustumGeometry._computeNearFarPlanes = function(origin, orientation, frustumType, frustum, positions, xDirection, yDirection, zDirection) {
  const rotationMatrix = Matrix3_default.fromQuaternion(
    orientation,
    scratchRotationMatrix
  );
  let x = defaultValue_default(xDirection, scratchXDirection);
  let y = defaultValue_default(yDirection, scratchYDirection);
  let z = defaultValue_default(zDirection, scratchZDirection);
  x = Matrix3_default.getColumn(rotationMatrix, 0, x);
  y = Matrix3_default.getColumn(rotationMatrix, 1, y);
  z = Matrix3_default.getColumn(rotationMatrix, 2, z);
  Cartesian3_default.normalize(x, x);
  Cartesian3_default.normalize(y, y);
  Cartesian3_default.normalize(z, z);
  Cartesian3_default.negate(x, x);
  const view = Matrix4_default.computeView(origin, z, y, x, scratchViewMatrix);
  let inverseView;
  let inverseViewProjection;
  if (frustumType === PERSPECTIVE) {
    const projection = frustum.projectionMatrix;
    const viewProjection = Matrix4_default.multiply(
      projection,
      view,
      scratchInverseMatrix
    );
    inverseViewProjection = Matrix4_default.inverse(
      viewProjection,
      scratchInverseMatrix
    );
  } else {
    inverseView = Matrix4_default.inverseTransformation(view, scratchInverseMatrix);
  }
  if (defined_default(inverseViewProjection)) {
    frustumSplits[0] = frustum.near;
    frustumSplits[1] = frustum.far;
  } else {
    frustumSplits[0] = 0;
    frustumSplits[1] = frustum.near;
    frustumSplits[2] = frustum.far;
  }
  for (let i2 = 0; i2 < 2; ++i2) {
    for (let j = 0; j < 4; ++j) {
      let corner = Cartesian4_default.clone(
        frustumCornersNDC[j],
        scratchFrustumCorners[j]
      );
      if (!defined_default(inverseViewProjection)) {
        if (defined_default(frustum._offCenterFrustum)) {
          frustum = frustum._offCenterFrustum;
        }
        const near = frustumSplits[i2];
        const far = frustumSplits[i2 + 1];
        corner.x = (corner.x * (frustum.right - frustum.left) + frustum.left + frustum.right) * 0.5;
        corner.y = (corner.y * (frustum.top - frustum.bottom) + frustum.bottom + frustum.top) * 0.5;
        corner.z = (corner.z * (near - far) - near - far) * 0.5;
        corner.w = 1;
        Matrix4_default.multiplyByVector(inverseView, corner, corner);
      } else {
        corner = Matrix4_default.multiplyByVector(
          inverseViewProjection,
          corner,
          corner
        );
        const w = 1 / corner.w;
        Cartesian3_default.multiplyByScalar(corner, w, corner);
        Cartesian3_default.subtract(corner, origin, corner);
        Cartesian3_default.normalize(corner, corner);
        const fac = Cartesian3_default.dot(z, corner);
        Cartesian3_default.multiplyByScalar(corner, frustumSplits[i2] / fac, corner);
        Cartesian3_default.add(corner, origin, corner);
      }
      positions[12 * i2 + j * 3] = corner.x;
      positions[12 * i2 + j * 3 + 1] = corner.y;
      positions[12 * i2 + j * 3 + 2] = corner.z;
    }
  }
};
FrustumGeometry.createGeometry = function(frustumGeometry) {
  const frustumType = frustumGeometry._frustumType;
  const frustum = frustumGeometry._frustum;
  const origin = frustumGeometry._origin;
  const orientation = frustumGeometry._orientation;
  const drawNearPlane = frustumGeometry._drawNearPlane;
  const vertexFormat = frustumGeometry._vertexFormat;
  const numberOfPlanes = drawNearPlane ? 6 : 5;
  let positions = new Float64Array(3 * 4 * 6);
  FrustumGeometry._computeNearFarPlanes(
    origin,
    orientation,
    frustumType,
    frustum,
    positions
  );
  let offset2 = 3 * 4 * 2;
  positions[offset2] = positions[3 * 4];
  positions[offset2 + 1] = positions[3 * 4 + 1];
  positions[offset2 + 2] = positions[3 * 4 + 2];
  positions[offset2 + 3] = positions[0];
  positions[offset2 + 4] = positions[1];
  positions[offset2 + 5] = positions[2];
  positions[offset2 + 6] = positions[3 * 3];
  positions[offset2 + 7] = positions[3 * 3 + 1];
  positions[offset2 + 8] = positions[3 * 3 + 2];
  positions[offset2 + 9] = positions[3 * 7];
  positions[offset2 + 10] = positions[3 * 7 + 1];
  positions[offset2 + 11] = positions[3 * 7 + 2];
  offset2 += 3 * 4;
  positions[offset2] = positions[3 * 5];
  positions[offset2 + 1] = positions[3 * 5 + 1];
  positions[offset2 + 2] = positions[3 * 5 + 2];
  positions[offset2 + 3] = positions[3];
  positions[offset2 + 4] = positions[3 + 1];
  positions[offset2 + 5] = positions[3 + 2];
  positions[offset2 + 6] = positions[0];
  positions[offset2 + 7] = positions[1];
  positions[offset2 + 8] = positions[2];
  positions[offset2 + 9] = positions[3 * 4];
  positions[offset2 + 10] = positions[3 * 4 + 1];
  positions[offset2 + 11] = positions[3 * 4 + 2];
  offset2 += 3 * 4;
  positions[offset2] = positions[3];
  positions[offset2 + 1] = positions[3 + 1];
  positions[offset2 + 2] = positions[3 + 2];
  positions[offset2 + 3] = positions[3 * 5];
  positions[offset2 + 4] = positions[3 * 5 + 1];
  positions[offset2 + 5] = positions[3 * 5 + 2];
  positions[offset2 + 6] = positions[3 * 6];
  positions[offset2 + 7] = positions[3 * 6 + 1];
  positions[offset2 + 8] = positions[3 * 6 + 2];
  positions[offset2 + 9] = positions[3 * 2];
  positions[offset2 + 10] = positions[3 * 2 + 1];
  positions[offset2 + 11] = positions[3 * 2 + 2];
  offset2 += 3 * 4;
  positions[offset2] = positions[3 * 2];
  positions[offset2 + 1] = positions[3 * 2 + 1];
  positions[offset2 + 2] = positions[3 * 2 + 2];
  positions[offset2 + 3] = positions[3 * 6];
  positions[offset2 + 4] = positions[3 * 6 + 1];
  positions[offset2 + 5] = positions[3 * 6 + 2];
  positions[offset2 + 6] = positions[3 * 7];
  positions[offset2 + 7] = positions[3 * 7 + 1];
  positions[offset2 + 8] = positions[3 * 7 + 2];
  positions[offset2 + 9] = positions[3 * 3];
  positions[offset2 + 10] = positions[3 * 3 + 1];
  positions[offset2 + 11] = positions[3 * 3 + 2];
  if (!drawNearPlane) {
    positions = positions.subarray(3 * 4);
  }
  const attributes = new GeometryAttributes_default({
    position: new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: positions
    })
  });
  if (defined_default(vertexFormat.normal) || defined_default(vertexFormat.tangent) || defined_default(vertexFormat.bitangent) || defined_default(vertexFormat.st)) {
    const normals = defined_default(vertexFormat.normal) ? new Float32Array(3 * 4 * numberOfPlanes) : void 0;
    const tangents = defined_default(vertexFormat.tangent) ? new Float32Array(3 * 4 * numberOfPlanes) : void 0;
    const bitangents = defined_default(vertexFormat.bitangent) ? new Float32Array(3 * 4 * numberOfPlanes) : void 0;
    const st = defined_default(vertexFormat.st) ? new Float32Array(2 * 4 * numberOfPlanes) : void 0;
    const x = scratchXDirection;
    const y = scratchYDirection;
    const z = scratchZDirection;
    const negativeX2 = Cartesian3_default.negate(x, scratchNegativeX);
    const negativeY = Cartesian3_default.negate(y, scratchNegativeY);
    const negativeZ = Cartesian3_default.negate(z, scratchNegativeZ);
    offset2 = 0;
    if (drawNearPlane) {
      getAttributes(offset2, normals, tangents, bitangents, st, negativeZ, x, y);
      offset2 += 3 * 4;
    }
    getAttributes(offset2, normals, tangents, bitangents, st, z, negativeX2, y);
    offset2 += 3 * 4;
    getAttributes(
      offset2,
      normals,
      tangents,
      bitangents,
      st,
      negativeX2,
      negativeZ,
      y
    );
    offset2 += 3 * 4;
    getAttributes(
      offset2,
      normals,
      tangents,
      bitangents,
      st,
      negativeY,
      negativeZ,
      negativeX2
    );
    offset2 += 3 * 4;
    getAttributes(offset2, normals, tangents, bitangents, st, x, z, y);
    offset2 += 3 * 4;
    getAttributes(offset2, normals, tangents, bitangents, st, y, z, negativeX2);
    if (defined_default(normals)) {
      attributes.normal = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: normals
      });
    }
    if (defined_default(tangents)) {
      attributes.tangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: tangents
      });
    }
    if (defined_default(bitangents)) {
      attributes.bitangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: bitangents
      });
    }
    if (defined_default(st)) {
      attributes.st = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 2,
        values: st
      });
    }
  }
  const indices2 = new Uint16Array(6 * numberOfPlanes);
  for (let i2 = 0; i2 < numberOfPlanes; ++i2) {
    const indexOffset = i2 * 6;
    const index2 = i2 * 4;
    indices2[indexOffset] = index2;
    indices2[indexOffset + 1] = index2 + 1;
    indices2[indexOffset + 2] = index2 + 2;
    indices2[indexOffset + 3] = index2;
    indices2[indexOffset + 4] = index2 + 2;
    indices2[indexOffset + 5] = index2 + 3;
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingSphere: BoundingSphere_default.fromVertices(positions)
  });
};
var FrustumGeometry_default = FrustumGeometry;

// node_modules/cesium/Source/Core/FrustumOutlineGeometry.js
var PERSPECTIVE2 = 0;
var ORTHOGRAPHIC2 = 1;
function FrustumOutlineGeometry(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.object("options.frustum", options.frustum);
  Check_default.typeOf.object("options.origin", options.origin);
  Check_default.typeOf.object("options.orientation", options.orientation);
  const frustum = options.frustum;
  const orientation = options.orientation;
  const origin = options.origin;
  const drawNearPlane = defaultValue_default(options._drawNearPlane, true);
  let frustumType;
  let frustumPackedLength;
  if (frustum instanceof PerspectiveFrustum_default) {
    frustumType = PERSPECTIVE2;
    frustumPackedLength = PerspectiveFrustum_default.packedLength;
  } else if (frustum instanceof OrthographicFrustum_default) {
    frustumType = ORTHOGRAPHIC2;
    frustumPackedLength = OrthographicFrustum_default.packedLength;
  }
  this._frustumType = frustumType;
  this._frustum = frustum.clone();
  this._origin = Cartesian3_default.clone(origin);
  this._orientation = Quaternion_default.clone(orientation);
  this._drawNearPlane = drawNearPlane;
  this._workerName = "createFrustumOutlineGeometry";
  this.packedLength = 2 + frustumPackedLength + Cartesian3_default.packedLength + Quaternion_default.packedLength;
}
FrustumOutlineGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const frustumType = value._frustumType;
  const frustum = value._frustum;
  array[startingIndex++] = frustumType;
  if (frustumType === PERSPECTIVE2) {
    PerspectiveFrustum_default.pack(frustum, array, startingIndex);
    startingIndex += PerspectiveFrustum_default.packedLength;
  } else {
    OrthographicFrustum_default.pack(frustum, array, startingIndex);
    startingIndex += OrthographicFrustum_default.packedLength;
  }
  Cartesian3_default.pack(value._origin, array, startingIndex);
  startingIndex += Cartesian3_default.packedLength;
  Quaternion_default.pack(value._orientation, array, startingIndex);
  startingIndex += Quaternion_default.packedLength;
  array[startingIndex] = value._drawNearPlane ? 1 : 0;
  return array;
};
var scratchPackPerspective2 = new PerspectiveFrustum_default();
var scratchPackOrthographic2 = new OrthographicFrustum_default();
var scratchPackQuaternion2 = new Quaternion_default();
var scratchPackorigin2 = new Cartesian3_default();
FrustumOutlineGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const frustumType = array[startingIndex++];
  let frustum;
  if (frustumType === PERSPECTIVE2) {
    frustum = PerspectiveFrustum_default.unpack(
      array,
      startingIndex,
      scratchPackPerspective2
    );
    startingIndex += PerspectiveFrustum_default.packedLength;
  } else {
    frustum = OrthographicFrustum_default.unpack(
      array,
      startingIndex,
      scratchPackOrthographic2
    );
    startingIndex += OrthographicFrustum_default.packedLength;
  }
  const origin = Cartesian3_default.unpack(array, startingIndex, scratchPackorigin2);
  startingIndex += Cartesian3_default.packedLength;
  const orientation = Quaternion_default.unpack(
    array,
    startingIndex,
    scratchPackQuaternion2
  );
  startingIndex += Quaternion_default.packedLength;
  const drawNearPlane = array[startingIndex] === 1;
  if (!defined_default(result)) {
    return new FrustumOutlineGeometry({
      frustum,
      origin,
      orientation,
      _drawNearPlane: drawNearPlane
    });
  }
  const frustumResult = frustumType === result._frustumType ? result._frustum : void 0;
  result._frustum = frustum.clone(frustumResult);
  result._frustumType = frustumType;
  result._origin = Cartesian3_default.clone(origin, result._origin);
  result._orientation = Quaternion_default.clone(orientation, result._orientation);
  result._drawNearPlane = drawNearPlane;
  return result;
};
FrustumOutlineGeometry.createGeometry = function(frustumGeometry) {
  const frustumType = frustumGeometry._frustumType;
  const frustum = frustumGeometry._frustum;
  const origin = frustumGeometry._origin;
  const orientation = frustumGeometry._orientation;
  const drawNearPlane = frustumGeometry._drawNearPlane;
  const positions = new Float64Array(3 * 4 * 2);
  FrustumGeometry_default._computeNearFarPlanes(
    origin,
    orientation,
    frustumType,
    frustum,
    positions
  );
  const attributes = new GeometryAttributes_default({
    position: new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: positions
    })
  });
  let offset2;
  let index2;
  const numberOfPlanes = drawNearPlane ? 2 : 1;
  const indices2 = new Uint16Array(8 * (numberOfPlanes + 1));
  let i2 = drawNearPlane ? 0 : 1;
  for (; i2 < 2; ++i2) {
    offset2 = drawNearPlane ? i2 * 8 : 0;
    index2 = i2 * 4;
    indices2[offset2] = index2;
    indices2[offset2 + 1] = index2 + 1;
    indices2[offset2 + 2] = index2 + 1;
    indices2[offset2 + 3] = index2 + 2;
    indices2[offset2 + 4] = index2 + 2;
    indices2[offset2 + 5] = index2 + 3;
    indices2[offset2 + 6] = index2 + 3;
    indices2[offset2 + 7] = index2;
  }
  for (i2 = 0; i2 < 2; ++i2) {
    offset2 = (numberOfPlanes + i2) * 8;
    index2 = i2 * 4;
    indices2[offset2] = index2;
    indices2[offset2 + 1] = index2 + 4;
    indices2[offset2 + 2] = index2 + 1;
    indices2[offset2 + 3] = index2 + 5;
    indices2[offset2 + 4] = index2 + 2;
    indices2[offset2 + 5] = index2 + 6;
    indices2[offset2 + 6] = index2 + 3;
    indices2[offset2 + 7] = index2 + 7;
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere: BoundingSphere_default.fromVertices(positions)
  });
};
var FrustumOutlineGeometry_default = FrustumOutlineGeometry;

// node_modules/cesium/Source/Core/GeocodeType.js
var GeocodeType = {
  SEARCH: 0,
  AUTOCOMPLETE: 1
};
var GeocodeType_default = Object.freeze(GeocodeType);

// node_modules/cesium/Source/Core/GeocoderService.js
function GeocoderService() {
}
GeocoderService.prototype.geocode = DeveloperError_default.throwInstantiationError;
var GeocoderService_default = GeocoderService;

// node_modules/cesium/Source/Core/GeometryFactory.js
function GeometryFactory() {
  DeveloperError_default.throwInstantiationError();
}
GeometryFactory.createGeometry = function(geometryFactory) {
  DeveloperError_default.throwInstantiationError();
};
var GeometryFactory_default = GeometryFactory;

// node_modules/cesium/Source/Core/GeometryInstanceAttribute.js
function GeometryInstanceAttribute(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.componentDatatype)) {
    throw new DeveloperError_default("options.componentDatatype is required.");
  }
  if (!defined_default(options.componentsPerAttribute)) {
    throw new DeveloperError_default("options.componentsPerAttribute is required.");
  }
  if (options.componentsPerAttribute < 1 || options.componentsPerAttribute > 4) {
    throw new DeveloperError_default(
      "options.componentsPerAttribute must be between 1 and 4."
    );
  }
  if (!defined_default(options.value)) {
    throw new DeveloperError_default("options.value is required.");
  }
  this.componentDatatype = options.componentDatatype;
  this.componentsPerAttribute = options.componentsPerAttribute;
  this.normalize = defaultValue_default(options.normalize, false);
  this.value = options.value;
}
var GeometryInstanceAttribute_default = GeometryInstanceAttribute;

// node_modules/cesium/Source/ThirdParty/protobufjs.js
function _mergeNamespaces(n2, m) {
  m.forEach(function(e2) {
    e2 && typeof e2 !== "string" && !Array.isArray(e2) && Object.keys(e2).forEach(function(k) {
      if (k !== "default" && !(k in n2)) {
        var d = Object.getOwnPropertyDescriptor(e2, k);
        Object.defineProperty(n2, k, d.get ? d : {
          enumerable: true,
          get: function() {
            return e2[k];
          }
        });
      }
    });
  });
  return Object.freeze(n2);
}
var protobuf = createCommonjsModule(function(module) {
  (function(global, undefined$1) {
    (function prelude(modules, cache, entries) {
      function $require(name) {
        var $module = cache[name];
        if (!$module)
          modules[name][0].call($module = cache[name] = { exports: {} }, $require, $module, $module.exports);
        return $module.exports;
      }
      var protobuf2 = global.protobuf = $require(entries[0]);
      if (typeof undefined$1 === "function" && undefined$1.amd)
        undefined$1(["long"], function(Long) {
          if (Long && Long.isLong) {
            protobuf2.util.Long = Long;
            protobuf2.configure();
          }
          return protobuf2;
        });
      if (module && module.exports)
        module.exports = protobuf2;
    })({ 1: [function(require2, module2, exports2) {
      module2.exports = asPromise;
      function asPromise(fn, ctx) {
        var params = [];
        for (var i2 = 2; i2 < arguments.length; )
          params.push(arguments[i2++]);
        var pending = true;
        return new Promise(function asPromiseExecutor(resolve2, reject) {
          params.push(function asPromiseCallback(err) {
            if (pending) {
              pending = false;
              if (err)
                reject(err);
              else {
                var args = [];
                for (var i3 = 1; i3 < arguments.length; )
                  args.push(arguments[i3++]);
                resolve2.apply(null, args);
              }
            }
          });
          try {
            fn.apply(ctx || this, params);
          } catch (err) {
            if (pending) {
              pending = false;
              reject(err);
            }
          }
        });
      }
    }, {}], 2: [function(require2, module2, exports2) {
      var base64 = exports2;
      base64.length = function length3(string) {
        var p2 = string.length;
        if (!p2)
          return 0;
        var n2 = 0;
        while (--p2 % 4 > 1 && string.charAt(p2) === "=")
          ++n2;
        return Math.ceil(string.length * 3) / 4 - n2;
      };
      var b64 = new Array(64);
      var s64 = new Array(123);
      for (var i2 = 0; i2 < 64; )
        s64[b64[i2] = i2 < 26 ? i2 + 65 : i2 < 52 ? i2 + 71 : i2 < 62 ? i2 - 4 : i2 - 59 | 43] = i2++;
      base64.encode = function encode(buffer, start, end) {
        var string = [];
        var i3 = 0, j = 0, t;
        while (start < end) {
          var b = buffer[start++];
          switch (j) {
            case 0:
              string[i3++] = b64[b >> 2];
              t = (b & 3) << 4;
              j = 1;
              break;
            case 1:
              string[i3++] = b64[t | b >> 4];
              t = (b & 15) << 2;
              j = 2;
              break;
            case 2:
              string[i3++] = b64[t | b >> 6];
              string[i3++] = b64[b & 63];
              j = 0;
              break;
          }
        }
        if (j) {
          string[i3++] = b64[t];
          string[i3] = 61;
          if (j === 1)
            string[i3 + 1] = 61;
        }
        return String.fromCharCode.apply(String, string);
      };
      var invalidEncoding = "invalid encoding";
      base64.decode = function decode(string, buffer, offset2) {
        var start = offset2;
        var j = 0, t;
        for (var i3 = 0; i3 < string.length; ) {
          var c14 = string.charCodeAt(i3++);
          if (c14 === 61 && j > 1)
            break;
          if ((c14 = s64[c14]) === undefined$1)
            throw Error(invalidEncoding);
          switch (j) {
            case 0:
              t = c14;
              j = 1;
              break;
            case 1:
              buffer[offset2++] = t << 2 | (c14 & 48) >> 4;
              t = c14;
              j = 2;
              break;
            case 2:
              buffer[offset2++] = (t & 15) << 4 | (c14 & 60) >> 2;
              t = c14;
              j = 3;
              break;
            case 3:
              buffer[offset2++] = (t & 3) << 6 | c14;
              j = 0;
              break;
          }
        }
        if (j === 1)
          throw Error(invalidEncoding);
        return offset2 - start;
      };
      base64.test = function test(string) {
        return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
      };
    }, {}], 3: [function(require2, module2, exports2) {
      module2.exports = EventEmitter;
      function EventEmitter() {
        this._listeners = {};
      }
      EventEmitter.prototype.on = function on(evt, fn, ctx) {
        (this._listeners[evt] || (this._listeners[evt] = [])).push({
          fn,
          ctx: ctx || this
        });
        return this;
      };
      EventEmitter.prototype.off = function off(evt, fn) {
        if (evt === undefined$1)
          this._listeners = {};
        else {
          if (fn === undefined$1)
            this._listeners[evt] = [];
          else {
            var listeners = this._listeners[evt];
            for (var i2 = 0; i2 < listeners.length; )
              if (listeners[i2].fn === fn)
                listeners.splice(i2, 1);
              else
                ++i2;
          }
        }
        return this;
      };
      EventEmitter.prototype.emit = function emit(evt) {
        var listeners = this._listeners[evt];
        if (listeners) {
          var args = [], i2 = 1;
          for (; i2 < arguments.length; )
            args.push(arguments[i2++]);
          for (i2 = 0; i2 < listeners.length; )
            listeners[i2].fn.apply(listeners[i2++].ctx, args);
        }
        return this;
      };
    }, {}], 4: [function(require2, module2, exports2) {
      module2.exports = factory(factory);
      function factory(exports3) {
        if (typeof Float32Array !== "undefined")
          (function() {
            var f32 = new Float32Array([-0]), f8b = new Uint8Array(f32.buffer), le = f8b[3] === 128;
            function writeFloat_f32_cpy(val, buf, pos) {
              f32[0] = val;
              buf[pos] = f8b[0];
              buf[pos + 1] = f8b[1];
              buf[pos + 2] = f8b[2];
              buf[pos + 3] = f8b[3];
            }
            function writeFloat_f32_rev(val, buf, pos) {
              f32[0] = val;
              buf[pos] = f8b[3];
              buf[pos + 1] = f8b[2];
              buf[pos + 2] = f8b[1];
              buf[pos + 3] = f8b[0];
            }
            exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
            exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
            function readFloat_f32_cpy(buf, pos) {
              f8b[0] = buf[pos];
              f8b[1] = buf[pos + 1];
              f8b[2] = buf[pos + 2];
              f8b[3] = buf[pos + 3];
              return f32[0];
            }
            function readFloat_f32_rev(buf, pos) {
              f8b[3] = buf[pos];
              f8b[2] = buf[pos + 1];
              f8b[1] = buf[pos + 2];
              f8b[0] = buf[pos + 3];
              return f32[0];
            }
            exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
            exports3.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
          })();
        else
          (function() {
            function writeFloat_ieee754(writeUint, val, buf, pos) {
              var sign3 = val < 0 ? 1 : 0;
              if (sign3)
                val = -val;
              if (val === 0)
                writeUint(1 / val > 0 ? 0 : 2147483648, buf, pos);
              else if (isNaN(val))
                writeUint(2143289344, buf, pos);
              else if (val > 34028234663852886e22)
                writeUint((sign3 << 31 | 2139095040) >>> 0, buf, pos);
              else if (val < 11754943508222875e-54)
                writeUint((sign3 << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf, pos);
              else {
                var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
                writeUint((sign3 << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
              }
            }
            exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
            exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
            function readFloat_ieee754(readUint, buf, pos) {
              var uint = readUint(buf, pos), sign3 = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607;
              return exponent === 255 ? mantissa ? NaN : sign3 * Infinity : exponent === 0 ? sign3 * 1401298464324817e-60 * mantissa : sign3 * Math.pow(2, exponent - 150) * (mantissa + 8388608);
            }
            exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
            exports3.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
          })();
        if (typeof Float64Array !== "undefined")
          (function() {
            var f64 = new Float64Array([-0]), f8b = new Uint8Array(f64.buffer), le = f8b[7] === 128;
            function writeDouble_f64_cpy(val, buf, pos) {
              f64[0] = val;
              buf[pos] = f8b[0];
              buf[pos + 1] = f8b[1];
              buf[pos + 2] = f8b[2];
              buf[pos + 3] = f8b[3];
              buf[pos + 4] = f8b[4];
              buf[pos + 5] = f8b[5];
              buf[pos + 6] = f8b[6];
              buf[pos + 7] = f8b[7];
            }
            function writeDouble_f64_rev(val, buf, pos) {
              f64[0] = val;
              buf[pos] = f8b[7];
              buf[pos + 1] = f8b[6];
              buf[pos + 2] = f8b[5];
              buf[pos + 3] = f8b[4];
              buf[pos + 4] = f8b[3];
              buf[pos + 5] = f8b[2];
              buf[pos + 6] = f8b[1];
              buf[pos + 7] = f8b[0];
            }
            exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
            exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
            function readDouble_f64_cpy(buf, pos) {
              f8b[0] = buf[pos];
              f8b[1] = buf[pos + 1];
              f8b[2] = buf[pos + 2];
              f8b[3] = buf[pos + 3];
              f8b[4] = buf[pos + 4];
              f8b[5] = buf[pos + 5];
              f8b[6] = buf[pos + 6];
              f8b[7] = buf[pos + 7];
              return f64[0];
            }
            function readDouble_f64_rev(buf, pos) {
              f8b[7] = buf[pos];
              f8b[6] = buf[pos + 1];
              f8b[5] = buf[pos + 2];
              f8b[4] = buf[pos + 3];
              f8b[3] = buf[pos + 4];
              f8b[2] = buf[pos + 5];
              f8b[1] = buf[pos + 6];
              f8b[0] = buf[pos + 7];
              return f64[0];
            }
            exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
            exports3.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
          })();
        else
          (function() {
            function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
              var sign3 = val < 0 ? 1 : 0;
              if (sign3)
                val = -val;
              if (val === 0) {
                writeUint(0, buf, pos + off0);
                writeUint(1 / val > 0 ? 0 : 2147483648, buf, pos + off1);
              } else if (isNaN(val)) {
                writeUint(0, buf, pos + off0);
                writeUint(2146959360, buf, pos + off1);
              } else if (val > 17976931348623157e292) {
                writeUint(0, buf, pos + off0);
                writeUint((sign3 << 31 | 2146435072) >>> 0, buf, pos + off1);
              } else {
                var mantissa;
                if (val < 22250738585072014e-324) {
                  mantissa = val / 5e-324;
                  writeUint(mantissa >>> 0, buf, pos + off0);
                  writeUint((sign3 << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
                } else {
                  var exponent = Math.floor(Math.log(val) / Math.LN2);
                  if (exponent === 1024)
                    exponent = 1023;
                  mantissa = val * Math.pow(2, -exponent);
                  writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
                  writeUint((sign3 << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
                }
              }
            }
            exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
            exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
            function readDouble_ieee754(readUint, off0, off1, buf, pos) {
              var lo = readUint(buf, pos + off0), hi = readUint(buf, pos + off1);
              var sign3 = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo;
              return exponent === 2047 ? mantissa ? NaN : sign3 * Infinity : exponent === 0 ? sign3 * 5e-324 * mantissa : sign3 * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
            }
            exports3.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
            exports3.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
          })();
        return exports3;
      }
      function writeUintLE(val, buf, pos) {
        buf[pos] = val & 255;
        buf[pos + 1] = val >>> 8 & 255;
        buf[pos + 2] = val >>> 16 & 255;
        buf[pos + 3] = val >>> 24;
      }
      function writeUintBE(val, buf, pos) {
        buf[pos] = val >>> 24;
        buf[pos + 1] = val >>> 16 & 255;
        buf[pos + 2] = val >>> 8 & 255;
        buf[pos + 3] = val & 255;
      }
      function readUintLE(buf, pos) {
        return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0;
      }
      function readUintBE(buf, pos) {
        return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0;
      }
    }, {}], 5: [function(require, module, exports) {
      module.exports = inquire;
      function inquire(moduleName) {
        try {
          var mod = eval("quire".replace(/^/, "re"))(moduleName);
          if (mod && (mod.length || Object.keys(mod).length))
            return mod;
        } catch (e2) {
        }
        return null;
      }
    }, {}], 6: [function(require2, module2, exports2) {
      module2.exports = pool2;
      function pool2(alloc, slice, size) {
        var SIZE = size || 8192;
        var MAX = SIZE >>> 1;
        var slab = null;
        var offset2 = SIZE;
        return function pool_alloc(size2) {
          if (size2 < 1 || size2 > MAX)
            return alloc(size2);
          if (offset2 + size2 > SIZE) {
            slab = alloc(SIZE);
            offset2 = 0;
          }
          var buf = slice.call(slab, offset2, offset2 += size2);
          if (offset2 & 7)
            offset2 = (offset2 | 7) + 1;
          return buf;
        };
      }
    }, {}], 7: [function(require2, module2, exports2) {
      var utf8 = exports2;
      utf8.length = function utf8_length(string) {
        var len = 0, c14 = 0;
        for (var i2 = 0; i2 < string.length; ++i2) {
          c14 = string.charCodeAt(i2);
          if (c14 < 128)
            len += 1;
          else if (c14 < 2048)
            len += 2;
          else if ((c14 & 64512) === 55296 && (string.charCodeAt(i2 + 1) & 64512) === 56320) {
            ++i2;
            len += 4;
          } else
            len += 3;
        }
        return len;
      };
      utf8.read = function utf8_read(buffer, start, end) {
        var len = end - start;
        if (len < 1)
          return "";
        var parts = null, chunk = [], i2 = 0, t;
        while (start < end) {
          t = buffer[start++];
          if (t < 128)
            chunk[i2++] = t;
          else if (t > 191 && t < 224)
            chunk[i2++] = (t & 31) << 6 | buffer[start++] & 63;
          else if (t > 239 && t < 365) {
            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 65536;
            chunk[i2++] = 55296 + (t >> 10);
            chunk[i2++] = 56320 + (t & 1023);
          } else
            chunk[i2++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
          if (i2 > 8191) {
            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
            i2 = 0;
          }
        }
        if (parts) {
          if (i2)
            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i2)));
          return parts.join("");
        }
        return String.fromCharCode.apply(String, chunk.slice(0, i2));
      };
      utf8.write = function utf8_write(string, buffer, offset2) {
        var start = offset2, c14, c22;
        for (var i2 = 0; i2 < string.length; ++i2) {
          c14 = string.charCodeAt(i2);
          if (c14 < 128) {
            buffer[offset2++] = c14;
          } else if (c14 < 2048) {
            buffer[offset2++] = c14 >> 6 | 192;
            buffer[offset2++] = c14 & 63 | 128;
          } else if ((c14 & 64512) === 55296 && ((c22 = string.charCodeAt(i2 + 1)) & 64512) === 56320) {
            c14 = 65536 + ((c14 & 1023) << 10) + (c22 & 1023);
            ++i2;
            buffer[offset2++] = c14 >> 18 | 240;
            buffer[offset2++] = c14 >> 12 & 63 | 128;
            buffer[offset2++] = c14 >> 6 & 63 | 128;
            buffer[offset2++] = c14 & 63 | 128;
          } else {
            buffer[offset2++] = c14 >> 12 | 224;
            buffer[offset2++] = c14 >> 6 & 63 | 128;
            buffer[offset2++] = c14 & 63 | 128;
          }
        }
        return offset2 - start;
      };
    }, {}], 8: [function(require2, module2, exports2) {
      var protobuf2 = exports2;
      protobuf2.build = "minimal";
      protobuf2.roots = {};
      protobuf2.Writer = require2(15);
      protobuf2.BufferWriter = require2(16);
      protobuf2.Reader = require2(9);
      protobuf2.BufferReader = require2(10);
      protobuf2.util = require2(14);
      protobuf2.rpc = require2(11);
      protobuf2.configure = configure2;
      function configure2() {
        protobuf2.Reader._configure(protobuf2.BufferReader);
        protobuf2.util._configure();
      }
      protobuf2.Writer._configure(protobuf2.BufferWriter);
      configure2();
    }, { "10": 10, "11": 11, "14": 14, "15": 15, "16": 16, "9": 9 }], 9: [function(require2, module2, exports2) {
      module2.exports = Reader2;
      var util = require2(14);
      var BufferReader;
      var LongBits = util.LongBits, utf8 = util.utf8;
      function indexOutOfRange(reader, writeLength) {
        return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
      }
      function Reader2(buffer) {
        this.buf = buffer;
        this.pos = 0;
        this.len = buffer.length;
      }
      var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) {
        if (buffer instanceof Uint8Array || Array.isArray(buffer))
          return new Reader2(buffer);
        throw Error("illegal buffer");
      } : function create_array2(buffer) {
        if (Array.isArray(buffer))
          return new Reader2(buffer);
        throw Error("illegal buffer");
      };
      Reader2.create = util.Buffer ? function create_buffer_setup(buffer) {
        return (Reader2.create = function create_buffer(buffer2) {
          return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2);
        })(buffer);
      } : create_array;
      Reader2.prototype._slice = util.Array.prototype.subarray || util.Array.prototype.slice;
      Reader2.prototype.uint32 = function read_uint32_setup() {
        var value = 4294967295;
        return function read_uint32() {
          value = (this.buf[this.pos] & 127) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
          if (this.buf[this.pos++] < 128)
            return value;
          if ((this.pos += 5) > this.len) {
            this.pos = this.len;
            throw indexOutOfRange(this, 10);
          }
          return value;
        };
      }();
      Reader2.prototype.int32 = function read_int32() {
        return this.uint32() | 0;
      };
      Reader2.prototype.sint32 = function read_sint32() {
        var value = this.uint32();
        return value >>> 1 ^ -(value & 1) | 0;
      };
      function readLongVarint() {
        var bits = new LongBits(0, 0);
        var i2 = 0;
        if (this.len - this.pos > 4) {
          for (; i2 < 4; ++i2) {
            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i2 * 7) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
          bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
          bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
          if (this.buf[this.pos++] < 128)
            return bits;
          i2 = 0;
        } else {
          for (; i2 < 3; ++i2) {
            if (this.pos >= this.len)
              throw indexOutOfRange(this);
            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i2 * 7) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
          bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i2 * 7) >>> 0;
          return bits;
        }
        if (this.len - this.pos > 4) {
          for (; i2 < 5; ++i2) {
            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i2 * 7 + 3) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
        } else {
          for (; i2 < 5; ++i2) {
            if (this.pos >= this.len)
              throw indexOutOfRange(this);
            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i2 * 7 + 3) >>> 0;
            if (this.buf[this.pos++] < 128)
              return bits;
          }
        }
        throw Error("invalid varint encoding");
      }
      Reader2.prototype.bool = function read_bool() {
        return this.uint32() !== 0;
      };
      function readFixed32_end(buf, end) {
        return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
      }
      Reader2.prototype.fixed32 = function read_fixed32() {
        if (this.pos + 4 > this.len)
          throw indexOutOfRange(this, 4);
        return readFixed32_end(this.buf, this.pos += 4);
      };
      Reader2.prototype.sfixed32 = function read_sfixed32() {
        if (this.pos + 4 > this.len)
          throw indexOutOfRange(this, 4);
        return readFixed32_end(this.buf, this.pos += 4) | 0;
      };
      function readFixed64() {
        if (this.pos + 8 > this.len)
          throw indexOutOfRange(this, 8);
        return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
      }
      Reader2.prototype.float = function read_float() {
        if (this.pos + 4 > this.len)
          throw indexOutOfRange(this, 4);
        var value = util.float.readFloatLE(this.buf, this.pos);
        this.pos += 4;
        return value;
      };
      Reader2.prototype.double = function read_double() {
        if (this.pos + 8 > this.len)
          throw indexOutOfRange(this, 4);
        var value = util.float.readDoubleLE(this.buf, this.pos);
        this.pos += 8;
        return value;
      };
      Reader2.prototype.bytes = function read_bytes() {
        var length3 = this.uint32(), start = this.pos, end = this.pos + length3;
        if (end > this.len)
          throw indexOutOfRange(this, length3);
        this.pos += length3;
        return start === end ? new this.buf.constructor(0) : this._slice.call(this.buf, start, end);
      };
      Reader2.prototype.string = function read_string() {
        var bytes = this.bytes();
        return utf8.read(bytes, 0, bytes.length);
      };
      Reader2.prototype.skip = function skip(length3) {
        if (typeof length3 === "number") {
          if (this.pos + length3 > this.len)
            throw indexOutOfRange(this, length3);
          this.pos += length3;
        } else {
          do {
            if (this.pos >= this.len)
              throw indexOutOfRange(this);
          } while (this.buf[this.pos++] & 128);
        }
        return this;
      };
      Reader2.prototype.skipType = function(wireType) {
        switch (wireType) {
          case 0:
            this.skip();
            break;
          case 1:
            this.skip(8);
            break;
          case 2:
            this.skip(this.uint32());
            break;
          case 3:
            do {
              if ((wireType = this.uint32() & 7) === 4)
                break;
              this.skipType(wireType);
            } while (true);
            break;
          case 5:
            this.skip(4);
            break;
          default:
            throw Error("invalid wire type " + wireType + " at offset " + this.pos);
        }
        return this;
      };
      Reader2._configure = function(BufferReader_) {
        BufferReader = BufferReader_;
        var fn = util.Long ? "toLong" : "toNumber";
        util.merge(Reader2.prototype, {
          int64: function read_int64() {
            return readLongVarint.call(this)[fn](false);
          },
          uint64: function read_uint64() {
            return readLongVarint.call(this)[fn](true);
          },
          sint64: function read_sint64() {
            return readLongVarint.call(this).zzDecode()[fn](false);
          },
          fixed64: function read_fixed64() {
            return readFixed64.call(this)[fn](true);
          },
          sfixed64: function read_sfixed64() {
            return readFixed64.call(this)[fn](false);
          }
        });
      };
    }, { "14": 14 }], 10: [function(require2, module2, exports2) {
      module2.exports = BufferReader;
      var Reader2 = require2(9);
      (BufferReader.prototype = Object.create(Reader2.prototype)).constructor = BufferReader;
      var util = require2(14);
      function BufferReader(buffer) {
        Reader2.call(this, buffer);
      }
      if (util.Buffer)
        BufferReader.prototype._slice = util.Buffer.prototype.slice;
      BufferReader.prototype.string = function read_string_buffer() {
        var len = this.uint32();
        return this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len));
      };
    }, { "14": 14, "9": 9 }], 11: [function(require2, module2, exports2) {
      var rpc = exports2;
      rpc.Service = require2(12);
    }, { "12": 12 }], 12: [function(require2, module2, exports2) {
      module2.exports = Service;
      var util = require2(14);
      (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
      function Service(rpcImpl, requestDelimited, responseDelimited) {
        if (typeof rpcImpl !== "function")
          throw TypeError("rpcImpl must be a function");
        util.EventEmitter.call(this);
        this.rpcImpl = rpcImpl;
        this.requestDelimited = Boolean(requestDelimited);
        this.responseDelimited = Boolean(responseDelimited);
      }
      Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
        if (!request)
          throw TypeError("request must be specified");
        var self2 = this;
        if (!callback)
          return util.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request);
        if (!self2.rpcImpl) {
          setTimeout(function() {
            callback(Error("already ended"));
          }, 0);
          return undefined$1;
        }
        try {
          return self2.rpcImpl(
            method,
            requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
            function rpcCallback(err, response) {
              if (err) {
                self2.emit("error", err, method);
                return callback(err);
              }
              if (response === null) {
                self2.end(true);
                return undefined$1;
              }
              if (!(response instanceof responseCtor)) {
                try {
                  response = responseCtor[self2.responseDelimited ? "decodeDelimited" : "decode"](response);
                } catch (err2) {
                  self2.emit("error", err2, method);
                  return callback(err2);
                }
              }
              self2.emit("data", response, method);
              return callback(null, response);
            }
          );
        } catch (err) {
          self2.emit("error", err, method);
          setTimeout(function() {
            callback(err);
          }, 0);
          return undefined$1;
        }
      };
      Service.prototype.end = function end(endedByRPC) {
        if (this.rpcImpl) {
          if (!endedByRPC)
            this.rpcImpl(null, null, null);
          this.rpcImpl = null;
          this.emit("end").off();
        }
        return this;
      };
    }, { "14": 14 }], 13: [function(require2, module2, exports2) {
      module2.exports = LongBits;
      var util = require2(14);
      function LongBits(lo, hi) {
        this.lo = lo >>> 0;
        this.hi = hi >>> 0;
      }
      var zero = LongBits.zero = new LongBits(0, 0);
      zero.toNumber = function() {
        return 0;
      };
      zero.zzEncode = zero.zzDecode = function() {
        return this;
      };
      zero.length = function() {
        return 1;
      };
      var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
      LongBits.fromNumber = function fromNumber(value) {
        if (value === 0)
          return zero;
        var sign3 = value < 0;
        if (sign3)
          value = -value;
        var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0;
        if (sign3) {
          hi = ~hi >>> 0;
          lo = ~lo >>> 0;
          if (++lo > 4294967295) {
            lo = 0;
            if (++hi > 4294967295)
              hi = 0;
          }
        }
        return new LongBits(lo, hi);
      };
      LongBits.from = function from(value) {
        if (typeof value === "number")
          return LongBits.fromNumber(value);
        if (util.isString(value)) {
          if (util.Long)
            value = util.Long.fromString(value);
          else
            return LongBits.fromNumber(parseInt(value, 10));
        }
        return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
      };
      LongBits.prototype.toNumber = function toNumber(unsigned) {
        if (!unsigned && this.hi >>> 31) {
          var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0;
          if (!lo)
            hi = hi + 1 >>> 0;
          return -(lo + hi * 4294967296);
        }
        return this.lo + this.hi * 4294967296;
      };
      LongBits.prototype.toLong = function toLong(unsigned) {
        return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
      };
      var charCodeAt = String.prototype.charCodeAt;
      LongBits.fromHash = function fromHash(hash2) {
        if (hash2 === zeroHash)
          return zero;
        return new LongBits(
          (charCodeAt.call(hash2, 0) | charCodeAt.call(hash2, 1) << 8 | charCodeAt.call(hash2, 2) << 16 | charCodeAt.call(hash2, 3) << 24) >>> 0,
          (charCodeAt.call(hash2, 4) | charCodeAt.call(hash2, 5) << 8 | charCodeAt.call(hash2, 6) << 16 | charCodeAt.call(hash2, 7) << 24) >>> 0
        );
      };
      LongBits.prototype.toHash = function toHash() {
        return String.fromCharCode(
          this.lo & 255,
          this.lo >>> 8 & 255,
          this.lo >>> 16 & 255,
          this.lo >>> 24,
          this.hi & 255,
          this.hi >>> 8 & 255,
          this.hi >>> 16 & 255,
          this.hi >>> 24
        );
      };
      LongBits.prototype.zzEncode = function zzEncode() {
        var mask = this.hi >> 31;
        this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
        this.lo = (this.lo << 1 ^ mask) >>> 0;
        return this;
      };
      LongBits.prototype.zzDecode = function zzDecode() {
        var mask = -(this.lo & 1);
        this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
        this.hi = (this.hi >>> 1 ^ mask) >>> 0;
        return this;
      };
      LongBits.prototype.length = function length3() {
        var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24;
        return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
      };
    }, { "14": 14 }], 14: [function(require2, module2, exports2) {
      var util = exports2;
      util.asPromise = require2(1);
      util.base64 = require2(2);
      util.EventEmitter = require2(3);
      util.float = require2(4);
      util.inquire = require2(5);
      util.utf8 = require2(7);
      util.pool = require2(6);
      util.LongBits = require2(13);
      util.emptyArray = Object.freeze ? Object.freeze([]) : [];
      util.emptyObject = Object.freeze ? Object.freeze({}) : {};
      util.isNode = Boolean(global.process && global.process.versions && global.process.versions.node);
      util.isInteger = Number.isInteger || function isInteger(value) {
        return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
      };
      util.isString = function isString(value) {
        return typeof value === "string" || value instanceof String;
      };
      util.isObject = function isObject(value) {
        return value && typeof value === "object";
      };
      util.isset = util.isSet = function isSet(obj, prop) {
        var value = obj[prop];
        if (value != null && obj.hasOwnProperty(prop))
          return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
        return false;
      };
      util.Buffer = function() {
        try {
          var Buffer3 = util.inquire("buffer").Buffer;
          return Buffer3.prototype.utf8Write ? Buffer3 : null;
        } catch (e2) {
          return null;
        }
      }();
      util._Buffer_from = null;
      util._Buffer_allocUnsafe = null;
      util.newBuffer = function newBuffer(sizeOrArray) {
        return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray);
      };
      util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
      util.Long = global.dcodeIO && global.dcodeIO.Long || util.inquire("long");
      util.key2Re = /^true|false|0|1$/;
      util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
      util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
      util.longToHash = function longToHash(value) {
        return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash;
      };
      util.longFromHash = function longFromHash(hash2, unsigned) {
        var bits = util.LongBits.fromHash(hash2);
        if (util.Long)
          return util.Long.fromBits(bits.lo, bits.hi, unsigned);
        return bits.toNumber(Boolean(unsigned));
      };
      function merge3(dst, src2, ifNotSet) {
        for (var keys = Object.keys(src2), i2 = 0; i2 < keys.length; ++i2)
          if (dst[keys[i2]] === undefined$1 || !ifNotSet)
            dst[keys[i2]] = src2[keys[i2]];
        return dst;
      }
      util.merge = merge3;
      util.lcFirst = function lcFirst(str) {
        return str.charAt(0).toLowerCase() + str.substring(1);
      };
      function newError(name) {
        function CustomError(message, properties) {
          if (!(this instanceof CustomError))
            return new CustomError(message, properties);
          Object.defineProperty(this, "message", { get: function() {
            return message;
          } });
          if (Error.captureStackTrace)
            Error.captureStackTrace(this, CustomError);
          else
            Object.defineProperty(this, "stack", { value: new Error().stack || "" });
          if (properties)
            merge3(this, properties);
        }
        (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;
        Object.defineProperty(CustomError.prototype, "name", { get: function() {
          return name;
        } });
        CustomError.prototype.toString = function toString2() {
          return this.name + ": " + this.message;
        };
        return CustomError;
      }
      util.newError = newError;
      util.ProtocolError = newError("ProtocolError");
      util.oneOfGetter = function getOneOf(fieldNames) {
        var fieldMap = {};
        for (var i2 = 0; i2 < fieldNames.length; ++i2)
          fieldMap[fieldNames[i2]] = 1;
        return function() {
          for (var keys = Object.keys(this), i3 = keys.length - 1; i3 > -1; --i3)
            if (fieldMap[keys[i3]] === 1 && this[keys[i3]] !== undefined$1 && this[keys[i3]] !== null)
              return keys[i3];
        };
      };
      util.oneOfSetter = function setOneOf(fieldNames) {
        return function(name) {
          for (var i2 = 0; i2 < fieldNames.length; ++i2)
            if (fieldNames[i2] !== name)
              delete this[fieldNames[i2]];
        };
      };
      util.lazyResolve = function lazyResolve(root, lazyTypes) {
        for (var i2 = 0; i2 < lazyTypes.length; ++i2) {
          for (var keys = Object.keys(lazyTypes[i2]), j = 0; j < keys.length; ++j) {
            var path = lazyTypes[i2][keys[j]].split("."), ptr = root;
            while (path.length)
              ptr = ptr[path.shift()];
            lazyTypes[i2][keys[j]] = ptr;
          }
        }
      };
      util.toJSONOptions = {
        longs: String,
        enums: String,
        bytes: String
      };
      util._configure = function() {
        var Buffer3 = util.Buffer;
        if (!Buffer3) {
          util._Buffer_from = util._Buffer_allocUnsafe = null;
          return;
        }
        util._Buffer_from = Buffer3.from !== Uint8Array.from && Buffer3.from || function Buffer_from(value, encoding) {
          return new Buffer3(value, encoding);
        };
        util._Buffer_allocUnsafe = Buffer3.allocUnsafe || function Buffer_allocUnsafe(size) {
          return new Buffer3(size);
        };
      };
    }, { "1": 1, "13": 13, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7 }], 15: [function(require2, module2, exports2) {
      module2.exports = Writer2;
      var util = require2(14);
      var BufferWriter;
      var LongBits = util.LongBits, base64 = util.base64, utf8 = util.utf8;
      function Op(fn, len, val) {
        this.fn = fn;
        this.len = len;
        this.next = undefined$1;
        this.val = val;
      }
      function noop() {
      }
      function State(writer) {
        this.head = writer.head;
        this.tail = writer.tail;
        this.len = writer.len;
        this.next = writer.states;
      }
      function Writer2() {
        this.len = 0;
        this.head = new Op(noop, 0, 0);
        this.tail = this.head;
        this.states = null;
      }
      Writer2.create = util.Buffer ? function create_buffer_setup() {
        return (Writer2.create = function create_buffer() {
          return new BufferWriter();
        })();
      } : function create_array() {
        return new Writer2();
      };
      Writer2.alloc = function alloc(size) {
        return new util.Array(size);
      };
      if (util.Array !== Array)
        Writer2.alloc = util.pool(Writer2.alloc, util.Array.prototype.subarray);
      Writer2.prototype.push = function push(fn, len, val) {
        this.tail = this.tail.next = new Op(fn, len, val);
        this.len += len;
        return this;
      };
      function writeByte(val, buf, pos) {
        buf[pos] = val & 255;
      }
      function writeVarint32(val, buf, pos) {
        while (val > 127) {
          buf[pos++] = val & 127 | 128;
          val >>>= 7;
        }
        buf[pos] = val;
      }
      function VarintOp(len, val) {
        this.len = len;
        this.next = undefined$1;
        this.val = val;
      }
      VarintOp.prototype = Object.create(Op.prototype);
      VarintOp.prototype.fn = writeVarint32;
      Writer2.prototype.uint32 = function write_uint32(value) {
        this.len += (this.tail = this.tail.next = new VarintOp(
          (value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5,
          value
        )).len;
        return this;
      };
      Writer2.prototype.int32 = function write_int32(value) {
        return value < 0 ? this.push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
      };
      Writer2.prototype.sint32 = function write_sint32(value) {
        return this.uint32((value << 1 ^ value >> 31) >>> 0);
      };
      function writeVarint64(val, buf, pos) {
        while (val.hi) {
          buf[pos++] = val.lo & 127 | 128;
          val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
          val.hi >>>= 7;
        }
        while (val.lo > 127) {
          buf[pos++] = val.lo & 127 | 128;
          val.lo = val.lo >>> 7;
        }
        buf[pos++] = val.lo;
      }
      Writer2.prototype.uint64 = function write_uint64(value) {
        var bits = LongBits.from(value);
        return this.push(writeVarint64, bits.length(), bits);
      };
      Writer2.prototype.int64 = Writer2.prototype.uint64;
      Writer2.prototype.sint64 = function write_sint64(value) {
        var bits = LongBits.from(value).zzEncode();
        return this.push(writeVarint64, bits.length(), bits);
      };
      Writer2.prototype.bool = function write_bool(value) {
        return this.push(writeByte, 1, value ? 1 : 0);
      };
      function writeFixed32(val, buf, pos) {
        buf[pos] = val & 255;
        buf[pos + 1] = val >>> 8 & 255;
        buf[pos + 2] = val >>> 16 & 255;
        buf[pos + 3] = val >>> 24;
      }
      Writer2.prototype.fixed32 = function write_fixed32(value) {
        return this.push(writeFixed32, 4, value >>> 0);
      };
      Writer2.prototype.sfixed32 = Writer2.prototype.fixed32;
      Writer2.prototype.fixed64 = function write_fixed64(value) {
        var bits = LongBits.from(value);
        return this.push(writeFixed32, 4, bits.lo).push(writeFixed32, 4, bits.hi);
      };
      Writer2.prototype.sfixed64 = Writer2.prototype.fixed64;
      Writer2.prototype.float = function write_float(value) {
        return this.push(util.float.writeFloatLE, 4, value);
      };
      Writer2.prototype.double = function write_double(value) {
        return this.push(util.float.writeDoubleLE, 8, value);
      };
      var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) {
        buf.set(val, pos);
      } : function writeBytes_for(val, buf, pos) {
        for (var i2 = 0; i2 < val.length; ++i2)
          buf[pos + i2] = val[i2];
      };
      Writer2.prototype.bytes = function write_bytes(value) {
        var len = value.length >>> 0;
        if (!len)
          return this.push(writeByte, 1, 0);
        if (util.isString(value)) {
          var buf = Writer2.alloc(len = base64.length(value));
          base64.decode(value, buf, 0);
          value = buf;
        }
        return this.uint32(len).push(writeBytes, len, value);
      };
      Writer2.prototype.string = function write_string(value) {
        var len = utf8.length(value);
        return len ? this.uint32(len).push(utf8.write, len, value) : this.push(writeByte, 1, 0);
      };
      Writer2.prototype.fork = function fork() {
        this.states = new State(this);
        this.head = this.tail = new Op(noop, 0, 0);
        this.len = 0;
        return this;
      };
      Writer2.prototype.reset = function reset() {
        if (this.states) {
          this.head = this.states.head;
          this.tail = this.states.tail;
          this.len = this.states.len;
          this.states = this.states.next;
        } else {
          this.head = this.tail = new Op(noop, 0, 0);
          this.len = 0;
        }
        return this;
      };
      Writer2.prototype.ldelim = function ldelim() {
        var head = this.head, tail = this.tail, len = this.len;
        this.reset().uint32(len);
        if (len) {
          this.tail.next = head.next;
          this.tail = tail;
          this.len += len;
        }
        return this;
      };
      Writer2.prototype.finish = function finish() {
        var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0;
        while (head) {
          head.fn(head.val, buf, pos);
          pos += head.len;
          head = head.next;
        }
        return buf;
      };
      Writer2._configure = function(BufferWriter_) {
        BufferWriter = BufferWriter_;
      };
    }, { "14": 14 }], 16: [function(require2, module2, exports2) {
      module2.exports = BufferWriter;
      var Writer2 = require2(15);
      (BufferWriter.prototype = Object.create(Writer2.prototype)).constructor = BufferWriter;
      var util = require2(14);
      var Buffer3 = util.Buffer;
      function BufferWriter() {
        Writer2.call(this);
      }
      BufferWriter.alloc = function alloc_buffer(size) {
        return (BufferWriter.alloc = util._Buffer_allocUnsafe)(size);
      };
      var writeBytesBuffer = Buffer3 && Buffer3.prototype instanceof Uint8Array && Buffer3.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) {
        buf.set(val, pos);
      } : function writeBytesBuffer_copy(val, buf, pos) {
        if (val.copy)
          val.copy(buf, pos, 0, val.length);
        else
          for (var i2 = 0; i2 < val.length; )
            buf[pos++] = val[i2++];
      };
      BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
        if (util.isString(value))
          value = util._Buffer_from(value, "base64");
        var len = value.length >>> 0;
        this.uint32(len);
        if (len)
          this.push(writeBytesBuffer, len, value);
        return this;
      };
      function writeStringBuffer(val, buf, pos) {
        if (val.length < 40)
          util.utf8.write(val, buf, pos);
        else
          buf.utf8Write(val, pos);
      }
      BufferWriter.prototype.string = function write_string_buffer(value) {
        var len = Buffer3.byteLength(value);
        this.uint32(len);
        if (len)
          this.push(writeStringBuffer, len, value);
        return this;
      };
    }, { "14": 14, "15": 15 }] }, {}, [8]);
  })(typeof window === "object" && window || typeof self === "object" && self || commonjsGlobal);
});
var protobuf$1 = _mergeNamespaces({
  __proto__: null,
  "default": protobuf
}, [protobuf]);

// node_modules/cesium/Source/Core/isBitSet.js
function isBitSet(bits, mask) {
  return (bits & mask) !== 0;
}
var isBitSet_default = isBitSet;

// node_modules/cesium/Source/Core/GoogleEarthEnterpriseTileInformation.js
var childrenBitmasks = [1, 2, 4, 8];
var anyChildBitmask = 15;
var cacheFlagBitmask = 16;
var imageBitmask = 64;
var terrainBitmask = 128;
function GoogleEarthEnterpriseTileInformation(bits, cnodeVersion, imageryVersion, terrainVersion, imageryProvider, terrainProvider) {
  this._bits = bits;
  this.cnodeVersion = cnodeVersion;
  this.imageryVersion = imageryVersion;
  this.terrainVersion = terrainVersion;
  this.imageryProvider = imageryProvider;
  this.terrainProvider = terrainProvider;
  this.ancestorHasTerrain = false;
  this.terrainState = void 0;
}
GoogleEarthEnterpriseTileInformation.clone = function(info, result) {
  if (!defined_default(result)) {
    result = new GoogleEarthEnterpriseTileInformation(
      info._bits,
      info.cnodeVersion,
      info.imageryVersion,
      info.terrainVersion,
      info.imageryProvider,
      info.terrainProvider
    );
  } else {
    result._bits = info._bits;
    result.cnodeVersion = info.cnodeVersion;
    result.imageryVersion = info.imageryVersion;
    result.terrainVersion = info.terrainVersion;
    result.imageryProvider = info.imageryProvider;
    result.terrainProvider = info.terrainProvider;
  }
  result.ancestorHasTerrain = info.ancestorHasTerrain;
  result.terrainState = info.terrainState;
  return result;
};
GoogleEarthEnterpriseTileInformation.prototype.setParent = function(parent) {
  this.ancestorHasTerrain = parent.ancestorHasTerrain || this.hasTerrain();
};
GoogleEarthEnterpriseTileInformation.prototype.hasSubtree = function() {
  return isBitSet_default(this._bits, cacheFlagBitmask);
};
GoogleEarthEnterpriseTileInformation.prototype.hasImagery = function() {
  return isBitSet_default(this._bits, imageBitmask);
};
GoogleEarthEnterpriseTileInformation.prototype.hasTerrain = function() {
  return isBitSet_default(this._bits, terrainBitmask);
};
GoogleEarthEnterpriseTileInformation.prototype.hasChildren = function() {
  return isBitSet_default(this._bits, anyChildBitmask);
};
GoogleEarthEnterpriseTileInformation.prototype.hasChild = function(index2) {
  return isBitSet_default(this._bits, childrenBitmasks[index2]);
};
GoogleEarthEnterpriseTileInformation.prototype.getChildBitmask = function() {
  return this._bits & anyChildBitmask;
};
var GoogleEarthEnterpriseTileInformation_default = GoogleEarthEnterpriseTileInformation;

// node_modules/cesium/Source/Core/GoogleEarthEnterpriseMetadata.js
function stringToBuffer(str) {
  const len = str.length;
  const buffer = new ArrayBuffer(len);
  const ui8 = new Uint8Array(buffer);
  for (let i2 = 0; i2 < len; ++i2) {
    ui8[i2] = str.charCodeAt(i2);
  }
  return buffer;
}
var defaultKey = stringToBuffer(
  `E\xF4\xBD\vy\xE2jE"\x92,\xCDq\xF8IFgQ\0B%\xC6\xE8a,f)\b\xC64\xDCjb%y
wmi\xD6\xF0\x9Ck\x93\xA1\xBDNu\xE0A[\xDF@V\f\xD9\xBBr\x9B\x81|3S\xEEOl\xD4q\xB0{\xC0\x7FEVZ\xADwUe\v3\x92*\xACl5\xC50s\xF83>mF8J\xB4\xDD\xF0.\xDDu\xDA\x8CDt"\xFAa"\f3"So\xAF9D\v\x8C9\xD99L\xB9\xBF\x7F\xAB\\\x8CP_\x9F"ux\xE9\x07q\x91h;\xC1\xC4\x9B\x7F\xF0<VqH\x82'UfYNe\x98u\xA3aF}a?A\0\x9F\xD7\xB44M\xCE\x87F\xB0\xD5\xB8\x8A'{\x8B\xDC+\xBBMg0\xC8\xD1\xF6\\\x8FP\xFA[/F\x9Bn5/'C.\xEB
\f^\xA5s\x1Be4\xE5l.jC'c#U\xA9?q{gC}:\xAF\xCD\xE2TU\x9C\xFDK\xC6\xE2\x9F/(\xED\xCB\\\xC6-f\x07\x88\xA7;/*"N\xB0k.\xDD\r\x95}}G\xBAC\xB2\xB2+>M\xAA>}\xE6\xCEI\x89\xC6\xE6x\fa1-
\xA4O\xA5~q \x88\xEC\r1\xE8N\v\0nPh}=\b\r\x95\xA6n\xA3h\x97$[k\xF3#\xF3\xB6s\xB3\r\v@\xC0\x9F\xD8Q]\xFA".j\xDFI\0\xB9\xA0wU\xC6\xEFj\xBF{GL\x7F\x83\xEE\xDC\xDCF\x85\xA9\xADS\x07+S4\x07\xFF\x94Y\xE48\xE81\x83N\xB9XFk\xCB-#\x86\x92p\x005\x88"\xCF1\xB2&/\xE7\xC3u-6,rt\xB0#G\xB7\xD3\xD1&\x857r\xE2\0\x8CD\xCF\xDA3-\xDE\`\x86i#i*|\xCDKQ\r\x95T9w.)\xEA\x1B\xA6P\xA2j\x8FoP\x99\\>T\xFB\xEFP[\v\x07E\x89m(w7\xDB\x8EJfJo\x99 \xE5p\xE2\xB9q~\fmI-z\xFEr\xC7\xF2Y0\x8F\xBB]s\xE5\xC9 \xEAx\xEC \x90\xF0\x8A\x7FB|G\`\xB0\xBD&\xB7q\xB6\xC7\x9F\xD13\x82=\xD3\xAB\xEEc\x99\xC8+S\xA0D\\q
\xC6\xCCD2O<\xCA\xC0)=R\xD3aX\xA9}e\xB4\xDC\xCF\r\xF4=\xF1\b\xA9B\xDA#	\xD8\xBF^PI\xF8M\xC0\xCBGLO\xF7{+\xD8\xC51\x92;\xB5o\xDCl\r\x92\x88\xD1\x9E\xDB?\xE2\xE9\xDA_\xD4\x84\xE2FaZ\xDEU\xCF\xA4\0\xBE\xFD\xCEg\xF1Ji\x97\xE6 H\xD8]\x7F~\xAEq N\xAE\xC0V\xA9\x91
<\x82r\xE7v\xEC)I\xD6]-\x83\xE3\xDB6\xA9;f\x97\x87j\xD5\xB6=P^R\xB9K\xC7sWx\xC9\xF4.Y\x07\x95\x93o\xD0KW>''\xC7\`\xDB;\xED\x9ASD>?\x8D\x92mw\xA2
\xEB?R\xA8\xC6U^1I7\x85\xF4\xC5&-\xA9\xBF\x8B'T\xDA\xC3j \xE5*x\xB0\xD6\x90pr\xAA\x8Bh\xBD\x88\xF7_H\xB1~\xC0XL?f\xF9>\xE1e\xC0p\xA7\xCF8i\xAF\xF0VldI\x9C'\xADxtO\xC2\x87\xDEV9\0\xDAw\v\xCB-\x1B\x89\xFB5O\xF5\bQ\`\xC1
ZGM&30x\xDA\xC0\x9CFG\xE2[y\`In7gS
>\xE9\xECF9\xB2\xF14\r\xC6\x84Sun\xE1\fY\xD9\xDE)\x85{II\xA5wy\xBEIV.6\xE7\v:\xBBOb{\xD2M1\x95/\xBD8{\xA8O!\xE1\xECFpv\x95})"x\x88
\x90\xDD\x9D\\\xDA\xDEQ\xCF\xF0\xFCYRe|3\xDF\xF3H\xDA\xBB*u\xDB\`\xB2\xD4\xFC\xED\x1B\xEC\x7F5\xA8\xFF(1\x07-\xC8\xDC\x88F|\x8A["`
);
function GoogleEarthEnterpriseMetadata(resourceOrUrl) {
  Check_default.defined("resourceOrUrl", resourceOrUrl);
  let url2 = resourceOrUrl;
  if (typeof url2 !== "string" && !(url2 instanceof Resource_default)) {
    Check_default.typeOf.string("resourceOrUrl.url", resourceOrUrl.url);
    url2 = resourceOrUrl.url;
  }
  const resource = Resource_default.createIfNeeded(url2);
  resource.appendForwardSlash();
  this._resource = resource;
  this.imageryPresent = true;
  this.protoImagery = void 0;
  this.terrainPresent = true;
  this.negativeAltitudeExponentBias = 32;
  this.negativeAltitudeThreshold = Math_default.EPSILON12;
  this.providers = {};
  this.key = void 0;
  this._quadPacketVersion = 1;
  this._tileInfo = {};
  this._subtreePromises = {};
  const that = this;
  this._readyPromise = requestDbRoot(this).then(function() {
    return that.getQuadTreePacket("", that._quadPacketVersion);
  }).then(function() {
    return true;
  }).catch(function(e2) {
    const message = `An error occurred while accessing ${getMetadataResource(that, "", 1).url}.`;
    return Promise.reject(new RuntimeError_default(message));
  });
}
Object.defineProperties(GoogleEarthEnterpriseMetadata.prototype, {
  url: {
    get: function() {
      return this._resource.url;
    }
  },
  proxy: {
    get: function() {
      return this._resource.proxy;
    }
  },
  resource: {
    get: function() {
      return this._resource;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  }
});
GoogleEarthEnterpriseMetadata.tileXYToQuadKey = function(x, y, level) {
  let quadkey = "";
  for (let i2 = level; i2 >= 0; --i2) {
    const bitmask = 1 << i2;
    let digit = 0;
    if (!isBitSet_default(y, bitmask)) {
      digit |= 2;
      if (!isBitSet_default(x, bitmask)) {
        digit |= 1;
      }
    } else if (isBitSet_default(x, bitmask)) {
      digit |= 1;
    }
    quadkey += digit;
  }
  return quadkey;
};
GoogleEarthEnterpriseMetadata.quadKeyToTileXY = function(quadkey) {
  let x = 0;
  let y = 0;
  const level = quadkey.length - 1;
  for (let i2 = level; i2 >= 0; --i2) {
    const bitmask = 1 << i2;
    const digit = +quadkey[level - i2];
    if (isBitSet_default(digit, 2)) {
      if (!isBitSet_default(digit, 1)) {
        x |= bitmask;
      }
    } else {
      y |= bitmask;
      if (isBitSet_default(digit, 1)) {
        x |= bitmask;
      }
    }
  }
  return {
    x,
    y,
    level
  };
};
GoogleEarthEnterpriseMetadata.prototype.isValid = function(quadKey) {
  let info = this.getTileInformationFromQuadKey(quadKey);
  if (defined_default(info)) {
    return info !== null;
  }
  let valid = true;
  let q = quadKey;
  let last;
  while (q.length > 1) {
    last = q.substring(q.length - 1);
    q = q.substring(0, q.length - 1);
    info = this.getTileInformationFromQuadKey(q);
    if (defined_default(info)) {
      if (!info.hasSubtree() && !info.hasChild(parseInt(last))) {
        valid = false;
      }
      break;
    } else if (info === null) {
      valid = false;
      break;
    }
  }
  return valid;
};
var taskProcessor = new TaskProcessor_default("decodeGoogleEarthEnterprisePacket");
GoogleEarthEnterpriseMetadata.prototype.getQuadTreePacket = function(quadKey, version, request) {
  version = defaultValue_default(version, 1);
  quadKey = defaultValue_default(quadKey, "");
  const resource = getMetadataResource(this, quadKey, version, request);
  const promise = resource.fetchArrayBuffer();
  if (!defined_default(promise)) {
    return void 0;
  }
  const tileInfo = this._tileInfo;
  const key = this.key;
  return promise.then(function(metadata) {
    const decodePromise = taskProcessor.scheduleTask(
      {
        buffer: metadata,
        quadKey,
        type: "Metadata",
        key
      },
      [metadata]
    );
    return decodePromise.then(function(result) {
      let root;
      let topLevelKeyLength = -1;
      if (quadKey !== "") {
        topLevelKeyLength = quadKey.length + 1;
        const top = result[quadKey];
        root = tileInfo[quadKey];
        root._bits |= top._bits;
        delete result[quadKey];
      }
      const keys = Object.keys(result);
      keys.sort(function(a4, b) {
        return a4.length - b.length;
      });
      const keysLength = keys.length;
      for (let i2 = 0; i2 < keysLength; ++i2) {
        const key2 = keys[i2];
        const r2 = result[key2];
        if (r2 !== null) {
          const info = GoogleEarthEnterpriseTileInformation_default.clone(result[key2]);
          const keyLength = key2.length;
          if (keyLength === topLevelKeyLength) {
            info.setParent(root);
          } else if (keyLength > 1) {
            const parent = tileInfo[key2.substring(0, key2.length - 1)];
            info.setParent(parent);
          }
          tileInfo[key2] = info;
        } else {
          tileInfo[key2] = null;
        }
      }
    });
  });
};
GoogleEarthEnterpriseMetadata.prototype.populateSubtree = function(x, y, level, request) {
  const quadkey = GoogleEarthEnterpriseMetadata.tileXYToQuadKey(x, y, level);
  return populateSubtree(this, quadkey, request);
};
function populateSubtree(that, quadKey, request) {
  const tileInfo = that._tileInfo;
  let q = quadKey;
  let t = tileInfo[q];
  if (defined_default(t) && (!t.hasSubtree() || t.hasChildren())) {
    return t;
  }
  while (t === void 0 && q.length > 1) {
    q = q.substring(0, q.length - 1);
    t = tileInfo[q];
  }
  let subtreeRequest;
  const subtreePromises = that._subtreePromises;
  let promise = subtreePromises[q];
  if (defined_default(promise)) {
    return promise.then(function() {
      subtreeRequest = new Request_default({
        throttle: request.throttle,
        throttleByServer: request.throttleByServer,
        type: request.type,
        priorityFunction: request.priorityFunction
      });
      return populateSubtree(that, quadKey, subtreeRequest);
    });
  }
  if (!defined_default(t) || !t.hasSubtree()) {
    return Promise.reject(
      new RuntimeError_default(`Couldn't load metadata for tile ${quadKey}`)
    );
  }
  promise = that.getQuadTreePacket(q, t.cnodeVersion, request);
  if (!defined_default(promise)) {
    return void 0;
  }
  subtreePromises[q] = promise;
  return promise.then(function() {
    subtreeRequest = new Request_default({
      throttle: request.throttle,
      throttleByServer: request.throttleByServer,
      type: request.type,
      priorityFunction: request.priorityFunction
    });
    return populateSubtree(that, quadKey, subtreeRequest);
  }).finally(function() {
    delete subtreePromises[q];
  });
}
GoogleEarthEnterpriseMetadata.prototype.getTileInformation = function(x, y, level) {
  const quadkey = GoogleEarthEnterpriseMetadata.tileXYToQuadKey(x, y, level);
  return this._tileInfo[quadkey];
};
GoogleEarthEnterpriseMetadata.prototype.getTileInformationFromQuadKey = function(quadkey) {
  return this._tileInfo[quadkey];
};
function getMetadataResource(that, quadKey, version, request) {
  return that._resource.getDerivedResource({
    url: `flatfile?q2-0${quadKey}-q.${version.toString()}`,
    request
  });
}
var dbrootParser;
var dbrootParserPromise;
function requestDbRoot(that) {
  const resource = that._resource.getDerivedResource({
    url: "dbRoot.v5",
    queryParameters: {
      output: "proto"
    }
  });
  if (!defined_default(dbrootParserPromise)) {
    const url2 = buildModuleUrl_default("ThirdParty/google-earth-dbroot-parser.js");
    const oldValue2 = window.cesiumGoogleEarthDbRootParser;
    dbrootParserPromise = loadAndExecuteScript_default(url2).then(function() {
      dbrootParser = window.cesiumGoogleEarthDbRootParser(protobuf$1);
      if (defined_default(oldValue2)) {
        window.cesiumGoogleEarthDbRootParser = oldValue2;
      } else {
        delete window.cesiumGoogleEarthDbRootParser;
      }
    });
  }
  return dbrootParserPromise.then(function() {
    return resource.fetchArrayBuffer();
  }).then(function(buf) {
    const encryptedDbRootProto = dbrootParser.EncryptedDbRootProto.decode(
      new Uint8Array(buf)
    );
    let byteArray = encryptedDbRootProto.encryptionData;
    let offset2 = byteArray.byteOffset;
    let end = offset2 + byteArray.byteLength;
    const key = that.key = byteArray.buffer.slice(offset2, end);
    byteArray = encryptedDbRootProto.dbrootData;
    offset2 = byteArray.byteOffset;
    end = offset2 + byteArray.byteLength;
    const dbRootCompressed = byteArray.buffer.slice(offset2, end);
    return taskProcessor.scheduleTask(
      {
        buffer: dbRootCompressed,
        type: "DbRoot",
        key
      },
      [dbRootCompressed]
    );
  }).then(function(result) {
    const dbRoot = dbrootParser.DbRootProto.decode(
      new Uint8Array(result.buffer)
    );
    that.imageryPresent = defaultValue_default(
      dbRoot.imageryPresent,
      that.imageryPresent
    );
    that.protoImagery = dbRoot.protoImagery;
    that.terrainPresent = defaultValue_default(
      dbRoot.terrainPresent,
      that.terrainPresent
    );
    if (defined_default(dbRoot.endSnippet) && defined_default(dbRoot.endSnippet.model)) {
      const model = dbRoot.endSnippet.model;
      that.negativeAltitudeExponentBias = defaultValue_default(
        model.negativeAltitudeExponentBias,
        that.negativeAltitudeExponentBias
      );
      that.negativeAltitudeThreshold = defaultValue_default(
        model.compressedNegativeAltitudeThreshold,
        that.negativeAltitudeThreshold
      );
    }
    if (defined_default(dbRoot.databaseVersion)) {
      that._quadPacketVersion = defaultValue_default(
        dbRoot.databaseVersion.quadtreeVersion,
        that._quadPacketVersion
      );
    }
    const providers = that.providers;
    const providerInfo = defaultValue_default(dbRoot.providerInfo, []);
    const count = providerInfo.length;
    for (let i2 = 0; i2 < count; ++i2) {
      const provider = providerInfo[i2];
      const copyrightString = provider.copyrightString;
      if (defined_default(copyrightString)) {
        providers[provider.providerId] = new Credit_default(copyrightString.value);
      }
    }
  }).catch(function() {
    console.log(`Failed to retrieve ${resource.url}. Using defaults.`);
    that.key = defaultKey;
  });
}
var GoogleEarthEnterpriseMetadata_default = GoogleEarthEnterpriseMetadata;

// node_modules/cesium/Source/Core/GoogleEarthEnterpriseTerrainData.js
function GoogleEarthEnterpriseTerrainData(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.buffer", options.buffer);
  Check_default.typeOf.number(
    "options.negativeAltitudeExponentBias",
    options.negativeAltitudeExponentBias
  );
  Check_default.typeOf.number(
    "options.negativeElevationThreshold",
    options.negativeElevationThreshold
  );
  this._buffer = options.buffer;
  this._credits = options.credits;
  this._negativeAltitudeExponentBias = options.negativeAltitudeExponentBias;
  this._negativeElevationThreshold = options.negativeElevationThreshold;
  const googleChildTileMask = defaultValue_default(options.childTileMask, 15);
  let childTileMask = googleChildTileMask & 3;
  childTileMask |= googleChildTileMask & 4 ? 8 : 0;
  childTileMask |= googleChildTileMask & 8 ? 4 : 0;
  this._childTileMask = childTileMask;
  this._createdByUpsampling = defaultValue_default(options.createdByUpsampling, false);
  this._skirtHeight = void 0;
  this._bufferType = this._buffer.constructor;
  this._mesh = void 0;
  this._minimumHeight = void 0;
  this._maximumHeight = void 0;
}
Object.defineProperties(GoogleEarthEnterpriseTerrainData.prototype, {
  credits: {
    get: function() {
      return this._credits;
    }
  },
  waterMask: {
    get: function() {
      return void 0;
    }
  }
});
var createMeshTaskName3 = "createVerticesFromGoogleEarthEnterpriseBuffer";
var createMeshTaskProcessorNoThrottle3 = new TaskProcessor_default(createMeshTaskName3);
var createMeshTaskProcessorThrottle3 = new TaskProcessor_default(
  createMeshTaskName3,
  TerrainData_default.maximumAsynchronousTasks
);
var nativeRectangleScratch = new Rectangle_default();
var rectangleScratch2 = new Rectangle_default();
GoogleEarthEnterpriseTerrainData.prototype.createMesh = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.tilingScheme", options.tilingScheme);
  Check_default.typeOf.number("options.x", options.x);
  Check_default.typeOf.number("options.y", options.y);
  Check_default.typeOf.number("options.level", options.level);
  const tilingScheme2 = options.tilingScheme;
  const x = options.x;
  const y = options.y;
  const level = options.level;
  const exaggeration = defaultValue_default(options.exaggeration, 1);
  const exaggerationRelativeHeight = defaultValue_default(
    options.exaggerationRelativeHeight,
    0
  );
  const throttle = defaultValue_default(options.throttle, true);
  const ellipsoid = tilingScheme2.ellipsoid;
  tilingScheme2.tileXYToNativeRectangle(x, y, level, nativeRectangleScratch);
  tilingScheme2.tileXYToRectangle(x, y, level, rectangleScratch2);
  const center = ellipsoid.cartographicToCartesian(
    Rectangle_default.center(rectangleScratch2)
  );
  const levelZeroMaxError = 40075.16;
  const thisLevelMaxError = levelZeroMaxError / (1 << level);
  this._skirtHeight = Math.min(thisLevelMaxError * 8, 1e3);
  const createMeshTaskProcessor = throttle ? createMeshTaskProcessorThrottle3 : createMeshTaskProcessorNoThrottle3;
  const verticesPromise = createMeshTaskProcessor.scheduleTask({
    buffer: this._buffer,
    nativeRectangle: nativeRectangleScratch,
    rectangle: rectangleScratch2,
    relativeToCenter: center,
    ellipsoid,
    skirtHeight: this._skirtHeight,
    exaggeration,
    exaggerationRelativeHeight,
    includeWebMercatorT: true,
    negativeAltitudeExponentBias: this._negativeAltitudeExponentBias,
    negativeElevationThreshold: this._negativeElevationThreshold
  });
  if (!defined_default(verticesPromise)) {
    return void 0;
  }
  const that = this;
  return verticesPromise.then(function(result) {
    that._mesh = new TerrainMesh_default(
      center,
      new Float32Array(result.vertices),
      new Uint16Array(result.indices),
      result.indexCountWithoutSkirts,
      result.vertexCountWithoutSkirts,
      result.minimumHeight,
      result.maximumHeight,
      BoundingSphere_default.clone(result.boundingSphere3D),
      Cartesian3_default.clone(result.occludeePointInScaledSpace),
      result.numberOfAttributes,
      OrientedBoundingBox_default.clone(result.orientedBoundingBox),
      TerrainEncoding_default.clone(result.encoding),
      result.westIndicesSouthToNorth,
      result.southIndicesEastToWest,
      result.eastIndicesNorthToSouth,
      result.northIndicesWestToEast
    );
    that._minimumHeight = result.minimumHeight;
    that._maximumHeight = result.maximumHeight;
    that._buffer = void 0;
    return that._mesh;
  });
};
GoogleEarthEnterpriseTerrainData.prototype.interpolateHeight = function(rectangle, longitude, latitude) {
  const u3 = Math_default.clamp(
    (longitude - rectangle.west) / rectangle.width,
    0,
    1
  );
  const v7 = Math_default.clamp(
    (latitude - rectangle.south) / rectangle.height,
    0,
    1
  );
  if (!defined_default(this._mesh)) {
    return interpolateHeight3(this, u3, v7, rectangle);
  }
  return interpolateMeshHeight3(this, u3, v7);
};
var upsampleTaskProcessor2 = new TaskProcessor_default(
  "upsampleQuantizedTerrainMesh",
  TerrainData_default.maximumAsynchronousTasks
);
GoogleEarthEnterpriseTerrainData.prototype.upsample = function(tilingScheme2, thisX, thisY, thisLevel, descendantX, descendantY, descendantLevel) {
  Check_default.typeOf.object("tilingScheme", tilingScheme2);
  Check_default.typeOf.number("thisX", thisX);
  Check_default.typeOf.number("thisY", thisY);
  Check_default.typeOf.number("thisLevel", thisLevel);
  Check_default.typeOf.number("descendantX", descendantX);
  Check_default.typeOf.number("descendantY", descendantY);
  Check_default.typeOf.number("descendantLevel", descendantLevel);
  const levelDifference = descendantLevel - thisLevel;
  if (levelDifference > 1) {
    throw new DeveloperError_default(
      "Upsampling through more than one level at a time is not currently supported."
    );
  }
  const mesh2 = this._mesh;
  if (!defined_default(this._mesh)) {
    return void 0;
  }
  const isEastChild = thisX * 2 !== descendantX;
  const isNorthChild = thisY * 2 === descendantY;
  const ellipsoid = tilingScheme2.ellipsoid;
  const childRectangle = tilingScheme2.tileXYToRectangle(
    descendantX,
    descendantY,
    descendantLevel
  );
  const upsamplePromise = upsampleTaskProcessor2.scheduleTask({
    vertices: mesh2.vertices,
    indices: mesh2.indices,
    indexCountWithoutSkirts: mesh2.indexCountWithoutSkirts,
    vertexCountWithoutSkirts: mesh2.vertexCountWithoutSkirts,
    encoding: mesh2.encoding,
    minimumHeight: this._minimumHeight,
    maximumHeight: this._maximumHeight,
    isEastChild,
    isNorthChild,
    childRectangle,
    ellipsoid
  });
  if (!defined_default(upsamplePromise)) {
    return void 0;
  }
  const that = this;
  return upsamplePromise.then(function(result) {
    const quantizedVertices = new Uint16Array(result.vertices);
    const indicesTypedArray = IndexDatatype_default.createTypedArray(
      quantizedVertices.length / 3,
      result.indices
    );
    const skirtHeight = that._skirtHeight;
    return new QuantizedMeshTerrainData_default({
      quantizedVertices,
      indices: indicesTypedArray,
      minimumHeight: result.minimumHeight,
      maximumHeight: result.maximumHeight,
      boundingSphere: BoundingSphere_default.clone(result.boundingSphere),
      orientedBoundingBox: OrientedBoundingBox_default.clone(
        result.orientedBoundingBox
      ),
      horizonOcclusionPoint: Cartesian3_default.clone(result.horizonOcclusionPoint),
      westIndices: result.westIndices,
      southIndices: result.southIndices,
      eastIndices: result.eastIndices,
      northIndices: result.northIndices,
      westSkirtHeight: skirtHeight,
      southSkirtHeight: skirtHeight,
      eastSkirtHeight: skirtHeight,
      northSkirtHeight: skirtHeight,
      childTileMask: 0,
      createdByUpsampling: true,
      credits: that._credits
    });
  });
};
GoogleEarthEnterpriseTerrainData.prototype.isChildAvailable = function(thisX, thisY, childX, childY) {
  Check_default.typeOf.number("thisX", thisX);
  Check_default.typeOf.number("thisY", thisY);
  Check_default.typeOf.number("childX", childX);
  Check_default.typeOf.number("childY", childY);
  let bitNumber = 2;
  if (childX !== thisX * 2) {
    ++bitNumber;
  }
  if (childY !== thisY * 2) {
    bitNumber -= 2;
  }
  return (this._childTileMask & 1 << bitNumber) !== 0;
};
GoogleEarthEnterpriseTerrainData.prototype.wasCreatedByUpsampling = function() {
  return this._createdByUpsampling;
};
var texCoordScratch02 = new Cartesian2_default();
var texCoordScratch12 = new Cartesian2_default();
var texCoordScratch22 = new Cartesian2_default();
var barycentricCoordinateScratch2 = new Cartesian3_default();
function interpolateMeshHeight3(terrainData, u3, v7) {
  const mesh2 = terrainData._mesh;
  const vertices = mesh2.vertices;
  const encoding = mesh2.encoding;
  const indices2 = mesh2.indices;
  for (let i2 = 0, len = indices2.length; i2 < len; i2 += 3) {
    const i0 = indices2[i2];
    const i1 = indices2[i2 + 1];
    const i22 = indices2[i2 + 2];
    const uv0 = encoding.decodeTextureCoordinates(
      vertices,
      i0,
      texCoordScratch02
    );
    const uv1 = encoding.decodeTextureCoordinates(
      vertices,
      i1,
      texCoordScratch12
    );
    const uv2 = encoding.decodeTextureCoordinates(
      vertices,
      i22,
      texCoordScratch22
    );
    const barycentric = Intersections2D_default.computeBarycentricCoordinates(
      u3,
      v7,
      uv0.x,
      uv0.y,
      uv1.x,
      uv1.y,
      uv2.x,
      uv2.y,
      barycentricCoordinateScratch2
    );
    if (barycentric.x >= -1e-15 && barycentric.y >= -1e-15 && barycentric.z >= -1e-15) {
      const h0 = encoding.decodeHeight(vertices, i0);
      const h1 = encoding.decodeHeight(vertices, i1);
      const h2 = encoding.decodeHeight(vertices, i22);
      return barycentric.x * h0 + barycentric.y * h1 + barycentric.z * h2;
    }
  }
  return void 0;
}
var sizeOfUint16 = Uint16Array.BYTES_PER_ELEMENT;
var sizeOfUint32 = Uint32Array.BYTES_PER_ELEMENT;
var sizeOfInt32 = Int32Array.BYTES_PER_ELEMENT;
var sizeOfFloat = Float32Array.BYTES_PER_ELEMENT;
var sizeOfDouble = Float64Array.BYTES_PER_ELEMENT;
function interpolateHeight3(terrainData, u3, v7, rectangle) {
  const buffer = terrainData._buffer;
  let quad = 0;
  let uStart = 0;
  let vStart = 0;
  if (v7 > 0.5) {
    if (u3 > 0.5) {
      quad = 2;
      uStart = 0.5;
    } else {
      quad = 3;
    }
    vStart = 0.5;
  } else if (u3 > 0.5) {
    quad = 1;
    uStart = 0.5;
  }
  const dv = new DataView(buffer);
  let offset2 = 0;
  for (let q = 0; q < quad; ++q) {
    offset2 += dv.getUint32(offset2, true);
    offset2 += sizeOfUint32;
  }
  offset2 += sizeOfUint32;
  offset2 += 2 * sizeOfDouble;
  const xSize = Math_default.toRadians(dv.getFloat64(offset2, true) * 180);
  offset2 += sizeOfDouble;
  const ySize = Math_default.toRadians(dv.getFloat64(offset2, true) * 180);
  offset2 += sizeOfDouble;
  const xScale = rectangle.width / xSize / 2;
  const yScale = rectangle.height / ySize / 2;
  const numPoints = dv.getInt32(offset2, true);
  offset2 += sizeOfInt32;
  const numIndices = dv.getInt32(offset2, true) * 3;
  offset2 += sizeOfInt32;
  offset2 += sizeOfInt32;
  const uBuffer = new Array(numPoints);
  const vBuffer = new Array(numPoints);
  const heights = new Array(numPoints);
  let i2;
  for (i2 = 0; i2 < numPoints; ++i2) {
    uBuffer[i2] = uStart + dv.getUint8(offset2++) * xScale;
    vBuffer[i2] = vStart + dv.getUint8(offset2++) * yScale;
    heights[i2] = dv.getFloat32(offset2, true) * 6371010;
    offset2 += sizeOfFloat;
  }
  const indices2 = new Array(numIndices);
  for (i2 = 0; i2 < numIndices; ++i2) {
    indices2[i2] = dv.getUint16(offset2, true);
    offset2 += sizeOfUint16;
  }
  for (i2 = 0; i2 < numIndices; i2 += 3) {
    const i0 = indices2[i2];
    const i1 = indices2[i2 + 1];
    const i22 = indices2[i2 + 2];
    const u0 = uBuffer[i0];
    const u12 = uBuffer[i1];
    const u22 = uBuffer[i22];
    const v02 = vBuffer[i0];
    const v13 = vBuffer[i1];
    const v23 = vBuffer[i22];
    const barycentric = Intersections2D_default.computeBarycentricCoordinates(
      u3,
      v7,
      u0,
      v02,
      u12,
      v13,
      u22,
      v23,
      barycentricCoordinateScratch2
    );
    if (barycentric.x >= -1e-15 && barycentric.y >= -1e-15 && barycentric.z >= -1e-15) {
      return barycentric.x * heights[i0] + barycentric.y * heights[i1] + barycentric.z * heights[i22];
    }
  }
  return void 0;
}
var GoogleEarthEnterpriseTerrainData_default = GoogleEarthEnterpriseTerrainData;

// node_modules/cesium/Source/Core/GoogleEarthEnterpriseTerrainProvider.js
var TerrainState = {
  UNKNOWN: 0,
  NONE: 1,
  SELF: 2,
  PARENT: 3
};
var julianDateScratch2 = new JulianDate_default();
function TerrainCache() {
  this._terrainCache = {};
  this._lastTidy = JulianDate_default.now();
}
TerrainCache.prototype.add = function(quadKey, buffer) {
  this._terrainCache[quadKey] = {
    buffer,
    timestamp: JulianDate_default.now()
  };
};
TerrainCache.prototype.get = function(quadKey) {
  const terrainCache = this._terrainCache;
  const result = terrainCache[quadKey];
  if (defined_default(result)) {
    delete this._terrainCache[quadKey];
    return result.buffer;
  }
};
TerrainCache.prototype.tidy = function() {
  JulianDate_default.now(julianDateScratch2);
  if (JulianDate_default.secondsDifference(julianDateScratch2, this._lastTidy) > 10) {
    const terrainCache = this._terrainCache;
    const keys = Object.keys(terrainCache);
    const count = keys.length;
    for (let i2 = 0; i2 < count; ++i2) {
      const k = keys[i2];
      const e2 = terrainCache[k];
      if (JulianDate_default.secondsDifference(julianDateScratch2, e2.timestamp) > 10) {
        delete terrainCache[k];
      }
    }
    JulianDate_default.clone(julianDateScratch2, this._lastTidy);
  }
};
function GoogleEarthEnterpriseTerrainProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!(defined_default(options.url) || defined_default(options.metadata))) {
    throw new DeveloperError_default("options.url or options.metadata is required.");
  }
  let metadata;
  if (defined_default(options.metadata)) {
    metadata = options.metadata;
  } else {
    const resource = Resource_default.createIfNeeded(options.url);
    metadata = new GoogleEarthEnterpriseMetadata_default(resource);
  }
  this._metadata = metadata;
  this._tilingScheme = new GeographicTilingScheme_default({
    numberOfLevelZeroTilesX: 2,
    numberOfLevelZeroTilesY: 2,
    rectangle: new Rectangle_default(
      -Math_default.PI,
      -Math_default.PI,
      Math_default.PI,
      Math_default.PI
    ),
    ellipsoid: options.ellipsoid
  });
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  this._credit = credit;
  this._levelZeroMaximumGeometricError = 40075.16;
  this._terrainCache = new TerrainCache();
  this._terrainPromises = {};
  this._terrainRequests = {};
  this._errorEvent = new Event_default();
  this._ready = false;
  const that = this;
  let metadataError;
  this._readyPromise = metadata.readyPromise.then(function(result) {
    if (!metadata.terrainPresent) {
      const e2 = new RuntimeError_default(
        `The server ${metadata.url} doesn't have terrain`
      );
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        e2.message,
        void 0,
        void 0,
        void 0,
        e2
      );
      return Promise.reject(e2);
    }
    TileProviderError_default.handleSuccess(metadataError);
    that._ready = result;
    return result;
  }).catch(function(e2) {
    metadataError = TileProviderError_default.handleError(
      metadataError,
      that,
      that._errorEvent,
      e2.message,
      void 0,
      void 0,
      void 0,
      e2
    );
    return Promise.reject(e2);
  });
}
Object.defineProperties(GoogleEarthEnterpriseTerrainProvider.prototype, {
  url: {
    get: function() {
      return this._metadata.url;
    }
  },
  proxy: {
    get: function() {
      return this._metadata.proxy;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  hasWaterMask: {
    get: function() {
      return false;
    }
  },
  hasVertexNormals: {
    get: function() {
      return false;
    }
  },
  availability: {
    get: function() {
      return void 0;
    }
  }
});
var taskProcessor2 = new TaskProcessor_default("decodeGoogleEarthEnterprisePacket");
function computeChildMask(quadKey, info, metadata) {
  let childMask = info.getChildBitmask();
  if (info.terrainState === TerrainState.PARENT) {
    childMask = 0;
    for (let i2 = 0; i2 < 4; ++i2) {
      const child = metadata.getTileInformationFromQuadKey(
        quadKey + i2.toString()
      );
      if (defined_default(child) && child.hasTerrain()) {
        childMask |= 1 << i2;
      }
    }
  }
  return childMask;
}
GoogleEarthEnterpriseTerrainProvider.prototype.requestTileGeometry = function(x, y, level, request) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "requestTileGeometry must not be called before the terrain provider is ready."
    );
  }
  const quadKey = GoogleEarthEnterpriseMetadata_default.tileXYToQuadKey(x, y, level);
  const terrainCache = this._terrainCache;
  const metadata = this._metadata;
  const info = metadata.getTileInformationFromQuadKey(quadKey);
  if (!defined_default(info)) {
    return Promise.reject(new RuntimeError_default("Terrain tile doesn't exist"));
  }
  let terrainState = info.terrainState;
  if (!defined_default(terrainState)) {
    terrainState = info.terrainState = TerrainState.UNKNOWN;
  }
  const buffer = terrainCache.get(quadKey);
  if (defined_default(buffer)) {
    const credit = metadata.providers[info.terrainProvider];
    return Promise.resolve(
      new GoogleEarthEnterpriseTerrainData_default({
        buffer,
        childTileMask: computeChildMask(quadKey, info, metadata),
        credits: defined_default(credit) ? [credit] : void 0,
        negativeAltitudeExponentBias: metadata.negativeAltitudeExponentBias,
        negativeElevationThreshold: metadata.negativeAltitudeThreshold
      })
    );
  }
  terrainCache.tidy();
  if (!info.ancestorHasTerrain) {
    return Promise.resolve(
      new HeightmapTerrainData_default({
        buffer: new Uint8Array(16 * 16),
        width: 16,
        height: 16
      })
    );
  } else if (terrainState === TerrainState.NONE) {
    return Promise.reject(new RuntimeError_default("Terrain tile doesn't exist"));
  }
  let parentInfo;
  let q = quadKey;
  let terrainVersion = -1;
  switch (terrainState) {
    case TerrainState.SELF:
      terrainVersion = info.terrainVersion;
      break;
    case TerrainState.PARENT:
      q = q.substring(0, q.length - 1);
      parentInfo = metadata.getTileInformationFromQuadKey(q);
      terrainVersion = parentInfo.terrainVersion;
      break;
    case TerrainState.UNKNOWN:
      if (info.hasTerrain()) {
        terrainVersion = info.terrainVersion;
      } else {
        q = q.substring(0, q.length - 1);
        parentInfo = metadata.getTileInformationFromQuadKey(q);
        if (defined_default(parentInfo) && parentInfo.hasTerrain()) {
          terrainVersion = parentInfo.terrainVersion;
        }
      }
      break;
  }
  if (terrainVersion < 0) {
    return Promise.reject(new RuntimeError_default("Terrain tile doesn't exist"));
  }
  const terrainPromises = this._terrainPromises;
  const terrainRequests = this._terrainRequests;
  let sharedPromise;
  let sharedRequest;
  if (defined_default(terrainPromises[q])) {
    sharedPromise = terrainPromises[q];
    sharedRequest = terrainRequests[q];
  } else {
    sharedRequest = request;
    const requestPromise = buildTerrainResource(
      this,
      q,
      terrainVersion,
      sharedRequest
    ).fetchArrayBuffer();
    if (!defined_default(requestPromise)) {
      return void 0;
    }
    sharedPromise = requestPromise.then(function(terrain) {
      if (defined_default(terrain)) {
        return taskProcessor2.scheduleTask(
          {
            buffer: terrain,
            type: "Terrain",
            key: metadata.key
          },
          [terrain]
        ).then(function(terrainTiles) {
          const requestedInfo = metadata.getTileInformationFromQuadKey(q);
          requestedInfo.terrainState = TerrainState.SELF;
          terrainCache.add(q, terrainTiles[0]);
          const provider = requestedInfo.terrainProvider;
          const count = terrainTiles.length - 1;
          for (let j = 0; j < count; ++j) {
            const childKey = q + j.toString();
            const child = metadata.getTileInformationFromQuadKey(childKey);
            if (defined_default(child)) {
              terrainCache.add(childKey, terrainTiles[j + 1]);
              child.terrainState = TerrainState.PARENT;
              if (child.terrainProvider === 0) {
                child.terrainProvider = provider;
              }
            }
          }
        });
      }
      return Promise.reject(new RuntimeError_default("Failed to load terrain."));
    });
    terrainPromises[q] = sharedPromise;
    terrainRequests[q] = sharedRequest;
    sharedPromise = sharedPromise.finally(function() {
      delete terrainPromises[q];
      delete terrainRequests[q];
    });
  }
  return sharedPromise.then(function() {
    const buffer2 = terrainCache.get(quadKey);
    if (defined_default(buffer2)) {
      const credit = metadata.providers[info.terrainProvider];
      return new GoogleEarthEnterpriseTerrainData_default({
        buffer: buffer2,
        childTileMask: computeChildMask(quadKey, info, metadata),
        credits: defined_default(credit) ? [credit] : void 0,
        negativeAltitudeExponentBias: metadata.negativeAltitudeExponentBias,
        negativeElevationThreshold: metadata.negativeAltitudeThreshold
      });
    }
    return Promise.reject(new RuntimeError_default("Failed to load terrain."));
  }).catch(function(error) {
    if (sharedRequest.state === RequestState_default.CANCELLED) {
      request.state = sharedRequest.state;
      return Promise.reject(error);
    }
    info.terrainState = TerrainState.NONE;
    return Promise.reject(error);
  });
};
GoogleEarthEnterpriseTerrainProvider.prototype.getLevelMaximumGeometricError = function(level) {
  return this._levelZeroMaximumGeometricError / (1 << level);
};
GoogleEarthEnterpriseTerrainProvider.prototype.getTileDataAvailable = function(x, y, level) {
  const metadata = this._metadata;
  let quadKey = GoogleEarthEnterpriseMetadata_default.tileXYToQuadKey(x, y, level);
  const info = metadata.getTileInformation(x, y, level);
  if (info === null) {
    return false;
  }
  if (defined_default(info)) {
    if (!info.ancestorHasTerrain) {
      return true;
    }
    const terrainState = info.terrainState;
    if (terrainState === TerrainState.NONE) {
      return false;
    }
    if (!defined_default(terrainState) || terrainState === TerrainState.UNKNOWN) {
      info.terrainState = TerrainState.UNKNOWN;
      if (!info.hasTerrain()) {
        quadKey = quadKey.substring(0, quadKey.length - 1);
        const parentInfo = metadata.getTileInformationFromQuadKey(quadKey);
        if (!defined_default(parentInfo) || !parentInfo.hasTerrain()) {
          return false;
        }
      }
    }
    return true;
  }
  if (metadata.isValid(quadKey)) {
    const request = new Request_default({
      throttle: false,
      throttleByServer: true,
      type: RequestType_default.TERRAIN
    });
    metadata.populateSubtree(x, y, level, request);
  }
  return false;
};
GoogleEarthEnterpriseTerrainProvider.prototype.loadTileDataAvailability = function(x, y, level) {
  return void 0;
};
function buildTerrainResource(terrainProvider, quadKey, version, request) {
  version = defined_default(version) && version > 0 ? version : 1;
  return terrainProvider._metadata.resource.getDerivedResource({
    url: `flatfile?f1c-0${quadKey}-t.${version.toString()}`,
    request
  });
}
var GoogleEarthEnterpriseTerrainProvider_default = GoogleEarthEnterpriseTerrainProvider;

// node_modules/cesium/Source/Core/GroundPolylineGeometry.js
var PROJECTIONS = [GeographicProjection_default, WebMercatorProjection_default];
var PROJECTION_COUNT = PROJECTIONS.length;
var MITER_BREAK_SMALL = Math.cos(Math_default.toRadians(30));
var MITER_BREAK_LARGE = Math.cos(Math_default.toRadians(150));
var WALL_INITIAL_MIN_HEIGHT = 0;
var WALL_INITIAL_MAX_HEIGHT = 1e3;
function GroundPolylineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.positions;
  if (!defined_default(positions) || positions.length < 2) {
    throw new DeveloperError_default("At least two positions are required.");
  }
  if (defined_default(options.arcType) && options.arcType !== ArcType_default.GEODESIC && options.arcType !== ArcType_default.RHUMB) {
    throw new DeveloperError_default(
      "Valid options for arcType are ArcType.GEODESIC and ArcType.RHUMB."
    );
  }
  this.width = defaultValue_default(options.width, 1);
  this._positions = positions;
  this.granularity = defaultValue_default(options.granularity, 9999);
  this.loop = defaultValue_default(options.loop, false);
  this.arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
  this._ellipsoid = Ellipsoid_default.WGS84;
  this._projectionIndex = 0;
  this._workerName = "createGroundPolylineGeometry";
  this._scene3DOnly = false;
}
Object.defineProperties(GroundPolylineGeometry.prototype, {
  packedLength: {
    get: function() {
      return 1 + this._positions.length * 3 + 1 + 1 + 1 + Ellipsoid_default.packedLength + 1 + 1;
    }
  }
});
GroundPolylineGeometry.setProjectionAndEllipsoid = function(groundPolylineGeometry, mapProjection) {
  let projectionIndex = 0;
  for (let i2 = 0; i2 < PROJECTION_COUNT; i2++) {
    if (mapProjection instanceof PROJECTIONS[i2]) {
      projectionIndex = i2;
      break;
    }
  }
  groundPolylineGeometry._projectionIndex = projectionIndex;
  groundPolylineGeometry._ellipsoid = mapProjection.ellipsoid;
};
var cart3Scratch1 = new Cartesian3_default();
var cart3Scratch2 = new Cartesian3_default();
var cart3Scratch3 = new Cartesian3_default();
function computeRightNormal(start, end, maxHeight, ellipsoid, result) {
  const startBottom = getPosition(ellipsoid, start, 0, cart3Scratch1);
  const startTop = getPosition(ellipsoid, start, maxHeight, cart3Scratch2);
  const endBottom = getPosition(ellipsoid, end, 0, cart3Scratch3);
  const up = direction(startTop, startBottom, cart3Scratch2);
  const forward = direction(endBottom, startBottom, cart3Scratch3);
  Cartesian3_default.cross(forward, up, result);
  return Cartesian3_default.normalize(result, result);
}
var interpolatedCartographicScratch = new Cartographic_default();
var interpolatedBottomScratch = new Cartesian3_default();
var interpolatedTopScratch = new Cartesian3_default();
var interpolatedNormalScratch = new Cartesian3_default();
function interpolateSegment(start, end, minHeight, maxHeight, granularity, arcType, ellipsoid, normalsArray, bottomPositionsArray, topPositionsArray, cartographicsArray) {
  if (granularity === 0) {
    return;
  }
  let ellipsoidLine;
  if (arcType === ArcType_default.GEODESIC) {
    ellipsoidLine = new EllipsoidGeodesic_default(start, end, ellipsoid);
  } else if (arcType === ArcType_default.RHUMB) {
    ellipsoidLine = new EllipsoidRhumbLine_default(start, end, ellipsoid);
  }
  const surfaceDistance = ellipsoidLine.surfaceDistance;
  if (surfaceDistance < granularity) {
    return;
  }
  const interpolatedNormal = computeRightNormal(
    start,
    end,
    maxHeight,
    ellipsoid,
    interpolatedNormalScratch
  );
  const segments = Math.ceil(surfaceDistance / granularity);
  const interpointDistance = surfaceDistance / segments;
  let distanceFromStart = interpointDistance;
  const pointsToAdd = segments - 1;
  let packIndex = normalsArray.length;
  for (let i2 = 0; i2 < pointsToAdd; i2++) {
    const interpolatedCartographic = ellipsoidLine.interpolateUsingSurfaceDistance(
      distanceFromStart,
      interpolatedCartographicScratch
    );
    const interpolatedBottom = getPosition(
      ellipsoid,
      interpolatedCartographic,
      minHeight,
      interpolatedBottomScratch
    );
    const interpolatedTop = getPosition(
      ellipsoid,
      interpolatedCartographic,
      maxHeight,
      interpolatedTopScratch
    );
    Cartesian3_default.pack(interpolatedNormal, normalsArray, packIndex);
    Cartesian3_default.pack(interpolatedBottom, bottomPositionsArray, packIndex);
    Cartesian3_default.pack(interpolatedTop, topPositionsArray, packIndex);
    cartographicsArray.push(interpolatedCartographic.latitude);
    cartographicsArray.push(interpolatedCartographic.longitude);
    packIndex += 3;
    distanceFromStart += interpointDistance;
  }
}
var heightlessCartographicScratch = new Cartographic_default();
function getPosition(ellipsoid, cartographic2, height, result) {
  Cartographic_default.clone(cartographic2, heightlessCartographicScratch);
  heightlessCartographicScratch.height = height;
  return Cartographic_default.toCartesian(
    heightlessCartographicScratch,
    ellipsoid,
    result
  );
}
GroundPolylineGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  let index2 = defaultValue_default(startingIndex, 0);
  const positions = value._positions;
  const positionsLength = positions.length;
  array[index2++] = positionsLength;
  for (let i2 = 0; i2 < positionsLength; ++i2) {
    const cartesian11 = positions[i2];
    Cartesian3_default.pack(cartesian11, array, index2);
    index2 += 3;
  }
  array[index2++] = value.granularity;
  array[index2++] = value.loop ? 1 : 0;
  array[index2++] = value.arcType;
  Ellipsoid_default.pack(value._ellipsoid, array, index2);
  index2 += Ellipsoid_default.packedLength;
  array[index2++] = value._projectionIndex;
  array[index2++] = value._scene3DOnly ? 1 : 0;
  return array;
};
GroundPolylineGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  let index2 = defaultValue_default(startingIndex, 0);
  const positionsLength = array[index2++];
  const positions = new Array(positionsLength);
  for (let i2 = 0; i2 < positionsLength; i2++) {
    positions[i2] = Cartesian3_default.unpack(array, index2);
    index2 += 3;
  }
  const granularity = array[index2++];
  const loop = array[index2++] === 1;
  const arcType = array[index2++];
  const ellipsoid = Ellipsoid_default.unpack(array, index2);
  index2 += Ellipsoid_default.packedLength;
  const projectionIndex = array[index2++];
  const scene3DOnly = array[index2++] === 1;
  if (!defined_default(result)) {
    result = new GroundPolylineGeometry({
      positions
    });
  }
  result._positions = positions;
  result.granularity = granularity;
  result.loop = loop;
  result.arcType = arcType;
  result._ellipsoid = ellipsoid;
  result._projectionIndex = projectionIndex;
  result._scene3DOnly = scene3DOnly;
  return result;
};
function direction(target, origin, result) {
  Cartesian3_default.subtract(target, origin, result);
  Cartesian3_default.normalize(result, result);
  return result;
}
function tangentDirection(target, origin, up, result) {
  result = direction(target, origin, result);
  result = Cartesian3_default.cross(result, up, result);
  result = Cartesian3_default.normalize(result, result);
  result = Cartesian3_default.cross(up, result, result);
  return result;
}
var toPreviousScratch = new Cartesian3_default();
var toNextScratch = new Cartesian3_default();
var forwardScratch = new Cartesian3_default();
var vertexUpScratch = new Cartesian3_default();
var cosine90 = 0;
var cosine180 = -1;
function computeVertexMiterNormal(previousBottom, vertexBottom, vertexTop, nextBottom, result) {
  const up = direction(vertexTop, vertexBottom, vertexUpScratch);
  const toPrevious = tangentDirection(
    previousBottom,
    vertexBottom,
    up,
    toPreviousScratch
  );
  const toNext = tangentDirection(nextBottom, vertexBottom, up, toNextScratch);
  if (Math_default.equalsEpsilon(
    Cartesian3_default.dot(toPrevious, toNext),
    cosine180,
    Math_default.EPSILON5
  )) {
    result = Cartesian3_default.cross(up, toPrevious, result);
    result = Cartesian3_default.normalize(result, result);
    return result;
  }
  result = Cartesian3_default.add(toNext, toPrevious, result);
  result = Cartesian3_default.normalize(result, result);
  const forward = Cartesian3_default.cross(up, result, forwardScratch);
  if (Cartesian3_default.dot(toNext, forward) < cosine90) {
    result = Cartesian3_default.negate(result, result);
  }
  return result;
}
var XZ_PLANE = Plane_default.fromPointNormal(Cartesian3_default.ZERO, Cartesian3_default.UNIT_Y);
var previousBottomScratch = new Cartesian3_default();
var vertexBottomScratch = new Cartesian3_default();
var vertexTopScratch = new Cartesian3_default();
var nextBottomScratch = new Cartesian3_default();
var vertexNormalScratch = new Cartesian3_default();
var intersectionScratch = new Cartesian3_default();
var cartographicScratch0 = new Cartographic_default();
var cartographicScratch1 = new Cartographic_default();
var cartographicIntersectionScratch = new Cartographic_default();
GroundPolylineGeometry.createGeometry = function(groundPolylineGeometry) {
  const compute2dAttributes = !groundPolylineGeometry._scene3DOnly;
  let loop = groundPolylineGeometry.loop;
  const ellipsoid = groundPolylineGeometry._ellipsoid;
  const granularity = groundPolylineGeometry.granularity;
  const arcType = groundPolylineGeometry.arcType;
  const projection = new PROJECTIONS[groundPolylineGeometry._projectionIndex](
    ellipsoid
  );
  const minHeight = WALL_INITIAL_MIN_HEIGHT;
  const maxHeight = WALL_INITIAL_MAX_HEIGHT;
  let index2;
  let i2;
  const positions = groundPolylineGeometry._positions;
  const positionsLength = positions.length;
  if (positionsLength === 2) {
    loop = false;
  }
  let p0;
  let p1;
  let c0;
  let c14;
  const rhumbLine = new EllipsoidRhumbLine_default(void 0, void 0, ellipsoid);
  let intersection;
  let intersectionCartographic;
  let intersectionLongitude;
  const splitPositions = [positions[0]];
  for (i2 = 0; i2 < positionsLength - 1; i2++) {
    p0 = positions[i2];
    p1 = positions[i2 + 1];
    intersection = IntersectionTests_default.lineSegmentPlane(
      p0,
      p1,
      XZ_PLANE,
      intersectionScratch
    );
    if (defined_default(intersection) && !Cartesian3_default.equalsEpsilon(intersection, p0, Math_default.EPSILON7) && !Cartesian3_default.equalsEpsilon(intersection, p1, Math_default.EPSILON7)) {
      if (groundPolylineGeometry.arcType === ArcType_default.GEODESIC) {
        splitPositions.push(Cartesian3_default.clone(intersection));
      } else if (groundPolylineGeometry.arcType === ArcType_default.RHUMB) {
        intersectionLongitude = ellipsoid.cartesianToCartographic(
          intersection,
          cartographicScratch0
        ).longitude;
        c0 = ellipsoid.cartesianToCartographic(p0, cartographicScratch0);
        c14 = ellipsoid.cartesianToCartographic(p1, cartographicScratch1);
        rhumbLine.setEndPoints(c0, c14);
        intersectionCartographic = rhumbLine.findIntersectionWithLongitude(
          intersectionLongitude,
          cartographicIntersectionScratch
        );
        intersection = ellipsoid.cartographicToCartesian(
          intersectionCartographic,
          intersectionScratch
        );
        if (defined_default(intersection) && !Cartesian3_default.equalsEpsilon(intersection, p0, Math_default.EPSILON7) && !Cartesian3_default.equalsEpsilon(intersection, p1, Math_default.EPSILON7)) {
          splitPositions.push(Cartesian3_default.clone(intersection));
        }
      }
    }
    splitPositions.push(p1);
  }
  if (loop) {
    p0 = positions[positionsLength - 1];
    p1 = positions[0];
    intersection = IntersectionTests_default.lineSegmentPlane(
      p0,
      p1,
      XZ_PLANE,
      intersectionScratch
    );
    if (defined_default(intersection) && !Cartesian3_default.equalsEpsilon(intersection, p0, Math_default.EPSILON7) && !Cartesian3_default.equalsEpsilon(intersection, p1, Math_default.EPSILON7)) {
      if (groundPolylineGeometry.arcType === ArcType_default.GEODESIC) {
        splitPositions.push(Cartesian3_default.clone(intersection));
      } else if (groundPolylineGeometry.arcType === ArcType_default.RHUMB) {
        intersectionLongitude = ellipsoid.cartesianToCartographic(
          intersection,
          cartographicScratch0
        ).longitude;
        c0 = ellipsoid.cartesianToCartographic(p0, cartographicScratch0);
        c14 = ellipsoid.cartesianToCartographic(p1, cartographicScratch1);
        rhumbLine.setEndPoints(c0, c14);
        intersectionCartographic = rhumbLine.findIntersectionWithLongitude(
          intersectionLongitude,
          cartographicIntersectionScratch
        );
        intersection = ellipsoid.cartographicToCartesian(
          intersectionCartographic,
          intersectionScratch
        );
        if (defined_default(intersection) && !Cartesian3_default.equalsEpsilon(intersection, p0, Math_default.EPSILON7) && !Cartesian3_default.equalsEpsilon(intersection, p1, Math_default.EPSILON7)) {
          splitPositions.push(Cartesian3_default.clone(intersection));
        }
      }
    }
  }
  let cartographicsLength = splitPositions.length;
  let cartographics = new Array(cartographicsLength);
  for (i2 = 0; i2 < cartographicsLength; i2++) {
    const cartographic2 = Cartographic_default.fromCartesian(
      splitPositions[i2],
      ellipsoid
    );
    cartographic2.height = 0;
    cartographics[i2] = cartographic2;
  }
  cartographics = arrayRemoveDuplicates_default(
    cartographics,
    Cartographic_default.equalsEpsilon
  );
  cartographicsLength = cartographics.length;
  if (cartographicsLength < 2) {
    return void 0;
  }
  const cartographicsArray = [];
  const normalsArray = [];
  const bottomPositionsArray = [];
  const topPositionsArray = [];
  let previousBottom = previousBottomScratch;
  let vertexBottom = vertexBottomScratch;
  let vertexTop = vertexTopScratch;
  let nextBottom = nextBottomScratch;
  let vertexNormal = vertexNormalScratch;
  const startCartographic = cartographics[0];
  const nextCartographic = cartographics[1];
  const prestartCartographic = cartographics[cartographicsLength - 1];
  previousBottom = getPosition(
    ellipsoid,
    prestartCartographic,
    minHeight,
    previousBottom
  );
  nextBottom = getPosition(ellipsoid, nextCartographic, minHeight, nextBottom);
  vertexBottom = getPosition(
    ellipsoid,
    startCartographic,
    minHeight,
    vertexBottom
  );
  vertexTop = getPosition(ellipsoid, startCartographic, maxHeight, vertexTop);
  if (loop) {
    vertexNormal = computeVertexMiterNormal(
      previousBottom,
      vertexBottom,
      vertexTop,
      nextBottom,
      vertexNormal
    );
  } else {
    vertexNormal = computeRightNormal(
      startCartographic,
      nextCartographic,
      maxHeight,
      ellipsoid,
      vertexNormal
    );
  }
  Cartesian3_default.pack(vertexNormal, normalsArray, 0);
  Cartesian3_default.pack(vertexBottom, bottomPositionsArray, 0);
  Cartesian3_default.pack(vertexTop, topPositionsArray, 0);
  cartographicsArray.push(startCartographic.latitude);
  cartographicsArray.push(startCartographic.longitude);
  interpolateSegment(
    startCartographic,
    nextCartographic,
    minHeight,
    maxHeight,
    granularity,
    arcType,
    ellipsoid,
    normalsArray,
    bottomPositionsArray,
    topPositionsArray,
    cartographicsArray
  );
  for (i2 = 1; i2 < cartographicsLength - 1; ++i2) {
    previousBottom = Cartesian3_default.clone(vertexBottom, previousBottom);
    vertexBottom = Cartesian3_default.clone(nextBottom, vertexBottom);
    const vertexCartographic = cartographics[i2];
    getPosition(ellipsoid, vertexCartographic, maxHeight, vertexTop);
    getPosition(ellipsoid, cartographics[i2 + 1], minHeight, nextBottom);
    computeVertexMiterNormal(
      previousBottom,
      vertexBottom,
      vertexTop,
      nextBottom,
      vertexNormal
    );
    index2 = normalsArray.length;
    Cartesian3_default.pack(vertexNormal, normalsArray, index2);
    Cartesian3_default.pack(vertexBottom, bottomPositionsArray, index2);
    Cartesian3_default.pack(vertexTop, topPositionsArray, index2);
    cartographicsArray.push(vertexCartographic.latitude);
    cartographicsArray.push(vertexCartographic.longitude);
    interpolateSegment(
      cartographics[i2],
      cartographics[i2 + 1],
      minHeight,
      maxHeight,
      granularity,
      arcType,
      ellipsoid,
      normalsArray,
      bottomPositionsArray,
      topPositionsArray,
      cartographicsArray
    );
  }
  const endCartographic = cartographics[cartographicsLength - 1];
  const preEndCartographic = cartographics[cartographicsLength - 2];
  vertexBottom = getPosition(
    ellipsoid,
    endCartographic,
    minHeight,
    vertexBottom
  );
  vertexTop = getPosition(ellipsoid, endCartographic, maxHeight, vertexTop);
  if (loop) {
    const postEndCartographic = cartographics[0];
    previousBottom = getPosition(
      ellipsoid,
      preEndCartographic,
      minHeight,
      previousBottom
    );
    nextBottom = getPosition(
      ellipsoid,
      postEndCartographic,
      minHeight,
      nextBottom
    );
    vertexNormal = computeVertexMiterNormal(
      previousBottom,
      vertexBottom,
      vertexTop,
      nextBottom,
      vertexNormal
    );
  } else {
    vertexNormal = computeRightNormal(
      preEndCartographic,
      endCartographic,
      maxHeight,
      ellipsoid,
      vertexNormal
    );
  }
  index2 = normalsArray.length;
  Cartesian3_default.pack(vertexNormal, normalsArray, index2);
  Cartesian3_default.pack(vertexBottom, bottomPositionsArray, index2);
  Cartesian3_default.pack(vertexTop, topPositionsArray, index2);
  cartographicsArray.push(endCartographic.latitude);
  cartographicsArray.push(endCartographic.longitude);
  if (loop) {
    interpolateSegment(
      endCartographic,
      startCartographic,
      minHeight,
      maxHeight,
      granularity,
      arcType,
      ellipsoid,
      normalsArray,
      bottomPositionsArray,
      topPositionsArray,
      cartographicsArray
    );
    index2 = normalsArray.length;
    for (i2 = 0; i2 < 3; ++i2) {
      normalsArray[index2 + i2] = normalsArray[i2];
      bottomPositionsArray[index2 + i2] = bottomPositionsArray[i2];
      topPositionsArray[index2 + i2] = topPositionsArray[i2];
    }
    cartographicsArray.push(startCartographic.latitude);
    cartographicsArray.push(startCartographic.longitude);
  }
  return generateGeometryAttributes(
    loop,
    projection,
    bottomPositionsArray,
    topPositionsArray,
    normalsArray,
    cartographicsArray,
    compute2dAttributes
  );
};
var lineDirectionScratch = new Cartesian3_default();
var matrix3Scratch = new Matrix3_default();
var quaternionScratch3 = new Quaternion_default();
function breakMiter(endGeometryNormal, startBottom, endBottom, endTop) {
  const lineDirection = direction(endBottom, startBottom, lineDirectionScratch);
  const dot2 = Cartesian3_default.dot(lineDirection, endGeometryNormal);
  if (dot2 > MITER_BREAK_SMALL || dot2 < MITER_BREAK_LARGE) {
    const vertexUp = direction(endTop, endBottom, vertexUpScratch);
    const angle = dot2 < MITER_BREAK_LARGE ? Math_default.PI_OVER_TWO : -Math_default.PI_OVER_TWO;
    const quaternion = Quaternion_default.fromAxisAngle(
      vertexUp,
      angle,
      quaternionScratch3
    );
    const rotationMatrix = Matrix3_default.fromQuaternion(quaternion, matrix3Scratch);
    Matrix3_default.multiplyByVector(
      rotationMatrix,
      endGeometryNormal,
      endGeometryNormal
    );
    return true;
  }
  return false;
}
var endPosCartographicScratch = new Cartographic_default();
var normalStartpointScratch = new Cartesian3_default();
var normalEndpointScratch = new Cartesian3_default();
function projectNormal(projection, cartographic2, normal2, projectedPosition2, result) {
  const position = Cartographic_default.toCartesian(
    cartographic2,
    projection._ellipsoid,
    normalStartpointScratch
  );
  let normalEndpoint = Cartesian3_default.add(position, normal2, normalEndpointScratch);
  let flipNormal = false;
  const ellipsoid = projection._ellipsoid;
  let normalEndpointCartographic = ellipsoid.cartesianToCartographic(
    normalEndpoint,
    endPosCartographicScratch
  );
  if (Math.abs(cartographic2.longitude - normalEndpointCartographic.longitude) > Math_default.PI_OVER_TWO) {
    flipNormal = true;
    normalEndpoint = Cartesian3_default.subtract(
      position,
      normal2,
      normalEndpointScratch
    );
    normalEndpointCartographic = ellipsoid.cartesianToCartographic(
      normalEndpoint,
      endPosCartographicScratch
    );
  }
  normalEndpointCartographic.height = 0;
  const normalEndpointProjected = projection.project(
    normalEndpointCartographic,
    result
  );
  result = Cartesian3_default.subtract(
    normalEndpointProjected,
    projectedPosition2,
    result
  );
  result.z = 0;
  result = Cartesian3_default.normalize(result, result);
  if (flipNormal) {
    Cartesian3_default.negate(result, result);
  }
  return result;
}
var adjustHeightNormalScratch = new Cartesian3_default();
var adjustHeightOffsetScratch = new Cartesian3_default();
function adjustHeights(bottom, top, minHeight, maxHeight, adjustHeightBottom, adjustHeightTop) {
  const adjustHeightNormal = Cartesian3_default.subtract(
    top,
    bottom,
    adjustHeightNormalScratch
  );
  Cartesian3_default.normalize(adjustHeightNormal, adjustHeightNormal);
  const distanceForBottom = minHeight - WALL_INITIAL_MIN_HEIGHT;
  let adjustHeightOffset = Cartesian3_default.multiplyByScalar(
    adjustHeightNormal,
    distanceForBottom,
    adjustHeightOffsetScratch
  );
  Cartesian3_default.add(bottom, adjustHeightOffset, adjustHeightBottom);
  const distanceForTop = maxHeight - WALL_INITIAL_MAX_HEIGHT;
  adjustHeightOffset = Cartesian3_default.multiplyByScalar(
    adjustHeightNormal,
    distanceForTop,
    adjustHeightOffsetScratch
  );
  Cartesian3_default.add(top, adjustHeightOffset, adjustHeightTop);
}
var nudgeDirectionScratch = new Cartesian3_default();
function nudgeXZ(start, end) {
  const startToXZdistance = Plane_default.getPointDistance(XZ_PLANE, start);
  const endToXZdistance = Plane_default.getPointDistance(XZ_PLANE, end);
  let offset2 = nudgeDirectionScratch;
  if (Math_default.equalsEpsilon(startToXZdistance, 0, Math_default.EPSILON2)) {
    offset2 = direction(end, start, offset2);
    Cartesian3_default.multiplyByScalar(offset2, Math_default.EPSILON2, offset2);
    Cartesian3_default.add(start, offset2, start);
  } else if (Math_default.equalsEpsilon(endToXZdistance, 0, Math_default.EPSILON2)) {
    offset2 = direction(start, end, offset2);
    Cartesian3_default.multiplyByScalar(offset2, Math_default.EPSILON2, offset2);
    Cartesian3_default.add(end, offset2, end);
  }
}
function nudgeCartographic(start, end) {
  const absStartLon = Math.abs(start.longitude);
  const absEndLon = Math.abs(end.longitude);
  if (Math_default.equalsEpsilon(absStartLon, Math_default.PI, Math_default.EPSILON11)) {
    const endSign = Math_default.sign(end.longitude);
    start.longitude = endSign * (absStartLon - Math_default.EPSILON11);
    return 1;
  } else if (Math_default.equalsEpsilon(absEndLon, Math_default.PI, Math_default.EPSILON11)) {
    const startSign = Math_default.sign(start.longitude);
    end.longitude = startSign * (absEndLon - Math_default.EPSILON11);
    return 2;
  }
  return 0;
}
var startCartographicScratch = new Cartographic_default();
var endCartographicScratch = new Cartographic_default();
var segmentStartTopScratch = new Cartesian3_default();
var segmentEndTopScratch = new Cartesian3_default();
var segmentStartBottomScratch = new Cartesian3_default();
var segmentEndBottomScratch = new Cartesian3_default();
var segmentStartNormalScratch = new Cartesian3_default();
var segmentEndNormalScratch = new Cartesian3_default();
var getHeightCartographics = [
  startCartographicScratch,
  endCartographicScratch
];
var getHeightRectangleScratch = new Rectangle_default();
var adjustHeightStartTopScratch = new Cartesian3_default();
var adjustHeightEndTopScratch = new Cartesian3_default();
var adjustHeightStartBottomScratch = new Cartesian3_default();
var adjustHeightEndBottomScratch = new Cartesian3_default();
var segmentStart2DScratch = new Cartesian3_default();
var segmentEnd2DScratch = new Cartesian3_default();
var segmentStartNormal2DScratch = new Cartesian3_default();
var segmentEndNormal2DScratch = new Cartesian3_default();
var offsetScratch2 = new Cartesian3_default();
var startUpScratch = new Cartesian3_default();
var endUpScratch = new Cartesian3_default();
var rightScratch2 = new Cartesian3_default();
var startPlaneNormalScratch = new Cartesian3_default();
var endPlaneNormalScratch = new Cartesian3_default();
var encodeScratch = new EncodedCartesian3_default();
var encodeScratch2D = new EncodedCartesian3_default();
var forwardOffset2DScratch = new Cartesian3_default();
var right2DScratch = new Cartesian3_default();
var normalNudgeScratch = new Cartesian3_default();
var scratchBoundingSpheres = [new BoundingSphere_default(), new BoundingSphere_default()];
var REFERENCE_INDICES = [
  0,
  2,
  1,
  0,
  3,
  2,
  0,
  7,
  3,
  0,
  4,
  7,
  0,
  5,
  4,
  0,
  1,
  5,
  5,
  7,
  4,
  5,
  6,
  7,
  5,
  2,
  6,
  5,
  1,
  2,
  3,
  6,
  2,
  3,
  7,
  6
];
var REFERENCE_INDICES_LENGTH = REFERENCE_INDICES.length;
function generateGeometryAttributes(loop, projection, bottomPositionsArray, topPositionsArray, normalsArray, cartographicsArray, compute2dAttributes) {
  let i2;
  let index2;
  const ellipsoid = projection._ellipsoid;
  const segmentCount = bottomPositionsArray.length / 3 - 1;
  const vertexCount = segmentCount * 8;
  const arraySizeVec4 = vertexCount * 4;
  const indexCount = segmentCount * 36;
  const indices2 = vertexCount > 65535 ? new Uint32Array(indexCount) : new Uint16Array(indexCount);
  const positionsArray = new Float64Array(vertexCount * 3);
  const startHiAndForwardOffsetX = new Float32Array(arraySizeVec4);
  const startLoAndForwardOffsetY = new Float32Array(arraySizeVec4);
  const startNormalAndForwardOffsetZ = new Float32Array(arraySizeVec4);
  const endNormalAndTextureCoordinateNormalizationX = new Float32Array(
    arraySizeVec4
  );
  const rightNormalAndTextureCoordinateNormalizationY = new Float32Array(
    arraySizeVec4
  );
  let startHiLo2D;
  let offsetAndRight2D;
  let startEndNormals2D;
  let texcoordNormalization2D;
  if (compute2dAttributes) {
    startHiLo2D = new Float32Array(arraySizeVec4);
    offsetAndRight2D = new Float32Array(arraySizeVec4);
    startEndNormals2D = new Float32Array(arraySizeVec4);
    texcoordNormalization2D = new Float32Array(vertexCount * 2);
  }
  const cartographicsLength = cartographicsArray.length / 2;
  let length2D = 0;
  const startCartographic = startCartographicScratch;
  startCartographic.height = 0;
  const endCartographic = endCartographicScratch;
  endCartographic.height = 0;
  let segmentStartCartesian = segmentStartTopScratch;
  let segmentEndCartesian = segmentEndTopScratch;
  if (compute2dAttributes) {
    index2 = 0;
    for (i2 = 1; i2 < cartographicsLength; i2++) {
      startCartographic.latitude = cartographicsArray[index2];
      startCartographic.longitude = cartographicsArray[index2 + 1];
      endCartographic.latitude = cartographicsArray[index2 + 2];
      endCartographic.longitude = cartographicsArray[index2 + 3];
      segmentStartCartesian = projection.project(
        startCartographic,
        segmentStartCartesian
      );
      segmentEndCartesian = projection.project(
        endCartographic,
        segmentEndCartesian
      );
      length2D += Cartesian3_default.distance(
        segmentStartCartesian,
        segmentEndCartesian
      );
      index2 += 2;
    }
  }
  const positionsLength = topPositionsArray.length / 3;
  segmentEndCartesian = Cartesian3_default.unpack(
    topPositionsArray,
    0,
    segmentEndCartesian
  );
  let length3D = 0;
  index2 = 3;
  for (i2 = 1; i2 < positionsLength; i2++) {
    segmentStartCartesian = Cartesian3_default.clone(
      segmentEndCartesian,
      segmentStartCartesian
    );
    segmentEndCartesian = Cartesian3_default.unpack(
      topPositionsArray,
      index2,
      segmentEndCartesian
    );
    length3D += Cartesian3_default.distance(segmentStartCartesian, segmentEndCartesian);
    index2 += 3;
  }
  let j;
  index2 = 3;
  let cartographicsIndex = 0;
  let vec2sWriteIndex = 0;
  let vec3sWriteIndex = 0;
  let vec4sWriteIndex = 0;
  let miterBroken = false;
  let endBottom = Cartesian3_default.unpack(
    bottomPositionsArray,
    0,
    segmentEndBottomScratch
  );
  let endTop = Cartesian3_default.unpack(topPositionsArray, 0, segmentEndTopScratch);
  let endGeometryNormal = Cartesian3_default.unpack(
    normalsArray,
    0,
    segmentEndNormalScratch
  );
  if (loop) {
    const preEndBottom = Cartesian3_default.unpack(
      bottomPositionsArray,
      bottomPositionsArray.length - 6,
      segmentStartBottomScratch
    );
    if (breakMiter(endGeometryNormal, preEndBottom, endBottom, endTop)) {
      endGeometryNormal = Cartesian3_default.negate(
        endGeometryNormal,
        endGeometryNormal
      );
    }
  }
  let lengthSoFar3D = 0;
  let lengthSoFar2D = 0;
  let sumHeights = 0;
  for (i2 = 0; i2 < segmentCount; i2++) {
    const startBottom = Cartesian3_default.clone(endBottom, segmentStartBottomScratch);
    const startTop = Cartesian3_default.clone(endTop, segmentStartTopScratch);
    let startGeometryNormal = Cartesian3_default.clone(
      endGeometryNormal,
      segmentStartNormalScratch
    );
    if (miterBroken) {
      startGeometryNormal = Cartesian3_default.negate(
        startGeometryNormal,
        startGeometryNormal
      );
    }
    endBottom = Cartesian3_default.unpack(
      bottomPositionsArray,
      index2,
      segmentEndBottomScratch
    );
    endTop = Cartesian3_default.unpack(topPositionsArray, index2, segmentEndTopScratch);
    endGeometryNormal = Cartesian3_default.unpack(
      normalsArray,
      index2,
      segmentEndNormalScratch
    );
    miterBroken = breakMiter(endGeometryNormal, startBottom, endBottom, endTop);
    startCartographic.latitude = cartographicsArray[cartographicsIndex];
    startCartographic.longitude = cartographicsArray[cartographicsIndex + 1];
    endCartographic.latitude = cartographicsArray[cartographicsIndex + 2];
    endCartographic.longitude = cartographicsArray[cartographicsIndex + 3];
    let start2D;
    let end2D;
    let startGeometryNormal2D;
    let endGeometryNormal2D;
    if (compute2dAttributes) {
      const nudgeResult = nudgeCartographic(startCartographic, endCartographic);
      start2D = projection.project(startCartographic, segmentStart2DScratch);
      end2D = projection.project(endCartographic, segmentEnd2DScratch);
      const direction2D = direction(end2D, start2D, forwardOffset2DScratch);
      direction2D.y = Math.abs(direction2D.y);
      startGeometryNormal2D = segmentStartNormal2DScratch;
      endGeometryNormal2D = segmentEndNormal2DScratch;
      if (nudgeResult === 0 || Cartesian3_default.dot(direction2D, Cartesian3_default.UNIT_Y) > MITER_BREAK_SMALL) {
        startGeometryNormal2D = projectNormal(
          projection,
          startCartographic,
          startGeometryNormal,
          start2D,
          segmentStartNormal2DScratch
        );
        endGeometryNormal2D = projectNormal(
          projection,
          endCartographic,
          endGeometryNormal,
          end2D,
          segmentEndNormal2DScratch
        );
      } else if (nudgeResult === 1) {
        endGeometryNormal2D = projectNormal(
          projection,
          endCartographic,
          endGeometryNormal,
          end2D,
          segmentEndNormal2DScratch
        );
        startGeometryNormal2D.x = 0;
        startGeometryNormal2D.y = Math_default.sign(
          startCartographic.longitude - Math.abs(endCartographic.longitude)
        );
        startGeometryNormal2D.z = 0;
      } else {
        startGeometryNormal2D = projectNormal(
          projection,
          startCartographic,
          startGeometryNormal,
          start2D,
          segmentStartNormal2DScratch
        );
        endGeometryNormal2D.x = 0;
        endGeometryNormal2D.y = Math_default.sign(
          startCartographic.longitude - endCartographic.longitude
        );
        endGeometryNormal2D.z = 0;
      }
    }
    const segmentLength3D = Cartesian3_default.distance(startTop, endTop);
    const encodedStart = EncodedCartesian3_default.fromCartesian(
      startBottom,
      encodeScratch
    );
    const forwardOffset = Cartesian3_default.subtract(
      endBottom,
      startBottom,
      offsetScratch2
    );
    const forward = Cartesian3_default.normalize(forwardOffset, rightScratch2);
    let startUp = Cartesian3_default.subtract(startTop, startBottom, startUpScratch);
    startUp = Cartesian3_default.normalize(startUp, startUp);
    let rightNormal = Cartesian3_default.cross(forward, startUp, rightScratch2);
    rightNormal = Cartesian3_default.normalize(rightNormal, rightNormal);
    let startPlaneNormal = Cartesian3_default.cross(
      startUp,
      startGeometryNormal,
      startPlaneNormalScratch
    );
    startPlaneNormal = Cartesian3_default.normalize(startPlaneNormal, startPlaneNormal);
    let endUp = Cartesian3_default.subtract(endTop, endBottom, endUpScratch);
    endUp = Cartesian3_default.normalize(endUp, endUp);
    let endPlaneNormal = Cartesian3_default.cross(
      endGeometryNormal,
      endUp,
      endPlaneNormalScratch
    );
    endPlaneNormal = Cartesian3_default.normalize(endPlaneNormal, endPlaneNormal);
    const texcoordNormalization3DX = segmentLength3D / length3D;
    const texcoordNormalization3DY = lengthSoFar3D / length3D;
    let segmentLength2D = 0;
    let encodedStart2D;
    let forwardOffset2D;
    let right2D;
    let texcoordNormalization2DX = 0;
    let texcoordNormalization2DY = 0;
    if (compute2dAttributes) {
      segmentLength2D = Cartesian3_default.distance(start2D, end2D);
      encodedStart2D = EncodedCartesian3_default.fromCartesian(
        start2D,
        encodeScratch2D
      );
      forwardOffset2D = Cartesian3_default.subtract(
        end2D,
        start2D,
        forwardOffset2DScratch
      );
      right2D = Cartesian3_default.normalize(forwardOffset2D, right2DScratch);
      const swap5 = right2D.x;
      right2D.x = right2D.y;
      right2D.y = -swap5;
      texcoordNormalization2DX = segmentLength2D / length2D;
      texcoordNormalization2DY = lengthSoFar2D / length2D;
    }
    for (j = 0; j < 8; j++) {
      const vec4Index = vec4sWriteIndex + j * 4;
      const vec2Index = vec2sWriteIndex + j * 2;
      const wIndex = vec4Index + 3;
      const rightPlaneSide = j < 4 ? 1 : -1;
      const topBottomSide = j === 2 || j === 3 || j === 6 || j === 7 ? 1 : -1;
      Cartesian3_default.pack(encodedStart.high, startHiAndForwardOffsetX, vec4Index);
      startHiAndForwardOffsetX[wIndex] = forwardOffset.x;
      Cartesian3_default.pack(encodedStart.low, startLoAndForwardOffsetY, vec4Index);
      startLoAndForwardOffsetY[wIndex] = forwardOffset.y;
      Cartesian3_default.pack(
        startPlaneNormal,
        startNormalAndForwardOffsetZ,
        vec4Index
      );
      startNormalAndForwardOffsetZ[wIndex] = forwardOffset.z;
      Cartesian3_default.pack(
        endPlaneNormal,
        endNormalAndTextureCoordinateNormalizationX,
        vec4Index
      );
      endNormalAndTextureCoordinateNormalizationX[wIndex] = texcoordNormalization3DX * rightPlaneSide;
      Cartesian3_default.pack(
        rightNormal,
        rightNormalAndTextureCoordinateNormalizationY,
        vec4Index
      );
      let texcoordNormalization = texcoordNormalization3DY * topBottomSide;
      if (texcoordNormalization === 0 && topBottomSide < 0) {
        texcoordNormalization = 9;
      }
      rightNormalAndTextureCoordinateNormalizationY[wIndex] = texcoordNormalization;
      if (compute2dAttributes) {
        startHiLo2D[vec4Index] = encodedStart2D.high.x;
        startHiLo2D[vec4Index + 1] = encodedStart2D.high.y;
        startHiLo2D[vec4Index + 2] = encodedStart2D.low.x;
        startHiLo2D[vec4Index + 3] = encodedStart2D.low.y;
        startEndNormals2D[vec4Index] = -startGeometryNormal2D.y;
        startEndNormals2D[vec4Index + 1] = startGeometryNormal2D.x;
        startEndNormals2D[vec4Index + 2] = endGeometryNormal2D.y;
        startEndNormals2D[vec4Index + 3] = -endGeometryNormal2D.x;
        offsetAndRight2D[vec4Index] = forwardOffset2D.x;
        offsetAndRight2D[vec4Index + 1] = forwardOffset2D.y;
        offsetAndRight2D[vec4Index + 2] = right2D.x;
        offsetAndRight2D[vec4Index + 3] = right2D.y;
        texcoordNormalization2D[vec2Index] = texcoordNormalization2DX * rightPlaneSide;
        texcoordNormalization = texcoordNormalization2DY * topBottomSide;
        if (texcoordNormalization === 0 && topBottomSide < 0) {
          texcoordNormalization = 9;
        }
        texcoordNormalization2D[vec2Index + 1] = texcoordNormalization;
      }
    }
    const adjustHeightStartBottom = adjustHeightStartBottomScratch;
    const adjustHeightEndBottom = adjustHeightEndBottomScratch;
    const adjustHeightStartTop = adjustHeightStartTopScratch;
    const adjustHeightEndTop = adjustHeightEndTopScratch;
    const getHeightsRectangle = Rectangle_default.fromCartographicArray(
      getHeightCartographics,
      getHeightRectangleScratch
    );
    const minMaxHeights = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
      getHeightsRectangle,
      ellipsoid
    );
    const minHeight = minMaxHeights.minimumTerrainHeight;
    const maxHeight = minMaxHeights.maximumTerrainHeight;
    sumHeights += minHeight;
    sumHeights += maxHeight;
    adjustHeights(
      startBottom,
      startTop,
      minHeight,
      maxHeight,
      adjustHeightStartBottom,
      adjustHeightStartTop
    );
    adjustHeights(
      endBottom,
      endTop,
      minHeight,
      maxHeight,
      adjustHeightEndBottom,
      adjustHeightEndTop
    );
    let normalNudge = Cartesian3_default.multiplyByScalar(
      rightNormal,
      Math_default.EPSILON5,
      normalNudgeScratch
    );
    Cartesian3_default.add(
      adjustHeightStartBottom,
      normalNudge,
      adjustHeightStartBottom
    );
    Cartesian3_default.add(adjustHeightEndBottom, normalNudge, adjustHeightEndBottom);
    Cartesian3_default.add(adjustHeightStartTop, normalNudge, adjustHeightStartTop);
    Cartesian3_default.add(adjustHeightEndTop, normalNudge, adjustHeightEndTop);
    nudgeXZ(adjustHeightStartBottom, adjustHeightEndBottom);
    nudgeXZ(adjustHeightStartTop, adjustHeightEndTop);
    Cartesian3_default.pack(adjustHeightStartBottom, positionsArray, vec3sWriteIndex);
    Cartesian3_default.pack(adjustHeightEndBottom, positionsArray, vec3sWriteIndex + 3);
    Cartesian3_default.pack(adjustHeightEndTop, positionsArray, vec3sWriteIndex + 6);
    Cartesian3_default.pack(adjustHeightStartTop, positionsArray, vec3sWriteIndex + 9);
    normalNudge = Cartesian3_default.multiplyByScalar(
      rightNormal,
      -2 * Math_default.EPSILON5,
      normalNudgeScratch
    );
    Cartesian3_default.add(
      adjustHeightStartBottom,
      normalNudge,
      adjustHeightStartBottom
    );
    Cartesian3_default.add(adjustHeightEndBottom, normalNudge, adjustHeightEndBottom);
    Cartesian3_default.add(adjustHeightStartTop, normalNudge, adjustHeightStartTop);
    Cartesian3_default.add(adjustHeightEndTop, normalNudge, adjustHeightEndTop);
    nudgeXZ(adjustHeightStartBottom, adjustHeightEndBottom);
    nudgeXZ(adjustHeightStartTop, adjustHeightEndTop);
    Cartesian3_default.pack(
      adjustHeightStartBottom,
      positionsArray,
      vec3sWriteIndex + 12
    );
    Cartesian3_default.pack(
      adjustHeightEndBottom,
      positionsArray,
      vec3sWriteIndex + 15
    );
    Cartesian3_default.pack(adjustHeightEndTop, positionsArray, vec3sWriteIndex + 18);
    Cartesian3_default.pack(adjustHeightStartTop, positionsArray, vec3sWriteIndex + 21);
    cartographicsIndex += 2;
    index2 += 3;
    vec2sWriteIndex += 16;
    vec3sWriteIndex += 24;
    vec4sWriteIndex += 32;
    lengthSoFar3D += segmentLength3D;
    lengthSoFar2D += segmentLength2D;
  }
  index2 = 0;
  let indexOffset = 0;
  for (i2 = 0; i2 < segmentCount; i2++) {
    for (j = 0; j < REFERENCE_INDICES_LENGTH; j++) {
      indices2[index2 + j] = REFERENCE_INDICES[j] + indexOffset;
    }
    indexOffset += 8;
    index2 += REFERENCE_INDICES_LENGTH;
  }
  const boundingSpheres = scratchBoundingSpheres;
  BoundingSphere_default.fromVertices(
    bottomPositionsArray,
    Cartesian3_default.ZERO,
    3,
    boundingSpheres[0]
  );
  BoundingSphere_default.fromVertices(
    topPositionsArray,
    Cartesian3_default.ZERO,
    3,
    boundingSpheres[1]
  );
  const boundingSphere = BoundingSphere_default.fromBoundingSpheres(boundingSpheres);
  boundingSphere.radius += sumHeights / (segmentCount * 2);
  const attributes = {
    position: new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      normalize: false,
      values: positionsArray
    }),
    startHiAndForwardOffsetX: getVec4GeometryAttribute(
      startHiAndForwardOffsetX
    ),
    startLoAndForwardOffsetY: getVec4GeometryAttribute(
      startLoAndForwardOffsetY
    ),
    startNormalAndForwardOffsetZ: getVec4GeometryAttribute(
      startNormalAndForwardOffsetZ
    ),
    endNormalAndTextureCoordinateNormalizationX: getVec4GeometryAttribute(
      endNormalAndTextureCoordinateNormalizationX
    ),
    rightNormalAndTextureCoordinateNormalizationY: getVec4GeometryAttribute(
      rightNormalAndTextureCoordinateNormalizationY
    )
  };
  if (compute2dAttributes) {
    attributes.startHiLo2D = getVec4GeometryAttribute(startHiLo2D);
    attributes.offsetAndRight2D = getVec4GeometryAttribute(offsetAndRight2D);
    attributes.startEndNormals2D = getVec4GeometryAttribute(startEndNormals2D);
    attributes.texcoordNormalization2D = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      normalize: false,
      values: texcoordNormalization2D
    });
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    boundingSphere
  });
}
function getVec4GeometryAttribute(typedArray) {
  return new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 4,
    normalize: false,
    values: typedArray
  });
}
GroundPolylineGeometry._projectNormal = projectNormal;
var GroundPolylineGeometry_default = GroundPolylineGeometry;

// node_modules/cesium/Source/Core/HeadingPitchRange.js
function HeadingPitchRange(heading, pitch, range2) {
  this.heading = defaultValue_default(heading, 0);
  this.pitch = defaultValue_default(pitch, 0);
  this.range = defaultValue_default(range2, 0);
}
HeadingPitchRange.clone = function(hpr, result) {
  if (!defined_default(hpr)) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new HeadingPitchRange();
  }
  result.heading = hpr.heading;
  result.pitch = hpr.pitch;
  result.range = hpr.range;
  return result;
};
var HeadingPitchRange_default = HeadingPitchRange;

// node_modules/cesium/Source/Core/HermitePolynomialApproximation.js
var factorial = Math_default.factorial;
function calculateCoefficientTerm(x, zIndices, xTable, derivOrder, termOrder, reservedIndices) {
  let result = 0;
  let reserved;
  let i2;
  let j;
  if (derivOrder > 0) {
    for (i2 = 0; i2 < termOrder; i2++) {
      reserved = false;
      for (j = 0; j < reservedIndices.length && !reserved; j++) {
        if (i2 === reservedIndices[j]) {
          reserved = true;
        }
      }
      if (!reserved) {
        reservedIndices.push(i2);
        result += calculateCoefficientTerm(
          x,
          zIndices,
          xTable,
          derivOrder - 1,
          termOrder,
          reservedIndices
        );
        reservedIndices.splice(reservedIndices.length - 1, 1);
      }
    }
    return result;
  }
  result = 1;
  for (i2 = 0; i2 < termOrder; i2++) {
    reserved = false;
    for (j = 0; j < reservedIndices.length && !reserved; j++) {
      if (i2 === reservedIndices[j]) {
        reserved = true;
      }
    }
    if (!reserved) {
      result *= x - xTable[zIndices[i2]];
    }
  }
  return result;
}
var HermitePolynomialApproximation = {
  type: "Hermite"
};
HermitePolynomialApproximation.getRequiredDataPoints = function(degree, inputOrder) {
  inputOrder = defaultValue_default(inputOrder, 0);
  if (!defined_default(degree)) {
    throw new DeveloperError_default("degree is required.");
  }
  if (degree < 0) {
    throw new DeveloperError_default("degree must be 0 or greater.");
  }
  if (inputOrder < 0) {
    throw new DeveloperError_default("inputOrder must be 0 or greater.");
  }
  return Math.max(Math.floor((degree + 1) / (inputOrder + 1)), 2);
};
HermitePolynomialApproximation.interpolateOrderZero = function(x, xTable, yTable, yStride, result) {
  if (!defined_default(result)) {
    result = new Array(yStride);
  }
  let i2;
  let j;
  let d;
  let s2;
  let len;
  let index2;
  const length3 = xTable.length;
  const coefficients = new Array(yStride);
  for (i2 = 0; i2 < yStride; i2++) {
    result[i2] = 0;
    const l2 = new Array(length3);
    coefficients[i2] = l2;
    for (j = 0; j < length3; j++) {
      l2[j] = [];
    }
  }
  const zIndicesLength = length3, zIndices = new Array(zIndicesLength);
  for (i2 = 0; i2 < zIndicesLength; i2++) {
    zIndices[i2] = i2;
  }
  let highestNonZeroCoef = length3 - 1;
  for (s2 = 0; s2 < yStride; s2++) {
    for (j = 0; j < zIndicesLength; j++) {
      index2 = zIndices[j] * yStride + s2;
      coefficients[s2][0].push(yTable[index2]);
    }
    for (i2 = 1; i2 < zIndicesLength; i2++) {
      let nonZeroCoefficients = false;
      for (j = 0; j < zIndicesLength - i2; j++) {
        const zj = xTable[zIndices[j]];
        const zn = xTable[zIndices[j + i2]];
        let numerator;
        if (zn - zj <= 0) {
          index2 = zIndices[j] * yStride + yStride * i2 + s2;
          numerator = yTable[index2];
          coefficients[s2][i2].push(numerator / factorial(i2));
        } else {
          numerator = coefficients[s2][i2 - 1][j + 1] - coefficients[s2][i2 - 1][j];
          coefficients[s2][i2].push(numerator / (zn - zj));
        }
        nonZeroCoefficients = nonZeroCoefficients || numerator !== 0;
      }
      if (!nonZeroCoefficients) {
        highestNonZeroCoef = i2 - 1;
      }
    }
  }
  for (d = 0, len = 0; d <= len; d++) {
    for (i2 = d; i2 <= highestNonZeroCoef; i2++) {
      const tempTerm = calculateCoefficientTerm(x, zIndices, xTable, d, i2, []);
      for (s2 = 0; s2 < yStride; s2++) {
        const coeff = coefficients[s2][i2][0];
        result[s2 + d * yStride] += coeff * tempTerm;
      }
    }
  }
  return result;
};
var arrayScratch2 = [];
HermitePolynomialApproximation.interpolate = function(x, xTable, yTable, yStride, inputOrder, outputOrder, result) {
  const resultLength = yStride * (outputOrder + 1);
  if (!defined_default(result)) {
    result = new Array(resultLength);
  }
  for (let r2 = 0; r2 < resultLength; r2++) {
    result[r2] = 0;
  }
  const length3 = xTable.length;
  const zIndices = new Array(length3 * (inputOrder + 1));
  let i2;
  for (i2 = 0; i2 < length3; i2++) {
    for (let j = 0; j < inputOrder + 1; j++) {
      zIndices[i2 * (inputOrder + 1) + j] = i2;
    }
  }
  const zIndiceslength = zIndices.length;
  const coefficients = arrayScratch2;
  const highestNonZeroCoef = fillCoefficientList(
    coefficients,
    zIndices,
    xTable,
    yTable,
    yStride,
    inputOrder
  );
  const reservedIndices = [];
  const tmp2 = zIndiceslength * (zIndiceslength + 1) / 2;
  const loopStop = Math.min(highestNonZeroCoef, outputOrder);
  for (let d = 0; d <= loopStop; d++) {
    for (i2 = d; i2 <= highestNonZeroCoef; i2++) {
      reservedIndices.length = 0;
      const tempTerm = calculateCoefficientTerm(
        x,
        zIndices,
        xTable,
        d,
        i2,
        reservedIndices
      );
      const dimTwo = Math.floor(i2 * (1 - i2) / 2) + zIndiceslength * i2;
      for (let s2 = 0; s2 < yStride; s2++) {
        const dimOne = Math.floor(s2 * tmp2);
        const coef = coefficients[dimOne + dimTwo];
        result[s2 + d * yStride] += coef * tempTerm;
      }
    }
  }
  return result;
};
function fillCoefficientList(coefficients, zIndices, xTable, yTable, yStride, inputOrder) {
  let j;
  let index2;
  let highestNonZero = -1;
  const zIndiceslength = zIndices.length;
  const tmp2 = zIndiceslength * (zIndiceslength + 1) / 2;
  for (let s2 = 0; s2 < yStride; s2++) {
    const dimOne = Math.floor(s2 * tmp2);
    for (j = 0; j < zIndiceslength; j++) {
      index2 = zIndices[j] * yStride * (inputOrder + 1) + s2;
      coefficients[dimOne + j] = yTable[index2];
    }
    for (let i2 = 1; i2 < zIndiceslength; i2++) {
      let coefIndex = 0;
      const dimTwo = Math.floor(i2 * (1 - i2) / 2) + zIndiceslength * i2;
      let nonZeroCoefficients = false;
      for (j = 0; j < zIndiceslength - i2; j++) {
        const zj = xTable[zIndices[j]];
        const zn = xTable[zIndices[j + i2]];
        let numerator;
        let coefficient;
        if (zn - zj <= 0) {
          index2 = zIndices[j] * yStride * (inputOrder + 1) + yStride * i2 + s2;
          numerator = yTable[index2];
          coefficient = numerator / Math_default.factorial(i2);
          coefficients[dimOne + dimTwo + coefIndex] = coefficient;
          coefIndex++;
        } else {
          const dimTwoMinusOne = Math.floor((i2 - 1) * (2 - i2) / 2) + zIndiceslength * (i2 - 1);
          numerator = coefficients[dimOne + dimTwoMinusOne + j + 1] - coefficients[dimOne + dimTwoMinusOne + j];
          coefficient = numerator / (zn - zj);
          coefficients[dimOne + dimTwo + coefIndex] = coefficient;
          coefIndex++;
        }
        nonZeroCoefficients = nonZeroCoefficients || numerator !== 0;
      }
      if (nonZeroCoefficients) {
        highestNonZero = Math.max(highestNonZero, i2);
      }
    }
  }
  return highestNonZero;
}
var HermitePolynomialApproximation_default = HermitePolynomialApproximation;

// node_modules/cesium/Source/Core/HilbertOrder.js
var HilbertOrder = {};
HilbertOrder.encode2D = function(level, x, y) {
  const n2 = Math.pow(2, level);
  Check_default.typeOf.number("level", level);
  Check_default.typeOf.number("x", x);
  Check_default.typeOf.number("y", y);
  if (level < 1) {
    throw new DeveloperError_default("Hilbert level cannot be less than 1.");
  }
  if (x < 0 || x >= n2 || y < 0 || y >= n2) {
    throw new DeveloperError_default("Invalid coordinates for given level.");
  }
  const p2 = {
    x,
    y
  };
  let rx, ry, s2, index2 = BigInt(0);
  for (s2 = n2 / 2; s2 > 0; s2 /= 2) {
    rx = (p2.x & s2) > 0 ? 1 : 0;
    ry = (p2.y & s2) > 0 ? 1 : 0;
    index2 += BigInt((3 * rx ^ ry) * s2 * s2);
    rotate(n2, p2, rx, ry);
  }
  return index2;
};
HilbertOrder.decode2D = function(level, index2) {
  Check_default.typeOf.number("level", level);
  Check_default.typeOf.bigint("index", index2);
  if (level < 1) {
    throw new DeveloperError_default("Hilbert level cannot be less than 1.");
  }
  if (index2 < BigInt(0) || index2 >= BigInt(Math.pow(4, level))) {
    throw new DeveloperError_default(
      "Hilbert index exceeds valid maximum for given level."
    );
  }
  const n2 = Math.pow(2, level);
  const p2 = {
    x: 0,
    y: 0
  };
  let rx, ry, s2, t;
  for (s2 = 1, t = index2; s2 < n2; s2 *= 2) {
    rx = 1 & Number(t / BigInt(2));
    ry = 1 & Number(t ^ BigInt(rx));
    rotate(s2, p2, rx, ry);
    p2.x += s2 * rx;
    p2.y += s2 * ry;
    t /= BigInt(4);
  }
  return [p2.x, p2.y];
};
function rotate(n2, p2, rx, ry) {
  if (ry !== 0) {
    return;
  }
  if (rx === 1) {
    p2.x = n2 - 1 - p2.x;
    p2.y = n2 - 1 - p2.y;
  }
  const t = p2.x;
  p2.x = p2.y;
  p2.y = t;
}
var HilbertOrder_default = HilbertOrder;

// node_modules/cesium/Source/Core/IauOrientationParameters.js
function IauOrientationParameters(rightAscension, declination, rotation, rotationRate) {
  this.rightAscension = rightAscension;
  this.declination = declination;
  this.rotation = rotation;
  this.rotationRate = rotationRate;
}
var IauOrientationParameters_default = IauOrientationParameters;

// node_modules/cesium/Source/Core/Iau2000Orientation.js
var Iau2000Orientation = {};
var TdtMinusTai = 32.184;
var J2000d = 2451545;
var c1 = -0.0529921;
var c2 = -0.1059842;
var c32 = 13.0120009;
var c4 = 13.3407154;
var c5 = 0.9856003;
var c6 = 26.4057084;
var c7 = 13.064993;
var c8 = 0.3287146;
var c9 = 1.7484877;
var c10 = -0.1589763;
var c11 = 36096e-7;
var c12 = 0.1643573;
var c13 = 12.9590088;
var dateTT = new JulianDate_default();
Iau2000Orientation.ComputeMoon = function(date, result) {
  if (!defined_default(date)) {
    date = JulianDate_default.now();
  }
  dateTT = JulianDate_default.addSeconds(date, TdtMinusTai, dateTT);
  const d = JulianDate_default.totalDays(dateTT) - J2000d;
  const T = d / TimeConstants_default.DAYS_PER_JULIAN_CENTURY;
  const E1 = (125.045 + c1 * d) * Math_default.RADIANS_PER_DEGREE;
  const E2 = (250.089 + c2 * d) * Math_default.RADIANS_PER_DEGREE;
  const E3 = (260.008 + c32 * d) * Math_default.RADIANS_PER_DEGREE;
  const E4 = (176.625 + c4 * d) * Math_default.RADIANS_PER_DEGREE;
  const E5 = (357.529 + c5 * d) * Math_default.RADIANS_PER_DEGREE;
  const E6 = (311.589 + c6 * d) * Math_default.RADIANS_PER_DEGREE;
  const E7 = (134.963 + c7 * d) * Math_default.RADIANS_PER_DEGREE;
  const E8 = (276.617 + c8 * d) * Math_default.RADIANS_PER_DEGREE;
  const E9 = (34.226 + c9 * d) * Math_default.RADIANS_PER_DEGREE;
  const E10 = (15.134 + c10 * d) * Math_default.RADIANS_PER_DEGREE;
  const E11 = (119.743 + c11 * d) * Math_default.RADIANS_PER_DEGREE;
  const E12 = (239.961 + c12 * d) * Math_default.RADIANS_PER_DEGREE;
  const E13 = (25.053 + c13 * d) * Math_default.RADIANS_PER_DEGREE;
  const sinE1 = Math.sin(E1);
  const sinE2 = Math.sin(E2);
  const sinE3 = Math.sin(E3);
  const sinE4 = Math.sin(E4);
  const sinE5 = Math.sin(E5);
  const sinE6 = Math.sin(E6);
  const sinE7 = Math.sin(E7);
  const sinE8 = Math.sin(E8);
  const sinE9 = Math.sin(E9);
  const sinE10 = Math.sin(E10);
  const sinE11 = Math.sin(E11);
  const sinE12 = Math.sin(E12);
  const sinE13 = Math.sin(E13);
  const cosE1 = Math.cos(E1);
  const cosE2 = Math.cos(E2);
  const cosE3 = Math.cos(E3);
  const cosE4 = Math.cos(E4);
  const cosE5 = Math.cos(E5);
  const cosE6 = Math.cos(E6);
  const cosE7 = Math.cos(E7);
  const cosE8 = Math.cos(E8);
  const cosE9 = Math.cos(E9);
  const cosE10 = Math.cos(E10);
  const cosE11 = Math.cos(E11);
  const cosE12 = Math.cos(E12);
  const cosE13 = Math.cos(E13);
  const rightAscension = (269.9949 + 31e-4 * T - 3.8787 * sinE1 - 0.1204 * sinE2 + 0.07 * sinE3 - 0.0172 * sinE4 + 72e-4 * sinE6 - 52e-4 * sinE10 + 43e-4 * sinE13) * Math_default.RADIANS_PER_DEGREE;
  const declination = (66.5392 + 0.013 * T + 1.5419 * cosE1 + 0.0239 * cosE2 - 0.0278 * cosE3 + 68e-4 * cosE4 - 29e-4 * cosE6 + 9e-4 * cosE7 + 8e-4 * cosE10 - 9e-4 * cosE13) * Math_default.RADIANS_PER_DEGREE;
  const rotation = (38.3213 + 13.17635815 * d - 14e-13 * d * d + 3.561 * sinE1 + 0.1208 * sinE2 - 0.0642 * sinE3 + 0.0158 * sinE4 + 0.0252 * sinE5 - 66e-4 * sinE6 - 47e-4 * sinE7 - 46e-4 * sinE8 + 28e-4 * sinE9 + 52e-4 * sinE10 + 4e-3 * sinE11 + 19e-4 * sinE12 - 44e-4 * sinE13) * Math_default.RADIANS_PER_DEGREE;
  const rotationRate = (13.17635815 - 14e-13 * (2 * d) + 3.561 * cosE1 * c1 + 0.1208 * cosE2 * c2 - 0.0642 * cosE3 * c32 + 0.0158 * cosE4 * c4 + 0.0252 * cosE5 * c5 - 66e-4 * cosE6 * c6 - 47e-4 * cosE7 * c7 - 46e-4 * cosE8 * c8 + 28e-4 * cosE9 * c9 + 52e-4 * cosE10 * c10 + 4e-3 * cosE11 * c11 + 19e-4 * cosE12 * c12 - 44e-4 * cosE13 * c13) / 86400 * Math_default.RADIANS_PER_DEGREE;
  if (!defined_default(result)) {
    result = new IauOrientationParameters_default();
  }
  result.rightAscension = rightAscension;
  result.declination = declination;
  result.rotation = rotation;
  result.rotationRate = rotationRate;
  return result;
};
var Iau2000Orientation_default = Iau2000Orientation;

// node_modules/cesium/Source/Core/IauOrientationAxes.js
function IauOrientationAxes(computeFunction) {
  if (!defined_default(computeFunction) || typeof computeFunction !== "function") {
    computeFunction = Iau2000Orientation_default.ComputeMoon;
  }
  this._computeFunction = computeFunction;
}
var xAxisScratch = new Cartesian3_default();
var yAxisScratch = new Cartesian3_default();
var zAxisScratch = new Cartesian3_default();
function computeRotationMatrix(alpha, delta, result) {
  const xAxis = xAxisScratch;
  xAxis.x = Math.cos(alpha + Math_default.PI_OVER_TWO);
  xAxis.y = Math.sin(alpha + Math_default.PI_OVER_TWO);
  xAxis.z = 0;
  const cosDec = Math.cos(delta);
  const zAxis = zAxisScratch;
  zAxis.x = cosDec * Math.cos(alpha);
  zAxis.y = cosDec * Math.sin(alpha);
  zAxis.z = Math.sin(delta);
  const yAxis = Cartesian3_default.cross(zAxis, xAxis, yAxisScratch);
  if (!defined_default(result)) {
    result = new Matrix3_default();
  }
  result[0] = xAxis.x;
  result[1] = yAxis.x;
  result[2] = zAxis.x;
  result[3] = xAxis.y;
  result[4] = yAxis.y;
  result[5] = zAxis.y;
  result[6] = xAxis.z;
  result[7] = yAxis.z;
  result[8] = zAxis.z;
  return result;
}
var rotMtxScratch = new Matrix3_default();
var quatScratch = new Quaternion_default();
IauOrientationAxes.prototype.evaluate = function(date, result) {
  if (!defined_default(date)) {
    date = JulianDate_default.now();
  }
  const alphaDeltaW = this._computeFunction(date);
  const precMtx = computeRotationMatrix(
    alphaDeltaW.rightAscension,
    alphaDeltaW.declination,
    result
  );
  const rot = Math_default.zeroToTwoPi(alphaDeltaW.rotation);
  const quat = Quaternion_default.fromAxisAngle(Cartesian3_default.UNIT_Z, rot, quatScratch);
  const rotMtx2 = Matrix3_default.fromQuaternion(
    Quaternion_default.conjugate(quat, quat),
    rotMtxScratch
  );
  const cbi2cbf = Matrix3_default.multiply(rotMtx2, precMtx, precMtx);
  return cbi2cbf;
};
var IauOrientationAxes_default = IauOrientationAxes;

// node_modules/cesium/Source/Core/InterpolationAlgorithm.js
var InterpolationAlgorithm = {};
InterpolationAlgorithm.type = void 0;
InterpolationAlgorithm.getRequiredDataPoints = DeveloperError_default.throwInstantiationError;
InterpolationAlgorithm.interpolateOrderZero = DeveloperError_default.throwInstantiationError;
InterpolationAlgorithm.interpolate = DeveloperError_default.throwInstantiationError;
var InterpolationAlgorithm_default = InterpolationAlgorithm;

// node_modules/cesium/Source/Core/InterpolationType.js
var InterpolationType = {
  STEP: 0,
  LINEAR: 1,
  CUBICSPLINE: 2
};
var InterpolationType_default = Object.freeze(InterpolationType);

// node_modules/cesium/Source/Core/Ion.js
var defaultTokenCredit;
var defaultAccessToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI5YTJlYmI0NC1kM2IwLTRmZDktOGI2Yy01MDFiZWRkYzQ4NzEiLCJpZCI6MjU5LCJpYXQiOjE2NTE0OTY5NDl9.GEWUJWU1Yuf7kVTVshQ1jb2ix9f-O-A74MuSsjq7Kbg";
var Ion = {};
Ion.defaultAccessToken = defaultAccessToken;
Ion.defaultServer = new Resource_default({ url: "https://api.cesium.com/" });
Ion.getDefaultTokenCredit = function(providedKey) {
  if (providedKey !== defaultAccessToken) {
    return void 0;
  }
  if (!defined_default(defaultTokenCredit)) {
    const defaultTokenMessage = `<b>             This application is using Cesium's default ion access token. Please assign <i>Cesium.Ion.defaultAccessToken</i>             with an access token from your ion account before making any Cesium API calls.             You can sign up for a free ion account at <a href="https://cesium.com">https://cesium.com</a>.</b>`;
    defaultTokenCredit = new Credit_default(defaultTokenMessage, true);
  }
  return defaultTokenCredit;
};
var Ion_default = Ion;

// node_modules/cesium/Source/Core/PeliasGeocoderService.js
function PeliasGeocoderService(url2) {
  Check_default.defined("url", url2);
  this._url = Resource_default.createIfNeeded(url2);
  this._url.appendForwardSlash();
}
Object.defineProperties(PeliasGeocoderService.prototype, {
  url: {
    get: function() {
      return this._url;
    }
  }
});
PeliasGeocoderService.prototype.geocode = function(query, type) {
  Check_default.typeOf.string("query", query);
  const resource = this._url.getDerivedResource({
    url: type === GeocodeType_default.AUTOCOMPLETE ? "autocomplete" : "search",
    queryParameters: {
      text: query
    }
  });
  return resource.fetchJson().then(function(results) {
    return results.features.map(function(resultObject) {
      let destination;
      const bboxDegrees = resultObject.bbox;
      if (defined_default(bboxDegrees)) {
        destination = Rectangle_default.fromDegrees(
          bboxDegrees[0],
          bboxDegrees[1],
          bboxDegrees[2],
          bboxDegrees[3]
        );
      } else {
        const lon = resultObject.geometry.coordinates[0];
        const lat = resultObject.geometry.coordinates[1];
        destination = Cartesian3_default.fromDegrees(lon, lat);
      }
      return {
        displayName: resultObject.properties.label,
        destination
      };
    });
  });
};
var PeliasGeocoderService_default = PeliasGeocoderService;

// node_modules/cesium/Source/Core/IonGeocoderService.js
function IonGeocoderService(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.scene", options.scene);
  const accessToken = defaultValue_default(options.accessToken, Ion_default.defaultAccessToken);
  const server = Resource_default.createIfNeeded(
    defaultValue_default(options.server, Ion_default.defaultServer)
  );
  server.appendForwardSlash();
  const defaultTokenCredit2 = Ion_default.getDefaultTokenCredit(accessToken);
  if (defined_default(defaultTokenCredit2)) {
    options.scene.frameState.creditDisplay.addDefaultCredit(
      Credit_default.clone(defaultTokenCredit2)
    );
  }
  const searchEndpoint = server.getDerivedResource({
    url: "v1/geocode"
  });
  if (defined_default(accessToken)) {
    searchEndpoint.appendQueryParameters({ access_token: accessToken });
  }
  this._accessToken = accessToken;
  this._server = server;
  this._pelias = new PeliasGeocoderService_default(searchEndpoint);
}
IonGeocoderService.prototype.geocode = function(query, geocodeType) {
  return this._pelias.geocode(query, geocodeType);
};
var IonGeocoderService_default = IonGeocoderService;

// node_modules/cesium/Source/Core/IonResource.js
function IonResource(endpoint, endpointResource) {
  Check_default.defined("endpoint", endpoint);
  Check_default.defined("endpointResource", endpointResource);
  let options;
  const externalType = endpoint.externalType;
  const isExternal = defined_default(externalType);
  if (!isExternal) {
    options = {
      url: endpoint.url,
      retryAttempts: 1,
      retryCallback
    };
  } else if (externalType === "3DTILES" || externalType === "STK_TERRAIN_SERVER") {
    options = { url: endpoint.options.url };
  } else {
    throw new RuntimeError_default(
      "Ion.createResource does not support external imagery assets; use IonImageryProvider instead."
    );
  }
  Resource_default.call(this, options);
  this._ionEndpoint = endpoint;
  this._ionEndpointDomain = isExternal ? void 0 : new URI(endpoint.url).authority();
  this._ionEndpointResource = endpointResource;
  this._ionRoot = void 0;
  this._pendingPromise = void 0;
  this._credits = void 0;
  this._isExternal = isExternal;
}
if (defined_default(Object.create)) {
  IonResource.prototype = Object.create(Resource_default.prototype);
  IonResource.prototype.constructor = IonResource;
}
IonResource.fromAssetId = function(assetId, options) {
  const endpointResource = IonResource._createEndpointResource(
    assetId,
    options
  );
  return endpointResource.fetchJson().then(function(endpoint) {
    return new IonResource(endpoint, endpointResource);
  });
};
Object.defineProperties(IonResource.prototype, {
  credits: {
    get: function() {
      if (defined_default(this._ionRoot)) {
        return this._ionRoot.credits;
      }
      if (defined_default(this._credits)) {
        return this._credits;
      }
      this._credits = IonResource.getCreditsFromEndpoint(
        this._ionEndpoint,
        this._ionEndpointResource
      );
      return this._credits;
    }
  }
});
IonResource.getCreditsFromEndpoint = function(endpoint, endpointResource) {
  const credits = endpoint.attributions.map(Credit_default.getIonCredit);
  const defaultTokenCredit2 = Ion_default.getDefaultTokenCredit(
    endpointResource.queryParameters.access_token
  );
  if (defined_default(defaultTokenCredit2)) {
    credits.push(Credit_default.clone(defaultTokenCredit2));
  }
  return credits;
};
IonResource.prototype.clone = function(result) {
  const ionRoot = defaultValue_default(this._ionRoot, this);
  if (!defined_default(result)) {
    result = new IonResource(
      ionRoot._ionEndpoint,
      ionRoot._ionEndpointResource
    );
  }
  result = Resource_default.prototype.clone.call(this, result);
  result._ionRoot = ionRoot;
  result._isExternal = this._isExternal;
  return result;
};
IonResource.prototype.fetchImage = function(options) {
  if (!this._isExternal) {
    const userOptions = options;
    options = {
      preferBlob: true
    };
    if (defined_default(userOptions)) {
      options.flipY = userOptions.flipY;
      options.preferImageBitmap = userOptions.preferImageBitmap;
    }
  }
  return Resource_default.prototype.fetchImage.call(this, options);
};
IonResource.prototype._makeRequest = function(options) {
  if (this._isExternal || new URI(this.url).authority() !== this._ionEndpointDomain) {
    return Resource_default.prototype._makeRequest.call(this, options);
  }
  if (!defined_default(options.headers)) {
    options.headers = {};
  }
  options.headers.Authorization = `Bearer ${this._ionEndpoint.accessToken}`;
  return Resource_default.prototype._makeRequest.call(this, options);
};
IonResource._createEndpointResource = function(assetId, options) {
  Check_default.defined("assetId", assetId);
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let server = defaultValue_default(options.server, Ion_default.defaultServer);
  const accessToken = defaultValue_default(options.accessToken, Ion_default.defaultAccessToken);
  server = Resource_default.createIfNeeded(server);
  const resourceOptions = {
    url: `v1/assets/${assetId}/endpoint`
  };
  if (defined_default(accessToken)) {
    resourceOptions.queryParameters = { access_token: accessToken };
  }
  return server.getDerivedResource(resourceOptions);
};
function retryCallback(that, error) {
  const ionRoot = defaultValue_default(that._ionRoot, that);
  const endpointResource = ionRoot._ionEndpointResource;
  const imageDefined = typeof Image !== "undefined";
  if (!defined_default(error) || error.statusCode !== 401 && !(imageDefined && error.target instanceof Image)) {
    return Promise.resolve(false);
  }
  if (!defined_default(ionRoot._pendingPromise)) {
    ionRoot._pendingPromise = endpointResource.fetchJson().then(function(newEndpoint) {
      ionRoot._ionEndpoint = newEndpoint;
      return newEndpoint;
    }).finally(function(newEndpoint) {
      ionRoot._pendingPromise = void 0;
      return newEndpoint;
    });
  }
  return ionRoot._pendingPromise.then(function(newEndpoint) {
    that._ionEndpoint = newEndpoint;
    return true;
  });
}
var IonResource_default = IonResource;

// node_modules/cesium/Source/Core/TimeInterval.js
function TimeInterval(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.start = defined_default(options.start) ? JulianDate_default.clone(options.start) : new JulianDate_default();
  this.stop = defined_default(options.stop) ? JulianDate_default.clone(options.stop) : new JulianDate_default();
  this.data = options.data;
  this.isStartIncluded = defaultValue_default(options.isStartIncluded, true);
  this.isStopIncluded = defaultValue_default(options.isStopIncluded, true);
}
Object.defineProperties(TimeInterval.prototype, {
  isEmpty: {
    get: function() {
      const stopComparedToStart = JulianDate_default.compare(this.stop, this.start);
      return stopComparedToStart < 0 || stopComparedToStart === 0 && (!this.isStartIncluded || !this.isStopIncluded);
    }
  }
});
var scratchInterval = {
  start: void 0,
  stop: void 0,
  isStartIncluded: void 0,
  isStopIncluded: void 0,
  data: void 0
};
TimeInterval.fromIso8601 = function(options, result) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.string("options.iso8601", options.iso8601);
  const dates = options.iso8601.split("/");
  if (dates.length !== 2) {
    throw new DeveloperError_default(
      "options.iso8601 is an invalid ISO 8601 interval."
    );
  }
  const start = JulianDate_default.fromIso8601(dates[0]);
  const stop2 = JulianDate_default.fromIso8601(dates[1]);
  const isStartIncluded = defaultValue_default(options.isStartIncluded, true);
  const isStopIncluded = defaultValue_default(options.isStopIncluded, true);
  const data = options.data;
  if (!defined_default(result)) {
    scratchInterval.start = start;
    scratchInterval.stop = stop2;
    scratchInterval.isStartIncluded = isStartIncluded;
    scratchInterval.isStopIncluded = isStopIncluded;
    scratchInterval.data = data;
    return new TimeInterval(scratchInterval);
  }
  result.start = start;
  result.stop = stop2;
  result.isStartIncluded = isStartIncluded;
  result.isStopIncluded = isStopIncluded;
  result.data = data;
  return result;
};
TimeInterval.toIso8601 = function(timeInterval, precision) {
  Check_default.typeOf.object("timeInterval", timeInterval);
  return `${JulianDate_default.toIso8601(
    timeInterval.start,
    precision
  )}/${JulianDate_default.toIso8601(timeInterval.stop, precision)}`;
};
TimeInterval.clone = function(timeInterval, result) {
  if (!defined_default(timeInterval)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new TimeInterval(timeInterval);
  }
  result.start = timeInterval.start;
  result.stop = timeInterval.stop;
  result.isStartIncluded = timeInterval.isStartIncluded;
  result.isStopIncluded = timeInterval.isStopIncluded;
  result.data = timeInterval.data;
  return result;
};
TimeInterval.equals = function(left, right, dataComparer) {
  return left === right || defined_default(left) && defined_default(right) && (left.isEmpty && right.isEmpty || left.isStartIncluded === right.isStartIncluded && left.isStopIncluded === right.isStopIncluded && JulianDate_default.equals(left.start, right.start) && JulianDate_default.equals(left.stop, right.stop) && (left.data === right.data || defined_default(dataComparer) && dataComparer(left.data, right.data)));
};
TimeInterval.equalsEpsilon = function(left, right, epsilon, dataComparer) {
  epsilon = defaultValue_default(epsilon, 0);
  return left === right || defined_default(left) && defined_default(right) && (left.isEmpty && right.isEmpty || left.isStartIncluded === right.isStartIncluded && left.isStopIncluded === right.isStopIncluded && JulianDate_default.equalsEpsilon(left.start, right.start, epsilon) && JulianDate_default.equalsEpsilon(left.stop, right.stop, epsilon) && (left.data === right.data || defined_default(dataComparer) && dataComparer(left.data, right.data)));
};
TimeInterval.intersect = function(left, right, result, mergeCallback) {
  Check_default.typeOf.object("left", left);
  if (!defined_default(right)) {
    return TimeInterval.clone(TimeInterval.EMPTY, result);
  }
  const leftStart = left.start;
  const leftStop = left.stop;
  const rightStart = right.start;
  const rightStop = right.stop;
  const intersectsStartRight = JulianDate_default.greaterThanOrEquals(rightStart, leftStart) && JulianDate_default.greaterThanOrEquals(leftStop, rightStart);
  const intersectsStartLeft = !intersectsStartRight && JulianDate_default.lessThanOrEquals(rightStart, leftStart) && JulianDate_default.lessThanOrEquals(leftStart, rightStop);
  if (!intersectsStartRight && !intersectsStartLeft) {
    return TimeInterval.clone(TimeInterval.EMPTY, result);
  }
  const leftIsStartIncluded = left.isStartIncluded;
  const leftIsStopIncluded = left.isStopIncluded;
  const rightIsStartIncluded = right.isStartIncluded;
  const rightIsStopIncluded = right.isStopIncluded;
  const leftLessThanRight = JulianDate_default.lessThan(leftStop, rightStop);
  if (!defined_default(result)) {
    result = new TimeInterval();
  }
  result.start = intersectsStartRight ? rightStart : leftStart;
  result.isStartIncluded = leftIsStartIncluded && rightIsStartIncluded || !JulianDate_default.equals(rightStart, leftStart) && (intersectsStartRight && rightIsStartIncluded || intersectsStartLeft && leftIsStartIncluded);
  result.stop = leftLessThanRight ? leftStop : rightStop;
  result.isStopIncluded = leftLessThanRight ? leftIsStopIncluded : leftIsStopIncluded && rightIsStopIncluded || !JulianDate_default.equals(rightStop, leftStop) && rightIsStopIncluded;
  result.data = defined_default(mergeCallback) ? mergeCallback(left.data, right.data) : left.data;
  return result;
};
TimeInterval.contains = function(timeInterval, julianDate) {
  Check_default.typeOf.object("timeInterval", timeInterval);
  Check_default.typeOf.object("julianDate", julianDate);
  if (timeInterval.isEmpty) {
    return false;
  }
  const startComparedToDate = JulianDate_default.compare(
    timeInterval.start,
    julianDate
  );
  if (startComparedToDate === 0) {
    return timeInterval.isStartIncluded;
  }
  const dateComparedToStop = JulianDate_default.compare(julianDate, timeInterval.stop);
  if (dateComparedToStop === 0) {
    return timeInterval.isStopIncluded;
  }
  return startComparedToDate < 0 && dateComparedToStop < 0;
};
TimeInterval.prototype.clone = function(result) {
  return TimeInterval.clone(this, result);
};
TimeInterval.prototype.equals = function(right, dataComparer) {
  return TimeInterval.equals(this, right, dataComparer);
};
TimeInterval.prototype.equalsEpsilon = function(right, epsilon, dataComparer) {
  return TimeInterval.equalsEpsilon(this, right, epsilon, dataComparer);
};
TimeInterval.prototype.toString = function() {
  return TimeInterval.toIso8601(this);
};
TimeInterval.EMPTY = Object.freeze(
  new TimeInterval({
    start: new JulianDate_default(),
    stop: new JulianDate_default(),
    isStartIncluded: false,
    isStopIncluded: false
  })
);
var TimeInterval_default = TimeInterval;

// node_modules/cesium/Source/Core/Iso8601.js
var MINIMUM_VALUE = Object.freeze(
  JulianDate_default.fromIso8601("0000-01-01T00:00:00Z")
);
var MAXIMUM_VALUE = Object.freeze(
  JulianDate_default.fromIso8601("9999-12-31T24:00:00Z")
);
var MAXIMUM_INTERVAL = Object.freeze(
  new TimeInterval_default({
    start: MINIMUM_VALUE,
    stop: MAXIMUM_VALUE
  })
);
var Iso8601 = {
  MINIMUM_VALUE,
  MAXIMUM_VALUE,
  MAXIMUM_INTERVAL
};
var Iso8601_default = Iso8601;

// node_modules/cesium/Source/Core/KTX2Transcoder.js
function KTX2Transcoder() {
}
KTX2Transcoder._transcodeTaskProcessor = new TaskProcessor_default(
  "transcodeKTX2",
  Number.POSITIVE_INFINITY
);
KTX2Transcoder._readyPromise = void 0;
function makeReadyPromise() {
  const readyPromise = KTX2Transcoder._transcodeTaskProcessor.initWebAssemblyModule({
    modulePath: "ThirdParty/Workers/basis_transcoder.js",
    wasmBinaryFile: "ThirdParty/basis_transcoder.wasm"
  }).then(function() {
    return KTX2Transcoder._transcodeTaskProcessor;
  });
  KTX2Transcoder._readyPromise = readyPromise;
}
KTX2Transcoder.transcode = function(ktx2Buffer, supportedTargetFormats) {
  Check_default.defined("supportedTargetFormats", supportedTargetFormats);
  if (!defined_default(KTX2Transcoder._readyPromise)) {
    makeReadyPromise();
  }
  return KTX2Transcoder._readyPromise.then(function(taskProcessor3) {
    let parameters;
    if (ktx2Buffer instanceof ArrayBuffer) {
      const view = new Uint8Array(ktx2Buffer);
      parameters = {
        supportedTargetFormats,
        ktx2Buffer: view
      };
      return taskProcessor3.scheduleTask(parameters, [ktx2Buffer]);
    }
    parameters = {
      supportedTargetFormats,
      ktx2Buffer
    };
    return taskProcessor3.scheduleTask(parameters, [ktx2Buffer.buffer]);
  }).then(function(result) {
    const levelsLength = result.length;
    const faceKeys = Object.keys(result[0]);
    const faceKeysLength = faceKeys.length;
    let i2;
    for (i2 = 0; i2 < levelsLength; i2++) {
      const faces2 = result[i2];
      for (let j = 0; j < faceKeysLength; j++) {
        const face = faces2[faceKeys[j]];
        faces2[faceKeys[j]] = new CompressedTextureBuffer_default(
          face.internalFormat,
          face.datatype,
          face.width,
          face.height,
          face.levelBuffer
        );
      }
    }
    if (faceKeysLength === 1) {
      for (i2 = 0; i2 < levelsLength; ++i2) {
        result[i2] = result[i2][faceKeys[0]];
      }
      if (levelsLength === 1) {
        result = result[0];
      }
    }
    return result;
  }).catch(function(error) {
    throw error;
  });
};
var KTX2Transcoder_default = KTX2Transcoder;

// node_modules/cesium/Source/Core/KeyboardEventModifier.js
var KeyboardEventModifier = {
  SHIFT: 0,
  CTRL: 1,
  ALT: 2
};
var KeyboardEventModifier_default = Object.freeze(KeyboardEventModifier);

// node_modules/cesium/Source/Core/LagrangePolynomialApproximation.js
var LagrangePolynomialApproximation = {
  type: "Lagrange"
};
LagrangePolynomialApproximation.getRequiredDataPoints = function(degree) {
  return Math.max(degree + 1, 2);
};
LagrangePolynomialApproximation.interpolateOrderZero = function(x, xTable, yTable, yStride, result) {
  if (!defined_default(result)) {
    result = new Array(yStride);
  }
  let i2;
  let j;
  const length3 = xTable.length;
  for (i2 = 0; i2 < yStride; i2++) {
    result[i2] = 0;
  }
  for (i2 = 0; i2 < length3; i2++) {
    let coefficient = 1;
    for (j = 0; j < length3; j++) {
      if (j !== i2) {
        const diffX = xTable[i2] - xTable[j];
        coefficient *= (x - xTable[j]) / diffX;
      }
    }
    for (j = 0; j < yStride; j++) {
      result[j] += coefficient * yTable[i2 * yStride + j];
    }
  }
  return result;
};
var LagrangePolynomialApproximation_default = LagrangePolynomialApproximation;

// node_modules/cesium/Source/Core/LinearApproximation.js
var LinearApproximation = {
  type: "Linear"
};
LinearApproximation.getRequiredDataPoints = function(degree) {
  return 2;
};
LinearApproximation.interpolateOrderZero = function(x, xTable, yTable, yStride, result) {
  if (xTable.length !== 2) {
    throw new DeveloperError_default(
      "The xTable provided to the linear interpolator must have exactly two elements."
    );
  } else if (yStride <= 0) {
    throw new DeveloperError_default(
      "There must be at least 1 dependent variable for each independent variable."
    );
  }
  if (!defined_default(result)) {
    result = new Array(yStride);
  }
  let i2;
  let y0;
  let y1;
  const x0 = xTable[0];
  const x1 = xTable[1];
  if (x0 === x1) {
    throw new DeveloperError_default(
      "Divide by zero error: xTable[0] and xTable[1] are equal"
    );
  }
  for (i2 = 0; i2 < yStride; i2++) {
    y0 = yTable[i2];
    y1 = yTable[i2 + yStride];
    result[i2] = ((y1 - y0) * x + x1 * y0 - x0 * y1) / (x1 - x0);
  }
  return result;
};
var LinearApproximation_default = LinearApproximation;

// node_modules/cesium/Source/Core/ManagedArray.js
function ManagedArray(length3) {
  length3 = defaultValue_default(length3, 0);
  this._array = new Array(length3);
  this._length = length3;
}
Object.defineProperties(ManagedArray.prototype, {
  length: {
    get: function() {
      return this._length;
    },
    set: function(length3) {
      Check_default.typeOf.number.greaterThanOrEquals("length", length3, 0);
      const array = this._array;
      const originalLength = this._length;
      if (length3 < originalLength) {
        for (let i2 = length3; i2 < originalLength; ++i2) {
          array[i2] = void 0;
        }
      } else if (length3 > array.length) {
        array.length = length3;
      }
      this._length = length3;
    }
  },
  values: {
    get: function() {
      return this._array;
    }
  }
});
ManagedArray.prototype.get = function(index2) {
  Check_default.typeOf.number.lessThan("index", index2, this._array.length);
  return this._array[index2];
};
ManagedArray.prototype.set = function(index2, element) {
  Check_default.typeOf.number("index", index2);
  if (index2 >= this._length) {
    this.length = index2 + 1;
  }
  this._array[index2] = element;
};
ManagedArray.prototype.peek = function() {
  return this._array[this._length - 1];
};
ManagedArray.prototype.push = function(element) {
  const index2 = this.length++;
  this._array[index2] = element;
};
ManagedArray.prototype.pop = function() {
  if (this._length === 0) {
    return void 0;
  }
  const element = this._array[this._length - 1];
  --this.length;
  return element;
};
ManagedArray.prototype.reserve = function(length3) {
  Check_default.typeOf.number.greaterThanOrEquals("length", length3, 0);
  if (length3 > this._array.length) {
    this._array.length = length3;
  }
};
ManagedArray.prototype.resize = function(length3) {
  Check_default.typeOf.number.greaterThanOrEquals("length", length3, 0);
  this.length = length3;
};
ManagedArray.prototype.trim = function(length3) {
  length3 = defaultValue_default(length3, this._length);
  this._array.length = length3;
};
var ManagedArray_default = ManagedArray;

// node_modules/cesium/Source/Core/MapProjection.js
function MapProjection() {
  DeveloperError_default.throwInstantiationError();
}
Object.defineProperties(MapProjection.prototype, {
  ellipsoid: {
    get: DeveloperError_default.throwInstantiationError
  }
});
MapProjection.prototype.project = DeveloperError_default.throwInstantiationError;
MapProjection.prototype.unproject = DeveloperError_default.throwInstantiationError;
var MapProjection_default = MapProjection;

// node_modules/cesium/Source/Core/MorphWeightSpline.js
function MorphWeightSpline(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const weights2 = options.weights;
  const times = options.times;
  Check_default.defined("weights", weights2);
  Check_default.defined("times", times);
  Check_default.typeOf.number.greaterThanOrEquals("weights.length", weights2.length, 3);
  if (weights2.length % times.length !== 0) {
    throw new DeveloperError_default(
      "times.length must be a factor of weights.length."
    );
  }
  this._times = times;
  this._weights = weights2;
  this._count = weights2.length / times.length;
  this._lastTimeIndex = 0;
}
Object.defineProperties(MorphWeightSpline.prototype, {
  times: {
    get: function() {
      return this._times;
    }
  },
  weights: {
    get: function() {
      return this._weights;
    }
  }
});
MorphWeightSpline.prototype.findTimeInterval = Spline_default.prototype.findTimeInterval;
MorphWeightSpline.prototype.wrapTime = Spline_default.prototype.wrapTime;
MorphWeightSpline.prototype.clampTime = Spline_default.prototype.clampTime;
MorphWeightSpline.prototype.evaluate = function(time, result) {
  const weights2 = this.weights;
  const times = this.times;
  const i2 = this._lastTimeIndex = this.findTimeInterval(
    time,
    this._lastTimeIndex
  );
  const u3 = (time - times[i2]) / (times[i2 + 1] - times[i2]);
  if (!defined_default(result)) {
    result = new Array(this._count);
  }
  for (let j = 0; j < this._count; j++) {
    const index2 = i2 * this._count + j;
    result[j] = weights2[index2] * (1 - u3) + weights2[index2 + this._count] * u3;
  }
  return result;
};
var MorphWeightSpline_default = MorphWeightSpline;

// node_modules/cesium/Source/Core/MortonOrder.js
var MortonOrder = {};
function insertOneSpacing(v7) {
  v7 = (v7 ^ v7 << 8) & 16711935;
  v7 = (v7 ^ v7 << 4) & 252645135;
  v7 = (v7 ^ v7 << 2) & 858993459;
  v7 = (v7 ^ v7 << 1) & 1431655765;
  return v7;
}
function insertTwoSpacing(v7) {
  v7 = (v7 ^ v7 << 16) & 50331903;
  v7 = (v7 ^ v7 << 8) & 50393103;
  v7 = (v7 ^ v7 << 4) & 51130563;
  v7 = (v7 ^ v7 << 2) & 153391689;
  return v7;
}
function removeOneSpacing(v7) {
  v7 &= 1431655765;
  v7 = (v7 ^ v7 >> 1) & 858993459;
  v7 = (v7 ^ v7 >> 2) & 252645135;
  v7 = (v7 ^ v7 >> 4) & 16711935;
  v7 = (v7 ^ v7 >> 8) & 65535;
  return v7;
}
function removeTwoSpacing(v7) {
  v7 &= 153391689;
  v7 = (v7 ^ v7 >> 2) & 51130563;
  v7 = (v7 ^ v7 >> 4) & 50393103;
  v7 = (v7 ^ v7 >> 8) & 4278190335;
  v7 = (v7 ^ v7 >> 16) & 1023;
  return v7;
}
MortonOrder.encode2D = function(x, y) {
  Check_default.typeOf.number("x", x);
  Check_default.typeOf.number("y", y);
  if (x < 0 || x > 65535 || y < 0 || y > 65535) {
    throw new DeveloperError_default("inputs must be 16-bit unsigned integers");
  }
  return (insertOneSpacing(x) | insertOneSpacing(y) << 1) >>> 0;
};
MortonOrder.decode2D = function(mortonIndex, result) {
  Check_default.typeOf.number("mortonIndex", mortonIndex);
  if (mortonIndex < 0 || mortonIndex > 4294967295) {
    throw new DeveloperError_default("input must be a 32-bit unsigned integer");
  }
  if (!defined_default(result)) {
    result = new Array(2);
  }
  result[0] = removeOneSpacing(mortonIndex);
  result[1] = removeOneSpacing(mortonIndex >> 1);
  return result;
};
MortonOrder.encode3D = function(x, y, z) {
  Check_default.typeOf.number("x", x);
  Check_default.typeOf.number("y", y);
  Check_default.typeOf.number("z", z);
  if (x < 0 || x > 1023 || y < 0 || y > 1023 || z < 0 || z > 1023) {
    throw new DeveloperError_default("inputs must be 10-bit unsigned integers");
  }
  return insertTwoSpacing(x) | insertTwoSpacing(y) << 1 | insertTwoSpacing(z) << 2;
};
MortonOrder.decode3D = function(mortonIndex, result) {
  Check_default.typeOf.number("mortonIndex", mortonIndex);
  if (mortonIndex < 0 || mortonIndex > 1073741823) {
    throw new DeveloperError_default("input must be a 30-bit unsigned integer");
  }
  if (!defined_default(result)) {
    result = new Array(3);
  }
  result[0] = removeTwoSpacing(mortonIndex);
  result[1] = removeTwoSpacing(mortonIndex >> 1);
  result[2] = removeTwoSpacing(mortonIndex >> 2);
  return result;
};
var MortonOrder_default = MortonOrder;

// node_modules/cesium/Source/Core/NearFarScalar.js
function NearFarScalar(near, nearValue, far, farValue) {
  this.near = defaultValue_default(near, 0);
  this.nearValue = defaultValue_default(nearValue, 0);
  this.far = defaultValue_default(far, 1);
  this.farValue = defaultValue_default(farValue, 0);
}
NearFarScalar.clone = function(nearFarScalar, result) {
  if (!defined_default(nearFarScalar)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new NearFarScalar(
      nearFarScalar.near,
      nearFarScalar.nearValue,
      nearFarScalar.far,
      nearFarScalar.farValue
    );
  }
  result.near = nearFarScalar.near;
  result.nearValue = nearFarScalar.nearValue;
  result.far = nearFarScalar.far;
  result.farValue = nearFarScalar.farValue;
  return result;
};
NearFarScalar.packedLength = 4;
NearFarScalar.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  array[startingIndex++] = value.near;
  array[startingIndex++] = value.nearValue;
  array[startingIndex++] = value.far;
  array[startingIndex] = value.farValue;
  return array;
};
NearFarScalar.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  if (!defined_default(result)) {
    result = new NearFarScalar();
  }
  result.near = array[startingIndex++];
  result.nearValue = array[startingIndex++];
  result.far = array[startingIndex++];
  result.farValue = array[startingIndex];
  return result;
};
NearFarScalar.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.near === right.near && left.nearValue === right.nearValue && left.far === right.far && left.farValue === right.farValue;
};
NearFarScalar.prototype.clone = function(result) {
  return NearFarScalar.clone(this, result);
};
NearFarScalar.prototype.equals = function(right) {
  return NearFarScalar.equals(this, right);
};
var NearFarScalar_default = NearFarScalar;

// node_modules/cesium/Source/Core/Visibility.js
var Visibility = {
  NONE: -1,
  PARTIAL: 0,
  FULL: 1
};
var Visibility_default = Object.freeze(Visibility);

// node_modules/cesium/Source/Core/Occluder.js
function Occluder(occluderBoundingSphere, cameraPosition) {
  if (!defined_default(occluderBoundingSphere)) {
    throw new DeveloperError_default("occluderBoundingSphere is required.");
  }
  if (!defined_default(cameraPosition)) {
    throw new DeveloperError_default("camera position is required.");
  }
  this._occluderPosition = Cartesian3_default.clone(occluderBoundingSphere.center);
  this._occluderRadius = occluderBoundingSphere.radius;
  this._horizonDistance = 0;
  this._horizonPlaneNormal = void 0;
  this._horizonPlanePosition = void 0;
  this._cameraPosition = void 0;
  this.cameraPosition = cameraPosition;
}
var scratchCartesian38 = new Cartesian3_default();
Object.defineProperties(Occluder.prototype, {
  position: {
    get: function() {
      return this._occluderPosition;
    }
  },
  radius: {
    get: function() {
      return this._occluderRadius;
    }
  },
  cameraPosition: {
    set: function(cameraPosition) {
      if (!defined_default(cameraPosition)) {
        throw new DeveloperError_default("cameraPosition is required.");
      }
      cameraPosition = Cartesian3_default.clone(cameraPosition, this._cameraPosition);
      const cameraToOccluderVec = Cartesian3_default.subtract(
        this._occluderPosition,
        cameraPosition,
        scratchCartesian38
      );
      let invCameraToOccluderDistance = Cartesian3_default.magnitudeSquared(
        cameraToOccluderVec
      );
      const occluderRadiusSqrd = this._occluderRadius * this._occluderRadius;
      let horizonDistance;
      let horizonPlaneNormal;
      let horizonPlanePosition;
      if (invCameraToOccluderDistance > occluderRadiusSqrd) {
        horizonDistance = Math.sqrt(
          invCameraToOccluderDistance - occluderRadiusSqrd
        );
        invCameraToOccluderDistance = 1 / Math.sqrt(invCameraToOccluderDistance);
        horizonPlaneNormal = Cartesian3_default.multiplyByScalar(
          cameraToOccluderVec,
          invCameraToOccluderDistance,
          scratchCartesian38
        );
        const nearPlaneDistance = horizonDistance * horizonDistance * invCameraToOccluderDistance;
        horizonPlanePosition = Cartesian3_default.add(
          cameraPosition,
          Cartesian3_default.multiplyByScalar(
            horizonPlaneNormal,
            nearPlaneDistance,
            scratchCartesian38
          ),
          scratchCartesian38
        );
      } else {
        horizonDistance = Number.MAX_VALUE;
      }
      this._horizonDistance = horizonDistance;
      this._horizonPlaneNormal = horizonPlaneNormal;
      this._horizonPlanePosition = horizonPlanePosition;
      this._cameraPosition = cameraPosition;
    }
  }
});
Occluder.fromBoundingSphere = function(occluderBoundingSphere, cameraPosition, result) {
  if (!defined_default(occluderBoundingSphere)) {
    throw new DeveloperError_default("occluderBoundingSphere is required.");
  }
  if (!defined_default(cameraPosition)) {
    throw new DeveloperError_default("camera position is required.");
  }
  if (!defined_default(result)) {
    return new Occluder(occluderBoundingSphere, cameraPosition);
  }
  Cartesian3_default.clone(occluderBoundingSphere.center, result._occluderPosition);
  result._occluderRadius = occluderBoundingSphere.radius;
  result.cameraPosition = cameraPosition;
  return result;
};
var tempVecScratch = new Cartesian3_default();
Occluder.prototype.isPointVisible = function(occludee) {
  if (this._horizonDistance !== Number.MAX_VALUE) {
    let tempVec2 = Cartesian3_default.subtract(
      occludee,
      this._occluderPosition,
      tempVecScratch
    );
    let temp = this._occluderRadius;
    temp = Cartesian3_default.magnitudeSquared(tempVec2) - temp * temp;
    if (temp > 0) {
      temp = Math.sqrt(temp) + this._horizonDistance;
      tempVec2 = Cartesian3_default.subtract(occludee, this._cameraPosition, tempVec2);
      return temp * temp > Cartesian3_default.magnitudeSquared(tempVec2);
    }
  }
  return false;
};
var occludeePositionScratch = new Cartesian3_default();
Occluder.prototype.isBoundingSphereVisible = function(occludee) {
  const occludeePosition = Cartesian3_default.clone(
    occludee.center,
    occludeePositionScratch
  );
  const occludeeRadius = occludee.radius;
  if (this._horizonDistance !== Number.MAX_VALUE) {
    let tempVec2 = Cartesian3_default.subtract(
      occludeePosition,
      this._occluderPosition,
      tempVecScratch
    );
    let temp = this._occluderRadius - occludeeRadius;
    temp = Cartesian3_default.magnitudeSquared(tempVec2) - temp * temp;
    if (occludeeRadius < this._occluderRadius) {
      if (temp > 0) {
        temp = Math.sqrt(temp) + this._horizonDistance;
        tempVec2 = Cartesian3_default.subtract(
          occludeePosition,
          this._cameraPosition,
          tempVec2
        );
        return temp * temp + occludeeRadius * occludeeRadius > Cartesian3_default.magnitudeSquared(tempVec2);
      }
      return false;
    }
    if (temp > 0) {
      tempVec2 = Cartesian3_default.subtract(
        occludeePosition,
        this._cameraPosition,
        tempVec2
      );
      const tempVecMagnitudeSquared = Cartesian3_default.magnitudeSquared(tempVec2);
      const occluderRadiusSquared = this._occluderRadius * this._occluderRadius;
      const occludeeRadiusSquared = occludeeRadius * occludeeRadius;
      if ((this._horizonDistance * this._horizonDistance + occluderRadiusSquared) * occludeeRadiusSquared > tempVecMagnitudeSquared * occluderRadiusSquared) {
        return true;
      }
      temp = Math.sqrt(temp) + this._horizonDistance;
      return temp * temp + occludeeRadiusSquared > tempVecMagnitudeSquared;
    }
    return true;
  }
  return false;
};
var tempScratch2 = new Cartesian3_default();
Occluder.prototype.computeVisibility = function(occludeeBS) {
  if (!defined_default(occludeeBS)) {
    throw new DeveloperError_default("occludeeBS is required.");
  }
  const occludeePosition = Cartesian3_default.clone(occludeeBS.center);
  const occludeeRadius = occludeeBS.radius;
  if (occludeeRadius > this._occluderRadius) {
    return Visibility_default.FULL;
  }
  if (this._horizonDistance !== Number.MAX_VALUE) {
    let tempVec2 = Cartesian3_default.subtract(
      occludeePosition,
      this._occluderPosition,
      tempScratch2
    );
    let temp = this._occluderRadius - occludeeRadius;
    const occluderToOccludeeDistSqrd = Cartesian3_default.magnitudeSquared(tempVec2);
    temp = occluderToOccludeeDistSqrd - temp * temp;
    if (temp > 0) {
      temp = Math.sqrt(temp) + this._horizonDistance;
      tempVec2 = Cartesian3_default.subtract(
        occludeePosition,
        this._cameraPosition,
        tempVec2
      );
      const cameraToOccludeeDistSqrd = Cartesian3_default.magnitudeSquared(tempVec2);
      if (temp * temp + occludeeRadius * occludeeRadius < cameraToOccludeeDistSqrd) {
        return Visibility_default.NONE;
      }
      temp = this._occluderRadius + occludeeRadius;
      temp = occluderToOccludeeDistSqrd - temp * temp;
      if (temp > 0) {
        temp = Math.sqrt(temp) + this._horizonDistance;
        return cameraToOccludeeDistSqrd < temp * temp + occludeeRadius * occludeeRadius ? Visibility_default.FULL : Visibility_default.PARTIAL;
      }
      tempVec2 = Cartesian3_default.subtract(
        occludeePosition,
        this._horizonPlanePosition,
        tempVec2
      );
      return Cartesian3_default.dot(tempVec2, this._horizonPlaneNormal) > -occludeeRadius ? Visibility_default.PARTIAL : Visibility_default.FULL;
    }
  }
  return Visibility_default.NONE;
};
var occludeePointScratch = new Cartesian3_default();
Occluder.computeOccludeePoint = function(occluderBoundingSphere, occludeePosition, positions) {
  if (!defined_default(occluderBoundingSphere)) {
    throw new DeveloperError_default("occluderBoundingSphere is required.");
  }
  if (!defined_default(positions)) {
    throw new DeveloperError_default("positions is required.");
  }
  if (positions.length === 0) {
    throw new DeveloperError_default("positions must contain at least one element");
  }
  const occludeePos = Cartesian3_default.clone(occludeePosition);
  const occluderPosition = Cartesian3_default.clone(occluderBoundingSphere.center);
  const occluderRadius = occluderBoundingSphere.radius;
  const numPositions = positions.length;
  if (Cartesian3_default.equals(occluderPosition, occludeePosition)) {
    throw new DeveloperError_default(
      "occludeePosition must be different than occluderBoundingSphere.center"
    );
  }
  const occluderPlaneNormal = Cartesian3_default.normalize(
    Cartesian3_default.subtract(occludeePos, occluderPosition, occludeePointScratch),
    occludeePointScratch
  );
  const occluderPlaneD = -Cartesian3_default.dot(occluderPlaneNormal, occluderPosition);
  const aRotationVector = Occluder._anyRotationVector(
    occluderPosition,
    occluderPlaneNormal,
    occluderPlaneD
  );
  let dot2 = Occluder._horizonToPlaneNormalDotProduct(
    occluderBoundingSphere,
    occluderPlaneNormal,
    occluderPlaneD,
    aRotationVector,
    positions[0]
  );
  if (!dot2) {
    return void 0;
  }
  let tempDot;
  for (let i2 = 1; i2 < numPositions; ++i2) {
    tempDot = Occluder._horizonToPlaneNormalDotProduct(
      occluderBoundingSphere,
      occluderPlaneNormal,
      occluderPlaneD,
      aRotationVector,
      positions[i2]
    );
    if (!tempDot) {
      return void 0;
    }
    if (tempDot < dot2) {
      dot2 = tempDot;
    }
  }
  if (dot2 < 0.0017453283658983088) {
    return void 0;
  }
  const distance2 = occluderRadius / dot2;
  return Cartesian3_default.add(
    occluderPosition,
    Cartesian3_default.multiplyByScalar(
      occluderPlaneNormal,
      distance2,
      occludeePointScratch
    ),
    occludeePointScratch
  );
};
var computeOccludeePointFromRectangleScratch = [];
Occluder.computeOccludeePointFromRectangle = function(rectangle, ellipsoid) {
  if (!defined_default(rectangle)) {
    throw new DeveloperError_default("rectangle is required.");
  }
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  const positions = Rectangle_default.subsample(
    rectangle,
    ellipsoid,
    0,
    computeOccludeePointFromRectangleScratch
  );
  const bs = BoundingSphere_default.fromPoints(positions);
  const ellipsoidCenter = Cartesian3_default.ZERO;
  if (!Cartesian3_default.equals(ellipsoidCenter, bs.center)) {
    return Occluder.computeOccludeePoint(
      new BoundingSphere_default(ellipsoidCenter, ellipsoid.minimumRadius),
      bs.center,
      positions
    );
  }
  return void 0;
};
var tempVec0Scratch = new Cartesian3_default();
Occluder._anyRotationVector = function(occluderPosition, occluderPlaneNormal, occluderPlaneD) {
  const tempVec0 = Cartesian3_default.abs(occluderPlaneNormal, tempVec0Scratch);
  let majorAxis = tempVec0.x > tempVec0.y ? 0 : 1;
  if (majorAxis === 0 && tempVec0.z > tempVec0.x || majorAxis === 1 && tempVec0.z > tempVec0.y) {
    majorAxis = 2;
  }
  const tempVec2 = new Cartesian3_default();
  let tempVec1;
  if (majorAxis === 0) {
    tempVec0.x = occluderPosition.x;
    tempVec0.y = occluderPosition.y + 1;
    tempVec0.z = occluderPosition.z + 1;
    tempVec1 = Cartesian3_default.UNIT_X;
  } else if (majorAxis === 1) {
    tempVec0.x = occluderPosition.x + 1;
    tempVec0.y = occluderPosition.y;
    tempVec0.z = occluderPosition.z + 1;
    tempVec1 = Cartesian3_default.UNIT_Y;
  } else {
    tempVec0.x = occluderPosition.x + 1;
    tempVec0.y = occluderPosition.y + 1;
    tempVec0.z = occluderPosition.z;
    tempVec1 = Cartesian3_default.UNIT_Z;
  }
  const u3 = (Cartesian3_default.dot(occluderPlaneNormal, tempVec0) + occluderPlaneD) / -Cartesian3_default.dot(occluderPlaneNormal, tempVec1);
  return Cartesian3_default.normalize(
    Cartesian3_default.subtract(
      Cartesian3_default.add(
        tempVec0,
        Cartesian3_default.multiplyByScalar(tempVec1, u3, tempVec2),
        tempVec0
      ),
      occluderPosition,
      tempVec0
    ),
    tempVec0
  );
};
var posDirectionScratch = new Cartesian3_default();
Occluder._rotationVector = function(occluderPosition, occluderPlaneNormal, occluderPlaneD, position, anyRotationVector) {
  let positionDirection = Cartesian3_default.subtract(
    position,
    occluderPosition,
    posDirectionScratch
  );
  positionDirection = Cartesian3_default.normalize(
    positionDirection,
    positionDirection
  );
  if (Cartesian3_default.dot(occluderPlaneNormal, positionDirection) < 0.9999999847691291) {
    const crossProduct = Cartesian3_default.cross(
      occluderPlaneNormal,
      positionDirection,
      positionDirection
    );
    const length3 = Cartesian3_default.magnitude(crossProduct);
    if (length3 > Math_default.EPSILON13) {
      return Cartesian3_default.normalize(crossProduct, new Cartesian3_default());
    }
  }
  return anyRotationVector;
};
var posScratch1 = new Cartesian3_default();
var occluerPosScratch = new Cartesian3_default();
var posScratch2 = new Cartesian3_default();
var horizonPlanePosScratch = new Cartesian3_default();
Occluder._horizonToPlaneNormalDotProduct = function(occluderBS, occluderPlaneNormal, occluderPlaneD, anyRotationVector, position) {
  const pos = Cartesian3_default.clone(position, posScratch1);
  const occluderPosition = Cartesian3_default.clone(
    occluderBS.center,
    occluerPosScratch
  );
  const occluderRadius = occluderBS.radius;
  let positionToOccluder = Cartesian3_default.subtract(
    occluderPosition,
    pos,
    posScratch2
  );
  const occluderToPositionDistanceSquared = Cartesian3_default.magnitudeSquared(
    positionToOccluder
  );
  const occluderRadiusSquared = occluderRadius * occluderRadius;
  if (occluderToPositionDistanceSquared < occluderRadiusSquared) {
    return false;
  }
  const horizonDistanceSquared = occluderToPositionDistanceSquared - occluderRadiusSquared;
  const horizonDistance = Math.sqrt(horizonDistanceSquared);
  const occluderToPositionDistance = Math.sqrt(
    occluderToPositionDistanceSquared
  );
  const invOccluderToPositionDistance = 1 / occluderToPositionDistance;
  const cosTheta = horizonDistance * invOccluderToPositionDistance;
  const horizonPlaneDistance = cosTheta * horizonDistance;
  positionToOccluder = Cartesian3_default.normalize(
    positionToOccluder,
    positionToOccluder
  );
  const horizonPlanePosition = Cartesian3_default.add(
    pos,
    Cartesian3_default.multiplyByScalar(
      positionToOccluder,
      horizonPlaneDistance,
      horizonPlanePosScratch
    ),
    horizonPlanePosScratch
  );
  const horizonCrossDistance = Math.sqrt(
    horizonDistanceSquared - horizonPlaneDistance * horizonPlaneDistance
  );
  let tempVec2 = this._rotationVector(
    occluderPosition,
    occluderPlaneNormal,
    occluderPlaneD,
    pos,
    anyRotationVector
  );
  let horizonCrossDirection = Cartesian3_default.fromElements(
    tempVec2.x * tempVec2.x * positionToOccluder.x + (tempVec2.x * tempVec2.y - tempVec2.z) * positionToOccluder.y + (tempVec2.x * tempVec2.z + tempVec2.y) * positionToOccluder.z,
    (tempVec2.x * tempVec2.y + tempVec2.z) * positionToOccluder.x + tempVec2.y * tempVec2.y * positionToOccluder.y + (tempVec2.y * tempVec2.z - tempVec2.x) * positionToOccluder.z,
    (tempVec2.x * tempVec2.z - tempVec2.y) * positionToOccluder.x + (tempVec2.y * tempVec2.z + tempVec2.x) * positionToOccluder.y + tempVec2.z * tempVec2.z * positionToOccluder.z,
    posScratch1
  );
  horizonCrossDirection = Cartesian3_default.normalize(
    horizonCrossDirection,
    horizonCrossDirection
  );
  const offset2 = Cartesian3_default.multiplyByScalar(
    horizonCrossDirection,
    horizonCrossDistance,
    posScratch1
  );
  tempVec2 = Cartesian3_default.normalize(
    Cartesian3_default.subtract(
      Cartesian3_default.add(horizonPlanePosition, offset2, posScratch2),
      occluderPosition,
      posScratch2
    ),
    posScratch2
  );
  const dot0 = Cartesian3_default.dot(occluderPlaneNormal, tempVec2);
  tempVec2 = Cartesian3_default.normalize(
    Cartesian3_default.subtract(
      Cartesian3_default.subtract(horizonPlanePosition, offset2, tempVec2),
      occluderPosition,
      tempVec2
    ),
    tempVec2
  );
  const dot1 = Cartesian3_default.dot(occluderPlaneNormal, tempVec2);
  return dot0 < dot1 ? dot0 : dot1;
};
var Occluder_default = Occluder;

// node_modules/cesium/Source/Core/OffsetGeometryInstanceAttribute.js
function OffsetGeometryInstanceAttribute(x, y, z) {
  x = defaultValue_default(x, 0);
  y = defaultValue_default(y, 0);
  z = defaultValue_default(z, 0);
  this.value = new Float32Array([x, y, z]);
}
Object.defineProperties(OffsetGeometryInstanceAttribute.prototype, {
  componentDatatype: {
    get: function() {
      return ComponentDatatype_default.FLOAT;
    }
  },
  componentsPerAttribute: {
    get: function() {
      return 3;
    }
  },
  normalize: {
    get: function() {
      return false;
    }
  }
});
OffsetGeometryInstanceAttribute.fromCartesian3 = function(offset2) {
  Check_default.defined("offset", offset2);
  return new OffsetGeometryInstanceAttribute(offset2.x, offset2.y, offset2.z);
};
OffsetGeometryInstanceAttribute.toValue = function(offset2, result) {
  Check_default.defined("offset", offset2);
  if (!defined_default(result)) {
    result = new Float32Array([offset2.x, offset2.y, offset2.z]);
  }
  result[0] = offset2.x;
  result[1] = offset2.y;
  result[2] = offset2.z;
  return result;
};
var OffsetGeometryInstanceAttribute_default = OffsetGeometryInstanceAttribute;

// node_modules/cesium/Source/Core/OpenCageGeocoderService.js
function OpenCageGeocoderService(url2, apiKey, params) {
  Check_default.defined("url", url2);
  Check_default.defined("apiKey", apiKey);
  if (defined_default(params)) {
    Check_default.typeOf.object("params", params);
  }
  url2 = Resource_default.createIfNeeded(url2);
  url2.appendForwardSlash();
  url2.setQueryParameters({ key: apiKey });
  this._url = url2;
  this._params = defaultValue_default(params, {});
}
Object.defineProperties(OpenCageGeocoderService.prototype, {
  url: {
    get: function() {
      return this._url;
    }
  },
  params: {
    get: function() {
      return this._params;
    }
  }
});
OpenCageGeocoderService.prototype.geocode = function(query) {
  Check_default.typeOf.string("query", query);
  const resource = this._url.getDerivedResource({
    url: "json",
    queryParameters: combine_default(this._params, { q: query })
  });
  return resource.fetchJson().then(function(response) {
    return response.results.map(function(resultObject) {
      let destination;
      const bounds = resultObject.bounds;
      if (defined_default(bounds)) {
        destination = Rectangle_default.fromDegrees(
          bounds.southwest.lng,
          bounds.southwest.lat,
          bounds.northeast.lng,
          bounds.northeast.lat
        );
      } else {
        const lon = resultObject.geometry.lat;
        const lat = resultObject.geometry.lng;
        destination = Cartesian3_default.fromDegrees(lon, lat);
      }
      return {
        displayName: resultObject.formatted,
        destination
      };
    });
  });
};
var OpenCageGeocoderService_default = OpenCageGeocoderService;

// node_modules/cesium/Source/Core/Packable.js
var Packable = {
  packedLength: void 0,
  pack: DeveloperError_default.throwInstantiationError,
  unpack: DeveloperError_default.throwInstantiationError
};
var Packable_default = Packable;

// node_modules/cesium/Source/Core/PackableForInterpolation.js
var PackableForInterpolation = {
  packedInterpolationLength: void 0,
  convertPackedArrayForInterpolation: DeveloperError_default.throwInstantiationError,
  unpackInterpolationResult: DeveloperError_default.throwInstantiationError
};
var PackableForInterpolation_default = PackableForInterpolation;

// node_modules/cesium/Source/Core/writeTextToCanvas.js
function measureText(context2D, textString, font, stroke, fill) {
  const metrics = context2D.measureText(textString);
  const isSpace = !/\S/.test(textString);
  if (!isSpace) {
    const fontSize = document.defaultView.getComputedStyle(context2D.canvas).getPropertyValue("font-size").replace("px", "");
    const canvas = document.createElement("canvas");
    const padding = 100;
    const width = metrics.width + padding | 0;
    const height = 3 * fontSize;
    const baseline = height / 2;
    canvas.width = width;
    canvas.height = height;
    const ctx = canvas.getContext("2d");
    ctx.font = font;
    ctx.fillStyle = "white";
    ctx.fillRect(0, 0, canvas.width + 1, canvas.height + 1);
    if (stroke) {
      ctx.strokeStyle = "black";
      ctx.lineWidth = context2D.lineWidth;
      ctx.strokeText(textString, padding / 2, baseline);
    }
    if (fill) {
      ctx.fillStyle = "black";
      ctx.fillText(textString, padding / 2, baseline);
    }
    const pixelData = ctx.getImageData(0, 0, width, height).data;
    const length3 = pixelData.length;
    const width4 = width * 4;
    let i2, j;
    let ascent, descent;
    for (i2 = 0; i2 < length3; ++i2) {
      if (pixelData[i2] !== 255) {
        ascent = i2 / width4 | 0;
        break;
      }
    }
    for (i2 = length3 - 1; i2 >= 0; --i2) {
      if (pixelData[i2] !== 255) {
        descent = i2 / width4 | 0;
        break;
      }
    }
    let minx = -1;
    for (i2 = 0; i2 < width && minx === -1; ++i2) {
      for (j = 0; j < height; ++j) {
        const pixelIndex = i2 * 4 + j * width4;
        if (pixelData[pixelIndex] !== 255 || pixelData[pixelIndex + 1] !== 255 || pixelData[pixelIndex + 2] !== 255 || pixelData[pixelIndex + 3] !== 255) {
          minx = i2;
          break;
        }
      }
    }
    return {
      width: metrics.width,
      height: descent - ascent,
      ascent: baseline - ascent,
      descent: descent - baseline,
      minx: minx - padding / 2
    };
  }
  return {
    width: metrics.width,
    height: 0,
    ascent: 0,
    descent: 0,
    minx: 0
  };
}
var imageSmoothingEnabledName;
function writeTextToCanvas(text2, options) {
  if (!defined_default(text2)) {
    throw new DeveloperError_default("text is required.");
  }
  if (text2 === "") {
    return void 0;
  }
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const font = defaultValue_default(options.font, "10px sans-serif");
  const stroke = defaultValue_default(options.stroke, false);
  const fill = defaultValue_default(options.fill, true);
  const strokeWidth = defaultValue_default(options.strokeWidth, 1);
  const backgroundColor = defaultValue_default(
    options.backgroundColor,
    Color_default.TRANSPARENT
  );
  const padding = defaultValue_default(options.padding, 0);
  const doublePadding = padding * 2;
  const canvas = document.createElement("canvas");
  canvas.width = 1;
  canvas.height = 1;
  canvas.style.font = font;
  const context2D = canvas.getContext("2d");
  if (!defined_default(imageSmoothingEnabledName)) {
    if (defined_default(context2D.imageSmoothingEnabled)) {
      imageSmoothingEnabledName = "imageSmoothingEnabled";
    } else if (defined_default(context2D.mozImageSmoothingEnabled)) {
      imageSmoothingEnabledName = "mozImageSmoothingEnabled";
    } else if (defined_default(context2D.webkitImageSmoothingEnabled)) {
      imageSmoothingEnabledName = "webkitImageSmoothingEnabled";
    } else if (defined_default(context2D.msImageSmoothingEnabled)) {
      imageSmoothingEnabledName = "msImageSmoothingEnabled";
    }
  }
  context2D.font = font;
  context2D.lineJoin = "round";
  context2D.lineWidth = strokeWidth;
  context2D[imageSmoothingEnabledName] = false;
  canvas.style.visibility = "hidden";
  document.body.appendChild(canvas);
  const dimensions = measureText(context2D, text2, font, stroke, fill);
  canvas.dimensions = dimensions;
  document.body.removeChild(canvas);
  canvas.style.visibility = "";
  const x = -dimensions.minx;
  const width = Math.ceil(dimensions.width) + x + doublePadding;
  const height = dimensions.height + doublePadding;
  const baseline = height - dimensions.ascent + padding;
  const y = height - baseline + doublePadding;
  canvas.width = width;
  canvas.height = height;
  context2D.font = font;
  context2D.lineJoin = "round";
  context2D.lineWidth = strokeWidth;
  context2D[imageSmoothingEnabledName] = false;
  if (backgroundColor !== Color_default.TRANSPARENT) {
    context2D.fillStyle = backgroundColor.toCssColorString();
    context2D.fillRect(0, 0, canvas.width, canvas.height);
  }
  if (stroke) {
    const strokeColor = defaultValue_default(options.strokeColor, Color_default.BLACK);
    context2D.strokeStyle = strokeColor.toCssColorString();
    context2D.strokeText(text2, x + padding, y);
  }
  if (fill) {
    const fillColor = defaultValue_default(options.fillColor, Color_default.WHITE);
    context2D.fillStyle = fillColor.toCssColorString();
    context2D.fillText(text2, x + padding, y);
  }
  return canvas;
}
var writeTextToCanvas_default = writeTextToCanvas;

// node_modules/cesium/Source/Core/PinBuilder.js
function PinBuilder() {
  this._cache = {};
}
PinBuilder.prototype.fromColor = function(color, size) {
  if (!defined_default(color)) {
    throw new DeveloperError_default("color is required");
  }
  if (!defined_default(size)) {
    throw new DeveloperError_default("size is required");
  }
  return createPin(void 0, void 0, color, size, this._cache);
};
PinBuilder.prototype.fromUrl = function(url2, color, size) {
  if (!defined_default(url2)) {
    throw new DeveloperError_default("url is required");
  }
  if (!defined_default(color)) {
    throw new DeveloperError_default("color is required");
  }
  if (!defined_default(size)) {
    throw new DeveloperError_default("size is required");
  }
  return createPin(url2, void 0, color, size, this._cache);
};
PinBuilder.prototype.fromMakiIconId = function(id, color, size) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required");
  }
  if (!defined_default(color)) {
    throw new DeveloperError_default("color is required");
  }
  if (!defined_default(size)) {
    throw new DeveloperError_default("size is required");
  }
  return createPin(
    buildModuleUrl_default(`Assets/Textures/maki/${encodeURIComponent(id)}.png`),
    void 0,
    color,
    size,
    this._cache
  );
};
PinBuilder.prototype.fromText = function(text2, color, size) {
  if (!defined_default(text2)) {
    throw new DeveloperError_default("text is required");
  }
  if (!defined_default(color)) {
    throw new DeveloperError_default("color is required");
  }
  if (!defined_default(size)) {
    throw new DeveloperError_default("size is required");
  }
  return createPin(void 0, text2, color, size, this._cache);
};
var colorScratch = new Color_default();
function drawPin(context2D, color, size) {
  context2D.save();
  context2D.scale(size / 24, size / 24);
  context2D.fillStyle = color.toCssColorString();
  context2D.strokeStyle = color.brighten(0.6, colorScratch).toCssColorString();
  context2D.lineWidth = 0.846;
  context2D.beginPath();
  context2D.moveTo(6.72, 0.422);
  context2D.lineTo(17.28, 0.422);
  context2D.bezierCurveTo(18.553, 0.422, 19.577, 1.758, 19.577, 3.415);
  context2D.lineTo(19.577, 10.973);
  context2D.bezierCurveTo(19.577, 12.63, 18.553, 13.966, 17.282, 13.966);
  context2D.lineTo(14.386, 14.008);
  context2D.lineTo(11.826, 23.578);
  context2D.lineTo(9.614, 14.008);
  context2D.lineTo(6.719, 13.965);
  context2D.bezierCurveTo(5.446, 13.983, 4.422, 12.629, 4.422, 10.972);
  context2D.lineTo(4.422, 3.416);
  context2D.bezierCurveTo(4.423, 1.76, 5.447, 0.423, 6.718, 0.423);
  context2D.closePath();
  context2D.fill();
  context2D.stroke();
  context2D.restore();
}
function drawIcon(context2D, image, size) {
  const imageSize = size / 2.5;
  let sizeX = imageSize;
  let sizeY = imageSize;
  if (image.width > image.height) {
    sizeY = imageSize * (image.height / image.width);
  } else if (image.width < image.height) {
    sizeX = imageSize * (image.width / image.height);
  }
  const x = Math.round((size - sizeX) / 2);
  const y = Math.round(7 / 24 * size - sizeY / 2);
  context2D.globalCompositeOperation = "destination-out";
  context2D.drawImage(image, x - 1, y, sizeX, sizeY);
  context2D.drawImage(image, x, y - 1, sizeX, sizeY);
  context2D.drawImage(image, x + 1, y, sizeX, sizeY);
  context2D.drawImage(image, x, y + 1, sizeX, sizeY);
  context2D.globalCompositeOperation = "destination-over";
  context2D.fillStyle = Color_default.BLACK.toCssColorString();
  context2D.fillRect(x - 1, y - 1, sizeX + 2, sizeY + 2);
  context2D.globalCompositeOperation = "destination-out";
  context2D.drawImage(image, x, y, sizeX, sizeY);
  context2D.globalCompositeOperation = "destination-over";
  context2D.fillStyle = Color_default.WHITE.toCssColorString();
  context2D.fillRect(x - 1, y - 2, sizeX + 2, sizeY + 2);
}
var stringifyScratch = new Array(4);
function createPin(url2, label, color, size, cache) {
  stringifyScratch[0] = url2;
  stringifyScratch[1] = label;
  stringifyScratch[2] = color;
  stringifyScratch[3] = size;
  const id = JSON.stringify(stringifyScratch);
  const item = cache[id];
  if (defined_default(item)) {
    return item;
  }
  const canvas = document.createElement("canvas");
  canvas.width = size;
  canvas.height = size;
  const context2D = canvas.getContext("2d");
  drawPin(context2D, color, size);
  if (defined_default(url2)) {
    const resource = Resource_default.createIfNeeded(url2);
    const promise = resource.fetchImage().then(function(image) {
      drawIcon(context2D, image, size);
      cache[id] = canvas;
      return canvas;
    });
    cache[id] = promise;
    return promise;
  } else if (defined_default(label)) {
    const image = writeTextToCanvas_default(label, {
      font: `bold ${size}px sans-serif`
    });
    drawIcon(context2D, image, size);
  }
  cache[id] = canvas;
  return canvas;
}
var PinBuilder_default = PinBuilder;

// node_modules/cesium/Source/Renderer/PixelDatatype.js
var PixelDatatype = {
  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT,
  FLOAT: WebGLConstants_default.FLOAT,
  HALF_FLOAT: WebGLConstants_default.HALF_FLOAT_OES,
  UNSIGNED_INT_24_8: WebGLConstants_default.UNSIGNED_INT_24_8,
  UNSIGNED_SHORT_4_4_4_4: WebGLConstants_default.UNSIGNED_SHORT_4_4_4_4,
  UNSIGNED_SHORT_5_5_5_1: WebGLConstants_default.UNSIGNED_SHORT_5_5_5_1,
  UNSIGNED_SHORT_5_6_5: WebGLConstants_default.UNSIGNED_SHORT_5_6_5
};
PixelDatatype.toWebGLConstant = function(pixelDatatype, context) {
  switch (pixelDatatype) {
    case PixelDatatype.UNSIGNED_BYTE:
      return WebGLConstants_default.UNSIGNED_BYTE;
    case PixelDatatype.UNSIGNED_SHORT:
      return WebGLConstants_default.UNSIGNED_SHORT;
    case PixelDatatype.UNSIGNED_INT:
      return WebGLConstants_default.UNSIGNED_INT;
    case PixelDatatype.FLOAT:
      return WebGLConstants_default.FLOAT;
    case PixelDatatype.HALF_FLOAT:
      return context.webgl2 ? WebGLConstants_default.HALF_FLOAT : WebGLConstants_default.HALF_FLOAT_OES;
    case PixelDatatype.UNSIGNED_INT_24_8:
      return WebGLConstants_default.UNSIGNED_INT_24_8;
    case PixelDatatype.UNSIGNED_SHORT_4_4_4_4:
      return WebGLConstants_default.UNSIGNED_SHORT_4_4_4_4;
    case PixelDatatype.UNSIGNED_SHORT_5_5_5_1:
      return WebGLConstants_default.UNSIGNED_SHORT_5_5_5_1;
    case PixelDatatype.UNSIGNED_SHORT_5_6_5:
      return PixelDatatype.UNSIGNED_SHORT_5_6_5;
  }
};
PixelDatatype.isPacked = function(pixelDatatype) {
  return pixelDatatype === PixelDatatype.UNSIGNED_INT_24_8 || pixelDatatype === PixelDatatype.UNSIGNED_SHORT_4_4_4_4 || pixelDatatype === PixelDatatype.UNSIGNED_SHORT_5_5_5_1 || pixelDatatype === PixelDatatype.UNSIGNED_SHORT_5_6_5;
};
PixelDatatype.sizeInBytes = function(pixelDatatype) {
  switch (pixelDatatype) {
    case PixelDatatype.UNSIGNED_BYTE:
      return 1;
    case PixelDatatype.UNSIGNED_SHORT:
    case PixelDatatype.UNSIGNED_SHORT_4_4_4_4:
    case PixelDatatype.UNSIGNED_SHORT_5_5_5_1:
    case PixelDatatype.UNSIGNED_SHORT_5_6_5:
    case PixelDatatype.HALF_FLOAT:
      return 2;
    case PixelDatatype.UNSIGNED_INT:
    case PixelDatatype.FLOAT:
    case PixelDatatype.UNSIGNED_INT_24_8:
      return 4;
  }
};
PixelDatatype.validate = function(pixelDatatype) {
  return pixelDatatype === PixelDatatype.UNSIGNED_BYTE || pixelDatatype === PixelDatatype.UNSIGNED_SHORT || pixelDatatype === PixelDatatype.UNSIGNED_INT || pixelDatatype === PixelDatatype.FLOAT || pixelDatatype === PixelDatatype.HALF_FLOAT || pixelDatatype === PixelDatatype.UNSIGNED_INT_24_8 || pixelDatatype === PixelDatatype.UNSIGNED_SHORT_4_4_4_4 || pixelDatatype === PixelDatatype.UNSIGNED_SHORT_5_5_5_1 || pixelDatatype === PixelDatatype.UNSIGNED_SHORT_5_6_5;
};
var PixelDatatype_default = Object.freeze(PixelDatatype);

// node_modules/cesium/Source/Core/PixelFormat.js
var PixelFormat = {
  DEPTH_COMPONENT: WebGLConstants_default.DEPTH_COMPONENT,
  DEPTH_STENCIL: WebGLConstants_default.DEPTH_STENCIL,
  ALPHA: WebGLConstants_default.ALPHA,
  RGB: WebGLConstants_default.RGB,
  RGBA: WebGLConstants_default.RGBA,
  LUMINANCE: WebGLConstants_default.LUMINANCE,
  LUMINANCE_ALPHA: WebGLConstants_default.LUMINANCE_ALPHA,
  RGB_DXT1: WebGLConstants_default.COMPRESSED_RGB_S3TC_DXT1_EXT,
  RGBA_DXT1: WebGLConstants_default.COMPRESSED_RGBA_S3TC_DXT1_EXT,
  RGBA_DXT3: WebGLConstants_default.COMPRESSED_RGBA_S3TC_DXT3_EXT,
  RGBA_DXT5: WebGLConstants_default.COMPRESSED_RGBA_S3TC_DXT5_EXT,
  RGB_PVRTC_4BPPV1: WebGLConstants_default.COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
  RGB_PVRTC_2BPPV1: WebGLConstants_default.COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
  RGBA_PVRTC_4BPPV1: WebGLConstants_default.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
  RGBA_PVRTC_2BPPV1: WebGLConstants_default.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
  RGBA_ASTC: WebGLConstants_default.COMPRESSED_RGBA_ASTC_4x4_WEBGL,
  RGB_ETC1: WebGLConstants_default.COMPRESSED_RGB_ETC1_WEBGL,
  RGB8_ETC2: WebGLConstants_default.COMPRESSED_RGB8_ETC2,
  RGBA8_ETC2_EAC: WebGLConstants_default.COMPRESSED_RGBA8_ETC2_EAC,
  RGBA_BC7: WebGLConstants_default.COMPRESSED_RGBA_BPTC_UNORM
};
PixelFormat.componentsLength = function(pixelFormat) {
  switch (pixelFormat) {
    case PixelFormat.RGB:
      return 3;
    case PixelFormat.RGBA:
      return 4;
    case PixelFormat.LUMINANCE_ALPHA:
      return 2;
    case PixelFormat.ALPHA:
    case PixelFormat.LUMINANCE:
      return 1;
    default:
      return 1;
  }
};
PixelFormat.validate = function(pixelFormat) {
  return pixelFormat === PixelFormat.DEPTH_COMPONENT || pixelFormat === PixelFormat.DEPTH_STENCIL || pixelFormat === PixelFormat.ALPHA || pixelFormat === PixelFormat.RGB || pixelFormat === PixelFormat.RGBA || pixelFormat === PixelFormat.LUMINANCE || pixelFormat === PixelFormat.LUMINANCE_ALPHA || pixelFormat === PixelFormat.RGB_DXT1 || pixelFormat === PixelFormat.RGBA_DXT1 || pixelFormat === PixelFormat.RGBA_DXT3 || pixelFormat === PixelFormat.RGBA_DXT5 || pixelFormat === PixelFormat.RGB_PVRTC_4BPPV1 || pixelFormat === PixelFormat.RGB_PVRTC_2BPPV1 || pixelFormat === PixelFormat.RGBA_PVRTC_4BPPV1 || pixelFormat === PixelFormat.RGBA_PVRTC_2BPPV1 || pixelFormat === PixelFormat.RGBA_ASTC || pixelFormat === PixelFormat.RGB_ETC1 || pixelFormat === PixelFormat.RGB8_ETC2 || pixelFormat === PixelFormat.RGBA8_ETC2_EAC || pixelFormat === PixelFormat.RGBA_BC7;
};
PixelFormat.isColorFormat = function(pixelFormat) {
  return pixelFormat === PixelFormat.ALPHA || pixelFormat === PixelFormat.RGB || pixelFormat === PixelFormat.RGBA || pixelFormat === PixelFormat.LUMINANCE || pixelFormat === PixelFormat.LUMINANCE_ALPHA;
};
PixelFormat.isDepthFormat = function(pixelFormat) {
  return pixelFormat === PixelFormat.DEPTH_COMPONENT || pixelFormat === PixelFormat.DEPTH_STENCIL;
};
PixelFormat.isCompressedFormat = function(pixelFormat) {
  return pixelFormat === PixelFormat.RGB_DXT1 || pixelFormat === PixelFormat.RGBA_DXT1 || pixelFormat === PixelFormat.RGBA_DXT3 || pixelFormat === PixelFormat.RGBA_DXT5 || pixelFormat === PixelFormat.RGB_PVRTC_4BPPV1 || pixelFormat === PixelFormat.RGB_PVRTC_2BPPV1 || pixelFormat === PixelFormat.RGBA_PVRTC_4BPPV1 || pixelFormat === PixelFormat.RGBA_PVRTC_2BPPV1 || pixelFormat === PixelFormat.RGBA_ASTC || pixelFormat === PixelFormat.RGB_ETC1 || pixelFormat === PixelFormat.RGB8_ETC2 || pixelFormat === PixelFormat.RGBA8_ETC2_EAC || pixelFormat === PixelFormat.RGBA_BC7;
};
PixelFormat.isDXTFormat = function(pixelFormat) {
  return pixelFormat === PixelFormat.RGB_DXT1 || pixelFormat === PixelFormat.RGBA_DXT1 || pixelFormat === PixelFormat.RGBA_DXT3 || pixelFormat === PixelFormat.RGBA_DXT5;
};
PixelFormat.isPVRTCFormat = function(pixelFormat) {
  return pixelFormat === PixelFormat.RGB_PVRTC_4BPPV1 || pixelFormat === PixelFormat.RGB_PVRTC_2BPPV1 || pixelFormat === PixelFormat.RGBA_PVRTC_4BPPV1 || pixelFormat === PixelFormat.RGBA_PVRTC_2BPPV1;
};
PixelFormat.isASTCFormat = function(pixelFormat) {
  return pixelFormat === PixelFormat.RGBA_ASTC;
};
PixelFormat.isETC1Format = function(pixelFormat) {
  return pixelFormat === PixelFormat.RGB_ETC1;
};
PixelFormat.isETC2Format = function(pixelFormat) {
  return pixelFormat === PixelFormat.RGB8_ETC2 || pixelFormat === PixelFormat.RGBA8_ETC2_EAC;
};
PixelFormat.isBC7Format = function(pixelFormat) {
  return pixelFormat === PixelFormat.RGBA_BC7;
};
PixelFormat.compressedTextureSizeInBytes = function(pixelFormat, width, height) {
  switch (pixelFormat) {
    case PixelFormat.RGB_DXT1:
    case PixelFormat.RGBA_DXT1:
    case PixelFormat.RGB_ETC1:
    case PixelFormat.RGB8_ETC2:
      return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 8;
    case PixelFormat.RGBA_DXT3:
    case PixelFormat.RGBA_DXT5:
    case PixelFormat.RGBA_ASTC:
    case PixelFormat.RGBA8_ETC2_EAC:
      return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
    case PixelFormat.RGB_PVRTC_4BPPV1:
    case PixelFormat.RGBA_PVRTC_4BPPV1:
      return Math.floor((Math.max(width, 8) * Math.max(height, 8) * 4 + 7) / 8);
    case PixelFormat.RGB_PVRTC_2BPPV1:
    case PixelFormat.RGBA_PVRTC_2BPPV1:
      return Math.floor(
        (Math.max(width, 16) * Math.max(height, 8) * 2 + 7) / 8
      );
    case PixelFormat.RGBA_BC7:
      return Math.ceil(width / 4) * Math.ceil(height / 4) * 16;
    default:
      return 0;
  }
};
PixelFormat.textureSizeInBytes = function(pixelFormat, pixelDatatype, width, height) {
  let componentsLength = PixelFormat.componentsLength(pixelFormat);
  if (PixelDatatype_default.isPacked(pixelDatatype)) {
    componentsLength = 1;
  }
  return componentsLength * PixelDatatype_default.sizeInBytes(pixelDatatype) * width * height;
};
PixelFormat.alignmentInBytes = function(pixelFormat, pixelDatatype, width) {
  const mod2 = PixelFormat.textureSizeInBytes(pixelFormat, pixelDatatype, width, 1) % 4;
  return mod2 === 0 ? 4 : mod2 === 2 ? 2 : 1;
};
PixelFormat.createTypedArray = function(pixelFormat, pixelDatatype, width, height) {
  let constructor;
  const sizeInBytes = PixelDatatype_default.sizeInBytes(pixelDatatype);
  if (sizeInBytes === Uint8Array.BYTES_PER_ELEMENT) {
    constructor = Uint8Array;
  } else if (sizeInBytes === Uint16Array.BYTES_PER_ELEMENT) {
    constructor = Uint16Array;
  } else if (sizeInBytes === Float32Array.BYTES_PER_ELEMENT && pixelDatatype === PixelDatatype_default.FLOAT) {
    constructor = Float32Array;
  } else {
    constructor = Uint32Array;
  }
  const size = PixelFormat.componentsLength(pixelFormat) * width * height;
  return new constructor(size);
};
PixelFormat.flipY = function(bufferView, pixelFormat, pixelDatatype, width, height) {
  if (height === 1) {
    return bufferView;
  }
  const flipped = PixelFormat.createTypedArray(
    pixelFormat,
    pixelDatatype,
    width,
    height
  );
  const numberOfComponents = PixelFormat.componentsLength(pixelFormat);
  const textureWidth = width * numberOfComponents;
  for (let i2 = 0; i2 < height; ++i2) {
    const row = i2 * width * numberOfComponents;
    const flippedRow = (height - i2 - 1) * width * numberOfComponents;
    for (let j = 0; j < textureWidth; ++j) {
      flipped[flippedRow + j] = bufferView[row + j];
    }
  }
  return flipped;
};
PixelFormat.toInternalFormat = function(pixelFormat, pixelDatatype, context) {
  if (!context.webgl2) {
    return pixelFormat;
  }
  if (pixelFormat === PixelFormat.DEPTH_STENCIL) {
    return WebGLConstants_default.DEPTH24_STENCIL8;
  }
  if (pixelFormat === PixelFormat.DEPTH_COMPONENT) {
    if (pixelDatatype === PixelDatatype_default.UNSIGNED_SHORT) {
      return WebGLConstants_default.DEPTH_COMPONENT16;
    } else if (pixelDatatype === PixelDatatype_default.UNSIGNED_INT) {
      return WebGLConstants_default.DEPTH_COMPONENT24;
    }
  }
  if (pixelDatatype === PixelDatatype_default.FLOAT) {
    switch (pixelFormat) {
      case PixelFormat.RGBA:
        return WebGLConstants_default.RGBA32F;
      case PixelFormat.RGB:
        return WebGLConstants_default.RGB32F;
      case PixelFormat.RG:
        return WebGLConstants_default.RG32F;
      case PixelFormat.R:
        return WebGLConstants_default.R32F;
    }
  }
  if (pixelDatatype === PixelDatatype_default.HALF_FLOAT) {
    switch (pixelFormat) {
      case PixelFormat.RGBA:
        return WebGLConstants_default.RGBA16F;
      case PixelFormat.RGB:
        return WebGLConstants_default.RGB16F;
      case PixelFormat.RG:
        return WebGLConstants_default.RG16F;
      case PixelFormat.R:
        return WebGLConstants_default.R16F;
    }
  }
  return pixelFormat;
};
var PixelFormat_default = Object.freeze(PixelFormat);

// node_modules/cesium/Source/Core/PlaneGeometry.js
function PlaneGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
  this._vertexFormat = vertexFormat;
  this._workerName = "createPlaneGeometry";
}
PlaneGeometry.packedLength = VertexFormat_default.packedLength;
PlaneGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  return array;
};
var scratchVertexFormat8 = new VertexFormat_default();
var scratchOptions15 = {
  vertexFormat: scratchVertexFormat8
};
PlaneGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat8
  );
  if (!defined_default(result)) {
    return new PlaneGeometry(scratchOptions15);
  }
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  return result;
};
var min = new Cartesian3_default(-0.5, -0.5, 0);
var max = new Cartesian3_default(0.5, 0.5, 0);
PlaneGeometry.createGeometry = function(planeGeometry) {
  const vertexFormat = planeGeometry._vertexFormat;
  const attributes = new GeometryAttributes_default();
  let indices2;
  let positions;
  if (vertexFormat.position) {
    positions = new Float64Array(4 * 3);
    positions[0] = min.x;
    positions[1] = min.y;
    positions[2] = 0;
    positions[3] = max.x;
    positions[4] = min.y;
    positions[5] = 0;
    positions[6] = max.x;
    positions[7] = max.y;
    positions[8] = 0;
    positions[9] = min.x;
    positions[10] = max.y;
    positions[11] = 0;
    attributes.position = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: positions
    });
    if (vertexFormat.normal) {
      const normals = new Float32Array(4 * 3);
      normals[0] = 0;
      normals[1] = 0;
      normals[2] = 1;
      normals[3] = 0;
      normals[4] = 0;
      normals[5] = 1;
      normals[6] = 0;
      normals[7] = 0;
      normals[8] = 1;
      normals[9] = 0;
      normals[10] = 0;
      normals[11] = 1;
      attributes.normal = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: normals
      });
    }
    if (vertexFormat.st) {
      const texCoords = new Float32Array(4 * 2);
      texCoords[0] = 0;
      texCoords[1] = 0;
      texCoords[2] = 1;
      texCoords[3] = 0;
      texCoords[4] = 1;
      texCoords[5] = 1;
      texCoords[6] = 0;
      texCoords[7] = 1;
      attributes.st = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 2,
        values: texCoords
      });
    }
    if (vertexFormat.tangent) {
      const tangents = new Float32Array(4 * 3);
      tangents[0] = 1;
      tangents[1] = 0;
      tangents[2] = 0;
      tangents[3] = 1;
      tangents[4] = 0;
      tangents[5] = 0;
      tangents[6] = 1;
      tangents[7] = 0;
      tangents[8] = 0;
      tangents[9] = 1;
      tangents[10] = 0;
      tangents[11] = 0;
      attributes.tangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: tangents
      });
    }
    if (vertexFormat.bitangent) {
      const bitangents = new Float32Array(4 * 3);
      bitangents[0] = 0;
      bitangents[1] = 1;
      bitangents[2] = 0;
      bitangents[3] = 0;
      bitangents[4] = 1;
      bitangents[5] = 0;
      bitangents[6] = 0;
      bitangents[7] = 1;
      bitangents[8] = 0;
      bitangents[9] = 0;
      bitangents[10] = 1;
      bitangents[11] = 0;
      attributes.bitangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: bitangents
      });
    }
    indices2 = new Uint16Array(2 * 3);
    indices2[0] = 0;
    indices2[1] = 1;
    indices2[2] = 2;
    indices2[3] = 0;
    indices2[4] = 2;
    indices2[5] = 3;
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingSphere: new BoundingSphere_default(Cartesian3_default.ZERO, Math.sqrt(2))
  });
};
var PlaneGeometry_default = PlaneGeometry;

// node_modules/cesium/Source/Core/PlaneOutlineGeometry.js
function PlaneOutlineGeometry() {
  this._workerName = "createPlaneOutlineGeometry";
}
PlaneOutlineGeometry.packedLength = 0;
PlaneOutlineGeometry.pack = function(value, array) {
  Check_default.defined("value", value);
  Check_default.defined("array", array);
  return array;
};
PlaneOutlineGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  if (!defined_default(result)) {
    return new PlaneOutlineGeometry();
  }
  return result;
};
var min2 = new Cartesian3_default(-0.5, -0.5, 0);
var max2 = new Cartesian3_default(0.5, 0.5, 0);
PlaneOutlineGeometry.createGeometry = function() {
  const attributes = new GeometryAttributes_default();
  const indices2 = new Uint16Array(4 * 2);
  const positions = new Float64Array(4 * 3);
  positions[0] = min2.x;
  positions[1] = min2.y;
  positions[2] = min2.z;
  positions[3] = max2.x;
  positions[4] = min2.y;
  positions[5] = min2.z;
  positions[6] = max2.x;
  positions[7] = max2.y;
  positions[8] = min2.z;
  positions[9] = min2.x;
  positions[10] = max2.y;
  positions[11] = min2.z;
  attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: positions
  });
  indices2[0] = 0;
  indices2[1] = 1;
  indices2[2] = 1;
  indices2[3] = 2;
  indices2[4] = 2;
  indices2[5] = 3;
  indices2[6] = 3;
  indices2[7] = 0;
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere: new BoundingSphere_default(Cartesian3_default.ZERO, Math.sqrt(2))
  });
};
var PlaneOutlineGeometry_default = PlaneOutlineGeometry;

// node_modules/cesium/Source/Core/PolygonGeometry.js
var scratchCarto1 = new Cartographic_default();
var scratchCarto2 = new Cartographic_default();
function adjustPosHeightsForNormal(position, p1, p2, ellipsoid) {
  const carto12 = ellipsoid.cartesianToCartographic(position, scratchCarto1);
  const height = carto12.height;
  const p1Carto = ellipsoid.cartesianToCartographic(p1, scratchCarto2);
  p1Carto.height = height;
  ellipsoid.cartographicToCartesian(p1Carto, p1);
  const p2Carto = ellipsoid.cartesianToCartographic(p2, scratchCarto2);
  p2Carto.height = height - 100;
  ellipsoid.cartographicToCartesian(p2Carto, p2);
}
var scratchBoundingRectangle = new BoundingRectangle_default();
var scratchPosition4 = new Cartesian3_default();
var scratchNormal6 = new Cartesian3_default();
var scratchTangent4 = new Cartesian3_default();
var scratchBitangent4 = new Cartesian3_default();
var p1Scratch3 = new Cartesian3_default();
var p2Scratch3 = new Cartesian3_default();
var scratchPerPosNormal = new Cartesian3_default();
var scratchPerPosTangent = new Cartesian3_default();
var scratchPerPosBitangent = new Cartesian3_default();
var appendTextureCoordinatesOrigin = new Cartesian2_default();
var appendTextureCoordinatesCartesian2 = new Cartesian2_default();
var appendTextureCoordinatesCartesian3 = new Cartesian3_default();
var appendTextureCoordinatesQuaternion = new Quaternion_default();
var appendTextureCoordinatesMatrix3 = new Matrix3_default();
var tangentMatrixScratch2 = new Matrix3_default();
function computeAttributes(options) {
  const vertexFormat = options.vertexFormat;
  const geometry = options.geometry;
  const shadowVolume = options.shadowVolume;
  const flatPositions2 = geometry.attributes.position.values;
  let length3 = flatPositions2.length;
  const wall = options.wall;
  const top = options.top || wall;
  const bottom = options.bottom || wall;
  if (vertexFormat.st || vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent || shadowVolume) {
    const boundingRectangle = options.boundingRectangle;
    const tangentPlane = options.tangentPlane;
    const ellipsoid = options.ellipsoid;
    const stRotation = options.stRotation;
    const perPositionHeight = options.perPositionHeight;
    const origin = appendTextureCoordinatesOrigin;
    origin.x = boundingRectangle.x;
    origin.y = boundingRectangle.y;
    const textureCoordinates = vertexFormat.st ? new Float32Array(2 * (length3 / 3)) : void 0;
    let normals;
    if (vertexFormat.normal) {
      if (perPositionHeight && top && !wall) {
        normals = geometry.attributes.normal.values;
      } else {
        normals = new Float32Array(length3);
      }
    }
    const tangents = vertexFormat.tangent ? new Float32Array(length3) : void 0;
    const bitangents = vertexFormat.bitangent ? new Float32Array(length3) : void 0;
    const extrudeNormals = shadowVolume ? new Float32Array(length3) : void 0;
    let textureCoordIndex = 0;
    let attrIndex = 0;
    let normal2 = scratchNormal6;
    let tangent = scratchTangent4;
    let bitangent = scratchBitangent4;
    let recomputeNormal = true;
    let textureMatrix = appendTextureCoordinatesMatrix3;
    let tangentRotationMatrix = tangentMatrixScratch2;
    if (stRotation !== 0) {
      let rotation = Quaternion_default.fromAxisAngle(
        tangentPlane._plane.normal,
        stRotation,
        appendTextureCoordinatesQuaternion
      );
      textureMatrix = Matrix3_default.fromQuaternion(rotation, textureMatrix);
      rotation = Quaternion_default.fromAxisAngle(
        tangentPlane._plane.normal,
        -stRotation,
        appendTextureCoordinatesQuaternion
      );
      tangentRotationMatrix = Matrix3_default.fromQuaternion(
        rotation,
        tangentRotationMatrix
      );
    } else {
      textureMatrix = Matrix3_default.clone(Matrix3_default.IDENTITY, textureMatrix);
      tangentRotationMatrix = Matrix3_default.clone(
        Matrix3_default.IDENTITY,
        tangentRotationMatrix
      );
    }
    let bottomOffset = 0;
    let bottomOffset2 = 0;
    if (top && bottom) {
      bottomOffset = length3 / 2;
      bottomOffset2 = length3 / 3;
      length3 /= 2;
    }
    for (let i2 = 0; i2 < length3; i2 += 3) {
      const position = Cartesian3_default.fromArray(
        flatPositions2,
        i2,
        appendTextureCoordinatesCartesian3
      );
      if (vertexFormat.st) {
        let p2 = Matrix3_default.multiplyByVector(
          textureMatrix,
          position,
          scratchPosition4
        );
        p2 = ellipsoid.scaleToGeodeticSurface(p2, p2);
        const st = tangentPlane.projectPointOntoPlane(
          p2,
          appendTextureCoordinatesCartesian2
        );
        Cartesian2_default.subtract(st, origin, st);
        const stx = Math_default.clamp(st.x / boundingRectangle.width, 0, 1);
        const sty = Math_default.clamp(st.y / boundingRectangle.height, 0, 1);
        if (bottom) {
          textureCoordinates[textureCoordIndex + bottomOffset2] = stx;
          textureCoordinates[textureCoordIndex + 1 + bottomOffset2] = sty;
        }
        if (top) {
          textureCoordinates[textureCoordIndex] = stx;
          textureCoordinates[textureCoordIndex + 1] = sty;
        }
        textureCoordIndex += 2;
      }
      if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent || shadowVolume) {
        const attrIndex1 = attrIndex + 1;
        const attrIndex2 = attrIndex + 2;
        if (wall) {
          if (i2 + 3 < length3) {
            const p1 = Cartesian3_default.fromArray(flatPositions2, i2 + 3, p1Scratch3);
            if (recomputeNormal) {
              const p2 = Cartesian3_default.fromArray(
                flatPositions2,
                i2 + length3,
                p2Scratch3
              );
              if (perPositionHeight) {
                adjustPosHeightsForNormal(position, p1, p2, ellipsoid);
              }
              Cartesian3_default.subtract(p1, position, p1);
              Cartesian3_default.subtract(p2, position, p2);
              normal2 = Cartesian3_default.normalize(
                Cartesian3_default.cross(p2, p1, normal2),
                normal2
              );
              recomputeNormal = false;
            }
            if (Cartesian3_default.equalsEpsilon(p1, position, Math_default.EPSILON10)) {
              recomputeNormal = true;
            }
          }
          if (vertexFormat.tangent || vertexFormat.bitangent) {
            bitangent = ellipsoid.geodeticSurfaceNormal(position, bitangent);
            if (vertexFormat.tangent) {
              tangent = Cartesian3_default.normalize(
                Cartesian3_default.cross(bitangent, normal2, tangent),
                tangent
              );
            }
          }
        } else {
          normal2 = ellipsoid.geodeticSurfaceNormal(position, normal2);
          if (vertexFormat.tangent || vertexFormat.bitangent) {
            if (perPositionHeight) {
              scratchPerPosNormal = Cartesian3_default.fromArray(
                normals,
                attrIndex,
                scratchPerPosNormal
              );
              scratchPerPosTangent = Cartesian3_default.cross(
                Cartesian3_default.UNIT_Z,
                scratchPerPosNormal,
                scratchPerPosTangent
              );
              scratchPerPosTangent = Cartesian3_default.normalize(
                Matrix3_default.multiplyByVector(
                  tangentRotationMatrix,
                  scratchPerPosTangent,
                  scratchPerPosTangent
                ),
                scratchPerPosTangent
              );
              if (vertexFormat.bitangent) {
                scratchPerPosBitangent = Cartesian3_default.normalize(
                  Cartesian3_default.cross(
                    scratchPerPosNormal,
                    scratchPerPosTangent,
                    scratchPerPosBitangent
                  ),
                  scratchPerPosBitangent
                );
              }
            }
            tangent = Cartesian3_default.cross(Cartesian3_default.UNIT_Z, normal2, tangent);
            tangent = Cartesian3_default.normalize(
              Matrix3_default.multiplyByVector(tangentRotationMatrix, tangent, tangent),
              tangent
            );
            if (vertexFormat.bitangent) {
              bitangent = Cartesian3_default.normalize(
                Cartesian3_default.cross(normal2, tangent, bitangent),
                bitangent
              );
            }
          }
        }
        if (vertexFormat.normal) {
          if (options.wall) {
            normals[attrIndex + bottomOffset] = normal2.x;
            normals[attrIndex1 + bottomOffset] = normal2.y;
            normals[attrIndex2 + bottomOffset] = normal2.z;
          } else if (bottom) {
            normals[attrIndex + bottomOffset] = -normal2.x;
            normals[attrIndex1 + bottomOffset] = -normal2.y;
            normals[attrIndex2 + bottomOffset] = -normal2.z;
          }
          if (top && !perPositionHeight || wall) {
            normals[attrIndex] = normal2.x;
            normals[attrIndex1] = normal2.y;
            normals[attrIndex2] = normal2.z;
          }
        }
        if (shadowVolume) {
          if (wall) {
            normal2 = ellipsoid.geodeticSurfaceNormal(position, normal2);
          }
          extrudeNormals[attrIndex + bottomOffset] = -normal2.x;
          extrudeNormals[attrIndex1 + bottomOffset] = -normal2.y;
          extrudeNormals[attrIndex2 + bottomOffset] = -normal2.z;
        }
        if (vertexFormat.tangent) {
          if (options.wall) {
            tangents[attrIndex + bottomOffset] = tangent.x;
            tangents[attrIndex1 + bottomOffset] = tangent.y;
            tangents[attrIndex2 + bottomOffset] = tangent.z;
          } else if (bottom) {
            tangents[attrIndex + bottomOffset] = -tangent.x;
            tangents[attrIndex1 + bottomOffset] = -tangent.y;
            tangents[attrIndex2 + bottomOffset] = -tangent.z;
          }
          if (top) {
            if (perPositionHeight) {
              tangents[attrIndex] = scratchPerPosTangent.x;
              tangents[attrIndex1] = scratchPerPosTangent.y;
              tangents[attrIndex2] = scratchPerPosTangent.z;
            } else {
              tangents[attrIndex] = tangent.x;
              tangents[attrIndex1] = tangent.y;
              tangents[attrIndex2] = tangent.z;
            }
          }
        }
        if (vertexFormat.bitangent) {
          if (bottom) {
            bitangents[attrIndex + bottomOffset] = bitangent.x;
            bitangents[attrIndex1 + bottomOffset] = bitangent.y;
            bitangents[attrIndex2 + bottomOffset] = bitangent.z;
          }
          if (top) {
            if (perPositionHeight) {
              bitangents[attrIndex] = scratchPerPosBitangent.x;
              bitangents[attrIndex1] = scratchPerPosBitangent.y;
              bitangents[attrIndex2] = scratchPerPosBitangent.z;
            } else {
              bitangents[attrIndex] = bitangent.x;
              bitangents[attrIndex1] = bitangent.y;
              bitangents[attrIndex2] = bitangent.z;
            }
          }
        }
        attrIndex += 3;
      }
    }
    if (vertexFormat.st) {
      geometry.attributes.st = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 2,
        values: textureCoordinates
      });
    }
    if (vertexFormat.normal) {
      geometry.attributes.normal = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: normals
      });
    }
    if (vertexFormat.tangent) {
      geometry.attributes.tangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: tangents
      });
    }
    if (vertexFormat.bitangent) {
      geometry.attributes.bitangent = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: bitangents
      });
    }
    if (shadowVolume) {
      geometry.attributes.extrudeDirection = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3,
        values: extrudeNormals
      });
    }
  }
  if (options.extrude && defined_default(options.offsetAttribute)) {
    const size = flatPositions2.length / 3;
    let offsetAttribute = new Uint8Array(size);
    if (options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
      if (top && bottom || wall) {
        offsetAttribute = arrayFill_default(offsetAttribute, 1, 0, size / 2);
      } else if (top) {
        offsetAttribute = arrayFill_default(offsetAttribute, 1);
      }
    } else {
      const offsetValue = options.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      offsetAttribute = arrayFill_default(offsetAttribute, offsetValue);
    }
    geometry.attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: offsetAttribute
    });
  }
  return geometry;
}
var startCartographicScratch2 = new Cartographic_default();
var endCartographicScratch2 = new Cartographic_default();
var idlCross = {
  westOverIDL: 0,
  eastOverIDL: 0
};
var ellipsoidGeodesic2 = new EllipsoidGeodesic_default();
function computeRectangle3(positions, ellipsoid, arcType, granularity, result) {
  result = defaultValue_default(result, new Rectangle_default());
  if (!defined_default(positions) || positions.length < 3) {
    result.west = 0;
    result.north = 0;
    result.south = 0;
    result.east = 0;
    return result;
  }
  if (arcType === ArcType_default.RHUMB) {
    return Rectangle_default.fromCartesianArray(positions, ellipsoid, result);
  }
  if (!ellipsoidGeodesic2.ellipsoid.equals(ellipsoid)) {
    ellipsoidGeodesic2 = new EllipsoidGeodesic_default(void 0, void 0, ellipsoid);
  }
  result.west = Number.POSITIVE_INFINITY;
  result.east = Number.NEGATIVE_INFINITY;
  result.south = Number.POSITIVE_INFINITY;
  result.north = Number.NEGATIVE_INFINITY;
  idlCross.westOverIDL = Number.POSITIVE_INFINITY;
  idlCross.eastOverIDL = Number.NEGATIVE_INFINITY;
  const inverseChordLength = 1 / Math_default.chordLength(granularity, ellipsoid.maximumRadius);
  const positionsLength = positions.length;
  let endCartographic = ellipsoid.cartesianToCartographic(
    positions[0],
    endCartographicScratch2
  );
  let startCartographic = startCartographicScratch2;
  let swap5;
  for (let i2 = 1; i2 < positionsLength; i2++) {
    swap5 = startCartographic;
    startCartographic = endCartographic;
    endCartographic = ellipsoid.cartesianToCartographic(positions[i2], swap5);
    ellipsoidGeodesic2.setEndPoints(startCartographic, endCartographic);
    interpolateAndGrowRectangle(
      ellipsoidGeodesic2,
      inverseChordLength,
      result,
      idlCross
    );
  }
  swap5 = startCartographic;
  startCartographic = endCartographic;
  endCartographic = ellipsoid.cartesianToCartographic(positions[0], swap5);
  ellipsoidGeodesic2.setEndPoints(startCartographic, endCartographic);
  interpolateAndGrowRectangle(
    ellipsoidGeodesic2,
    inverseChordLength,
    result,
    idlCross
  );
  if (result.east - result.west > idlCross.eastOverIDL - idlCross.westOverIDL) {
    result.west = idlCross.westOverIDL;
    result.east = idlCross.eastOverIDL;
    if (result.east > Math_default.PI) {
      result.east = result.east - Math_default.TWO_PI;
    }
    if (result.west > Math_default.PI) {
      result.west = result.west - Math_default.TWO_PI;
    }
  }
  return result;
}
var interpolatedCartographicScratch2 = new Cartographic_default();
function interpolateAndGrowRectangle(ellipsoidGeodesic3, inverseChordLength, result, idlCross2) {
  const segmentLength = ellipsoidGeodesic3.surfaceDistance;
  const numPoints = Math.ceil(segmentLength * inverseChordLength);
  const subsegmentDistance = numPoints > 0 ? segmentLength / (numPoints - 1) : Number.POSITIVE_INFINITY;
  let interpolationDistance = 0;
  for (let i2 = 0; i2 < numPoints; i2++) {
    const interpolatedCartographic = ellipsoidGeodesic3.interpolateUsingSurfaceDistance(
      interpolationDistance,
      interpolatedCartographicScratch2
    );
    interpolationDistance += subsegmentDistance;
    const longitude = interpolatedCartographic.longitude;
    const latitude = interpolatedCartographic.latitude;
    result.west = Math.min(result.west, longitude);
    result.east = Math.max(result.east, longitude);
    result.south = Math.min(result.south, latitude);
    result.north = Math.max(result.north, latitude);
    const lonAdjusted = longitude >= 0 ? longitude : longitude + Math_default.TWO_PI;
    idlCross2.westOverIDL = Math.min(idlCross2.westOverIDL, lonAdjusted);
    idlCross2.eastOverIDL = Math.max(idlCross2.eastOverIDL, lonAdjusted);
  }
}
var createGeometryFromPositionsExtrudedPositions = [];
function createGeometryFromPositionsExtruded(ellipsoid, polygon, granularity, hierarchy, perPositionHeight, closeTop, closeBottom, vertexFormat, arcType) {
  const geos = {
    walls: []
  };
  let i2;
  if (closeTop || closeBottom) {
    const topGeo = PolygonGeometryLibrary_default.createGeometryFromPositions(
      ellipsoid,
      polygon,
      granularity,
      perPositionHeight,
      vertexFormat,
      arcType
    );
    const edgePoints = topGeo.attributes.position.values;
    const indices2 = topGeo.indices;
    let numPositions;
    let newIndices;
    if (closeTop && closeBottom) {
      const topBottomPositions = edgePoints.concat(edgePoints);
      numPositions = topBottomPositions.length / 3;
      newIndices = IndexDatatype_default.createTypedArray(
        numPositions,
        indices2.length * 2
      );
      newIndices.set(indices2);
      const ilength = indices2.length;
      const length3 = numPositions / 2;
      for (i2 = 0; i2 < ilength; i2 += 3) {
        const i0 = newIndices[i2] + length3;
        const i1 = newIndices[i2 + 1] + length3;
        const i22 = newIndices[i2 + 2] + length3;
        newIndices[i2 + ilength] = i22;
        newIndices[i2 + 1 + ilength] = i1;
        newIndices[i2 + 2 + ilength] = i0;
      }
      topGeo.attributes.position.values = topBottomPositions;
      if (perPositionHeight && vertexFormat.normal) {
        const normals = topGeo.attributes.normal.values;
        topGeo.attributes.normal.values = new Float32Array(
          topBottomPositions.length
        );
        topGeo.attributes.normal.values.set(normals);
      }
      topGeo.indices = newIndices;
    } else if (closeBottom) {
      numPositions = edgePoints.length / 3;
      newIndices = IndexDatatype_default.createTypedArray(numPositions, indices2.length);
      for (i2 = 0; i2 < indices2.length; i2 += 3) {
        newIndices[i2] = indices2[i2 + 2];
        newIndices[i2 + 1] = indices2[i2 + 1];
        newIndices[i2 + 2] = indices2[i2];
      }
      topGeo.indices = newIndices;
    }
    geos.topAndBottom = new GeometryInstance_default({
      geometry: topGeo
    });
  }
  let outerRing = hierarchy.outerRing;
  let tangentPlane = EllipsoidTangentPlane_default.fromPoints(outerRing, ellipsoid);
  let positions2D = tangentPlane.projectPointsOntoPlane(
    outerRing,
    createGeometryFromPositionsExtrudedPositions
  );
  let windingOrder = PolygonPipeline_default.computeWindingOrder2D(positions2D);
  if (windingOrder === WindingOrder_default.CLOCKWISE) {
    outerRing = outerRing.slice().reverse();
  }
  let wallGeo = PolygonGeometryLibrary_default.computeWallGeometry(
    outerRing,
    ellipsoid,
    granularity,
    perPositionHeight,
    arcType
  );
  geos.walls.push(
    new GeometryInstance_default({
      geometry: wallGeo
    })
  );
  const holes = hierarchy.holes;
  for (i2 = 0; i2 < holes.length; i2++) {
    let hole = holes[i2];
    tangentPlane = EllipsoidTangentPlane_default.fromPoints(hole, ellipsoid);
    positions2D = tangentPlane.projectPointsOntoPlane(
      hole,
      createGeometryFromPositionsExtrudedPositions
    );
    windingOrder = PolygonPipeline_default.computeWindingOrder2D(positions2D);
    if (windingOrder === WindingOrder_default.COUNTER_CLOCKWISE) {
      hole = hole.slice().reverse();
    }
    wallGeo = PolygonGeometryLibrary_default.computeWallGeometry(
      hole,
      ellipsoid,
      granularity,
      perPositionHeight,
      arcType
    );
    geos.walls.push(
      new GeometryInstance_default({
        geometry: wallGeo
      })
    );
  }
  return geos;
}
function PolygonGeometry(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
  if (defined_default(options.perPositionHeight) && options.perPositionHeight && defined_default(options.height)) {
    throw new DeveloperError_default(
      "Cannot use both options.perPositionHeight and options.height"
    );
  }
  if (defined_default(options.arcType) && options.arcType !== ArcType_default.GEODESIC && options.arcType !== ArcType_default.RHUMB) {
    throw new DeveloperError_default(
      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
    );
  }
  const polygonHierarchy = options.polygonHierarchy;
  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  const stRotation = defaultValue_default(options.stRotation, 0);
  const perPositionHeight = defaultValue_default(options.perPositionHeight, false);
  const perPositionHeightExtrude = perPositionHeight && defined_default(options.extrudedHeight);
  let height = defaultValue_default(options.height, 0);
  let extrudedHeight = defaultValue_default(options.extrudedHeight, height);
  if (!perPositionHeightExtrude) {
    const h = Math.max(height, extrudedHeight);
    extrudedHeight = Math.min(height, extrudedHeight);
    height = h;
  }
  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
  this._granularity = granularity;
  this._stRotation = stRotation;
  this._height = height;
  this._extrudedHeight = extrudedHeight;
  this._closeTop = defaultValue_default(options.closeTop, true);
  this._closeBottom = defaultValue_default(options.closeBottom, true);
  this._polygonHierarchy = polygonHierarchy;
  this._perPositionHeight = perPositionHeight;
  this._perPositionHeightExtrude = perPositionHeightExtrude;
  this._shadowVolume = defaultValue_default(options.shadowVolume, false);
  this._workerName = "createPolygonGeometry";
  this._offsetAttribute = options.offsetAttribute;
  this._arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
  this._rectangle = void 0;
  this._textureCoordinateRotationPoints = void 0;
  this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(polygonHierarchy) + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 12;
}
PolygonGeometry.fromPositions = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.positions", options.positions);
  const newOptions2 = {
    polygonHierarchy: {
      positions: options.positions
    },
    height: options.height,
    extrudedHeight: options.extrudedHeight,
    vertexFormat: options.vertexFormat,
    stRotation: options.stRotation,
    ellipsoid: options.ellipsoid,
    granularity: options.granularity,
    perPositionHeight: options.perPositionHeight,
    closeTop: options.closeTop,
    closeBottom: options.closeBottom,
    offsetAttribute: options.offsetAttribute,
    arcType: options.arcType
  };
  return new PolygonGeometry(newOptions2);
};
PolygonGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
    value._polygonHierarchy,
    array,
    startingIndex
  );
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex++] = value._height;
  array[startingIndex++] = value._extrudedHeight;
  array[startingIndex++] = value._granularity;
  array[startingIndex++] = value._stRotation;
  array[startingIndex++] = value._perPositionHeightExtrude ? 1 : 0;
  array[startingIndex++] = value._perPositionHeight ? 1 : 0;
  array[startingIndex++] = value._closeTop ? 1 : 0;
  array[startingIndex++] = value._closeBottom ? 1 : 0;
  array[startingIndex++] = value._shadowVolume ? 1 : 0;
  array[startingIndex++] = defaultValue_default(value._offsetAttribute, -1);
  array[startingIndex++] = value._arcType;
  array[startingIndex] = value.packedLength;
  return array;
};
var scratchEllipsoid6 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchVertexFormat9 = new VertexFormat_default();
var dummyOptions = {
  polygonHierarchy: {}
};
PolygonGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
    array,
    startingIndex
  );
  startingIndex = polygonHierarchy.startingIndex;
  delete polygonHierarchy.startingIndex;
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid6);
  startingIndex += Ellipsoid_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat9
  );
  startingIndex += VertexFormat_default.packedLength;
  const height = array[startingIndex++];
  const extrudedHeight = array[startingIndex++];
  const granularity = array[startingIndex++];
  const stRotation = array[startingIndex++];
  const perPositionHeightExtrude = array[startingIndex++] === 1;
  const perPositionHeight = array[startingIndex++] === 1;
  const closeTop = array[startingIndex++] === 1;
  const closeBottom = array[startingIndex++] === 1;
  const shadowVolume = array[startingIndex++] === 1;
  const offsetAttribute = array[startingIndex++];
  const arcType = array[startingIndex++];
  const packedLength = array[startingIndex];
  if (!defined_default(result)) {
    result = new PolygonGeometry(dummyOptions);
  }
  result._polygonHierarchy = polygonHierarchy;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._height = height;
  result._extrudedHeight = extrudedHeight;
  result._granularity = granularity;
  result._stRotation = stRotation;
  result._perPositionHeightExtrude = perPositionHeightExtrude;
  result._perPositionHeight = perPositionHeight;
  result._closeTop = closeTop;
  result._closeBottom = closeBottom;
  result._shadowVolume = shadowVolume;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  result._arcType = arcType;
  result.packedLength = packedLength;
  return result;
};
PolygonGeometry.computeRectangle = function(options, result) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  const arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
  if (arcType !== ArcType_default.GEODESIC && arcType !== ArcType_default.RHUMB) {
    throw new DeveloperError_default(
      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
    );
  }
  const polygonHierarchy = options.polygonHierarchy;
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  return computeRectangle3(
    polygonHierarchy.positions,
    ellipsoid,
    arcType,
    granularity,
    result
  );
};
PolygonGeometry.createGeometry = function(polygonGeometry) {
  const vertexFormat = polygonGeometry._vertexFormat;
  const ellipsoid = polygonGeometry._ellipsoid;
  const granularity = polygonGeometry._granularity;
  const stRotation = polygonGeometry._stRotation;
  const polygonHierarchy = polygonGeometry._polygonHierarchy;
  const perPositionHeight = polygonGeometry._perPositionHeight;
  const closeTop = polygonGeometry._closeTop;
  const closeBottom = polygonGeometry._closeBottom;
  const arcType = polygonGeometry._arcType;
  let outerPositions = polygonHierarchy.positions;
  if (outerPositions.length < 3) {
    return;
  }
  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(
    outerPositions,
    ellipsoid
  );
  const results = PolygonGeometryLibrary_default.polygonsFromHierarchy(
    polygonHierarchy,
    tangentPlane.projectPointsOntoPlane.bind(tangentPlane),
    !perPositionHeight,
    ellipsoid
  );
  const hierarchy = results.hierarchy;
  const polygons = results.polygons;
  if (hierarchy.length === 0) {
    return;
  }
  outerPositions = hierarchy[0].outerRing;
  const boundingRectangle = PolygonGeometryLibrary_default.computeBoundingRectangle(
    tangentPlane.plane.normal,
    tangentPlane.projectPointOntoPlane.bind(tangentPlane),
    outerPositions,
    stRotation,
    scratchBoundingRectangle
  );
  const geometries = [];
  const height = polygonGeometry._height;
  const extrudedHeight = polygonGeometry._extrudedHeight;
  const extrude = polygonGeometry._perPositionHeightExtrude || !Math_default.equalsEpsilon(height, extrudedHeight, 0, Math_default.EPSILON2);
  const options = {
    perPositionHeight,
    vertexFormat,
    geometry: void 0,
    tangentPlane,
    boundingRectangle,
    ellipsoid,
    stRotation,
    bottom: false,
    top: true,
    wall: false,
    extrude: false,
    arcType
  };
  let i2;
  if (extrude) {
    options.extrude = true;
    options.top = closeTop;
    options.bottom = closeBottom;
    options.shadowVolume = polygonGeometry._shadowVolume;
    options.offsetAttribute = polygonGeometry._offsetAttribute;
    for (i2 = 0; i2 < polygons.length; i2++) {
      const splitGeometry = createGeometryFromPositionsExtruded(
        ellipsoid,
        polygons[i2],
        granularity,
        hierarchy[i2],
        perPositionHeight,
        closeTop,
        closeBottom,
        vertexFormat,
        arcType
      );
      let topAndBottom;
      if (closeTop && closeBottom) {
        topAndBottom = splitGeometry.topAndBottom;
        options.geometry = PolygonGeometryLibrary_default.scaleToGeodeticHeightExtruded(
          topAndBottom.geometry,
          height,
          extrudedHeight,
          ellipsoid,
          perPositionHeight
        );
      } else if (closeTop) {
        topAndBottom = splitGeometry.topAndBottom;
        topAndBottom.geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
          topAndBottom.geometry.attributes.position.values,
          height,
          ellipsoid,
          !perPositionHeight
        );
        options.geometry = topAndBottom.geometry;
      } else if (closeBottom) {
        topAndBottom = splitGeometry.topAndBottom;
        topAndBottom.geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
          topAndBottom.geometry.attributes.position.values,
          extrudedHeight,
          ellipsoid,
          true
        );
        options.geometry = topAndBottom.geometry;
      }
      if (closeTop || closeBottom) {
        options.wall = false;
        topAndBottom.geometry = computeAttributes(options);
        geometries.push(topAndBottom);
      }
      const walls = splitGeometry.walls;
      options.wall = true;
      for (let k = 0; k < walls.length; k++) {
        const wall = walls[k];
        options.geometry = PolygonGeometryLibrary_default.scaleToGeodeticHeightExtruded(
          wall.geometry,
          height,
          extrudedHeight,
          ellipsoid,
          perPositionHeight
        );
        wall.geometry = computeAttributes(options);
        geometries.push(wall);
      }
    }
  } else {
    for (i2 = 0; i2 < polygons.length; i2++) {
      const geometryInstance = new GeometryInstance_default({
        geometry: PolygonGeometryLibrary_default.createGeometryFromPositions(
          ellipsoid,
          polygons[i2],
          granularity,
          perPositionHeight,
          vertexFormat,
          arcType
        )
      });
      geometryInstance.geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
        geometryInstance.geometry.attributes.position.values,
        height,
        ellipsoid,
        !perPositionHeight
      );
      options.geometry = geometryInstance.geometry;
      geometryInstance.geometry = computeAttributes(options);
      if (defined_default(polygonGeometry._offsetAttribute)) {
        const length3 = geometryInstance.geometry.attributes.position.values.length;
        const applyOffset = new Uint8Array(length3 / 3);
        const offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
        arrayFill_default(applyOffset, offsetValue);
        geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default(
          {
            componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
            componentsPerAttribute: 1,
            values: applyOffset
          }
        );
      }
      geometries.push(geometryInstance);
    }
  }
  const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
  geometry.attributes.position.values = new Float64Array(
    geometry.attributes.position.values
  );
  geometry.indices = IndexDatatype_default.createTypedArray(
    geometry.attributes.position.values.length / 3,
    geometry.indices
  );
  const attributes = geometry.attributes;
  const boundingSphere = BoundingSphere_default.fromVertices(
    attributes.position.values
  );
  if (!vertexFormat.position) {
    delete attributes.position;
  }
  return new Geometry_default({
    attributes,
    indices: geometry.indices,
    primitiveType: geometry.primitiveType,
    boundingSphere,
    offsetAttribute: polygonGeometry._offsetAttribute
  });
};
PolygonGeometry.createShadowVolume = function(polygonGeometry, minHeightFunc, maxHeightFunc) {
  const granularity = polygonGeometry._granularity;
  const ellipsoid = polygonGeometry._ellipsoid;
  const minHeight = minHeightFunc(granularity, ellipsoid);
  const maxHeight = maxHeightFunc(granularity, ellipsoid);
  return new PolygonGeometry({
    polygonHierarchy: polygonGeometry._polygonHierarchy,
    ellipsoid,
    stRotation: polygonGeometry._stRotation,
    granularity,
    perPositionHeight: false,
    extrudedHeight: minHeight,
    height: maxHeight,
    vertexFormat: VertexFormat_default.POSITION_ONLY,
    shadowVolume: true,
    arcType: polygonGeometry._arcType
  });
};
function textureCoordinateRotationPoints2(polygonGeometry) {
  const stRotation = -polygonGeometry._stRotation;
  if (stRotation === 0) {
    return [0, 0, 0, 1, 1, 0];
  }
  const ellipsoid = polygonGeometry._ellipsoid;
  const positions = polygonGeometry._polygonHierarchy.positions;
  const boundingRectangle = polygonGeometry.rectangle;
  return Geometry_default._textureCoordinateRotationPoints(
    positions,
    stRotation,
    ellipsoid,
    boundingRectangle
  );
}
Object.defineProperties(PolygonGeometry.prototype, {
  rectangle: {
    get: function() {
      if (!defined_default(this._rectangle)) {
        const positions = this._polygonHierarchy.positions;
        this._rectangle = computeRectangle3(
          positions,
          this._ellipsoid,
          this._arcType,
          this._granularity
        );
      }
      return this._rectangle;
    }
  },
  textureCoordinateRotationPoints: {
    get: function() {
      if (!defined_default(this._textureCoordinateRotationPoints)) {
        this._textureCoordinateRotationPoints = textureCoordinateRotationPoints2(
          this
        );
      }
      return this._textureCoordinateRotationPoints;
    }
  }
});
var PolygonGeometry_default = PolygonGeometry;

// node_modules/cesium/Source/Core/PolygonHierarchy.js
function PolygonHierarchy(positions, holes) {
  this.positions = defined_default(positions) ? positions : [];
  this.holes = defined_default(holes) ? holes : [];
}
var PolygonHierarchy_default = PolygonHierarchy;

// node_modules/cesium/Source/Core/PolygonOutlineGeometry.js
var createGeometryFromPositionsPositions = [];
var createGeometryFromPositionsSubdivided = [];
function createGeometryFromPositions2(ellipsoid, positions, minDistance, perPositionHeight, arcType) {
  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
  const positions2D = tangentPlane.projectPointsOntoPlane(
    positions,
    createGeometryFromPositionsPositions
  );
  const originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
    positions2D
  );
  if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
    positions2D.reverse();
    positions = positions.slice().reverse();
  }
  let subdividedPositions;
  let i2;
  let length3 = positions.length;
  let index2 = 0;
  if (!perPositionHeight) {
    let numVertices = 0;
    if (arcType === ArcType_default.GEODESIC) {
      for (i2 = 0; i2 < length3; i2++) {
        numVertices += PolygonGeometryLibrary_default.subdivideLineCount(
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance
        );
      }
    } else if (arcType === ArcType_default.RHUMB) {
      for (i2 = 0; i2 < length3; i2++) {
        numVertices += PolygonGeometryLibrary_default.subdivideRhumbLineCount(
          ellipsoid,
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance
        );
      }
    }
    subdividedPositions = new Float64Array(numVertices * 3);
    for (i2 = 0; i2 < length3; i2++) {
      let tempPositions;
      if (arcType === ArcType_default.GEODESIC) {
        tempPositions = PolygonGeometryLibrary_default.subdivideLine(
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance,
          createGeometryFromPositionsSubdivided
        );
      } else if (arcType === ArcType_default.RHUMB) {
        tempPositions = PolygonGeometryLibrary_default.subdivideRhumbLine(
          ellipsoid,
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance,
          createGeometryFromPositionsSubdivided
        );
      }
      const tempPositionsLength = tempPositions.length;
      for (let j = 0; j < tempPositionsLength; ++j) {
        subdividedPositions[index2++] = tempPositions[j];
      }
    }
  } else {
    subdividedPositions = new Float64Array(length3 * 2 * 3);
    for (i2 = 0; i2 < length3; i2++) {
      const p0 = positions[i2];
      const p1 = positions[(i2 + 1) % length3];
      subdividedPositions[index2++] = p0.x;
      subdividedPositions[index2++] = p0.y;
      subdividedPositions[index2++] = p0.z;
      subdividedPositions[index2++] = p1.x;
      subdividedPositions[index2++] = p1.y;
      subdividedPositions[index2++] = p1.z;
    }
  }
  length3 = subdividedPositions.length / 3;
  const indicesSize = length3 * 2;
  const indices2 = IndexDatatype_default.createTypedArray(length3, indicesSize);
  index2 = 0;
  for (i2 = 0; i2 < length3 - 1; i2++) {
    indices2[index2++] = i2;
    indices2[index2++] = i2 + 1;
  }
  indices2[index2++] = length3 - 1;
  indices2[index2++] = 0;
  return new GeometryInstance_default({
    geometry: new Geometry_default({
      attributes: new GeometryAttributes_default({
        position: new GeometryAttribute_default({
          componentDatatype: ComponentDatatype_default.DOUBLE,
          componentsPerAttribute: 3,
          values: subdividedPositions
        })
      }),
      indices: indices2,
      primitiveType: PrimitiveType_default.LINES
    })
  });
}
function createGeometryFromPositionsExtruded2(ellipsoid, positions, minDistance, perPositionHeight, arcType) {
  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
  const positions2D = tangentPlane.projectPointsOntoPlane(
    positions,
    createGeometryFromPositionsPositions
  );
  const originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
    positions2D
  );
  if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
    positions2D.reverse();
    positions = positions.slice().reverse();
  }
  let subdividedPositions;
  let i2;
  let length3 = positions.length;
  const corners = new Array(length3);
  let index2 = 0;
  if (!perPositionHeight) {
    let numVertices = 0;
    if (arcType === ArcType_default.GEODESIC) {
      for (i2 = 0; i2 < length3; i2++) {
        numVertices += PolygonGeometryLibrary_default.subdivideLineCount(
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance
        );
      }
    } else if (arcType === ArcType_default.RHUMB) {
      for (i2 = 0; i2 < length3; i2++) {
        numVertices += PolygonGeometryLibrary_default.subdivideRhumbLineCount(
          ellipsoid,
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance
        );
      }
    }
    subdividedPositions = new Float64Array(numVertices * 3 * 2);
    for (i2 = 0; i2 < length3; ++i2) {
      corners[i2] = index2 / 3;
      let tempPositions;
      if (arcType === ArcType_default.GEODESIC) {
        tempPositions = PolygonGeometryLibrary_default.subdivideLine(
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance,
          createGeometryFromPositionsSubdivided
        );
      } else if (arcType === ArcType_default.RHUMB) {
        tempPositions = PolygonGeometryLibrary_default.subdivideRhumbLine(
          ellipsoid,
          positions[i2],
          positions[(i2 + 1) % length3],
          minDistance,
          createGeometryFromPositionsSubdivided
        );
      }
      const tempPositionsLength = tempPositions.length;
      for (let j = 0; j < tempPositionsLength; ++j) {
        subdividedPositions[index2++] = tempPositions[j];
      }
    }
  } else {
    subdividedPositions = new Float64Array(length3 * 2 * 3 * 2);
    for (i2 = 0; i2 < length3; ++i2) {
      corners[i2] = index2 / 3;
      const p0 = positions[i2];
      const p1 = positions[(i2 + 1) % length3];
      subdividedPositions[index2++] = p0.x;
      subdividedPositions[index2++] = p0.y;
      subdividedPositions[index2++] = p0.z;
      subdividedPositions[index2++] = p1.x;
      subdividedPositions[index2++] = p1.y;
      subdividedPositions[index2++] = p1.z;
    }
  }
  length3 = subdividedPositions.length / (3 * 2);
  const cornersLength = corners.length;
  const indicesSize = (length3 * 2 + cornersLength) * 2;
  const indices2 = IndexDatatype_default.createTypedArray(
    length3 + cornersLength,
    indicesSize
  );
  index2 = 0;
  for (i2 = 0; i2 < length3; ++i2) {
    indices2[index2++] = i2;
    indices2[index2++] = (i2 + 1) % length3;
    indices2[index2++] = i2 + length3;
    indices2[index2++] = (i2 + 1) % length3 + length3;
  }
  for (i2 = 0; i2 < cornersLength; i2++) {
    const corner = corners[i2];
    indices2[index2++] = corner;
    indices2[index2++] = corner + length3;
  }
  return new GeometryInstance_default({
    geometry: new Geometry_default({
      attributes: new GeometryAttributes_default({
        position: new GeometryAttribute_default({
          componentDatatype: ComponentDatatype_default.DOUBLE,
          componentsPerAttribute: 3,
          values: subdividedPositions
        })
      }),
      indices: indices2,
      primitiveType: PrimitiveType_default.LINES
    })
  });
}
function PolygonOutlineGeometry(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
  if (options.perPositionHeight && defined_default(options.height)) {
    throw new DeveloperError_default(
      "Cannot use both options.perPositionHeight and options.height"
    );
  }
  if (defined_default(options.arcType) && options.arcType !== ArcType_default.GEODESIC && options.arcType !== ArcType_default.RHUMB) {
    throw new DeveloperError_default(
      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
    );
  }
  const polygonHierarchy = options.polygonHierarchy;
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  const perPositionHeight = defaultValue_default(options.perPositionHeight, false);
  const perPositionHeightExtrude = perPositionHeight && defined_default(options.extrudedHeight);
  const arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
  let height = defaultValue_default(options.height, 0);
  let extrudedHeight = defaultValue_default(options.extrudedHeight, height);
  if (!perPositionHeightExtrude) {
    const h = Math.max(height, extrudedHeight);
    extrudedHeight = Math.min(height, extrudedHeight);
    height = h;
  }
  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
  this._granularity = granularity;
  this._height = height;
  this._extrudedHeight = extrudedHeight;
  this._arcType = arcType;
  this._polygonHierarchy = polygonHierarchy;
  this._perPositionHeight = perPositionHeight;
  this._perPositionHeightExtrude = perPositionHeightExtrude;
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createPolygonOutlineGeometry";
  this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(polygonHierarchy) + Ellipsoid_default.packedLength + 8;
}
PolygonOutlineGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
    value._polygonHierarchy,
    array,
    startingIndex
  );
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  array[startingIndex++] = value._height;
  array[startingIndex++] = value._extrudedHeight;
  array[startingIndex++] = value._granularity;
  array[startingIndex++] = value._perPositionHeightExtrude ? 1 : 0;
  array[startingIndex++] = value._perPositionHeight ? 1 : 0;
  array[startingIndex++] = value._arcType;
  array[startingIndex++] = defaultValue_default(value._offsetAttribute, -1);
  array[startingIndex] = value.packedLength;
  return array;
};
var scratchEllipsoid7 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var dummyOptions2 = {
  polygonHierarchy: {}
};
PolygonOutlineGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
    array,
    startingIndex
  );
  startingIndex = polygonHierarchy.startingIndex;
  delete polygonHierarchy.startingIndex;
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid7);
  startingIndex += Ellipsoid_default.packedLength;
  const height = array[startingIndex++];
  const extrudedHeight = array[startingIndex++];
  const granularity = array[startingIndex++];
  const perPositionHeightExtrude = array[startingIndex++] === 1;
  const perPositionHeight = array[startingIndex++] === 1;
  const arcType = array[startingIndex++];
  const offsetAttribute = array[startingIndex++];
  const packedLength = array[startingIndex];
  if (!defined_default(result)) {
    result = new PolygonOutlineGeometry(dummyOptions2);
  }
  result._polygonHierarchy = polygonHierarchy;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._height = height;
  result._extrudedHeight = extrudedHeight;
  result._granularity = granularity;
  result._perPositionHeight = perPositionHeight;
  result._perPositionHeightExtrude = perPositionHeightExtrude;
  result._arcType = arcType;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  result.packedLength = packedLength;
  return result;
};
PolygonOutlineGeometry.fromPositions = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.positions", options.positions);
  const newOptions2 = {
    polygonHierarchy: {
      positions: options.positions
    },
    height: options.height,
    extrudedHeight: options.extrudedHeight,
    ellipsoid: options.ellipsoid,
    granularity: options.granularity,
    perPositionHeight: options.perPositionHeight,
    arcType: options.arcType,
    offsetAttribute: options.offsetAttribute
  };
  return new PolygonOutlineGeometry(newOptions2);
};
PolygonOutlineGeometry.createGeometry = function(polygonGeometry) {
  const ellipsoid = polygonGeometry._ellipsoid;
  const granularity = polygonGeometry._granularity;
  const polygonHierarchy = polygonGeometry._polygonHierarchy;
  const perPositionHeight = polygonGeometry._perPositionHeight;
  const arcType = polygonGeometry._arcType;
  const polygons = PolygonGeometryLibrary_default.polygonOutlinesFromHierarchy(
    polygonHierarchy,
    !perPositionHeight,
    ellipsoid
  );
  if (polygons.length === 0) {
    return void 0;
  }
  let geometryInstance;
  const geometries = [];
  const minDistance = Math_default.chordLength(
    granularity,
    ellipsoid.maximumRadius
  );
  const height = polygonGeometry._height;
  const extrudedHeight = polygonGeometry._extrudedHeight;
  const extrude = polygonGeometry._perPositionHeightExtrude || !Math_default.equalsEpsilon(height, extrudedHeight, 0, Math_default.EPSILON2);
  let offsetValue;
  let i2;
  if (extrude) {
    for (i2 = 0; i2 < polygons.length; i2++) {
      geometryInstance = createGeometryFromPositionsExtruded2(
        ellipsoid,
        polygons[i2],
        minDistance,
        perPositionHeight,
        arcType
      );
      geometryInstance.geometry = PolygonGeometryLibrary_default.scaleToGeodeticHeightExtruded(
        geometryInstance.geometry,
        height,
        extrudedHeight,
        ellipsoid,
        perPositionHeight
      );
      if (defined_default(polygonGeometry._offsetAttribute)) {
        const size = geometryInstance.geometry.attributes.position.values.length / 3;
        let offsetAttribute = new Uint8Array(size);
        if (polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.TOP) {
          offsetAttribute = arrayFill_default(offsetAttribute, 1, 0, size / 2);
        } else {
          offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
          offsetAttribute = arrayFill_default(offsetAttribute, offsetValue);
        }
        geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default(
          {
            componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
            componentsPerAttribute: 1,
            values: offsetAttribute
          }
        );
      }
      geometries.push(geometryInstance);
    }
  } else {
    for (i2 = 0; i2 < polygons.length; i2++) {
      geometryInstance = createGeometryFromPositions2(
        ellipsoid,
        polygons[i2],
        minDistance,
        perPositionHeight,
        arcType
      );
      geometryInstance.geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
        geometryInstance.geometry.attributes.position.values,
        height,
        ellipsoid,
        !perPositionHeight
      );
      if (defined_default(polygonGeometry._offsetAttribute)) {
        const length3 = geometryInstance.geometry.attributes.position.values.length;
        const applyOffset = new Uint8Array(length3 / 3);
        offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
        arrayFill_default(applyOffset, offsetValue);
        geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default(
          {
            componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
            componentsPerAttribute: 1,
            values: applyOffset
          }
        );
      }
      geometries.push(geometryInstance);
    }
  }
  const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
  const boundingSphere = BoundingSphere_default.fromVertices(
    geometry.attributes.position.values
  );
  return new Geometry_default({
    attributes: geometry.attributes,
    indices: geometry.indices,
    primitiveType: geometry.primitiveType,
    boundingSphere,
    offsetAttribute: polygonGeometry._offsetAttribute
  });
};
var PolygonOutlineGeometry_default = PolygonOutlineGeometry;

// node_modules/cesium/Source/Core/PolylineGeometry.js
var scratchInterpolateColorsArray = [];
function interpolateColors(p0, p1, color0, color1, numPoints) {
  const colors = scratchInterpolateColorsArray;
  colors.length = numPoints;
  let i2;
  const r0 = color0.red;
  const g0 = color0.green;
  const b0 = color0.blue;
  const a0 = color0.alpha;
  const r1 = color1.red;
  const g1 = color1.green;
  const b1 = color1.blue;
  const a1 = color1.alpha;
  if (Color_default.equals(color0, color1)) {
    for (i2 = 0; i2 < numPoints; i2++) {
      colors[i2] = Color_default.clone(color0);
    }
    return colors;
  }
  const redPerVertex = (r1 - r0) / numPoints;
  const greenPerVertex = (g1 - g0) / numPoints;
  const bluePerVertex = (b1 - b0) / numPoints;
  const alphaPerVertex = (a1 - a0) / numPoints;
  for (i2 = 0; i2 < numPoints; i2++) {
    colors[i2] = new Color_default(
      r0 + i2 * redPerVertex,
      g0 + i2 * greenPerVertex,
      b0 + i2 * bluePerVertex,
      a0 + i2 * alphaPerVertex
    );
  }
  return colors;
}
function PolylineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.positions;
  const colors = options.colors;
  const width = defaultValue_default(options.width, 1);
  const colorsPerVertex = defaultValue_default(options.colorsPerVertex, false);
  if (!defined_default(positions) || positions.length < 2) {
    throw new DeveloperError_default("At least two positions are required.");
  }
  if (typeof width !== "number") {
    throw new DeveloperError_default("width must be a number");
  }
  if (defined_default(colors) && (colorsPerVertex && colors.length < positions.length || !colorsPerVertex && colors.length < positions.length - 1)) {
    throw new DeveloperError_default("colors has an invalid length.");
  }
  this._positions = positions;
  this._colors = colors;
  this._width = width;
  this._colorsPerVertex = colorsPerVertex;
  this._vertexFormat = VertexFormat_default.clone(
    defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT)
  );
  this._arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
  this._granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  this._ellipsoid = Ellipsoid_default.clone(
    defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
  );
  this._workerName = "createPolylineGeometry";
  let numComponents = 1 + positions.length * Cartesian3_default.packedLength;
  numComponents += defined_default(colors) ? 1 + colors.length * Color_default.packedLength : 1;
  this.packedLength = numComponents + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 4;
}
PolylineGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  const positions = value._positions;
  let length3 = positions.length;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    Cartesian3_default.pack(positions[i2], array, startingIndex);
  }
  const colors = value._colors;
  length3 = defined_default(colors) ? colors.length : 0;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Color_default.packedLength) {
    Color_default.pack(colors[i2], array, startingIndex);
  }
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex++] = value._width;
  array[startingIndex++] = value._colorsPerVertex ? 1 : 0;
  array[startingIndex++] = value._arcType;
  array[startingIndex] = value._granularity;
  return array;
};
var scratchEllipsoid8 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchVertexFormat10 = new VertexFormat_default();
var scratchOptions16 = {
  positions: void 0,
  colors: void 0,
  ellipsoid: scratchEllipsoid8,
  vertexFormat: scratchVertexFormat10,
  width: void 0,
  colorsPerVertex: void 0,
  arcType: void 0,
  granularity: void 0
};
PolylineGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  let length3 = array[startingIndex++];
  const positions = new Array(length3);
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    positions[i2] = Cartesian3_default.unpack(array, startingIndex);
  }
  length3 = array[startingIndex++];
  const colors = length3 > 0 ? new Array(length3) : void 0;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Color_default.packedLength) {
    colors[i2] = Color_default.unpack(array, startingIndex);
  }
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid8);
  startingIndex += Ellipsoid_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat10
  );
  startingIndex += VertexFormat_default.packedLength;
  const width = array[startingIndex++];
  const colorsPerVertex = array[startingIndex++] === 1;
  const arcType = array[startingIndex++];
  const granularity = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions16.positions = positions;
    scratchOptions16.colors = colors;
    scratchOptions16.width = width;
    scratchOptions16.colorsPerVertex = colorsPerVertex;
    scratchOptions16.arcType = arcType;
    scratchOptions16.granularity = granularity;
    return new PolylineGeometry(scratchOptions16);
  }
  result._positions = positions;
  result._colors = colors;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._width = width;
  result._colorsPerVertex = colorsPerVertex;
  result._arcType = arcType;
  result._granularity = granularity;
  return result;
};
var scratchCartesian39 = new Cartesian3_default();
var scratchPosition5 = new Cartesian3_default();
var scratchPrevPosition = new Cartesian3_default();
var scratchNextPosition = new Cartesian3_default();
PolylineGeometry.createGeometry = function(polylineGeometry) {
  const width = polylineGeometry._width;
  const vertexFormat = polylineGeometry._vertexFormat;
  let colors = polylineGeometry._colors;
  const colorsPerVertex = polylineGeometry._colorsPerVertex;
  const arcType = polylineGeometry._arcType;
  const granularity = polylineGeometry._granularity;
  const ellipsoid = polylineGeometry._ellipsoid;
  let i2;
  let j;
  let k;
  const removedIndices = [];
  let positions = arrayRemoveDuplicates_default(
    polylineGeometry._positions,
    Cartesian3_default.equalsEpsilon,
    false,
    removedIndices
  );
  if (defined_default(colors) && removedIndices.length > 0) {
    let removedArrayIndex = 0;
    let nextRemovedIndex = removedIndices[0];
    colors = colors.filter(function(color, index3) {
      let remove4 = false;
      if (colorsPerVertex) {
        remove4 = index3 === nextRemovedIndex || index3 === 0 && nextRemovedIndex === 1;
      } else {
        remove4 = index3 + 1 === nextRemovedIndex;
      }
      if (remove4) {
        removedArrayIndex++;
        nextRemovedIndex = removedIndices[removedArrayIndex];
        return false;
      }
      return true;
    });
  }
  let positionsLength = positions.length;
  if (positionsLength < 2 || width <= 0) {
    return void 0;
  }
  if (arcType === ArcType_default.GEODESIC || arcType === ArcType_default.RHUMB) {
    let subdivisionSize;
    let numberOfPointsFunction;
    if (arcType === ArcType_default.GEODESIC) {
      subdivisionSize = Math_default.chordLength(
        granularity,
        ellipsoid.maximumRadius
      );
      numberOfPointsFunction = PolylinePipeline_default.numberOfPoints;
    } else {
      subdivisionSize = granularity;
      numberOfPointsFunction = PolylinePipeline_default.numberOfPointsRhumbLine;
    }
    const heights = PolylinePipeline_default.extractHeights(positions, ellipsoid);
    if (defined_default(colors)) {
      let colorLength = 1;
      for (i2 = 0; i2 < positionsLength - 1; ++i2) {
        colorLength += numberOfPointsFunction(
          positions[i2],
          positions[i2 + 1],
          subdivisionSize
        );
      }
      const newColors = new Array(colorLength);
      let newColorIndex = 0;
      for (i2 = 0; i2 < positionsLength - 1; ++i2) {
        const p0 = positions[i2];
        const p1 = positions[i2 + 1];
        const c0 = colors[i2];
        const numColors = numberOfPointsFunction(p0, p1, subdivisionSize);
        if (colorsPerVertex && i2 < colorLength) {
          const c14 = colors[i2 + 1];
          const interpolatedColors = interpolateColors(
            p0,
            p1,
            c0,
            c14,
            numColors
          );
          const interpolatedColorsLength = interpolatedColors.length;
          for (j = 0; j < interpolatedColorsLength; ++j) {
            newColors[newColorIndex++] = interpolatedColors[j];
          }
        } else {
          for (j = 0; j < numColors; ++j) {
            newColors[newColorIndex++] = Color_default.clone(c0);
          }
        }
      }
      newColors[newColorIndex] = Color_default.clone(colors[colors.length - 1]);
      colors = newColors;
      scratchInterpolateColorsArray.length = 0;
    }
    if (arcType === ArcType_default.GEODESIC) {
      positions = PolylinePipeline_default.generateCartesianArc({
        positions,
        minDistance: subdivisionSize,
        ellipsoid,
        height: heights
      });
    } else {
      positions = PolylinePipeline_default.generateCartesianRhumbArc({
        positions,
        granularity: subdivisionSize,
        ellipsoid,
        height: heights
      });
    }
  }
  positionsLength = positions.length;
  const size = positionsLength * 4 - 4;
  const finalPositions = new Float64Array(size * 3);
  const prevPositions = new Float64Array(size * 3);
  const nextPositions = new Float64Array(size * 3);
  const expandAndWidth = new Float32Array(size * 2);
  const st = vertexFormat.st ? new Float32Array(size * 2) : void 0;
  const finalColors = defined_default(colors) ? new Uint8Array(size * 4) : void 0;
  let positionIndex = 0;
  let expandAndWidthIndex = 0;
  let stIndex = 0;
  let colorIndex = 0;
  let position;
  for (j = 0; j < positionsLength; ++j) {
    if (j === 0) {
      position = scratchCartesian39;
      Cartesian3_default.subtract(positions[0], positions[1], position);
      Cartesian3_default.add(positions[0], position, position);
    } else {
      position = positions[j - 1];
    }
    Cartesian3_default.clone(position, scratchPrevPosition);
    Cartesian3_default.clone(positions[j], scratchPosition5);
    if (j === positionsLength - 1) {
      position = scratchCartesian39;
      Cartesian3_default.subtract(
        positions[positionsLength - 1],
        positions[positionsLength - 2],
        position
      );
      Cartesian3_default.add(positions[positionsLength - 1], position, position);
    } else {
      position = positions[j + 1];
    }
    Cartesian3_default.clone(position, scratchNextPosition);
    let color0, color1;
    if (defined_default(finalColors)) {
      if (j !== 0 && !colorsPerVertex) {
        color0 = colors[j - 1];
      } else {
        color0 = colors[j];
      }
      if (j !== positionsLength - 1) {
        color1 = colors[j];
      }
    }
    const startK = j === 0 ? 2 : 0;
    const endK = j === positionsLength - 1 ? 2 : 4;
    for (k = startK; k < endK; ++k) {
      Cartesian3_default.pack(scratchPosition5, finalPositions, positionIndex);
      Cartesian3_default.pack(scratchPrevPosition, prevPositions, positionIndex);
      Cartesian3_default.pack(scratchNextPosition, nextPositions, positionIndex);
      positionIndex += 3;
      const direction2 = k - 2 < 0 ? -1 : 1;
      expandAndWidth[expandAndWidthIndex++] = 2 * (k % 2) - 1;
      expandAndWidth[expandAndWidthIndex++] = direction2 * width;
      if (vertexFormat.st) {
        st[stIndex++] = j / (positionsLength - 1);
        st[stIndex++] = Math.max(expandAndWidth[expandAndWidthIndex - 2], 0);
      }
      if (defined_default(finalColors)) {
        const color = k < 2 ? color0 : color1;
        finalColors[colorIndex++] = Color_default.floatToByte(color.red);
        finalColors[colorIndex++] = Color_default.floatToByte(color.green);
        finalColors[colorIndex++] = Color_default.floatToByte(color.blue);
        finalColors[colorIndex++] = Color_default.floatToByte(color.alpha);
      }
    }
  }
  const attributes = new GeometryAttributes_default();
  attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: finalPositions
  });
  attributes.prevPosition = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: prevPositions
  });
  attributes.nextPosition = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: nextPositions
  });
  attributes.expandAndWidth = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 2,
    values: expandAndWidth
  });
  if (vertexFormat.st) {
    attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: st
    });
  }
  if (defined_default(finalColors)) {
    attributes.color = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 4,
      values: finalColors,
      normalize: true
    });
  }
  const indices2 = IndexDatatype_default.createTypedArray(size, positionsLength * 6 - 6);
  let index2 = 0;
  let indicesIndex = 0;
  const length3 = positionsLength - 1;
  for (j = 0; j < length3; ++j) {
    indices2[indicesIndex++] = index2;
    indices2[indicesIndex++] = index2 + 2;
    indices2[indicesIndex++] = index2 + 1;
    indices2[indicesIndex++] = index2 + 1;
    indices2[indicesIndex++] = index2 + 2;
    indices2[indicesIndex++] = index2 + 3;
    index2 += 4;
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingSphere: BoundingSphere_default.fromPoints(positions),
    geometryType: GeometryType_default.POLYLINES
  });
};
var PolylineGeometry_default = PolylineGeometry;

// node_modules/cesium/Source/Core/PolylineVolumeGeometry.js
function computeAttributes2(combinedPositions, shape, boundingRectangle, vertexFormat) {
  const attributes = new GeometryAttributes_default();
  if (vertexFormat.position) {
    attributes.position = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: combinedPositions
    });
  }
  const shapeLength = shape.length;
  const vertexCount = combinedPositions.length / 3;
  const length3 = (vertexCount - shapeLength * 2) / (shapeLength * 2);
  const firstEndIndices = PolygonPipeline_default.triangulate(shape);
  const indicesCount = (length3 - 1) * shapeLength * 6 + firstEndIndices.length * 2;
  const indices2 = IndexDatatype_default.createTypedArray(vertexCount, indicesCount);
  let i2, j;
  let ll, ul, ur, lr;
  const offset2 = shapeLength * 2;
  let index2 = 0;
  for (i2 = 0; i2 < length3 - 1; i2++) {
    for (j = 0; j < shapeLength - 1; j++) {
      ll = j * 2 + i2 * shapeLength * 2;
      lr = ll + offset2;
      ul = ll + 1;
      ur = ul + offset2;
      indices2[index2++] = ul;
      indices2[index2++] = ll;
      indices2[index2++] = ur;
      indices2[index2++] = ur;
      indices2[index2++] = ll;
      indices2[index2++] = lr;
    }
    ll = shapeLength * 2 - 2 + i2 * shapeLength * 2;
    ul = ll + 1;
    ur = ul + offset2;
    lr = ll + offset2;
    indices2[index2++] = ul;
    indices2[index2++] = ll;
    indices2[index2++] = ur;
    indices2[index2++] = ur;
    indices2[index2++] = ll;
    indices2[index2++] = lr;
  }
  if (vertexFormat.st || vertexFormat.tangent || vertexFormat.bitangent) {
    const st = new Float32Array(vertexCount * 2);
    const lengthSt = 1 / (length3 - 1);
    const heightSt = 1 / boundingRectangle.height;
    const heightOffset = boundingRectangle.height / 2;
    let s2, t;
    let stindex = 0;
    for (i2 = 0; i2 < length3; i2++) {
      s2 = i2 * lengthSt;
      t = heightSt * (shape[0].y + heightOffset);
      st[stindex++] = s2;
      st[stindex++] = t;
      for (j = 1; j < shapeLength; j++) {
        t = heightSt * (shape[j].y + heightOffset);
        st[stindex++] = s2;
        st[stindex++] = t;
        st[stindex++] = s2;
        st[stindex++] = t;
      }
      t = heightSt * (shape[0].y + heightOffset);
      st[stindex++] = s2;
      st[stindex++] = t;
    }
    for (j = 0; j < shapeLength; j++) {
      s2 = 0;
      t = heightSt * (shape[j].y + heightOffset);
      st[stindex++] = s2;
      st[stindex++] = t;
    }
    for (j = 0; j < shapeLength; j++) {
      s2 = (length3 - 1) * lengthSt;
      t = heightSt * (shape[j].y + heightOffset);
      st[stindex++] = s2;
      st[stindex++] = t;
    }
    attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: new Float32Array(st)
    });
  }
  const endOffset = vertexCount - shapeLength * 2;
  for (i2 = 0; i2 < firstEndIndices.length; i2 += 3) {
    const v02 = firstEndIndices[i2] + endOffset;
    const v13 = firstEndIndices[i2 + 1] + endOffset;
    const v23 = firstEndIndices[i2 + 2] + endOffset;
    indices2[index2++] = v02;
    indices2[index2++] = v13;
    indices2[index2++] = v23;
    indices2[index2++] = v23 + shapeLength;
    indices2[index2++] = v13 + shapeLength;
    indices2[index2++] = v02 + shapeLength;
  }
  let geometry = new Geometry_default({
    attributes,
    indices: indices2,
    boundingSphere: BoundingSphere_default.fromVertices(combinedPositions),
    primitiveType: PrimitiveType_default.TRIANGLES
  });
  if (vertexFormat.normal) {
    geometry = GeometryPipeline_default.computeNormal(geometry);
  }
  if (vertexFormat.tangent || vertexFormat.bitangent) {
    try {
      geometry = GeometryPipeline_default.computeTangentAndBitangent(geometry);
    } catch (e2) {
      oneTimeWarning_default(
        "polyline-volume-tangent-bitangent",
        "Unable to compute tangents and bitangents for polyline volume geometry"
      );
    }
    if (!vertexFormat.tangent) {
      geometry.attributes.tangent = void 0;
    }
    if (!vertexFormat.bitangent) {
      geometry.attributes.bitangent = void 0;
    }
    if (!vertexFormat.st) {
      geometry.attributes.st = void 0;
    }
  }
  return geometry;
}
function PolylineVolumeGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.polylinePositions;
  const shape = options.shapePositions;
  if (!defined_default(positions)) {
    throw new DeveloperError_default("options.polylinePositions is required.");
  }
  if (!defined_default(shape)) {
    throw new DeveloperError_default("options.shapePositions is required.");
  }
  this._positions = positions;
  this._shape = shape;
  this._ellipsoid = Ellipsoid_default.clone(
    defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
  );
  this._cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
  this._vertexFormat = VertexFormat_default.clone(
    defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT)
  );
  this._granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  this._workerName = "createPolylineVolumeGeometry";
  let numComponents = 1 + positions.length * Cartesian3_default.packedLength;
  numComponents += 1 + shape.length * Cartesian2_default.packedLength;
  this.packedLength = numComponents + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 2;
}
PolylineVolumeGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  const positions = value._positions;
  let length3 = positions.length;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    Cartesian3_default.pack(positions[i2], array, startingIndex);
  }
  const shape = value._shape;
  length3 = shape.length;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian2_default.packedLength) {
    Cartesian2_default.pack(shape[i2], array, startingIndex);
  }
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex++] = value._cornerType;
  array[startingIndex] = value._granularity;
  return array;
};
var scratchEllipsoid9 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchVertexFormat11 = new VertexFormat_default();
var scratchOptions17 = {
  polylinePositions: void 0,
  shapePositions: void 0,
  ellipsoid: scratchEllipsoid9,
  vertexFormat: scratchVertexFormat11,
  cornerType: void 0,
  granularity: void 0
};
PolylineVolumeGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  let length3 = array[startingIndex++];
  const positions = new Array(length3);
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    positions[i2] = Cartesian3_default.unpack(array, startingIndex);
  }
  length3 = array[startingIndex++];
  const shape = new Array(length3);
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian2_default.packedLength) {
    shape[i2] = Cartesian2_default.unpack(array, startingIndex);
  }
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid9);
  startingIndex += Ellipsoid_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat11
  );
  startingIndex += VertexFormat_default.packedLength;
  const cornerType = array[startingIndex++];
  const granularity = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions17.polylinePositions = positions;
    scratchOptions17.shapePositions = shape;
    scratchOptions17.cornerType = cornerType;
    scratchOptions17.granularity = granularity;
    return new PolylineVolumeGeometry(scratchOptions17);
  }
  result._positions = positions;
  result._shape = shape;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._cornerType = cornerType;
  result._granularity = granularity;
  return result;
};
var brScratch = new BoundingRectangle_default();
PolylineVolumeGeometry.createGeometry = function(polylineVolumeGeometry) {
  const positions = polylineVolumeGeometry._positions;
  const cleanPositions = arrayRemoveDuplicates_default(
    positions,
    Cartesian3_default.equalsEpsilon
  );
  let shape2D = polylineVolumeGeometry._shape;
  shape2D = PolylineVolumeGeometryLibrary_default.removeDuplicatesFromShape(shape2D);
  if (cleanPositions.length < 2 || shape2D.length < 3) {
    return void 0;
  }
  if (PolygonPipeline_default.computeWindingOrder2D(shape2D) === WindingOrder_default.CLOCKWISE) {
    shape2D.reverse();
  }
  const boundingRectangle = BoundingRectangle_default.fromPoints(shape2D, brScratch);
  const computedPositions = PolylineVolumeGeometryLibrary_default.computePositions(
    cleanPositions,
    shape2D,
    boundingRectangle,
    polylineVolumeGeometry,
    true
  );
  return computeAttributes2(
    computedPositions,
    shape2D,
    boundingRectangle,
    polylineVolumeGeometry._vertexFormat
  );
};
var PolylineVolumeGeometry_default = PolylineVolumeGeometry;

// node_modules/cesium/Source/Core/PolylineVolumeOutlineGeometry.js
function computeAttributes3(positions, shape) {
  const attributes = new GeometryAttributes_default();
  attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: positions
  });
  const shapeLength = shape.length;
  const vertexCount = attributes.position.values.length / 3;
  const positionLength = positions.length / 3;
  const shapeCount = positionLength / shapeLength;
  const indices2 = IndexDatatype_default.createTypedArray(
    vertexCount,
    2 * shapeLength * (shapeCount + 1)
  );
  let i2, j;
  let index2 = 0;
  i2 = 0;
  let offset2 = i2 * shapeLength;
  for (j = 0; j < shapeLength - 1; j++) {
    indices2[index2++] = j + offset2;
    indices2[index2++] = j + offset2 + 1;
  }
  indices2[index2++] = shapeLength - 1 + offset2;
  indices2[index2++] = offset2;
  i2 = shapeCount - 1;
  offset2 = i2 * shapeLength;
  for (j = 0; j < shapeLength - 1; j++) {
    indices2[index2++] = j + offset2;
    indices2[index2++] = j + offset2 + 1;
  }
  indices2[index2++] = shapeLength - 1 + offset2;
  indices2[index2++] = offset2;
  for (i2 = 0; i2 < shapeCount - 1; i2++) {
    const firstOffset = shapeLength * i2;
    const secondOffset = firstOffset + shapeLength;
    for (j = 0; j < shapeLength; j++) {
      indices2[index2++] = j + firstOffset;
      indices2[index2++] = j + secondOffset;
    }
  }
  const geometry = new Geometry_default({
    attributes,
    indices: IndexDatatype_default.createTypedArray(vertexCount, indices2),
    boundingSphere: BoundingSphere_default.fromVertices(positions),
    primitiveType: PrimitiveType_default.LINES
  });
  return geometry;
}
function PolylineVolumeOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.polylinePositions;
  const shape = options.shapePositions;
  if (!defined_default(positions)) {
    throw new DeveloperError_default("options.polylinePositions is required.");
  }
  if (!defined_default(shape)) {
    throw new DeveloperError_default("options.shapePositions is required.");
  }
  this._positions = positions;
  this._shape = shape;
  this._ellipsoid = Ellipsoid_default.clone(
    defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
  );
  this._cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
  this._granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  this._workerName = "createPolylineVolumeOutlineGeometry";
  let numComponents = 1 + positions.length * Cartesian3_default.packedLength;
  numComponents += 1 + shape.length * Cartesian2_default.packedLength;
  this.packedLength = numComponents + Ellipsoid_default.packedLength + 2;
}
PolylineVolumeOutlineGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  const positions = value._positions;
  let length3 = positions.length;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    Cartesian3_default.pack(positions[i2], array, startingIndex);
  }
  const shape = value._shape;
  length3 = shape.length;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian2_default.packedLength) {
    Cartesian2_default.pack(shape[i2], array, startingIndex);
  }
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  array[startingIndex++] = value._cornerType;
  array[startingIndex] = value._granularity;
  return array;
};
var scratchEllipsoid10 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchOptions18 = {
  polylinePositions: void 0,
  shapePositions: void 0,
  ellipsoid: scratchEllipsoid10,
  height: void 0,
  cornerType: void 0,
  granularity: void 0
};
PolylineVolumeOutlineGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  let length3 = array[startingIndex++];
  const positions = new Array(length3);
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    positions[i2] = Cartesian3_default.unpack(array, startingIndex);
  }
  length3 = array[startingIndex++];
  const shape = new Array(length3);
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian2_default.packedLength) {
    shape[i2] = Cartesian2_default.unpack(array, startingIndex);
  }
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid10);
  startingIndex += Ellipsoid_default.packedLength;
  const cornerType = array[startingIndex++];
  const granularity = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions18.polylinePositions = positions;
    scratchOptions18.shapePositions = shape;
    scratchOptions18.cornerType = cornerType;
    scratchOptions18.granularity = granularity;
    return new PolylineVolumeOutlineGeometry(scratchOptions18);
  }
  result._positions = positions;
  result._shape = shape;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._cornerType = cornerType;
  result._granularity = granularity;
  return result;
};
var brScratch2 = new BoundingRectangle_default();
PolylineVolumeOutlineGeometry.createGeometry = function(polylineVolumeOutlineGeometry) {
  const positions = polylineVolumeOutlineGeometry._positions;
  const cleanPositions = arrayRemoveDuplicates_default(
    positions,
    Cartesian3_default.equalsEpsilon
  );
  let shape2D = polylineVolumeOutlineGeometry._shape;
  shape2D = PolylineVolumeGeometryLibrary_default.removeDuplicatesFromShape(shape2D);
  if (cleanPositions.length < 2 || shape2D.length < 3) {
    return void 0;
  }
  if (PolygonPipeline_default.computeWindingOrder2D(shape2D) === WindingOrder_default.CLOCKWISE) {
    shape2D.reverse();
  }
  const boundingRectangle = BoundingRectangle_default.fromPoints(shape2D, brScratch2);
  const computedPositions = PolylineVolumeGeometryLibrary_default.computePositions(
    cleanPositions,
    shape2D,
    boundingRectangle,
    polylineVolumeOutlineGeometry,
    false
  );
  return computeAttributes3(computedPositions, shape2D);
};
var PolylineVolumeOutlineGeometry_default = PolylineVolumeOutlineGeometry;

// node_modules/cesium/Source/Core/Proxy.js
function Proxy2() {
  DeveloperError_default.throwInstantiationError();
}
Proxy2.prototype.getURL = DeveloperError_default.throwInstantiationError;
var Proxy_default = Proxy2;

// node_modules/cesium/Source/Core/QuaternionSpline.js
function createEvaluateFunction2(spline) {
  const points = spline.points;
  const times = spline.times;
  return function(time, result) {
    if (!defined_default(result)) {
      result = new Quaternion_default();
    }
    const i2 = spline._lastTimeIndex = spline.findTimeInterval(
      time,
      spline._lastTimeIndex
    );
    const u3 = (time - times[i2]) / (times[i2 + 1] - times[i2]);
    const q0 = points[i2];
    const q12 = points[i2 + 1];
    return Quaternion_default.fastSlerp(q0, q12, u3, result);
  };
}
function QuaternionSpline(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const points = options.points;
  const times = options.times;
  if (!defined_default(points) || !defined_default(times)) {
    throw new DeveloperError_default("points and times are required.");
  }
  if (points.length < 2) {
    throw new DeveloperError_default(
      "points.length must be greater than or equal to 2."
    );
  }
  if (times.length !== points.length) {
    throw new DeveloperError_default("times.length must be equal to points.length.");
  }
  this._times = times;
  this._points = points;
  this._evaluateFunction = createEvaluateFunction2(this);
  this._lastTimeIndex = 0;
}
Object.defineProperties(QuaternionSpline.prototype, {
  times: {
    get: function() {
      return this._times;
    }
  },
  points: {
    get: function() {
      return this._points;
    }
  }
});
QuaternionSpline.prototype.findTimeInterval = Spline_default.prototype.findTimeInterval;
QuaternionSpline.prototype.wrapTime = Spline_default.prototype.wrapTime;
QuaternionSpline.prototype.clampTime = Spline_default.prototype.clampTime;
QuaternionSpline.prototype.evaluate = function(time, result) {
  return this._evaluateFunction(time, result);
};
var QuaternionSpline_default = QuaternionSpline;

// node_modules/cesium/Source/ThirdParty/rbush.js
function quickselect(arr, k, left, right, compare) {
  quickselectStep(arr, k, left || 0, right || arr.length - 1, compare || defaultCompare);
}
function quickselectStep(arr, k, left, right, compare) {
  while (right > left) {
    if (right - left > 600) {
      var n2 = right - left + 1;
      var m = k - left + 1;
      var z = Math.log(n2);
      var s2 = 0.5 * Math.exp(2 * z / 3);
      var sd = 0.5 * Math.sqrt(z * s2 * (n2 - s2) / n2) * (m - n2 / 2 < 0 ? -1 : 1);
      var newLeft = Math.max(left, Math.floor(k - m * s2 / n2 + sd));
      var newRight = Math.min(right, Math.floor(k + (n2 - m) * s2 / n2 + sd));
      quickselectStep(arr, k, newLeft, newRight, compare);
    }
    var t = arr[k];
    var i2 = left;
    var j = right;
    swap3(arr, left, k);
    if (compare(arr[right], t) > 0)
      swap3(arr, left, right);
    while (i2 < j) {
      swap3(arr, i2, j);
      i2++;
      j--;
      while (compare(arr[i2], t) < 0)
        i2++;
      while (compare(arr[j], t) > 0)
        j--;
    }
    if (compare(arr[left], t) === 0)
      swap3(arr, left, j);
    else {
      j++;
      swap3(arr, j, right);
    }
    if (j <= k)
      left = j + 1;
    if (k <= j)
      right = j - 1;
  }
}
function swap3(arr, i2, j) {
  var tmp2 = arr[i2];
  arr[i2] = arr[j];
  arr[j] = tmp2;
}
function defaultCompare(a4, b) {
  return a4 < b ? -1 : a4 > b ? 1 : 0;
}
var RBush = class {
  constructor(maxEntries = 9) {
    this._maxEntries = Math.max(4, maxEntries);
    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
    this.clear();
  }
  all() {
    return this._all(this.data, []);
  }
  search(bbox2) {
    let node = this.data;
    const result = [];
    if (!intersects2(bbox2, node))
      return result;
    const toBBox = this.toBBox;
    const nodesToSearch = [];
    while (node) {
      for (let i2 = 0; i2 < node.children.length; i2++) {
        const child = node.children[i2];
        const childBBox = node.leaf ? toBBox(child) : child;
        if (intersects2(bbox2, childBBox)) {
          if (node.leaf)
            result.push(child);
          else if (contains(bbox2, childBBox))
            this._all(child, result);
          else
            nodesToSearch.push(child);
        }
      }
      node = nodesToSearch.pop();
    }
    return result;
  }
  collides(bbox2) {
    let node = this.data;
    if (!intersects2(bbox2, node))
      return false;
    const nodesToSearch = [];
    while (node) {
      for (let i2 = 0; i2 < node.children.length; i2++) {
        const child = node.children[i2];
        const childBBox = node.leaf ? this.toBBox(child) : child;
        if (intersects2(bbox2, childBBox)) {
          if (node.leaf || contains(bbox2, childBBox))
            return true;
          nodesToSearch.push(child);
        }
      }
      node = nodesToSearch.pop();
    }
    return false;
  }
  load(data) {
    if (!(data && data.length))
      return this;
    if (data.length < this._minEntries) {
      for (let i2 = 0; i2 < data.length; i2++) {
        this.insert(data[i2]);
      }
      return this;
    }
    let node = this._build(data.slice(), 0, data.length - 1, 0);
    if (!this.data.children.length) {
      this.data = node;
    } else if (this.data.height === node.height) {
      this._splitRoot(this.data, node);
    } else {
      if (this.data.height < node.height) {
        const tmpNode = this.data;
        this.data = node;
        node = tmpNode;
      }
      this._insert(node, this.data.height - node.height - 1, true);
    }
    return this;
  }
  insert(item) {
    if (item)
      this._insert(item, this.data.height - 1);
    return this;
  }
  clear() {
    this.data = createNode([]);
    return this;
  }
  remove(item, equalsFn) {
    if (!item)
      return this;
    let node = this.data;
    const bbox2 = this.toBBox(item);
    const path = [];
    const indexes = [];
    let i2, parent, goingUp;
    while (node || path.length) {
      if (!node) {
        node = path.pop();
        parent = path[path.length - 1];
        i2 = indexes.pop();
        goingUp = true;
      }
      if (node.leaf) {
        const index2 = findItem(item, node.children, equalsFn);
        if (index2 !== -1) {
          node.children.splice(index2, 1);
          path.push(node);
          this._condense(path);
          return this;
        }
      }
      if (!goingUp && !node.leaf && contains(node, bbox2)) {
        path.push(node);
        indexes.push(i2);
        i2 = 0;
        parent = node;
        node = node.children[0];
      } else if (parent) {
        i2++;
        node = parent.children[i2];
        goingUp = false;
      } else
        node = null;
    }
    return this;
  }
  toBBox(item) {
    return item;
  }
  compareMinX(a4, b) {
    return a4.minX - b.minX;
  }
  compareMinY(a4, b) {
    return a4.minY - b.minY;
  }
  toJSON() {
    return this.data;
  }
  fromJSON(data) {
    this.data = data;
    return this;
  }
  _all(node, result) {
    const nodesToSearch = [];
    while (node) {
      if (node.leaf)
        result.push(...node.children);
      else
        nodesToSearch.push(...node.children);
      node = nodesToSearch.pop();
    }
    return result;
  }
  _build(items, left, right, height) {
    const N = right - left + 1;
    let M = this._maxEntries;
    let node;
    if (N <= M) {
      node = createNode(items.slice(left, right + 1));
      calcBBox(node, this.toBBox);
      return node;
    }
    if (!height) {
      height = Math.ceil(Math.log(N) / Math.log(M));
      M = Math.ceil(N / Math.pow(M, height - 1));
    }
    node = createNode([]);
    node.leaf = false;
    node.height = height;
    const N2 = Math.ceil(N / M);
    const N1 = N2 * Math.ceil(Math.sqrt(M));
    multiSelect(items, left, right, N1, this.compareMinX);
    for (let i2 = left; i2 <= right; i2 += N1) {
      const right2 = Math.min(i2 + N1 - 1, right);
      multiSelect(items, i2, right2, N2, this.compareMinY);
      for (let j = i2; j <= right2; j += N2) {
        const right3 = Math.min(j + N2 - 1, right2);
        node.children.push(this._build(items, j, right3, height - 1));
      }
    }
    calcBBox(node, this.toBBox);
    return node;
  }
  _chooseSubtree(bbox2, node, level, path) {
    while (true) {
      path.push(node);
      if (node.leaf || path.length - 1 === level)
        break;
      let minArea = Infinity;
      let minEnlargement = Infinity;
      let targetNode;
      for (let i2 = 0; i2 < node.children.length; i2++) {
        const child = node.children[i2];
        const area2 = bboxArea(child);
        const enlargement = enlargedArea(bbox2, child) - area2;
        if (enlargement < minEnlargement) {
          minEnlargement = enlargement;
          minArea = area2 < minArea ? area2 : minArea;
          targetNode = child;
        } else if (enlargement === minEnlargement) {
          if (area2 < minArea) {
            minArea = area2;
            targetNode = child;
          }
        }
      }
      node = targetNode || node.children[0];
    }
    return node;
  }
  _insert(item, level, isNode) {
    const bbox2 = isNode ? item : this.toBBox(item);
    const insertPath = [];
    const node = this._chooseSubtree(bbox2, this.data, level, insertPath);
    node.children.push(item);
    extend(node, bbox2);
    while (level >= 0) {
      if (insertPath[level].children.length > this._maxEntries) {
        this._split(insertPath, level);
        level--;
      } else
        break;
    }
    this._adjustParentBBoxes(bbox2, insertPath, level);
  }
  _split(insertPath, level) {
    const node = insertPath[level];
    const M = node.children.length;
    const m = this._minEntries;
    this._chooseSplitAxis(node, m, M);
    const splitIndex = this._chooseSplitIndex(node, m, M);
    const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
    newNode.height = node.height;
    newNode.leaf = node.leaf;
    calcBBox(node, this.toBBox);
    calcBBox(newNode, this.toBBox);
    if (level)
      insertPath[level - 1].children.push(newNode);
    else
      this._splitRoot(node, newNode);
  }
  _splitRoot(node, newNode) {
    this.data = createNode([node, newNode]);
    this.data.height = node.height + 1;
    this.data.leaf = false;
    calcBBox(this.data, this.toBBox);
  }
  _chooseSplitIndex(node, m, M) {
    let index2;
    let minOverlap = Infinity;
    let minArea = Infinity;
    for (let i2 = m; i2 <= M - m; i2++) {
      const bbox1 = distBBox(node, 0, i2, this.toBBox);
      const bbox2 = distBBox(node, i2, M, this.toBBox);
      const overlap = intersectionArea(bbox1, bbox2);
      const area2 = bboxArea(bbox1) + bboxArea(bbox2);
      if (overlap < minOverlap) {
        minOverlap = overlap;
        index2 = i2;
        minArea = area2 < minArea ? area2 : minArea;
      } else if (overlap === minOverlap) {
        if (area2 < minArea) {
          minArea = area2;
          index2 = i2;
        }
      }
    }
    return index2 || M - m;
  }
  _chooseSplitAxis(node, m, M) {
    const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
    const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
    const xMargin = this._allDistMargin(node, m, M, compareMinX);
    const yMargin = this._allDistMargin(node, m, M, compareMinY);
    if (xMargin < yMargin)
      node.children.sort(compareMinX);
  }
  _allDistMargin(node, m, M, compare) {
    node.children.sort(compare);
    const toBBox = this.toBBox;
    const leftBBox = distBBox(node, 0, m, toBBox);
    const rightBBox = distBBox(node, M - m, M, toBBox);
    let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
    for (let i2 = m; i2 < M - m; i2++) {
      const child = node.children[i2];
      extend(leftBBox, node.leaf ? toBBox(child) : child);
      margin += bboxMargin(leftBBox);
    }
    for (let i2 = M - m - 1; i2 >= m; i2--) {
      const child = node.children[i2];
      extend(rightBBox, node.leaf ? toBBox(child) : child);
      margin += bboxMargin(rightBBox);
    }
    return margin;
  }
  _adjustParentBBoxes(bbox2, path, level) {
    for (let i2 = level; i2 >= 0; i2--) {
      extend(path[i2], bbox2);
    }
  }
  _condense(path) {
    for (let i2 = path.length - 1, siblings; i2 >= 0; i2--) {
      if (path[i2].children.length === 0) {
        if (i2 > 0) {
          siblings = path[i2 - 1].children;
          siblings.splice(siblings.indexOf(path[i2]), 1);
        } else
          this.clear();
      } else
        calcBBox(path[i2], this.toBBox);
    }
  }
};
function findItem(item, items, equalsFn) {
  if (!equalsFn)
    return items.indexOf(item);
  for (let i2 = 0; i2 < items.length; i2++) {
    if (equalsFn(item, items[i2]))
      return i2;
  }
  return -1;
}
function calcBBox(node, toBBox) {
  distBBox(node, 0, node.children.length, toBBox, node);
}
function distBBox(node, k, p2, toBBox, destNode) {
  if (!destNode)
    destNode = createNode(null);
  destNode.minX = Infinity;
  destNode.minY = Infinity;
  destNode.maxX = -Infinity;
  destNode.maxY = -Infinity;
  for (let i2 = k; i2 < p2; i2++) {
    const child = node.children[i2];
    extend(destNode, node.leaf ? toBBox(child) : child);
  }
  return destNode;
}
function extend(a4, b) {
  a4.minX = Math.min(a4.minX, b.minX);
  a4.minY = Math.min(a4.minY, b.minY);
  a4.maxX = Math.max(a4.maxX, b.maxX);
  a4.maxY = Math.max(a4.maxY, b.maxY);
  return a4;
}
function compareNodeMinX(a4, b) {
  return a4.minX - b.minX;
}
function compareNodeMinY(a4, b) {
  return a4.minY - b.minY;
}
function bboxArea(a4) {
  return (a4.maxX - a4.minX) * (a4.maxY - a4.minY);
}
function bboxMargin(a4) {
  return a4.maxX - a4.minX + (a4.maxY - a4.minY);
}
function enlargedArea(a4, b) {
  return (Math.max(b.maxX, a4.maxX) - Math.min(b.minX, a4.minX)) * (Math.max(b.maxY, a4.maxY) - Math.min(b.minY, a4.minY));
}
function intersectionArea(a4, b) {
  const minX = Math.max(a4.minX, b.minX);
  const minY = Math.max(a4.minY, b.minY);
  const maxX = Math.min(a4.maxX, b.maxX);
  const maxY = Math.min(a4.maxY, b.maxY);
  return Math.max(0, maxX - minX) * Math.max(0, maxY - minY);
}
function contains(a4, b) {
  return a4.minX <= b.minX && a4.minY <= b.minY && b.maxX <= a4.maxX && b.maxY <= a4.maxY;
}
function intersects2(a4, b) {
  return b.minX <= a4.maxX && b.minY <= a4.maxY && b.maxX >= a4.minX && b.maxY >= a4.minY;
}
function createNode(children) {
  return {
    children,
    height: 1,
    leaf: true,
    minX: Infinity,
    minY: Infinity,
    maxX: -Infinity,
    maxY: -Infinity
  };
}
function multiSelect(arr, left, right, n2, compare) {
  const stack = [left, right];
  while (stack.length) {
    right = stack.pop();
    left = stack.pop();
    if (right - left <= n2)
      continue;
    const mid = left + Math.ceil((right - left) / n2 / 2) * n2;
    quickselect(arr, mid, left, right, compare);
    stack.push(left, mid, mid, right);
  }
}

// node_modules/cesium/Source/Core/RectangleCollisionChecker.js
function RectangleCollisionChecker() {
  this._tree = new RBush();
}
function RectangleWithId() {
  this.minX = 0;
  this.minY = 0;
  this.maxX = 0;
  this.maxY = 0;
  this.id = "";
}
RectangleWithId.fromRectangleAndId = function(id, rectangle, result) {
  result.minX = rectangle.west;
  result.minY = rectangle.south;
  result.maxX = rectangle.east;
  result.maxY = rectangle.north;
  result.id = id;
  return result;
};
RectangleCollisionChecker.prototype.insert = function(id, rectangle) {
  Check_default.typeOf.string("id", id);
  Check_default.typeOf.object("rectangle", rectangle);
  const withId = RectangleWithId.fromRectangleAndId(
    id,
    rectangle,
    new RectangleWithId()
  );
  this._tree.insert(withId);
};
function idCompare(a4, b) {
  return a4.id === b.id;
}
var removalScratch = new RectangleWithId();
RectangleCollisionChecker.prototype.remove = function(id, rectangle) {
  Check_default.typeOf.string("id", id);
  Check_default.typeOf.object("rectangle", rectangle);
  const withId = RectangleWithId.fromRectangleAndId(
    id,
    rectangle,
    removalScratch
  );
  this._tree.remove(withId, idCompare);
};
var collisionScratch = new RectangleWithId();
RectangleCollisionChecker.prototype.collides = function(rectangle) {
  Check_default.typeOf.object("rectangle", rectangle);
  const withId = RectangleWithId.fromRectangleAndId(
    "",
    rectangle,
    collisionScratch
  );
  return this._tree.collides(withId);
};
var RectangleCollisionChecker_default = RectangleCollisionChecker;

// node_modules/cesium/Source/Core/RectangleGeometryLibrary.js
var cos3 = Math.cos;
var sin3 = Math.sin;
var sqrt = Math.sqrt;
var RectangleGeometryLibrary = {};
RectangleGeometryLibrary.computePosition = function(computedOptions, ellipsoid, computeST, row, col, position, st) {
  const radiiSquared = ellipsoid.radiiSquared;
  const nwCorner = computedOptions.nwCorner;
  const rectangle = computedOptions.boundingRectangle;
  let stLatitude = nwCorner.latitude - computedOptions.granYCos * row + col * computedOptions.granXSin;
  const cosLatitude = cos3(stLatitude);
  const nZ = sin3(stLatitude);
  const kZ = radiiSquared.z * nZ;
  let stLongitude = nwCorner.longitude + row * computedOptions.granYSin + col * computedOptions.granXCos;
  const nX = cosLatitude * cos3(stLongitude);
  const nY = cosLatitude * sin3(stLongitude);
  const kX = radiiSquared.x * nX;
  const kY = radiiSquared.y * nY;
  const gamma = sqrt(kX * nX + kY * nY + kZ * nZ);
  position.x = kX / gamma;
  position.y = kY / gamma;
  position.z = kZ / gamma;
  if (computeST) {
    const stNwCorner = computedOptions.stNwCorner;
    if (defined_default(stNwCorner)) {
      stLatitude = stNwCorner.latitude - computedOptions.stGranYCos * row + col * computedOptions.stGranXSin;
      stLongitude = stNwCorner.longitude + row * computedOptions.stGranYSin + col * computedOptions.stGranXCos;
      st.x = (stLongitude - computedOptions.stWest) * computedOptions.lonScalar;
      st.y = (stLatitude - computedOptions.stSouth) * computedOptions.latScalar;
    } else {
      st.x = (stLongitude - rectangle.west) * computedOptions.lonScalar;
      st.y = (stLatitude - rectangle.south) * computedOptions.latScalar;
    }
  }
};
var rotationMatrixScratch = new Matrix2_default();
var nwCartesian = new Cartesian3_default();
var centerScratch3 = new Cartographic_default();
var centerCartesian = new Cartesian3_default();
var proj = new GeographicProjection_default();
function getRotationOptions(nwCorner, rotation, granularityX, granularityY, center, width, height) {
  const cosRotation = Math.cos(rotation);
  const granYCos = granularityY * cosRotation;
  const granXCos = granularityX * cosRotation;
  const sinRotation = Math.sin(rotation);
  const granYSin = granularityY * sinRotation;
  const granXSin = granularityX * sinRotation;
  nwCartesian = proj.project(nwCorner, nwCartesian);
  nwCartesian = Cartesian3_default.subtract(nwCartesian, centerCartesian, nwCartesian);
  const rotationMatrix = Matrix2_default.fromRotation(rotation, rotationMatrixScratch);
  nwCartesian = Matrix2_default.multiplyByVector(
    rotationMatrix,
    nwCartesian,
    nwCartesian
  );
  nwCartesian = Cartesian3_default.add(nwCartesian, centerCartesian, nwCartesian);
  nwCorner = proj.unproject(nwCartesian, nwCorner);
  width -= 1;
  height -= 1;
  const latitude = nwCorner.latitude;
  const latitude0 = latitude + width * granXSin;
  const latitude1 = latitude - granYCos * height;
  const latitude2 = latitude - granYCos * height + width * granXSin;
  const north = Math.max(latitude, latitude0, latitude1, latitude2);
  const south = Math.min(latitude, latitude0, latitude1, latitude2);
  const longitude = nwCorner.longitude;
  const longitude0 = longitude + width * granXCos;
  const longitude1 = longitude + height * granYSin;
  const longitude2 = longitude + height * granYSin + width * granXCos;
  const east = Math.max(longitude, longitude0, longitude1, longitude2);
  const west = Math.min(longitude, longitude0, longitude1, longitude2);
  return {
    north,
    south,
    east,
    west,
    granYCos,
    granYSin,
    granXCos,
    granXSin,
    nwCorner
  };
}
RectangleGeometryLibrary.computeOptions = function(rectangle, granularity, rotation, stRotation, boundingRectangleScratch2, nwCornerResult, stNwCornerResult) {
  let east = rectangle.east;
  let west = rectangle.west;
  let north = rectangle.north;
  let south = rectangle.south;
  let northCap = false;
  let southCap = false;
  if (north === Math_default.PI_OVER_TWO) {
    northCap = true;
  }
  if (south === -Math_default.PI_OVER_TWO) {
    southCap = true;
  }
  let dx;
  const dy = north - south;
  if (west > east) {
    dx = Math_default.TWO_PI - west + east;
  } else {
    dx = east - west;
  }
  const width = Math.ceil(dx / granularity) + 1;
  const height = Math.ceil(dy / granularity) + 1;
  const granularityX = dx / (width - 1);
  const granularityY = dy / (height - 1);
  const nwCorner = Rectangle_default.northwest(rectangle, nwCornerResult);
  const center = Rectangle_default.center(rectangle, centerScratch3);
  if (rotation !== 0 || stRotation !== 0) {
    if (center.longitude < nwCorner.longitude) {
      center.longitude += Math_default.TWO_PI;
    }
    centerCartesian = proj.project(center, centerCartesian);
  }
  const granYCos = granularityY;
  const granXCos = granularityX;
  const granYSin = 0;
  const granXSin = 0;
  const boundingRectangle = Rectangle_default.clone(
    rectangle,
    boundingRectangleScratch2
  );
  const computedOptions = {
    granYCos,
    granYSin,
    granXCos,
    granXSin,
    nwCorner,
    boundingRectangle,
    width,
    height,
    northCap,
    southCap
  };
  if (rotation !== 0) {
    const rotationOptions = getRotationOptions(
      nwCorner,
      rotation,
      granularityX,
      granularityY,
      center,
      width,
      height
    );
    north = rotationOptions.north;
    south = rotationOptions.south;
    east = rotationOptions.east;
    west = rotationOptions.west;
    if (north < -Math_default.PI_OVER_TWO || north > Math_default.PI_OVER_TWO || south < -Math_default.PI_OVER_TWO || south > Math_default.PI_OVER_TWO) {
      throw new DeveloperError_default(
        "Rotated rectangle is invalid.  It crosses over either the north or south pole."
      );
    }
    computedOptions.granYCos = rotationOptions.granYCos;
    computedOptions.granYSin = rotationOptions.granYSin;
    computedOptions.granXCos = rotationOptions.granXCos;
    computedOptions.granXSin = rotationOptions.granXSin;
    boundingRectangle.north = north;
    boundingRectangle.south = south;
    boundingRectangle.east = east;
    boundingRectangle.west = west;
  }
  if (stRotation !== 0) {
    rotation = rotation - stRotation;
    const stNwCorner = Rectangle_default.northwest(boundingRectangle, stNwCornerResult);
    const stRotationOptions = getRotationOptions(
      stNwCorner,
      rotation,
      granularityX,
      granularityY,
      center,
      width,
      height
    );
    computedOptions.stGranYCos = stRotationOptions.granYCos;
    computedOptions.stGranXCos = stRotationOptions.granXCos;
    computedOptions.stGranYSin = stRotationOptions.granYSin;
    computedOptions.stGranXSin = stRotationOptions.granXSin;
    computedOptions.stNwCorner = stNwCorner;
    computedOptions.stWest = stRotationOptions.west;
    computedOptions.stSouth = stRotationOptions.south;
  }
  return computedOptions;
};
var RectangleGeometryLibrary_default = RectangleGeometryLibrary;

// node_modules/cesium/Source/Core/RectangleGeometry.js
var positionScratch3 = new Cartesian3_default();
var normalScratch4 = new Cartesian3_default();
var tangentScratch2 = new Cartesian3_default();
var bitangentScratch2 = new Cartesian3_default();
var rectangleScratch3 = new Rectangle_default();
var stScratch2 = new Cartesian2_default();
var bottomBoundingSphere3 = new BoundingSphere_default();
var topBoundingSphere3 = new BoundingSphere_default();
function createAttributes(vertexFormat, attributes) {
  const geo = new Geometry_default({
    attributes: new GeometryAttributes_default(),
    primitiveType: PrimitiveType_default.TRIANGLES
  });
  geo.attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: attributes.positions
  });
  if (vertexFormat.normal) {
    geo.attributes.normal = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: attributes.normals
    });
  }
  if (vertexFormat.tangent) {
    geo.attributes.tangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: attributes.tangents
    });
  }
  if (vertexFormat.bitangent) {
    geo.attributes.bitangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: attributes.bitangents
    });
  }
  return geo;
}
function calculateAttributes(positions, vertexFormat, ellipsoid, tangentRotationMatrix) {
  const length3 = positions.length;
  const normals = vertexFormat.normal ? new Float32Array(length3) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(length3) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(length3) : void 0;
  let attrIndex = 0;
  const bitangent = bitangentScratch2;
  const tangent = tangentScratch2;
  let normal2 = normalScratch4;
  if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent) {
    for (let i2 = 0; i2 < length3; i2 += 3) {
      const p2 = Cartesian3_default.fromArray(positions, i2, positionScratch3);
      const attrIndex1 = attrIndex + 1;
      const attrIndex2 = attrIndex + 2;
      normal2 = ellipsoid.geodeticSurfaceNormal(p2, normal2);
      if (vertexFormat.tangent || vertexFormat.bitangent) {
        Cartesian3_default.cross(Cartesian3_default.UNIT_Z, normal2, tangent);
        Matrix3_default.multiplyByVector(tangentRotationMatrix, tangent, tangent);
        Cartesian3_default.normalize(tangent, tangent);
        if (vertexFormat.bitangent) {
          Cartesian3_default.normalize(
            Cartesian3_default.cross(normal2, tangent, bitangent),
            bitangent
          );
        }
      }
      if (vertexFormat.normal) {
        normals[attrIndex] = normal2.x;
        normals[attrIndex1] = normal2.y;
        normals[attrIndex2] = normal2.z;
      }
      if (vertexFormat.tangent) {
        tangents[attrIndex] = tangent.x;
        tangents[attrIndex1] = tangent.y;
        tangents[attrIndex2] = tangent.z;
      }
      if (vertexFormat.bitangent) {
        bitangents[attrIndex] = bitangent.x;
        bitangents[attrIndex1] = bitangent.y;
        bitangents[attrIndex2] = bitangent.z;
      }
      attrIndex += 3;
    }
  }
  return createAttributes(vertexFormat, {
    positions,
    normals,
    tangents,
    bitangents
  });
}
var v1Scratch = new Cartesian3_default();
var v2Scratch = new Cartesian3_default();
function calculateAttributesWall(positions, vertexFormat, ellipsoid) {
  const length3 = positions.length;
  const normals = vertexFormat.normal ? new Float32Array(length3) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(length3) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(length3) : void 0;
  let normalIndex = 0;
  let tangentIndex = 0;
  let bitangentIndex = 0;
  let recomputeNormal = true;
  let bitangent = bitangentScratch2;
  let tangent = tangentScratch2;
  let normal2 = normalScratch4;
  if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent) {
    for (let i2 = 0; i2 < length3; i2 += 6) {
      const p2 = Cartesian3_default.fromArray(positions, i2, positionScratch3);
      const p1 = Cartesian3_default.fromArray(positions, (i2 + 6) % length3, v1Scratch);
      if (recomputeNormal) {
        const p22 = Cartesian3_default.fromArray(positions, (i2 + 3) % length3, v2Scratch);
        Cartesian3_default.subtract(p1, p2, p1);
        Cartesian3_default.subtract(p22, p2, p22);
        normal2 = Cartesian3_default.normalize(Cartesian3_default.cross(p22, p1, normal2), normal2);
        recomputeNormal = false;
      }
      if (Cartesian3_default.equalsEpsilon(p1, p2, Math_default.EPSILON10)) {
        recomputeNormal = true;
      }
      if (vertexFormat.tangent || vertexFormat.bitangent) {
        bitangent = ellipsoid.geodeticSurfaceNormal(p2, bitangent);
        if (vertexFormat.tangent) {
          tangent = Cartesian3_default.normalize(
            Cartesian3_default.cross(bitangent, normal2, tangent),
            tangent
          );
        }
      }
      if (vertexFormat.normal) {
        normals[normalIndex++] = normal2.x;
        normals[normalIndex++] = normal2.y;
        normals[normalIndex++] = normal2.z;
        normals[normalIndex++] = normal2.x;
        normals[normalIndex++] = normal2.y;
        normals[normalIndex++] = normal2.z;
      }
      if (vertexFormat.tangent) {
        tangents[tangentIndex++] = tangent.x;
        tangents[tangentIndex++] = tangent.y;
        tangents[tangentIndex++] = tangent.z;
        tangents[tangentIndex++] = tangent.x;
        tangents[tangentIndex++] = tangent.y;
        tangents[tangentIndex++] = tangent.z;
      }
      if (vertexFormat.bitangent) {
        bitangents[bitangentIndex++] = bitangent.x;
        bitangents[bitangentIndex++] = bitangent.y;
        bitangents[bitangentIndex++] = bitangent.z;
        bitangents[bitangentIndex++] = bitangent.x;
        bitangents[bitangentIndex++] = bitangent.y;
        bitangents[bitangentIndex++] = bitangent.z;
      }
    }
  }
  return createAttributes(vertexFormat, {
    positions,
    normals,
    tangents,
    bitangents
  });
}
function constructRectangle(rectangleGeometry, computedOptions) {
  const vertexFormat = rectangleGeometry._vertexFormat;
  const ellipsoid = rectangleGeometry._ellipsoid;
  const height = computedOptions.height;
  const width = computedOptions.width;
  const northCap = computedOptions.northCap;
  const southCap = computedOptions.southCap;
  let rowStart = 0;
  let rowEnd = height;
  let rowHeight = height;
  let size = 0;
  if (northCap) {
    rowStart = 1;
    rowHeight -= 1;
    size += 1;
  }
  if (southCap) {
    rowEnd -= 1;
    rowHeight -= 1;
    size += 1;
  }
  size += width * rowHeight;
  const positions = vertexFormat.position ? new Float64Array(size * 3) : void 0;
  const textureCoordinates = vertexFormat.st ? new Float32Array(size * 2) : void 0;
  let posIndex = 0;
  let stIndex = 0;
  const position = positionScratch3;
  const st = stScratch2;
  let minX = Number.MAX_VALUE;
  let minY = Number.MAX_VALUE;
  let maxX = -Number.MAX_VALUE;
  let maxY = -Number.MAX_VALUE;
  for (let row = rowStart; row < rowEnd; ++row) {
    for (let col = 0; col < width; ++col) {
      RectangleGeometryLibrary_default.computePosition(
        computedOptions,
        ellipsoid,
        vertexFormat.st,
        row,
        col,
        position,
        st
      );
      positions[posIndex++] = position.x;
      positions[posIndex++] = position.y;
      positions[posIndex++] = position.z;
      if (vertexFormat.st) {
        textureCoordinates[stIndex++] = st.x;
        textureCoordinates[stIndex++] = st.y;
        minX = Math.min(minX, st.x);
        minY = Math.min(minY, st.y);
        maxX = Math.max(maxX, st.x);
        maxY = Math.max(maxY, st.y);
      }
    }
  }
  if (northCap) {
    RectangleGeometryLibrary_default.computePosition(
      computedOptions,
      ellipsoid,
      vertexFormat.st,
      0,
      0,
      position,
      st
    );
    positions[posIndex++] = position.x;
    positions[posIndex++] = position.y;
    positions[posIndex++] = position.z;
    if (vertexFormat.st) {
      textureCoordinates[stIndex++] = st.x;
      textureCoordinates[stIndex++] = st.y;
      minX = st.x;
      minY = st.y;
      maxX = st.x;
      maxY = st.y;
    }
  }
  if (southCap) {
    RectangleGeometryLibrary_default.computePosition(
      computedOptions,
      ellipsoid,
      vertexFormat.st,
      height - 1,
      0,
      position,
      st
    );
    positions[posIndex++] = position.x;
    positions[posIndex++] = position.y;
    positions[posIndex] = position.z;
    if (vertexFormat.st) {
      textureCoordinates[stIndex++] = st.x;
      textureCoordinates[stIndex] = st.y;
      minX = Math.min(minX, st.x);
      minY = Math.min(minY, st.y);
      maxX = Math.max(maxX, st.x);
      maxY = Math.max(maxY, st.y);
    }
  }
  if (vertexFormat.st && (minX < 0 || minY < 0 || maxX > 1 || maxY > 1)) {
    for (let k = 0; k < textureCoordinates.length; k += 2) {
      textureCoordinates[k] = (textureCoordinates[k] - minX) / (maxX - minX);
      textureCoordinates[k + 1] = (textureCoordinates[k + 1] - minY) / (maxY - minY);
    }
  }
  const geo = calculateAttributes(
    positions,
    vertexFormat,
    ellipsoid,
    computedOptions.tangentRotationMatrix
  );
  let indicesSize = 6 * (width - 1) * (rowHeight - 1);
  if (northCap) {
    indicesSize += 3 * (width - 1);
  }
  if (southCap) {
    indicesSize += 3 * (width - 1);
  }
  const indices2 = IndexDatatype_default.createTypedArray(size, indicesSize);
  let index2 = 0;
  let indicesIndex = 0;
  let i2;
  for (i2 = 0; i2 < rowHeight - 1; ++i2) {
    for (let j = 0; j < width - 1; ++j) {
      const upperLeft = index2;
      const lowerLeft = upperLeft + width;
      const lowerRight = lowerLeft + 1;
      const upperRight = upperLeft + 1;
      indices2[indicesIndex++] = upperLeft;
      indices2[indicesIndex++] = lowerLeft;
      indices2[indicesIndex++] = upperRight;
      indices2[indicesIndex++] = upperRight;
      indices2[indicesIndex++] = lowerLeft;
      indices2[indicesIndex++] = lowerRight;
      ++index2;
    }
    ++index2;
  }
  if (northCap || southCap) {
    let northIndex = size - 1;
    const southIndex = size - 1;
    if (northCap && southCap) {
      northIndex = size - 2;
    }
    let p1;
    let p2;
    index2 = 0;
    if (northCap) {
      for (i2 = 0; i2 < width - 1; i2++) {
        p1 = index2;
        p2 = p1 + 1;
        indices2[indicesIndex++] = northIndex;
        indices2[indicesIndex++] = p1;
        indices2[indicesIndex++] = p2;
        ++index2;
      }
    }
    if (southCap) {
      index2 = (rowHeight - 1) * width;
      for (i2 = 0; i2 < width - 1; i2++) {
        p1 = index2;
        p2 = p1 + 1;
        indices2[indicesIndex++] = p1;
        indices2[indicesIndex++] = southIndex;
        indices2[indicesIndex++] = p2;
        ++index2;
      }
    }
  }
  geo.indices = indices2;
  if (vertexFormat.st) {
    geo.attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: textureCoordinates
    });
  }
  return geo;
}
function addWallPositions2(wallPositions, posIndex, i2, topPositions, bottomPositions) {
  wallPositions[posIndex++] = topPositions[i2];
  wallPositions[posIndex++] = topPositions[i2 + 1];
  wallPositions[posIndex++] = topPositions[i2 + 2];
  wallPositions[posIndex++] = bottomPositions[i2];
  wallPositions[posIndex++] = bottomPositions[i2 + 1];
  wallPositions[posIndex] = bottomPositions[i2 + 2];
  return wallPositions;
}
function addWallTextureCoordinates(wallTextures, stIndex, i2, st) {
  wallTextures[stIndex++] = st[i2];
  wallTextures[stIndex++] = st[i2 + 1];
  wallTextures[stIndex++] = st[i2];
  wallTextures[stIndex] = st[i2 + 1];
  return wallTextures;
}
var scratchVertexFormat12 = new VertexFormat_default();
function constructExtrudedRectangle(rectangleGeometry, computedOptions) {
  const shadowVolume = rectangleGeometry._shadowVolume;
  const offsetAttributeValue = rectangleGeometry._offsetAttribute;
  const vertexFormat = rectangleGeometry._vertexFormat;
  const minHeight = rectangleGeometry._extrudedHeight;
  const maxHeight = rectangleGeometry._surfaceHeight;
  const ellipsoid = rectangleGeometry._ellipsoid;
  const height = computedOptions.height;
  const width = computedOptions.width;
  let i2;
  if (shadowVolume) {
    const newVertexFormat = VertexFormat_default.clone(
      vertexFormat,
      scratchVertexFormat12
    );
    newVertexFormat.normal = true;
    rectangleGeometry._vertexFormat = newVertexFormat;
  }
  const topBottomGeo = constructRectangle(rectangleGeometry, computedOptions);
  if (shadowVolume) {
    rectangleGeometry._vertexFormat = vertexFormat;
  }
  let topPositions = PolygonPipeline_default.scaleToGeodeticHeight(
    topBottomGeo.attributes.position.values,
    maxHeight,
    ellipsoid,
    false
  );
  topPositions = new Float64Array(topPositions);
  let length3 = topPositions.length;
  const newLength = length3 * 2;
  const positions = new Float64Array(newLength);
  positions.set(topPositions);
  const bottomPositions = PolygonPipeline_default.scaleToGeodeticHeight(
    topBottomGeo.attributes.position.values,
    minHeight,
    ellipsoid
  );
  positions.set(bottomPositions, length3);
  topBottomGeo.attributes.position.values = positions;
  const normals = vertexFormat.normal ? new Float32Array(newLength) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(newLength) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(newLength) : void 0;
  const textures = vertexFormat.st ? new Float32Array(newLength / 3 * 2) : void 0;
  let topSt;
  let topNormals;
  if (vertexFormat.normal) {
    topNormals = topBottomGeo.attributes.normal.values;
    normals.set(topNormals);
    for (i2 = 0; i2 < length3; i2++) {
      topNormals[i2] = -topNormals[i2];
    }
    normals.set(topNormals, length3);
    topBottomGeo.attributes.normal.values = normals;
  }
  if (shadowVolume) {
    topNormals = topBottomGeo.attributes.normal.values;
    if (!vertexFormat.normal) {
      topBottomGeo.attributes.normal = void 0;
    }
    const extrudeNormals = new Float32Array(newLength);
    for (i2 = 0; i2 < length3; i2++) {
      topNormals[i2] = -topNormals[i2];
    }
    extrudeNormals.set(topNormals, length3);
    topBottomGeo.attributes.extrudeDirection = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: extrudeNormals
    });
  }
  let offsetValue;
  const hasOffsets = defined_default(offsetAttributeValue);
  if (hasOffsets) {
    const size = length3 / 3 * 2;
    let offsetAttribute = new Uint8Array(size);
    if (offsetAttributeValue === GeometryOffsetAttribute_default.TOP) {
      offsetAttribute = arrayFill_default(offsetAttribute, 1, 0, size / 2);
    } else {
      offsetValue = offsetAttributeValue === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      offsetAttribute = arrayFill_default(offsetAttribute, offsetValue);
    }
    topBottomGeo.attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: offsetAttribute
    });
  }
  if (vertexFormat.tangent) {
    const topTangents = topBottomGeo.attributes.tangent.values;
    tangents.set(topTangents);
    for (i2 = 0; i2 < length3; i2++) {
      topTangents[i2] = -topTangents[i2];
    }
    tangents.set(topTangents, length3);
    topBottomGeo.attributes.tangent.values = tangents;
  }
  if (vertexFormat.bitangent) {
    const topBitangents = topBottomGeo.attributes.bitangent.values;
    bitangents.set(topBitangents);
    bitangents.set(topBitangents, length3);
    topBottomGeo.attributes.bitangent.values = bitangents;
  }
  if (vertexFormat.st) {
    topSt = topBottomGeo.attributes.st.values;
    textures.set(topSt);
    textures.set(topSt, length3 / 3 * 2);
    topBottomGeo.attributes.st.values = textures;
  }
  const indices2 = topBottomGeo.indices;
  const indicesLength = indices2.length;
  const posLength = length3 / 3;
  const newIndices = IndexDatatype_default.createTypedArray(
    newLength / 3,
    indicesLength * 2
  );
  newIndices.set(indices2);
  for (i2 = 0; i2 < indicesLength; i2 += 3) {
    newIndices[i2 + indicesLength] = indices2[i2 + 2] + posLength;
    newIndices[i2 + 1 + indicesLength] = indices2[i2 + 1] + posLength;
    newIndices[i2 + 2 + indicesLength] = indices2[i2] + posLength;
  }
  topBottomGeo.indices = newIndices;
  const northCap = computedOptions.northCap;
  const southCap = computedOptions.southCap;
  let rowHeight = height;
  let widthMultiplier = 2;
  let perimeterPositions = 0;
  let corners = 4;
  let dupliateCorners = 4;
  if (northCap) {
    widthMultiplier -= 1;
    rowHeight -= 1;
    perimeterPositions += 1;
    corners -= 2;
    dupliateCorners -= 1;
  }
  if (southCap) {
    widthMultiplier -= 1;
    rowHeight -= 1;
    perimeterPositions += 1;
    corners -= 2;
    dupliateCorners -= 1;
  }
  perimeterPositions += widthMultiplier * width + 2 * rowHeight - corners;
  const wallCount = (perimeterPositions + dupliateCorners) * 2;
  let wallPositions = new Float64Array(wallCount * 3);
  const wallExtrudeNormals = shadowVolume ? new Float32Array(wallCount * 3) : void 0;
  let wallOffsetAttribute = hasOffsets ? new Uint8Array(wallCount) : void 0;
  let wallTextures = vertexFormat.st ? new Float32Array(wallCount * 2) : void 0;
  const computeTopOffsets = offsetAttributeValue === GeometryOffsetAttribute_default.TOP;
  if (hasOffsets && !computeTopOffsets) {
    offsetValue = offsetAttributeValue === GeometryOffsetAttribute_default.ALL ? 1 : 0;
    wallOffsetAttribute = arrayFill_default(wallOffsetAttribute, offsetValue);
  }
  let posIndex = 0;
  let stIndex = 0;
  let extrudeNormalIndex = 0;
  let wallOffsetIndex = 0;
  const area2 = width * rowHeight;
  let threeI;
  for (i2 = 0; i2 < area2; i2 += width) {
    threeI = i2 * 3;
    wallPositions = addWallPositions2(
      wallPositions,
      posIndex,
      threeI,
      topPositions,
      bottomPositions
    );
    posIndex += 6;
    if (vertexFormat.st) {
      wallTextures = addWallTextureCoordinates(
        wallTextures,
        stIndex,
        i2 * 2,
        topSt
      );
      stIndex += 4;
    }
    if (shadowVolume) {
      extrudeNormalIndex += 3;
      wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI];
      wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 1];
      wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 2];
    }
    if (computeTopOffsets) {
      wallOffsetAttribute[wallOffsetIndex++] = 1;
      wallOffsetIndex += 1;
    }
  }
  if (!southCap) {
    for (i2 = area2 - width; i2 < area2; i2++) {
      threeI = i2 * 3;
      wallPositions = addWallPositions2(
        wallPositions,
        posIndex,
        threeI,
        topPositions,
        bottomPositions
      );
      posIndex += 6;
      if (vertexFormat.st) {
        wallTextures = addWallTextureCoordinates(
          wallTextures,
          stIndex,
          i2 * 2,
          topSt
        );
        stIndex += 4;
      }
      if (shadowVolume) {
        extrudeNormalIndex += 3;
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI];
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 1];
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 2];
      }
      if (computeTopOffsets) {
        wallOffsetAttribute[wallOffsetIndex++] = 1;
        wallOffsetIndex += 1;
      }
    }
  } else {
    const southIndex = northCap ? area2 + 1 : area2;
    threeI = southIndex * 3;
    for (i2 = 0; i2 < 2; i2++) {
      wallPositions = addWallPositions2(
        wallPositions,
        posIndex,
        threeI,
        topPositions,
        bottomPositions
      );
      posIndex += 6;
      if (vertexFormat.st) {
        wallTextures = addWallTextureCoordinates(
          wallTextures,
          stIndex,
          southIndex * 2,
          topSt
        );
        stIndex += 4;
      }
      if (shadowVolume) {
        extrudeNormalIndex += 3;
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI];
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 1];
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 2];
      }
      if (computeTopOffsets) {
        wallOffsetAttribute[wallOffsetIndex++] = 1;
        wallOffsetIndex += 1;
      }
    }
  }
  for (i2 = area2 - 1; i2 > 0; i2 -= width) {
    threeI = i2 * 3;
    wallPositions = addWallPositions2(
      wallPositions,
      posIndex,
      threeI,
      topPositions,
      bottomPositions
    );
    posIndex += 6;
    if (vertexFormat.st) {
      wallTextures = addWallTextureCoordinates(
        wallTextures,
        stIndex,
        i2 * 2,
        topSt
      );
      stIndex += 4;
    }
    if (shadowVolume) {
      extrudeNormalIndex += 3;
      wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI];
      wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 1];
      wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 2];
    }
    if (computeTopOffsets) {
      wallOffsetAttribute[wallOffsetIndex++] = 1;
      wallOffsetIndex += 1;
    }
  }
  if (!northCap) {
    for (i2 = width - 1; i2 >= 0; i2--) {
      threeI = i2 * 3;
      wallPositions = addWallPositions2(
        wallPositions,
        posIndex,
        threeI,
        topPositions,
        bottomPositions
      );
      posIndex += 6;
      if (vertexFormat.st) {
        wallTextures = addWallTextureCoordinates(
          wallTextures,
          stIndex,
          i2 * 2,
          topSt
        );
        stIndex += 4;
      }
      if (shadowVolume) {
        extrudeNormalIndex += 3;
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI];
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 1];
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 2];
      }
      if (computeTopOffsets) {
        wallOffsetAttribute[wallOffsetIndex++] = 1;
        wallOffsetIndex += 1;
      }
    }
  } else {
    const northIndex = area2;
    threeI = northIndex * 3;
    for (i2 = 0; i2 < 2; i2++) {
      wallPositions = addWallPositions2(
        wallPositions,
        posIndex,
        threeI,
        topPositions,
        bottomPositions
      );
      posIndex += 6;
      if (vertexFormat.st) {
        wallTextures = addWallTextureCoordinates(
          wallTextures,
          stIndex,
          northIndex * 2,
          topSt
        );
        stIndex += 4;
      }
      if (shadowVolume) {
        extrudeNormalIndex += 3;
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI];
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 1];
        wallExtrudeNormals[extrudeNormalIndex++] = topNormals[threeI + 2];
      }
      if (computeTopOffsets) {
        wallOffsetAttribute[wallOffsetIndex++] = 1;
        wallOffsetIndex += 1;
      }
    }
  }
  let geo = calculateAttributesWall(wallPositions, vertexFormat, ellipsoid);
  if (vertexFormat.st) {
    geo.attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: wallTextures
    });
  }
  if (shadowVolume) {
    geo.attributes.extrudeDirection = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: wallExtrudeNormals
    });
  }
  if (hasOffsets) {
    geo.attributes.applyOffset = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: wallOffsetAttribute
    });
  }
  const wallIndices = IndexDatatype_default.createTypedArray(
    wallCount,
    perimeterPositions * 6
  );
  let upperLeft;
  let lowerLeft;
  let lowerRight;
  let upperRight;
  length3 = wallPositions.length / 3;
  let index2 = 0;
  for (i2 = 0; i2 < length3 - 1; i2 += 2) {
    upperLeft = i2;
    upperRight = (upperLeft + 2) % length3;
    const p1 = Cartesian3_default.fromArray(wallPositions, upperLeft * 3, v1Scratch);
    const p2 = Cartesian3_default.fromArray(wallPositions, upperRight * 3, v2Scratch);
    if (Cartesian3_default.equalsEpsilon(p1, p2, Math_default.EPSILON10)) {
      continue;
    }
    lowerLeft = (upperLeft + 1) % length3;
    lowerRight = (lowerLeft + 2) % length3;
    wallIndices[index2++] = upperLeft;
    wallIndices[index2++] = lowerLeft;
    wallIndices[index2++] = upperRight;
    wallIndices[index2++] = upperRight;
    wallIndices[index2++] = lowerLeft;
    wallIndices[index2++] = lowerRight;
  }
  geo.indices = wallIndices;
  geo = GeometryPipeline_default.combineInstances([
    new GeometryInstance_default({
      geometry: topBottomGeo
    }),
    new GeometryInstance_default({
      geometry: geo
    })
  ]);
  return geo[0];
}
var scratchRectanglePoints = [
  new Cartesian3_default(),
  new Cartesian3_default(),
  new Cartesian3_default(),
  new Cartesian3_default()
];
var nwScratch = new Cartographic_default();
var stNwScratch = new Cartographic_default();
function computeRectangle4(rectangle, granularity, rotation, ellipsoid, result) {
  if (rotation === 0) {
    return Rectangle_default.clone(rectangle, result);
  }
  const computedOptions = RectangleGeometryLibrary_default.computeOptions(
    rectangle,
    granularity,
    rotation,
    0,
    rectangleScratch3,
    nwScratch
  );
  const height = computedOptions.height;
  const width = computedOptions.width;
  const positions = scratchRectanglePoints;
  RectangleGeometryLibrary_default.computePosition(
    computedOptions,
    ellipsoid,
    false,
    0,
    0,
    positions[0]
  );
  RectangleGeometryLibrary_default.computePosition(
    computedOptions,
    ellipsoid,
    false,
    0,
    width - 1,
    positions[1]
  );
  RectangleGeometryLibrary_default.computePosition(
    computedOptions,
    ellipsoid,
    false,
    height - 1,
    0,
    positions[2]
  );
  RectangleGeometryLibrary_default.computePosition(
    computedOptions,
    ellipsoid,
    false,
    height - 1,
    width - 1,
    positions[3]
  );
  return Rectangle_default.fromCartesianArray(positions, ellipsoid, result);
}
function RectangleGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const rectangle = options.rectangle;
  Check_default.typeOf.object("rectangle", rectangle);
  Rectangle_default.validate(rectangle);
  if (rectangle.north < rectangle.south) {
    throw new DeveloperError_default(
      "options.rectangle.north must be greater than or equal to options.rectangle.south"
    );
  }
  const height = defaultValue_default(options.height, 0);
  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
  this._rectangle = Rectangle_default.clone(rectangle);
  this._granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  this._ellipsoid = Ellipsoid_default.clone(
    defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
  );
  this._surfaceHeight = Math.max(height, extrudedHeight);
  this._rotation = defaultValue_default(options.rotation, 0);
  this._stRotation = defaultValue_default(options.stRotation, 0);
  this._vertexFormat = VertexFormat_default.clone(
    defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT)
  );
  this._extrudedHeight = Math.min(height, extrudedHeight);
  this._shadowVolume = defaultValue_default(options.shadowVolume, false);
  this._workerName = "createRectangleGeometry";
  this._offsetAttribute = options.offsetAttribute;
  this._rotatedRectangle = void 0;
  this._textureCoordinateRotationPoints = void 0;
}
RectangleGeometry.packedLength = Rectangle_default.packedLength + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 7;
RectangleGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  Rectangle_default.pack(value._rectangle, array, startingIndex);
  startingIndex += Rectangle_default.packedLength;
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex++] = value._granularity;
  array[startingIndex++] = value._surfaceHeight;
  array[startingIndex++] = value._rotation;
  array[startingIndex++] = value._stRotation;
  array[startingIndex++] = value._extrudedHeight;
  array[startingIndex++] = value._shadowVolume ? 1 : 0;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchRectangle = new Rectangle_default();
var scratchEllipsoid11 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchOptions19 = {
  rectangle: scratchRectangle,
  ellipsoid: scratchEllipsoid11,
  vertexFormat: scratchVertexFormat12,
  granularity: void 0,
  height: void 0,
  rotation: void 0,
  stRotation: void 0,
  extrudedHeight: void 0,
  shadowVolume: void 0,
  offsetAttribute: void 0
};
RectangleGeometry.unpack = function(array, startingIndex, result) {
  Check_default.defined("array", array);
  startingIndex = defaultValue_default(startingIndex, 0);
  const rectangle = Rectangle_default.unpack(array, startingIndex, scratchRectangle);
  startingIndex += Rectangle_default.packedLength;
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid11);
  startingIndex += Ellipsoid_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat12
  );
  startingIndex += VertexFormat_default.packedLength;
  const granularity = array[startingIndex++];
  const surfaceHeight = array[startingIndex++];
  const rotation = array[startingIndex++];
  const stRotation = array[startingIndex++];
  const extrudedHeight = array[startingIndex++];
  const shadowVolume = array[startingIndex++] === 1;
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions19.granularity = granularity;
    scratchOptions19.height = surfaceHeight;
    scratchOptions19.rotation = rotation;
    scratchOptions19.stRotation = stRotation;
    scratchOptions19.extrudedHeight = extrudedHeight;
    scratchOptions19.shadowVolume = shadowVolume;
    scratchOptions19.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new RectangleGeometry(scratchOptions19);
  }
  result._rectangle = Rectangle_default.clone(rectangle, result._rectangle);
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._granularity = granularity;
  result._surfaceHeight = surfaceHeight;
  result._rotation = rotation;
  result._stRotation = stRotation;
  result._extrudedHeight = extrudedHeight;
  result._shadowVolume = shadowVolume;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
RectangleGeometry.computeRectangle = function(options, result) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const rectangle = options.rectangle;
  Check_default.typeOf.object("rectangle", rectangle);
  Rectangle_default.validate(rectangle);
  if (rectangle.north < rectangle.south) {
    throw new DeveloperError_default(
      "options.rectangle.north must be greater than or equal to options.rectangle.south"
    );
  }
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  const rotation = defaultValue_default(options.rotation, 0);
  return computeRectangle4(rectangle, granularity, rotation, ellipsoid, result);
};
var tangentRotationMatrixScratch = new Matrix3_default();
var quaternionScratch4 = new Quaternion_default();
var centerScratch4 = new Cartographic_default();
RectangleGeometry.createGeometry = function(rectangleGeometry) {
  if (Math_default.equalsEpsilon(
    rectangleGeometry._rectangle.north,
    rectangleGeometry._rectangle.south,
    Math_default.EPSILON10
  ) || Math_default.equalsEpsilon(
    rectangleGeometry._rectangle.east,
    rectangleGeometry._rectangle.west,
    Math_default.EPSILON10
  )) {
    return void 0;
  }
  let rectangle = rectangleGeometry._rectangle;
  const ellipsoid = rectangleGeometry._ellipsoid;
  const rotation = rectangleGeometry._rotation;
  const stRotation = rectangleGeometry._stRotation;
  const vertexFormat = rectangleGeometry._vertexFormat;
  const computedOptions = RectangleGeometryLibrary_default.computeOptions(
    rectangle,
    rectangleGeometry._granularity,
    rotation,
    stRotation,
    rectangleScratch3,
    nwScratch,
    stNwScratch
  );
  const tangentRotationMatrix = tangentRotationMatrixScratch;
  if (stRotation !== 0 || rotation !== 0) {
    const center = Rectangle_default.center(rectangle, centerScratch4);
    const axis = ellipsoid.geodeticSurfaceNormalCartographic(center, v1Scratch);
    Quaternion_default.fromAxisAngle(axis, -stRotation, quaternionScratch4);
    Matrix3_default.fromQuaternion(quaternionScratch4, tangentRotationMatrix);
  } else {
    Matrix3_default.clone(Matrix3_default.IDENTITY, tangentRotationMatrix);
  }
  const surfaceHeight = rectangleGeometry._surfaceHeight;
  const extrudedHeight = rectangleGeometry._extrudedHeight;
  const extrude = !Math_default.equalsEpsilon(
    surfaceHeight,
    extrudedHeight,
    0,
    Math_default.EPSILON2
  );
  computedOptions.lonScalar = 1 / rectangleGeometry._rectangle.width;
  computedOptions.latScalar = 1 / rectangleGeometry._rectangle.height;
  computedOptions.tangentRotationMatrix = tangentRotationMatrix;
  let geometry;
  let boundingSphere;
  rectangle = rectangleGeometry._rectangle;
  if (extrude) {
    geometry = constructExtrudedRectangle(rectangleGeometry, computedOptions);
    const topBS = BoundingSphere_default.fromRectangle3D(
      rectangle,
      ellipsoid,
      surfaceHeight,
      topBoundingSphere3
    );
    const bottomBS = BoundingSphere_default.fromRectangle3D(
      rectangle,
      ellipsoid,
      extrudedHeight,
      bottomBoundingSphere3
    );
    boundingSphere = BoundingSphere_default.union(topBS, bottomBS);
  } else {
    geometry = constructRectangle(rectangleGeometry, computedOptions);
    geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
      geometry.attributes.position.values,
      surfaceHeight,
      ellipsoid,
      false
    );
    if (defined_default(rectangleGeometry._offsetAttribute)) {
      const length3 = geometry.attributes.position.values.length;
      const applyOffset = new Uint8Array(length3 / 3);
      const offsetValue = rectangleGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      arrayFill_default(applyOffset, offsetValue);
      geometry.attributes.applyOffset = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
        componentsPerAttribute: 1,
        values: applyOffset
      });
    }
    boundingSphere = BoundingSphere_default.fromRectangle3D(
      rectangle,
      ellipsoid,
      surfaceHeight
    );
  }
  if (!vertexFormat.position) {
    delete geometry.attributes.position;
  }
  return new Geometry_default({
    attributes: geometry.attributes,
    indices: geometry.indices,
    primitiveType: geometry.primitiveType,
    boundingSphere,
    offsetAttribute: rectangleGeometry._offsetAttribute
  });
};
RectangleGeometry.createShadowVolume = function(rectangleGeometry, minHeightFunc, maxHeightFunc) {
  const granularity = rectangleGeometry._granularity;
  const ellipsoid = rectangleGeometry._ellipsoid;
  const minHeight = minHeightFunc(granularity, ellipsoid);
  const maxHeight = maxHeightFunc(granularity, ellipsoid);
  return new RectangleGeometry({
    rectangle: rectangleGeometry._rectangle,
    rotation: rectangleGeometry._rotation,
    ellipsoid,
    stRotation: rectangleGeometry._stRotation,
    granularity,
    extrudedHeight: maxHeight,
    height: minHeight,
    vertexFormat: VertexFormat_default.POSITION_ONLY,
    shadowVolume: true
  });
};
var unrotatedTextureRectangleScratch = new Rectangle_default();
var points2DScratch2 = [new Cartesian2_default(), new Cartesian2_default(), new Cartesian2_default()];
var rotation2DScratch2 = new Matrix2_default();
var rectangleCenterScratch2 = new Cartographic_default();
function textureCoordinateRotationPoints3(rectangleGeometry) {
  if (rectangleGeometry._stRotation === 0) {
    return [0, 0, 0, 1, 1, 0];
  }
  const rectangle = Rectangle_default.clone(
    rectangleGeometry._rectangle,
    unrotatedTextureRectangleScratch
  );
  const granularity = rectangleGeometry._granularity;
  const ellipsoid = rectangleGeometry._ellipsoid;
  const rotation = rectangleGeometry._rotation - rectangleGeometry._stRotation;
  const unrotatedTextureRectangle = computeRectangle4(
    rectangle,
    granularity,
    rotation,
    ellipsoid,
    unrotatedTextureRectangleScratch
  );
  const points2D = points2DScratch2;
  points2D[0].x = unrotatedTextureRectangle.west;
  points2D[0].y = unrotatedTextureRectangle.south;
  points2D[1].x = unrotatedTextureRectangle.west;
  points2D[1].y = unrotatedTextureRectangle.north;
  points2D[2].x = unrotatedTextureRectangle.east;
  points2D[2].y = unrotatedTextureRectangle.south;
  const boundingRectangle = rectangleGeometry.rectangle;
  const toDesiredInComputed = Matrix2_default.fromRotation(
    rectangleGeometry._stRotation,
    rotation2DScratch2
  );
  const boundingRectangleCenter = Rectangle_default.center(
    boundingRectangle,
    rectangleCenterScratch2
  );
  for (let i2 = 0; i2 < 3; ++i2) {
    const point2D = points2D[i2];
    point2D.x -= boundingRectangleCenter.longitude;
    point2D.y -= boundingRectangleCenter.latitude;
    Matrix2_default.multiplyByVector(toDesiredInComputed, point2D, point2D);
    point2D.x += boundingRectangleCenter.longitude;
    point2D.y += boundingRectangleCenter.latitude;
    point2D.x = (point2D.x - boundingRectangle.west) / boundingRectangle.width;
    point2D.y = (point2D.y - boundingRectangle.south) / boundingRectangle.height;
  }
  const minXYCorner = points2D[0];
  const maxYCorner = points2D[1];
  const maxXCorner = points2D[2];
  const result = new Array(6);
  Cartesian2_default.pack(minXYCorner, result);
  Cartesian2_default.pack(maxYCorner, result, 2);
  Cartesian2_default.pack(maxXCorner, result, 4);
  return result;
}
Object.defineProperties(RectangleGeometry.prototype, {
  rectangle: {
    get: function() {
      if (!defined_default(this._rotatedRectangle)) {
        this._rotatedRectangle = computeRectangle4(
          this._rectangle,
          this._granularity,
          this._rotation,
          this._ellipsoid
        );
      }
      return this._rotatedRectangle;
    }
  },
  textureCoordinateRotationPoints: {
    get: function() {
      if (!defined_default(this._textureCoordinateRotationPoints)) {
        this._textureCoordinateRotationPoints = textureCoordinateRotationPoints3(
          this
        );
      }
      return this._textureCoordinateRotationPoints;
    }
  }
});
var RectangleGeometry_default = RectangleGeometry;

// node_modules/cesium/Source/Core/RectangleOutlineGeometry.js
var bottomBoundingSphere4 = new BoundingSphere_default();
var topBoundingSphere4 = new BoundingSphere_default();
var positionScratch4 = new Cartesian3_default();
var rectangleScratch4 = new Rectangle_default();
function constructRectangle2(geometry, computedOptions) {
  const ellipsoid = geometry._ellipsoid;
  const height = computedOptions.height;
  const width = computedOptions.width;
  const northCap = computedOptions.northCap;
  const southCap = computedOptions.southCap;
  let rowHeight = height;
  let widthMultiplier = 2;
  let size = 0;
  let corners = 4;
  if (northCap) {
    widthMultiplier -= 1;
    rowHeight -= 1;
    size += 1;
    corners -= 2;
  }
  if (southCap) {
    widthMultiplier -= 1;
    rowHeight -= 1;
    size += 1;
    corners -= 2;
  }
  size += widthMultiplier * width + 2 * rowHeight - corners;
  const positions = new Float64Array(size * 3);
  let posIndex = 0;
  let row = 0;
  let col;
  const position = positionScratch4;
  if (northCap) {
    RectangleGeometryLibrary_default.computePosition(
      computedOptions,
      ellipsoid,
      false,
      row,
      0,
      position
    );
    positions[posIndex++] = position.x;
    positions[posIndex++] = position.y;
    positions[posIndex++] = position.z;
  } else {
    for (col = 0; col < width; col++) {
      RectangleGeometryLibrary_default.computePosition(
        computedOptions,
        ellipsoid,
        false,
        row,
        col,
        position
      );
      positions[posIndex++] = position.x;
      positions[posIndex++] = position.y;
      positions[posIndex++] = position.z;
    }
  }
  col = width - 1;
  for (row = 1; row < height; row++) {
    RectangleGeometryLibrary_default.computePosition(
      computedOptions,
      ellipsoid,
      false,
      row,
      col,
      position
    );
    positions[posIndex++] = position.x;
    positions[posIndex++] = position.y;
    positions[posIndex++] = position.z;
  }
  row = height - 1;
  if (!southCap) {
    for (col = width - 2; col >= 0; col--) {
      RectangleGeometryLibrary_default.computePosition(
        computedOptions,
        ellipsoid,
        false,
        row,
        col,
        position
      );
      positions[posIndex++] = position.x;
      positions[posIndex++] = position.y;
      positions[posIndex++] = position.z;
    }
  }
  col = 0;
  for (row = height - 2; row > 0; row--) {
    RectangleGeometryLibrary_default.computePosition(
      computedOptions,
      ellipsoid,
      false,
      row,
      col,
      position
    );
    positions[posIndex++] = position.x;
    positions[posIndex++] = position.y;
    positions[posIndex++] = position.z;
  }
  const indicesSize = positions.length / 3 * 2;
  const indices2 = IndexDatatype_default.createTypedArray(
    positions.length / 3,
    indicesSize
  );
  let index2 = 0;
  for (let i2 = 0; i2 < positions.length / 3 - 1; i2++) {
    indices2[index2++] = i2;
    indices2[index2++] = i2 + 1;
  }
  indices2[index2++] = positions.length / 3 - 1;
  indices2[index2++] = 0;
  const geo = new Geometry_default({
    attributes: new GeometryAttributes_default(),
    primitiveType: PrimitiveType_default.LINES
  });
  geo.attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: positions
  });
  geo.indices = indices2;
  return geo;
}
function constructExtrudedRectangle2(rectangleGeometry, computedOptions) {
  const surfaceHeight = rectangleGeometry._surfaceHeight;
  const extrudedHeight = rectangleGeometry._extrudedHeight;
  const ellipsoid = rectangleGeometry._ellipsoid;
  const minHeight = extrudedHeight;
  const maxHeight = surfaceHeight;
  const geo = constructRectangle2(rectangleGeometry, computedOptions);
  const height = computedOptions.height;
  const width = computedOptions.width;
  const topPositions = PolygonPipeline_default.scaleToGeodeticHeight(
    geo.attributes.position.values,
    maxHeight,
    ellipsoid,
    false
  );
  let length3 = topPositions.length;
  const positions = new Float64Array(length3 * 2);
  positions.set(topPositions);
  const bottomPositions = PolygonPipeline_default.scaleToGeodeticHeight(
    geo.attributes.position.values,
    minHeight,
    ellipsoid
  );
  positions.set(bottomPositions, length3);
  geo.attributes.position.values = positions;
  const northCap = computedOptions.northCap;
  const southCap = computedOptions.southCap;
  let corners = 4;
  if (northCap) {
    corners -= 1;
  }
  if (southCap) {
    corners -= 1;
  }
  const indicesSize = (positions.length / 3 + corners) * 2;
  const indices2 = IndexDatatype_default.createTypedArray(
    positions.length / 3,
    indicesSize
  );
  length3 = positions.length / 6;
  let index2 = 0;
  for (let i2 = 0; i2 < length3 - 1; i2++) {
    indices2[index2++] = i2;
    indices2[index2++] = i2 + 1;
    indices2[index2++] = i2 + length3;
    indices2[index2++] = i2 + length3 + 1;
  }
  indices2[index2++] = length3 - 1;
  indices2[index2++] = 0;
  indices2[index2++] = length3 + length3 - 1;
  indices2[index2++] = length3;
  indices2[index2++] = 0;
  indices2[index2++] = length3;
  let bottomCorner;
  if (northCap) {
    bottomCorner = height - 1;
  } else {
    const topRightCorner = width - 1;
    indices2[index2++] = topRightCorner;
    indices2[index2++] = topRightCorner + length3;
    bottomCorner = width + height - 2;
  }
  indices2[index2++] = bottomCorner;
  indices2[index2++] = bottomCorner + length3;
  if (!southCap) {
    const bottomLeftCorner = width + bottomCorner - 1;
    indices2[index2++] = bottomLeftCorner;
    indices2[index2] = bottomLeftCorner + length3;
  }
  geo.indices = indices2;
  return geo;
}
function RectangleOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const rectangle = options.rectangle;
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  const rotation = defaultValue_default(options.rotation, 0);
  if (!defined_default(rectangle)) {
    throw new DeveloperError_default("rectangle is required.");
  }
  Rectangle_default.validate(rectangle);
  if (rectangle.north < rectangle.south) {
    throw new DeveloperError_default(
      "options.rectangle.north must be greater than options.rectangle.south"
    );
  }
  const height = defaultValue_default(options.height, 0);
  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
  this._rectangle = Rectangle_default.clone(rectangle);
  this._granularity = granularity;
  this._ellipsoid = ellipsoid;
  this._surfaceHeight = Math.max(height, extrudedHeight);
  this._rotation = rotation;
  this._extrudedHeight = Math.min(height, extrudedHeight);
  this._offsetAttribute = options.offsetAttribute;
  this._workerName = "createRectangleOutlineGeometry";
}
RectangleOutlineGeometry.packedLength = Rectangle_default.packedLength + Ellipsoid_default.packedLength + 5;
RectangleOutlineGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  Rectangle_default.pack(value._rectangle, array, startingIndex);
  startingIndex += Rectangle_default.packedLength;
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  array[startingIndex++] = value._granularity;
  array[startingIndex++] = value._surfaceHeight;
  array[startingIndex++] = value._rotation;
  array[startingIndex++] = value._extrudedHeight;
  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
  return array;
};
var scratchRectangle2 = new Rectangle_default();
var scratchEllipsoid12 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchOptions20 = {
  rectangle: scratchRectangle2,
  ellipsoid: scratchEllipsoid12,
  granularity: void 0,
  height: void 0,
  rotation: void 0,
  extrudedHeight: void 0,
  offsetAttribute: void 0
};
RectangleOutlineGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  const rectangle = Rectangle_default.unpack(array, startingIndex, scratchRectangle2);
  startingIndex += Rectangle_default.packedLength;
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid12);
  startingIndex += Ellipsoid_default.packedLength;
  const granularity = array[startingIndex++];
  const height = array[startingIndex++];
  const rotation = array[startingIndex++];
  const extrudedHeight = array[startingIndex++];
  const offsetAttribute = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions20.granularity = granularity;
    scratchOptions20.height = height;
    scratchOptions20.rotation = rotation;
    scratchOptions20.extrudedHeight = extrudedHeight;
    scratchOptions20.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
    return new RectangleOutlineGeometry(scratchOptions20);
  }
  result._rectangle = Rectangle_default.clone(rectangle, result._rectangle);
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._surfaceHeight = height;
  result._rotation = rotation;
  result._extrudedHeight = extrudedHeight;
  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
  return result;
};
var nwScratch2 = new Cartographic_default();
RectangleOutlineGeometry.createGeometry = function(rectangleGeometry) {
  const rectangle = rectangleGeometry._rectangle;
  const ellipsoid = rectangleGeometry._ellipsoid;
  const computedOptions = RectangleGeometryLibrary_default.computeOptions(
    rectangle,
    rectangleGeometry._granularity,
    rectangleGeometry._rotation,
    0,
    rectangleScratch4,
    nwScratch2
  );
  let geometry;
  let boundingSphere;
  if (Math_default.equalsEpsilon(
    rectangle.north,
    rectangle.south,
    Math_default.EPSILON10
  ) || Math_default.equalsEpsilon(
    rectangle.east,
    rectangle.west,
    Math_default.EPSILON10
  )) {
    return void 0;
  }
  const surfaceHeight = rectangleGeometry._surfaceHeight;
  const extrudedHeight = rectangleGeometry._extrudedHeight;
  const extrude = !Math_default.equalsEpsilon(
    surfaceHeight,
    extrudedHeight,
    0,
    Math_default.EPSILON2
  );
  let offsetValue;
  if (extrude) {
    geometry = constructExtrudedRectangle2(rectangleGeometry, computedOptions);
    if (defined_default(rectangleGeometry._offsetAttribute)) {
      const size = geometry.attributes.position.values.length / 3;
      let offsetAttribute = new Uint8Array(size);
      if (rectangleGeometry._offsetAttribute === GeometryOffsetAttribute_default.TOP) {
        offsetAttribute = arrayFill_default(offsetAttribute, 1, 0, size / 2);
      } else {
        offsetValue = rectangleGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
        offsetAttribute = arrayFill_default(offsetAttribute, offsetValue);
      }
      geometry.attributes.applyOffset = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
        componentsPerAttribute: 1,
        values: offsetAttribute
      });
    }
    const topBS = BoundingSphere_default.fromRectangle3D(
      rectangle,
      ellipsoid,
      surfaceHeight,
      topBoundingSphere4
    );
    const bottomBS = BoundingSphere_default.fromRectangle3D(
      rectangle,
      ellipsoid,
      extrudedHeight,
      bottomBoundingSphere4
    );
    boundingSphere = BoundingSphere_default.union(topBS, bottomBS);
  } else {
    geometry = constructRectangle2(rectangleGeometry, computedOptions);
    geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
      geometry.attributes.position.values,
      surfaceHeight,
      ellipsoid,
      false
    );
    if (defined_default(rectangleGeometry._offsetAttribute)) {
      const length3 = geometry.attributes.position.values.length;
      const applyOffset = new Uint8Array(length3 / 3);
      offsetValue = rectangleGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
      arrayFill_default(applyOffset, offsetValue);
      geometry.attributes.applyOffset = new GeometryAttribute_default({
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
        componentsPerAttribute: 1,
        values: applyOffset
      });
    }
    boundingSphere = BoundingSphere_default.fromRectangle3D(
      rectangle,
      ellipsoid,
      surfaceHeight
    );
  }
  return new Geometry_default({
    attributes: geometry.attributes,
    indices: geometry.indices,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere,
    offsetAttribute: rectangleGeometry._offsetAttribute
  });
};
var RectangleOutlineGeometry_default = RectangleOutlineGeometry;

// node_modules/cesium/Source/Core/ReferenceFrame.js
var ReferenceFrame = {
  FIXED: 0,
  INERTIAL: 1
};
var ReferenceFrame_default = Object.freeze(ReferenceFrame);

// node_modules/cesium/Source/Core/S2Cell.js
var S2_MAX_LEVEL = 30;
var S2_LIMIT_IJ = 1 << S2_MAX_LEVEL;
var S2_MAX_SITI = 1 << S2_MAX_LEVEL + 1 >>> 0;
var S2_POSITION_BITS = 2 * S2_MAX_LEVEL + 1;
var S2_LOOKUP_BITS = 4;
var S2_LOOKUP_POSITIONS = [];
var S2_LOOKUP_IJ = [];
var S2_POSITION_TO_IJ = [
  [0, 1, 3, 2],
  [0, 2, 3, 1],
  [3, 2, 0, 1],
  [3, 1, 0, 2]
];
var S2_SWAP_MASK = 1;
var S2_INVERT_MASK = 2;
var S2_POSITION_TO_ORIENTATION_MASK = [
  S2_SWAP_MASK,
  0,
  0,
  S2_SWAP_MASK | S2_INVERT_MASK
];
function S2Cell(cellId) {
  if (!FeatureDetection_default.supportsBigInt()) {
    throw new RuntimeError_default("S2 required BigInt support");
  }
  if (!defined_default(cellId)) {
    throw new DeveloperError_default("cell ID is required.");
  }
  if (!S2Cell.isValidId(cellId)) {
    throw new DeveloperError_default("cell ID is invalid.");
  }
  this._cellId = cellId;
  this._level = S2Cell.getLevel(cellId);
}
S2Cell.fromToken = function(token) {
  Check_default.typeOf.string("token", token);
  if (!S2Cell.isValidToken(token)) {
    throw new DeveloperError_default("token is invalid.");
  }
  return new S2Cell(S2Cell.getIdFromToken(token));
};
S2Cell.isValidId = function(cellId) {
  Check_default.typeOf.bigint("cellId", cellId);
  if (cellId <= 0) {
    return false;
  }
  if (cellId >> BigInt(S2_POSITION_BITS) > 5) {
    return false;
  }
  const lowestSetBit = cellId & ~cellId + BigInt(1);
  if (!(lowestSetBit & BigInt("0x1555555555555555"))) {
    return false;
  }
  return true;
};
S2Cell.isValidToken = function(token) {
  Check_default.typeOf.string("token", token);
  if (!/^[0-9a-fA-F]{1,16}$/.test(token)) {
    return false;
  }
  return S2Cell.isValidId(S2Cell.getIdFromToken(token));
};
S2Cell.getIdFromToken = function(token) {
  Check_default.typeOf.string("token", token);
  return BigInt("0x" + token + "0".repeat(16 - token.length));
};
S2Cell.getTokenFromId = function(cellId) {
  Check_default.typeOf.bigint("cellId", cellId);
  const trailingZeroHexChars = Math.floor(countTrailingZeroBits(cellId) / 4);
  const hexString = cellId.toString(16).replace(/0*$/, "");
  const zeroString = Array(17 - trailingZeroHexChars - hexString.length).join(
    "0"
  );
  return zeroString + hexString;
};
S2Cell.getLevel = function(cellId) {
  Check_default.typeOf.bigint("cellId", cellId);
  if (!S2Cell.isValidId(cellId)) {
    throw new DeveloperError_default();
  }
  let lsbPosition = 0;
  while (cellId !== BigInt(0)) {
    if (cellId & BigInt(1)) {
      break;
    }
    lsbPosition++;
    cellId = cellId >> BigInt(1);
  }
  return S2_MAX_LEVEL - (lsbPosition >> 1);
};
S2Cell.prototype.getChild = function(index2) {
  Check_default.typeOf.number("index", index2);
  if (index2 < 0 || index2 > 3) {
    throw new DeveloperError_default("child index must be in the range [0-3].");
  }
  if (this._level === 30) {
    throw new DeveloperError_default("cannot get child of leaf cell.");
  }
  const newLsb = lsb(this._cellId) >> BigInt(2);
  const childCellId = this._cellId + BigInt(2 * index2 + 1 - 4) * newLsb;
  return new S2Cell(childCellId);
};
S2Cell.prototype.getParent = function() {
  if (this._level === 0) {
    throw new DeveloperError_default("cannot get parent of root cell.");
  }
  const newLsb = lsb(this._cellId) << BigInt(2);
  return new S2Cell(this._cellId & ~newLsb + BigInt(1) | newLsb);
};
S2Cell.prototype.getParentAtLevel = function(level) {
  if (this._level === 0 || level < 0 || this._level < level) {
    throw new DeveloperError_default("cannot get parent at invalid level.");
  }
  const newLsb = lsbForLevel(level);
  return new S2Cell(this._cellId & -newLsb | newLsb);
};
S2Cell.prototype.getCenter = function(ellipsoid) {
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  let center = getS2Center(this._cellId, this._level);
  center = Cartesian3_default.normalize(center, center);
  const cartographic2 = new Cartographic_default.fromCartesian(
    center,
    Ellipsoid_default.UNIT_SPHERE
  );
  return Cartographic_default.toCartesian(cartographic2, ellipsoid, new Cartesian3_default());
};
S2Cell.prototype.getVertex = function(index2, ellipsoid) {
  Check_default.typeOf.number("index", index2);
  if (index2 < 0 || index2 > 3) {
    throw new DeveloperError_default("vertex index must be in the range [0-3].");
  }
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  let vertex = getS2Vertex(this._cellId, this._level, index2);
  vertex = Cartesian3_default.normalize(vertex, vertex);
  const cartographic2 = new Cartographic_default.fromCartesian(
    vertex,
    Ellipsoid_default.UNIT_SPHERE
  );
  return Cartographic_default.toCartesian(cartographic2, ellipsoid, new Cartesian3_default());
};
S2Cell.fromFacePositionLevel = function(face, position, level) {
  Check_default.typeOf.bigint("position", position);
  if (face < 0 || face > 5) {
    throw new DeveloperError_default("Invalid S2 Face (must be within 0-5)");
  }
  if (level < 0 || level > S2_MAX_LEVEL) {
    throw new DeveloperError_default("Invalid level (must be within 0-30)");
  }
  if (position < 0 || position >= Math.pow(4, level)) {
    throw new DeveloperError_default("Invalid Hilbert position for level");
  }
  const faceBitString = (face < 4 ? "0" : "") + (face < 2 ? "0" : "") + face.toString(2);
  const positionBitString = position.toString(2);
  const positionPrefixPadding = Array(
    2 * level - positionBitString.length + 1
  ).join("0");
  const positionSuffixPadding = Array(S2_POSITION_BITS - 2 * level).join("0");
  const cellId = BigInt(
    `0b${faceBitString}${positionPrefixPadding}${positionBitString}1${positionSuffixPadding}`
  );
  return new S2Cell(cellId);
};
function getS2Center(cellId, level) {
  const faceSiTi = convertCellIdToFaceSiTi(cellId, level);
  return convertFaceSiTitoXYZ(faceSiTi[0], faceSiTi[1], faceSiTi[2]);
}
function getS2Vertex(cellId, level, index2) {
  const faceIJ = convertCellIdToFaceIJ(cellId, level);
  const uv = convertIJLeveltoBoundUV([faceIJ[1], faceIJ[2]], level);
  const y = index2 >> 1 & 1;
  return convertFaceUVtoXYZ(faceIJ[0], uv[0][y ^ index2 & 1], uv[1][y]);
}
function convertCellIdToFaceSiTi(cellId, level) {
  const faceIJ = convertCellIdToFaceIJ(cellId);
  const face = faceIJ[0];
  const i2 = faceIJ[1];
  const j = faceIJ[2];
  const isLeaf = level === 30;
  const shouldCorrect = !isLeaf && (BigInt(i2) ^ cellId >> BigInt(2)) & BigInt(1);
  const correction = isLeaf ? 1 : shouldCorrect ? 2 : 0;
  const si = (i2 << 1) + correction;
  const ti = (j << 1) + correction;
  return [face, si, ti];
}
function convertCellIdToFaceIJ(cellId) {
  if (S2_LOOKUP_POSITIONS.length === 0) {
    generateLookupTable();
  }
  const face = Number(cellId >> BigInt(S2_POSITION_BITS));
  let bits = face & S2_SWAP_MASK;
  const lookupMask = (1 << S2_LOOKUP_BITS) - 1;
  let i2 = 0;
  let j = 0;
  for (let k = 7; k >= 0; k--) {
    const numberOfBits = k === 7 ? S2_MAX_LEVEL - 7 * S2_LOOKUP_BITS : S2_LOOKUP_BITS;
    const extractMask = (1 << 2 * numberOfBits) - 1;
    bits += Number(
      cellId >> BigInt(k * 2 * S2_LOOKUP_BITS + 1) & BigInt(extractMask)
    ) << 2;
    bits = S2_LOOKUP_IJ[bits];
    const offset2 = k * S2_LOOKUP_BITS;
    i2 += bits >> S2_LOOKUP_BITS + 2 << offset2;
    j += (bits >> 2 & lookupMask) << offset2;
    bits &= S2_SWAP_MASK | S2_INVERT_MASK;
  }
  return [face, i2, j];
}
function convertFaceSiTitoXYZ(face, si, ti) {
  const s2 = convertSiTitoST(si);
  const t = convertSiTitoST(ti);
  const u3 = convertSTtoUV(s2);
  const v7 = convertSTtoUV(t);
  return convertFaceUVtoXYZ(face, u3, v7);
}
function convertFaceUVtoXYZ(face, u3, v7) {
  switch (face) {
    case 0:
      return new Cartesian3_default(1, u3, v7);
    case 1:
      return new Cartesian3_default(-u3, 1, v7);
    case 2:
      return new Cartesian3_default(-u3, -v7, 1);
    case 3:
      return new Cartesian3_default(-1, -v7, -u3);
    case 4:
      return new Cartesian3_default(v7, -1, -u3);
    default:
      return new Cartesian3_default(v7, u3, -1);
  }
}
function convertSTtoUV(s2) {
  if (s2 >= 0.5)
    return 1 / 3 * (4 * s2 * s2 - 1);
  return 1 / 3 * (1 - 4 * (1 - s2) * (1 - s2));
}
function convertSiTitoST(si) {
  return 1 / S2_MAX_SITI * si;
}
function convertIJLeveltoBoundUV(ij, level) {
  const result = [[], []];
  const cellSize = getSizeIJ(level);
  for (let d = 0; d < 2; ++d) {
    const ijLow = ij[d] & -cellSize;
    const ijHigh = ijLow + cellSize;
    result[d][0] = convertSTtoUV(convertIJtoSTMinimum(ijLow));
    result[d][1] = convertSTtoUV(convertIJtoSTMinimum(ijHigh));
  }
  return result;
}
function getSizeIJ(level) {
  return 1 << S2_MAX_LEVEL - level >>> 0;
}
function convertIJtoSTMinimum(i2) {
  return 1 / S2_LIMIT_IJ * i2;
}
function generateLookupCell(level, i2, j, originalOrientation, position, orientation) {
  if (level === S2_LOOKUP_BITS) {
    const ij = (i2 << S2_LOOKUP_BITS) + j;
    S2_LOOKUP_POSITIONS[(ij << 2) + originalOrientation] = (position << 2) + orientation;
    S2_LOOKUP_IJ[(position << 2) + originalOrientation] = (ij << 2) + orientation;
  } else {
    level++;
    i2 <<= 1;
    j <<= 1;
    position <<= 2;
    const r2 = S2_POSITION_TO_IJ[orientation];
    generateLookupCell(
      level,
      i2 + (r2[0] >> 1),
      j + (r2[0] & 1),
      originalOrientation,
      position,
      orientation ^ S2_POSITION_TO_ORIENTATION_MASK[0]
    );
    generateLookupCell(
      level,
      i2 + (r2[1] >> 1),
      j + (r2[1] & 1),
      originalOrientation,
      position + 1,
      orientation ^ S2_POSITION_TO_ORIENTATION_MASK[1]
    );
    generateLookupCell(
      level,
      i2 + (r2[2] >> 1),
      j + (r2[2] & 1),
      originalOrientation,
      position + 2,
      orientation ^ S2_POSITION_TO_ORIENTATION_MASK[2]
    );
    generateLookupCell(
      level,
      i2 + (r2[3] >> 1),
      j + (r2[3] & 1),
      originalOrientation,
      position + 3,
      orientation ^ S2_POSITION_TO_ORIENTATION_MASK[3]
    );
  }
}
function generateLookupTable() {
  generateLookupCell(0, 0, 0, 0, 0, 0);
  generateLookupCell(0, 0, 0, S2_SWAP_MASK, 0, S2_SWAP_MASK);
  generateLookupCell(0, 0, 0, S2_INVERT_MASK, 0, S2_INVERT_MASK);
  generateLookupCell(
    0,
    0,
    0,
    S2_SWAP_MASK | S2_INVERT_MASK,
    0,
    S2_SWAP_MASK | S2_INVERT_MASK
  );
}
function lsb(cellId) {
  return cellId & ~cellId + BigInt(1);
}
function lsbForLevel(level) {
  return BigInt(1) << BigInt(2 * (S2_MAX_LEVEL - level));
}
var Mod67BitPosition = [
  64,
  0,
  1,
  39,
  2,
  15,
  40,
  23,
  3,
  12,
  16,
  59,
  41,
  19,
  24,
  54,
  4,
  64,
  13,
  10,
  17,
  62,
  60,
  28,
  42,
  30,
  20,
  51,
  25,
  44,
  55,
  47,
  5,
  32,
  65,
  38,
  14,
  22,
  11,
  58,
  18,
  53,
  63,
  9,
  61,
  27,
  29,
  50,
  43,
  46,
  31,
  37,
  21,
  57,
  52,
  8,
  26,
  49,
  45,
  36,
  56,
  7,
  48,
  35,
  6,
  34,
  33,
  0
];
function countTrailingZeroBits(x) {
  return Mod67BitPosition[(-x & x) % BigInt(67)];
}
var S2Cell_default = S2Cell;

// node_modules/cesium/Source/Core/ScreenSpaceEventType.js
var ScreenSpaceEventType = {
  LEFT_DOWN: 0,
  LEFT_UP: 1,
  LEFT_CLICK: 2,
  LEFT_DOUBLE_CLICK: 3,
  RIGHT_DOWN: 5,
  RIGHT_UP: 6,
  RIGHT_CLICK: 7,
  MIDDLE_DOWN: 10,
  MIDDLE_UP: 11,
  MIDDLE_CLICK: 12,
  MOUSE_MOVE: 15,
  WHEEL: 16,
  PINCH_START: 17,
  PINCH_END: 18,
  PINCH_MOVE: 19
};
var ScreenSpaceEventType_default = Object.freeze(ScreenSpaceEventType);

// node_modules/cesium/Source/Core/ScreenSpaceEventHandler.js
function getPosition2(screenSpaceEventHandler, event, result) {
  const element = screenSpaceEventHandler._element;
  if (element === document) {
    result.x = event.clientX;
    result.y = event.clientY;
    return result;
  }
  const rect = element.getBoundingClientRect();
  result.x = event.clientX - rect.left;
  result.y = event.clientY - rect.top;
  return result;
}
function getInputEventKey(type, modifier) {
  let key = type;
  if (defined_default(modifier)) {
    key += `+${modifier}`;
  }
  return key;
}
function getModifier(event) {
  if (event.shiftKey) {
    return KeyboardEventModifier_default.SHIFT;
  } else if (event.ctrlKey) {
    return KeyboardEventModifier_default.CTRL;
  } else if (event.altKey) {
    return KeyboardEventModifier_default.ALT;
  }
  return void 0;
}
var MouseButton = {
  LEFT: 0,
  MIDDLE: 1,
  RIGHT: 2
};
function registerListener(screenSpaceEventHandler, domType, element, callback) {
  function listener(e2) {
    callback(screenSpaceEventHandler, e2);
  }
  if (FeatureDetection_default.isInternetExplorer()) {
    element.addEventListener(domType, listener, false);
  } else {
    element.addEventListener(domType, listener, {
      capture: false,
      passive: false
    });
  }
  screenSpaceEventHandler._removalFunctions.push(function() {
    element.removeEventListener(domType, listener, false);
  });
}
function registerListeners(screenSpaceEventHandler) {
  const element = screenSpaceEventHandler._element;
  const alternateElement = !defined_default(element.disableRootEvents) ? document : element;
  if (FeatureDetection_default.supportsPointerEvents()) {
    registerListener(
      screenSpaceEventHandler,
      "pointerdown",
      element,
      handlePointerDown
    );
    registerListener(
      screenSpaceEventHandler,
      "pointerup",
      element,
      handlePointerUp
    );
    registerListener(
      screenSpaceEventHandler,
      "pointermove",
      element,
      handlePointerMove
    );
    registerListener(
      screenSpaceEventHandler,
      "pointercancel",
      element,
      handlePointerUp
    );
  } else {
    registerListener(
      screenSpaceEventHandler,
      "mousedown",
      element,
      handleMouseDown
    );
    registerListener(
      screenSpaceEventHandler,
      "mouseup",
      alternateElement,
      handleMouseUp
    );
    registerListener(
      screenSpaceEventHandler,
      "mousemove",
      alternateElement,
      handleMouseMove
    );
    registerListener(
      screenSpaceEventHandler,
      "touchstart",
      element,
      handleTouchStart
    );
    registerListener(
      screenSpaceEventHandler,
      "touchend",
      alternateElement,
      handleTouchEnd
    );
    registerListener(
      screenSpaceEventHandler,
      "touchmove",
      alternateElement,
      handleTouchMove
    );
    registerListener(
      screenSpaceEventHandler,
      "touchcancel",
      alternateElement,
      handleTouchEnd
    );
  }
  registerListener(
    screenSpaceEventHandler,
    "dblclick",
    element,
    handleDblClick
  );
  let wheelEvent;
  if ("onwheel" in element) {
    wheelEvent = "wheel";
  } else if (document.onmousewheel !== void 0) {
    wheelEvent = "mousewheel";
  } else {
    wheelEvent = "DOMMouseScroll";
  }
  registerListener(screenSpaceEventHandler, wheelEvent, element, handleWheel);
}
function unregisterListeners(screenSpaceEventHandler) {
  const removalFunctions = screenSpaceEventHandler._removalFunctions;
  for (let i2 = 0; i2 < removalFunctions.length; ++i2) {
    removalFunctions[i2]();
  }
}
var mouseDownEvent = {
  position: new Cartesian2_default()
};
function gotTouchEvent(screenSpaceEventHandler) {
  screenSpaceEventHandler._lastSeenTouchEvent = getTimestamp_default();
}
function canProcessMouseEvent(screenSpaceEventHandler) {
  return getTimestamp_default() - screenSpaceEventHandler._lastSeenTouchEvent > ScreenSpaceEventHandler.mouseEmulationIgnoreMilliseconds;
}
function checkPixelTolerance(startPosition, endPosition, pixelTolerance) {
  const xDiff = startPosition.x - endPosition.x;
  const yDiff = startPosition.y - endPosition.y;
  const totalPixels = Math.sqrt(xDiff * xDiff + yDiff * yDiff);
  return totalPixels < pixelTolerance;
}
function handleMouseDown(screenSpaceEventHandler, event) {
  if (!canProcessMouseEvent(screenSpaceEventHandler)) {
    return;
  }
  const button = event.button;
  screenSpaceEventHandler._buttonDown[button] = true;
  let screenSpaceEventType;
  if (button === MouseButton.LEFT) {
    screenSpaceEventType = ScreenSpaceEventType_default.LEFT_DOWN;
  } else if (button === MouseButton.MIDDLE) {
    screenSpaceEventType = ScreenSpaceEventType_default.MIDDLE_DOWN;
  } else if (button === MouseButton.RIGHT) {
    screenSpaceEventType = ScreenSpaceEventType_default.RIGHT_DOWN;
  } else {
    return;
  }
  const position = getPosition2(
    screenSpaceEventHandler,
    event,
    screenSpaceEventHandler._primaryPosition
  );
  Cartesian2_default.clone(position, screenSpaceEventHandler._primaryStartPosition);
  Cartesian2_default.clone(position, screenSpaceEventHandler._primaryPreviousPosition);
  const modifier = getModifier(event);
  const action = screenSpaceEventHandler.getInputAction(
    screenSpaceEventType,
    modifier
  );
  if (defined_default(action)) {
    Cartesian2_default.clone(position, mouseDownEvent.position);
    action(mouseDownEvent);
    event.preventDefault();
  }
}
var mouseUpEvent = {
  position: new Cartesian2_default()
};
var mouseClickEvent = {
  position: new Cartesian2_default()
};
function cancelMouseEvent(screenSpaceEventHandler, screenSpaceEventType, clickScreenSpaceEventType, event) {
  const modifier = getModifier(event);
  const action = screenSpaceEventHandler.getInputAction(
    screenSpaceEventType,
    modifier
  );
  const clickAction = screenSpaceEventHandler.getInputAction(
    clickScreenSpaceEventType,
    modifier
  );
  if (defined_default(action) || defined_default(clickAction)) {
    const position = getPosition2(
      screenSpaceEventHandler,
      event,
      screenSpaceEventHandler._primaryPosition
    );
    if (defined_default(action)) {
      Cartesian2_default.clone(position, mouseUpEvent.position);
      action(mouseUpEvent);
    }
    if (defined_default(clickAction)) {
      const startPosition = screenSpaceEventHandler._primaryStartPosition;
      if (checkPixelTolerance(
        startPosition,
        position,
        screenSpaceEventHandler._clickPixelTolerance
      )) {
        Cartesian2_default.clone(position, mouseClickEvent.position);
        clickAction(mouseClickEvent);
      }
    }
  }
}
function handleMouseUp(screenSpaceEventHandler, event) {
  if (!canProcessMouseEvent(screenSpaceEventHandler)) {
    return;
  }
  const button = event.button;
  if (button !== MouseButton.LEFT && button !== MouseButton.MIDDLE && button !== MouseButton.RIGHT) {
    return;
  }
  if (screenSpaceEventHandler._buttonDown[MouseButton.LEFT]) {
    cancelMouseEvent(
      screenSpaceEventHandler,
      ScreenSpaceEventType_default.LEFT_UP,
      ScreenSpaceEventType_default.LEFT_CLICK,
      event
    );
    screenSpaceEventHandler._buttonDown[MouseButton.LEFT] = false;
  }
  if (screenSpaceEventHandler._buttonDown[MouseButton.MIDDLE]) {
    cancelMouseEvent(
      screenSpaceEventHandler,
      ScreenSpaceEventType_default.MIDDLE_UP,
      ScreenSpaceEventType_default.MIDDLE_CLICK,
      event
    );
    screenSpaceEventHandler._buttonDown[MouseButton.MIDDLE] = false;
  }
  if (screenSpaceEventHandler._buttonDown[MouseButton.RIGHT]) {
    cancelMouseEvent(
      screenSpaceEventHandler,
      ScreenSpaceEventType_default.RIGHT_UP,
      ScreenSpaceEventType_default.RIGHT_CLICK,
      event
    );
    screenSpaceEventHandler._buttonDown[MouseButton.RIGHT] = false;
  }
}
var mouseMoveEvent = {
  startPosition: new Cartesian2_default(),
  endPosition: new Cartesian2_default()
};
function handleMouseMove(screenSpaceEventHandler, event) {
  if (!canProcessMouseEvent(screenSpaceEventHandler)) {
    return;
  }
  const modifier = getModifier(event);
  const position = getPosition2(
    screenSpaceEventHandler,
    event,
    screenSpaceEventHandler._primaryPosition
  );
  const previousPosition = screenSpaceEventHandler._primaryPreviousPosition;
  const action = screenSpaceEventHandler.getInputAction(
    ScreenSpaceEventType_default.MOUSE_MOVE,
    modifier
  );
  if (defined_default(action)) {
    Cartesian2_default.clone(previousPosition, mouseMoveEvent.startPosition);
    Cartesian2_default.clone(position, mouseMoveEvent.endPosition);
    action(mouseMoveEvent);
  }
  Cartesian2_default.clone(position, previousPosition);
  if (screenSpaceEventHandler._buttonDown[MouseButton.LEFT] || screenSpaceEventHandler._buttonDown[MouseButton.MIDDLE] || screenSpaceEventHandler._buttonDown[MouseButton.RIGHT]) {
    event.preventDefault();
  }
}
var mouseDblClickEvent = {
  position: new Cartesian2_default()
};
function handleDblClick(screenSpaceEventHandler, event) {
  const button = event.button;
  let screenSpaceEventType;
  if (button === MouseButton.LEFT) {
    screenSpaceEventType = ScreenSpaceEventType_default.LEFT_DOUBLE_CLICK;
  } else {
    return;
  }
  const modifier = getModifier(event);
  const action = screenSpaceEventHandler.getInputAction(
    screenSpaceEventType,
    modifier
  );
  if (defined_default(action)) {
    getPosition2(screenSpaceEventHandler, event, mouseDblClickEvent.position);
    action(mouseDblClickEvent);
  }
}
function handleWheel(screenSpaceEventHandler, event) {
  let delta;
  if (defined_default(event.deltaY)) {
    const deltaMode = event.deltaMode;
    if (deltaMode === event.DOM_DELTA_PIXEL) {
      delta = -event.deltaY;
    } else if (deltaMode === event.DOM_DELTA_LINE) {
      delta = -event.deltaY * 40;
    } else {
      delta = -event.deltaY * 120;
    }
  } else if (event.detail > 0) {
    delta = event.detail * -120;
  } else {
    delta = event.wheelDelta;
  }
  if (!defined_default(delta)) {
    return;
  }
  const modifier = getModifier(event);
  const action = screenSpaceEventHandler.getInputAction(
    ScreenSpaceEventType_default.WHEEL,
    modifier
  );
  if (defined_default(action)) {
    action(delta);
    event.preventDefault();
  }
}
function handleTouchStart(screenSpaceEventHandler, event) {
  gotTouchEvent(screenSpaceEventHandler);
  const changedTouches = event.changedTouches;
  let i2;
  const length3 = changedTouches.length;
  let touch;
  let identifier;
  const positions = screenSpaceEventHandler._positions;
  for (i2 = 0; i2 < length3; ++i2) {
    touch = changedTouches[i2];
    identifier = touch.identifier;
    positions.set(
      identifier,
      getPosition2(screenSpaceEventHandler, touch, new Cartesian2_default())
    );
  }
  fireTouchEvents(screenSpaceEventHandler, event);
  const previousPositions = screenSpaceEventHandler._previousPositions;
  for (i2 = 0; i2 < length3; ++i2) {
    touch = changedTouches[i2];
    identifier = touch.identifier;
    previousPositions.set(
      identifier,
      Cartesian2_default.clone(positions.get(identifier))
    );
  }
}
function handleTouchEnd(screenSpaceEventHandler, event) {
  gotTouchEvent(screenSpaceEventHandler);
  const changedTouches = event.changedTouches;
  let i2;
  const length3 = changedTouches.length;
  let touch;
  let identifier;
  const positions = screenSpaceEventHandler._positions;
  for (i2 = 0; i2 < length3; ++i2) {
    touch = changedTouches[i2];
    identifier = touch.identifier;
    positions.remove(identifier);
  }
  fireTouchEvents(screenSpaceEventHandler, event);
  const previousPositions = screenSpaceEventHandler._previousPositions;
  for (i2 = 0; i2 < length3; ++i2) {
    touch = changedTouches[i2];
    identifier = touch.identifier;
    previousPositions.remove(identifier);
  }
}
var touchStartEvent = {
  position: new Cartesian2_default()
};
var touch2StartEvent = {
  position1: new Cartesian2_default(),
  position2: new Cartesian2_default()
};
var touchEndEvent = {
  position: new Cartesian2_default()
};
var touchClickEvent = {
  position: new Cartesian2_default()
};
var touchHoldEvent = {
  position: new Cartesian2_default()
};
function fireTouchEvents(screenSpaceEventHandler, event) {
  const modifier = getModifier(event);
  const positions = screenSpaceEventHandler._positions;
  const numberOfTouches = positions.length;
  let action;
  let clickAction;
  const pinching = screenSpaceEventHandler._isPinching;
  if (numberOfTouches !== 1 && screenSpaceEventHandler._buttonDown[MouseButton.LEFT]) {
    screenSpaceEventHandler._buttonDown[MouseButton.LEFT] = false;
    if (defined_default(screenSpaceEventHandler._touchHoldTimer)) {
      clearTimeout(screenSpaceEventHandler._touchHoldTimer);
      screenSpaceEventHandler._touchHoldTimer = void 0;
    }
    action = screenSpaceEventHandler.getInputAction(
      ScreenSpaceEventType_default.LEFT_UP,
      modifier
    );
    if (defined_default(action)) {
      Cartesian2_default.clone(
        screenSpaceEventHandler._primaryPosition,
        touchEndEvent.position
      );
      action(touchEndEvent);
    }
    if (numberOfTouches === 0 && !screenSpaceEventHandler._isTouchHolding) {
      clickAction = screenSpaceEventHandler.getInputAction(
        ScreenSpaceEventType_default.LEFT_CLICK,
        modifier
      );
      if (defined_default(clickAction)) {
        const startPosition = screenSpaceEventHandler._primaryStartPosition;
        const endPosition = screenSpaceEventHandler._previousPositions.values[0];
        if (checkPixelTolerance(
          startPosition,
          endPosition,
          screenSpaceEventHandler._clickPixelTolerance
        )) {
          Cartesian2_default.clone(
            screenSpaceEventHandler._primaryPosition,
            touchClickEvent.position
          );
          clickAction(touchClickEvent);
        }
      }
    }
    screenSpaceEventHandler._isTouchHolding = false;
  }
  if (numberOfTouches === 0 && pinching) {
    screenSpaceEventHandler._isPinching = false;
    action = screenSpaceEventHandler.getInputAction(
      ScreenSpaceEventType_default.PINCH_END,
      modifier
    );
    if (defined_default(action)) {
      action();
    }
  }
  if (numberOfTouches === 1 && !pinching) {
    const position = positions.values[0];
    Cartesian2_default.clone(position, screenSpaceEventHandler._primaryPosition);
    Cartesian2_default.clone(position, screenSpaceEventHandler._primaryStartPosition);
    Cartesian2_default.clone(
      position,
      screenSpaceEventHandler._primaryPreviousPosition
    );
    screenSpaceEventHandler._buttonDown[MouseButton.LEFT] = true;
    action = screenSpaceEventHandler.getInputAction(
      ScreenSpaceEventType_default.LEFT_DOWN,
      modifier
    );
    if (defined_default(action)) {
      Cartesian2_default.clone(position, touchStartEvent.position);
      action(touchStartEvent);
    }
    screenSpaceEventHandler._touchHoldTimer = setTimeout(function() {
      if (!screenSpaceEventHandler.isDestroyed()) {
        screenSpaceEventHandler._touchHoldTimer = void 0;
        screenSpaceEventHandler._isTouchHolding = true;
        clickAction = screenSpaceEventHandler.getInputAction(
          ScreenSpaceEventType_default.RIGHT_CLICK,
          modifier
        );
        if (defined_default(clickAction)) {
          const startPosition = screenSpaceEventHandler._primaryStartPosition;
          const endPosition = screenSpaceEventHandler._previousPositions.values[0];
          if (checkPixelTolerance(
            startPosition,
            endPosition,
            screenSpaceEventHandler._holdPixelTolerance
          )) {
            Cartesian2_default.clone(
              screenSpaceEventHandler._primaryPosition,
              touchHoldEvent.position
            );
            clickAction(touchHoldEvent);
          }
        }
      }
    }, ScreenSpaceEventHandler.touchHoldDelayMilliseconds);
    event.preventDefault();
  }
  if (numberOfTouches === 2 && !pinching) {
    screenSpaceEventHandler._isPinching = true;
    action = screenSpaceEventHandler.getInputAction(
      ScreenSpaceEventType_default.PINCH_START,
      modifier
    );
    if (defined_default(action)) {
      Cartesian2_default.clone(positions.values[0], touch2StartEvent.position1);
      Cartesian2_default.clone(positions.values[1], touch2StartEvent.position2);
      action(touch2StartEvent);
      event.preventDefault();
    }
  }
}
function handleTouchMove(screenSpaceEventHandler, event) {
  gotTouchEvent(screenSpaceEventHandler);
  const changedTouches = event.changedTouches;
  let i2;
  const length3 = changedTouches.length;
  let touch;
  let identifier;
  const positions = screenSpaceEventHandler._positions;
  for (i2 = 0; i2 < length3; ++i2) {
    touch = changedTouches[i2];
    identifier = touch.identifier;
    const position = positions.get(identifier);
    if (defined_default(position)) {
      getPosition2(screenSpaceEventHandler, touch, position);
    }
  }
  fireTouchMoveEvents(screenSpaceEventHandler, event);
  const previousPositions = screenSpaceEventHandler._previousPositions;
  for (i2 = 0; i2 < length3; ++i2) {
    touch = changedTouches[i2];
    identifier = touch.identifier;
    Cartesian2_default.clone(
      positions.get(identifier),
      previousPositions.get(identifier)
    );
  }
}
var touchMoveEvent = {
  startPosition: new Cartesian2_default(),
  endPosition: new Cartesian2_default()
};
var touchPinchMovementEvent = {
  distance: {
    startPosition: new Cartesian2_default(),
    endPosition: new Cartesian2_default()
  },
  angleAndHeight: {
    startPosition: new Cartesian2_default(),
    endPosition: new Cartesian2_default()
  }
};
function fireTouchMoveEvents(screenSpaceEventHandler, event) {
  const modifier = getModifier(event);
  const positions = screenSpaceEventHandler._positions;
  const previousPositions = screenSpaceEventHandler._previousPositions;
  const numberOfTouches = positions.length;
  let action;
  if (numberOfTouches === 1 && screenSpaceEventHandler._buttonDown[MouseButton.LEFT]) {
    const position = positions.values[0];
    Cartesian2_default.clone(position, screenSpaceEventHandler._primaryPosition);
    const previousPosition = screenSpaceEventHandler._primaryPreviousPosition;
    action = screenSpaceEventHandler.getInputAction(
      ScreenSpaceEventType_default.MOUSE_MOVE,
      modifier
    );
    if (defined_default(action)) {
      Cartesian2_default.clone(previousPosition, touchMoveEvent.startPosition);
      Cartesian2_default.clone(position, touchMoveEvent.endPosition);
      action(touchMoveEvent);
    }
    Cartesian2_default.clone(position, previousPosition);
    event.preventDefault();
  } else if (numberOfTouches === 2 && screenSpaceEventHandler._isPinching) {
    action = screenSpaceEventHandler.getInputAction(
      ScreenSpaceEventType_default.PINCH_MOVE,
      modifier
    );
    if (defined_default(action)) {
      const position1 = positions.values[0];
      const position2 = positions.values[1];
      const previousPosition1 = previousPositions.values[0];
      const previousPosition2 = previousPositions.values[1];
      const dX = position2.x - position1.x;
      const dY = position2.y - position1.y;
      const dist = Math.sqrt(dX * dX + dY * dY) * 0.25;
      const prevDX = previousPosition2.x - previousPosition1.x;
      const prevDY = previousPosition2.y - previousPosition1.y;
      const prevDist = Math.sqrt(prevDX * prevDX + prevDY * prevDY) * 0.25;
      const cY = (position2.y + position1.y) * 0.125;
      const prevCY = (previousPosition2.y + previousPosition1.y) * 0.125;
      const angle = Math.atan2(dY, dX);
      const prevAngle = Math.atan2(prevDY, prevDX);
      Cartesian2_default.fromElements(
        0,
        prevDist,
        touchPinchMovementEvent.distance.startPosition
      );
      Cartesian2_default.fromElements(
        0,
        dist,
        touchPinchMovementEvent.distance.endPosition
      );
      Cartesian2_default.fromElements(
        prevAngle,
        prevCY,
        touchPinchMovementEvent.angleAndHeight.startPosition
      );
      Cartesian2_default.fromElements(
        angle,
        cY,
        touchPinchMovementEvent.angleAndHeight.endPosition
      );
      action(touchPinchMovementEvent);
    }
  }
}
function handlePointerDown(screenSpaceEventHandler, event) {
  event.target.setPointerCapture(event.pointerId);
  if (event.pointerType === "touch") {
    const positions = screenSpaceEventHandler._positions;
    const identifier = event.pointerId;
    positions.set(
      identifier,
      getPosition2(screenSpaceEventHandler, event, new Cartesian2_default())
    );
    fireTouchEvents(screenSpaceEventHandler, event);
    const previousPositions = screenSpaceEventHandler._previousPositions;
    previousPositions.set(
      identifier,
      Cartesian2_default.clone(positions.get(identifier))
    );
  } else {
    handleMouseDown(screenSpaceEventHandler, event);
  }
}
function handlePointerUp(screenSpaceEventHandler, event) {
  if (event.pointerType === "touch") {
    const positions = screenSpaceEventHandler._positions;
    const identifier = event.pointerId;
    positions.remove(identifier);
    fireTouchEvents(screenSpaceEventHandler, event);
    const previousPositions = screenSpaceEventHandler._previousPositions;
    previousPositions.remove(identifier);
  } else {
    handleMouseUp(screenSpaceEventHandler, event);
  }
}
function handlePointerMove(screenSpaceEventHandler, event) {
  if (event.pointerType === "touch") {
    const positions = screenSpaceEventHandler._positions;
    const identifier = event.pointerId;
    const position = positions.get(identifier);
    if (!defined_default(position)) {
      return;
    }
    getPosition2(screenSpaceEventHandler, event, position);
    fireTouchMoveEvents(screenSpaceEventHandler, event);
    const previousPositions = screenSpaceEventHandler._previousPositions;
    Cartesian2_default.clone(
      positions.get(identifier),
      previousPositions.get(identifier)
    );
  } else {
    handleMouseMove(screenSpaceEventHandler, event);
  }
}
function ScreenSpaceEventHandler(element) {
  this._inputEvents = {};
  this._buttonDown = {
    LEFT: false,
    MIDDLE: false,
    RIGHT: false
  };
  this._isPinching = false;
  this._isTouchHolding = false;
  this._lastSeenTouchEvent = -ScreenSpaceEventHandler.mouseEmulationIgnoreMilliseconds;
  this._primaryStartPosition = new Cartesian2_default();
  this._primaryPosition = new Cartesian2_default();
  this._primaryPreviousPosition = new Cartesian2_default();
  this._positions = new AssociativeArray_default();
  this._previousPositions = new AssociativeArray_default();
  this._removalFunctions = [];
  this._touchHoldTimer = void 0;
  this._clickPixelTolerance = 5;
  this._holdPixelTolerance = 25;
  this._element = defaultValue_default(element, document);
  registerListeners(this);
}
ScreenSpaceEventHandler.prototype.setInputAction = function(action, type, modifier) {
  if (!defined_default(action)) {
    throw new DeveloperError_default("action is required.");
  }
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  const key = getInputEventKey(type, modifier);
  this._inputEvents[key] = action;
};
ScreenSpaceEventHandler.prototype.getInputAction = function(type, modifier) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  const key = getInputEventKey(type, modifier);
  return this._inputEvents[key];
};
ScreenSpaceEventHandler.prototype.removeInputAction = function(type, modifier) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  const key = getInputEventKey(type, modifier);
  delete this._inputEvents[key];
};
ScreenSpaceEventHandler.prototype.isDestroyed = function() {
  return false;
};
ScreenSpaceEventHandler.prototype.destroy = function() {
  unregisterListeners(this);
  return destroyObject_default(this);
};
ScreenSpaceEventHandler.mouseEmulationIgnoreMilliseconds = 800;
ScreenSpaceEventHandler.touchHoldDelayMilliseconds = 1500;
var ScreenSpaceEventHandler_default = ScreenSpaceEventHandler;

// node_modules/cesium/Source/Core/ShowGeometryInstanceAttribute.js
function ShowGeometryInstanceAttribute(show) {
  show = defaultValue_default(show, true);
  this.value = ShowGeometryInstanceAttribute.toValue(show);
}
Object.defineProperties(ShowGeometryInstanceAttribute.prototype, {
  componentDatatype: {
    get: function() {
      return ComponentDatatype_default.UNSIGNED_BYTE;
    }
  },
  componentsPerAttribute: {
    get: function() {
      return 1;
    }
  },
  normalize: {
    get: function() {
      return false;
    }
  }
});
ShowGeometryInstanceAttribute.toValue = function(show, result) {
  if (!defined_default(show)) {
    throw new DeveloperError_default("show is required.");
  }
  if (!defined_default(result)) {
    return new Uint8Array([show]);
  }
  result[0] = show;
  return result;
};
var ShowGeometryInstanceAttribute_default = ShowGeometryInstanceAttribute;

// node_modules/cesium/Source/Core/Simon1994PlanetaryPositions.js
var Simon1994PlanetaryPositions = {};
function computeTdbMinusTtSpice(daysSinceJ2000InTerrestrialTime) {
  const g = 6.239996 + 0.0172019696544 * daysSinceJ2000InTerrestrialTime;
  return 1657e-6 * Math.sin(g + 0.01671 * Math.sin(g));
}
var TdtMinusTai2 = 32.184;
var J2000d2 = 2451545;
function taiToTdb(date, result) {
  result = JulianDate_default.addSeconds(date, TdtMinusTai2, result);
  const days = JulianDate_default.totalDays(result) - J2000d2;
  result = JulianDate_default.addSeconds(result, computeTdbMinusTtSpice(days), result);
  return result;
}
var epoch = new JulianDate_default(2451545, 0, TimeStandard_default.TAI);
var MetersPerKilometer = 1e3;
var RadiansPerDegree = Math_default.RADIANS_PER_DEGREE;
var RadiansPerArcSecond = Math_default.RADIANS_PER_ARCSECOND;
var MetersPerAstronomicalUnit = 14959787e4;
var perifocalToEquatorial = new Matrix3_default();
function elementsToCartesian(semimajorAxis, eccentricity, inclination, longitudeOfPerigee, longitudeOfNode, meanLongitude, result) {
  if (inclination < 0) {
    inclination = -inclination;
    longitudeOfNode += Math_default.PI;
  }
  if (inclination < 0 || inclination > Math_default.PI) {
    throw new DeveloperError_default(
      "The inclination is out of range. Inclination must be greater than or equal to zero and less than or equal to Pi radians."
    );
  }
  const radiusOfPeriapsis = semimajorAxis * (1 - eccentricity);
  const argumentOfPeriapsis = longitudeOfPerigee - longitudeOfNode;
  const rightAscensionOfAscendingNode = longitudeOfNode;
  const trueAnomaly = meanAnomalyToTrueAnomaly(
    meanLongitude - longitudeOfPerigee,
    eccentricity
  );
  const type = chooseOrbit(eccentricity, 0);
  if (type === "Hyperbolic" && Math.abs(Math_default.negativePiToPi(trueAnomaly)) >= Math.acos(-1 / eccentricity)) {
    throw new DeveloperError_default(
      "The true anomaly of the hyperbolic orbit lies outside of the bounds of the hyperbola."
    );
  }
  perifocalToCartesianMatrix(
    argumentOfPeriapsis,
    inclination,
    rightAscensionOfAscendingNode,
    perifocalToEquatorial
  );
  const semilatus = radiusOfPeriapsis * (1 + eccentricity);
  const costheta = Math.cos(trueAnomaly);
  const sintheta = Math.sin(trueAnomaly);
  const denom = 1 + eccentricity * costheta;
  if (denom <= Math_default.Epsilon10) {
    throw new DeveloperError_default("elements cannot be converted to cartesian");
  }
  const radius = semilatus / denom;
  if (!defined_default(result)) {
    result = new Cartesian3_default(radius * costheta, radius * sintheta, 0);
  } else {
    result.x = radius * costheta;
    result.y = radius * sintheta;
    result.z = 0;
  }
  return Matrix3_default.multiplyByVector(perifocalToEquatorial, result, result);
}
function chooseOrbit(eccentricity, tolerance) {
  if (eccentricity < 0) {
    throw new DeveloperError_default("eccentricity cannot be negative.");
  }
  if (eccentricity <= tolerance) {
    return "Circular";
  } else if (eccentricity < 1 - tolerance) {
    return "Elliptical";
  } else if (eccentricity <= 1 + tolerance) {
    return "Parabolic";
  }
  return "Hyperbolic";
}
function meanAnomalyToTrueAnomaly(meanAnomaly, eccentricity) {
  if (eccentricity < 0 || eccentricity >= 1) {
    throw new DeveloperError_default("eccentricity out of range.");
  }
  const eccentricAnomaly = meanAnomalyToEccentricAnomaly(
    meanAnomaly,
    eccentricity
  );
  return eccentricAnomalyToTrueAnomaly(eccentricAnomaly, eccentricity);
}
var maxIterationCount = 50;
var keplerEqConvergence = Math_default.EPSILON8;
function meanAnomalyToEccentricAnomaly(meanAnomaly, eccentricity) {
  if (eccentricity < 0 || eccentricity >= 1) {
    throw new DeveloperError_default("eccentricity out of range.");
  }
  const revs = Math.floor(meanAnomaly / Math_default.TWO_PI);
  meanAnomaly -= revs * Math_default.TWO_PI;
  let iterationValue = meanAnomaly + eccentricity * Math.sin(meanAnomaly) / (1 - Math.sin(meanAnomaly + eccentricity) + Math.sin(meanAnomaly));
  let eccentricAnomaly = Number.MAX_VALUE;
  let count;
  for (count = 0; count < maxIterationCount && Math.abs(eccentricAnomaly - iterationValue) > keplerEqConvergence; ++count) {
    eccentricAnomaly = iterationValue;
    const NRfunction = eccentricAnomaly - eccentricity * Math.sin(eccentricAnomaly) - meanAnomaly;
    const dNRfunction = 1 - eccentricity * Math.cos(eccentricAnomaly);
    iterationValue = eccentricAnomaly - NRfunction / dNRfunction;
  }
  if (count >= maxIterationCount) {
    throw new DeveloperError_default("Kepler equation did not converge");
  }
  eccentricAnomaly = iterationValue + revs * Math_default.TWO_PI;
  return eccentricAnomaly;
}
function eccentricAnomalyToTrueAnomaly(eccentricAnomaly, eccentricity) {
  if (eccentricity < 0 || eccentricity >= 1) {
    throw new DeveloperError_default("eccentricity out of range.");
  }
  const revs = Math.floor(eccentricAnomaly / Math_default.TWO_PI);
  eccentricAnomaly -= revs * Math_default.TWO_PI;
  const trueAnomalyX = Math.cos(eccentricAnomaly) - eccentricity;
  const trueAnomalyY = Math.sin(eccentricAnomaly) * Math.sqrt(1 - eccentricity * eccentricity);
  let trueAnomaly = Math.atan2(trueAnomalyY, trueAnomalyX);
  trueAnomaly = Math_default.zeroToTwoPi(trueAnomaly);
  if (eccentricAnomaly < 0) {
    trueAnomaly -= Math_default.TWO_PI;
  }
  trueAnomaly += revs * Math_default.TWO_PI;
  return trueAnomaly;
}
function perifocalToCartesianMatrix(argumentOfPeriapsis, inclination, rightAscension, result) {
  if (inclination < 0 || inclination > Math_default.PI) {
    throw new DeveloperError_default("inclination out of range");
  }
  const cosap = Math.cos(argumentOfPeriapsis);
  const sinap = Math.sin(argumentOfPeriapsis);
  const cosi = Math.cos(inclination);
  const sini = Math.sin(inclination);
  const cosraan = Math.cos(rightAscension);
  const sinraan = Math.sin(rightAscension);
  if (!defined_default(result)) {
    result = new Matrix3_default(
      cosraan * cosap - sinraan * sinap * cosi,
      -cosraan * sinap - sinraan * cosap * cosi,
      sinraan * sini,
      sinraan * cosap + cosraan * sinap * cosi,
      -sinraan * sinap + cosraan * cosap * cosi,
      -cosraan * sini,
      sinap * sini,
      cosap * sini,
      cosi
    );
  } else {
    result[0] = cosraan * cosap - sinraan * sinap * cosi;
    result[1] = sinraan * cosap + cosraan * sinap * cosi;
    result[2] = sinap * sini;
    result[3] = -cosraan * sinap - sinraan * cosap * cosi;
    result[4] = -sinraan * sinap + cosraan * cosap * cosi;
    result[5] = cosap * sini;
    result[6] = sinraan * sini;
    result[7] = -cosraan * sini;
    result[8] = cosi;
  }
  return result;
}
var semiMajorAxis0 = 1.0000010178 * MetersPerAstronomicalUnit;
var meanLongitude0 = 100.46645683 * RadiansPerDegree;
var meanLongitude1 = 129597742283429e-5 * RadiansPerArcSecond;
var p1u = 16002;
var p2u = 21863;
var p3u = 32004;
var p4u = 10931;
var p5u = 14529;
var p6u = 16368;
var p7u = 15318;
var p8u = 32794;
var Ca1 = 64 * 1e-7 * MetersPerAstronomicalUnit;
var Ca2 = -152 * 1e-7 * MetersPerAstronomicalUnit;
var Ca3 = 62 * 1e-7 * MetersPerAstronomicalUnit;
var Ca4 = -8 * 1e-7 * MetersPerAstronomicalUnit;
var Ca5 = 32 * 1e-7 * MetersPerAstronomicalUnit;
var Ca6 = -41 * 1e-7 * MetersPerAstronomicalUnit;
var Ca7 = 19 * 1e-7 * MetersPerAstronomicalUnit;
var Ca8 = -11 * 1e-7 * MetersPerAstronomicalUnit;
var Sa1 = -150 * 1e-7 * MetersPerAstronomicalUnit;
var Sa2 = -46 * 1e-7 * MetersPerAstronomicalUnit;
var Sa3 = 68 * 1e-7 * MetersPerAstronomicalUnit;
var Sa4 = 54 * 1e-7 * MetersPerAstronomicalUnit;
var Sa5 = 14 * 1e-7 * MetersPerAstronomicalUnit;
var Sa6 = 24 * 1e-7 * MetersPerAstronomicalUnit;
var Sa7 = -28 * 1e-7 * MetersPerAstronomicalUnit;
var Sa8 = 22 * 1e-7 * MetersPerAstronomicalUnit;
var q1u = 10;
var q2u = 16002;
var q3u = 21863;
var q4u = 10931;
var q5u = 1473;
var q6u = 32004;
var q7u = 4387;
var q8u = 73;
var Cl1 = -325 * 1e-7;
var Cl2 = -322 * 1e-7;
var Cl3 = -79 * 1e-7;
var Cl4 = 232 * 1e-7;
var Cl5 = -52 * 1e-7;
var Cl6 = 97 * 1e-7;
var Cl7 = 55 * 1e-7;
var Cl8 = -41 * 1e-7;
var Sl1 = -105 * 1e-7;
var Sl2 = -137 * 1e-7;
var Sl3 = 258 * 1e-7;
var Sl4 = 35 * 1e-7;
var Sl5 = -116 * 1e-7;
var Sl6 = -88 * 1e-7;
var Sl7 = -112 * 1e-7;
var Sl8 = -80 * 1e-7;
var scratchDate = new JulianDate_default(0, 0, TimeStandard_default.TAI);
function computeSimonEarthMoonBarycenter(date, result) {
  taiToTdb(date, scratchDate);
  const x = scratchDate.dayNumber - epoch.dayNumber + (scratchDate.secondsOfDay - epoch.secondsOfDay) / TimeConstants_default.SECONDS_PER_DAY;
  const t = x / (TimeConstants_default.DAYS_PER_JULIAN_CENTURY * 10);
  const u3 = 0.3595362 * t;
  const semimajorAxis = semiMajorAxis0 + Ca1 * Math.cos(p1u * u3) + Sa1 * Math.sin(p1u * u3) + Ca2 * Math.cos(p2u * u3) + Sa2 * Math.sin(p2u * u3) + Ca3 * Math.cos(p3u * u3) + Sa3 * Math.sin(p3u * u3) + Ca4 * Math.cos(p4u * u3) + Sa4 * Math.sin(p4u * u3) + Ca5 * Math.cos(p5u * u3) + Sa5 * Math.sin(p5u * u3) + Ca6 * Math.cos(p6u * u3) + Sa6 * Math.sin(p6u * u3) + Ca7 * Math.cos(p7u * u3) + Sa7 * Math.sin(p7u * u3) + Ca8 * Math.cos(p8u * u3) + Sa8 * Math.sin(p8u * u3);
  const meanLongitude = meanLongitude0 + meanLongitude1 * t + Cl1 * Math.cos(q1u * u3) + Sl1 * Math.sin(q1u * u3) + Cl2 * Math.cos(q2u * u3) + Sl2 * Math.sin(q2u * u3) + Cl3 * Math.cos(q3u * u3) + Sl3 * Math.sin(q3u * u3) + Cl4 * Math.cos(q4u * u3) + Sl4 * Math.sin(q4u * u3) + Cl5 * Math.cos(q5u * u3) + Sl5 * Math.sin(q5u * u3) + Cl6 * Math.cos(q6u * u3) + Sl6 * Math.sin(q6u * u3) + Cl7 * Math.cos(q7u * u3) + Sl7 * Math.sin(q7u * u3) + Cl8 * Math.cos(q8u * u3) + Sl8 * Math.sin(q8u * u3);
  const eccentricity = 0.0167086342 - 4203654e-10 * t;
  const longitudeOfPerigee = 102.93734808 * RadiansPerDegree + 11612.3529 * RadiansPerArcSecond * t;
  const inclination = 469.97289 * RadiansPerArcSecond * t;
  const longitudeOfNode = 174.87317577 * RadiansPerDegree - 8679.27034 * RadiansPerArcSecond * t;
  return elementsToCartesian(
    semimajorAxis,
    eccentricity,
    inclination,
    longitudeOfPerigee,
    longitudeOfNode,
    meanLongitude,
    result
  );
}
function computeSimonMoon(date, result) {
  taiToTdb(date, scratchDate);
  const x = scratchDate.dayNumber - epoch.dayNumber + (scratchDate.secondsOfDay - epoch.secondsOfDay) / TimeConstants_default.SECONDS_PER_DAY;
  const t = x / TimeConstants_default.DAYS_PER_JULIAN_CENTURY;
  const t2 = t * t;
  const t3 = t2 * t;
  const t4 = t3 * t;
  let semimajorAxis = 383397.7725 + 4e-3 * t;
  let eccentricity = 0.055545526 - 16e-9 * t;
  const inclinationConstant = 5.15668983 * RadiansPerDegree;
  let inclinationSecPart = -8e-5 * t + 0.02966 * t2 - 42e-6 * t3 - 13e-8 * t4;
  const longitudeOfPerigeeConstant = 83.35324312 * RadiansPerDegree;
  let longitudeOfPerigeeSecPart = 146434202669e-4 * t - 38.2702 * t2 - 0.045047 * t3 + 21301e-8 * t4;
  const longitudeOfNodeConstant = 125.04455501 * RadiansPerDegree;
  let longitudeOfNodeSecPart = -69679193631e-4 * t + 6.3602 * t2 + 7625e-6 * t3 - 3586e-8 * t4;
  const meanLongitudeConstant = 218.31664563 * RadiansPerDegree;
  let meanLongitudeSecPart = 17325593434847e-4 * t - 6.391 * t2 + 6588e-6 * t3 - 3169e-8 * t4;
  const D = 297.85019547 * RadiansPerDegree + RadiansPerArcSecond * (1602961601209e-3 * t - 6.3706 * t2 + 6593e-6 * t3 - 3169e-8 * t4);
  const F = 93.27209062 * RadiansPerDegree + RadiansPerArcSecond * (17395272628478e-4 * t - 12.7512 * t2 - 1037e-6 * t3 + 417e-8 * t4);
  const l2 = 134.96340251 * RadiansPerDegree + RadiansPerArcSecond * (17179159232178e-4 * t + 31.8792 * t2 + 0.051635 * t3 - 2447e-7 * t4);
  const lprime = 357.52910918 * RadiansPerDegree + RadiansPerArcSecond * (1295965810481e-4 * t - 0.5532 * t2 + 136e-6 * t3 - 1149e-8 * t4);
  const psi = 310.17137918 * RadiansPerDegree - RadiansPerArcSecond * (6967051436e-3 * t + 6.2068 * t2 + 7618e-6 * t3 - 3219e-8 * t4);
  const twoD = 2 * D;
  const fourD = 4 * D;
  const sixD = 6 * D;
  const twol = 2 * l2;
  const threel = 3 * l2;
  const fourl = 4 * l2;
  const twoF = 2 * F;
  semimajorAxis += 3400.4 * Math.cos(twoD) - 635.6 * Math.cos(twoD - l2) - 235.6 * Math.cos(l2) + 218.1 * Math.cos(twoD - lprime) + 181 * Math.cos(twoD + l2);
  eccentricity += 0.014216 * Math.cos(twoD - l2) + 8551e-6 * Math.cos(twoD - twol) - 1383e-6 * Math.cos(l2) + 1356e-6 * Math.cos(twoD + l2) - 1147e-6 * Math.cos(fourD - threel) - 914e-6 * Math.cos(fourD - twol) + 869e-6 * Math.cos(twoD - lprime - l2) - 627e-6 * Math.cos(twoD) - 394e-6 * Math.cos(fourD - fourl) + 282e-6 * Math.cos(twoD - lprime - twol) - 279e-6 * Math.cos(D - l2) - 236e-6 * Math.cos(twol) + 231e-6 * Math.cos(fourD) + 229e-6 * Math.cos(sixD - fourl) - 201e-6 * Math.cos(twol - twoF);
  inclinationSecPart += 486.26 * Math.cos(twoD - twoF) - 40.13 * Math.cos(twoD) + 37.51 * Math.cos(twoF) + 25.73 * Math.cos(twol - twoF) + 19.97 * Math.cos(twoD - lprime - twoF);
  longitudeOfPerigeeSecPart += -55609 * Math.sin(twoD - l2) - 34711 * Math.sin(twoD - twol) - 9792 * Math.sin(l2) + 9385 * Math.sin(fourD - threel) + 7505 * Math.sin(fourD - twol) + 5318 * Math.sin(twoD + l2) + 3484 * Math.sin(fourD - fourl) - 3417 * Math.sin(twoD - lprime - l2) - 2530 * Math.sin(sixD - fourl) - 2376 * Math.sin(twoD) - 2075 * Math.sin(twoD - threel) - 1883 * Math.sin(twol) - 1736 * Math.sin(sixD - 5 * l2) + 1626 * Math.sin(lprime) - 1370 * Math.sin(sixD - threel);
  longitudeOfNodeSecPart += -5392 * Math.sin(twoD - twoF) - 540 * Math.sin(lprime) - 441 * Math.sin(twoD) + 423 * Math.sin(twoF) - 288 * Math.sin(twol - twoF);
  meanLongitudeSecPart += -3332.9 * Math.sin(twoD) + 1197.4 * Math.sin(twoD - l2) - 662.5 * Math.sin(lprime) + 396.3 * Math.sin(l2) - 218 * Math.sin(twoD - lprime);
  const twoPsi = 2 * psi;
  const threePsi = 3 * psi;
  inclinationSecPart += 46.997 * Math.cos(psi) * t - 0.614 * Math.cos(twoD - twoF + psi) * t + 0.614 * Math.cos(twoD - twoF - psi) * t - 0.0297 * Math.cos(twoPsi) * t2 - 0.0335 * Math.cos(psi) * t2 + 12e-4 * Math.cos(twoD - twoF + twoPsi) * t2 - 16e-5 * Math.cos(psi) * t3 + 4e-5 * Math.cos(threePsi) * t3 + 4e-5 * Math.cos(twoPsi) * t3;
  const perigeeAndMean = 2.116 * Math.sin(psi) * t - 0.111 * Math.sin(twoD - twoF - psi) * t - 15e-4 * Math.sin(psi) * t2;
  longitudeOfPerigeeSecPart += perigeeAndMean;
  meanLongitudeSecPart += perigeeAndMean;
  longitudeOfNodeSecPart += -520.77 * Math.sin(psi) * t + 13.66 * Math.sin(twoD - twoF + psi) * t + 1.12 * Math.sin(twoD - psi) * t - 1.06 * Math.sin(twoF - psi) * t + 0.66 * Math.sin(twoPsi) * t2 + 0.371 * Math.sin(psi) * t2 - 0.035 * Math.sin(twoD - twoF + twoPsi) * t2 - 0.015 * Math.sin(twoD - twoF + psi) * t2 + 14e-4 * Math.sin(psi) * t3 - 11e-4 * Math.sin(threePsi) * t3 - 9e-4 * Math.sin(twoPsi) * t3;
  semimajorAxis *= MetersPerKilometer;
  const inclination = inclinationConstant + inclinationSecPart * RadiansPerArcSecond;
  const longitudeOfPerigee = longitudeOfPerigeeConstant + longitudeOfPerigeeSecPart * RadiansPerArcSecond;
  const meanLongitude = meanLongitudeConstant + meanLongitudeSecPart * RadiansPerArcSecond;
  const longitudeOfNode = longitudeOfNodeConstant + longitudeOfNodeSecPart * RadiansPerArcSecond;
  return elementsToCartesian(
    semimajorAxis,
    eccentricity,
    inclination,
    longitudeOfPerigee,
    longitudeOfNode,
    meanLongitude,
    result
  );
}
var moonEarthMassRatio = 0.012300034;
var factor = moonEarthMassRatio / (moonEarthMassRatio + 1) * -1;
function computeSimonEarth(date, result) {
  result = computeSimonMoon(date, result);
  return Cartesian3_default.multiplyByScalar(result, factor, result);
}
var axesTransformation = new Matrix3_default(
  1.0000000000000002,
  5619723173785822e-31,
  4690511510146299e-34,
  -5154129427414611e-31,
  0.9174820620691819,
  -0.39777715593191376,
  -223970096136568e-30,
  0.39777715593191376,
  0.9174820620691819
);
var translation2 = new Cartesian3_default();
Simon1994PlanetaryPositions.computeSunPositionInEarthInertialFrame = function(julianDate, result) {
  if (!defined_default(julianDate)) {
    julianDate = JulianDate_default.now();
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  translation2 = computeSimonEarthMoonBarycenter(julianDate, translation2);
  result = Cartesian3_default.negate(translation2, result);
  computeSimonEarth(julianDate, translation2);
  Cartesian3_default.subtract(result, translation2, result);
  Matrix3_default.multiplyByVector(axesTransformation, result, result);
  return result;
};
Simon1994PlanetaryPositions.computeMoonPositionInEarthInertialFrame = function(julianDate, result) {
  if (!defined_default(julianDate)) {
    julianDate = JulianDate_default.now();
  }
  result = computeSimonMoon(julianDate, result);
  Matrix3_default.multiplyByVector(axesTransformation, result, result);
  return result;
};
var Simon1994PlanetaryPositions_default = Simon1994PlanetaryPositions;

// node_modules/cesium/Source/Core/SimplePolylineGeometry.js
function interpolateColors2(p0, p1, color0, color1, minDistance, array, offset2) {
  const numPoints = PolylinePipeline_default.numberOfPoints(p0, p1, minDistance);
  let i2;
  const r0 = color0.red;
  const g0 = color0.green;
  const b0 = color0.blue;
  const a0 = color0.alpha;
  const r1 = color1.red;
  const g1 = color1.green;
  const b1 = color1.blue;
  const a1 = color1.alpha;
  if (Color_default.equals(color0, color1)) {
    for (i2 = 0; i2 < numPoints; i2++) {
      array[offset2++] = Color_default.floatToByte(r0);
      array[offset2++] = Color_default.floatToByte(g0);
      array[offset2++] = Color_default.floatToByte(b0);
      array[offset2++] = Color_default.floatToByte(a0);
    }
    return offset2;
  }
  const redPerVertex = (r1 - r0) / numPoints;
  const greenPerVertex = (g1 - g0) / numPoints;
  const bluePerVertex = (b1 - b0) / numPoints;
  const alphaPerVertex = (a1 - a0) / numPoints;
  let index2 = offset2;
  for (i2 = 0; i2 < numPoints; i2++) {
    array[index2++] = Color_default.floatToByte(r0 + i2 * redPerVertex);
    array[index2++] = Color_default.floatToByte(g0 + i2 * greenPerVertex);
    array[index2++] = Color_default.floatToByte(b0 + i2 * bluePerVertex);
    array[index2++] = Color_default.floatToByte(a0 + i2 * alphaPerVertex);
  }
  return index2;
}
function SimplePolylineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.positions;
  const colors = options.colors;
  const colorsPerVertex = defaultValue_default(options.colorsPerVertex, false);
  if (!defined_default(positions) || positions.length < 2) {
    throw new DeveloperError_default("At least two positions are required.");
  }
  if (defined_default(colors) && (colorsPerVertex && colors.length < positions.length || !colorsPerVertex && colors.length < positions.length - 1)) {
    throw new DeveloperError_default("colors has an invalid length.");
  }
  this._positions = positions;
  this._colors = colors;
  this._colorsPerVertex = colorsPerVertex;
  this._arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
  this._granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._workerName = "createSimplePolylineGeometry";
  let numComponents = 1 + positions.length * Cartesian3_default.packedLength;
  numComponents += defined_default(colors) ? 1 + colors.length * Color_default.packedLength : 1;
  this.packedLength = numComponents + Ellipsoid_default.packedLength + 3;
}
SimplePolylineGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  const positions = value._positions;
  let length3 = positions.length;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    Cartesian3_default.pack(positions[i2], array, startingIndex);
  }
  const colors = value._colors;
  length3 = defined_default(colors) ? colors.length : 0;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Color_default.packedLength) {
    Color_default.pack(colors[i2], array, startingIndex);
  }
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  array[startingIndex++] = value._colorsPerVertex ? 1 : 0;
  array[startingIndex++] = value._arcType;
  array[startingIndex] = value._granularity;
  return array;
};
SimplePolylineGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  let length3 = array[startingIndex++];
  const positions = new Array(length3);
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    positions[i2] = Cartesian3_default.unpack(array, startingIndex);
  }
  length3 = array[startingIndex++];
  const colors = length3 > 0 ? new Array(length3) : void 0;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Color_default.packedLength) {
    colors[i2] = Color_default.unpack(array, startingIndex);
  }
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  const colorsPerVertex = array[startingIndex++] === 1;
  const arcType = array[startingIndex++];
  const granularity = array[startingIndex];
  if (!defined_default(result)) {
    return new SimplePolylineGeometry({
      positions,
      colors,
      ellipsoid,
      colorsPerVertex,
      arcType,
      granularity
    });
  }
  result._positions = positions;
  result._colors = colors;
  result._ellipsoid = ellipsoid;
  result._colorsPerVertex = colorsPerVertex;
  result._arcType = arcType;
  result._granularity = granularity;
  return result;
};
var scratchArray1 = new Array(2);
var scratchArray2 = new Array(2);
var generateArcOptionsScratch = {
  positions: scratchArray1,
  height: scratchArray2,
  ellipsoid: void 0,
  minDistance: void 0,
  granularity: void 0
};
SimplePolylineGeometry.createGeometry = function(simplePolylineGeometry) {
  const positions = simplePolylineGeometry._positions;
  const colors = simplePolylineGeometry._colors;
  const colorsPerVertex = simplePolylineGeometry._colorsPerVertex;
  const arcType = simplePolylineGeometry._arcType;
  const granularity = simplePolylineGeometry._granularity;
  const ellipsoid = simplePolylineGeometry._ellipsoid;
  const minDistance = Math_default.chordLength(
    granularity,
    ellipsoid.maximumRadius
  );
  const perSegmentColors = defined_default(colors) && !colorsPerVertex;
  let i2;
  const length3 = positions.length;
  let positionValues;
  let numberOfPositions;
  let colorValues;
  let color;
  let offset2 = 0;
  if (arcType === ArcType_default.GEODESIC || arcType === ArcType_default.RHUMB) {
    let subdivisionSize;
    let numberOfPointsFunction;
    let generateArcFunction;
    if (arcType === ArcType_default.GEODESIC) {
      subdivisionSize = Math_default.chordLength(
        granularity,
        ellipsoid.maximumRadius
      );
      numberOfPointsFunction = PolylinePipeline_default.numberOfPoints;
      generateArcFunction = PolylinePipeline_default.generateArc;
    } else {
      subdivisionSize = granularity;
      numberOfPointsFunction = PolylinePipeline_default.numberOfPointsRhumbLine;
      generateArcFunction = PolylinePipeline_default.generateRhumbArc;
    }
    const heights = PolylinePipeline_default.extractHeights(positions, ellipsoid);
    const generateArcOptions = generateArcOptionsScratch;
    if (arcType === ArcType_default.GEODESIC) {
      generateArcOptions.minDistance = minDistance;
    } else {
      generateArcOptions.granularity = granularity;
    }
    generateArcOptions.ellipsoid = ellipsoid;
    if (perSegmentColors) {
      let positionCount = 0;
      for (i2 = 0; i2 < length3 - 1; i2++) {
        positionCount += numberOfPointsFunction(
          positions[i2],
          positions[i2 + 1],
          subdivisionSize
        ) + 1;
      }
      positionValues = new Float64Array(positionCount * 3);
      colorValues = new Uint8Array(positionCount * 4);
      generateArcOptions.positions = scratchArray1;
      generateArcOptions.height = scratchArray2;
      let ci = 0;
      for (i2 = 0; i2 < length3 - 1; ++i2) {
        scratchArray1[0] = positions[i2];
        scratchArray1[1] = positions[i2 + 1];
        scratchArray2[0] = heights[i2];
        scratchArray2[1] = heights[i2 + 1];
        const pos = generateArcFunction(generateArcOptions);
        if (defined_default(colors)) {
          const segLen = pos.length / 3;
          color = colors[i2];
          for (let k = 0; k < segLen; ++k) {
            colorValues[ci++] = Color_default.floatToByte(color.red);
            colorValues[ci++] = Color_default.floatToByte(color.green);
            colorValues[ci++] = Color_default.floatToByte(color.blue);
            colorValues[ci++] = Color_default.floatToByte(color.alpha);
          }
        }
        positionValues.set(pos, offset2);
        offset2 += pos.length;
      }
    } else {
      generateArcOptions.positions = positions;
      generateArcOptions.height = heights;
      positionValues = new Float64Array(
        generateArcFunction(generateArcOptions)
      );
      if (defined_default(colors)) {
        colorValues = new Uint8Array(positionValues.length / 3 * 4);
        for (i2 = 0; i2 < length3 - 1; ++i2) {
          const p0 = positions[i2];
          const p1 = positions[i2 + 1];
          const c0 = colors[i2];
          const c14 = colors[i2 + 1];
          offset2 = interpolateColors2(
            p0,
            p1,
            c0,
            c14,
            minDistance,
            colorValues,
            offset2
          );
        }
        const lastColor = colors[length3 - 1];
        colorValues[offset2++] = Color_default.floatToByte(lastColor.red);
        colorValues[offset2++] = Color_default.floatToByte(lastColor.green);
        colorValues[offset2++] = Color_default.floatToByte(lastColor.blue);
        colorValues[offset2++] = Color_default.floatToByte(lastColor.alpha);
      }
    }
  } else {
    numberOfPositions = perSegmentColors ? length3 * 2 - 2 : length3;
    positionValues = new Float64Array(numberOfPositions * 3);
    colorValues = defined_default(colors) ? new Uint8Array(numberOfPositions * 4) : void 0;
    let positionIndex = 0;
    let colorIndex = 0;
    for (i2 = 0; i2 < length3; ++i2) {
      const p2 = positions[i2];
      if (perSegmentColors && i2 > 0) {
        Cartesian3_default.pack(p2, positionValues, positionIndex);
        positionIndex += 3;
        color = colors[i2 - 1];
        colorValues[colorIndex++] = Color_default.floatToByte(color.red);
        colorValues[colorIndex++] = Color_default.floatToByte(color.green);
        colorValues[colorIndex++] = Color_default.floatToByte(color.blue);
        colorValues[colorIndex++] = Color_default.floatToByte(color.alpha);
      }
      if (perSegmentColors && i2 === length3 - 1) {
        break;
      }
      Cartesian3_default.pack(p2, positionValues, positionIndex);
      positionIndex += 3;
      if (defined_default(colors)) {
        color = colors[i2];
        colorValues[colorIndex++] = Color_default.floatToByte(color.red);
        colorValues[colorIndex++] = Color_default.floatToByte(color.green);
        colorValues[colorIndex++] = Color_default.floatToByte(color.blue);
        colorValues[colorIndex++] = Color_default.floatToByte(color.alpha);
      }
    }
  }
  const attributes = new GeometryAttributes_default();
  attributes.position = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.DOUBLE,
    componentsPerAttribute: 3,
    values: positionValues
  });
  if (defined_default(colors)) {
    attributes.color = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 4,
      values: colorValues,
      normalize: true
    });
  }
  numberOfPositions = positionValues.length / 3;
  const numberOfIndices = (numberOfPositions - 1) * 2;
  const indices2 = IndexDatatype_default.createTypedArray(
    numberOfPositions,
    numberOfIndices
  );
  let index2 = 0;
  for (i2 = 0; i2 < numberOfPositions - 1; ++i2) {
    indices2[index2++] = i2;
    indices2[index2++] = i2 + 1;
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere: BoundingSphere_default.fromPoints(positions)
  });
};
var SimplePolylineGeometry_default = SimplePolylineGeometry;

// node_modules/cesium/Source/Core/SphereGeometry.js
function SphereGeometry(options) {
  const radius = defaultValue_default(options.radius, 1);
  const radii = new Cartesian3_default(radius, radius, radius);
  const ellipsoidOptions = {
    radii,
    stackPartitions: options.stackPartitions,
    slicePartitions: options.slicePartitions,
    vertexFormat: options.vertexFormat
  };
  this._ellipsoidGeometry = new EllipsoidGeometry_default(ellipsoidOptions);
  this._workerName = "createSphereGeometry";
}
SphereGeometry.packedLength = EllipsoidGeometry_default.packedLength;
SphereGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  return EllipsoidGeometry_default.pack(value._ellipsoidGeometry, array, startingIndex);
};
var scratchEllipsoidGeometry = new EllipsoidGeometry_default();
var scratchOptions21 = {
  radius: void 0,
  radii: new Cartesian3_default(),
  vertexFormat: new VertexFormat_default(),
  stackPartitions: void 0,
  slicePartitions: void 0
};
SphereGeometry.unpack = function(array, startingIndex, result) {
  const ellipsoidGeometry = EllipsoidGeometry_default.unpack(
    array,
    startingIndex,
    scratchEllipsoidGeometry
  );
  scratchOptions21.vertexFormat = VertexFormat_default.clone(
    ellipsoidGeometry._vertexFormat,
    scratchOptions21.vertexFormat
  );
  scratchOptions21.stackPartitions = ellipsoidGeometry._stackPartitions;
  scratchOptions21.slicePartitions = ellipsoidGeometry._slicePartitions;
  if (!defined_default(result)) {
    scratchOptions21.radius = ellipsoidGeometry._radii.x;
    return new SphereGeometry(scratchOptions21);
  }
  Cartesian3_default.clone(ellipsoidGeometry._radii, scratchOptions21.radii);
  result._ellipsoidGeometry = new EllipsoidGeometry_default(scratchOptions21);
  return result;
};
SphereGeometry.createGeometry = function(sphereGeometry) {
  return EllipsoidGeometry_default.createGeometry(sphereGeometry._ellipsoidGeometry);
};
var SphereGeometry_default = SphereGeometry;

// node_modules/cesium/Source/Core/SphereOutlineGeometry.js
function SphereOutlineGeometry(options) {
  const radius = defaultValue_default(options.radius, 1);
  const radii = new Cartesian3_default(radius, radius, radius);
  const ellipsoidOptions = {
    radii,
    stackPartitions: options.stackPartitions,
    slicePartitions: options.slicePartitions,
    subdivisions: options.subdivisions
  };
  this._ellipsoidGeometry = new EllipsoidOutlineGeometry_default(ellipsoidOptions);
  this._workerName = "createSphereOutlineGeometry";
}
SphereOutlineGeometry.packedLength = EllipsoidOutlineGeometry_default.packedLength;
SphereOutlineGeometry.pack = function(value, array, startingIndex) {
  Check_default.typeOf.object("value", value);
  return EllipsoidOutlineGeometry_default.pack(
    value._ellipsoidGeometry,
    array,
    startingIndex
  );
};
var scratchEllipsoidGeometry2 = new EllipsoidOutlineGeometry_default();
var scratchOptions22 = {
  radius: void 0,
  radii: new Cartesian3_default(),
  stackPartitions: void 0,
  slicePartitions: void 0,
  subdivisions: void 0
};
SphereOutlineGeometry.unpack = function(array, startingIndex, result) {
  const ellipsoidGeometry = EllipsoidOutlineGeometry_default.unpack(
    array,
    startingIndex,
    scratchEllipsoidGeometry2
  );
  scratchOptions22.stackPartitions = ellipsoidGeometry._stackPartitions;
  scratchOptions22.slicePartitions = ellipsoidGeometry._slicePartitions;
  scratchOptions22.subdivisions = ellipsoidGeometry._subdivisions;
  if (!defined_default(result)) {
    scratchOptions22.radius = ellipsoidGeometry._radii.x;
    return new SphereOutlineGeometry(scratchOptions22);
  }
  Cartesian3_default.clone(ellipsoidGeometry._radii, scratchOptions22.radii);
  result._ellipsoidGeometry = new EllipsoidOutlineGeometry_default(scratchOptions22);
  return result;
};
SphereOutlineGeometry.createGeometry = function(sphereGeometry) {
  return EllipsoidOutlineGeometry_default.createGeometry(
    sphereGeometry._ellipsoidGeometry
  );
};
var SphereOutlineGeometry_default = SphereOutlineGeometry;

// node_modules/cesium/Source/Core/Spherical.js
function Spherical(clock, cone, magnitude) {
  this.clock = defaultValue_default(clock, 0);
  this.cone = defaultValue_default(cone, 0);
  this.magnitude = defaultValue_default(magnitude, 1);
}
Spherical.fromCartesian3 = function(cartesian34, result) {
  Check_default.typeOf.object("cartesian3", cartesian34);
  const x = cartesian34.x;
  const y = cartesian34.y;
  const z = cartesian34.z;
  const radialSquared = x * x + y * y;
  if (!defined_default(result)) {
    result = new Spherical();
  }
  result.clock = Math.atan2(y, x);
  result.cone = Math.atan2(Math.sqrt(radialSquared), z);
  result.magnitude = Math.sqrt(radialSquared + z * z);
  return result;
};
Spherical.clone = function(spherical, result) {
  if (!defined_default(spherical)) {
    return void 0;
  }
  if (!defined_default(result)) {
    return new Spherical(spherical.clock, spherical.cone, spherical.magnitude);
  }
  result.clock = spherical.clock;
  result.cone = spherical.cone;
  result.magnitude = spherical.magnitude;
  return result;
};
Spherical.normalize = function(spherical, result) {
  Check_default.typeOf.object("spherical", spherical);
  if (!defined_default(result)) {
    return new Spherical(spherical.clock, spherical.cone, 1);
  }
  result.clock = spherical.clock;
  result.cone = spherical.cone;
  result.magnitude = 1;
  return result;
};
Spherical.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left.clock === right.clock && left.cone === right.cone && left.magnitude === right.magnitude;
};
Spherical.equalsEpsilon = function(left, right, epsilon) {
  epsilon = defaultValue_default(epsilon, 0);
  return left === right || defined_default(left) && defined_default(right) && Math.abs(left.clock - right.clock) <= epsilon && Math.abs(left.cone - right.cone) <= epsilon && Math.abs(left.magnitude - right.magnitude) <= epsilon;
};
Spherical.prototype.equals = function(other) {
  return Spherical.equals(this, other);
};
Spherical.prototype.clone = function(result) {
  return Spherical.clone(this, result);
};
Spherical.prototype.equalsEpsilon = function(other, epsilon) {
  return Spherical.equalsEpsilon(this, other, epsilon);
};
Spherical.prototype.toString = function() {
  return `(${this.clock}, ${this.cone}, ${this.magnitude})`;
};
var Spherical_default = Spherical;

// node_modules/cesium/Source/Core/SteppedSpline.js
function SteppedSpline(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const points = options.points;
  const times = options.times;
  if (!defined_default(points) || !defined_default(times)) {
    throw new DeveloperError_default("points and times are required.");
  }
  if (points.length < 2) {
    throw new DeveloperError_default(
      "points.length must be greater than or equal to 2."
    );
  }
  if (times.length !== points.length) {
    throw new DeveloperError_default("times.length must be equal to points.length.");
  }
  this._times = times;
  this._points = points;
  this._pointType = Spline_default.getPointType(points[0]);
  this._lastTimeIndex = 0;
}
Object.defineProperties(SteppedSpline.prototype, {
  times: {
    get: function() {
      return this._times;
    }
  },
  points: {
    get: function() {
      return this._points;
    }
  }
});
SteppedSpline.prototype.findTimeInterval = Spline_default.prototype.findTimeInterval;
SteppedSpline.prototype.wrapTime = Spline_default.prototype.wrapTime;
SteppedSpline.prototype.clampTime = Spline_default.prototype.clampTime;
SteppedSpline.prototype.evaluate = function(time, result) {
  const points = this.points;
  this._lastTimeIndex = this.findTimeInterval(time, this._lastTimeIndex);
  const i2 = this._lastTimeIndex;
  const PointType = this._pointType;
  if (PointType === Number) {
    return points[i2];
  }
  if (!defined_default(result)) {
    result = new PointType();
  }
  return PointType.clone(points[i2], result);
};
var SteppedSpline_default = SteppedSpline;

// node_modules/cesium/Source/Core/TileEdge.js
var TileEdge = {
  WEST: 0,
  NORTH: 1,
  EAST: 2,
  SOUTH: 3,
  NORTHWEST: 4,
  NORTHEAST: 5,
  SOUTHWEST: 6,
  SOUTHEAST: 7
};
var TileEdge_default = TileEdge;

// node_modules/cesium/Source/Core/TilingScheme.js
function TilingScheme(options) {
  throw new DeveloperError_default(
    "This type should not be instantiated directly.  Instead, use WebMercatorTilingScheme or GeographicTilingScheme."
  );
}
Object.defineProperties(TilingScheme.prototype, {
  ellipsoid: {
    get: DeveloperError_default.throwInstantiationError
  },
  rectangle: {
    get: DeveloperError_default.throwInstantiationError
  },
  projection: {
    get: DeveloperError_default.throwInstantiationError
  }
});
TilingScheme.prototype.getNumberOfXTilesAtLevel = DeveloperError_default.throwInstantiationError;
TilingScheme.prototype.getNumberOfYTilesAtLevel = DeveloperError_default.throwInstantiationError;
TilingScheme.prototype.rectangleToNativeRectangle = DeveloperError_default.throwInstantiationError;
TilingScheme.prototype.tileXYToNativeRectangle = DeveloperError_default.throwInstantiationError;
TilingScheme.prototype.tileXYToRectangle = DeveloperError_default.throwInstantiationError;
TilingScheme.prototype.positionToTileXY = DeveloperError_default.throwInstantiationError;
var TilingScheme_default = TilingScheme;

// node_modules/cesium/Source/Core/TimeIntervalCollection.js
function compareIntervalStartTimes(left, right) {
  return JulianDate_default.compare(left.start, right.start);
}
function TimeIntervalCollection(intervals) {
  this._intervals = [];
  this._changedEvent = new Event_default();
  if (defined_default(intervals)) {
    const length3 = intervals.length;
    for (let i2 = 0; i2 < length3; i2++) {
      this.addInterval(intervals[i2]);
    }
  }
}
Object.defineProperties(TimeIntervalCollection.prototype, {
  changedEvent: {
    get: function() {
      return this._changedEvent;
    }
  },
  start: {
    get: function() {
      const intervals = this._intervals;
      return intervals.length === 0 ? void 0 : intervals[0].start;
    }
  },
  isStartIncluded: {
    get: function() {
      const intervals = this._intervals;
      return intervals.length === 0 ? false : intervals[0].isStartIncluded;
    }
  },
  stop: {
    get: function() {
      const intervals = this._intervals;
      const length3 = intervals.length;
      return length3 === 0 ? void 0 : intervals[length3 - 1].stop;
    }
  },
  isStopIncluded: {
    get: function() {
      const intervals = this._intervals;
      const length3 = intervals.length;
      return length3 === 0 ? false : intervals[length3 - 1].isStopIncluded;
    }
  },
  length: {
    get: function() {
      return this._intervals.length;
    }
  },
  isEmpty: {
    get: function() {
      return this._intervals.length === 0;
    }
  }
});
TimeIntervalCollection.prototype.equals = function(right, dataComparer) {
  if (this === right) {
    return true;
  }
  if (!(right instanceof TimeIntervalCollection)) {
    return false;
  }
  const intervals = this._intervals;
  const rightIntervals = right._intervals;
  const length3 = intervals.length;
  if (length3 !== rightIntervals.length) {
    return false;
  }
  for (let i2 = 0; i2 < length3; i2++) {
    if (!TimeInterval_default.equals(intervals[i2], rightIntervals[i2], dataComparer)) {
      return false;
    }
  }
  return true;
};
TimeIntervalCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.");
  }
  return this._intervals[index2];
};
TimeIntervalCollection.prototype.removeAll = function() {
  if (this._intervals.length > 0) {
    this._intervals.length = 0;
    this._changedEvent.raiseEvent(this);
  }
};
TimeIntervalCollection.prototype.findIntervalContainingDate = function(date) {
  const index2 = this.indexOf(date);
  return index2 >= 0 ? this._intervals[index2] : void 0;
};
TimeIntervalCollection.prototype.findDataForIntervalContainingDate = function(date) {
  const index2 = this.indexOf(date);
  return index2 >= 0 ? this._intervals[index2].data : void 0;
};
TimeIntervalCollection.prototype.contains = function(julianDate) {
  return this.indexOf(julianDate) >= 0;
};
var indexOfScratch = new TimeInterval_default();
TimeIntervalCollection.prototype.indexOf = function(date) {
  if (!defined_default(date)) {
    throw new DeveloperError_default("date is required");
  }
  const intervals = this._intervals;
  indexOfScratch.start = date;
  indexOfScratch.stop = date;
  let index2 = binarySearch_default(
    intervals,
    indexOfScratch,
    compareIntervalStartTimes
  );
  if (index2 >= 0) {
    if (intervals[index2].isStartIncluded) {
      return index2;
    }
    if (index2 > 0 && intervals[index2 - 1].stop.equals(date) && intervals[index2 - 1].isStopIncluded) {
      return index2 - 1;
    }
    return ~index2;
  }
  index2 = ~index2;
  if (index2 > 0 && index2 - 1 < intervals.length && TimeInterval_default.contains(intervals[index2 - 1], date)) {
    return index2 - 1;
  }
  return ~index2;
};
TimeIntervalCollection.prototype.findInterval = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const start = options.start;
  const stop2 = options.stop;
  const isStartIncluded = options.isStartIncluded;
  const isStopIncluded = options.isStopIncluded;
  const intervals = this._intervals;
  for (let i2 = 0, len = intervals.length; i2 < len; i2++) {
    const interval = intervals[i2];
    if ((!defined_default(start) || interval.start.equals(start)) && (!defined_default(stop2) || interval.stop.equals(stop2)) && (!defined_default(isStartIncluded) || interval.isStartIncluded === isStartIncluded) && (!defined_default(isStopIncluded) || interval.isStopIncluded === isStopIncluded)) {
      return intervals[i2];
    }
  }
  return void 0;
};
TimeIntervalCollection.prototype.addInterval = function(interval, dataComparer) {
  if (!defined_default(interval)) {
    throw new DeveloperError_default("interval is required");
  }
  if (interval.isEmpty) {
    return;
  }
  const intervals = this._intervals;
  if (intervals.length === 0 || JulianDate_default.greaterThan(interval.start, intervals[intervals.length - 1].stop)) {
    intervals.push(interval);
    this._changedEvent.raiseEvent(this);
    return;
  }
  let index2 = binarySearch_default(intervals, interval, compareIntervalStartTimes);
  if (index2 < 0) {
    index2 = ~index2;
  } else {
    if (index2 > 0 && interval.isStartIncluded && intervals[index2 - 1].isStartIncluded && intervals[index2 - 1].start.equals(interval.start)) {
      --index2;
    } else if (index2 < intervals.length && !interval.isStartIncluded && intervals[index2].isStartIncluded && intervals[index2].start.equals(interval.start)) {
      ++index2;
    }
  }
  let comparison;
  if (index2 > 0) {
    comparison = JulianDate_default.compare(intervals[index2 - 1].stop, interval.start);
    if (comparison > 0 || comparison === 0 && (intervals[index2 - 1].isStopIncluded || interval.isStartIncluded)) {
      if (defined_default(dataComparer) ? dataComparer(intervals[index2 - 1].data, interval.data) : intervals[index2 - 1].data === interval.data) {
        if (JulianDate_default.greaterThan(interval.stop, intervals[index2 - 1].stop)) {
          interval = new TimeInterval_default({
            start: intervals[index2 - 1].start,
            stop: interval.stop,
            isStartIncluded: intervals[index2 - 1].isStartIncluded,
            isStopIncluded: interval.isStopIncluded,
            data: interval.data
          });
        } else {
          interval = new TimeInterval_default({
            start: intervals[index2 - 1].start,
            stop: intervals[index2 - 1].stop,
            isStartIncluded: intervals[index2 - 1].isStartIncluded,
            isStopIncluded: intervals[index2 - 1].isStopIncluded || interval.stop.equals(intervals[index2 - 1].stop) && interval.isStopIncluded,
            data: interval.data
          });
        }
        intervals.splice(index2 - 1, 1);
        --index2;
      } else {
        comparison = JulianDate_default.compare(
          intervals[index2 - 1].stop,
          interval.stop
        );
        if (comparison > 0 || comparison === 0 && intervals[index2 - 1].isStopIncluded && !interval.isStopIncluded) {
          intervals.splice(
            index2,
            0,
            new TimeInterval_default({
              start: interval.stop,
              stop: intervals[index2 - 1].stop,
              isStartIncluded: !interval.isStopIncluded,
              isStopIncluded: intervals[index2 - 1].isStopIncluded,
              data: intervals[index2 - 1].data
            })
          );
        }
        intervals[index2 - 1] = new TimeInterval_default({
          start: intervals[index2 - 1].start,
          stop: interval.start,
          isStartIncluded: intervals[index2 - 1].isStartIncluded,
          isStopIncluded: !interval.isStartIncluded,
          data: intervals[index2 - 1].data
        });
      }
    }
  }
  while (index2 < intervals.length) {
    comparison = JulianDate_default.compare(interval.stop, intervals[index2].start);
    if (comparison > 0 || comparison === 0 && (interval.isStopIncluded || intervals[index2].isStartIncluded)) {
      if (defined_default(dataComparer) ? dataComparer(intervals[index2].data, interval.data) : intervals[index2].data === interval.data) {
        interval = new TimeInterval_default({
          start: interval.start,
          stop: JulianDate_default.greaterThan(intervals[index2].stop, interval.stop) ? intervals[index2].stop : interval.stop,
          isStartIncluded: interval.isStartIncluded,
          isStopIncluded: JulianDate_default.greaterThan(
            intervals[index2].stop,
            interval.stop
          ) ? intervals[index2].isStopIncluded : interval.isStopIncluded,
          data: interval.data
        });
        intervals.splice(index2, 1);
      } else {
        intervals[index2] = new TimeInterval_default({
          start: interval.stop,
          stop: intervals[index2].stop,
          isStartIncluded: !interval.isStopIncluded,
          isStopIncluded: intervals[index2].isStopIncluded,
          data: intervals[index2].data
        });
        if (intervals[index2].isEmpty) {
          intervals.splice(index2, 1);
        } else {
          break;
        }
      }
    } else {
      break;
    }
  }
  intervals.splice(index2, 0, interval);
  this._changedEvent.raiseEvent(this);
};
TimeIntervalCollection.prototype.removeInterval = function(interval) {
  if (!defined_default(interval)) {
    throw new DeveloperError_default("interval is required");
  }
  if (interval.isEmpty) {
    return false;
  }
  const intervals = this._intervals;
  let index2 = binarySearch_default(intervals, interval, compareIntervalStartTimes);
  if (index2 < 0) {
    index2 = ~index2;
  }
  let result = false;
  if (index2 > 0 && (JulianDate_default.greaterThan(intervals[index2 - 1].stop, interval.start) || intervals[index2 - 1].stop.equals(interval.start) && intervals[index2 - 1].isStopIncluded && interval.isStartIncluded)) {
    result = true;
    if (JulianDate_default.greaterThan(intervals[index2 - 1].stop, interval.stop) || intervals[index2 - 1].isStopIncluded && !interval.isStopIncluded && intervals[index2 - 1].stop.equals(interval.stop)) {
      intervals.splice(
        index2,
        0,
        new TimeInterval_default({
          start: interval.stop,
          stop: intervals[index2 - 1].stop,
          isStartIncluded: !interval.isStopIncluded,
          isStopIncluded: intervals[index2 - 1].isStopIncluded,
          data: intervals[index2 - 1].data
        })
      );
    }
    intervals[index2 - 1] = new TimeInterval_default({
      start: intervals[index2 - 1].start,
      stop: interval.start,
      isStartIncluded: intervals[index2 - 1].isStartIncluded,
      isStopIncluded: !interval.isStartIncluded,
      data: intervals[index2 - 1].data
    });
  }
  if (index2 < intervals.length && !interval.isStartIncluded && intervals[index2].isStartIncluded && interval.start.equals(intervals[index2].start)) {
    result = true;
    intervals.splice(
      index2,
      0,
      new TimeInterval_default({
        start: intervals[index2].start,
        stop: intervals[index2].start,
        isStartIncluded: true,
        isStopIncluded: true,
        data: intervals[index2].data
      })
    );
    ++index2;
  }
  while (index2 < intervals.length && JulianDate_default.greaterThan(interval.stop, intervals[index2].stop)) {
    result = true;
    intervals.splice(index2, 1);
  }
  if (index2 < intervals.length && interval.stop.equals(intervals[index2].stop)) {
    result = true;
    if (!interval.isStopIncluded && intervals[index2].isStopIncluded) {
      if (index2 + 1 < intervals.length && intervals[index2 + 1].start.equals(interval.stop) && intervals[index2].data === intervals[index2 + 1].data) {
        intervals.splice(index2, 1);
        intervals[index2] = new TimeInterval_default({
          start: intervals[index2].start,
          stop: intervals[index2].stop,
          isStartIncluded: true,
          isStopIncluded: intervals[index2].isStopIncluded,
          data: intervals[index2].data
        });
      } else {
        intervals[index2] = new TimeInterval_default({
          start: interval.stop,
          stop: interval.stop,
          isStartIncluded: true,
          isStopIncluded: true,
          data: intervals[index2].data
        });
      }
    } else {
      intervals.splice(index2, 1);
    }
  }
  if (index2 < intervals.length && (JulianDate_default.greaterThan(interval.stop, intervals[index2].start) || interval.stop.equals(intervals[index2].start) && interval.isStopIncluded && intervals[index2].isStartIncluded)) {
    result = true;
    intervals[index2] = new TimeInterval_default({
      start: interval.stop,
      stop: intervals[index2].stop,
      isStartIncluded: !interval.isStopIncluded,
      isStopIncluded: intervals[index2].isStopIncluded,
      data: intervals[index2].data
    });
  }
  if (result) {
    this._changedEvent.raiseEvent(this);
  }
  return result;
};
TimeIntervalCollection.prototype.intersect = function(other, dataComparer, mergeCallback) {
  if (!defined_default(other)) {
    throw new DeveloperError_default("other is required.");
  }
  const result = new TimeIntervalCollection();
  let left = 0;
  let right = 0;
  const intervals = this._intervals;
  const otherIntervals = other._intervals;
  while (left < intervals.length && right < otherIntervals.length) {
    const leftInterval = intervals[left];
    const rightInterval = otherIntervals[right];
    if (JulianDate_default.lessThan(leftInterval.stop, rightInterval.start)) {
      ++left;
    } else if (JulianDate_default.lessThan(rightInterval.stop, leftInterval.start)) {
      ++right;
    } else {
      if (defined_default(mergeCallback) || defined_default(dataComparer) && dataComparer(leftInterval.data, rightInterval.data) || !defined_default(dataComparer) && rightInterval.data === leftInterval.data) {
        const intersection = TimeInterval_default.intersect(
          leftInterval,
          rightInterval,
          new TimeInterval_default(),
          mergeCallback
        );
        if (!intersection.isEmpty) {
          result.addInterval(intersection, dataComparer);
        }
      }
      if (JulianDate_default.lessThan(leftInterval.stop, rightInterval.stop) || leftInterval.stop.equals(rightInterval.stop) && !leftInterval.isStopIncluded && rightInterval.isStopIncluded) {
        ++left;
      } else {
        ++right;
      }
    }
  }
  return result;
};
TimeIntervalCollection.fromJulianDateArray = function(options, result) {
  if (!defined_default(options)) {
    throw new DeveloperError_default("options is required.");
  }
  if (!defined_default(options.julianDates)) {
    throw new DeveloperError_default("options.iso8601Array is required.");
  }
  if (!defined_default(result)) {
    result = new TimeIntervalCollection();
  }
  const julianDates = options.julianDates;
  const length3 = julianDates.length;
  const dataCallback = options.dataCallback;
  const isStartIncluded = defaultValue_default(options.isStartIncluded, true);
  const isStopIncluded = defaultValue_default(options.isStopIncluded, true);
  const leadingInterval = defaultValue_default(options.leadingInterval, false);
  const trailingInterval = defaultValue_default(options.trailingInterval, false);
  let interval;
  let startIndex = 0;
  if (leadingInterval) {
    ++startIndex;
    interval = new TimeInterval_default({
      start: Iso8601_default.MINIMUM_VALUE,
      stop: julianDates[0],
      isStartIncluded: true,
      isStopIncluded: !isStartIncluded
    });
    interval.data = defined_default(dataCallback) ? dataCallback(interval, result.length) : result.length;
    result.addInterval(interval);
  }
  for (let i2 = 0; i2 < length3 - 1; ++i2) {
    let startDate = julianDates[i2];
    const endDate = julianDates[i2 + 1];
    interval = new TimeInterval_default({
      start: startDate,
      stop: endDate,
      isStartIncluded: result.length === startIndex ? isStartIncluded : true,
      isStopIncluded: i2 === length3 - 2 ? isStopIncluded : false
    });
    interval.data = defined_default(dataCallback) ? dataCallback(interval, result.length) : result.length;
    result.addInterval(interval);
    startDate = endDate;
  }
  if (trailingInterval) {
    interval = new TimeInterval_default({
      start: julianDates[length3 - 1],
      stop: Iso8601_default.MAXIMUM_VALUE,
      isStartIncluded: !isStopIncluded,
      isStopIncluded: true
    });
    interval.data = defined_default(dataCallback) ? dataCallback(interval, result.length) : result.length;
    result.addInterval(interval);
  }
  return result;
};
var scratchGregorianDate = new GregorianDate_default();
var monthLengths = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
function addToDate(julianDate, duration, result) {
  if (!defined_default(result)) {
    result = new JulianDate_default();
  }
  JulianDate_default.toGregorianDate(julianDate, scratchGregorianDate);
  let millisecond = scratchGregorianDate.millisecond + duration.millisecond;
  let second = scratchGregorianDate.second + duration.second;
  let minute = scratchGregorianDate.minute + duration.minute;
  let hour = scratchGregorianDate.hour + duration.hour;
  let day = scratchGregorianDate.day + duration.day;
  let month = scratchGregorianDate.month + duration.month;
  let year = scratchGregorianDate.year + duration.year;
  if (millisecond >= 1e3) {
    second += Math.floor(millisecond / 1e3);
    millisecond = millisecond % 1e3;
  }
  if (second >= 60) {
    minute += Math.floor(second / 60);
    second = second % 60;
  }
  if (minute >= 60) {
    hour += Math.floor(minute / 60);
    minute = minute % 60;
  }
  if (hour >= 24) {
    day += Math.floor(hour / 24);
    hour = hour % 24;
  }
  monthLengths[2] = isLeapYear_default(year) ? 29 : 28;
  while (day > monthLengths[month] || month >= 13) {
    if (day > monthLengths[month]) {
      day -= monthLengths[month];
      ++month;
    }
    if (month >= 13) {
      --month;
      year += Math.floor(month / 12);
      month = month % 12;
      ++month;
    }
    monthLengths[2] = isLeapYear_default(year) ? 29 : 28;
  }
  scratchGregorianDate.millisecond = millisecond;
  scratchGregorianDate.second = second;
  scratchGregorianDate.minute = minute;
  scratchGregorianDate.hour = hour;
  scratchGregorianDate.day = day;
  scratchGregorianDate.month = month;
  scratchGregorianDate.year = year;
  return JulianDate_default.fromGregorianDate(scratchGregorianDate, result);
}
var scratchJulianDate = new JulianDate_default();
var durationRegex = /P(?:([\d.,]+)Y)?(?:([\d.,]+)M)?(?:([\d.,]+)W)?(?:([\d.,]+)D)?(?:T(?:([\d.,]+)H)?(?:([\d.,]+)M)?(?:([\d.,]+)S)?)?/;
function parseDuration(iso8601, result) {
  if (!defined_default(iso8601) || iso8601.length === 0) {
    return false;
  }
  result.year = 0;
  result.month = 0;
  result.day = 0;
  result.hour = 0;
  result.minute = 0;
  result.second = 0;
  result.millisecond = 0;
  if (iso8601[0] === "P") {
    const matches = iso8601.match(durationRegex);
    if (!defined_default(matches)) {
      return false;
    }
    if (defined_default(matches[1])) {
      result.year = Number(matches[1].replace(",", "."));
    }
    if (defined_default(matches[2])) {
      result.month = Number(matches[2].replace(",", "."));
    }
    if (defined_default(matches[3])) {
      result.day = Number(matches[3].replace(",", ".")) * 7;
    }
    if (defined_default(matches[4])) {
      result.day += Number(matches[4].replace(",", "."));
    }
    if (defined_default(matches[5])) {
      result.hour = Number(matches[5].replace(",", "."));
    }
    if (defined_default(matches[6])) {
      result.minute = Number(matches[6].replace(",", "."));
    }
    if (defined_default(matches[7])) {
      const seconds = Number(matches[7].replace(",", "."));
      result.second = Math.floor(seconds);
      result.millisecond = seconds % 1 * 1e3;
    }
  } else {
    if (iso8601[iso8601.length - 1] !== "Z") {
      iso8601 += "Z";
    }
    JulianDate_default.toGregorianDate(
      JulianDate_default.fromIso8601(iso8601, scratchJulianDate),
      result
    );
  }
  return result.year || result.month || result.day || result.hour || result.minute || result.second || result.millisecond;
}
var scratchDuration = new GregorianDate_default();
TimeIntervalCollection.fromIso8601 = function(options, result) {
  if (!defined_default(options)) {
    throw new DeveloperError_default("options is required.");
  }
  if (!defined_default(options.iso8601)) {
    throw new DeveloperError_default("options.iso8601 is required.");
  }
  const dates = options.iso8601.split("/");
  const start = JulianDate_default.fromIso8601(dates[0]);
  const stop2 = JulianDate_default.fromIso8601(dates[1]);
  const julianDates = [];
  if (!parseDuration(dates[2], scratchDuration)) {
    julianDates.push(start, stop2);
  } else {
    let date = JulianDate_default.clone(start);
    julianDates.push(date);
    while (JulianDate_default.compare(date, stop2) < 0) {
      date = addToDate(date, scratchDuration);
      const afterStop = JulianDate_default.compare(stop2, date) <= 0;
      if (afterStop) {
        JulianDate_default.clone(stop2, date);
      }
      julianDates.push(date);
    }
  }
  return TimeIntervalCollection.fromJulianDateArray(
    {
      julianDates,
      isStartIncluded: options.isStartIncluded,
      isStopIncluded: options.isStopIncluded,
      leadingInterval: options.leadingInterval,
      trailingInterval: options.trailingInterval,
      dataCallback: options.dataCallback
    },
    result
  );
};
TimeIntervalCollection.fromIso8601DateArray = function(options, result) {
  if (!defined_default(options)) {
    throw new DeveloperError_default("options is required.");
  }
  if (!defined_default(options.iso8601Dates)) {
    throw new DeveloperError_default("options.iso8601Dates is required.");
  }
  return TimeIntervalCollection.fromJulianDateArray(
    {
      julianDates: options.iso8601Dates.map(function(date) {
        return JulianDate_default.fromIso8601(date);
      }),
      isStartIncluded: options.isStartIncluded,
      isStopIncluded: options.isStopIncluded,
      leadingInterval: options.leadingInterval,
      trailingInterval: options.trailingInterval,
      dataCallback: options.dataCallback
    },
    result
  );
};
TimeIntervalCollection.fromIso8601DurationArray = function(options, result) {
  if (!defined_default(options)) {
    throw new DeveloperError_default("options is required.");
  }
  if (!defined_default(options.epoch)) {
    throw new DeveloperError_default("options.epoch is required.");
  }
  if (!defined_default(options.iso8601Durations)) {
    throw new DeveloperError_default("options.iso8601Durations is required.");
  }
  const epoch2 = options.epoch;
  const iso8601Durations = options.iso8601Durations;
  const relativeToPrevious = defaultValue_default(options.relativeToPrevious, false);
  const julianDates = [];
  let date, previousDate;
  const length3 = iso8601Durations.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (parseDuration(iso8601Durations[i2], scratchDuration) || i2 === 0) {
      if (relativeToPrevious && defined_default(previousDate)) {
        date = addToDate(previousDate, scratchDuration);
      } else {
        date = addToDate(epoch2, scratchDuration);
      }
      julianDates.push(date);
      previousDate = date;
    }
  }
  return TimeIntervalCollection.fromJulianDateArray(
    {
      julianDates,
      isStartIncluded: options.isStartIncluded,
      isStopIncluded: options.isStopIncluded,
      leadingInterval: options.leadingInterval,
      trailingInterval: options.trailingInterval,
      dataCallback: options.dataCallback
    },
    result
  );
};
var TimeIntervalCollection_default = TimeIntervalCollection;

// node_modules/cesium/Source/Core/TranslationRotationScale.js
var defaultScale = new Cartesian3_default(1, 1, 1);
var defaultTranslation = Cartesian3_default.ZERO;
var defaultRotation = Quaternion_default.IDENTITY;
function TranslationRotationScale(translation3, rotation, scale) {
  this.translation = Cartesian3_default.clone(
    defaultValue_default(translation3, defaultTranslation)
  );
  this.rotation = Quaternion_default.clone(defaultValue_default(rotation, defaultRotation));
  this.scale = Cartesian3_default.clone(defaultValue_default(scale, defaultScale));
}
TranslationRotationScale.prototype.equals = function(right) {
  return this === right || defined_default(right) && Cartesian3_default.equals(this.translation, right.translation) && Quaternion_default.equals(this.rotation, right.rotation) && Cartesian3_default.equals(this.scale, right.scale);
};
var TranslationRotationScale_default = TranslationRotationScale;

// node_modules/cesium/Source/Core/VRTheWorldTerrainProvider.js
function DataRectangle(rectangle, maxLevel) {
  this.rectangle = rectangle;
  this.maxLevel = maxLevel;
}
function VRTheWorldTerrainProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  const resource = Resource_default.createIfNeeded(options.url);
  this._resource = resource;
  this._errorEvent = new Event_default();
  this._ready = false;
  this._readyPromise = defer_default();
  this._terrainDataStructure = {
    heightScale: 1 / 1e3,
    heightOffset: -1e3,
    elementsPerHeight: 3,
    stride: 4,
    elementMultiplier: 256,
    isBigEndian: true,
    lowestEncodedHeight: 0,
    highestEncodedHeight: 256 * 256 * 256 - 1
  };
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  this._credit = credit;
  this._tilingScheme = void 0;
  this._rectangles = [];
  const that = this;
  let metadataError;
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  function metadataSuccess(xml2) {
    const srs = xml2.getElementsByTagName("SRS")[0].textContent;
    if (srs === "EPSG:4326") {
      that._tilingScheme = new GeographicTilingScheme_default({ ellipsoid });
    } else {
      metadataFailure(`SRS ${srs} is not supported.`);
      return;
    }
    const tileFormat = xml2.getElementsByTagName("TileFormat")[0];
    that._heightmapWidth = parseInt(tileFormat.getAttribute("width"), 10);
    that._heightmapHeight = parseInt(tileFormat.getAttribute("height"), 10);
    that._levelZeroMaximumGeometricError = TerrainProvider_default.getEstimatedLevelZeroGeometricErrorForAHeightmap(
      ellipsoid,
      Math.min(that._heightmapWidth, that._heightmapHeight),
      that._tilingScheme.getNumberOfXTilesAtLevel(0)
    );
    const dataRectangles = xml2.getElementsByTagName("DataExtent");
    for (let i2 = 0; i2 < dataRectangles.length; ++i2) {
      const dataRectangle = dataRectangles[i2];
      const west = Math_default.toRadians(
        parseFloat(dataRectangle.getAttribute("minx"))
      );
      const south = Math_default.toRadians(
        parseFloat(dataRectangle.getAttribute("miny"))
      );
      const east = Math_default.toRadians(
        parseFloat(dataRectangle.getAttribute("maxx"))
      );
      const north = Math_default.toRadians(
        parseFloat(dataRectangle.getAttribute("maxy"))
      );
      const maxLevel = parseInt(dataRectangle.getAttribute("maxlevel"), 10);
      that._rectangles.push(
        new DataRectangle(new Rectangle_default(west, south, east, north), maxLevel)
      );
    }
    that._ready = true;
    that._readyPromise.resolve(true);
  }
  function metadataFailure(e2) {
    const message = defaultValue_default(
      e2,
      `An error occurred while accessing ${that._resource.url}.`
    );
    metadataError = TileProviderError_default.handleError(
      metadataError,
      that,
      that._errorEvent,
      message,
      void 0,
      void 0,
      void 0,
      requestMetadata
    );
  }
  function requestMetadata() {
    that._resource.fetchXML().then(metadataSuccess).catch(metadataFailure);
  }
  requestMetadata();
}
Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "requestTileGeometry must not be called before ready returns true."
        );
      }
      return this._tilingScheme;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  hasWaterMask: {
    get: function() {
      return false;
    }
  },
  hasVertexNormals: {
    get: function() {
      return false;
    }
  },
  availability: {
    get: function() {
      return void 0;
    }
  }
});
VRTheWorldTerrainProvider.prototype.requestTileGeometry = function(x, y, level, request) {
  if (!this.ready) {
    throw new DeveloperError_default(
      "requestTileGeometry must not be called before ready returns true."
    );
  }
  const yTiles = this._tilingScheme.getNumberOfYTilesAtLevel(level);
  const resource = this._resource.getDerivedResource({
    url: `${level}/${x}/${yTiles - y - 1}.tif`,
    queryParameters: {
      cesium: true
    },
    request
  });
  const promise = resource.fetchImage({
    preferImageBitmap: true
  });
  if (!defined_default(promise)) {
    return void 0;
  }
  const that = this;
  return Promise.resolve(promise).then(function(image) {
    return new HeightmapTerrainData_default({
      buffer: getImagePixels_default(image),
      width: that._heightmapWidth,
      height: that._heightmapHeight,
      childTileMask: getChildMask(that, x, y, level),
      structure: that._terrainDataStructure
    });
  });
};
VRTheWorldTerrainProvider.prototype.getLevelMaximumGeometricError = function(level) {
  if (!this.ready) {
    throw new DeveloperError_default(
      "requestTileGeometry must not be called before ready returns true."
    );
  }
  return this._levelZeroMaximumGeometricError / (1 << level);
};
var rectangleScratch5 = new Rectangle_default();
function getChildMask(provider, x, y, level) {
  const tilingScheme2 = provider._tilingScheme;
  const rectangles = provider._rectangles;
  const parentRectangle = tilingScheme2.tileXYToRectangle(x, y, level);
  let childMask = 0;
  for (let i2 = 0; i2 < rectangles.length && childMask !== 15; ++i2) {
    const rectangle = rectangles[i2];
    if (rectangle.maxLevel <= level) {
      continue;
    }
    const testRectangle = rectangle.rectangle;
    const intersection = Rectangle_default.intersection(
      testRectangle,
      parentRectangle,
      rectangleScratch5
    );
    if (defined_default(intersection)) {
      if (isTileInRectangle(tilingScheme2, testRectangle, x * 2, y * 2, level + 1)) {
        childMask |= 4;
      }
      if (isTileInRectangle(
        tilingScheme2,
        testRectangle,
        x * 2 + 1,
        y * 2,
        level + 1
      )) {
        childMask |= 8;
      }
      if (isTileInRectangle(
        tilingScheme2,
        testRectangle,
        x * 2,
        y * 2 + 1,
        level + 1
      )) {
        childMask |= 1;
      }
      if (isTileInRectangle(
        tilingScheme2,
        testRectangle,
        x * 2 + 1,
        y * 2 + 1,
        level + 1
      )) {
        childMask |= 2;
      }
    }
  }
  return childMask;
}
function isTileInRectangle(tilingScheme2, rectangle, x, y, level) {
  const tileRectangle = tilingScheme2.tileXYToRectangle(x, y, level);
  return defined_default(
    Rectangle_default.intersection(tileRectangle, rectangle, rectangleScratch5)
  );
}
VRTheWorldTerrainProvider.prototype.getTileDataAvailable = function(x, y, level) {
  return void 0;
};
VRTheWorldTerrainProvider.prototype.loadTileDataAvailability = function(x, y, level) {
  return void 0;
};
var VRTheWorldTerrainProvider_default = VRTheWorldTerrainProvider;

// node_modules/cesium/Source/Core/VideoSynchronizer.js
function VideoSynchronizer(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._clock = void 0;
  this._element = void 0;
  this._clockSubscription = void 0;
  this._seekFunction = void 0;
  this._lastPlaybackRate = void 0;
  this.clock = options.clock;
  this.element = options.element;
  this.epoch = defaultValue_default(options.epoch, Iso8601_default.MINIMUM_VALUE);
  this.tolerance = defaultValue_default(options.tolerance, 1);
  this._seeking = false;
  this._seekFunction = void 0;
  this._firstTickAfterSeek = false;
}
Object.defineProperties(VideoSynchronizer.prototype, {
  clock: {
    get: function() {
      return this._clock;
    },
    set: function(value) {
      const oldValue2 = this._clock;
      if (oldValue2 === value) {
        return;
      }
      if (defined_default(oldValue2)) {
        this._clockSubscription();
        this._clockSubscription = void 0;
      }
      if (defined_default(value)) {
        this._clockSubscription = value.onTick.addEventListener(
          VideoSynchronizer.prototype._onTick,
          this
        );
      }
      this._clock = value;
    }
  },
  element: {
    get: function() {
      return this._element;
    },
    set: function(value) {
      const oldValue2 = this._element;
      if (oldValue2 === value) {
        return;
      }
      if (defined_default(oldValue2)) {
        oldValue2.removeEventListener("seeked", this._seekFunction, false);
      }
      if (defined_default(value)) {
        this._seeking = false;
        this._seekFunction = createSeekFunction(this);
        value.addEventListener("seeked", this._seekFunction, false);
      }
      this._element = value;
      this._seeking = false;
      this._firstTickAfterSeek = false;
    }
  }
});
VideoSynchronizer.prototype.destroy = function() {
  this.element = void 0;
  this.clock = void 0;
  return destroyObject_default(this);
};
VideoSynchronizer.prototype.isDestroyed = function() {
  return false;
};
VideoSynchronizer.prototype._trySetPlaybackRate = function(clock) {
  if (this._lastPlaybackRate === clock.multiplier) {
    return;
  }
  const element = this._element;
  try {
    element.playbackRate = clock.multiplier;
  } catch (error) {
    element.playbackRate = 0;
  }
  this._lastPlaybackRate = clock.multiplier;
};
VideoSynchronizer.prototype._onTick = function(clock) {
  const element = this._element;
  if (!defined_default(element) || element.readyState < 2) {
    return;
  }
  const paused = element.paused;
  const shouldAnimate = clock.shouldAnimate;
  if (shouldAnimate === paused) {
    if (shouldAnimate) {
      element.play();
    } else {
      element.pause();
    }
  }
  if (this._seeking || this._firstTickAfterSeek) {
    this._firstTickAfterSeek = false;
    return;
  }
  this._trySetPlaybackRate(clock);
  const clockTime = clock.currentTime;
  const epoch2 = defaultValue_default(this.epoch, Iso8601_default.MINIMUM_VALUE);
  let videoTime = JulianDate_default.secondsDifference(clockTime, epoch2);
  const duration = element.duration;
  let desiredTime;
  const currentTime = element.currentTime;
  if (element.loop) {
    videoTime = videoTime % duration;
    if (videoTime < 0) {
      videoTime = duration - videoTime;
    }
    desiredTime = videoTime;
  } else if (videoTime > duration) {
    desiredTime = duration;
  } else if (videoTime < 0) {
    desiredTime = 0;
  } else {
    desiredTime = videoTime;
  }
  const tolerance = shouldAnimate ? defaultValue_default(this.tolerance, 1) : 1e-3;
  if (Math.abs(desiredTime - currentTime) > tolerance) {
    this._seeking = true;
    element.currentTime = desiredTime;
  }
};
function createSeekFunction(that) {
  return function() {
    that._seeking = false;
    that._firstTickAfterSeek = true;
  };
}
var VideoSynchronizer_default = VideoSynchronizer;

// node_modules/cesium/Source/Core/VulkanConstants.js
var VulkanConstants = {
  VK_FORMAT_UNDEFINED: 0,
  VK_FORMAT_R4G4_UNORM_PACK8: 1,
  VK_FORMAT_R4G4B4A4_UNORM_PACK16: 2,
  VK_FORMAT_B4G4R4A4_UNORM_PACK16: 3,
  VK_FORMAT_R5G6B5_UNORM_PACK16: 4,
  VK_FORMAT_B5G6R5_UNORM_PACK16: 5,
  VK_FORMAT_R5G5B5A1_UNORM_PACK16: 6,
  VK_FORMAT_B5G5R5A1_UNORM_PACK16: 7,
  VK_FORMAT_A1R5G5B5_UNORM_PACK16: 8,
  VK_FORMAT_R8_UNORM: 9,
  VK_FORMAT_R8_SNORM: 10,
  VK_FORMAT_R8_USCALED: 11,
  VK_FORMAT_R8_SSCALED: 12,
  VK_FORMAT_R8_UINT: 13,
  VK_FORMAT_R8_SINT: 14,
  VK_FORMAT_R8_SRGB: 15,
  VK_FORMAT_R8G8_UNORM: 16,
  VK_FORMAT_R8G8_SNORM: 17,
  VK_FORMAT_R8G8_USCALED: 18,
  VK_FORMAT_R8G8_SSCALED: 19,
  VK_FORMAT_R8G8_UINT: 20,
  VK_FORMAT_R8G8_SINT: 21,
  VK_FORMAT_R8G8_SRGB: 22,
  VK_FORMAT_R8G8B8_UNORM: 23,
  VK_FORMAT_R8G8B8_SNORM: 24,
  VK_FORMAT_R8G8B8_USCALED: 25,
  VK_FORMAT_R8G8B8_SSCALED: 26,
  VK_FORMAT_R8G8B8_UINT: 27,
  VK_FORMAT_R8G8B8_SINT: 28,
  VK_FORMAT_R8G8B8_SRGB: 29,
  VK_FORMAT_B8G8R8_UNORM: 30,
  VK_FORMAT_B8G8R8_SNORM: 31,
  VK_FORMAT_B8G8R8_USCALED: 32,
  VK_FORMAT_B8G8R8_SSCALED: 33,
  VK_FORMAT_B8G8R8_UINT: 34,
  VK_FORMAT_B8G8R8_SINT: 35,
  VK_FORMAT_B8G8R8_SRGB: 36,
  VK_FORMAT_R8G8B8A8_UNORM: 37,
  VK_FORMAT_R8G8B8A8_SNORM: 38,
  VK_FORMAT_R8G8B8A8_USCALED: 39,
  VK_FORMAT_R8G8B8A8_SSCALED: 40,
  VK_FORMAT_R8G8B8A8_UINT: 41,
  VK_FORMAT_R8G8B8A8_SINT: 42,
  VK_FORMAT_R8G8B8A8_SRGB: 43,
  VK_FORMAT_B8G8R8A8_UNORM: 44,
  VK_FORMAT_B8G8R8A8_SNORM: 45,
  VK_FORMAT_B8G8R8A8_USCALED: 46,
  VK_FORMAT_B8G8R8A8_SSCALED: 47,
  VK_FORMAT_B8G8R8A8_UINT: 48,
  VK_FORMAT_B8G8R8A8_SINT: 49,
  VK_FORMAT_B8G8R8A8_SRGB: 50,
  VK_FORMAT_A8B8G8R8_UNORM_PACK32: 51,
  VK_FORMAT_A8B8G8R8_SNORM_PACK32: 52,
  VK_FORMAT_A8B8G8R8_USCALED_PACK32: 53,
  VK_FORMAT_A8B8G8R8_SSCALED_PACK32: 54,
  VK_FORMAT_A8B8G8R8_UINT_PACK32: 55,
  VK_FORMAT_A8B8G8R8_SINT_PACK32: 56,
  VK_FORMAT_A8B8G8R8_SRGB_PACK32: 57,
  VK_FORMAT_A2R10G10B10_UNORM_PACK32: 58,
  VK_FORMAT_A2R10G10B10_SNORM_PACK32: 59,
  VK_FORMAT_A2R10G10B10_USCALED_PACK32: 60,
  VK_FORMAT_A2R10G10B10_SSCALED_PACK32: 61,
  VK_FORMAT_A2R10G10B10_UINT_PACK32: 62,
  VK_FORMAT_A2R10G10B10_SINT_PACK32: 63,
  VK_FORMAT_A2B10G10R10_UNORM_PACK32: 64,
  VK_FORMAT_A2B10G10R10_SNORM_PACK32: 65,
  VK_FORMAT_A2B10G10R10_USCALED_PACK32: 66,
  VK_FORMAT_A2B10G10R10_SSCALED_PACK32: 67,
  VK_FORMAT_A2B10G10R10_UINT_PACK32: 68,
  VK_FORMAT_A2B10G10R10_SINT_PACK32: 69,
  VK_FORMAT_R16_UNORM: 70,
  VK_FORMAT_R16_SNORM: 71,
  VK_FORMAT_R16_USCALED: 72,
  VK_FORMAT_R16_SSCALED: 73,
  VK_FORMAT_R16_UINT: 74,
  VK_FORMAT_R16_SINT: 75,
  VK_FORMAT_R16_SFLOAT: 76,
  VK_FORMAT_R16G16_UNORM: 77,
  VK_FORMAT_R16G16_SNORM: 78,
  VK_FORMAT_R16G16_USCALED: 79,
  VK_FORMAT_R16G16_SSCALED: 80,
  VK_FORMAT_R16G16_UINT: 81,
  VK_FORMAT_R16G16_SINT: 82,
  VK_FORMAT_R16G16_SFLOAT: 83,
  VK_FORMAT_R16G16B16_UNORM: 84,
  VK_FORMAT_R16G16B16_SNORM: 85,
  VK_FORMAT_R16G16B16_USCALED: 86,
  VK_FORMAT_R16G16B16_SSCALED: 87,
  VK_FORMAT_R16G16B16_UINT: 88,
  VK_FORMAT_R16G16B16_SINT: 89,
  VK_FORMAT_R16G16B16_SFLOAT: 90,
  VK_FORMAT_R16G16B16A16_UNORM: 91,
  VK_FORMAT_R16G16B16A16_SNORM: 92,
  VK_FORMAT_R16G16B16A16_USCALED: 93,
  VK_FORMAT_R16G16B16A16_SSCALED: 94,
  VK_FORMAT_R16G16B16A16_UINT: 95,
  VK_FORMAT_R16G16B16A16_SINT: 96,
  VK_FORMAT_R16G16B16A16_SFLOAT: 97,
  VK_FORMAT_R32_UINT: 98,
  VK_FORMAT_R32_SINT: 99,
  VK_FORMAT_R32_SFLOAT: 100,
  VK_FORMAT_R32G32_UINT: 101,
  VK_FORMAT_R32G32_SINT: 102,
  VK_FORMAT_R32G32_SFLOAT: 103,
  VK_FORMAT_R32G32B32_UINT: 104,
  VK_FORMAT_R32G32B32_SINT: 105,
  VK_FORMAT_R32G32B32_SFLOAT: 106,
  VK_FORMAT_R32G32B32A32_UINT: 107,
  VK_FORMAT_R32G32B32A32_SINT: 108,
  VK_FORMAT_R32G32B32A32_SFLOAT: 109,
  VK_FORMAT_R64_UINT: 110,
  VK_FORMAT_R64_SINT: 111,
  VK_FORMAT_R64_SFLOAT: 112,
  VK_FORMAT_R64G64_UINT: 113,
  VK_FORMAT_R64G64_SINT: 114,
  VK_FORMAT_R64G64_SFLOAT: 115,
  VK_FORMAT_R64G64B64_UINT: 116,
  VK_FORMAT_R64G64B64_SINT: 117,
  VK_FORMAT_R64G64B64_SFLOAT: 118,
  VK_FORMAT_R64G64B64A64_UINT: 119,
  VK_FORMAT_R64G64B64A64_SINT: 120,
  VK_FORMAT_R64G64B64A64_SFLOAT: 121,
  VK_FORMAT_B10G11R11_UFLOAT_PACK32: 122,
  VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: 123,
  VK_FORMAT_D16_UNORM: 124,
  VK_FORMAT_X8_D24_UNORM_PACK32: 125,
  VK_FORMAT_D32_SFLOAT: 126,
  VK_FORMAT_S8_UINT: 127,
  VK_FORMAT_D16_UNORM_S8_UINT: 128,
  VK_FORMAT_D24_UNORM_S8_UINT: 129,
  VK_FORMAT_D32_SFLOAT_S8_UINT: 130,
  VK_FORMAT_BC1_RGB_UNORM_BLOCK: 131,
  VK_FORMAT_BC1_RGB_SRGB_BLOCK: 132,
  VK_FORMAT_BC1_RGBA_UNORM_BLOCK: 133,
  VK_FORMAT_BC1_RGBA_SRGB_BLOCK: 134,
  VK_FORMAT_BC2_UNORM_BLOCK: 135,
  VK_FORMAT_BC2_SRGB_BLOCK: 136,
  VK_FORMAT_BC3_UNORM_BLOCK: 137,
  VK_FORMAT_BC3_SRGB_BLOCK: 138,
  VK_FORMAT_BC4_UNORM_BLOCK: 139,
  VK_FORMAT_BC4_SNORM_BLOCK: 140,
  VK_FORMAT_BC5_UNORM_BLOCK: 141,
  VK_FORMAT_BC5_SNORM_BLOCK: 142,
  VK_FORMAT_BC6H_UFLOAT_BLOCK: 143,
  VK_FORMAT_BC6H_SFLOAT_BLOCK: 144,
  VK_FORMAT_BC7_UNORM_BLOCK: 145,
  VK_FORMAT_BC7_SRGB_BLOCK: 146,
  VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: 147,
  VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: 148,
  VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: 149,
  VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: 150,
  VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: 151,
  VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: 152,
  VK_FORMAT_EAC_R11_UNORM_BLOCK: 153,
  VK_FORMAT_EAC_R11_SNORM_BLOCK: 154,
  VK_FORMAT_EAC_R11G11_UNORM_BLOCK: 155,
  VK_FORMAT_EAC_R11G11_SNORM_BLOCK: 156,
  VK_FORMAT_ASTC_4x4_UNORM_BLOCK: 157,
  VK_FORMAT_ASTC_4x4_SRGB_BLOCK: 158,
  VK_FORMAT_ASTC_5x4_UNORM_BLOCK: 159,
  VK_FORMAT_ASTC_5x4_SRGB_BLOCK: 160,
  VK_FORMAT_ASTC_5x5_UNORM_BLOCK: 161,
  VK_FORMAT_ASTC_5x5_SRGB_BLOCK: 162,
  VK_FORMAT_ASTC_6x5_UNORM_BLOCK: 163,
  VK_FORMAT_ASTC_6x5_SRGB_BLOCK: 164,
  VK_FORMAT_ASTC_6x6_UNORM_BLOCK: 165,
  VK_FORMAT_ASTC_6x6_SRGB_BLOCK: 166,
  VK_FORMAT_ASTC_8x5_UNORM_BLOCK: 167,
  VK_FORMAT_ASTC_8x5_SRGB_BLOCK: 168,
  VK_FORMAT_ASTC_8x6_UNORM_BLOCK: 169,
  VK_FORMAT_ASTC_8x6_SRGB_BLOCK: 170,
  VK_FORMAT_ASTC_8x8_UNORM_BLOCK: 171,
  VK_FORMAT_ASTC_8x8_SRGB_BLOCK: 172,
  VK_FORMAT_ASTC_10x5_UNORM_BLOCK: 173,
  VK_FORMAT_ASTC_10x5_SRGB_BLOCK: 174,
  VK_FORMAT_ASTC_10x6_UNORM_BLOCK: 175,
  VK_FORMAT_ASTC_10x6_SRGB_BLOCK: 176,
  VK_FORMAT_ASTC_10x8_UNORM_BLOCK: 177,
  VK_FORMAT_ASTC_10x8_SRGB_BLOCK: 178,
  VK_FORMAT_ASTC_10x10_UNORM_BLOCK: 179,
  VK_FORMAT_ASTC_10x10_SRGB_BLOCK: 180,
  VK_FORMAT_ASTC_12x10_UNORM_BLOCK: 181,
  VK_FORMAT_ASTC_12x10_SRGB_BLOCK: 182,
  VK_FORMAT_ASTC_12x12_UNORM_BLOCK: 183,
  VK_FORMAT_ASTC_12x12_SRGB_BLOCK: 184,
  VK_FORMAT_G8B8G8R8_422_UNORM: 1000156e3,
  VK_FORMAT_B8G8R8G8_422_UNORM: 1000156001,
  VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: 1000156002,
  VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: 1000156003,
  VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: 1000156004,
  VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: 1000156005,
  VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: 1000156006,
  VK_FORMAT_R10X6_UNORM_PACK16: 1000156007,
  VK_FORMAT_R10X6G10X6_UNORM_2PACK16: 1000156008,
  VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: 1000156009,
  VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: 1000156010,
  VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: 1000156011,
  VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: 1000156012,
  VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: 1000156013,
  VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: 1000156014,
  VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: 1000156015,
  VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: 1000156016,
  VK_FORMAT_R12X4_UNORM_PACK16: 1000156017,
  VK_FORMAT_R12X4G12X4_UNORM_2PACK16: 1000156018,
  VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: 1000156019,
  VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: 1000156020,
  VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: 1000156021,
  VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: 1000156022,
  VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: 1000156023,
  VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: 1000156024,
  VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: 1000156025,
  VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: 1000156026,
  VK_FORMAT_G16B16G16R16_422_UNORM: 1000156027,
  VK_FORMAT_B16G16R16G16_422_UNORM: 1000156028,
  VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: 1000156029,
  VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: 1000156030,
  VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: 1000156031,
  VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: 1000156032,
  VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: 1000156033,
  VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: 1000054e3,
  VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: 1000054001,
  VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: 1000054002,
  VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: 1000054003,
  VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: 1000054004,
  VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: 1000054005,
  VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: 1000054006,
  VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: 1000054007,
  VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT: 1000066e3,
  VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT: 1000066001,
  VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT: 1000066002,
  VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT: 1000066003,
  VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT: 1000066004,
  VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT: 1000066005,
  VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT: 1000066006,
  VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT: 1000066007,
  VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT: 1000066008,
  VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT: 1000066009,
  VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT: 1000066010,
  VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT: 1000066011,
  VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT: 1000066012,
  VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT: 1000066013,
  VK_FORMAT_G8B8G8R8_422_UNORM_KHR: 1000156e3,
  VK_FORMAT_B8G8R8G8_422_UNORM_KHR: 1000156001,
  VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: 1000156002,
  VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: 1000156003,
  VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: 1000156004,
  VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: 1000156005,
  VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: 1000156006,
  VK_FORMAT_R10X6_UNORM_PACK16_KHR: 1000156007,
  VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: 1000156008,
  VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: 1000156009,
  VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: 1000156010,
  VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: 1000156011,
  VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: 1000156012,
  VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: 1000156013,
  VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: 1000156014,
  VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: 1000156015,
  VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: 1000156016,
  VK_FORMAT_R12X4_UNORM_PACK16_KHR: 1000156017,
  VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: 1000156018,
  VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: 1000156019,
  VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: 1000156020,
  VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: 1000156021,
  VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: 1000156022,
  VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: 1000156023,
  VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: 1000156024,
  VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: 1000156025,
  VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: 1000156026,
  VK_FORMAT_G16B16G16R16_422_UNORM_KHR: 1000156027,
  VK_FORMAT_B16G16R16G16_422_UNORM_KHR: 1000156028,
  VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: 1000156029,
  VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: 1000156030,
  VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: 1000156031,
  VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: 1000156032,
  VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: 1000156033
};
var VulkanConstants_default = Object.freeze(VulkanConstants);

// node_modules/cesium/Source/Core/WallGeometryLibrary.js
var WallGeometryLibrary = {};
function latLonEquals(c0, c14) {
  return Math_default.equalsEpsilon(c0.latitude, c14.latitude, Math_default.EPSILON10) && Math_default.equalsEpsilon(c0.longitude, c14.longitude, Math_default.EPSILON10);
}
var scratchCartographic13 = new Cartographic_default();
var scratchCartographic23 = new Cartographic_default();
function removeDuplicates(ellipsoid, positions, topHeights, bottomHeights) {
  positions = arrayRemoveDuplicates_default(positions, Cartesian3_default.equalsEpsilon);
  const length3 = positions.length;
  if (length3 < 2) {
    return;
  }
  const hasBottomHeights = defined_default(bottomHeights);
  const hasTopHeights = defined_default(topHeights);
  const cleanedPositions = new Array(length3);
  const cleanedTopHeights = new Array(length3);
  const cleanedBottomHeights = new Array(length3);
  const v02 = positions[0];
  cleanedPositions[0] = v02;
  const c0 = ellipsoid.cartesianToCartographic(v02, scratchCartographic13);
  if (hasTopHeights) {
    c0.height = topHeights[0];
  }
  cleanedTopHeights[0] = c0.height;
  if (hasBottomHeights) {
    cleanedBottomHeights[0] = bottomHeights[0];
  } else {
    cleanedBottomHeights[0] = 0;
  }
  const startTopHeight = cleanedTopHeights[0];
  const startBottomHeight = cleanedBottomHeights[0];
  let hasAllSameHeights = startTopHeight === startBottomHeight;
  let index2 = 1;
  for (let i2 = 1; i2 < length3; ++i2) {
    const v13 = positions[i2];
    const c14 = ellipsoid.cartesianToCartographic(v13, scratchCartographic23);
    if (hasTopHeights) {
      c14.height = topHeights[i2];
    }
    hasAllSameHeights = hasAllSameHeights && c14.height === 0;
    if (!latLonEquals(c0, c14)) {
      cleanedPositions[index2] = v13;
      cleanedTopHeights[index2] = c14.height;
      if (hasBottomHeights) {
        cleanedBottomHeights[index2] = bottomHeights[i2];
      } else {
        cleanedBottomHeights[index2] = 0;
      }
      hasAllSameHeights = hasAllSameHeights && cleanedTopHeights[index2] === cleanedBottomHeights[index2];
      Cartographic_default.clone(c14, c0);
      ++index2;
    } else if (c0.height < c14.height) {
      cleanedTopHeights[index2 - 1] = c14.height;
    }
  }
  if (hasAllSameHeights || index2 < 2) {
    return;
  }
  cleanedPositions.length = index2;
  cleanedTopHeights.length = index2;
  cleanedBottomHeights.length = index2;
  return {
    positions: cleanedPositions,
    topHeights: cleanedTopHeights,
    bottomHeights: cleanedBottomHeights
  };
}
var positionsArrayScratch = new Array(2);
var heightsArrayScratch = new Array(2);
var generateArcOptionsScratch2 = {
  positions: void 0,
  height: void 0,
  granularity: void 0,
  ellipsoid: void 0
};
WallGeometryLibrary.computePositions = function(ellipsoid, wallPositions, maximumHeights, minimumHeights, granularity, duplicateCorners) {
  const o2 = removeDuplicates(
    ellipsoid,
    wallPositions,
    maximumHeights,
    minimumHeights
  );
  if (!defined_default(o2)) {
    return;
  }
  wallPositions = o2.positions;
  maximumHeights = o2.topHeights;
  minimumHeights = o2.bottomHeights;
  const length3 = wallPositions.length;
  const numCorners = length3 - 2;
  let topPositions;
  let bottomPositions;
  const minDistance = Math_default.chordLength(
    granularity,
    ellipsoid.maximumRadius
  );
  const generateArcOptions = generateArcOptionsScratch2;
  generateArcOptions.minDistance = minDistance;
  generateArcOptions.ellipsoid = ellipsoid;
  if (duplicateCorners) {
    let count = 0;
    let i2;
    for (i2 = 0; i2 < length3 - 1; i2++) {
      count += PolylinePipeline_default.numberOfPoints(
        wallPositions[i2],
        wallPositions[i2 + 1],
        minDistance
      ) + 1;
    }
    topPositions = new Float64Array(count * 3);
    bottomPositions = new Float64Array(count * 3);
    const generateArcPositions = positionsArrayScratch;
    const generateArcHeights = heightsArrayScratch;
    generateArcOptions.positions = generateArcPositions;
    generateArcOptions.height = generateArcHeights;
    let offset2 = 0;
    for (i2 = 0; i2 < length3 - 1; i2++) {
      generateArcPositions[0] = wallPositions[i2];
      generateArcPositions[1] = wallPositions[i2 + 1];
      generateArcHeights[0] = maximumHeights[i2];
      generateArcHeights[1] = maximumHeights[i2 + 1];
      const pos = PolylinePipeline_default.generateArc(generateArcOptions);
      topPositions.set(pos, offset2);
      generateArcHeights[0] = minimumHeights[i2];
      generateArcHeights[1] = minimumHeights[i2 + 1];
      bottomPositions.set(
        PolylinePipeline_default.generateArc(generateArcOptions),
        offset2
      );
      offset2 += pos.length;
    }
  } else {
    generateArcOptions.positions = wallPositions;
    generateArcOptions.height = maximumHeights;
    topPositions = new Float64Array(
      PolylinePipeline_default.generateArc(generateArcOptions)
    );
    generateArcOptions.height = minimumHeights;
    bottomPositions = new Float64Array(
      PolylinePipeline_default.generateArc(generateArcOptions)
    );
  }
  return {
    bottomPositions,
    topPositions,
    numCorners
  };
};
var WallGeometryLibrary_default = WallGeometryLibrary;

// node_modules/cesium/Source/Core/WallGeometry.js
var scratchCartesian3Position1 = new Cartesian3_default();
var scratchCartesian3Position2 = new Cartesian3_default();
var scratchCartesian3Position4 = new Cartesian3_default();
var scratchCartesian3Position5 = new Cartesian3_default();
var scratchBitangent5 = new Cartesian3_default();
var scratchTangent5 = new Cartesian3_default();
var scratchNormal7 = new Cartesian3_default();
function WallGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const wallPositions = options.positions;
  const maximumHeights = options.maximumHeights;
  const minimumHeights = options.minimumHeights;
  if (!defined_default(wallPositions)) {
    throw new DeveloperError_default("options.positions is required.");
  }
  if (defined_default(maximumHeights) && maximumHeights.length !== wallPositions.length) {
    throw new DeveloperError_default(
      "options.positions and options.maximumHeights must have the same length."
    );
  }
  if (defined_default(minimumHeights) && minimumHeights.length !== wallPositions.length) {
    throw new DeveloperError_default(
      "options.positions and options.minimumHeights must have the same length."
    );
  }
  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._positions = wallPositions;
  this._minimumHeights = minimumHeights;
  this._maximumHeights = maximumHeights;
  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
  this._granularity = granularity;
  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
  this._workerName = "createWallGeometry";
  let numComponents = 1 + wallPositions.length * Cartesian3_default.packedLength + 2;
  if (defined_default(minimumHeights)) {
    numComponents += minimumHeights.length;
  }
  if (defined_default(maximumHeights)) {
    numComponents += maximumHeights.length;
  }
  this.packedLength = numComponents + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 1;
}
WallGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  const positions = value._positions;
  let length3 = positions.length;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    Cartesian3_default.pack(positions[i2], array, startingIndex);
  }
  const minimumHeights = value._minimumHeights;
  length3 = defined_default(minimumHeights) ? minimumHeights.length : 0;
  array[startingIndex++] = length3;
  if (defined_default(minimumHeights)) {
    for (i2 = 0; i2 < length3; ++i2) {
      array[startingIndex++] = minimumHeights[i2];
    }
  }
  const maximumHeights = value._maximumHeights;
  length3 = defined_default(maximumHeights) ? maximumHeights.length : 0;
  array[startingIndex++] = length3;
  if (defined_default(maximumHeights)) {
    for (i2 = 0; i2 < length3; ++i2) {
      array[startingIndex++] = maximumHeights[i2];
    }
  }
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
  startingIndex += VertexFormat_default.packedLength;
  array[startingIndex] = value._granularity;
  return array;
};
var scratchEllipsoid13 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchVertexFormat13 = new VertexFormat_default();
var scratchOptions23 = {
  positions: void 0,
  minimumHeights: void 0,
  maximumHeights: void 0,
  ellipsoid: scratchEllipsoid13,
  vertexFormat: scratchVertexFormat13,
  granularity: void 0
};
WallGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  let length3 = array[startingIndex++];
  const positions = new Array(length3);
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    positions[i2] = Cartesian3_default.unpack(array, startingIndex);
  }
  length3 = array[startingIndex++];
  let minimumHeights;
  if (length3 > 0) {
    minimumHeights = new Array(length3);
    for (i2 = 0; i2 < length3; ++i2) {
      minimumHeights[i2] = array[startingIndex++];
    }
  }
  length3 = array[startingIndex++];
  let maximumHeights;
  if (length3 > 0) {
    maximumHeights = new Array(length3);
    for (i2 = 0; i2 < length3; ++i2) {
      maximumHeights[i2] = array[startingIndex++];
    }
  }
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid13);
  startingIndex += Ellipsoid_default.packedLength;
  const vertexFormat = VertexFormat_default.unpack(
    array,
    startingIndex,
    scratchVertexFormat13
  );
  startingIndex += VertexFormat_default.packedLength;
  const granularity = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions23.positions = positions;
    scratchOptions23.minimumHeights = minimumHeights;
    scratchOptions23.maximumHeights = maximumHeights;
    scratchOptions23.granularity = granularity;
    return new WallGeometry(scratchOptions23);
  }
  result._positions = positions;
  result._minimumHeights = minimumHeights;
  result._maximumHeights = maximumHeights;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
  result._granularity = granularity;
  return result;
};
WallGeometry.fromConstantHeights = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.positions;
  if (!defined_default(positions)) {
    throw new DeveloperError_default("options.positions is required.");
  }
  let minHeights;
  let maxHeights;
  const min3 = options.minimumHeight;
  const max3 = options.maximumHeight;
  const doMin = defined_default(min3);
  const doMax = defined_default(max3);
  if (doMin || doMax) {
    const length3 = positions.length;
    minHeights = doMin ? new Array(length3) : void 0;
    maxHeights = doMax ? new Array(length3) : void 0;
    for (let i2 = 0; i2 < length3; ++i2) {
      if (doMin) {
        minHeights[i2] = min3;
      }
      if (doMax) {
        maxHeights[i2] = max3;
      }
    }
  }
  const newOptions2 = {
    positions,
    maximumHeights: maxHeights,
    minimumHeights: minHeights,
    ellipsoid: options.ellipsoid,
    vertexFormat: options.vertexFormat
  };
  return new WallGeometry(newOptions2);
};
WallGeometry.createGeometry = function(wallGeometry) {
  const wallPositions = wallGeometry._positions;
  const minimumHeights = wallGeometry._minimumHeights;
  const maximumHeights = wallGeometry._maximumHeights;
  const vertexFormat = wallGeometry._vertexFormat;
  const granularity = wallGeometry._granularity;
  const ellipsoid = wallGeometry._ellipsoid;
  const pos = WallGeometryLibrary_default.computePositions(
    ellipsoid,
    wallPositions,
    maximumHeights,
    minimumHeights,
    granularity,
    true
  );
  if (!defined_default(pos)) {
    return;
  }
  const bottomPositions = pos.bottomPositions;
  const topPositions = pos.topPositions;
  const numCorners = pos.numCorners;
  let length3 = topPositions.length;
  let size = length3 * 2;
  const positions = vertexFormat.position ? new Float64Array(size) : void 0;
  const normals = vertexFormat.normal ? new Float32Array(size) : void 0;
  const tangents = vertexFormat.tangent ? new Float32Array(size) : void 0;
  const bitangents = vertexFormat.bitangent ? new Float32Array(size) : void 0;
  const textureCoordinates = vertexFormat.st ? new Float32Array(size / 3 * 2) : void 0;
  let positionIndex = 0;
  let normalIndex = 0;
  let bitangentIndex = 0;
  let tangentIndex = 0;
  let stIndex = 0;
  let normal2 = scratchNormal7;
  let tangent = scratchTangent5;
  let bitangent = scratchBitangent5;
  let recomputeNormal = true;
  length3 /= 3;
  let i2;
  let s2 = 0;
  const ds = 1 / (length3 - numCorners - 1);
  for (i2 = 0; i2 < length3; ++i2) {
    const i3 = i2 * 3;
    const topPosition = Cartesian3_default.fromArray(
      topPositions,
      i3,
      scratchCartesian3Position1
    );
    const bottomPosition = Cartesian3_default.fromArray(
      bottomPositions,
      i3,
      scratchCartesian3Position2
    );
    if (vertexFormat.position) {
      positions[positionIndex++] = bottomPosition.x;
      positions[positionIndex++] = bottomPosition.y;
      positions[positionIndex++] = bottomPosition.z;
      positions[positionIndex++] = topPosition.x;
      positions[positionIndex++] = topPosition.y;
      positions[positionIndex++] = topPosition.z;
    }
    if (vertexFormat.st) {
      textureCoordinates[stIndex++] = s2;
      textureCoordinates[stIndex++] = 0;
      textureCoordinates[stIndex++] = s2;
      textureCoordinates[stIndex++] = 1;
    }
    if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent) {
      let nextTop = Cartesian3_default.clone(
        Cartesian3_default.ZERO,
        scratchCartesian3Position5
      );
      const groundPosition = Cartesian3_default.subtract(
        topPosition,
        ellipsoid.geodeticSurfaceNormal(
          topPosition,
          scratchCartesian3Position2
        ),
        scratchCartesian3Position2
      );
      if (i2 + 1 < length3) {
        nextTop = Cartesian3_default.fromArray(
          topPositions,
          i3 + 3,
          scratchCartesian3Position5
        );
      }
      if (recomputeNormal) {
        const scalednextPosition = Cartesian3_default.subtract(
          nextTop,
          topPosition,
          scratchCartesian3Position4
        );
        const scaledGroundPosition = Cartesian3_default.subtract(
          groundPosition,
          topPosition,
          scratchCartesian3Position1
        );
        normal2 = Cartesian3_default.normalize(
          Cartesian3_default.cross(scaledGroundPosition, scalednextPosition, normal2),
          normal2
        );
        recomputeNormal = false;
      }
      if (Cartesian3_default.equalsEpsilon(topPosition, nextTop, Math_default.EPSILON10)) {
        recomputeNormal = true;
      } else {
        s2 += ds;
        if (vertexFormat.tangent) {
          tangent = Cartesian3_default.normalize(
            Cartesian3_default.subtract(nextTop, topPosition, tangent),
            tangent
          );
        }
        if (vertexFormat.bitangent) {
          bitangent = Cartesian3_default.normalize(
            Cartesian3_default.cross(normal2, tangent, bitangent),
            bitangent
          );
        }
      }
      if (vertexFormat.normal) {
        normals[normalIndex++] = normal2.x;
        normals[normalIndex++] = normal2.y;
        normals[normalIndex++] = normal2.z;
        normals[normalIndex++] = normal2.x;
        normals[normalIndex++] = normal2.y;
        normals[normalIndex++] = normal2.z;
      }
      if (vertexFormat.tangent) {
        tangents[tangentIndex++] = tangent.x;
        tangents[tangentIndex++] = tangent.y;
        tangents[tangentIndex++] = tangent.z;
        tangents[tangentIndex++] = tangent.x;
        tangents[tangentIndex++] = tangent.y;
        tangents[tangentIndex++] = tangent.z;
      }
      if (vertexFormat.bitangent) {
        bitangents[bitangentIndex++] = bitangent.x;
        bitangents[bitangentIndex++] = bitangent.y;
        bitangents[bitangentIndex++] = bitangent.z;
        bitangents[bitangentIndex++] = bitangent.x;
        bitangents[bitangentIndex++] = bitangent.y;
        bitangents[bitangentIndex++] = bitangent.z;
      }
    }
  }
  const attributes = new GeometryAttributes_default();
  if (vertexFormat.position) {
    attributes.position = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: positions
    });
  }
  if (vertexFormat.normal) {
    attributes.normal = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: normals
    });
  }
  if (vertexFormat.tangent) {
    attributes.tangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: tangents
    });
  }
  if (vertexFormat.bitangent) {
    attributes.bitangent = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3,
      values: bitangents
    });
  }
  if (vertexFormat.st) {
    attributes.st = new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2,
      values: textureCoordinates
    });
  }
  const numVertices = size / 3;
  size -= 6 * (numCorners + 1);
  const indices2 = IndexDatatype_default.createTypedArray(numVertices, size);
  let edgeIndex = 0;
  for (i2 = 0; i2 < numVertices - 2; i2 += 2) {
    const LL = i2;
    const LR = i2 + 2;
    const pl = Cartesian3_default.fromArray(
      positions,
      LL * 3,
      scratchCartesian3Position1
    );
    const pr = Cartesian3_default.fromArray(
      positions,
      LR * 3,
      scratchCartesian3Position2
    );
    if (Cartesian3_default.equalsEpsilon(pl, pr, Math_default.EPSILON10)) {
      continue;
    }
    const UL = i2 + 1;
    const UR = i2 + 3;
    indices2[edgeIndex++] = UL;
    indices2[edgeIndex++] = LL;
    indices2[edgeIndex++] = UR;
    indices2[edgeIndex++] = UR;
    indices2[edgeIndex++] = LL;
    indices2[edgeIndex++] = LR;
  }
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingSphere: new BoundingSphere_default.fromVertices(positions)
  });
};
var WallGeometry_default = WallGeometry;

// node_modules/cesium/Source/Core/WallOutlineGeometry.js
var scratchCartesian3Position12 = new Cartesian3_default();
var scratchCartesian3Position22 = new Cartesian3_default();
function WallOutlineGeometry(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const wallPositions = options.positions;
  const maximumHeights = options.maximumHeights;
  const minimumHeights = options.minimumHeights;
  if (!defined_default(wallPositions)) {
    throw new DeveloperError_default("options.positions is required.");
  }
  if (defined_default(maximumHeights) && maximumHeights.length !== wallPositions.length) {
    throw new DeveloperError_default(
      "options.positions and options.maximumHeights must have the same length."
    );
  }
  if (defined_default(minimumHeights) && minimumHeights.length !== wallPositions.length) {
    throw new DeveloperError_default(
      "options.positions and options.minimumHeights must have the same length."
    );
  }
  const granularity = defaultValue_default(
    options.granularity,
    Math_default.RADIANS_PER_DEGREE
  );
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._positions = wallPositions;
  this._minimumHeights = minimumHeights;
  this._maximumHeights = maximumHeights;
  this._granularity = granularity;
  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
  this._workerName = "createWallOutlineGeometry";
  let numComponents = 1 + wallPositions.length * Cartesian3_default.packedLength + 2;
  if (defined_default(minimumHeights)) {
    numComponents += minimumHeights.length;
  }
  if (defined_default(maximumHeights)) {
    numComponents += maximumHeights.length;
  }
  this.packedLength = numComponents + Ellipsoid_default.packedLength + 1;
}
WallOutlineGeometry.pack = function(value, array, startingIndex) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required");
  }
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  const positions = value._positions;
  let length3 = positions.length;
  array[startingIndex++] = length3;
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    Cartesian3_default.pack(positions[i2], array, startingIndex);
  }
  const minimumHeights = value._minimumHeights;
  length3 = defined_default(minimumHeights) ? minimumHeights.length : 0;
  array[startingIndex++] = length3;
  if (defined_default(minimumHeights)) {
    for (i2 = 0; i2 < length3; ++i2) {
      array[startingIndex++] = minimumHeights[i2];
    }
  }
  const maximumHeights = value._maximumHeights;
  length3 = defined_default(maximumHeights) ? maximumHeights.length : 0;
  array[startingIndex++] = length3;
  if (defined_default(maximumHeights)) {
    for (i2 = 0; i2 < length3; ++i2) {
      array[startingIndex++] = maximumHeights[i2];
    }
  }
  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
  startingIndex += Ellipsoid_default.packedLength;
  array[startingIndex] = value._granularity;
  return array;
};
var scratchEllipsoid14 = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var scratchOptions24 = {
  positions: void 0,
  minimumHeights: void 0,
  maximumHeights: void 0,
  ellipsoid: scratchEllipsoid14,
  granularity: void 0
};
WallOutlineGeometry.unpack = function(array, startingIndex, result) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required");
  }
  startingIndex = defaultValue_default(startingIndex, 0);
  let i2;
  let length3 = array[startingIndex++];
  const positions = new Array(length3);
  for (i2 = 0; i2 < length3; ++i2, startingIndex += Cartesian3_default.packedLength) {
    positions[i2] = Cartesian3_default.unpack(array, startingIndex);
  }
  length3 = array[startingIndex++];
  let minimumHeights;
  if (length3 > 0) {
    minimumHeights = new Array(length3);
    for (i2 = 0; i2 < length3; ++i2) {
      minimumHeights[i2] = array[startingIndex++];
    }
  }
  length3 = array[startingIndex++];
  let maximumHeights;
  if (length3 > 0) {
    maximumHeights = new Array(length3);
    for (i2 = 0; i2 < length3; ++i2) {
      maximumHeights[i2] = array[startingIndex++];
    }
  }
  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid14);
  startingIndex += Ellipsoid_default.packedLength;
  const granularity = array[startingIndex];
  if (!defined_default(result)) {
    scratchOptions24.positions = positions;
    scratchOptions24.minimumHeights = minimumHeights;
    scratchOptions24.maximumHeights = maximumHeights;
    scratchOptions24.granularity = granularity;
    return new WallOutlineGeometry(scratchOptions24);
  }
  result._positions = positions;
  result._minimumHeights = minimumHeights;
  result._maximumHeights = maximumHeights;
  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
  result._granularity = granularity;
  return result;
};
WallOutlineGeometry.fromConstantHeights = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const positions = options.positions;
  if (!defined_default(positions)) {
    throw new DeveloperError_default("options.positions is required.");
  }
  let minHeights;
  let maxHeights;
  const min3 = options.minimumHeight;
  const max3 = options.maximumHeight;
  const doMin = defined_default(min3);
  const doMax = defined_default(max3);
  if (doMin || doMax) {
    const length3 = positions.length;
    minHeights = doMin ? new Array(length3) : void 0;
    maxHeights = doMax ? new Array(length3) : void 0;
    for (let i2 = 0; i2 < length3; ++i2) {
      if (doMin) {
        minHeights[i2] = min3;
      }
      if (doMax) {
        maxHeights[i2] = max3;
      }
    }
  }
  const newOptions2 = {
    positions,
    maximumHeights: maxHeights,
    minimumHeights: minHeights,
    ellipsoid: options.ellipsoid
  };
  return new WallOutlineGeometry(newOptions2);
};
WallOutlineGeometry.createGeometry = function(wallGeometry) {
  const wallPositions = wallGeometry._positions;
  const minimumHeights = wallGeometry._minimumHeights;
  const maximumHeights = wallGeometry._maximumHeights;
  const granularity = wallGeometry._granularity;
  const ellipsoid = wallGeometry._ellipsoid;
  const pos = WallGeometryLibrary_default.computePositions(
    ellipsoid,
    wallPositions,
    maximumHeights,
    minimumHeights,
    granularity,
    false
  );
  if (!defined_default(pos)) {
    return;
  }
  const bottomPositions = pos.bottomPositions;
  const topPositions = pos.topPositions;
  let length3 = topPositions.length;
  let size = length3 * 2;
  const positions = new Float64Array(size);
  let positionIndex = 0;
  length3 /= 3;
  let i2;
  for (i2 = 0; i2 < length3; ++i2) {
    const i3 = i2 * 3;
    const topPosition = Cartesian3_default.fromArray(
      topPositions,
      i3,
      scratchCartesian3Position12
    );
    const bottomPosition = Cartesian3_default.fromArray(
      bottomPositions,
      i3,
      scratchCartesian3Position22
    );
    positions[positionIndex++] = bottomPosition.x;
    positions[positionIndex++] = bottomPosition.y;
    positions[positionIndex++] = bottomPosition.z;
    positions[positionIndex++] = topPosition.x;
    positions[positionIndex++] = topPosition.y;
    positions[positionIndex++] = topPosition.z;
  }
  const attributes = new GeometryAttributes_default({
    position: new GeometryAttribute_default({
      componentDatatype: ComponentDatatype_default.DOUBLE,
      componentsPerAttribute: 3,
      values: positions
    })
  });
  const numVertices = size / 3;
  size = 2 * numVertices - 4 + numVertices;
  const indices2 = IndexDatatype_default.createTypedArray(numVertices, size);
  let edgeIndex = 0;
  for (i2 = 0; i2 < numVertices - 2; i2 += 2) {
    const LL = i2;
    const LR = i2 + 2;
    const pl = Cartesian3_default.fromArray(
      positions,
      LL * 3,
      scratchCartesian3Position12
    );
    const pr = Cartesian3_default.fromArray(
      positions,
      LR * 3,
      scratchCartesian3Position22
    );
    if (Cartesian3_default.equalsEpsilon(pl, pr, Math_default.EPSILON10)) {
      continue;
    }
    const UL = i2 + 1;
    const UR = i2 + 3;
    indices2[edgeIndex++] = UL;
    indices2[edgeIndex++] = LL;
    indices2[edgeIndex++] = UL;
    indices2[edgeIndex++] = UR;
    indices2[edgeIndex++] = LL;
    indices2[edgeIndex++] = LR;
  }
  indices2[edgeIndex++] = numVertices - 2;
  indices2[edgeIndex++] = numVertices - 1;
  return new Geometry_default({
    attributes,
    indices: indices2,
    primitiveType: PrimitiveType_default.LINES,
    boundingSphere: new BoundingSphere_default.fromVertices(positions)
  });
};
var WallOutlineGeometry_default = WallOutlineGeometry;

// node_modules/cesium/Source/Core/WireframeIndexGenerator.js
var WireframeIndexGenerator = {};
function createWireframeFromTriangles(vertexCount) {
  const wireframeIndices = IndexDatatype_default.createTypedArray(
    vertexCount,
    vertexCount * 2
  );
  const length3 = vertexCount;
  let index2 = 0;
  for (let i2 = 0; i2 < length3; i2 += 3) {
    wireframeIndices[index2++] = i2;
    wireframeIndices[index2++] = i2 + 1;
    wireframeIndices[index2++] = i2 + 1;
    wireframeIndices[index2++] = i2 + 2;
    wireframeIndices[index2++] = i2 + 2;
    wireframeIndices[index2++] = i2;
  }
  return wireframeIndices;
}
function createWireframeFromTriangleIndices(vertexCount, originalIndices) {
  const originalIndicesCount = originalIndices.length;
  const wireframeIndices = IndexDatatype_default.createTypedArray(
    vertexCount,
    originalIndicesCount * 2
  );
  let index2 = 0;
  for (let i2 = 0; i2 < originalIndicesCount; i2 += 3) {
    const point0 = originalIndices[i2];
    const point1 = originalIndices[i2 + 1];
    const point2 = originalIndices[i2 + 2];
    wireframeIndices[index2++] = point0;
    wireframeIndices[index2++] = point1;
    wireframeIndices[index2++] = point1;
    wireframeIndices[index2++] = point2;
    wireframeIndices[index2++] = point2;
    wireframeIndices[index2++] = point0;
  }
  return wireframeIndices;
}
function createWireframeFromTriangleStrip(vertexCount) {
  const numberOfTriangles = vertexCount - 2;
  const wireframeIndicesCount = 2 + numberOfTriangles * 4;
  const wireframeIndices = IndexDatatype_default.createTypedArray(
    vertexCount,
    wireframeIndicesCount
  );
  let index2 = 0;
  wireframeIndices[index2++] = 0;
  wireframeIndices[index2++] = 1;
  for (let i2 = 0; i2 < numberOfTriangles; i2++) {
    wireframeIndices[index2++] = i2 + 1;
    wireframeIndices[index2++] = i2 + 2;
    wireframeIndices[index2++] = i2 + 2;
    wireframeIndices[index2++] = i2;
  }
  return wireframeIndices;
}
function createWireframeFromTriangleStripIndices(vertexCount, originalIndices) {
  const originalIndicesCount = originalIndices.length;
  const numberOfTriangles = originalIndicesCount - 2;
  const wireframeIndicesCount = 2 + numberOfTriangles * 4;
  const wireframeIndices = IndexDatatype_default.createTypedArray(
    vertexCount,
    wireframeIndicesCount
  );
  let index2 = 0;
  wireframeIndices[index2++] = originalIndices[0];
  wireframeIndices[index2++] = originalIndices[1];
  for (let i2 = 0; i2 < numberOfTriangles; i2++) {
    const point0 = originalIndices[i2];
    const point1 = originalIndices[i2 + 1];
    const point2 = originalIndices[i2 + 2];
    wireframeIndices[index2++] = point1;
    wireframeIndices[index2++] = point2;
    wireframeIndices[index2++] = point2;
    wireframeIndices[index2++] = point0;
  }
  return wireframeIndices;
}
function createWireframeFromTriangleFan(vertexCount) {
  const numberOfTriangles = vertexCount - 2;
  const wireframeIndicesCount = 2 + numberOfTriangles * 4;
  const wireframeIndices = IndexDatatype_default.createTypedArray(
    vertexCount,
    wireframeIndicesCount
  );
  let index2 = 0;
  wireframeIndices[index2++] = 0;
  wireframeIndices[index2++] = 1;
  for (let i2 = 0; i2 < numberOfTriangles; i2++) {
    wireframeIndices[index2++] = i2 + 1;
    wireframeIndices[index2++] = i2 + 2;
    wireframeIndices[index2++] = i2 + 2;
    wireframeIndices[index2++] = 0;
  }
  return wireframeIndices;
}
function createWireframeFromTriangleFanIndices(vertexCount, originalIndices) {
  const originalIndicesCount = originalIndices.length;
  const numberOfTriangles = originalIndicesCount - 2;
  const wireframeIndicesCount = 2 + numberOfTriangles * 4;
  const wireframeIndices = IndexDatatype_default.createTypedArray(
    vertexCount,
    wireframeIndicesCount
  );
  let index2 = 0;
  const firstPoint = originalIndices[0];
  wireframeIndices[index2++] = firstPoint;
  wireframeIndices[index2++] = originalIndices[1];
  for (let i2 = 0; i2 < numberOfTriangles; i2++) {
    const point1 = originalIndices[i2 + 1];
    const point2 = originalIndices[i2 + 2];
    wireframeIndices[index2++] = point1;
    wireframeIndices[index2++] = point2;
    wireframeIndices[index2++] = point2;
    wireframeIndices[index2++] = firstPoint;
  }
  return wireframeIndices;
}
WireframeIndexGenerator.createWireframeIndices = function(primitiveType, vertexCount, originalIndices) {
  const hasOriginalIndices = defined_default(originalIndices);
  if (primitiveType === PrimitiveType_default.TRIANGLES) {
    return hasOriginalIndices ? createWireframeFromTriangleIndices(vertexCount, originalIndices) : createWireframeFromTriangles(vertexCount);
  }
  if (primitiveType === PrimitiveType_default.TRIANGLE_STRIP) {
    return hasOriginalIndices ? createWireframeFromTriangleStripIndices(vertexCount, originalIndices) : createWireframeFromTriangleStrip(vertexCount);
  }
  if (primitiveType === PrimitiveType_default.TRIANGLE_FAN) {
    return hasOriginalIndices ? createWireframeFromTriangleFanIndices(vertexCount, originalIndices) : createWireframeFromTriangleFan(vertexCount);
  }
  return void 0;
};
WireframeIndexGenerator.getWireframeIndicesCount = function(primitiveType, originalCount) {
  if (primitiveType === PrimitiveType_default.TRIANGLES) {
    return originalCount * 2;
  }
  if (primitiveType === PrimitiveType_default.TRIANGLE_STRIP || primitiveType === PrimitiveType_default.TRIANGLE_FAN) {
    const numberOfTriangles = originalCount - 2;
    return 2 + numberOfTriangles * 4;
  }
  return originalCount;
};
var WireframeIndexGenerator_default = WireframeIndexGenerator;

// node_modules/cesium/Source/Core/arraySlice.js
function arraySlice(array, begin, end) {
  Check_default.defined("array", array);
  if (defined_default(begin)) {
    Check_default.typeOf.number("begin", begin);
  }
  if (defined_default(end)) {
    Check_default.typeOf.number("end", end);
  }
  if (typeof array.slice === "function") {
    return array.slice(begin, end);
  }
  let copy = Array.prototype.slice.call(array, begin, end);
  const typedArrayTypes2 = FeatureDetection_default.typedArrayTypes;
  const length3 = typedArrayTypes2.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (array instanceof typedArrayTypes2[i2]) {
      copy = new typedArrayTypes2[i2](copy);
      break;
    }
  }
  return copy;
}
var arraySlice_default = arraySlice;

// node_modules/cesium/Source/Core/cancelAnimationFrame.js
var implementation2;
if (typeof cancelAnimationFrame !== "undefined") {
  implementation2 = cancelAnimationFrame;
}
(function() {
  if (!defined_default(implementation2) && typeof window !== "undefined") {
    const vendors = ["webkit", "moz", "ms", "o"];
    let i2 = 0;
    const len = vendors.length;
    while (i2 < len && !defined_default(implementation2)) {
      implementation2 = window[`${vendors[i2]}CancelAnimationFrame`];
      if (!defined_default(implementation2)) {
        implementation2 = window[`${vendors[i2]}CancelRequestAnimationFrame`];
      }
      ++i2;
    }
  }
  if (!defined_default(implementation2)) {
    implementation2 = clearTimeout;
  }
})();
function cancelAnimationFramePolyfill(requestID) {
  implementation2(requestID);
}
var cancelAnimationFrame_default = cancelAnimationFramePolyfill;

// node_modules/cesium/Source/Core/createGuid.js
function createGuid() {
  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c14) {
    const r2 = Math.random() * 16 | 0;
    const v7 = c14 === "x" ? r2 : r2 & 3 | 8;
    return v7.toString(16);
  });
}
var createGuid_default = createGuid;

// node_modules/cesium/Source/Core/createWorldTerrain.js
function createWorldTerrain(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  return new CesiumTerrainProvider_default({
    url: IonResource_default.fromAssetId(1),
    requestVertexNormals: defaultValue_default(options.requestVertexNormals, false),
    requestWaterMask: defaultValue_default(options.requestWaterMask, false)
  });
}
var createWorldTerrain_default = createWorldTerrain;

// node_modules/cesium/Source/Core/decodeGoogleEarthEnterpriseData.js
var compressedMagic = 1953029805;
var compressedMagicSwap = 2917034100;
function decodeGoogleEarthEnterpriseData(key, data) {
  if (decodeGoogleEarthEnterpriseData.passThroughDataForTesting) {
    return data;
  }
  Check_default.typeOf.object("key", key);
  Check_default.typeOf.object("data", data);
  const keyLength = key.byteLength;
  if (keyLength === 0 || keyLength % 4 !== 0) {
    throw new RuntimeError_default(
      "The length of key must be greater than 0 and a multiple of 4."
    );
  }
  const dataView = new DataView(data);
  const magic = dataView.getUint32(0, true);
  if (magic === compressedMagic || magic === compressedMagicSwap) {
    return data;
  }
  const keyView = new DataView(key);
  let dp = 0;
  const dpend = data.byteLength;
  const dpend64 = dpend - dpend % 8;
  const kpend = keyLength;
  let kp;
  let off = 8;
  while (dp < dpend64) {
    off = (off + 8) % 24;
    kp = off;
    while (dp < dpend64 && kp < kpend) {
      dataView.setUint32(
        dp,
        dataView.getUint32(dp, true) ^ keyView.getUint32(kp, true),
        true
      );
      dataView.setUint32(
        dp + 4,
        dataView.getUint32(dp + 4, true) ^ keyView.getUint32(kp + 4, true),
        true
      );
      dp += 8;
      kp += 24;
    }
  }
  if (dp < dpend) {
    if (kp >= kpend) {
      off = (off + 8) % 24;
      kp = off;
    }
    while (dp < dpend) {
      dataView.setUint8(dp, dataView.getUint8(dp) ^ keyView.getUint8(kp));
      dp++;
      kp++;
    }
  }
}
decodeGoogleEarthEnterpriseData.passThroughDataForTesting = false;
var decodeGoogleEarthEnterpriseData_default = decodeGoogleEarthEnterpriseData;

// node_modules/cesium/Source/Core/decodeVectorPolylinePositions.js
var maxShort2 = 32767;
var scratchBVCartographic = new Cartographic_default();
var scratchEncodedPosition = new Cartesian3_default();
function decodeVectorPolylinePositions(positions, rectangle, minimumHeight, maximumHeight, ellipsoid) {
  const positionsLength = positions.length / 3;
  const uBuffer = positions.subarray(0, positionsLength);
  const vBuffer = positions.subarray(positionsLength, 2 * positionsLength);
  const heightBuffer = positions.subarray(
    2 * positionsLength,
    3 * positionsLength
  );
  AttributeCompression_default.zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer);
  const decoded = new Float64Array(positions.length);
  for (let i2 = 0; i2 < positionsLength; ++i2) {
    const u3 = uBuffer[i2];
    const v7 = vBuffer[i2];
    const h = heightBuffer[i2];
    const lon = Math_default.lerp(rectangle.west, rectangle.east, u3 / maxShort2);
    const lat = Math_default.lerp(rectangle.south, rectangle.north, v7 / maxShort2);
    const alt = Math_default.lerp(minimumHeight, maximumHeight, h / maxShort2);
    const cartographic2 = Cartographic_default.fromRadians(
      lon,
      lat,
      alt,
      scratchBVCartographic
    );
    const decodedPosition = ellipsoid.cartographicToCartesian(
      cartographic2,
      scratchEncodedPosition
    );
    Cartesian3_default.pack(decodedPosition, decoded, i2 * 3);
  }
  return decoded;
}
var decodeVectorPolylinePositions_default = decodeVectorPolylinePositions;

// node_modules/cesium/Source/Core/deprecationWarning.js
function deprecationWarning(identifier, message) {
  if (!defined_default(identifier) || !defined_default(message)) {
    throw new DeveloperError_default("identifier and message are required.");
  }
  oneTimeWarning_default(identifier, message);
}
var deprecationWarning_default = deprecationWarning;

// node_modules/cesium/Source/Core/getFilenameFromUri.js
function getFilenameFromUri(uri) {
  if (!defined_default(uri)) {
    throw new DeveloperError_default("uri is required.");
  }
  const uriObject = new URI(uri);
  uriObject.normalize();
  let path = uriObject.path();
  const index2 = path.lastIndexOf("/");
  if (index2 !== -1) {
    path = path.substr(index2 + 1);
  }
  return path;
}
var getFilenameFromUri_default = getFilenameFromUri;

// node_modules/cesium/Source/Core/getMagic.js
function getMagic(uint8Array, byteOffset) {
  byteOffset = defaultValue_default(byteOffset, 0);
  return getStringFromTypedArray_default(
    uint8Array,
    byteOffset,
    Math.min(4, uint8Array.length)
  );
}
var getMagic_default = getMagic;

// node_modules/cesium/Source/Core/loadImageFromTypedArray.js
function loadImageFromTypedArray(options) {
  const uint8Array = options.uint8Array;
  const format = options.format;
  const request = options.request;
  const flipY = defaultValue_default(options.flipY, false);
  const skipColorSpaceConversion = defaultValue_default(
    options.skipColorSpaceConversion,
    false
  );
  Check_default.typeOf.object("uint8Array", uint8Array);
  Check_default.typeOf.string("format", format);
  const blob = new Blob([uint8Array], {
    type: format
  });
  let blobUrl;
  return Resource_default.supportsImageBitmapOptions().then(function(result) {
    if (result) {
      return Promise.resolve(
        Resource_default.createImageBitmapFromBlob(blob, {
          flipY,
          premultiplyAlpha: false,
          skipColorSpaceConversion
        })
      );
    }
    blobUrl = window.URL.createObjectURL(blob);
    const resource = new Resource_default({
      url: blobUrl,
      request
    });
    return resource.fetchImage({
      flipY,
      skipColorSpaceConversion
    });
  }).then(function(result) {
    if (defined_default(blobUrl)) {
      window.URL.revokeObjectURL(blobUrl);
    }
    return result;
  }).catch(function(error) {
    if (defined_default(blobUrl)) {
      window.URL.revokeObjectURL(blobUrl);
    }
    return Promise.reject(error);
  });
}
var loadImageFromTypedArray_default = loadImageFromTypedArray;

// node_modules/cesium/Source/Core/loadKTX2.js
var supportedTranscoderFormats;
loadKTX2.setKTX2SupportedFormats = function(s3tc, pvrtc, astc, etc, etc1, bc7) {
  supportedTranscoderFormats = {
    s3tc,
    pvrtc,
    astc,
    etc,
    etc1,
    bc7
  };
};
function loadKTX2(resourceOrUrlOrBuffer) {
  Check_default.defined("resourceOrUrlOrBuffer", resourceOrUrlOrBuffer);
  let loadPromise;
  if (resourceOrUrlOrBuffer instanceof ArrayBuffer || ArrayBuffer.isView(resourceOrUrlOrBuffer)) {
    loadPromise = Promise.resolve(resourceOrUrlOrBuffer);
  } else {
    const resource = Resource_default.createIfNeeded(resourceOrUrlOrBuffer);
    loadPromise = resource.fetchArrayBuffer();
  }
  return loadPromise.then(function(data) {
    return KTX2Transcoder_default.transcode(data, supportedTranscoderFormats);
  });
}
var loadKTX2_default = loadKTX2;

// node_modules/cesium/Source/Core/mergeSort.js
var leftScratchArray = [];
var rightScratchArray = [];
function merge(array, compare, userDefinedObject, start, middle, end) {
  const leftLength = middle - start + 1;
  const rightLength = end - middle;
  const left = leftScratchArray;
  const right = rightScratchArray;
  let i2;
  let j;
  for (i2 = 0; i2 < leftLength; ++i2) {
    left[i2] = array[start + i2];
  }
  for (j = 0; j < rightLength; ++j) {
    right[j] = array[middle + j + 1];
  }
  i2 = 0;
  j = 0;
  for (let k = start; k <= end; ++k) {
    const leftElement = left[i2];
    const rightElement = right[j];
    if (i2 < leftLength && (j >= rightLength || compare(leftElement, rightElement, userDefinedObject) <= 0)) {
      array[k] = leftElement;
      ++i2;
    } else if (j < rightLength) {
      array[k] = rightElement;
      ++j;
    }
  }
}
function sort(array, compare, userDefinedObject, start, end) {
  if (start >= end) {
    return;
  }
  const middle = Math.floor((start + end) * 0.5);
  sort(array, compare, userDefinedObject, start, middle);
  sort(array, compare, userDefinedObject, middle + 1, end);
  merge(array, compare, userDefinedObject, start, middle, end);
}
function mergeSort(array, comparator, userDefinedObject) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required.");
  }
  if (!defined_default(comparator)) {
    throw new DeveloperError_default("comparator is required.");
  }
  const length3 = array.length;
  const scratchLength = Math.ceil(length3 * 0.5);
  leftScratchArray.length = scratchLength;
  rightScratchArray.length = scratchLength;
  sort(array, comparator, userDefinedObject, 0, length3 - 1);
  leftScratchArray.length = 0;
  rightScratchArray.length = 0;
}
var mergeSort_default = mergeSort;

// node_modules/cesium/Source/Core/pointInsideTriangle.js
var scratchBarycentricCoords = new Cartesian3_default();
function pointInsideTriangle(point, p0, p1, p2) {
  const coords = barycentricCoordinates_default(
    point,
    p0,
    p1,
    p2,
    scratchBarycentricCoords
  );
  if (!defined_default(coords)) {
    return false;
  }
  return coords.x > 0 && coords.y > 0 && coords.z > 0;
}
var pointInsideTriangle_default = pointInsideTriangle;

// node_modules/cesium/Source/Core/requestAnimationFrame.js
var implementation3;
if (typeof requestAnimationFrame !== "undefined") {
  implementation3 = requestAnimationFrame;
}
(function() {
  if (!defined_default(implementation3) && typeof window !== "undefined") {
    const vendors = ["webkit", "moz", "ms", "o"];
    let i2 = 0;
    const len = vendors.length;
    while (i2 < len && !defined_default(implementation3)) {
      implementation3 = window[`${vendors[i2]}RequestAnimationFrame`];
      ++i2;
    }
  }
  if (!defined_default(implementation3)) {
    const msPerFrame = 1e3 / 60;
    let lastFrameTime = 0;
    implementation3 = function(callback) {
      const currentTime = getTimestamp_default();
      const delay = Math.max(msPerFrame - (currentTime - lastFrameTime), 0);
      lastFrameTime = currentTime + delay;
      return setTimeout(function() {
        callback(lastFrameTime);
      }, delay);
    };
  }
})();
function requestAnimationFramePolyFill(callback) {
  return implementation3(callback);
}
var requestAnimationFrame_default = requestAnimationFramePolyFill;

// node_modules/cesium/Source/Core/sampleTerrain.js
function sampleTerrain(terrainProvider, level, positions) {
  Check_default.typeOf.object("terrainProvider", terrainProvider);
  Check_default.typeOf.number("level", level);
  Check_default.defined("positions", positions);
  return terrainProvider.readyPromise.then(function() {
    return doSampling(terrainProvider, level, positions);
  });
}
function doSampling(terrainProvider, level, positions) {
  const tilingScheme2 = terrainProvider.tilingScheme;
  let i2;
  const tileRequests = [];
  const tileRequestSet = {};
  for (i2 = 0; i2 < positions.length; ++i2) {
    const xy = tilingScheme2.positionToTileXY(positions[i2], level);
    const key = xy.toString();
    if (!tileRequestSet.hasOwnProperty(key)) {
      const value = {
        x: xy.x,
        y: xy.y,
        level,
        tilingScheme: tilingScheme2,
        terrainProvider,
        positions: []
      };
      tileRequestSet[key] = value;
      tileRequests.push(value);
    }
    tileRequestSet[key].positions.push(positions[i2]);
  }
  const tilePromises = [];
  for (i2 = 0; i2 < tileRequests.length; ++i2) {
    const tileRequest = tileRequests[i2];
    const requestPromise = tileRequest.terrainProvider.requestTileGeometry(
      tileRequest.x,
      tileRequest.y,
      tileRequest.level
    );
    const tilePromise = requestPromise.then(createInterpolateFunction(tileRequest)).catch(createMarkFailedFunction(tileRequest));
    tilePromises.push(tilePromise);
  }
  return Promise.all(tilePromises).then(function() {
    return positions;
  });
}
function interpolateAndAssignHeight(position, terrainData, rectangle) {
  const height = terrainData.interpolateHeight(
    rectangle,
    position.longitude,
    position.latitude
  );
  if (height === void 0) {
    return false;
  }
  position.height = height;
  return true;
}
function createInterpolateFunction(tileRequest) {
  const tilePositions = tileRequest.positions;
  const rectangle = tileRequest.tilingScheme.tileXYToRectangle(
    tileRequest.x,
    tileRequest.y,
    tileRequest.level
  );
  return function(terrainData) {
    let isMeshRequired = false;
    for (let i2 = 0; i2 < tilePositions.length; ++i2) {
      const position = tilePositions[i2];
      const isHeightAssigned = interpolateAndAssignHeight(
        position,
        terrainData,
        rectangle
      );
      if (!isHeightAssigned) {
        isMeshRequired = true;
        break;
      }
    }
    if (!isMeshRequired) {
      return Promise.resolve();
    }
    return terrainData.createMesh({
      tilingScheme: tileRequest.tilingScheme,
      x: tileRequest.x,
      y: tileRequest.y,
      level: tileRequest.level,
      throttle: false
    }).then(function() {
      for (let i2 = 0; i2 < tilePositions.length; ++i2) {
        const position = tilePositions[i2];
        interpolateAndAssignHeight(position, terrainData, rectangle);
      }
    });
  };
}
function createMarkFailedFunction(tileRequest) {
  const tilePositions = tileRequest.positions;
  return function() {
    for (let i2 = 0; i2 < tilePositions.length; ++i2) {
      const position = tilePositions[i2];
      position.height = void 0;
    }
  };
}
var sampleTerrain_default = sampleTerrain;

// node_modules/cesium/Source/Core/sampleTerrainMostDetailed.js
var scratchCartesian29 = new Cartesian2_default();
function sampleTerrainMostDetailed(terrainProvider, positions) {
  if (!defined_default(terrainProvider)) {
    throw new DeveloperError_default("terrainProvider is required.");
  }
  if (!defined_default(positions)) {
    throw new DeveloperError_default("positions is required.");
  }
  return terrainProvider.readyPromise.then(function() {
    const byLevel = [];
    const maxLevels = [];
    const availability = terrainProvider.availability;
    if (!defined_default(availability)) {
      throw new DeveloperError_default(
        "sampleTerrainMostDetailed requires a terrain provider that has tile availability."
      );
    }
    const promises = [];
    for (let i2 = 0; i2 < positions.length; ++i2) {
      const position = positions[i2];
      const maxLevel = availability.computeMaximumLevelAtPosition(position);
      maxLevels[i2] = maxLevel;
      if (maxLevel === 0) {
        terrainProvider.tilingScheme.positionToTileXY(
          position,
          1,
          scratchCartesian29
        );
        const promise = terrainProvider.loadTileDataAvailability(
          scratchCartesian29.x,
          scratchCartesian29.y,
          1
        );
        if (defined_default(promise)) {
          promises.push(promise);
        }
      }
      let atLevel = byLevel[maxLevel];
      if (!defined_default(atLevel)) {
        byLevel[maxLevel] = atLevel = [];
      }
      atLevel.push(position);
    }
    return Promise.all(promises).then(function() {
      return Promise.all(
        byLevel.map(function(positionsAtLevel, index2) {
          if (defined_default(positionsAtLevel)) {
            return sampleTerrain_default(terrainProvider, index2, positionsAtLevel);
          }
        })
      );
    }).then(function() {
      const changedPositions = [];
      for (let i2 = 0; i2 < positions.length; ++i2) {
        const position = positions[i2];
        const maxLevel = availability.computeMaximumLevelAtPosition(position);
        if (maxLevel !== maxLevels[i2]) {
          changedPositions.push(position);
        }
      }
      if (changedPositions.length > 0) {
        return sampleTerrainMostDetailed(terrainProvider, changedPositions);
      }
    }).then(function() {
      return positions;
    });
  });
}
var sampleTerrainMostDetailed_default = sampleTerrainMostDetailed;

// node_modules/cesium/Source/Core/subdivideArray.js
function subdivideArray(array, numberOfArrays) {
  if (!defined_default(array)) {
    throw new DeveloperError_default("array is required.");
  }
  if (!defined_default(numberOfArrays) || numberOfArrays < 1) {
    throw new DeveloperError_default("numberOfArrays must be greater than 0.");
  }
  const result = [];
  const len = array.length;
  let i2 = 0;
  while (i2 < len) {
    const size = Math.ceil((len - i2) / numberOfArrays--);
    result.push(array.slice(i2, i2 + size));
    i2 += size;
  }
  return result;
}
var subdivideArray_default = subdivideArray;

// node_modules/cesium/Source/Core/webGLConstantToGlslType.js
function webGLConstantToGlslType(webGLValue) {
  switch (webGLValue) {
    case WebGLConstants_default.FLOAT:
      return "float";
    case WebGLConstants_default.FLOAT_VEC2:
      return "vec2";
    case WebGLConstants_default.FLOAT_VEC3:
      return "vec3";
    case WebGLConstants_default.FLOAT_VEC4:
      return "vec4";
    case WebGLConstants_default.FLOAT_MAT2:
      return "mat2";
    case WebGLConstants_default.FLOAT_MAT3:
      return "mat3";
    case WebGLConstants_default.FLOAT_MAT4:
      return "mat4";
    case WebGLConstants_default.SAMPLER_2D:
      return "sampler2D";
    case WebGLConstants_default.BOOL:
      return "bool";
  }
}
var webGLConstantToGlslType_default = webGLConstantToGlslType;

// node_modules/cesium/Source/Core/wrapFunction.js
function wrapFunction(obj, oldFunction, newFunction) {
  if (typeof oldFunction !== "function") {
    throw new DeveloperError_default("oldFunction is required to be a function.");
  }
  if (typeof newFunction !== "function") {
    throw new DeveloperError_default("oldFunction is required to be a function.");
  }
  return function() {
    newFunction.apply(obj, arguments);
    oldFunction.apply(obj, arguments);
  };
}
var wrapFunction_default = wrapFunction;

// node_modules/cesium/Source/DataSources/ConstantProperty.js
function ConstantProperty(value) {
  this._value = void 0;
  this._hasClone = false;
  this._hasEquals = false;
  this._definitionChanged = new Event_default();
  this.setValue(value);
}
Object.defineProperties(ConstantProperty.prototype, {
  isConstant: {
    value: true
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  }
});
ConstantProperty.prototype.getValue = function(time, result) {
  return this._hasClone ? this._value.clone(result) : this._value;
};
ConstantProperty.prototype.setValue = function(value) {
  const oldValue2 = this._value;
  if (oldValue2 !== value) {
    const isDefined = defined_default(value);
    const hasClone = isDefined && typeof value.clone === "function";
    const hasEquals = isDefined && typeof value.equals === "function";
    const changed = !hasEquals || !value.equals(oldValue2);
    if (changed) {
      this._hasClone = hasClone;
      this._hasEquals = hasEquals;
      this._value = !hasClone ? value : value.clone(this._value);
      this._definitionChanged.raiseEvent(this);
    }
  }
};
ConstantProperty.prototype.equals = function(other) {
  return this === other || other instanceof ConstantProperty && (!this._hasEquals && this._value === other._value || this._hasEquals && this._value.equals(other._value));
};
ConstantProperty.prototype.valueOf = function() {
  return this._value;
};
ConstantProperty.prototype.toString = function() {
  return String(this._value);
};
var ConstantProperty_default = ConstantProperty;

// node_modules/cesium/Source/DataSources/createPropertyDescriptor.js
function createProperty(name, privateName, subscriptionName, configurable, createPropertyCallback) {
  return {
    configurable,
    get: function() {
      return this[privateName];
    },
    set: function(value) {
      const oldValue2 = this[privateName];
      const subscription = this[subscriptionName];
      if (defined_default(subscription)) {
        subscription();
        this[subscriptionName] = void 0;
      }
      const hasValue = value !== void 0;
      if (hasValue && (!defined_default(value) || !defined_default(value.getValue)) && defined_default(createPropertyCallback)) {
        value = createPropertyCallback(value);
      }
      if (oldValue2 !== value) {
        this[privateName] = value;
        this._definitionChanged.raiseEvent(this, name, value, oldValue2);
      }
      if (defined_default(value) && defined_default(value.definitionChanged)) {
        this[subscriptionName] = value.definitionChanged.addEventListener(
          function() {
            this._definitionChanged.raiseEvent(this, name, value, value);
          },
          this
        );
      }
    }
  };
}
function createConstantProperty(value) {
  return new ConstantProperty_default(value);
}
function createPropertyDescriptor(name, configurable, createPropertyCallback) {
  return createProperty(
    name,
    `_${name.toString()}`,
    `_${name.toString()}Subscription`,
    defaultValue_default(configurable, false),
    defaultValue_default(createPropertyCallback, createConstantProperty)
  );
}
var createPropertyDescriptor_default = createPropertyDescriptor;

// node_modules/cesium/Source/DataSources/BillboardGraphics.js
function BillboardGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._image = void 0;
  this._imageSubscription = void 0;
  this._scale = void 0;
  this._scaleSubscription = void 0;
  this._pixelOffset = void 0;
  this._pixelOffsetSubscription = void 0;
  this._eyeOffset = void 0;
  this._eyeOffsetSubscription = void 0;
  this._horizontalOrigin = void 0;
  this._horizontalOriginSubscription = void 0;
  this._verticalOrigin = void 0;
  this._verticalOriginSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._color = void 0;
  this._colorSubscription = void 0;
  this._rotation = void 0;
  this._rotationSubscription = void 0;
  this._alignedAxis = void 0;
  this._alignedAxisSubscription = void 0;
  this._sizeInMeters = void 0;
  this._sizeInMetersSubscription = void 0;
  this._width = void 0;
  this._widthSubscription = void 0;
  this._height = void 0;
  this._heightSubscription = void 0;
  this._scaleByDistance = void 0;
  this._scaleByDistanceSubscription = void 0;
  this._translucencyByDistance = void 0;
  this._translucencyByDistanceSubscription = void 0;
  this._pixelOffsetScaleByDistance = void 0;
  this._pixelOffsetScaleByDistanceSubscription = void 0;
  this._imageSubRegion = void 0;
  this._imageSubRegionSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this._disableDepthTestDistance = void 0;
  this._disableDepthTestDistanceSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(BillboardGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  image: createPropertyDescriptor_default("image"),
  scale: createPropertyDescriptor_default("scale"),
  pixelOffset: createPropertyDescriptor_default("pixelOffset"),
  eyeOffset: createPropertyDescriptor_default("eyeOffset"),
  horizontalOrigin: createPropertyDescriptor_default("horizontalOrigin"),
  verticalOrigin: createPropertyDescriptor_default("verticalOrigin"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  color: createPropertyDescriptor_default("color"),
  rotation: createPropertyDescriptor_default("rotation"),
  alignedAxis: createPropertyDescriptor_default("alignedAxis"),
  sizeInMeters: createPropertyDescriptor_default("sizeInMeters"),
  width: createPropertyDescriptor_default("width"),
  height: createPropertyDescriptor_default("height"),
  scaleByDistance: createPropertyDescriptor_default("scaleByDistance"),
  translucencyByDistance: createPropertyDescriptor_default("translucencyByDistance"),
  pixelOffsetScaleByDistance: createPropertyDescriptor_default(
    "pixelOffsetScaleByDistance"
  ),
  imageSubRegion: createPropertyDescriptor_default("imageSubRegion"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  ),
  disableDepthTestDistance: createPropertyDescriptor_default(
    "disableDepthTestDistance"
  )
});
BillboardGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new BillboardGraphics(this);
  }
  result.show = this._show;
  result.image = this._image;
  result.scale = this._scale;
  result.pixelOffset = this._pixelOffset;
  result.eyeOffset = this._eyeOffset;
  result.horizontalOrigin = this._horizontalOrigin;
  result.verticalOrigin = this._verticalOrigin;
  result.heightReference = this._heightReference;
  result.color = this._color;
  result.rotation = this._rotation;
  result.alignedAxis = this._alignedAxis;
  result.sizeInMeters = this._sizeInMeters;
  result.width = this._width;
  result.height = this._height;
  result.scaleByDistance = this._scaleByDistance;
  result.translucencyByDistance = this._translucencyByDistance;
  result.pixelOffsetScaleByDistance = this._pixelOffsetScaleByDistance;
  result.imageSubRegion = this._imageSubRegion;
  result.distanceDisplayCondition = this._distanceDisplayCondition;
  result.disableDepthTestDistance = this._disableDepthTestDistance;
  return result;
};
BillboardGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this._show, source.show);
  this.image = defaultValue_default(this._image, source.image);
  this.scale = defaultValue_default(this._scale, source.scale);
  this.pixelOffset = defaultValue_default(this._pixelOffset, source.pixelOffset);
  this.eyeOffset = defaultValue_default(this._eyeOffset, source.eyeOffset);
  this.horizontalOrigin = defaultValue_default(
    this._horizontalOrigin,
    source.horizontalOrigin
  );
  this.verticalOrigin = defaultValue_default(
    this._verticalOrigin,
    source.verticalOrigin
  );
  this.heightReference = defaultValue_default(
    this._heightReference,
    source.heightReference
  );
  this.color = defaultValue_default(this._color, source.color);
  this.rotation = defaultValue_default(this._rotation, source.rotation);
  this.alignedAxis = defaultValue_default(this._alignedAxis, source.alignedAxis);
  this.sizeInMeters = defaultValue_default(this._sizeInMeters, source.sizeInMeters);
  this.width = defaultValue_default(this._width, source.width);
  this.height = defaultValue_default(this._height, source.height);
  this.scaleByDistance = defaultValue_default(
    this._scaleByDistance,
    source.scaleByDistance
  );
  this.translucencyByDistance = defaultValue_default(
    this._translucencyByDistance,
    source.translucencyByDistance
  );
  this.pixelOffsetScaleByDistance = defaultValue_default(
    this._pixelOffsetScaleByDistance,
    source.pixelOffsetScaleByDistance
  );
  this.imageSubRegion = defaultValue_default(
    this._imageSubRegion,
    source.imageSubRegion
  );
  this.distanceDisplayCondition = defaultValue_default(
    this._distanceDisplayCondition,
    source.distanceDisplayCondition
  );
  this.disableDepthTestDistance = defaultValue_default(
    this._disableDepthTestDistance,
    source.disableDepthTestDistance
  );
};
var BillboardGraphics_default = BillboardGraphics;

// node_modules/cesium/Source/Scene/HeightReference.js
var HeightReference = {
  NONE: 0,
  CLAMP_TO_GROUND: 1,
  RELATIVE_TO_GROUND: 2
};
var HeightReference_default = Object.freeze(HeightReference);

// node_modules/cesium/Source/Scene/HorizontalOrigin.js
var HorizontalOrigin = {
  CENTER: 0,
  LEFT: 1,
  RIGHT: -1
};
var HorizontalOrigin_default = Object.freeze(HorizontalOrigin);

// node_modules/cesium/Source/Scene/VerticalOrigin.js
var VerticalOrigin = {
  CENTER: 0,
  BOTTOM: 1,
  BASELINE: 2,
  TOP: -1
};
var VerticalOrigin_default = Object.freeze(VerticalOrigin);

// node_modules/cesium/Source/DataSources/BoundingSphereState.js
var BoundingSphereState = {
  DONE: 0,
  PENDING: 1,
  FAILED: 2
};
var BoundingSphereState_default = Object.freeze(BoundingSphereState);

// node_modules/cesium/Source/DataSources/Property.js
function Property() {
  DeveloperError_default.throwInstantiationError();
}
Object.defineProperties(Property.prototype, {
  isConstant: {
    get: DeveloperError_default.throwInstantiationError
  },
  definitionChanged: {
    get: DeveloperError_default.throwInstantiationError
  }
});
Property.prototype.getValue = DeveloperError_default.throwInstantiationError;
Property.prototype.equals = DeveloperError_default.throwInstantiationError;
Property.equals = function(left, right) {
  return left === right || defined_default(left) && left.equals(right);
};
Property.arrayEquals = function(left, right) {
  if (left === right) {
    return true;
  }
  if (!defined_default(left) || !defined_default(right) || left.length !== right.length) {
    return false;
  }
  const length3 = left.length;
  for (let i2 = 0; i2 < length3; i2++) {
    if (!Property.equals(left[i2], right[i2])) {
      return false;
    }
  }
  return true;
};
Property.isConstant = function(property) {
  return !defined_default(property) || property.isConstant;
};
Property.getValueOrUndefined = function(property, time, result) {
  return defined_default(property) ? property.getValue(time, result) : void 0;
};
Property.getValueOrDefault = function(property, time, valueDefault, result) {
  return defined_default(property) ? defaultValue_default(property.getValue(time, result), valueDefault) : valueDefault;
};
Property.getValueOrClonedDefault = function(property, time, valueDefault, result) {
  let value;
  if (defined_default(property)) {
    value = property.getValue(time, result);
  }
  if (!defined_default(value)) {
    value = valueDefault.clone(value);
  }
  return value;
};
var Property_default = Property;

// node_modules/cesium/Source/DataSources/BillboardVisualizer.js
var defaultColor = Color_default.WHITE;
var defaultEyeOffset = Cartesian3_default.ZERO;
var defaultHeightReference = HeightReference_default.NONE;
var defaultPixelOffset = Cartesian2_default.ZERO;
var defaultScale2 = 1;
var defaultRotation2 = 0;
var defaultAlignedAxis = Cartesian3_default.ZERO;
var defaultHorizontalOrigin = HorizontalOrigin_default.CENTER;
var defaultVerticalOrigin = VerticalOrigin_default.CENTER;
var defaultSizeInMeters = false;
var positionScratch5 = new Cartesian3_default();
var colorScratch2 = new Color_default();
var eyeOffsetScratch = new Cartesian3_default();
var pixelOffsetScratch = new Cartesian2_default();
var scaleByDistanceScratch = new NearFarScalar_default();
var translucencyByDistanceScratch = new NearFarScalar_default();
var pixelOffsetScaleByDistanceScratch = new NearFarScalar_default();
var boundingRectangleScratch = new BoundingRectangle_default();
var distanceDisplayConditionScratch = new DistanceDisplayCondition_default();
function EntityData(entity) {
  this.entity = entity;
  this.billboard = void 0;
  this.textureValue = void 0;
}
function BillboardVisualizer(entityCluster, entityCollection) {
  if (!defined_default(entityCluster)) {
    throw new DeveloperError_default("entityCluster is required.");
  }
  if (!defined_default(entityCollection)) {
    throw new DeveloperError_default("entityCollection is required.");
  }
  entityCollection.collectionChanged.addEventListener(
    BillboardVisualizer.prototype._onCollectionChanged,
    this
  );
  this._cluster = entityCluster;
  this._entityCollection = entityCollection;
  this._items = new AssociativeArray_default();
  this._onCollectionChanged(entityCollection, entityCollection.values, [], []);
}
BillboardVisualizer.prototype.update = function(time) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  const items = this._items.values;
  const cluster = this._cluster;
  for (let i2 = 0, len = items.length; i2 < len; i2++) {
    const item = items[i2];
    const entity = item.entity;
    const billboardGraphics = entity._billboard;
    let textureValue;
    let billboard = item.billboard;
    let show = entity.isShowing && entity.isAvailable(time) && Property_default.getValueOrDefault(billboardGraphics._show, time, true);
    let position;
    if (show) {
      position = Property_default.getValueOrUndefined(
        entity._position,
        time,
        positionScratch5
      );
      textureValue = Property_default.getValueOrUndefined(
        billboardGraphics._image,
        time
      );
      show = defined_default(position) && defined_default(textureValue);
    }
    if (!show) {
      returnPrimitive(item, entity, cluster);
      continue;
    }
    if (!Property_default.isConstant(entity._position)) {
      cluster._clusterDirty = true;
    }
    if (!defined_default(billboard)) {
      billboard = cluster.getBillboard(entity);
      billboard.id = entity;
      billboard.image = void 0;
      item.billboard = billboard;
    }
    billboard.show = show;
    if (!defined_default(billboard.image) || item.textureValue !== textureValue) {
      billboard.image = textureValue;
      item.textureValue = textureValue;
    }
    billboard.position = position;
    billboard.color = Property_default.getValueOrDefault(
      billboardGraphics._color,
      time,
      defaultColor,
      colorScratch2
    );
    billboard.eyeOffset = Property_default.getValueOrDefault(
      billboardGraphics._eyeOffset,
      time,
      defaultEyeOffset,
      eyeOffsetScratch
    );
    billboard.heightReference = Property_default.getValueOrDefault(
      billboardGraphics._heightReference,
      time,
      defaultHeightReference
    );
    billboard.pixelOffset = Property_default.getValueOrDefault(
      billboardGraphics._pixelOffset,
      time,
      defaultPixelOffset,
      pixelOffsetScratch
    );
    billboard.scale = Property_default.getValueOrDefault(
      billboardGraphics._scale,
      time,
      defaultScale2
    );
    billboard.rotation = Property_default.getValueOrDefault(
      billboardGraphics._rotation,
      time,
      defaultRotation2
    );
    billboard.alignedAxis = Property_default.getValueOrDefault(
      billboardGraphics._alignedAxis,
      time,
      defaultAlignedAxis
    );
    billboard.horizontalOrigin = Property_default.getValueOrDefault(
      billboardGraphics._horizontalOrigin,
      time,
      defaultHorizontalOrigin
    );
    billboard.verticalOrigin = Property_default.getValueOrDefault(
      billboardGraphics._verticalOrigin,
      time,
      defaultVerticalOrigin
    );
    billboard.width = Property_default.getValueOrUndefined(
      billboardGraphics._width,
      time
    );
    billboard.height = Property_default.getValueOrUndefined(
      billboardGraphics._height,
      time
    );
    billboard.scaleByDistance = Property_default.getValueOrUndefined(
      billboardGraphics._scaleByDistance,
      time,
      scaleByDistanceScratch
    );
    billboard.translucencyByDistance = Property_default.getValueOrUndefined(
      billboardGraphics._translucencyByDistance,
      time,
      translucencyByDistanceScratch
    );
    billboard.pixelOffsetScaleByDistance = Property_default.getValueOrUndefined(
      billboardGraphics._pixelOffsetScaleByDistance,
      time,
      pixelOffsetScaleByDistanceScratch
    );
    billboard.sizeInMeters = Property_default.getValueOrDefault(
      billboardGraphics._sizeInMeters,
      time,
      defaultSizeInMeters
    );
    billboard.distanceDisplayCondition = Property_default.getValueOrUndefined(
      billboardGraphics._distanceDisplayCondition,
      time,
      distanceDisplayConditionScratch
    );
    billboard.disableDepthTestDistance = Property_default.getValueOrUndefined(
      billboardGraphics._disableDepthTestDistance,
      time
    );
    const subRegion = Property_default.getValueOrUndefined(
      billboardGraphics._imageSubRegion,
      time,
      boundingRectangleScratch
    );
    if (defined_default(subRegion)) {
      billboard.setImageSubRegion(billboard._imageId, subRegion);
    }
  }
  return true;
};
BillboardVisualizer.prototype.getBoundingSphere = function(entity, result) {
  if (!defined_default(entity)) {
    throw new DeveloperError_default("entity is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const item = this._items.get(entity.id);
  if (!defined_default(item) || !defined_default(item.billboard)) {
    return BoundingSphereState_default.FAILED;
  }
  const billboard = item.billboard;
  if (billboard.heightReference === HeightReference_default.NONE) {
    result.center = Cartesian3_default.clone(billboard.position, result.center);
  } else {
    if (!defined_default(billboard._clampedPosition)) {
      return BoundingSphereState_default.PENDING;
    }
    result.center = Cartesian3_default.clone(billboard._clampedPosition, result.center);
  }
  result.radius = 0;
  return BoundingSphereState_default.DONE;
};
BillboardVisualizer.prototype.isDestroyed = function() {
  return false;
};
BillboardVisualizer.prototype.destroy = function() {
  this._entityCollection.collectionChanged.removeEventListener(
    BillboardVisualizer.prototype._onCollectionChanged,
    this
  );
  const entities = this._entityCollection.values;
  for (let i2 = 0; i2 < entities.length; i2++) {
    this._cluster.removeBillboard(entities[i2]);
  }
  return destroyObject_default(this);
};
BillboardVisualizer.prototype._onCollectionChanged = function(entityCollection, added, removed, changed) {
  let i2;
  let entity;
  const items = this._items;
  const cluster = this._cluster;
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    if (defined_default(entity._billboard) && defined_default(entity._position)) {
      items.set(entity.id, new EntityData(entity));
    }
  }
  for (i2 = changed.length - 1; i2 > -1; i2--) {
    entity = changed[i2];
    if (defined_default(entity._billboard) && defined_default(entity._position)) {
      if (!items.contains(entity.id)) {
        items.set(entity.id, new EntityData(entity));
      }
    } else {
      returnPrimitive(items.get(entity.id), entity, cluster);
      items.remove(entity.id);
    }
  }
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    returnPrimitive(items.get(entity.id), entity, cluster);
    items.remove(entity.id);
  }
};
function returnPrimitive(item, entity, cluster) {
  if (defined_default(item)) {
    item.billboard = void 0;
    cluster.removeBillboard(entity);
  }
}
var BillboardVisualizer_default = BillboardVisualizer;

// node_modules/cesium/Source/Shaders/Appearances/AllMaterialAppearanceFS.js
var AllMaterialAppearanceFS_default = "varying vec3 v_positionEC;\nvarying vec3 v_normalEC;\nvarying vec3 v_tangentEC;\nvarying vec3 v_bitangentEC;\nvarying vec2 v_st;\n\nvoid main()\n{\n    vec3 positionToEyeEC = -v_positionEC;\n    mat3 tangentToEyeMatrix = czm_tangentToEyeSpaceMatrix(v_normalEC, v_tangentEC, v_bitangentEC);\n\n    vec3 normalEC = normalize(v_normalEC);\n#ifdef FACE_FORWARD\n    normalEC = faceforward(normalEC, vec3(0.0, 0.0, 1.0), -normalEC);\n#endif\n\n    czm_materialInput materialInput;\n    materialInput.normalEC = normalEC;\n    materialInput.tangentToEyeMatrix = tangentToEyeMatrix;\n    materialInput.positionToEyeEC = positionToEyeEC;\n    materialInput.st = v_st;\n    czm_material material = czm_getMaterial(materialInput);\n\n#ifdef FLAT\n    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n#else\n    gl_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n#endif\n}\n";

// node_modules/cesium/Source/Shaders/Appearances/AllMaterialAppearanceVS.js
var AllMaterialAppearanceVS_default = "attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute vec3 normal;\nattribute vec3 tangent;\nattribute vec3 bitangent;\nattribute vec2 st;\nattribute float batchId;\n\nvarying vec3 v_positionEC;\nvarying vec3 v_normalEC;\nvarying vec3 v_tangentEC;\nvarying vec3 v_bitangentEC;\nvarying vec2 v_st;\n\nvoid main()\n{\n    vec4 p = czm_computePosition();\n\n    v_positionEC = (czm_modelViewRelativeToEye * p).xyz;      // position in eye coordinates\n    v_normalEC = czm_normal * normal;                         // normal in eye coordinates\n    v_tangentEC = czm_normal * tangent;                       // tangent in eye coordinates\n    v_bitangentEC = czm_normal * bitangent;                   // bitangent in eye coordinates\n    v_st = st;\n\n    gl_Position = czm_modelViewProjectionRelativeToEye * p;\n}\n";

// node_modules/cesium/Source/Shaders/Appearances/BasicMaterialAppearanceFS.js
var BasicMaterialAppearanceFS_default = "varying vec3 v_positionEC;\nvarying vec3 v_normalEC;\n\nvoid main()\n{\n    vec3 positionToEyeEC = -v_positionEC;\n\n    vec3 normalEC = normalize(v_normalEC);\n#ifdef FACE_FORWARD\n    normalEC = faceforward(normalEC, vec3(0.0, 0.0, 1.0), -normalEC);\n#endif\n\n    czm_materialInput materialInput;\n    materialInput.normalEC = normalEC;\n    materialInput.positionToEyeEC = positionToEyeEC;\n    czm_material material = czm_getMaterial(materialInput);\n\n#ifdef FLAT\n    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n#else\n    gl_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n#endif\n}\n";

// node_modules/cesium/Source/Shaders/Appearances/BasicMaterialAppearanceVS.js
var BasicMaterialAppearanceVS_default = "attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute vec3 normal;\nattribute float batchId;\n\nvarying vec3 v_positionEC;\nvarying vec3 v_normalEC;\n\nvoid main()\n{\n    vec4 p = czm_computePosition();\n\n    v_positionEC = (czm_modelViewRelativeToEye * p).xyz;      // position in eye coordinates\n    v_normalEC = czm_normal * normal;                         // normal in eye coordinates\n\n    gl_Position = czm_modelViewProjectionRelativeToEye * p;\n}\n";

// node_modules/cesium/Source/Shaders/Appearances/TexturedMaterialAppearanceFS.js
var TexturedMaterialAppearanceFS_default = "varying vec3 v_positionEC;\nvarying vec3 v_normalEC;\nvarying vec2 v_st;\n\nvoid main()\n{\n    vec3 positionToEyeEC = -v_positionEC;\n\n    vec3 normalEC = normalize(v_normalEC);\n#ifdef FACE_FORWARD\n    normalEC = faceforward(normalEC, vec3(0.0, 0.0, 1.0), -normalEC);\n#endif\n\n    czm_materialInput materialInput;\n    materialInput.normalEC = normalEC;\n    materialInput.positionToEyeEC = positionToEyeEC;\n    materialInput.st = v_st;\n    czm_material material = czm_getMaterial(materialInput);\n\n#ifdef FLAT\n    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n#else\n    gl_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n#endif\n}\n";

// node_modules/cesium/Source/Shaders/Appearances/TexturedMaterialAppearanceVS.js
var TexturedMaterialAppearanceVS_default = "attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute vec3 normal;\nattribute vec2 st;\nattribute float batchId;\n\nvarying vec3 v_positionEC;\nvarying vec3 v_normalEC;\nvarying vec2 v_st;\n\nvoid main()\n{\n    vec4 p = czm_computePosition();\n\n    v_positionEC = (czm_modelViewRelativeToEye * p).xyz;      // position in eye coordinates\n    v_normalEC = czm_normal * normal;                         // normal in eye coordinates\n    v_st = st;\n\n    gl_Position = czm_modelViewProjectionRelativeToEye * p;\n}\n";

// node_modules/cesium/Source/Scene/BlendEquation.js
var BlendEquation = {
  ADD: WebGLConstants_default.FUNC_ADD,
  SUBTRACT: WebGLConstants_default.FUNC_SUBTRACT,
  REVERSE_SUBTRACT: WebGLConstants_default.FUNC_REVERSE_SUBTRACT,
  MIN: WebGLConstants_default.MIN,
  MAX: WebGLConstants_default.MAX
};
var BlendEquation_default = Object.freeze(BlendEquation);

// node_modules/cesium/Source/Scene/BlendFunction.js
var BlendFunction = {
  ZERO: WebGLConstants_default.ZERO,
  ONE: WebGLConstants_default.ONE,
  SOURCE_COLOR: WebGLConstants_default.SRC_COLOR,
  ONE_MINUS_SOURCE_COLOR: WebGLConstants_default.ONE_MINUS_SRC_COLOR,
  DESTINATION_COLOR: WebGLConstants_default.DST_COLOR,
  ONE_MINUS_DESTINATION_COLOR: WebGLConstants_default.ONE_MINUS_DST_COLOR,
  SOURCE_ALPHA: WebGLConstants_default.SRC_ALPHA,
  ONE_MINUS_SOURCE_ALPHA: WebGLConstants_default.ONE_MINUS_SRC_ALPHA,
  DESTINATION_ALPHA: WebGLConstants_default.DST_ALPHA,
  ONE_MINUS_DESTINATION_ALPHA: WebGLConstants_default.ONE_MINUS_DST_ALPHA,
  CONSTANT_COLOR: WebGLConstants_default.CONSTANT_COLOR,
  ONE_MINUS_CONSTANT_COLOR: WebGLConstants_default.ONE_MINUS_CONSTANT_COLOR,
  CONSTANT_ALPHA: WebGLConstants_default.CONSTANT_ALPHA,
  ONE_MINUS_CONSTANT_ALPHA: WebGLConstants_default.ONE_MINUS_CONSTANT_ALPHA,
  SOURCE_ALPHA_SATURATE: WebGLConstants_default.SRC_ALPHA_SATURATE
};
var BlendFunction_default = Object.freeze(BlendFunction);

// node_modules/cesium/Source/Scene/BlendingState.js
var BlendingState = {
  DISABLED: Object.freeze({
    enabled: false
  }),
  ALPHA_BLEND: Object.freeze({
    enabled: true,
    equationRgb: BlendEquation_default.ADD,
    equationAlpha: BlendEquation_default.ADD,
    functionSourceRgb: BlendFunction_default.SOURCE_ALPHA,
    functionSourceAlpha: BlendFunction_default.ONE,
    functionDestinationRgb: BlendFunction_default.ONE_MINUS_SOURCE_ALPHA,
    functionDestinationAlpha: BlendFunction_default.ONE_MINUS_SOURCE_ALPHA
  }),
  PRE_MULTIPLIED_ALPHA_BLEND: Object.freeze({
    enabled: true,
    equationRgb: BlendEquation_default.ADD,
    equationAlpha: BlendEquation_default.ADD,
    functionSourceRgb: BlendFunction_default.ONE,
    functionSourceAlpha: BlendFunction_default.ONE,
    functionDestinationRgb: BlendFunction_default.ONE_MINUS_SOURCE_ALPHA,
    functionDestinationAlpha: BlendFunction_default.ONE_MINUS_SOURCE_ALPHA
  }),
  ADDITIVE_BLEND: Object.freeze({
    enabled: true,
    equationRgb: BlendEquation_default.ADD,
    equationAlpha: BlendEquation_default.ADD,
    functionSourceRgb: BlendFunction_default.SOURCE_ALPHA,
    functionSourceAlpha: BlendFunction_default.ONE,
    functionDestinationRgb: BlendFunction_default.ONE,
    functionDestinationAlpha: BlendFunction_default.ONE
  })
};
var BlendingState_default = Object.freeze(BlendingState);

// node_modules/cesium/Source/Scene/CullFace.js
var CullFace = {
  FRONT: WebGLConstants_default.FRONT,
  BACK: WebGLConstants_default.BACK,
  FRONT_AND_BACK: WebGLConstants_default.FRONT_AND_BACK
};
var CullFace_default = Object.freeze(CullFace);

// node_modules/cesium/Source/Scene/Appearance.js
function Appearance(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.material = options.material;
  this.translucent = defaultValue_default(options.translucent, true);
  this._vertexShaderSource = options.vertexShaderSource;
  this._fragmentShaderSource = options.fragmentShaderSource;
  this._renderState = options.renderState;
  this._closed = defaultValue_default(options.closed, false);
}
Object.defineProperties(Appearance.prototype, {
  vertexShaderSource: {
    get: function() {
      return this._vertexShaderSource;
    }
  },
  fragmentShaderSource: {
    get: function() {
      return this._fragmentShaderSource;
    }
  },
  renderState: {
    get: function() {
      return this._renderState;
    }
  },
  closed: {
    get: function() {
      return this._closed;
    }
  }
});
Appearance.prototype.getFragmentShaderSource = function() {
  const parts = [];
  if (this.flat) {
    parts.push("#define FLAT");
  }
  if (this.faceForward) {
    parts.push("#define FACE_FORWARD");
  }
  if (defined_default(this.material)) {
    parts.push(this.material.shaderSource);
  }
  parts.push(this.fragmentShaderSource);
  return parts.join("\n");
};
Appearance.prototype.isTranslucent = function() {
  return defined_default(this.material) && this.material.isTranslucent() || !defined_default(this.material) && this.translucent;
};
Appearance.prototype.getRenderState = function() {
  const translucent = this.isTranslucent();
  const rs = clone_default(this.renderState, false);
  if (translucent) {
    rs.depthMask = false;
    rs.blending = BlendingState_default.ALPHA_BLEND;
  } else {
    rs.depthMask = true;
  }
  return rs;
};
Appearance.getDefaultRenderState = function(translucent, closed, existing) {
  let rs = {
    depthTest: {
      enabled: true
    }
  };
  if (translucent) {
    rs.depthMask = false;
    rs.blending = BlendingState_default.ALPHA_BLEND;
  }
  if (closed) {
    rs.cull = {
      enabled: true,
      face: CullFace_default.BACK
    };
  }
  if (defined_default(existing)) {
    rs = combine_default(existing, rs, true);
  }
  return rs;
};
var Appearance_default = Appearance;

// node_modules/cesium/Source/Renderer/ContextLimits.js
var ContextLimits = {
  _maximumCombinedTextureImageUnits: 0,
  _maximumCubeMapSize: 0,
  _maximumFragmentUniformVectors: 0,
  _maximumTextureImageUnits: 0,
  _maximumRenderbufferSize: 0,
  _maximumTextureSize: 0,
  _maximumVaryingVectors: 0,
  _maximumVertexAttributes: 0,
  _maximumVertexTextureImageUnits: 0,
  _maximumVertexUniformVectors: 0,
  _minimumAliasedLineWidth: 0,
  _maximumAliasedLineWidth: 0,
  _minimumAliasedPointSize: 0,
  _maximumAliasedPointSize: 0,
  _maximumViewportWidth: 0,
  _maximumViewportHeight: 0,
  _maximumTextureFilterAnisotropy: 0,
  _maximumDrawBuffers: 0,
  _maximumColorAttachments: 0,
  _maximumSamples: 0,
  _highpFloatSupported: false,
  _highpIntSupported: false
};
Object.defineProperties(ContextLimits, {
  maximumCombinedTextureImageUnits: {
    get: function() {
      return ContextLimits._maximumCombinedTextureImageUnits;
    }
  },
  maximumCubeMapSize: {
    get: function() {
      return ContextLimits._maximumCubeMapSize;
    }
  },
  maximumFragmentUniformVectors: {
    get: function() {
      return ContextLimits._maximumFragmentUniformVectors;
    }
  },
  maximumTextureImageUnits: {
    get: function() {
      return ContextLimits._maximumTextureImageUnits;
    }
  },
  maximumRenderbufferSize: {
    get: function() {
      return ContextLimits._maximumRenderbufferSize;
    }
  },
  maximumTextureSize: {
    get: function() {
      return ContextLimits._maximumTextureSize;
    }
  },
  maximumVaryingVectors: {
    get: function() {
      return ContextLimits._maximumVaryingVectors;
    }
  },
  maximumVertexAttributes: {
    get: function() {
      return ContextLimits._maximumVertexAttributes;
    }
  },
  maximumVertexTextureImageUnits: {
    get: function() {
      return ContextLimits._maximumVertexTextureImageUnits;
    }
  },
  maximumVertexUniformVectors: {
    get: function() {
      return ContextLimits._maximumVertexUniformVectors;
    }
  },
  minimumAliasedLineWidth: {
    get: function() {
      return ContextLimits._minimumAliasedLineWidth;
    }
  },
  maximumAliasedLineWidth: {
    get: function() {
      return ContextLimits._maximumAliasedLineWidth;
    }
  },
  minimumAliasedPointSize: {
    get: function() {
      return ContextLimits._minimumAliasedPointSize;
    }
  },
  maximumAliasedPointSize: {
    get: function() {
      return ContextLimits._maximumAliasedPointSize;
    }
  },
  maximumViewportWidth: {
    get: function() {
      return ContextLimits._maximumViewportWidth;
    }
  },
  maximumViewportHeight: {
    get: function() {
      return ContextLimits._maximumViewportHeight;
    }
  },
  maximumTextureFilterAnisotropy: {
    get: function() {
      return ContextLimits._maximumTextureFilterAnisotropy;
    }
  },
  maximumDrawBuffers: {
    get: function() {
      return ContextLimits._maximumDrawBuffers;
    }
  },
  maximumColorAttachments: {
    get: function() {
      return ContextLimits._maximumColorAttachments;
    }
  },
  maximumSamples: {
    get: function() {
      return ContextLimits._maximumSamples;
    }
  },
  highpFloatSupported: {
    get: function() {
      return ContextLimits._highpFloatSupported;
    }
  },
  highpIntSupported: {
    get: function() {
      return ContextLimits._highpIntSupported;
    }
  }
});
var ContextLimits_default = ContextLimits;

// node_modules/cesium/Source/Renderer/CubeMapFace.js
function CubeMapFace(context, texture, textureTarget, targetFace, internalFormat, pixelFormat, pixelDatatype, size, preMultiplyAlpha, flipY, initialized) {
  this._context = context;
  this._texture = texture;
  this._textureTarget = textureTarget;
  this._targetFace = targetFace;
  this._pixelDatatype = pixelDatatype;
  this._internalFormat = internalFormat;
  this._pixelFormat = pixelFormat;
  this._size = size;
  this._preMultiplyAlpha = preMultiplyAlpha;
  this._flipY = flipY;
  this._initialized = initialized;
}
Object.defineProperties(CubeMapFace.prototype, {
  pixelFormat: {
    get: function() {
      return this._pixelFormat;
    }
  },
  pixelDatatype: {
    get: function() {
      return this._pixelDatatype;
    }
  },
  _target: {
    get: function() {
      return this._targetFace;
    }
  }
});
CubeMapFace.prototype.copyFrom = function(options) {
  Check_default.defined("options", options);
  const xOffset = defaultValue_default(options.xOffset, 0);
  const yOffset = defaultValue_default(options.yOffset, 0);
  Check_default.defined("options.source", options.source);
  Check_default.typeOf.number.greaterThanOrEquals("xOffset", xOffset, 0);
  Check_default.typeOf.number.greaterThanOrEquals("yOffset", yOffset, 0);
  if (xOffset + options.source.width > this._size) {
    throw new DeveloperError_default(
      "xOffset + options.source.width must be less than or equal to width."
    );
  }
  if (yOffset + options.source.height > this._size) {
    throw new DeveloperError_default(
      "yOffset + options.source.height must be less than or equal to height."
    );
  }
  const source = options.source;
  const gl = this._context._gl;
  const target = this._textureTarget;
  const targetFace = this._targetFace;
  gl.activeTexture(gl.TEXTURE0);
  gl.bindTexture(target, this._texture);
  const width = source.width;
  const height = source.height;
  let arrayBufferView = source.arrayBufferView;
  const size = this._size;
  const pixelFormat = this._pixelFormat;
  const internalFormat = this._internalFormat;
  const pixelDatatype = this._pixelDatatype;
  const preMultiplyAlpha = this._preMultiplyAlpha;
  const flipY = this._flipY;
  const skipColorSpaceConversion = defaultValue_default(
    options.skipColorSpaceConversion,
    false
  );
  let unpackAlignment = 4;
  if (defined_default(arrayBufferView)) {
    unpackAlignment = PixelFormat_default.alignmentInBytes(
      pixelFormat,
      pixelDatatype,
      width
    );
  }
  gl.pixelStorei(gl.UNPACK_ALIGNMENT, unpackAlignment);
  if (skipColorSpaceConversion) {
    gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
  } else {
    gl.pixelStorei(
      gl.UNPACK_COLORSPACE_CONVERSION_WEBGL,
      gl.BROWSER_DEFAULT_WEBGL
    );
  }
  let uploaded = false;
  if (!this._initialized) {
    if (xOffset === 0 && yOffset === 0 && width === size && height === size) {
      if (defined_default(arrayBufferView)) {
        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
        if (flipY) {
          arrayBufferView = PixelFormat_default.flipY(
            arrayBufferView,
            pixelFormat,
            pixelDatatype,
            size,
            size
          );
        }
        gl.texImage2D(
          targetFace,
          0,
          internalFormat,
          size,
          size,
          0,
          pixelFormat,
          PixelDatatype_default.toWebGLConstant(pixelDatatype, this._context),
          arrayBufferView
        );
      } else {
        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
        gl.texImage2D(
          targetFace,
          0,
          internalFormat,
          pixelFormat,
          PixelDatatype_default.toWebGLConstant(pixelDatatype, this._context),
          source
        );
      }
      uploaded = true;
    } else {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
      const bufferView = PixelFormat_default.createTypedArray(
        pixelFormat,
        pixelDatatype,
        size,
        size
      );
      gl.texImage2D(
        targetFace,
        0,
        internalFormat,
        size,
        size,
        0,
        pixelFormat,
        PixelDatatype_default.toWebGLConstant(pixelDatatype, this._context),
        bufferView
      );
    }
    this._initialized = true;
  }
  if (!uploaded) {
    if (defined_default(arrayBufferView)) {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
      if (flipY) {
        arrayBufferView = PixelFormat_default.flipY(
          arrayBufferView,
          pixelFormat,
          pixelDatatype,
          width,
          height
        );
      }
      gl.texSubImage2D(
        targetFace,
        0,
        xOffset,
        yOffset,
        width,
        height,
        pixelFormat,
        PixelDatatype_default.toWebGLConstant(pixelDatatype, this._context),
        arrayBufferView
      );
    } else {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
      gl.texSubImage2D(
        targetFace,
        0,
        xOffset,
        yOffset,
        pixelFormat,
        PixelDatatype_default.toWebGLConstant(pixelDatatype, this._context),
        source
      );
    }
  }
  gl.bindTexture(target, null);
};
CubeMapFace.prototype.copyFromFramebuffer = function(xOffset, yOffset, framebufferXOffset, framebufferYOffset, width, height) {
  xOffset = defaultValue_default(xOffset, 0);
  yOffset = defaultValue_default(yOffset, 0);
  framebufferXOffset = defaultValue_default(framebufferXOffset, 0);
  framebufferYOffset = defaultValue_default(framebufferYOffset, 0);
  width = defaultValue_default(width, this._size);
  height = defaultValue_default(height, this._size);
  Check_default.typeOf.number.greaterThanOrEquals("xOffset", xOffset, 0);
  Check_default.typeOf.number.greaterThanOrEquals("yOffset", yOffset, 0);
  Check_default.typeOf.number.greaterThanOrEquals(
    "framebufferXOffset",
    framebufferXOffset,
    0
  );
  Check_default.typeOf.number.greaterThanOrEquals(
    "framebufferYOffset",
    framebufferYOffset,
    0
  );
  if (xOffset + width > this._size) {
    throw new DeveloperError_default(
      "xOffset + source.width must be less than or equal to width."
    );
  }
  if (yOffset + height > this._size) {
    throw new DeveloperError_default(
      "yOffset + source.height must be less than or equal to height."
    );
  }
  if (this._pixelDatatype === PixelDatatype_default.FLOAT) {
    throw new DeveloperError_default(
      "Cannot call copyFromFramebuffer when the texture pixel data type is FLOAT."
    );
  }
  if (this._pixelDatatype === PixelDatatype_default.HALF_FLOAT) {
    throw new DeveloperError_default(
      "Cannot call copyFromFramebuffer when the texture pixel data type is HALF_FLOAT."
    );
  }
  const gl = this._context._gl;
  const target = this._textureTarget;
  gl.activeTexture(gl.TEXTURE0);
  gl.bindTexture(target, this._texture);
  gl.copyTexSubImage2D(
    this._targetFace,
    0,
    xOffset,
    yOffset,
    framebufferXOffset,
    framebufferYOffset,
    width,
    height
  );
  gl.bindTexture(target, null);
  this._initialized = true;
};
var CubeMapFace_default = CubeMapFace;

// node_modules/cesium/Source/Renderer/MipmapHint.js
var MipmapHint = {
  DONT_CARE: WebGLConstants_default.DONT_CARE,
  FASTEST: WebGLConstants_default.FASTEST,
  NICEST: WebGLConstants_default.NICEST,
  validate: function(mipmapHint) {
    return mipmapHint === MipmapHint.DONT_CARE || mipmapHint === MipmapHint.FASTEST || mipmapHint === MipmapHint.NICEST;
  }
};
var MipmapHint_default = Object.freeze(MipmapHint);

// node_modules/cesium/Source/Renderer/TextureMagnificationFilter.js
var TextureMagnificationFilter = {
  NEAREST: WebGLConstants_default.NEAREST,
  LINEAR: WebGLConstants_default.LINEAR
};
TextureMagnificationFilter.validate = function(textureMagnificationFilter) {
  return textureMagnificationFilter === TextureMagnificationFilter.NEAREST || textureMagnificationFilter === TextureMagnificationFilter.LINEAR;
};
var TextureMagnificationFilter_default = Object.freeze(TextureMagnificationFilter);

// node_modules/cesium/Source/Renderer/TextureMinificationFilter.js
var TextureMinificationFilter = {
  NEAREST: WebGLConstants_default.NEAREST,
  LINEAR: WebGLConstants_default.LINEAR,
  NEAREST_MIPMAP_NEAREST: WebGLConstants_default.NEAREST_MIPMAP_NEAREST,
  LINEAR_MIPMAP_NEAREST: WebGLConstants_default.LINEAR_MIPMAP_NEAREST,
  NEAREST_MIPMAP_LINEAR: WebGLConstants_default.NEAREST_MIPMAP_LINEAR,
  LINEAR_MIPMAP_LINEAR: WebGLConstants_default.LINEAR_MIPMAP_LINEAR
};
TextureMinificationFilter.validate = function(textureMinificationFilter) {
  return textureMinificationFilter === TextureMinificationFilter.NEAREST || textureMinificationFilter === TextureMinificationFilter.LINEAR || textureMinificationFilter === TextureMinificationFilter.NEAREST_MIPMAP_NEAREST || textureMinificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_NEAREST || textureMinificationFilter === TextureMinificationFilter.NEAREST_MIPMAP_LINEAR || textureMinificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
};
var TextureMinificationFilter_default = Object.freeze(TextureMinificationFilter);

// node_modules/cesium/Source/Renderer/TextureWrap.js
var TextureWrap = {
  CLAMP_TO_EDGE: WebGLConstants_default.CLAMP_TO_EDGE,
  REPEAT: WebGLConstants_default.REPEAT,
  MIRRORED_REPEAT: WebGLConstants_default.MIRRORED_REPEAT,
  validate: function(textureWrap) {
    return textureWrap === TextureWrap.CLAMP_TO_EDGE || textureWrap === TextureWrap.REPEAT || textureWrap === TextureWrap.MIRRORED_REPEAT;
  }
};
var TextureWrap_default = Object.freeze(TextureWrap);

// node_modules/cesium/Source/Renderer/Sampler.js
function Sampler(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const wrapS = defaultValue_default(options.wrapS, TextureWrap_default.CLAMP_TO_EDGE);
  const wrapT = defaultValue_default(options.wrapT, TextureWrap_default.CLAMP_TO_EDGE);
  const minificationFilter = defaultValue_default(
    options.minificationFilter,
    TextureMinificationFilter_default.LINEAR
  );
  const magnificationFilter = defaultValue_default(
    options.magnificationFilter,
    TextureMagnificationFilter_default.LINEAR
  );
  const maximumAnisotropy = defined_default(options.maximumAnisotropy) ? options.maximumAnisotropy : 1;
  if (!TextureWrap_default.validate(wrapS)) {
    throw new DeveloperError_default("Invalid sampler.wrapS.");
  }
  if (!TextureWrap_default.validate(wrapT)) {
    throw new DeveloperError_default("Invalid sampler.wrapT.");
  }
  if (!TextureMinificationFilter_default.validate(minificationFilter)) {
    throw new DeveloperError_default("Invalid sampler.minificationFilter.");
  }
  if (!TextureMagnificationFilter_default.validate(magnificationFilter)) {
    throw new DeveloperError_default("Invalid sampler.magnificationFilter.");
  }
  Check_default.typeOf.number.greaterThanOrEquals(
    "maximumAnisotropy",
    maximumAnisotropy,
    1
  );
  this._wrapS = wrapS;
  this._wrapT = wrapT;
  this._minificationFilter = minificationFilter;
  this._magnificationFilter = magnificationFilter;
  this._maximumAnisotropy = maximumAnisotropy;
}
Object.defineProperties(Sampler.prototype, {
  wrapS: {
    get: function() {
      return this._wrapS;
    }
  },
  wrapT: {
    get: function() {
      return this._wrapT;
    }
  },
  minificationFilter: {
    get: function() {
      return this._minificationFilter;
    }
  },
  magnificationFilter: {
    get: function() {
      return this._magnificationFilter;
    }
  },
  maximumAnisotropy: {
    get: function() {
      return this._maximumAnisotropy;
    }
  }
});
Sampler.equals = function(left, right) {
  return left === right || defined_default(left) && defined_default(right) && left._wrapS === right._wrapS && left._wrapT === right._wrapT && left._minificationFilter === right._minificationFilter && left._magnificationFilter === right._magnificationFilter && left._maximumAnisotropy === right._maximumAnisotropy;
};
Sampler.NEAREST = Object.freeze(
  new Sampler({
    wrapS: TextureWrap_default.CLAMP_TO_EDGE,
    wrapT: TextureWrap_default.CLAMP_TO_EDGE,
    minificationFilter: TextureMinificationFilter_default.NEAREST,
    magnificationFilter: TextureMagnificationFilter_default.NEAREST
  })
);
var Sampler_default = Sampler;

// node_modules/cesium/Source/Renderer/CubeMap.js
function CubeMap(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.context", options.context);
  const context = options.context;
  const source = options.source;
  let width;
  let height;
  if (defined_default(source)) {
    const faces2 = [
      source.positiveX,
      source.negativeX,
      source.positiveY,
      source.negativeY,
      source.positiveZ,
      source.negativeZ
    ];
    if (!faces2[0] || !faces2[1] || !faces2[2] || !faces2[3] || !faces2[4] || !faces2[5]) {
      throw new DeveloperError_default(
        "options.source requires positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ faces."
      );
    }
    width = faces2[0].width;
    height = faces2[0].height;
    for (let i2 = 1; i2 < 6; ++i2) {
      if (Number(faces2[i2].width) !== width || Number(faces2[i2].height) !== height) {
        throw new DeveloperError_default(
          "Each face in options.source must have the same width and height."
        );
      }
    }
  } else {
    width = options.width;
    height = options.height;
  }
  const size = width;
  const pixelDatatype = defaultValue_default(
    options.pixelDatatype,
    PixelDatatype_default.UNSIGNED_BYTE
  );
  const pixelFormat = defaultValue_default(options.pixelFormat, PixelFormat_default.RGBA);
  const internalFormat = PixelFormat_default.toInternalFormat(
    pixelFormat,
    pixelDatatype,
    context
  );
  if (!defined_default(width) || !defined_default(height)) {
    throw new DeveloperError_default(
      "options requires a source field to create an initialized cube map or width and height fields to create a blank cube map."
    );
  }
  if (width !== height) {
    throw new DeveloperError_default("Width must equal height.");
  }
  if (size <= 0) {
    throw new DeveloperError_default("Width and height must be greater than zero.");
  }
  if (size > ContextLimits_default.maximumCubeMapSize) {
    throw new DeveloperError_default(
      `Width and height must be less than or equal to the maximum cube map size (${ContextLimits_default.maximumCubeMapSize}).  Check maximumCubeMapSize.`
    );
  }
  if (!PixelFormat_default.validate(pixelFormat)) {
    throw new DeveloperError_default("Invalid options.pixelFormat.");
  }
  if (PixelFormat_default.isDepthFormat(pixelFormat)) {
    throw new DeveloperError_default(
      "options.pixelFormat cannot be DEPTH_COMPONENT or DEPTH_STENCIL."
    );
  }
  if (!PixelDatatype_default.validate(pixelDatatype)) {
    throw new DeveloperError_default("Invalid options.pixelDatatype.");
  }
  if (pixelDatatype === PixelDatatype_default.FLOAT && !context.floatingPointTexture) {
    throw new DeveloperError_default(
      "When options.pixelDatatype is FLOAT, this WebGL implementation must support the OES_texture_float extension."
    );
  }
  if (pixelDatatype === PixelDatatype_default.HALF_FLOAT && !context.halfFloatingPointTexture) {
    throw new DeveloperError_default(
      "When options.pixelDatatype is HALF_FLOAT, this WebGL implementation must support the OES_texture_half_float extension."
    );
  }
  const sizeInBytes = PixelFormat_default.textureSizeInBytes(pixelFormat, pixelDatatype, size, size) * 6;
  const preMultiplyAlpha = options.preMultiplyAlpha || pixelFormat === PixelFormat_default.RGB || pixelFormat === PixelFormat_default.LUMINANCE;
  const flipY = defaultValue_default(options.flipY, true);
  const skipColorSpaceConversion = defaultValue_default(
    options.skipColorSpaceConversion,
    false
  );
  const gl = context._gl;
  const textureTarget = gl.TEXTURE_CUBE_MAP;
  const texture = gl.createTexture();
  gl.activeTexture(gl.TEXTURE0);
  gl.bindTexture(textureTarget, texture);
  function createFace(target, sourceFace, preMultiplyAlpha2, flipY2, skipColorSpaceConversion2) {
    let arrayBufferView = sourceFace.arrayBufferView;
    if (!defined_default(arrayBufferView)) {
      arrayBufferView = sourceFace.bufferView;
    }
    let unpackAlignment = 4;
    if (defined_default(arrayBufferView)) {
      unpackAlignment = PixelFormat_default.alignmentInBytes(
        pixelFormat,
        pixelDatatype,
        width
      );
    }
    gl.pixelStorei(gl.UNPACK_ALIGNMENT, unpackAlignment);
    if (skipColorSpaceConversion2) {
      gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
    } else {
      gl.pixelStorei(
        gl.UNPACK_COLORSPACE_CONVERSION_WEBGL,
        gl.BROWSER_DEFAULT_WEBGL
      );
    }
    if (defined_default(arrayBufferView)) {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
      if (flipY2) {
        arrayBufferView = PixelFormat_default.flipY(
          arrayBufferView,
          pixelFormat,
          pixelDatatype,
          size,
          size
        );
      }
      gl.texImage2D(
        target,
        0,
        internalFormat,
        size,
        size,
        0,
        pixelFormat,
        PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
        arrayBufferView
      );
    } else {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha2);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY2);
      gl.texImage2D(
        target,
        0,
        internalFormat,
        pixelFormat,
        PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
        sourceFace
      );
    }
  }
  if (defined_default(source)) {
    createFace(
      gl.TEXTURE_CUBE_MAP_POSITIVE_X,
      source.positiveX,
      preMultiplyAlpha,
      flipY,
      skipColorSpaceConversion
    );
    createFace(
      gl.TEXTURE_CUBE_MAP_NEGATIVE_X,
      source.negativeX,
      preMultiplyAlpha,
      flipY,
      skipColorSpaceConversion
    );
    createFace(
      gl.TEXTURE_CUBE_MAP_POSITIVE_Y,
      source.positiveY,
      preMultiplyAlpha,
      flipY,
      skipColorSpaceConversion
    );
    createFace(
      gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,
      source.negativeY,
      preMultiplyAlpha,
      flipY,
      skipColorSpaceConversion
    );
    createFace(
      gl.TEXTURE_CUBE_MAP_POSITIVE_Z,
      source.positiveZ,
      preMultiplyAlpha,
      flipY,
      skipColorSpaceConversion
    );
    createFace(
      gl.TEXTURE_CUBE_MAP_NEGATIVE_Z,
      source.negativeZ,
      preMultiplyAlpha,
      flipY,
      skipColorSpaceConversion
    );
  } else {
    gl.texImage2D(
      gl.TEXTURE_CUBE_MAP_POSITIVE_X,
      0,
      internalFormat,
      size,
      size,
      0,
      pixelFormat,
      PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
      null
    );
    gl.texImage2D(
      gl.TEXTURE_CUBE_MAP_NEGATIVE_X,
      0,
      internalFormat,
      size,
      size,
      0,
      pixelFormat,
      PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
      null
    );
    gl.texImage2D(
      gl.TEXTURE_CUBE_MAP_POSITIVE_Y,
      0,
      internalFormat,
      size,
      size,
      0,
      pixelFormat,
      PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
      null
    );
    gl.texImage2D(
      gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,
      0,
      internalFormat,
      size,
      size,
      0,
      pixelFormat,
      PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
      null
    );
    gl.texImage2D(
      gl.TEXTURE_CUBE_MAP_POSITIVE_Z,
      0,
      internalFormat,
      size,
      size,
      0,
      pixelFormat,
      PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
      null
    );
    gl.texImage2D(
      gl.TEXTURE_CUBE_MAP_NEGATIVE_Z,
      0,
      internalFormat,
      size,
      size,
      0,
      pixelFormat,
      PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
      null
    );
  }
  gl.bindTexture(textureTarget, null);
  this._context = context;
  this._textureFilterAnisotropic = context._textureFilterAnisotropic;
  this._textureTarget = textureTarget;
  this._texture = texture;
  this._pixelFormat = pixelFormat;
  this._pixelDatatype = pixelDatatype;
  this._size = size;
  this._hasMipmap = false;
  this._sizeInBytes = sizeInBytes;
  this._preMultiplyAlpha = preMultiplyAlpha;
  this._flipY = flipY;
  this._sampler = void 0;
  const initialized = defined_default(source);
  this._positiveX = new CubeMapFace_default(
    context,
    texture,
    textureTarget,
    gl.TEXTURE_CUBE_MAP_POSITIVE_X,
    internalFormat,
    pixelFormat,
    pixelDatatype,
    size,
    preMultiplyAlpha,
    flipY,
    initialized
  );
  this._negativeX = new CubeMapFace_default(
    context,
    texture,
    textureTarget,
    gl.TEXTURE_CUBE_MAP_NEGATIVE_X,
    internalFormat,
    pixelFormat,
    pixelDatatype,
    size,
    preMultiplyAlpha,
    flipY,
    initialized
  );
  this._positiveY = new CubeMapFace_default(
    context,
    texture,
    textureTarget,
    gl.TEXTURE_CUBE_MAP_POSITIVE_Y,
    internalFormat,
    pixelFormat,
    pixelDatatype,
    size,
    preMultiplyAlpha,
    flipY,
    initialized
  );
  this._negativeY = new CubeMapFace_default(
    context,
    texture,
    textureTarget,
    gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,
    internalFormat,
    pixelFormat,
    pixelDatatype,
    size,
    preMultiplyAlpha,
    flipY,
    initialized
  );
  this._positiveZ = new CubeMapFace_default(
    context,
    texture,
    textureTarget,
    gl.TEXTURE_CUBE_MAP_POSITIVE_Z,
    internalFormat,
    pixelFormat,
    pixelDatatype,
    size,
    preMultiplyAlpha,
    flipY,
    initialized
  );
  this._negativeZ = new CubeMapFace_default(
    context,
    texture,
    textureTarget,
    gl.TEXTURE_CUBE_MAP_NEGATIVE_Z,
    internalFormat,
    pixelFormat,
    pixelDatatype,
    size,
    preMultiplyAlpha,
    flipY,
    initialized
  );
  this.sampler = defined_default(options.sampler) ? options.sampler : new Sampler_default();
}
Object.defineProperties(CubeMap.prototype, {
  positiveX: {
    get: function() {
      return this._positiveX;
    }
  },
  negativeX: {
    get: function() {
      return this._negativeX;
    }
  },
  positiveY: {
    get: function() {
      return this._positiveY;
    }
  },
  negativeY: {
    get: function() {
      return this._negativeY;
    }
  },
  positiveZ: {
    get: function() {
      return this._positiveZ;
    }
  },
  negativeZ: {
    get: function() {
      return this._negativeZ;
    }
  },
  sampler: {
    get: function() {
      return this._sampler;
    },
    set: function(sampler) {
      let minificationFilter = sampler.minificationFilter;
      let magnificationFilter = sampler.magnificationFilter;
      const mipmap = minificationFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_NEAREST || minificationFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_LINEAR || minificationFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_NEAREST || minificationFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_LINEAR;
      const context = this._context;
      const pixelDatatype = this._pixelDatatype;
      if (pixelDatatype === PixelDatatype_default.FLOAT && !context.textureFloatLinear || pixelDatatype === PixelDatatype_default.HALF_FLOAT && !context.textureHalfFloatLinear) {
        minificationFilter = mipmap ? TextureMinificationFilter_default.NEAREST_MIPMAP_NEAREST : TextureMinificationFilter_default.NEAREST;
        magnificationFilter = TextureMagnificationFilter_default.NEAREST;
      }
      const gl = context._gl;
      const target = this._textureTarget;
      gl.activeTexture(gl.TEXTURE0);
      gl.bindTexture(target, this._texture);
      gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, minificationFilter);
      gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, magnificationFilter);
      gl.texParameteri(target, gl.TEXTURE_WRAP_S, sampler.wrapS);
      gl.texParameteri(target, gl.TEXTURE_WRAP_T, sampler.wrapT);
      if (defined_default(this._textureFilterAnisotropic)) {
        gl.texParameteri(
          target,
          this._textureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT,
          sampler.maximumAnisotropy
        );
      }
      gl.bindTexture(target, null);
      this._sampler = sampler;
    }
  },
  pixelFormat: {
    get: function() {
      return this._pixelFormat;
    }
  },
  pixelDatatype: {
    get: function() {
      return this._pixelDatatype;
    }
  },
  width: {
    get: function() {
      return this._size;
    }
  },
  height: {
    get: function() {
      return this._size;
    }
  },
  sizeInBytes: {
    get: function() {
      if (this._hasMipmap) {
        return Math.floor(this._sizeInBytes * 4 / 3);
      }
      return this._sizeInBytes;
    }
  },
  preMultiplyAlpha: {
    get: function() {
      return this._preMultiplyAlpha;
    }
  },
  flipY: {
    get: function() {
      return this._flipY;
    }
  },
  _target: {
    get: function() {
      return this._textureTarget;
    }
  }
});
CubeMap.prototype.generateMipmap = function(hint) {
  hint = defaultValue_default(hint, MipmapHint_default.DONT_CARE);
  if (this._size > 1 && !Math_default.isPowerOfTwo(this._size)) {
    throw new DeveloperError_default(
      "width and height must be a power of two to call generateMipmap()."
    );
  }
  if (!MipmapHint_default.validate(hint)) {
    throw new DeveloperError_default("hint is invalid.");
  }
  this._hasMipmap = true;
  const gl = this._context._gl;
  const target = this._textureTarget;
  gl.hint(gl.GENERATE_MIPMAP_HINT, hint);
  gl.activeTexture(gl.TEXTURE0);
  gl.bindTexture(target, this._texture);
  gl.generateMipmap(target);
  gl.bindTexture(target, null);
};
CubeMap.prototype.isDestroyed = function() {
  return false;
};
CubeMap.prototype.destroy = function() {
  this._context._gl.deleteTexture(this._texture);
  this._positiveX = destroyObject_default(this._positiveX);
  this._negativeX = destroyObject_default(this._negativeX);
  this._positiveY = destroyObject_default(this._positiveY);
  this._negativeY = destroyObject_default(this._negativeY);
  this._positiveZ = destroyObject_default(this._positiveZ);
  this._negativeZ = destroyObject_default(this._negativeZ);
  return destroyObject_default(this);
};
var CubeMap_default = CubeMap;

// node_modules/cesium/Source/Renderer/Texture.js
function Texture(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.context", options.context);
  const context = options.context;
  let width = options.width;
  let height = options.height;
  const source = options.source;
  if (defined_default(source)) {
    if (!defined_default(width)) {
      width = defaultValue_default(source.videoWidth, source.width);
    }
    if (!defined_default(height)) {
      height = defaultValue_default(source.videoHeight, source.height);
    }
  }
  const pixelFormat = defaultValue_default(options.pixelFormat, PixelFormat_default.RGBA);
  const pixelDatatype = defaultValue_default(
    options.pixelDatatype,
    PixelDatatype_default.UNSIGNED_BYTE
  );
  const internalFormat = PixelFormat_default.toInternalFormat(
    pixelFormat,
    pixelDatatype,
    context
  );
  const isCompressed = PixelFormat_default.isCompressedFormat(internalFormat);
  if (!defined_default(width) || !defined_default(height)) {
    throw new DeveloperError_default(
      "options requires a source field to create an initialized texture or width and height fields to create a blank texture."
    );
  }
  Check_default.typeOf.number.greaterThan("width", width, 0);
  if (width > ContextLimits_default.maximumTextureSize) {
    throw new DeveloperError_default(
      `Width must be less than or equal to the maximum texture size (${ContextLimits_default.maximumTextureSize}).  Check maximumTextureSize.`
    );
  }
  Check_default.typeOf.number.greaterThan("height", height, 0);
  if (height > ContextLimits_default.maximumTextureSize) {
    throw new DeveloperError_default(
      `Height must be less than or equal to the maximum texture size (${ContextLimits_default.maximumTextureSize}).  Check maximumTextureSize.`
    );
  }
  if (!PixelFormat_default.validate(pixelFormat)) {
    throw new DeveloperError_default("Invalid options.pixelFormat.");
  }
  if (!isCompressed && !PixelDatatype_default.validate(pixelDatatype)) {
    throw new DeveloperError_default("Invalid options.pixelDatatype.");
  }
  if (pixelFormat === PixelFormat_default.DEPTH_COMPONENT && pixelDatatype !== PixelDatatype_default.UNSIGNED_SHORT && pixelDatatype !== PixelDatatype_default.UNSIGNED_INT) {
    throw new DeveloperError_default(
      "When options.pixelFormat is DEPTH_COMPONENT, options.pixelDatatype must be UNSIGNED_SHORT or UNSIGNED_INT."
    );
  }
  if (pixelFormat === PixelFormat_default.DEPTH_STENCIL && pixelDatatype !== PixelDatatype_default.UNSIGNED_INT_24_8) {
    throw new DeveloperError_default(
      "When options.pixelFormat is DEPTH_STENCIL, options.pixelDatatype must be UNSIGNED_INT_24_8."
    );
  }
  if (pixelDatatype === PixelDatatype_default.FLOAT && !context.floatingPointTexture) {
    throw new DeveloperError_default(
      "When options.pixelDatatype is FLOAT, this WebGL implementation must support the OES_texture_float extension.  Check context.floatingPointTexture."
    );
  }
  if (pixelDatatype === PixelDatatype_default.HALF_FLOAT && !context.halfFloatingPointTexture) {
    throw new DeveloperError_default(
      "When options.pixelDatatype is HALF_FLOAT, this WebGL implementation must support the OES_texture_half_float extension. Check context.halfFloatingPointTexture."
    );
  }
  if (PixelFormat_default.isDepthFormat(pixelFormat)) {
    if (defined_default(source)) {
      throw new DeveloperError_default(
        "When options.pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, source cannot be provided."
      );
    }
    if (!context.depthTexture) {
      throw new DeveloperError_default(
        "When options.pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, this WebGL implementation must support WEBGL_depth_texture.  Check context.depthTexture."
      );
    }
  }
  if (isCompressed) {
    if (!defined_default(source) || !defined_default(source.arrayBufferView)) {
      throw new DeveloperError_default(
        "When options.pixelFormat is compressed, options.source.arrayBufferView must be defined."
      );
    }
    if (PixelFormat_default.isDXTFormat(internalFormat) && !context.s3tc) {
      throw new DeveloperError_default(
        "When options.pixelFormat is S3TC compressed, this WebGL implementation must support the WEBGL_compressed_texture_s3tc extension. Check context.s3tc."
      );
    } else if (PixelFormat_default.isPVRTCFormat(internalFormat) && !context.pvrtc) {
      throw new DeveloperError_default(
        "When options.pixelFormat is PVRTC compressed, this WebGL implementation must support the WEBGL_compressed_texture_pvrtc extension. Check context.pvrtc."
      );
    } else if (PixelFormat_default.isASTCFormat(internalFormat) && !context.astc) {
      throw new DeveloperError_default(
        "When options.pixelFormat is ASTC compressed, this WebGL implementation must support the WEBGL_compressed_texture_astc extension. Check context.astc."
      );
    } else if (PixelFormat_default.isETC2Format(internalFormat) && !context.etc) {
      throw new DeveloperError_default(
        "When options.pixelFormat is ETC2 compressed, this WebGL implementation must support the WEBGL_compressed_texture_etc extension. Check context.etc."
      );
    } else if (PixelFormat_default.isETC1Format(internalFormat) && !context.etc1) {
      throw new DeveloperError_default(
        "When options.pixelFormat is ETC1 compressed, this WebGL implementation must support the WEBGL_compressed_texture_etc1 extension. Check context.etc1."
      );
    } else if (PixelFormat_default.isBC7Format(internalFormat) && !context.bc7) {
      throw new DeveloperError_default(
        "When options.pixelFormat is BC7 compressed, this WebGL implementation must support the EXT_texture_compression_bptc extension. Check context.bc7."
      );
    }
    if (PixelFormat_default.compressedTextureSizeInBytes(
      internalFormat,
      width,
      height
    ) !== source.arrayBufferView.byteLength) {
      throw new DeveloperError_default(
        "The byte length of the array buffer is invalid for the compressed texture with the given width and height."
      );
    }
  }
  const preMultiplyAlpha = options.preMultiplyAlpha || pixelFormat === PixelFormat_default.RGB || pixelFormat === PixelFormat_default.LUMINANCE;
  const flipY = defaultValue_default(options.flipY, true);
  const skipColorSpaceConversion = defaultValue_default(
    options.skipColorSpaceConversion,
    false
  );
  let initialized = true;
  const gl = context._gl;
  const textureTarget = gl.TEXTURE_2D;
  const texture = gl.createTexture();
  gl.activeTexture(gl.TEXTURE0);
  gl.bindTexture(textureTarget, texture);
  let unpackAlignment = 4;
  if (defined_default(source) && defined_default(source.arrayBufferView) && !isCompressed) {
    unpackAlignment = PixelFormat_default.alignmentInBytes(
      pixelFormat,
      pixelDatatype,
      width
    );
  }
  gl.pixelStorei(gl.UNPACK_ALIGNMENT, unpackAlignment);
  if (skipColorSpaceConversion) {
    gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
  } else {
    gl.pixelStorei(
      gl.UNPACK_COLORSPACE_CONVERSION_WEBGL,
      gl.BROWSER_DEFAULT_WEBGL
    );
  }
  if (defined_default(source)) {
    if (defined_default(source.arrayBufferView)) {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
      let arrayBufferView = source.arrayBufferView;
      let i2, mipWidth, mipHeight;
      if (isCompressed) {
        gl.compressedTexImage2D(
          textureTarget,
          0,
          internalFormat,
          width,
          height,
          0,
          arrayBufferView
        );
        if (defined_default(source.mipLevels)) {
          mipWidth = width;
          mipHeight = height;
          for (i2 = 0; i2 < source.mipLevels.length; ++i2) {
            mipWidth = Math.floor(mipWidth / 2) | 0;
            if (mipWidth < 1) {
              mipWidth = 1;
            }
            mipHeight = Math.floor(mipHeight / 2) | 0;
            if (mipHeight < 1) {
              mipHeight = 1;
            }
            gl.compressedTexImage2D(
              textureTarget,
              i2 + 1,
              internalFormat,
              mipWidth,
              mipHeight,
              0,
              source.mipLevels[i2]
            );
          }
        }
      } else {
        if (flipY) {
          arrayBufferView = PixelFormat_default.flipY(
            arrayBufferView,
            pixelFormat,
            pixelDatatype,
            width,
            height
          );
        }
        gl.texImage2D(
          textureTarget,
          0,
          internalFormat,
          width,
          height,
          0,
          pixelFormat,
          PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
          arrayBufferView
        );
        if (defined_default(source.mipLevels)) {
          mipWidth = width;
          mipHeight = height;
          for (i2 = 0; i2 < source.mipLevels.length; ++i2) {
            mipWidth = Math.floor(mipWidth / 2) | 0;
            if (mipWidth < 1) {
              mipWidth = 1;
            }
            mipHeight = Math.floor(mipHeight / 2) | 0;
            if (mipHeight < 1) {
              mipHeight = 1;
            }
            gl.texImage2D(
              textureTarget,
              i2 + 1,
              internalFormat,
              mipWidth,
              mipHeight,
              0,
              pixelFormat,
              PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
              source.mipLevels[i2]
            );
          }
        }
      }
    } else if (defined_default(source.framebuffer)) {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
      if (source.framebuffer !== context.defaultFramebuffer) {
        source.framebuffer._bind();
      }
      gl.copyTexImage2D(
        textureTarget,
        0,
        internalFormat,
        source.xOffset,
        source.yOffset,
        width,
        height,
        0
      );
      if (source.framebuffer !== context.defaultFramebuffer) {
        source.framebuffer._unBind();
      }
    } else {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
      gl.texImage2D(
        textureTarget,
        0,
        internalFormat,
        pixelFormat,
        PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
        source
      );
    }
  } else {
    gl.texImage2D(
      textureTarget,
      0,
      internalFormat,
      width,
      height,
      0,
      pixelFormat,
      PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
      null
    );
    initialized = false;
  }
  gl.bindTexture(textureTarget, null);
  let sizeInBytes;
  if (isCompressed) {
    sizeInBytes = PixelFormat_default.compressedTextureSizeInBytes(
      pixelFormat,
      width,
      height
    );
  } else {
    sizeInBytes = PixelFormat_default.textureSizeInBytes(
      pixelFormat,
      pixelDatatype,
      width,
      height
    );
  }
  this._id = createGuid_default();
  this._context = context;
  this._textureFilterAnisotropic = context._textureFilterAnisotropic;
  this._textureTarget = textureTarget;
  this._texture = texture;
  this._internalFormat = internalFormat;
  this._pixelFormat = pixelFormat;
  this._pixelDatatype = pixelDatatype;
  this._width = width;
  this._height = height;
  this._dimensions = new Cartesian2_default(width, height);
  this._hasMipmap = false;
  this._sizeInBytes = sizeInBytes;
  this._preMultiplyAlpha = preMultiplyAlpha;
  this._flipY = flipY;
  this._initialized = initialized;
  this._sampler = void 0;
  this.sampler = defined_default(options.sampler) ? options.sampler : new Sampler_default();
}
Texture.create = function(options) {
  return new Texture(options);
};
Texture.fromFramebuffer = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.context", options.context);
  const context = options.context;
  const gl = context._gl;
  const pixelFormat = defaultValue_default(options.pixelFormat, PixelFormat_default.RGB);
  const framebufferXOffset = defaultValue_default(options.framebufferXOffset, 0);
  const framebufferYOffset = defaultValue_default(options.framebufferYOffset, 0);
  const width = defaultValue_default(options.width, gl.drawingBufferWidth);
  const height = defaultValue_default(options.height, gl.drawingBufferHeight);
  const framebuffer = options.framebuffer;
  if (!PixelFormat_default.validate(pixelFormat)) {
    throw new DeveloperError_default("Invalid pixelFormat.");
  }
  if (PixelFormat_default.isDepthFormat(pixelFormat) || PixelFormat_default.isCompressedFormat(pixelFormat)) {
    throw new DeveloperError_default(
      "pixelFormat cannot be DEPTH_COMPONENT, DEPTH_STENCIL or a compressed format."
    );
  }
  Check_default.defined("options.context", options.context);
  Check_default.typeOf.number.greaterThanOrEquals(
    "framebufferXOffset",
    framebufferXOffset,
    0
  );
  Check_default.typeOf.number.greaterThanOrEquals(
    "framebufferYOffset",
    framebufferYOffset,
    0
  );
  if (framebufferXOffset + width > gl.drawingBufferWidth) {
    throw new DeveloperError_default(
      "framebufferXOffset + width must be less than or equal to drawingBufferWidth"
    );
  }
  if (framebufferYOffset + height > gl.drawingBufferHeight) {
    throw new DeveloperError_default(
      "framebufferYOffset + height must be less than or equal to drawingBufferHeight."
    );
  }
  const texture = new Texture({
    context,
    width,
    height,
    pixelFormat,
    source: {
      framebuffer: defined_default(framebuffer) ? framebuffer : context.defaultFramebuffer,
      xOffset: framebufferXOffset,
      yOffset: framebufferYOffset,
      width,
      height
    }
  });
  return texture;
};
Object.defineProperties(Texture.prototype, {
  id: {
    get: function() {
      return this._id;
    }
  },
  sampler: {
    get: function() {
      return this._sampler;
    },
    set: function(sampler) {
      let minificationFilter = sampler.minificationFilter;
      let magnificationFilter = sampler.magnificationFilter;
      const context = this._context;
      const pixelFormat = this._pixelFormat;
      const pixelDatatype = this._pixelDatatype;
      const mipmap = minificationFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_NEAREST || minificationFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_LINEAR || minificationFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_NEAREST || minificationFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_LINEAR;
      if (pixelDatatype === PixelDatatype_default.FLOAT && !context.textureFloatLinear || pixelDatatype === PixelDatatype_default.HALF_FLOAT && !context.textureHalfFloatLinear) {
        minificationFilter = mipmap ? TextureMinificationFilter_default.NEAREST_MIPMAP_NEAREST : TextureMinificationFilter_default.NEAREST;
        magnificationFilter = TextureMagnificationFilter_default.NEAREST;
      }
      if (context.webgl2) {
        if (PixelFormat_default.isDepthFormat(pixelFormat)) {
          minificationFilter = TextureMinificationFilter_default.NEAREST;
          magnificationFilter = TextureMagnificationFilter_default.NEAREST;
        }
      }
      const gl = context._gl;
      const target = this._textureTarget;
      gl.activeTexture(gl.TEXTURE0);
      gl.bindTexture(target, this._texture);
      gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, minificationFilter);
      gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, magnificationFilter);
      gl.texParameteri(target, gl.TEXTURE_WRAP_S, sampler.wrapS);
      gl.texParameteri(target, gl.TEXTURE_WRAP_T, sampler.wrapT);
      if (defined_default(this._textureFilterAnisotropic)) {
        gl.texParameteri(
          target,
          this._textureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT,
          sampler.maximumAnisotropy
        );
      }
      gl.bindTexture(target, null);
      this._sampler = sampler;
    }
  },
  pixelFormat: {
    get: function() {
      return this._pixelFormat;
    }
  },
  pixelDatatype: {
    get: function() {
      return this._pixelDatatype;
    }
  },
  dimensions: {
    get: function() {
      return this._dimensions;
    }
  },
  preMultiplyAlpha: {
    get: function() {
      return this._preMultiplyAlpha;
    }
  },
  flipY: {
    get: function() {
      return this._flipY;
    }
  },
  width: {
    get: function() {
      return this._width;
    }
  },
  height: {
    get: function() {
      return this._height;
    }
  },
  sizeInBytes: {
    get: function() {
      if (this._hasMipmap) {
        return Math.floor(this._sizeInBytes * 4 / 3);
      }
      return this._sizeInBytes;
    }
  },
  _target: {
    get: function() {
      return this._textureTarget;
    }
  }
});
Texture.prototype.copyFrom = function(options) {
  Check_default.defined("options", options);
  const xOffset = defaultValue_default(options.xOffset, 0);
  const yOffset = defaultValue_default(options.yOffset, 0);
  Check_default.defined("options.source", options.source);
  if (PixelFormat_default.isDepthFormat(this._pixelFormat)) {
    throw new DeveloperError_default(
      "Cannot call copyFrom when the texture pixel format is DEPTH_COMPONENT or DEPTH_STENCIL."
    );
  }
  if (PixelFormat_default.isCompressedFormat(this._pixelFormat)) {
    throw new DeveloperError_default(
      "Cannot call copyFrom with a compressed texture pixel format."
    );
  }
  Check_default.typeOf.number.greaterThanOrEquals("xOffset", xOffset, 0);
  Check_default.typeOf.number.greaterThanOrEquals("yOffset", yOffset, 0);
  Check_default.typeOf.number.lessThanOrEquals(
    "xOffset + options.source.width",
    xOffset + options.source.width,
    this._width
  );
  Check_default.typeOf.number.lessThanOrEquals(
    "yOffset + options.source.height",
    yOffset + options.source.height,
    this._height
  );
  const source = options.source;
  const context = this._context;
  const gl = context._gl;
  const target = this._textureTarget;
  gl.activeTexture(gl.TEXTURE0);
  gl.bindTexture(target, this._texture);
  const width = source.width;
  const height = source.height;
  let arrayBufferView = source.arrayBufferView;
  const textureWidth = this._width;
  const textureHeight = this._height;
  const internalFormat = this._internalFormat;
  const pixelFormat = this._pixelFormat;
  const pixelDatatype = this._pixelDatatype;
  const preMultiplyAlpha = this._preMultiplyAlpha;
  const flipY = this._flipY;
  const skipColorSpaceConversion = defaultValue_default(
    options.skipColorSpaceConversion,
    false
  );
  let unpackAlignment = 4;
  if (defined_default(arrayBufferView)) {
    unpackAlignment = PixelFormat_default.alignmentInBytes(
      pixelFormat,
      pixelDatatype,
      width
    );
  }
  gl.pixelStorei(gl.UNPACK_ALIGNMENT, unpackAlignment);
  if (skipColorSpaceConversion) {
    gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
  } else {
    gl.pixelStorei(
      gl.UNPACK_COLORSPACE_CONVERSION_WEBGL,
      gl.BROWSER_DEFAULT_WEBGL
    );
  }
  let uploaded = false;
  if (!this._initialized) {
    if (xOffset === 0 && yOffset === 0 && width === textureWidth && height === textureHeight) {
      if (defined_default(arrayBufferView)) {
        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
        if (flipY) {
          arrayBufferView = PixelFormat_default.flipY(
            arrayBufferView,
            pixelFormat,
            pixelDatatype,
            textureWidth,
            textureHeight
          );
        }
        gl.texImage2D(
          target,
          0,
          internalFormat,
          textureWidth,
          textureHeight,
          0,
          pixelFormat,
          PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
          arrayBufferView
        );
      } else {
        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
        gl.texImage2D(
          target,
          0,
          internalFormat,
          pixelFormat,
          PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
          source
        );
      }
      uploaded = true;
    } else {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
      const bufferView = PixelFormat_default.createTypedArray(
        pixelFormat,
        pixelDatatype,
        textureWidth,
        textureHeight
      );
      gl.texImage2D(
        target,
        0,
        internalFormat,
        textureWidth,
        textureHeight,
        0,
        pixelFormat,
        PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
        bufferView
      );
    }
    this._initialized = true;
  }
  if (!uploaded) {
    if (defined_default(arrayBufferView)) {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
      if (flipY) {
        arrayBufferView = PixelFormat_default.flipY(
          arrayBufferView,
          pixelFormat,
          pixelDatatype,
          width,
          height
        );
      }
      gl.texSubImage2D(
        target,
        0,
        xOffset,
        yOffset,
        width,
        height,
        pixelFormat,
        PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
        arrayBufferView
      );
    } else {
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
      gl.texSubImage2D(
        target,
        0,
        xOffset,
        yOffset,
        pixelFormat,
        PixelDatatype_default.toWebGLConstant(pixelDatatype, context),
        source
      );
    }
  }
  gl.bindTexture(target, null);
};
Texture.prototype.copyFromFramebuffer = function(xOffset, yOffset, framebufferXOffset, framebufferYOffset, width, height) {
  xOffset = defaultValue_default(xOffset, 0);
  yOffset = defaultValue_default(yOffset, 0);
  framebufferXOffset = defaultValue_default(framebufferXOffset, 0);
  framebufferYOffset = defaultValue_default(framebufferYOffset, 0);
  width = defaultValue_default(width, this._width);
  height = defaultValue_default(height, this._height);
  if (PixelFormat_default.isDepthFormat(this._pixelFormat)) {
    throw new DeveloperError_default(
      "Cannot call copyFromFramebuffer when the texture pixel format is DEPTH_COMPONENT or DEPTH_STENCIL."
    );
  }
  if (this._pixelDatatype === PixelDatatype_default.FLOAT) {
    throw new DeveloperError_default(
      "Cannot call copyFromFramebuffer when the texture pixel data type is FLOAT."
    );
  }
  if (this._pixelDatatype === PixelDatatype_default.HALF_FLOAT) {
    throw new DeveloperError_default(
      "Cannot call copyFromFramebuffer when the texture pixel data type is HALF_FLOAT."
    );
  }
  if (PixelFormat_default.isCompressedFormat(this._pixelFormat)) {
    throw new DeveloperError_default(
      "Cannot call copyFrom with a compressed texture pixel format."
    );
  }
  Check_default.typeOf.number.greaterThanOrEquals("xOffset", xOffset, 0);
  Check_default.typeOf.number.greaterThanOrEquals("yOffset", yOffset, 0);
  Check_default.typeOf.number.greaterThanOrEquals(
    "framebufferXOffset",
    framebufferXOffset,
    0
  );
  Check_default.typeOf.number.greaterThanOrEquals(
    "framebufferYOffset",
    framebufferYOffset,
    0
  );
  Check_default.typeOf.number.lessThanOrEquals(
    "xOffset + width",
    xOffset + width,
    this._width
  );
  Check_default.typeOf.number.lessThanOrEquals(
    "yOffset + height",
    yOffset + height,
    this._height
  );
  const gl = this._context._gl;
  const target = this._textureTarget;
  gl.activeTexture(gl.TEXTURE0);
  gl.bindTexture(target, this._texture);
  gl.copyTexSubImage2D(
    target,
    0,
    xOffset,
    yOffset,
    framebufferXOffset,
    framebufferYOffset,
    width,
    height
  );
  gl.bindTexture(target, null);
  this._initialized = true;
};
Texture.prototype.generateMipmap = function(hint) {
  hint = defaultValue_default(hint, MipmapHint_default.DONT_CARE);
  if (PixelFormat_default.isDepthFormat(this._pixelFormat)) {
    throw new DeveloperError_default(
      "Cannot call generateMipmap when the texture pixel format is DEPTH_COMPONENT or DEPTH_STENCIL."
    );
  }
  if (PixelFormat_default.isCompressedFormat(this._pixelFormat)) {
    throw new DeveloperError_default(
      "Cannot call generateMipmap with a compressed pixel format."
    );
  }
  if (this._width > 1 && !Math_default.isPowerOfTwo(this._width)) {
    throw new DeveloperError_default(
      "width must be a power of two to call generateMipmap()."
    );
  }
  if (this._height > 1 && !Math_default.isPowerOfTwo(this._height)) {
    throw new DeveloperError_default(
      "height must be a power of two to call generateMipmap()."
    );
  }
  if (!MipmapHint_default.validate(hint)) {
    throw new DeveloperError_default("hint is invalid.");
  }
  this._hasMipmap = true;
  const gl = this._context._gl;
  const target = this._textureTarget;
  gl.hint(gl.GENERATE_MIPMAP_HINT, hint);
  gl.activeTexture(gl.TEXTURE0);
  gl.bindTexture(target, this._texture);
  gl.generateMipmap(target);
  gl.bindTexture(target, null);
};
Texture.prototype.isDestroyed = function() {
  return false;
};
Texture.prototype.destroy = function() {
  this._context._gl.deleteTexture(this._texture);
  return destroyObject_default(this);
};
var Texture_default = Texture;

// node_modules/cesium/Source/Shaders/Materials/AspectRampMaterial.js
var AspectRampMaterial_default = "uniform sampler2D image;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n    vec4 rampColor = texture2D(image, vec2(materialInput.aspect / (2.0 * czm_pi), 0.5));\n    rampColor = czm_gammaCorrect(rampColor);\n    material.diffuse = rampColor.rgb;\n    material.alpha = rampColor.a;\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/BumpMapMaterial.js
var BumpMapMaterial_default = "uniform sampler2D image;\nuniform float strength;\nuniform vec2 repeat;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    vec2 st = materialInput.st;\n\n    vec2 centerPixel = fract(repeat * st);\n    float centerBump = texture2D(image, centerPixel).channel;\n\n    float imageWidth = float(imageDimensions.x);\n    vec2 rightPixel = fract(repeat * (st + vec2(1.0 / imageWidth, 0.0)));\n    float rightBump = texture2D(image, rightPixel).channel;\n\n    float imageHeight = float(imageDimensions.y);\n    vec2 leftPixel = fract(repeat * (st + vec2(0.0, 1.0 / imageHeight)));\n    float topBump = texture2D(image, leftPixel).channel;\n\n    vec3 normalTangentSpace = normalize(vec3(centerBump - rightBump, centerBump - topBump, clamp(1.0 - strength, 0.1, 1.0)));\n    vec3 normalEC = materialInput.tangentToEyeMatrix * normalTangentSpace;\n\n    material.normal = normalEC;\n    material.diffuse = vec3(0.01);\n\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/CheckerboardMaterial.js
var CheckerboardMaterial_default = "uniform vec4 lightColor;\nuniform vec4 darkColor;\nuniform vec2 repeat;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    vec2 st = materialInput.st;\n\n    // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights\n    float b = mod(floor(repeat.s * st.s) + floor(repeat.t * st.t), 2.0);  // 0.0 or 1.0\n\n    // Find the distance from the closest separator (region between two colors)\n    float scaledWidth = fract(repeat.s * st.s);\n    scaledWidth = abs(scaledWidth - floor(scaledWidth + 0.5));\n    float scaledHeight = fract(repeat.t * st.t);\n    scaledHeight = abs(scaledHeight - floor(scaledHeight + 0.5));\n    float value = min(scaledWidth, scaledHeight);\n\n    vec4 currentColor = mix(lightColor, darkColor, b);\n    vec4 color = czm_antialias(lightColor, darkColor, currentColor, value, 0.03);\n\n    color = czm_gammaCorrect(color);\n    material.diffuse = color.rgb;\n    material.alpha = color.a;\n\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/DotMaterial.js
var DotMaterial_default = "uniform vec4 lightColor;\nuniform vec4 darkColor;\nuniform vec2 repeat;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    // From Stefan Gustavson's Procedural Textures in GLSL in OpenGL Insights\n    float b = smoothstep(0.3, 0.32, length(fract(repeat * materialInput.st) - 0.5));  // 0.0 or 1.0\n\n    vec4 color = mix(lightColor, darkColor, b);\n    color = czm_gammaCorrect(color);\n    material.diffuse = color.rgb;\n    material.alpha = color.a;\n\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/ElevationBandMaterial.js
var ElevationBandMaterial_default = "uniform sampler2D heights;\nuniform sampler2D colors;\n\n// This material expects heights to be sorted from lowest to highest.\n\nfloat getHeight(int idx, float invTexSize)\n{\n    vec2 uv = vec2((float(idx) + 0.5) * invTexSize, 0.5);\n#ifdef OES_texture_float\n    return texture2D(heights, uv).x;\n#else\n    return czm_unpackFloat(texture2D(heights, uv));\n#endif\n}\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    float height = materialInput.height;\n    float invTexSize = 1.0 / float(heightsDimensions.x);\n\n    float minHeight = getHeight(0, invTexSize);\n    float maxHeight = getHeight(heightsDimensions.x - 1, invTexSize);\n\n    // early-out when outside the height range\n    if (height < minHeight || height > maxHeight) {\n        material.diffuse = vec3(0.0);\n        material.alpha = 0.0;\n        return material;\n    }\n\n    // Binary search to find heights above and below.\n    int idxBelow = 0;\n    int idxAbove = heightsDimensions.x;\n    float heightBelow = minHeight;\n    float heightAbove = maxHeight;\n\n    // while loop not allowed, so use for loop with max iterations.\n    // maxIterations of 16 supports a texture size up to 65536 (2^16).\n    const int maxIterations = 16;\n    for (int i = 0; i < maxIterations; i++) {\n        if (idxBelow >= idxAbove - 1) {\n            break;\n        }\n\n        int idxMid = (idxBelow + idxAbove) / 2;\n        float heightTex = getHeight(idxMid, invTexSize);\n\n        if (height > heightTex) {\n            idxBelow = idxMid;\n            heightBelow = heightTex;\n        } else {\n            idxAbove = idxMid;\n            heightAbove = heightTex;\n        }\n    }\n\n    float lerper = heightBelow == heightAbove ? 1.0 : (height - heightBelow) / (heightAbove - heightBelow);\n    vec2 colorUv = vec2(invTexSize * (float(idxBelow) + 0.5 + lerper), 0.5);\n    vec4 color = texture2D(colors, colorUv);\n\n    // undo preumultiplied alpha\n    if (color.a > 0.0) \n    {\n        color.rgb /= color.a;\n    }\n    \n    color.rgb = czm_gammaCorrect(color.rgb);\n\n    material.diffuse = color.rgb;\n    material.alpha = color.a;\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/ElevationContourMaterial.js
var ElevationContourMaterial_default = "#ifdef GL_OES_standard_derivatives\n    #extension GL_OES_standard_derivatives : enable\n#endif\n\nuniform vec4 color;\nuniform float spacing;\nuniform float width;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    float distanceToContour = mod(materialInput.height, spacing);\n\n#ifdef GL_OES_standard_derivatives\n    float dxc = abs(dFdx(materialInput.height));\n    float dyc = abs(dFdy(materialInput.height));\n    float dF = max(dxc, dyc) * czm_pixelRatio * width;\n    float alpha = (distanceToContour < dF) ? 1.0 : 0.0;\n#else\n    float alpha = (distanceToContour < (czm_pixelRatio * width)) ? 1.0 : 0.0;\n#endif\n\n    vec4 outColor = czm_gammaCorrect(vec4(color.rgb, alpha * color.a));\n    material.diffuse = outColor.rgb;\n    material.alpha = outColor.a;\n\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/ElevationRampMaterial.js
var ElevationRampMaterial_default = "uniform sampler2D image;\nuniform float minimumHeight;\nuniform float maximumHeight;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n    float scaledHeight = clamp((materialInput.height - minimumHeight) / (maximumHeight - minimumHeight), 0.0, 1.0);\n    vec4 rampColor = texture2D(image, vec2(scaledHeight, 0.5));\n    rampColor = czm_gammaCorrect(rampColor);\n    material.diffuse = rampColor.rgb;\n    material.alpha = rampColor.a;\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/FadeMaterial.js
var FadeMaterial_default = "uniform vec4 fadeInColor;\nuniform vec4 fadeOutColor;\nuniform float maximumDistance;\nuniform bool repeat;\nuniform vec2 fadeDirection;\nuniform vec2 time;\n\nfloat getTime(float t, float coord)\n{\n    float scalar = 1.0 / maximumDistance;\n    float q  = distance(t, coord) * scalar;\n    if (repeat)\n    {\n        float r = distance(t, coord + 1.0) * scalar;\n        float s = distance(t, coord - 1.0) * scalar;\n        q = min(min(r, s), q);\n    }\n    return clamp(q, 0.0, 1.0);\n}\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    vec2 st = materialInput.st;\n    float s = getTime(time.x, st.s) * fadeDirection.s;\n    float t = getTime(time.y, st.t) * fadeDirection.t;\n\n    float u = length(vec2(s, t));\n    vec4 color = mix(fadeInColor, fadeOutColor, u);\n\n    color = czm_gammaCorrect(color);\n    material.emission = color.rgb;\n    material.alpha = color.a;\n\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/GridMaterial.js
var GridMaterial_default = '#ifdef GL_OES_standard_derivatives\n    #extension GL_OES_standard_derivatives : enable\n#endif\n\nuniform vec4 color;\nuniform float cellAlpha;\nuniform vec2 lineCount;\nuniform vec2 lineThickness;\nuniform vec2 lineOffset;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    vec2 st = materialInput.st;\n\n    float scaledWidth = fract(lineCount.s * st.s - lineOffset.s);\n    scaledWidth = abs(scaledWidth - floor(scaledWidth + 0.5));\n    float scaledHeight = fract(lineCount.t * st.t - lineOffset.t);\n    scaledHeight = abs(scaledHeight - floor(scaledHeight + 0.5));\n\n    float value;\n#ifdef GL_OES_standard_derivatives\n    // Fuzz Factor - Controls blurriness of lines\n    const float fuzz = 1.2;\n    vec2 thickness = (lineThickness * czm_pixelRatio) - 1.0;\n\n    // From "3D Engine Design for Virtual Globes" by Cozzi and Ring, Listing 4.13.\n    vec2 dx = abs(dFdx(st));\n    vec2 dy = abs(dFdy(st));\n    vec2 dF = vec2(max(dx.s, dy.s), max(dx.t, dy.t)) * lineCount;\n    value = min(\n        smoothstep(dF.s * thickness.s, dF.s * (fuzz + thickness.s), scaledWidth),\n        smoothstep(dF.t * thickness.t, dF.t * (fuzz + thickness.t), scaledHeight));\n#else\n    // Fuzz Factor - Controls blurriness of lines\n    const float fuzz = 0.05;\n\n    vec2 range = 0.5 - (lineThickness * 0.05);\n    value = min(\n        1.0 - smoothstep(range.s, range.s + fuzz, scaledWidth),\n        1.0 - smoothstep(range.t, range.t + fuzz, scaledHeight));\n#endif\n\n    // Edges taken from RimLightingMaterial.glsl\n    // See http://www.fundza.com/rman_shaders/surface/fake_rim/fake_rim1.html\n    float dRim = 1.0 - abs(dot(materialInput.normalEC, normalize(materialInput.positionToEyeEC)));\n    float sRim = smoothstep(0.8, 1.0, dRim);\n    value *= (1.0 - sRim);\n\n    vec4 halfColor;\n    halfColor.rgb = color.rgb * 0.5;\n    halfColor.a = color.a * (1.0 - ((1.0 - cellAlpha) * value));\n    halfColor = czm_gammaCorrect(halfColor);\n    material.diffuse = halfColor.rgb;\n    material.emission = halfColor.rgb;\n    material.alpha = halfColor.a;\n\n    return material;\n}\n';

// node_modules/cesium/Source/Shaders/Materials/NormalMapMaterial.js
var NormalMapMaterial_default = "uniform sampler2D image;\nuniform float strength;\nuniform vec2 repeat;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n    \n    vec4 textureValue = texture2D(image, fract(repeat * materialInput.st));\n    vec3 normalTangentSpace = textureValue.channels;\n    normalTangentSpace.xy = normalTangentSpace.xy * 2.0 - 1.0;\n    normalTangentSpace.z = clamp(1.0 - strength, 0.1, 1.0);\n    normalTangentSpace = normalize(normalTangentSpace);\n    vec3 normalEC = materialInput.tangentToEyeMatrix * normalTangentSpace;\n    \n    material.normal = normalEC;\n    \n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/PolylineArrowMaterial.js
var PolylineArrowMaterial_default = "#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n#endif\n\nuniform vec4 color;\n\nfloat getPointOnLine(vec2 p0, vec2 p1, float x)\n{\n    float slope = (p0.y - p1.y) / (p0.x - p1.x);\n    return slope * (x - p0.x) + p0.y;\n}\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    vec2 st = materialInput.st;\n\n#ifdef GL_OES_standard_derivatives\n    float base = 1.0 - abs(fwidth(st.s)) * 10.0 * czm_pixelRatio;\n#else\n    float base = 0.975; // 2.5% of the line will be the arrow head\n#endif\n\n    vec2 center = vec2(1.0, 0.5);\n    float ptOnUpperLine = getPointOnLine(vec2(base, 1.0), center, st.s);\n    float ptOnLowerLine = getPointOnLine(vec2(base, 0.0), center, st.s);\n\n    float halfWidth = 0.15;\n    float s = step(0.5 - halfWidth, st.t);\n    s *= 1.0 - step(0.5 + halfWidth, st.t);\n    s *= 1.0 - step(base, st.s);\n\n    float t = step(base, materialInput.st.s);\n    t *= 1.0 - step(ptOnUpperLine, st.t);\n    t *= step(ptOnLowerLine, st.t);\n\n    // Find the distance from the closest separator (region between two colors)\n    float dist;\n    if (st.s < base)\n    {\n        float d1 = abs(st.t - (0.5 - halfWidth));\n        float d2 = abs(st.t - (0.5 + halfWidth));\n        dist = min(d1, d2);\n    }\n    else\n    {\n        float d1 = czm_infinity;\n        if (st.t < 0.5 - halfWidth && st.t > 0.5 + halfWidth)\n        {\n            d1 = abs(st.s - base);\n        }\n        float d2 = abs(st.t - ptOnUpperLine);\n        float d3 = abs(st.t - ptOnLowerLine);\n        dist = min(min(d1, d2), d3);\n    }\n\n    vec4 outsideColor = vec4(0.0);\n    vec4 currentColor = mix(outsideColor, color, clamp(s + t, 0.0, 1.0));\n    vec4 outColor = czm_antialias(outsideColor, color, currentColor, dist);\n\n    outColor = czm_gammaCorrect(outColor);\n    material.diffuse = outColor.rgb;\n    material.alpha = outColor.a;\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/PolylineDashMaterial.js
var PolylineDashMaterial_default = "uniform vec4 color;\nuniform vec4 gapColor;\nuniform float dashLength;\nuniform float dashPattern;\nvarying float v_polylineAngle;\n\nconst float maskLength = 16.0;\n\nmat2 rotate(float rad) {\n    float c = cos(rad);\n    float s = sin(rad);\n    return mat2(\n        c, s,\n        -s, c\n    );\n}\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    vec2 pos = rotate(v_polylineAngle) * gl_FragCoord.xy;\n\n    // Get the relative position within the dash from 0 to 1\n    float dashPosition = fract(pos.x / (dashLength * czm_pixelRatio));\n    // Figure out the mask index.\n    float maskIndex = floor(dashPosition * maskLength);\n    // Test the bit mask.\n    float maskTest = floor(dashPattern / pow(2.0, maskIndex));\n    vec4 fragColor = (mod(maskTest, 2.0) < 1.0) ? gapColor : color;\n    if (fragColor.a < 0.005) {   // matches 0/255 and 1/255\n        discard;\n    }\n\n    fragColor = czm_gammaCorrect(fragColor);\n    material.emission = fragColor.rgb;\n    material.alpha = fragColor.a;\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/PolylineGlowMaterial.js
var PolylineGlowMaterial_default = "uniform vec4 color;\nuniform float glowPower;\nuniform float taperPower;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    vec2 st = materialInput.st;\n    float glow = glowPower / abs(st.t - 0.5) - (glowPower / 0.5);\n\n    if (taperPower <= 0.99999) {\n        glow *= min(1.0, taperPower / (0.5 - st.s * 0.5) - (taperPower / 0.5));\n    }\n\n    vec4 fragColor;\n    fragColor.rgb = max(vec3(glow - 1.0 + color.rgb), color.rgb);\n    fragColor.a = clamp(0.0, 1.0, glow) * color.a;\n    fragColor = czm_gammaCorrect(fragColor);\n\n    material.emission = fragColor.rgb;\n    material.alpha = fragColor.a;\n\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/PolylineOutlineMaterial.js
var PolylineOutlineMaterial_default = "uniform vec4 color;\nuniform vec4 outlineColor;\nuniform float outlineWidth;\n\nvarying float v_width;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    vec2 st = materialInput.st;\n    float halfInteriorWidth =  0.5 * (v_width - outlineWidth) / v_width;\n    float b = step(0.5 - halfInteriorWidth, st.t);\n    b *= 1.0 - step(0.5 + halfInteriorWidth, st.t);\n\n    // Find the distance from the closest separator (region between two colors)\n    float d1 = abs(st.t - (0.5 - halfInteriorWidth));\n    float d2 = abs(st.t - (0.5 + halfInteriorWidth));\n    float dist = min(d1, d2);\n\n    vec4 currentColor = mix(outlineColor, color, b);\n    vec4 outColor = czm_antialias(outlineColor, color, currentColor, dist);\n    outColor = czm_gammaCorrect(outColor);\n\n    material.diffuse = outColor.rgb;\n    material.alpha = outColor.a;\n\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/RimLightingMaterial.js
var RimLightingMaterial_default = "uniform vec4 color;\nuniform vec4 rimColor;\nuniform float width;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    // See http://www.fundza.com/rman_shaders/surface/fake_rim/fake_rim1.html\n    float d = 1.0 - dot(materialInput.normalEC, normalize(materialInput.positionToEyeEC));\n    float s = smoothstep(1.0 - width, 1.0, d);\n\n    vec4 outColor = czm_gammaCorrect(color);\n    vec4 outRimColor = czm_gammaCorrect(rimColor);\n\n    material.diffuse = outColor.rgb;\n    material.emission = outRimColor.rgb * s;\n    material.alpha = mix(outColor.a, outRimColor.a, s);\n\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/SlopeRampMaterial.js
var SlopeRampMaterial_default = "uniform sampler2D image;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n    vec4 rampColor = texture2D(image, vec2(materialInput.slope / (czm_pi / 2.0), 0.5));\n    rampColor = czm_gammaCorrect(rampColor);\n    material.diffuse = rampColor.rgb;\n    material.alpha = rampColor.a;\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/StripeMaterial.js
var StripeMaterial_default = "uniform vec4 evenColor;\nuniform vec4 oddColor;\nuniform float offset;\nuniform float repeat;\nuniform bool horizontal;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    // Based on the Stripes Fragment Shader in the Orange Book (11.1.2)\n    float coord = mix(materialInput.st.s, materialInput.st.t, float(horizontal));\n    float value = fract((coord - offset) * (repeat * 0.5));\n    float dist = min(value, min(abs(value - 0.5), 1.0 - value));\n\n    vec4 currentColor = mix(evenColor, oddColor, step(0.5, value));\n    vec4 color = czm_antialias(evenColor, oddColor, currentColor, dist);\n    color = czm_gammaCorrect(color);\n\n    material.diffuse = color.rgb;\n    material.alpha = color.a;\n\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Materials/Water.js
var Water_default = "// Thanks for the contribution Jonas\n// http://29a.ch/2012/7/19/webgl-terrain-rendering-water-fog\n\nuniform sampler2D specularMap;\nuniform sampler2D normalMap;\nuniform vec4 baseWaterColor;\nuniform vec4 blendColor;\nuniform float frequency;\nuniform float animationSpeed;\nuniform float amplitude;\nuniform float specularIntensity;\nuniform float fadeFactor;\n\nczm_material czm_getMaterial(czm_materialInput materialInput)\n{\n    czm_material material = czm_getDefaultMaterial(materialInput);\n\n    float time = czm_frameNumber * animationSpeed;\n\n    // fade is a function of the distance from the fragment and the frequency of the waves\n    float fade = max(1.0, (length(materialInput.positionToEyeEC) / 10000000000.0) * frequency * fadeFactor);\n\n    float specularMapValue = texture2D(specularMap, materialInput.st).r;\n\n    // note: not using directional motion at this time, just set the angle to 0.0;\n    vec4 noise = czm_getWaterNoise(normalMap, materialInput.st * frequency, time, 0.0);\n    vec3 normalTangentSpace = noise.xyz * vec3(1.0, 1.0, (1.0 / amplitude));\n\n    // fade out the normal perturbation as we move further from the water surface\n    normalTangentSpace.xy /= fade;\n\n    // attempt to fade out the normal perturbation as we approach non water areas (low specular map value)\n    normalTangentSpace = mix(vec3(0.0, 0.0, 50.0), normalTangentSpace, specularMapValue);\n\n    normalTangentSpace = normalize(normalTangentSpace);\n\n    // get ratios for alignment of the new normal vector with a vector perpendicular to the tangent plane\n    float tsPerturbationRatio = clamp(dot(normalTangentSpace, vec3(0.0, 0.0, 1.0)), 0.0, 1.0);\n\n    // fade out water effect as specular map value decreases\n    material.alpha = mix(blendColor.a, baseWaterColor.a, specularMapValue) * specularMapValue;\n\n    // base color is a blend of the water and non-water color based on the value from the specular map\n    // may need a uniform blend factor to better control this\n    material.diffuse = mix(blendColor.rgb, baseWaterColor.rgb, specularMapValue);\n\n    // diffuse highlights are based on how perturbed the normal is\n    material.diffuse += (0.1 * tsPerturbationRatio);\n\n    material.diffuse = material.diffuse;\n\n    material.normal = normalize(materialInput.tangentToEyeMatrix * normalTangentSpace);\n\n    material.specular = specularIntensity;\n    material.shininess = 10.0;\n\n    return material;\n}\n";

// node_modules/cesium/Source/Scene/Material.js
function Material(options) {
  this.type = void 0;
  this.shaderSource = void 0;
  this.materials = void 0;
  this.uniforms = void 0;
  this._uniforms = void 0;
  this.translucent = void 0;
  this._minificationFilter = defaultValue_default(
    options.minificationFilter,
    TextureMinificationFilter_default.LINEAR
  );
  this._magnificationFilter = defaultValue_default(
    options.magnificationFilter,
    TextureMagnificationFilter_default.LINEAR
  );
  this._strict = void 0;
  this._template = void 0;
  this._count = void 0;
  this._texturePaths = {};
  this._loadedImages = [];
  this._loadedCubeMaps = [];
  this._textures = {};
  this._updateFunctions = [];
  this._defaultTexture = void 0;
  initializeMaterial(options, this);
  Object.defineProperties(this, {
    type: {
      value: this.type,
      writable: false
    }
  });
  if (!defined_default(Material._uniformList[this.type])) {
    Material._uniformList[this.type] = Object.keys(this._uniforms);
  }
}
Material._uniformList = {};
Material.fromType = function(type, uniforms) {
  if (!defined_default(Material._materialCache.getMaterial(type))) {
    throw new DeveloperError_default(`material with type '${type}' does not exist.`);
  }
  const material = new Material({
    fabric: {
      type
    }
  });
  if (defined_default(uniforms)) {
    for (const name in uniforms) {
      if (uniforms.hasOwnProperty(name)) {
        material.uniforms[name] = uniforms[name];
      }
    }
  }
  return material;
};
Material.prototype.isTranslucent = function() {
  if (defined_default(this.translucent)) {
    if (typeof this.translucent === "function") {
      return this.translucent();
    }
    return this.translucent;
  }
  let translucent = true;
  const funcs = this._translucentFunctions;
  const length3 = funcs.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const func = funcs[i2];
    if (typeof func === "function") {
      translucent = translucent && func();
    } else {
      translucent = translucent && func;
    }
    if (!translucent) {
      break;
    }
  }
  return translucent;
};
Material.prototype.update = function(context) {
  this._defaultTexture = context.defaultTexture;
  let i2;
  let uniformId;
  const loadedImages = this._loadedImages;
  let length3 = loadedImages.length;
  for (i2 = 0; i2 < length3; ++i2) {
    const loadedImage = loadedImages[i2];
    uniformId = loadedImage.id;
    let image = loadedImage.image;
    let mipLevels;
    if (Array.isArray(image)) {
      mipLevels = image.slice(1, image.length).map(function(mipLevel) {
        return mipLevel.bufferView;
      });
      image = image[0];
    }
    const sampler = new Sampler_default({
      minificationFilter: this._minificationFilter,
      magnificationFilter: this._magnificationFilter
    });
    let texture;
    if (defined_default(image.internalFormat)) {
      texture = new Texture_default({
        context,
        pixelFormat: image.internalFormat,
        width: image.width,
        height: image.height,
        source: {
          arrayBufferView: image.bufferView,
          mipLevels
        },
        sampler
      });
    } else {
      texture = new Texture_default({
        context,
        source: image,
        sampler
      });
    }
    const oldTexture = this._textures[uniformId];
    if (defined_default(oldTexture) && oldTexture !== this._defaultTexture) {
      oldTexture.destroy();
    }
    this._textures[uniformId] = texture;
    const uniformDimensionsName = `${uniformId}Dimensions`;
    if (this.uniforms.hasOwnProperty(uniformDimensionsName)) {
      const uniformDimensions = this.uniforms[uniformDimensionsName];
      uniformDimensions.x = texture._width;
      uniformDimensions.y = texture._height;
    }
  }
  loadedImages.length = 0;
  const loadedCubeMaps = this._loadedCubeMaps;
  length3 = loadedCubeMaps.length;
  for (i2 = 0; i2 < length3; ++i2) {
    const loadedCubeMap = loadedCubeMaps[i2];
    uniformId = loadedCubeMap.id;
    const images = loadedCubeMap.images;
    const cubeMap = new CubeMap_default({
      context,
      source: {
        positiveX: images[0],
        negativeX: images[1],
        positiveY: images[2],
        negativeY: images[3],
        positiveZ: images[4],
        negativeZ: images[5]
      },
      sampler: new Sampler_default({
        minificationFilter: this._minificationFilter,
        magnificationFilter: this._magnificationFilter
      })
    });
    this._textures[uniformId] = cubeMap;
  }
  loadedCubeMaps.length = 0;
  const updateFunctions2 = this._updateFunctions;
  length3 = updateFunctions2.length;
  for (i2 = 0; i2 < length3; ++i2) {
    updateFunctions2[i2](this, context);
  }
  const subMaterials = this.materials;
  for (const name in subMaterials) {
    if (subMaterials.hasOwnProperty(name)) {
      subMaterials[name].update(context);
    }
  }
};
Material.prototype.isDestroyed = function() {
  return false;
};
Material.prototype.destroy = function() {
  const textures = this._textures;
  for (const texture in textures) {
    if (textures.hasOwnProperty(texture)) {
      const instance = textures[texture];
      if (instance !== this._defaultTexture) {
        instance.destroy();
      }
    }
  }
  const materials = this.materials;
  for (const material in materials) {
    if (materials.hasOwnProperty(material)) {
      materials[material].destroy();
    }
  }
  return destroyObject_default(this);
};
function initializeMaterial(options, result) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  result._strict = defaultValue_default(options.strict, false);
  result._count = defaultValue_default(options.count, 0);
  result._template = clone_default(
    defaultValue_default(options.fabric, defaultValue_default.EMPTY_OBJECT)
  );
  result._template.uniforms = clone_default(
    defaultValue_default(result._template.uniforms, defaultValue_default.EMPTY_OBJECT)
  );
  result._template.materials = clone_default(
    defaultValue_default(result._template.materials, defaultValue_default.EMPTY_OBJECT)
  );
  result.type = defined_default(result._template.type) ? result._template.type : createGuid_default();
  result.shaderSource = "";
  result.materials = {};
  result.uniforms = {};
  result._uniforms = {};
  result._translucentFunctions = [];
  let translucent;
  const cachedMaterial = Material._materialCache.getMaterial(result.type);
  if (defined_default(cachedMaterial)) {
    const template = clone_default(cachedMaterial.fabric, true);
    result._template = combine_default(result._template, template, true);
    translucent = cachedMaterial.translucent;
  }
  checkForTemplateErrors(result);
  if (!defined_default(cachedMaterial)) {
    Material._materialCache.addMaterial(result.type, result);
  }
  createMethodDefinition(result);
  createUniforms(result);
  createSubMaterials(result);
  const defaultTranslucent = result._translucentFunctions.length === 0 ? true : void 0;
  translucent = defaultValue_default(translucent, defaultTranslucent);
  translucent = defaultValue_default(options.translucent, translucent);
  if (defined_default(translucent)) {
    if (typeof translucent === "function") {
      const wrappedTranslucent = function() {
        return translucent(result);
      };
      result._translucentFunctions.push(wrappedTranslucent);
    } else {
      result._translucentFunctions.push(translucent);
    }
  }
}
function checkForValidProperties(object2, properties, result, throwNotFound) {
  if (defined_default(object2)) {
    for (const property in object2) {
      if (object2.hasOwnProperty(property)) {
        const hasProperty = properties.indexOf(property) !== -1;
        if (throwNotFound && !hasProperty || !throwNotFound && hasProperty) {
          result(property, properties);
        }
      }
    }
  }
}
function invalidNameError(property, properties) {
  let errorString = `fabric: property name '${property}' is not valid. It should be `;
  for (let i2 = 0; i2 < properties.length; i2++) {
    const propertyName = `'${properties[i2]}'`;
    errorString += i2 === properties.length - 1 ? `or ${propertyName}.` : `${propertyName}, `;
  }
  throw new DeveloperError_default(errorString);
}
function duplicateNameError(property, properties) {
  const errorString = `fabric: uniforms and materials cannot share the same property '${property}'`;
  throw new DeveloperError_default(errorString);
}
var templateProperties = [
  "type",
  "materials",
  "uniforms",
  "components",
  "source"
];
var componentProperties = [
  "diffuse",
  "specular",
  "shininess",
  "normal",
  "emission",
  "alpha"
];
function checkForTemplateErrors(material) {
  const template = material._template;
  const uniforms = template.uniforms;
  const materials = template.materials;
  const components = template.components;
  if (defined_default(components) && defined_default(template.source)) {
    throw new DeveloperError_default(
      "fabric: cannot have source and components in the same template."
    );
  }
  checkForValidProperties(template, templateProperties, invalidNameError, true);
  checkForValidProperties(
    components,
    componentProperties,
    invalidNameError,
    true
  );
  const materialNames = [];
  for (const property in materials) {
    if (materials.hasOwnProperty(property)) {
      materialNames.push(property);
    }
  }
  checkForValidProperties(uniforms, materialNames, duplicateNameError, false);
}
function isMaterialFused(shaderComponent, material) {
  const materials = material._template.materials;
  for (const subMaterialId in materials) {
    if (materials.hasOwnProperty(subMaterialId)) {
      if (shaderComponent.indexOf(subMaterialId) > -1) {
        return true;
      }
    }
  }
  return false;
}
function createMethodDefinition(material) {
  const components = material._template.components;
  const source = material._template.source;
  if (defined_default(source)) {
    material.shaderSource += `${source}
`;
  } else {
    material.shaderSource += "czm_material czm_getMaterial(czm_materialInput materialInput)\n{\n";
    material.shaderSource += "czm_material material = czm_getDefaultMaterial(materialInput);\n";
    if (defined_default(components)) {
      const isMultiMaterial = Object.keys(material._template.materials).length > 0;
      for (const component in components) {
        if (components.hasOwnProperty(component)) {
          if (component === "diffuse" || component === "emission") {
            const isFusion = isMultiMaterial && isMaterialFused(components[component], material);
            const componentSource = isFusion ? components[component] : `czm_gammaCorrect(${components[component]})`;
            material.shaderSource += `material.${component} = ${componentSource}; 
`;
          } else if (component === "alpha") {
            material.shaderSource += `material.alpha = ${components.alpha}; 
`;
          } else {
            material.shaderSource += `material.${component} = ${components[component]};
`;
          }
        }
      }
    }
    material.shaderSource += "return material;\n}\n";
  }
}
var matrixMap = {
  mat2: Matrix2_default,
  mat3: Matrix3_default,
  mat4: Matrix4_default
};
var ktx2Regex = /\.ktx2$/i;
function createTexture2DUpdateFunction(uniformId) {
  let oldUniformValue;
  return function(material, context) {
    const uniforms = material.uniforms;
    const uniformValue = uniforms[uniformId];
    const uniformChanged = oldUniformValue !== uniformValue;
    const uniformValueIsDefaultImage = !defined_default(uniformValue) || uniformValue === Material.DefaultImageId;
    oldUniformValue = uniformValue;
    let texture = material._textures[uniformId];
    let uniformDimensionsName;
    let uniformDimensions;
    if (uniformValue instanceof HTMLVideoElement) {
      if (uniformValue.readyState >= 2) {
        if (uniformChanged && defined_default(texture)) {
          if (texture !== context.defaultTexture) {
            texture.destroy();
          }
          texture = void 0;
        }
        if (!defined_default(texture) || texture === context.defaultTexture) {
          const sampler = new Sampler_default({
            minificationFilter: material._minificationFilter,
            magnificationFilter: material._magnificationFilter
          });
          texture = new Texture_default({
            context,
            source: uniformValue,
            sampler
          });
          material._textures[uniformId] = texture;
          return;
        }
        texture.copyFrom({
          source: uniformValue
        });
      } else if (!defined_default(texture)) {
        material._textures[uniformId] = context.defaultTexture;
      }
      return;
    }
    if (uniformValue instanceof Texture_default && uniformValue !== texture) {
      material._texturePaths[uniformId] = void 0;
      const tmp2 = material._textures[uniformId];
      if (defined_default(tmp2) && tmp2 !== material._defaultTexture) {
        tmp2.destroy();
      }
      material._textures[uniformId] = uniformValue;
      uniformDimensionsName = `${uniformId}Dimensions`;
      if (uniforms.hasOwnProperty(uniformDimensionsName)) {
        uniformDimensions = uniforms[uniformDimensionsName];
        uniformDimensions.x = uniformValue._width;
        uniformDimensions.y = uniformValue._height;
      }
      return;
    }
    if (uniformChanged && defined_default(texture) && uniformValueIsDefaultImage) {
      if (texture !== material._defaultTexture) {
        texture.destroy();
      }
      texture = void 0;
    }
    if (!defined_default(texture)) {
      material._texturePaths[uniformId] = void 0;
      texture = material._textures[uniformId] = material._defaultTexture;
      uniformDimensionsName = `${uniformId}Dimensions`;
      if (uniforms.hasOwnProperty(uniformDimensionsName)) {
        uniformDimensions = uniforms[uniformDimensionsName];
        uniformDimensions.x = texture._width;
        uniformDimensions.y = texture._height;
      }
    }
    if (uniformValueIsDefaultImage) {
      return;
    }
    const isResource = uniformValue instanceof Resource_default;
    if (!defined_default(material._texturePaths[uniformId]) || isResource && uniformValue.url !== material._texturePaths[uniformId].url || !isResource && uniformValue !== material._texturePaths[uniformId]) {
      if (typeof uniformValue === "string" || isResource) {
        const resource = isResource ? uniformValue : Resource_default.createIfNeeded(uniformValue);
        let promise;
        if (ktx2Regex.test(resource.url)) {
          promise = loadKTX2_default(resource.url);
        } else {
          promise = resource.fetchImage();
        }
        Promise.resolve(promise).then(function(image) {
          material._loadedImages.push({
            id: uniformId,
            image
          });
        }).catch(function() {
          if (defined_default(texture) && texture !== material._defaultTexture) {
            texture.destroy();
          }
          material._textures[uniformId] = material._defaultTexture;
        });
      } else if (uniformValue instanceof HTMLCanvasElement || uniformValue instanceof HTMLImageElement) {
        material._loadedImages.push({
          id: uniformId,
          image: uniformValue
        });
      }
      material._texturePaths[uniformId] = uniformValue;
    }
  };
}
function createCubeMapUpdateFunction(uniformId) {
  return function(material, context) {
    const uniformValue = material.uniforms[uniformId];
    if (uniformValue instanceof CubeMap_default) {
      const tmp2 = material._textures[uniformId];
      if (tmp2 !== material._defaultTexture) {
        tmp2.destroy();
      }
      material._texturePaths[uniformId] = void 0;
      material._textures[uniformId] = uniformValue;
      return;
    }
    if (!defined_default(material._textures[uniformId])) {
      material._texturePaths[uniformId] = void 0;
      material._textures[uniformId] = context.defaultCubeMap;
    }
    if (uniformValue === Material.DefaultCubeMapId) {
      return;
    }
    const path = uniformValue.positiveX + uniformValue.negativeX + uniformValue.positiveY + uniformValue.negativeY + uniformValue.positiveZ + uniformValue.negativeZ;
    if (path !== material._texturePaths[uniformId]) {
      const promises = [
        Resource_default.createIfNeeded(uniformValue.positiveX).fetchImage(),
        Resource_default.createIfNeeded(uniformValue.negativeX).fetchImage(),
        Resource_default.createIfNeeded(uniformValue.positiveY).fetchImage(),
        Resource_default.createIfNeeded(uniformValue.negativeY).fetchImage(),
        Resource_default.createIfNeeded(uniformValue.positiveZ).fetchImage(),
        Resource_default.createIfNeeded(uniformValue.negativeZ).fetchImage()
      ];
      Promise.all(promises).then(function(images) {
        material._loadedCubeMaps.push({
          id: uniformId,
          images
        });
      });
      material._texturePaths[uniformId] = path;
    }
  };
}
function createUniforms(material) {
  const uniforms = material._template.uniforms;
  for (const uniformId in uniforms) {
    if (uniforms.hasOwnProperty(uniformId)) {
      createUniform(material, uniformId);
    }
  }
}
function createUniform(material, uniformId) {
  const strict = material._strict;
  const materialUniforms = material._template.uniforms;
  const uniformValue = materialUniforms[uniformId];
  const uniformType = getUniformType(uniformValue);
  if (!defined_default(uniformType)) {
    throw new DeveloperError_default(
      `fabric: uniform '${uniformId}' has invalid type.`
    );
  }
  let replacedTokenCount;
  if (uniformType === "channels") {
    replacedTokenCount = replaceToken(material, uniformId, uniformValue, false);
    if (replacedTokenCount === 0 && strict) {
      throw new DeveloperError_default(
        `strict: shader source does not use channels '${uniformId}'.`
      );
    }
  } else {
    if (uniformType === "sampler2D") {
      const imageDimensionsUniformName = `${uniformId}Dimensions`;
      if (getNumberOfTokens(material, imageDimensionsUniformName) > 0) {
        materialUniforms[imageDimensionsUniformName] = {
          type: "ivec3",
          x: 1,
          y: 1
        };
        createUniform(material, imageDimensionsUniformName);
      }
    }
    const uniformDeclarationRegex = new RegExp(
      `uniform\\s+${uniformType}\\s+${uniformId}\\s*;`
    );
    if (!uniformDeclarationRegex.test(material.shaderSource)) {
      const uniformDeclaration = `uniform ${uniformType} ${uniformId};`;
      material.shaderSource = uniformDeclaration + material.shaderSource;
    }
    const newUniformId = `${uniformId}_${material._count++}`;
    replacedTokenCount = replaceToken(material, uniformId, newUniformId);
    if (replacedTokenCount === 1 && strict) {
      throw new DeveloperError_default(
        `strict: shader source does not use uniform '${uniformId}'.`
      );
    }
    material.uniforms[uniformId] = uniformValue;
    if (uniformType === "sampler2D") {
      material._uniforms[newUniformId] = function() {
        return material._textures[uniformId];
      };
      material._updateFunctions.push(createTexture2DUpdateFunction(uniformId));
    } else if (uniformType === "samplerCube") {
      material._uniforms[newUniformId] = function() {
        return material._textures[uniformId];
      };
      material._updateFunctions.push(createCubeMapUpdateFunction(uniformId));
    } else if (uniformType.indexOf("mat") !== -1) {
      const scratchMatrix7 = new matrixMap[uniformType]();
      material._uniforms[newUniformId] = function() {
        return matrixMap[uniformType].fromColumnMajorArray(
          material.uniforms[uniformId],
          scratchMatrix7
        );
      };
    } else {
      material._uniforms[newUniformId] = function() {
        return material.uniforms[uniformId];
      };
    }
  }
}
function getUniformType(uniformValue) {
  let uniformType = uniformValue.type;
  if (!defined_default(uniformType)) {
    const type = typeof uniformValue;
    if (type === "number") {
      uniformType = "float";
    } else if (type === "boolean") {
      uniformType = "bool";
    } else if (type === "string" || uniformValue instanceof Resource_default || uniformValue instanceof HTMLCanvasElement || uniformValue instanceof HTMLImageElement) {
      if (/^([rgba]){1,4}$/i.test(uniformValue)) {
        uniformType = "channels";
      } else if (uniformValue === Material.DefaultCubeMapId) {
        uniformType = "samplerCube";
      } else {
        uniformType = "sampler2D";
      }
    } else if (type === "object") {
      if (Array.isArray(uniformValue)) {
        if (uniformValue.length === 4 || uniformValue.length === 9 || uniformValue.length === 16) {
          uniformType = `mat${Math.sqrt(uniformValue.length)}`;
        }
      } else {
        let numAttributes = 0;
        for (const attribute in uniformValue) {
          if (uniformValue.hasOwnProperty(attribute)) {
            numAttributes += 1;
          }
        }
        if (numAttributes >= 2 && numAttributes <= 4) {
          uniformType = `vec${numAttributes}`;
        } else if (numAttributes === 6) {
          uniformType = "samplerCube";
        }
      }
    }
  }
  return uniformType;
}
function createSubMaterials(material) {
  const strict = material._strict;
  const subMaterialTemplates = material._template.materials;
  for (const subMaterialId in subMaterialTemplates) {
    if (subMaterialTemplates.hasOwnProperty(subMaterialId)) {
      const subMaterial = new Material({
        strict,
        fabric: subMaterialTemplates[subMaterialId],
        count: material._count
      });
      material._count = subMaterial._count;
      material._uniforms = combine_default(
        material._uniforms,
        subMaterial._uniforms,
        true
      );
      material.materials[subMaterialId] = subMaterial;
      material._translucentFunctions = material._translucentFunctions.concat(
        subMaterial._translucentFunctions
      );
      const originalMethodName = "czm_getMaterial";
      const newMethodName = `${originalMethodName}_${material._count++}`;
      replaceToken(subMaterial, originalMethodName, newMethodName);
      material.shaderSource = subMaterial.shaderSource + material.shaderSource;
      const materialMethodCall = `${newMethodName}(materialInput)`;
      const tokensReplacedCount = replaceToken(
        material,
        subMaterialId,
        materialMethodCall
      );
      if (tokensReplacedCount === 0 && strict) {
        throw new DeveloperError_default(
          `strict: shader source does not use material '${subMaterialId}'.`
        );
      }
    }
  }
}
function replaceToken(material, token, newToken, excludePeriod) {
  excludePeriod = defaultValue_default(excludePeriod, true);
  let count = 0;
  const suffixChars = "([\\w])?";
  const prefixChars = `([\\w${excludePeriod ? "." : ""}])?`;
  const regExp = new RegExp(prefixChars + token + suffixChars, "g");
  material.shaderSource = material.shaderSource.replace(regExp, function($0, $1, $2) {
    if ($1 || $2) {
      return $0;
    }
    count += 1;
    return newToken;
  });
  return count;
}
function getNumberOfTokens(material, token, excludePeriod) {
  return replaceToken(material, token, token, excludePeriod);
}
Material._materialCache = {
  _materials: {},
  addMaterial: function(type, materialTemplate) {
    this._materials[type] = materialTemplate;
  },
  getMaterial: function(type) {
    return this._materials[type];
  }
};
Material.DefaultImageId = "czm_defaultImage";
Material.DefaultCubeMapId = "czm_defaultCubeMap";
Material.ColorType = "Color";
Material._materialCache.addMaterial(Material.ColorType, {
  fabric: {
    type: Material.ColorType,
    uniforms: {
      color: new Color_default(1, 0, 0, 0.5)
    },
    components: {
      diffuse: "color.rgb",
      alpha: "color.a"
    }
  },
  translucent: function(material) {
    return material.uniforms.color.alpha < 1;
  }
});
Material.ImageType = "Image";
Material._materialCache.addMaterial(Material.ImageType, {
  fabric: {
    type: Material.ImageType,
    uniforms: {
      image: Material.DefaultImageId,
      repeat: new Cartesian2_default(1, 1),
      color: new Color_default(1, 1, 1, 1)
    },
    components: {
      diffuse: "texture2D(image, fract(repeat * materialInput.st)).rgb * color.rgb",
      alpha: "texture2D(image, fract(repeat * materialInput.st)).a * color.a"
    }
  },
  translucent: function(material) {
    return material.uniforms.color.alpha < 1;
  }
});
Material.DiffuseMapType = "DiffuseMap";
Material._materialCache.addMaterial(Material.DiffuseMapType, {
  fabric: {
    type: Material.DiffuseMapType,
    uniforms: {
      image: Material.DefaultImageId,
      channels: "rgb",
      repeat: new Cartesian2_default(1, 1)
    },
    components: {
      diffuse: "texture2D(image, fract(repeat * materialInput.st)).channels"
    }
  },
  translucent: false
});
Material.AlphaMapType = "AlphaMap";
Material._materialCache.addMaterial(Material.AlphaMapType, {
  fabric: {
    type: Material.AlphaMapType,
    uniforms: {
      image: Material.DefaultImageId,
      channel: "a",
      repeat: new Cartesian2_default(1, 1)
    },
    components: {
      alpha: "texture2D(image, fract(repeat * materialInput.st)).channel"
    }
  },
  translucent: true
});
Material.SpecularMapType = "SpecularMap";
Material._materialCache.addMaterial(Material.SpecularMapType, {
  fabric: {
    type: Material.SpecularMapType,
    uniforms: {
      image: Material.DefaultImageId,
      channel: "r",
      repeat: new Cartesian2_default(1, 1)
    },
    components: {
      specular: "texture2D(image, fract(repeat * materialInput.st)).channel"
    }
  },
  translucent: false
});
Material.EmissionMapType = "EmissionMap";
Material._materialCache.addMaterial(Material.EmissionMapType, {
  fabric: {
    type: Material.EmissionMapType,
    uniforms: {
      image: Material.DefaultImageId,
      channels: "rgb",
      repeat: new Cartesian2_default(1, 1)
    },
    components: {
      emission: "texture2D(image, fract(repeat * materialInput.st)).channels"
    }
  },
  translucent: false
});
Material.BumpMapType = "BumpMap";
Material._materialCache.addMaterial(Material.BumpMapType, {
  fabric: {
    type: Material.BumpMapType,
    uniforms: {
      image: Material.DefaultImageId,
      channel: "r",
      strength: 0.8,
      repeat: new Cartesian2_default(1, 1)
    },
    source: BumpMapMaterial_default
  },
  translucent: false
});
Material.NormalMapType = "NormalMap";
Material._materialCache.addMaterial(Material.NormalMapType, {
  fabric: {
    type: Material.NormalMapType,
    uniforms: {
      image: Material.DefaultImageId,
      channels: "rgb",
      strength: 0.8,
      repeat: new Cartesian2_default(1, 1)
    },
    source: NormalMapMaterial_default
  },
  translucent: false
});
Material.GridType = "Grid";
Material._materialCache.addMaterial(Material.GridType, {
  fabric: {
    type: Material.GridType,
    uniforms: {
      color: new Color_default(0, 1, 0, 1),
      cellAlpha: 0.1,
      lineCount: new Cartesian2_default(8, 8),
      lineThickness: new Cartesian2_default(1, 1),
      lineOffset: new Cartesian2_default(0, 0)
    },
    source: GridMaterial_default
  },
  translucent: function(material) {
    const uniforms = material.uniforms;
    return uniforms.color.alpha < 1 || uniforms.cellAlpha < 1;
  }
});
Material.StripeType = "Stripe";
Material._materialCache.addMaterial(Material.StripeType, {
  fabric: {
    type: Material.StripeType,
    uniforms: {
      horizontal: true,
      evenColor: new Color_default(1, 1, 1, 0.5),
      oddColor: new Color_default(0, 0, 1, 0.5),
      offset: 0,
      repeat: 5
    },
    source: StripeMaterial_default
  },
  translucent: function(material) {
    const uniforms = material.uniforms;
    return uniforms.evenColor.alpha < 1 || uniforms.oddColor.alpha < 1;
  }
});
Material.CheckerboardType = "Checkerboard";
Material._materialCache.addMaterial(Material.CheckerboardType, {
  fabric: {
    type: Material.CheckerboardType,
    uniforms: {
      lightColor: new Color_default(1, 1, 1, 0.5),
      darkColor: new Color_default(0, 0, 0, 0.5),
      repeat: new Cartesian2_default(5, 5)
    },
    source: CheckerboardMaterial_default
  },
  translucent: function(material) {
    const uniforms = material.uniforms;
    return uniforms.lightColor.alpha < 1 || uniforms.darkColor.alpha < 1;
  }
});
Material.DotType = "Dot";
Material._materialCache.addMaterial(Material.DotType, {
  fabric: {
    type: Material.DotType,
    uniforms: {
      lightColor: new Color_default(1, 1, 0, 0.75),
      darkColor: new Color_default(0, 1, 1, 0.75),
      repeat: new Cartesian2_default(5, 5)
    },
    source: DotMaterial_default
  },
  translucent: function(material) {
    const uniforms = material.uniforms;
    return uniforms.lightColor.alpha < 1 || uniforms.darkColor.alpha < 1;
  }
});
Material.WaterType = "Water";
Material._materialCache.addMaterial(Material.WaterType, {
  fabric: {
    type: Material.WaterType,
    uniforms: {
      baseWaterColor: new Color_default(0.2, 0.3, 0.6, 1),
      blendColor: new Color_default(0, 1, 0.699, 1),
      specularMap: Material.DefaultImageId,
      normalMap: Material.DefaultImageId,
      frequency: 10,
      animationSpeed: 0.01,
      amplitude: 1,
      specularIntensity: 0.5,
      fadeFactor: 1
    },
    source: Water_default
  },
  translucent: function(material) {
    const uniforms = material.uniforms;
    return uniforms.baseWaterColor.alpha < 1 || uniforms.blendColor.alpha < 1;
  }
});
Material.RimLightingType = "RimLighting";
Material._materialCache.addMaterial(Material.RimLightingType, {
  fabric: {
    type: Material.RimLightingType,
    uniforms: {
      color: new Color_default(1, 0, 0, 0.7),
      rimColor: new Color_default(1, 1, 1, 0.4),
      width: 0.3
    },
    source: RimLightingMaterial_default
  },
  translucent: function(material) {
    const uniforms = material.uniforms;
    return uniforms.color.alpha < 1 || uniforms.rimColor.alpha < 1;
  }
});
Material.FadeType = "Fade";
Material._materialCache.addMaterial(Material.FadeType, {
  fabric: {
    type: Material.FadeType,
    uniforms: {
      fadeInColor: new Color_default(1, 0, 0, 1),
      fadeOutColor: new Color_default(0, 0, 0, 0),
      maximumDistance: 0.5,
      repeat: true,
      fadeDirection: {
        x: true,
        y: true
      },
      time: new Cartesian2_default(0.5, 0.5)
    },
    source: FadeMaterial_default
  },
  translucent: function(material) {
    const uniforms = material.uniforms;
    return uniforms.fadeInColor.alpha < 1 || uniforms.fadeOutColor.alpha < 1;
  }
});
Material.PolylineArrowType = "PolylineArrow";
Material._materialCache.addMaterial(Material.PolylineArrowType, {
  fabric: {
    type: Material.PolylineArrowType,
    uniforms: {
      color: new Color_default(1, 1, 1, 1)
    },
    source: PolylineArrowMaterial_default
  },
  translucent: true
});
Material.PolylineDashType = "PolylineDash";
Material._materialCache.addMaterial(Material.PolylineDashType, {
  fabric: {
    type: Material.PolylineDashType,
    uniforms: {
      color: new Color_default(1, 0, 1, 1),
      gapColor: new Color_default(0, 0, 0, 0),
      dashLength: 16,
      dashPattern: 255
    },
    source: PolylineDashMaterial_default
  },
  translucent: true
});
Material.PolylineGlowType = "PolylineGlow";
Material._materialCache.addMaterial(Material.PolylineGlowType, {
  fabric: {
    type: Material.PolylineGlowType,
    uniforms: {
      color: new Color_default(0, 0.5, 1, 1),
      glowPower: 0.25,
      taperPower: 1
    },
    source: PolylineGlowMaterial_default
  },
  translucent: true
});
Material.PolylineOutlineType = "PolylineOutline";
Material._materialCache.addMaterial(Material.PolylineOutlineType, {
  fabric: {
    type: Material.PolylineOutlineType,
    uniforms: {
      color: new Color_default(1, 1, 1, 1),
      outlineColor: new Color_default(1, 0, 0, 1),
      outlineWidth: 1
    },
    source: PolylineOutlineMaterial_default
  },
  translucent: function(material) {
    const uniforms = material.uniforms;
    return uniforms.color.alpha < 1 || uniforms.outlineColor.alpha < 1;
  }
});
Material.ElevationContourType = "ElevationContour";
Material._materialCache.addMaterial(Material.ElevationContourType, {
  fabric: {
    type: Material.ElevationContourType,
    uniforms: {
      spacing: 100,
      color: new Color_default(1, 0, 0, 1),
      width: 1
    },
    source: ElevationContourMaterial_default
  },
  translucent: false
});
Material.ElevationRampType = "ElevationRamp";
Material._materialCache.addMaterial(Material.ElevationRampType, {
  fabric: {
    type: Material.ElevationRampType,
    uniforms: {
      image: Material.DefaultImageId,
      minimumHeight: 0,
      maximumHeight: 1e4
    },
    source: ElevationRampMaterial_default
  },
  translucent: false
});
Material.SlopeRampMaterialType = "SlopeRamp";
Material._materialCache.addMaterial(Material.SlopeRampMaterialType, {
  fabric: {
    type: Material.SlopeRampMaterialType,
    uniforms: {
      image: Material.DefaultImageId
    },
    source: SlopeRampMaterial_default
  },
  translucent: false
});
Material.AspectRampMaterialType = "AspectRamp";
Material._materialCache.addMaterial(Material.AspectRampMaterialType, {
  fabric: {
    type: Material.AspectRampMaterialType,
    uniforms: {
      image: Material.DefaultImageId
    },
    source: AspectRampMaterial_default
  },
  translucent: false
});
Material.ElevationBandType = "ElevationBand";
Material._materialCache.addMaterial(Material.ElevationBandType, {
  fabric: {
    type: Material.ElevationBandType,
    uniforms: {
      heights: Material.DefaultImageId,
      colors: Material.DefaultImageId
    },
    source: ElevationBandMaterial_default
  },
  translucent: true
});
var Material_default = Material;

// node_modules/cesium/Source/Scene/MaterialAppearance.js
function MaterialAppearance(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const translucent = defaultValue_default(options.translucent, true);
  const closed = defaultValue_default(options.closed, false);
  const materialSupport = defaultValue_default(
    options.materialSupport,
    MaterialAppearance.MaterialSupport.TEXTURED
  );
  this.material = defined_default(options.material) ? options.material : Material_default.fromType(Material_default.ColorType);
  this.translucent = translucent;
  this._vertexShaderSource = defaultValue_default(
    options.vertexShaderSource,
    materialSupport.vertexShaderSource
  );
  this._fragmentShaderSource = defaultValue_default(
    options.fragmentShaderSource,
    materialSupport.fragmentShaderSource
  );
  this._renderState = Appearance_default.getDefaultRenderState(
    translucent,
    closed,
    options.renderState
  );
  this._closed = closed;
  this._materialSupport = materialSupport;
  this._vertexFormat = materialSupport.vertexFormat;
  this._flat = defaultValue_default(options.flat, false);
  this._faceForward = defaultValue_default(options.faceForward, !closed);
}
Object.defineProperties(MaterialAppearance.prototype, {
  vertexShaderSource: {
    get: function() {
      return this._vertexShaderSource;
    }
  },
  fragmentShaderSource: {
    get: function() {
      return this._fragmentShaderSource;
    }
  },
  renderState: {
    get: function() {
      return this._renderState;
    }
  },
  closed: {
    get: function() {
      return this._closed;
    }
  },
  materialSupport: {
    get: function() {
      return this._materialSupport;
    }
  },
  vertexFormat: {
    get: function() {
      return this._vertexFormat;
    }
  },
  flat: {
    get: function() {
      return this._flat;
    }
  },
  faceForward: {
    get: function() {
      return this._faceForward;
    }
  }
});
MaterialAppearance.prototype.getFragmentShaderSource = Appearance_default.prototype.getFragmentShaderSource;
MaterialAppearance.prototype.isTranslucent = Appearance_default.prototype.isTranslucent;
MaterialAppearance.prototype.getRenderState = Appearance_default.prototype.getRenderState;
MaterialAppearance.MaterialSupport = {
  BASIC: Object.freeze({
    vertexFormat: VertexFormat_default.POSITION_AND_NORMAL,
    vertexShaderSource: BasicMaterialAppearanceVS_default,
    fragmentShaderSource: BasicMaterialAppearanceFS_default
  }),
  TEXTURED: Object.freeze({
    vertexFormat: VertexFormat_default.POSITION_NORMAL_AND_ST,
    vertexShaderSource: TexturedMaterialAppearanceVS_default,
    fragmentShaderSource: TexturedMaterialAppearanceFS_default
  }),
  ALL: Object.freeze({
    vertexFormat: VertexFormat_default.ALL,
    vertexShaderSource: AllMaterialAppearanceVS_default,
    fragmentShaderSource: AllMaterialAppearanceFS_default
  })
};
var MaterialAppearance_default = MaterialAppearance;

// node_modules/cesium/Source/Shaders/Appearances/PerInstanceColorAppearanceFS.js
var PerInstanceColorAppearanceFS_default = "varying vec3 v_positionEC;\nvarying vec3 v_normalEC;\nvarying vec4 v_color;\n\nvoid main()\n{\n    vec3 positionToEyeEC = -v_positionEC;\n\n    vec3 normalEC = normalize(v_normalEC);\n#ifdef FACE_FORWARD\n    normalEC = faceforward(normalEC, vec3(0.0, 0.0, 1.0), -normalEC);\n#endif\n\n    vec4 color = czm_gammaCorrect(v_color);\n\n    czm_materialInput materialInput;\n    materialInput.normalEC = normalEC;\n    materialInput.positionToEyeEC = positionToEyeEC;\n    czm_material material = czm_getDefaultMaterial(materialInput);\n    material.diffuse = color.rgb;\n    material.alpha = color.a;\n\n    gl_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n}\n";

// node_modules/cesium/Source/Shaders/Appearances/PerInstanceColorAppearanceVS.js
var PerInstanceColorAppearanceVS_default = "attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute vec3 normal;\nattribute vec4 color;\nattribute float batchId;\n\nvarying vec3 v_positionEC;\nvarying vec3 v_normalEC;\nvarying vec4 v_color;\n\nvoid main()\n{\n    vec4 p = czm_computePosition();\n\n    v_positionEC = (czm_modelViewRelativeToEye * p).xyz;      // position in eye coordinates\n    v_normalEC = czm_normal * normal;                         // normal in eye coordinates\n    v_color = color;\n\n    gl_Position = czm_modelViewProjectionRelativeToEye * p;\n}\n";

// node_modules/cesium/Source/Shaders/Appearances/PerInstanceFlatColorAppearanceFS.js
var PerInstanceFlatColorAppearanceFS_default = "varying vec4 v_color;\n\nvoid main()\n{\n    gl_FragColor = czm_gammaCorrect(v_color);\n}\n";

// node_modules/cesium/Source/Shaders/Appearances/PerInstanceFlatColorAppearanceVS.js
var PerInstanceFlatColorAppearanceVS_default = "attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute vec4 color;\nattribute float batchId;\n\nvarying vec4 v_color;\n\nvoid main()\n{\n    vec4 p = czm_computePosition();\n\n    v_color = color;\n\n    gl_Position = czm_modelViewProjectionRelativeToEye * p;\n}\n";

// node_modules/cesium/Source/Scene/PerInstanceColorAppearance.js
function PerInstanceColorAppearance(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const translucent = defaultValue_default(options.translucent, true);
  const closed = defaultValue_default(options.closed, false);
  const flat = defaultValue_default(options.flat, false);
  const vs = flat ? PerInstanceFlatColorAppearanceVS_default : PerInstanceColorAppearanceVS_default;
  const fs = flat ? PerInstanceFlatColorAppearanceFS_default : PerInstanceColorAppearanceFS_default;
  const vertexFormat = flat ? PerInstanceColorAppearance.FLAT_VERTEX_FORMAT : PerInstanceColorAppearance.VERTEX_FORMAT;
  this.material = void 0;
  this.translucent = translucent;
  this._vertexShaderSource = defaultValue_default(options.vertexShaderSource, vs);
  this._fragmentShaderSource = defaultValue_default(options.fragmentShaderSource, fs);
  this._renderState = Appearance_default.getDefaultRenderState(
    translucent,
    closed,
    options.renderState
  );
  this._closed = closed;
  this._vertexFormat = vertexFormat;
  this._flat = flat;
  this._faceForward = defaultValue_default(options.faceForward, !closed);
}
Object.defineProperties(PerInstanceColorAppearance.prototype, {
  vertexShaderSource: {
    get: function() {
      return this._vertexShaderSource;
    }
  },
  fragmentShaderSource: {
    get: function() {
      return this._fragmentShaderSource;
    }
  },
  renderState: {
    get: function() {
      return this._renderState;
    }
  },
  closed: {
    get: function() {
      return this._closed;
    }
  },
  vertexFormat: {
    get: function() {
      return this._vertexFormat;
    }
  },
  flat: {
    get: function() {
      return this._flat;
    }
  },
  faceForward: {
    get: function() {
      return this._faceForward;
    }
  }
});
PerInstanceColorAppearance.VERTEX_FORMAT = VertexFormat_default.POSITION_AND_NORMAL;
PerInstanceColorAppearance.FLAT_VERTEX_FORMAT = VertexFormat_default.POSITION_ONLY;
PerInstanceColorAppearance.prototype.getFragmentShaderSource = Appearance_default.prototype.getFragmentShaderSource;
PerInstanceColorAppearance.prototype.isTranslucent = Appearance_default.prototype.isTranslucent;
PerInstanceColorAppearance.prototype.getRenderState = Appearance_default.prototype.getRenderState;
var PerInstanceColorAppearance_default = PerInstanceColorAppearance;

// node_modules/cesium/Source/DataSources/ColorMaterialProperty.js
function ColorMaterialProperty(color) {
  this._definitionChanged = new Event_default();
  this._color = void 0;
  this._colorSubscription = void 0;
  this.color = color;
}
Object.defineProperties(ColorMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._color);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  color: createPropertyDescriptor_default("color")
});
ColorMaterialProperty.prototype.getType = function(time) {
  return "Color";
};
ColorMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = {};
  }
  result.color = Property_default.getValueOrClonedDefault(
    this._color,
    time,
    Color_default.WHITE,
    result.color
  );
  return result;
};
ColorMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof ColorMaterialProperty && Property_default.equals(this._color, other._color);
};
var ColorMaterialProperty_default = ColorMaterialProperty;

// node_modules/cesium/Source/Renderer/DrawCommand.js
var Flags = {
  CULL: 1,
  OCCLUDE: 2,
  EXECUTE_IN_CLOSEST_FRUSTUM: 4,
  DEBUG_SHOW_BOUNDING_VOLUME: 8,
  CAST_SHADOWS: 16,
  RECEIVE_SHADOWS: 32,
  PICK_ONLY: 64,
  DEPTH_FOR_TRANSLUCENT_CLASSIFICATION: 128
};
function DrawCommand(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._boundingVolume = options.boundingVolume;
  this._orientedBoundingBox = options.orientedBoundingBox;
  this._modelMatrix = options.modelMatrix;
  this._primitiveType = defaultValue_default(
    options.primitiveType,
    PrimitiveType_default.TRIANGLES
  );
  this._vertexArray = options.vertexArray;
  this._count = options.count;
  this._offset = defaultValue_default(options.offset, 0);
  this._instanceCount = defaultValue_default(options.instanceCount, 0);
  this._shaderProgram = options.shaderProgram;
  this._uniformMap = options.uniformMap;
  this._renderState = options.renderState;
  this._framebuffer = options.framebuffer;
  this._pass = options.pass;
  this._owner = options.owner;
  this._debugOverlappingFrustums = 0;
  this._pickId = options.pickId;
  this._flags = 0;
  this.cull = defaultValue_default(options.cull, true);
  this.occlude = defaultValue_default(options.occlude, true);
  this.executeInClosestFrustum = defaultValue_default(
    options.executeInClosestFrustum,
    false
  );
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this.castShadows = defaultValue_default(options.castShadows, false);
  this.receiveShadows = defaultValue_default(options.receiveShadows, false);
  this.pickOnly = defaultValue_default(options.pickOnly, false);
  this.depthForTranslucentClassification = defaultValue_default(
    options.depthForTranslucentClassification,
    false
  );
  this.dirty = true;
  this.lastDirtyTime = 0;
  this.derivedCommands = {};
}
function hasFlag(command, flag) {
  return (command._flags & flag) === flag;
}
function setFlag(command, flag, value) {
  if (value) {
    command._flags |= flag;
  } else {
    command._flags &= ~flag;
  }
}
Object.defineProperties(DrawCommand.prototype, {
  boundingVolume: {
    get: function() {
      return this._boundingVolume;
    },
    set: function(value) {
      if (this._boundingVolume !== value) {
        this._boundingVolume = value;
        this.dirty = true;
      }
    }
  },
  orientedBoundingBox: {
    get: function() {
      return this._orientedBoundingBox;
    },
    set: function(value) {
      if (this._orientedBoundingBox !== value) {
        this._orientedBoundingBox = value;
        this.dirty = true;
      }
    }
  },
  cull: {
    get: function() {
      return hasFlag(this, Flags.CULL);
    },
    set: function(value) {
      if (hasFlag(this, Flags.CULL) !== value) {
        setFlag(this, Flags.CULL, value);
        this.dirty = true;
      }
    }
  },
  occlude: {
    get: function() {
      return hasFlag(this, Flags.OCCLUDE);
    },
    set: function(value) {
      if (hasFlag(this, Flags.OCCLUDE) !== value) {
        setFlag(this, Flags.OCCLUDE, value);
        this.dirty = true;
      }
    }
  },
  modelMatrix: {
    get: function() {
      return this._modelMatrix;
    },
    set: function(value) {
      if (this._modelMatrix !== value) {
        this._modelMatrix = value;
        this.dirty = true;
      }
    }
  },
  primitiveType: {
    get: function() {
      return this._primitiveType;
    },
    set: function(value) {
      if (this._primitiveType !== value) {
        this._primitiveType = value;
        this.dirty = true;
      }
    }
  },
  vertexArray: {
    get: function() {
      return this._vertexArray;
    },
    set: function(value) {
      if (this._vertexArray !== value) {
        this._vertexArray = value;
        this.dirty = true;
      }
    }
  },
  count: {
    get: function() {
      return this._count;
    },
    set: function(value) {
      if (this._count !== value) {
        this._count = value;
        this.dirty = true;
      }
    }
  },
  offset: {
    get: function() {
      return this._offset;
    },
    set: function(value) {
      if (this._offset !== value) {
        this._offset = value;
        this.dirty = true;
      }
    }
  },
  instanceCount: {
    get: function() {
      return this._instanceCount;
    },
    set: function(value) {
      if (this._instanceCount !== value) {
        this._instanceCount = value;
        this.dirty = true;
      }
    }
  },
  shaderProgram: {
    get: function() {
      return this._shaderProgram;
    },
    set: function(value) {
      if (this._shaderProgram !== value) {
        this._shaderProgram = value;
        this.dirty = true;
      }
    }
  },
  castShadows: {
    get: function() {
      return hasFlag(this, Flags.CAST_SHADOWS);
    },
    set: function(value) {
      if (hasFlag(this, Flags.CAST_SHADOWS) !== value) {
        setFlag(this, Flags.CAST_SHADOWS, value);
        this.dirty = true;
      }
    }
  },
  receiveShadows: {
    get: function() {
      return hasFlag(this, Flags.RECEIVE_SHADOWS);
    },
    set: function(value) {
      if (hasFlag(this, Flags.RECEIVE_SHADOWS) !== value) {
        setFlag(this, Flags.RECEIVE_SHADOWS, value);
        this.dirty = true;
      }
    }
  },
  uniformMap: {
    get: function() {
      return this._uniformMap;
    },
    set: function(value) {
      if (this._uniformMap !== value) {
        this._uniformMap = value;
        this.dirty = true;
      }
    }
  },
  renderState: {
    get: function() {
      return this._renderState;
    },
    set: function(value) {
      if (this._renderState !== value) {
        this._renderState = value;
        this.dirty = true;
      }
    }
  },
  framebuffer: {
    get: function() {
      return this._framebuffer;
    },
    set: function(value) {
      if (this._framebuffer !== value) {
        this._framebuffer = value;
        this.dirty = true;
      }
    }
  },
  pass: {
    get: function() {
      return this._pass;
    },
    set: function(value) {
      if (this._pass !== value) {
        this._pass = value;
        this.dirty = true;
      }
    }
  },
  executeInClosestFrustum: {
    get: function() {
      return hasFlag(this, Flags.EXECUTE_IN_CLOSEST_FRUSTUM);
    },
    set: function(value) {
      if (hasFlag(this, Flags.EXECUTE_IN_CLOSEST_FRUSTUM) !== value) {
        setFlag(this, Flags.EXECUTE_IN_CLOSEST_FRUSTUM, value);
        this.dirty = true;
      }
    }
  },
  owner: {
    get: function() {
      return this._owner;
    },
    set: function(value) {
      if (this._owner !== value) {
        this._owner = value;
        this.dirty = true;
      }
    }
  },
  debugShowBoundingVolume: {
    get: function() {
      return hasFlag(this, Flags.DEBUG_SHOW_BOUNDING_VOLUME);
    },
    set: function(value) {
      if (hasFlag(this, Flags.DEBUG_SHOW_BOUNDING_VOLUME) !== value) {
        setFlag(this, Flags.DEBUG_SHOW_BOUNDING_VOLUME, value);
        this.dirty = true;
      }
    }
  },
  debugOverlappingFrustums: {
    get: function() {
      return this._debugOverlappingFrustums;
    },
    set: function(value) {
      if (this._debugOverlappingFrustums !== value) {
        this._debugOverlappingFrustums = value;
        this.dirty = true;
      }
    }
  },
  pickId: {
    get: function() {
      return this._pickId;
    },
    set: function(value) {
      if (this._pickId !== value) {
        this._pickId = value;
        this.dirty = true;
      }
    }
  },
  pickOnly: {
    get: function() {
      return hasFlag(this, Flags.PICK_ONLY);
    },
    set: function(value) {
      if (hasFlag(this, Flags.PICK_ONLY) !== value) {
        setFlag(this, Flags.PICK_ONLY, value);
        this.dirty = true;
      }
    }
  },
  depthForTranslucentClassification: {
    get: function() {
      return hasFlag(this, Flags.DEPTH_FOR_TRANSLUCENT_CLASSIFICATION);
    },
    set: function(value) {
      if (hasFlag(this, Flags.DEPTH_FOR_TRANSLUCENT_CLASSIFICATION) !== value) {
        setFlag(this, Flags.DEPTH_FOR_TRANSLUCENT_CLASSIFICATION, value);
        this.dirty = true;
      }
    }
  }
});
DrawCommand.shallowClone = function(command, result) {
  if (!defined_default(command)) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new DrawCommand();
  }
  result._boundingVolume = command._boundingVolume;
  result._orientedBoundingBox = command._orientedBoundingBox;
  result._modelMatrix = command._modelMatrix;
  result._primitiveType = command._primitiveType;
  result._vertexArray = command._vertexArray;
  result._count = command._count;
  result._offset = command._offset;
  result._instanceCount = command._instanceCount;
  result._shaderProgram = command._shaderProgram;
  result._uniformMap = command._uniformMap;
  result._renderState = command._renderState;
  result._framebuffer = command._framebuffer;
  result._pass = command._pass;
  result._owner = command._owner;
  result._debugOverlappingFrustums = command._debugOverlappingFrustums;
  result._pickId = command._pickId;
  result._flags = command._flags;
  result.dirty = true;
  result.lastDirtyTime = 0;
  return result;
};
DrawCommand.prototype.execute = function(context, passState) {
  context.draw(this, passState);
};
var DrawCommand_default = DrawCommand;

// node_modules/cesium/Source/Renderer/Pass.js
var Pass = {
  ENVIRONMENT: 0,
  COMPUTE: 1,
  GLOBE: 2,
  TERRAIN_CLASSIFICATION: 3,
  CESIUM_3D_TILE: 4,
  CESIUM_3D_TILE_CLASSIFICATION: 5,
  CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW: 6,
  OPAQUE: 7,
  TRANSLUCENT: 8,
  OVERLAY: 9,
  NUMBER_OF_PASSES: 10
};
var Pass_default = Object.freeze(Pass);

// node_modules/cesium/Source/Renderer/freezeRenderState.js
function freezeRenderState(renderState) {
  if (typeof renderState !== "object" || renderState === null) {
    return renderState;
  }
  let propName;
  const propNames = Object.keys(renderState);
  for (let i2 = 0; i2 < propNames.length; i2++) {
    propName = propNames[i2];
    if (renderState.hasOwnProperty(propName) && propName !== "_applyFunctions") {
      renderState[propName] = freezeRenderState(renderState[propName]);
    }
  }
  return Object.freeze(renderState);
}
var freezeRenderState_default = freezeRenderState;

// node_modules/cesium/Source/Renderer/RenderState.js
function validateBlendEquation(blendEquation) {
  return blendEquation === WebGLConstants_default.FUNC_ADD || blendEquation === WebGLConstants_default.FUNC_SUBTRACT || blendEquation === WebGLConstants_default.FUNC_REVERSE_SUBTRACT || blendEquation === WebGLConstants_default.MIN || blendEquation === WebGLConstants_default.MAX;
}
function validateBlendFunction(blendFunction) {
  return blendFunction === WebGLConstants_default.ZERO || blendFunction === WebGLConstants_default.ONE || blendFunction === WebGLConstants_default.SRC_COLOR || blendFunction === WebGLConstants_default.ONE_MINUS_SRC_COLOR || blendFunction === WebGLConstants_default.DST_COLOR || blendFunction === WebGLConstants_default.ONE_MINUS_DST_COLOR || blendFunction === WebGLConstants_default.SRC_ALPHA || blendFunction === WebGLConstants_default.ONE_MINUS_SRC_ALPHA || blendFunction === WebGLConstants_default.DST_ALPHA || blendFunction === WebGLConstants_default.ONE_MINUS_DST_ALPHA || blendFunction === WebGLConstants_default.CONSTANT_COLOR || blendFunction === WebGLConstants_default.ONE_MINUS_CONSTANT_COLOR || blendFunction === WebGLConstants_default.CONSTANT_ALPHA || blendFunction === WebGLConstants_default.ONE_MINUS_CONSTANT_ALPHA || blendFunction === WebGLConstants_default.SRC_ALPHA_SATURATE;
}
function validateCullFace(cullFace) {
  return cullFace === WebGLConstants_default.FRONT || cullFace === WebGLConstants_default.BACK || cullFace === WebGLConstants_default.FRONT_AND_BACK;
}
function validateDepthFunction(depthFunction) {
  return depthFunction === WebGLConstants_default.NEVER || depthFunction === WebGLConstants_default.LESS || depthFunction === WebGLConstants_default.EQUAL || depthFunction === WebGLConstants_default.LEQUAL || depthFunction === WebGLConstants_default.GREATER || depthFunction === WebGLConstants_default.NOTEQUAL || depthFunction === WebGLConstants_default.GEQUAL || depthFunction === WebGLConstants_default.ALWAYS;
}
function validateStencilFunction(stencilFunction) {
  return stencilFunction === WebGLConstants_default.NEVER || stencilFunction === WebGLConstants_default.LESS || stencilFunction === WebGLConstants_default.EQUAL || stencilFunction === WebGLConstants_default.LEQUAL || stencilFunction === WebGLConstants_default.GREATER || stencilFunction === WebGLConstants_default.NOTEQUAL || stencilFunction === WebGLConstants_default.GEQUAL || stencilFunction === WebGLConstants_default.ALWAYS;
}
function validateStencilOperation(stencilOperation) {
  return stencilOperation === WebGLConstants_default.ZERO || stencilOperation === WebGLConstants_default.KEEP || stencilOperation === WebGLConstants_default.REPLACE || stencilOperation === WebGLConstants_default.INCR || stencilOperation === WebGLConstants_default.DECR || stencilOperation === WebGLConstants_default.INVERT || stencilOperation === WebGLConstants_default.INCR_WRAP || stencilOperation === WebGLConstants_default.DECR_WRAP;
}
function RenderState(renderState) {
  const rs = defaultValue_default(renderState, defaultValue_default.EMPTY_OBJECT);
  const cull = defaultValue_default(rs.cull, defaultValue_default.EMPTY_OBJECT);
  const polygonOffset = defaultValue_default(
    rs.polygonOffset,
    defaultValue_default.EMPTY_OBJECT
  );
  const scissorTest = defaultValue_default(rs.scissorTest, defaultValue_default.EMPTY_OBJECT);
  const scissorTestRectangle = defaultValue_default(
    scissorTest.rectangle,
    defaultValue_default.EMPTY_OBJECT
  );
  const depthRange = defaultValue_default(rs.depthRange, defaultValue_default.EMPTY_OBJECT);
  const depthTest = defaultValue_default(rs.depthTest, defaultValue_default.EMPTY_OBJECT);
  const colorMask = defaultValue_default(rs.colorMask, defaultValue_default.EMPTY_OBJECT);
  const blending = defaultValue_default(rs.blending, defaultValue_default.EMPTY_OBJECT);
  const blendingColor = defaultValue_default(blending.color, defaultValue_default.EMPTY_OBJECT);
  const stencilTest = defaultValue_default(rs.stencilTest, defaultValue_default.EMPTY_OBJECT);
  const stencilTestFrontOperation = defaultValue_default(
    stencilTest.frontOperation,
    defaultValue_default.EMPTY_OBJECT
  );
  const stencilTestBackOperation = defaultValue_default(
    stencilTest.backOperation,
    defaultValue_default.EMPTY_OBJECT
  );
  const sampleCoverage = defaultValue_default(
    rs.sampleCoverage,
    defaultValue_default.EMPTY_OBJECT
  );
  const viewport = rs.viewport;
  this.frontFace = defaultValue_default(rs.frontFace, WindingOrder_default.COUNTER_CLOCKWISE);
  this.cull = {
    enabled: defaultValue_default(cull.enabled, false),
    face: defaultValue_default(cull.face, WebGLConstants_default.BACK)
  };
  this.lineWidth = defaultValue_default(rs.lineWidth, 1);
  this.polygonOffset = {
    enabled: defaultValue_default(polygonOffset.enabled, false),
    factor: defaultValue_default(polygonOffset.factor, 0),
    units: defaultValue_default(polygonOffset.units, 0)
  };
  this.scissorTest = {
    enabled: defaultValue_default(scissorTest.enabled, false),
    rectangle: BoundingRectangle_default.clone(scissorTestRectangle)
  };
  this.depthRange = {
    near: defaultValue_default(depthRange.near, 0),
    far: defaultValue_default(depthRange.far, 1)
  };
  this.depthTest = {
    enabled: defaultValue_default(depthTest.enabled, false),
    func: defaultValue_default(depthTest.func, WebGLConstants_default.LESS)
  };
  this.colorMask = {
    red: defaultValue_default(colorMask.red, true),
    green: defaultValue_default(colorMask.green, true),
    blue: defaultValue_default(colorMask.blue, true),
    alpha: defaultValue_default(colorMask.alpha, true)
  };
  this.depthMask = defaultValue_default(rs.depthMask, true);
  this.stencilMask = defaultValue_default(rs.stencilMask, ~0);
  this.blending = {
    enabled: defaultValue_default(blending.enabled, false),
    color: new Color_default(
      defaultValue_default(blendingColor.red, 0),
      defaultValue_default(blendingColor.green, 0),
      defaultValue_default(blendingColor.blue, 0),
      defaultValue_default(blendingColor.alpha, 0)
    ),
    equationRgb: defaultValue_default(blending.equationRgb, WebGLConstants_default.FUNC_ADD),
    equationAlpha: defaultValue_default(
      blending.equationAlpha,
      WebGLConstants_default.FUNC_ADD
    ),
    functionSourceRgb: defaultValue_default(
      blending.functionSourceRgb,
      WebGLConstants_default.ONE
    ),
    functionSourceAlpha: defaultValue_default(
      blending.functionSourceAlpha,
      WebGLConstants_default.ONE
    ),
    functionDestinationRgb: defaultValue_default(
      blending.functionDestinationRgb,
      WebGLConstants_default.ZERO
    ),
    functionDestinationAlpha: defaultValue_default(
      blending.functionDestinationAlpha,
      WebGLConstants_default.ZERO
    )
  };
  this.stencilTest = {
    enabled: defaultValue_default(stencilTest.enabled, false),
    frontFunction: defaultValue_default(
      stencilTest.frontFunction,
      WebGLConstants_default.ALWAYS
    ),
    backFunction: defaultValue_default(stencilTest.backFunction, WebGLConstants_default.ALWAYS),
    reference: defaultValue_default(stencilTest.reference, 0),
    mask: defaultValue_default(stencilTest.mask, ~0),
    frontOperation: {
      fail: defaultValue_default(stencilTestFrontOperation.fail, WebGLConstants_default.KEEP),
      zFail: defaultValue_default(stencilTestFrontOperation.zFail, WebGLConstants_default.KEEP),
      zPass: defaultValue_default(stencilTestFrontOperation.zPass, WebGLConstants_default.KEEP)
    },
    backOperation: {
      fail: defaultValue_default(stencilTestBackOperation.fail, WebGLConstants_default.KEEP),
      zFail: defaultValue_default(stencilTestBackOperation.zFail, WebGLConstants_default.KEEP),
      zPass: defaultValue_default(stencilTestBackOperation.zPass, WebGLConstants_default.KEEP)
    }
  };
  this.sampleCoverage = {
    enabled: defaultValue_default(sampleCoverage.enabled, false),
    value: defaultValue_default(sampleCoverage.value, 1),
    invert: defaultValue_default(sampleCoverage.invert, false)
  };
  this.viewport = defined_default(viewport) ? new BoundingRectangle_default(
    viewport.x,
    viewport.y,
    viewport.width,
    viewport.height
  ) : void 0;
  if (this.lineWidth < ContextLimits_default.minimumAliasedLineWidth || this.lineWidth > ContextLimits_default.maximumAliasedLineWidth) {
    throw new DeveloperError_default(
      "renderState.lineWidth is out of range.  Check minimumAliasedLineWidth and maximumAliasedLineWidth."
    );
  }
  if (!WindingOrder_default.validate(this.frontFace)) {
    throw new DeveloperError_default("Invalid renderState.frontFace.");
  }
  if (!validateCullFace(this.cull.face)) {
    throw new DeveloperError_default("Invalid renderState.cull.face.");
  }
  if (this.scissorTest.rectangle.width < 0 || this.scissorTest.rectangle.height < 0) {
    throw new DeveloperError_default(
      "renderState.scissorTest.rectangle.width and renderState.scissorTest.rectangle.height must be greater than or equal to zero."
    );
  }
  if (this.depthRange.near > this.depthRange.far) {
    throw new DeveloperError_default(
      "renderState.depthRange.near can not be greater than renderState.depthRange.far."
    );
  }
  if (this.depthRange.near < 0) {
    throw new DeveloperError_default(
      "renderState.depthRange.near must be greater than or equal to zero."
    );
  }
  if (this.depthRange.far > 1) {
    throw new DeveloperError_default(
      "renderState.depthRange.far must be less than or equal to one."
    );
  }
  if (!validateDepthFunction(this.depthTest.func)) {
    throw new DeveloperError_default("Invalid renderState.depthTest.func.");
  }
  if (this.blending.color.red < 0 || this.blending.color.red > 1 || this.blending.color.green < 0 || this.blending.color.green > 1 || this.blending.color.blue < 0 || this.blending.color.blue > 1 || this.blending.color.alpha < 0 || this.blending.color.alpha > 1) {
    throw new DeveloperError_default(
      "renderState.blending.color components must be greater than or equal to zero and less than or equal to one."
    );
  }
  if (!validateBlendEquation(this.blending.equationRgb)) {
    throw new DeveloperError_default("Invalid renderState.blending.equationRgb.");
  }
  if (!validateBlendEquation(this.blending.equationAlpha)) {
    throw new DeveloperError_default("Invalid renderState.blending.equationAlpha.");
  }
  if (!validateBlendFunction(this.blending.functionSourceRgb)) {
    throw new DeveloperError_default("Invalid renderState.blending.functionSourceRgb.");
  }
  if (!validateBlendFunction(this.blending.functionSourceAlpha)) {
    throw new DeveloperError_default(
      "Invalid renderState.blending.functionSourceAlpha."
    );
  }
  if (!validateBlendFunction(this.blending.functionDestinationRgb)) {
    throw new DeveloperError_default(
      "Invalid renderState.blending.functionDestinationRgb."
    );
  }
  if (!validateBlendFunction(this.blending.functionDestinationAlpha)) {
    throw new DeveloperError_default(
      "Invalid renderState.blending.functionDestinationAlpha."
    );
  }
  if (!validateStencilFunction(this.stencilTest.frontFunction)) {
    throw new DeveloperError_default("Invalid renderState.stencilTest.frontFunction.");
  }
  if (!validateStencilFunction(this.stencilTest.backFunction)) {
    throw new DeveloperError_default("Invalid renderState.stencilTest.backFunction.");
  }
  if (!validateStencilOperation(this.stencilTest.frontOperation.fail)) {
    throw new DeveloperError_default(
      "Invalid renderState.stencilTest.frontOperation.fail."
    );
  }
  if (!validateStencilOperation(this.stencilTest.frontOperation.zFail)) {
    throw new DeveloperError_default(
      "Invalid renderState.stencilTest.frontOperation.zFail."
    );
  }
  if (!validateStencilOperation(this.stencilTest.frontOperation.zPass)) {
    throw new DeveloperError_default(
      "Invalid renderState.stencilTest.frontOperation.zPass."
    );
  }
  if (!validateStencilOperation(this.stencilTest.backOperation.fail)) {
    throw new DeveloperError_default(
      "Invalid renderState.stencilTest.backOperation.fail."
    );
  }
  if (!validateStencilOperation(this.stencilTest.backOperation.zFail)) {
    throw new DeveloperError_default(
      "Invalid renderState.stencilTest.backOperation.zFail."
    );
  }
  if (!validateStencilOperation(this.stencilTest.backOperation.zPass)) {
    throw new DeveloperError_default(
      "Invalid renderState.stencilTest.backOperation.zPass."
    );
  }
  if (defined_default(this.viewport)) {
    if (this.viewport.width < 0) {
      throw new DeveloperError_default(
        "renderState.viewport.width must be greater than or equal to zero."
      );
    }
    if (this.viewport.height < 0) {
      throw new DeveloperError_default(
        "renderState.viewport.height must be greater than or equal to zero."
      );
    }
    if (this.viewport.width > ContextLimits_default.maximumViewportWidth) {
      throw new DeveloperError_default(
        `renderState.viewport.width must be less than or equal to the maximum viewport width (${ContextLimits_default.maximumViewportWidth.toString()}).  Check maximumViewportWidth.`
      );
    }
    if (this.viewport.height > ContextLimits_default.maximumViewportHeight) {
      throw new DeveloperError_default(
        `renderState.viewport.height must be less than or equal to the maximum viewport height (${ContextLimits_default.maximumViewportHeight.toString()}).  Check maximumViewportHeight.`
      );
    }
  }
  this.id = 0;
  this._applyFunctions = [];
}
var nextRenderStateId = 0;
var renderStateCache = {};
RenderState.fromCache = function(renderState) {
  const partialKey = JSON.stringify(renderState);
  let cachedState = renderStateCache[partialKey];
  if (defined_default(cachedState)) {
    ++cachedState.referenceCount;
    return cachedState.state;
  }
  let states = new RenderState(renderState);
  const fullKey = JSON.stringify(states);
  cachedState = renderStateCache[fullKey];
  if (!defined_default(cachedState)) {
    states.id = nextRenderStateId++;
    states = freezeRenderState_default(states);
    cachedState = {
      referenceCount: 0,
      state: states
    };
    renderStateCache[fullKey] = cachedState;
  }
  ++cachedState.referenceCount;
  renderStateCache[partialKey] = {
    referenceCount: 1,
    state: cachedState.state
  };
  return cachedState.state;
};
RenderState.removeFromCache = function(renderState) {
  const states = new RenderState(renderState);
  const fullKey = JSON.stringify(states);
  const fullCachedState = renderStateCache[fullKey];
  const partialKey = JSON.stringify(renderState);
  const cachedState = renderStateCache[partialKey];
  if (defined_default(cachedState)) {
    --cachedState.referenceCount;
    if (cachedState.referenceCount === 0) {
      delete renderStateCache[partialKey];
      if (defined_default(fullCachedState)) {
        --fullCachedState.referenceCount;
      }
    }
  }
  if (defined_default(fullCachedState) && fullCachedState.referenceCount === 0) {
    delete renderStateCache[fullKey];
  }
};
RenderState.getCache = function() {
  return renderStateCache;
};
RenderState.clearCache = function() {
  renderStateCache = {};
};
function enableOrDisable(gl, glEnum, enable) {
  if (enable) {
    gl.enable(glEnum);
  } else {
    gl.disable(glEnum);
  }
}
function applyFrontFace(gl, renderState) {
  gl.frontFace(renderState.frontFace);
}
function applyCull(gl, renderState) {
  const cull = renderState.cull;
  const enabled = cull.enabled;
  enableOrDisable(gl, gl.CULL_FACE, enabled);
  if (enabled) {
    gl.cullFace(cull.face);
  }
}
function applyLineWidth(gl, renderState) {
  gl.lineWidth(renderState.lineWidth);
}
function applyPolygonOffset(gl, renderState) {
  const polygonOffset = renderState.polygonOffset;
  const enabled = polygonOffset.enabled;
  enableOrDisable(gl, gl.POLYGON_OFFSET_FILL, enabled);
  if (enabled) {
    gl.polygonOffset(polygonOffset.factor, polygonOffset.units);
  }
}
function applyScissorTest(gl, renderState, passState) {
  const scissorTest = renderState.scissorTest;
  const enabled = defined_default(passState.scissorTest) ? passState.scissorTest.enabled : scissorTest.enabled;
  enableOrDisable(gl, gl.SCISSOR_TEST, enabled);
  if (enabled) {
    const rectangle = defined_default(passState.scissorTest) ? passState.scissorTest.rectangle : scissorTest.rectangle;
    gl.scissor(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
  }
}
function applyDepthRange(gl, renderState) {
  const depthRange = renderState.depthRange;
  gl.depthRange(depthRange.near, depthRange.far);
}
function applyDepthTest(gl, renderState) {
  const depthTest = renderState.depthTest;
  const enabled = depthTest.enabled;
  enableOrDisable(gl, gl.DEPTH_TEST, enabled);
  if (enabled) {
    gl.depthFunc(depthTest.func);
  }
}
function applyColorMask(gl, renderState) {
  const colorMask = renderState.colorMask;
  gl.colorMask(colorMask.red, colorMask.green, colorMask.blue, colorMask.alpha);
}
function applyDepthMask(gl, renderState) {
  gl.depthMask(renderState.depthMask);
}
function applyStencilMask(gl, renderState) {
  gl.stencilMask(renderState.stencilMask);
}
function applyBlendingColor(gl, color) {
  gl.blendColor(color.red, color.green, color.blue, color.alpha);
}
function applyBlending(gl, renderState, passState) {
  const blending = renderState.blending;
  const enabled = defined_default(passState.blendingEnabled) ? passState.blendingEnabled : blending.enabled;
  enableOrDisable(gl, gl.BLEND, enabled);
  if (enabled) {
    applyBlendingColor(gl, blending.color);
    gl.blendEquationSeparate(blending.equationRgb, blending.equationAlpha);
    gl.blendFuncSeparate(
      blending.functionSourceRgb,
      blending.functionDestinationRgb,
      blending.functionSourceAlpha,
      blending.functionDestinationAlpha
    );
  }
}
function applyStencilTest(gl, renderState) {
  const stencilTest = renderState.stencilTest;
  const enabled = stencilTest.enabled;
  enableOrDisable(gl, gl.STENCIL_TEST, enabled);
  if (enabled) {
    const frontFunction = stencilTest.frontFunction;
    const backFunction = stencilTest.backFunction;
    const reference = stencilTest.reference;
    const mask = stencilTest.mask;
    gl.stencilFunc(frontFunction, reference, mask);
    gl.stencilFuncSeparate(gl.BACK, backFunction, reference, mask);
    gl.stencilFuncSeparate(gl.FRONT, frontFunction, reference, mask);
    const frontOperation = stencilTest.frontOperation;
    const frontOperationFail = frontOperation.fail;
    const frontOperationZFail = frontOperation.zFail;
    const frontOperationZPass = frontOperation.zPass;
    gl.stencilOpSeparate(
      gl.FRONT,
      frontOperationFail,
      frontOperationZFail,
      frontOperationZPass
    );
    const backOperation = stencilTest.backOperation;
    const backOperationFail = backOperation.fail;
    const backOperationZFail = backOperation.zFail;
    const backOperationZPass = backOperation.zPass;
    gl.stencilOpSeparate(
      gl.BACK,
      backOperationFail,
      backOperationZFail,
      backOperationZPass
    );
  }
}
function applySampleCoverage(gl, renderState) {
  const sampleCoverage = renderState.sampleCoverage;
  const enabled = sampleCoverage.enabled;
  enableOrDisable(gl, gl.SAMPLE_COVERAGE, enabled);
  if (enabled) {
    gl.sampleCoverage(sampleCoverage.value, sampleCoverage.invert);
  }
}
var scratchViewport = new BoundingRectangle_default();
function applyViewport(gl, renderState, passState) {
  let viewport = defaultValue_default(renderState.viewport, passState.viewport);
  if (!defined_default(viewport)) {
    viewport = scratchViewport;
    viewport.width = passState.context.drawingBufferWidth;
    viewport.height = passState.context.drawingBufferHeight;
  }
  passState.context.uniformState.viewport = viewport;
  gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
}
RenderState.apply = function(gl, renderState, passState) {
  applyFrontFace(gl, renderState);
  applyCull(gl, renderState);
  applyLineWidth(gl, renderState);
  applyPolygonOffset(gl, renderState);
  applyDepthRange(gl, renderState);
  applyDepthTest(gl, renderState);
  applyColorMask(gl, renderState);
  applyDepthMask(gl, renderState);
  applyStencilMask(gl, renderState);
  applyStencilTest(gl, renderState);
  applySampleCoverage(gl, renderState);
  applyScissorTest(gl, renderState, passState);
  applyBlending(gl, renderState, passState);
  applyViewport(gl, renderState, passState);
};
function createFuncs(previousState, nextState) {
  const funcs = [];
  if (previousState.frontFace !== nextState.frontFace) {
    funcs.push(applyFrontFace);
  }
  if (previousState.cull.enabled !== nextState.cull.enabled || previousState.cull.face !== nextState.cull.face) {
    funcs.push(applyCull);
  }
  if (previousState.lineWidth !== nextState.lineWidth) {
    funcs.push(applyLineWidth);
  }
  if (previousState.polygonOffset.enabled !== nextState.polygonOffset.enabled || previousState.polygonOffset.factor !== nextState.polygonOffset.factor || previousState.polygonOffset.units !== nextState.polygonOffset.units) {
    funcs.push(applyPolygonOffset);
  }
  if (previousState.depthRange.near !== nextState.depthRange.near || previousState.depthRange.far !== nextState.depthRange.far) {
    funcs.push(applyDepthRange);
  }
  if (previousState.depthTest.enabled !== nextState.depthTest.enabled || previousState.depthTest.func !== nextState.depthTest.func) {
    funcs.push(applyDepthTest);
  }
  if (previousState.colorMask.red !== nextState.colorMask.red || previousState.colorMask.green !== nextState.colorMask.green || previousState.colorMask.blue !== nextState.colorMask.blue || previousState.colorMask.alpha !== nextState.colorMask.alpha) {
    funcs.push(applyColorMask);
  }
  if (previousState.depthMask !== nextState.depthMask) {
    funcs.push(applyDepthMask);
  }
  if (previousState.stencilMask !== nextState.stencilMask) {
    funcs.push(applyStencilMask);
  }
  if (previousState.stencilTest.enabled !== nextState.stencilTest.enabled || previousState.stencilTest.frontFunction !== nextState.stencilTest.frontFunction || previousState.stencilTest.backFunction !== nextState.stencilTest.backFunction || previousState.stencilTest.reference !== nextState.stencilTest.reference || previousState.stencilTest.mask !== nextState.stencilTest.mask || previousState.stencilTest.frontOperation.fail !== nextState.stencilTest.frontOperation.fail || previousState.stencilTest.frontOperation.zFail !== nextState.stencilTest.frontOperation.zFail || previousState.stencilTest.backOperation.fail !== nextState.stencilTest.backOperation.fail || previousState.stencilTest.backOperation.zFail !== nextState.stencilTest.backOperation.zFail || previousState.stencilTest.backOperation.zPass !== nextState.stencilTest.backOperation.zPass) {
    funcs.push(applyStencilTest);
  }
  if (previousState.sampleCoverage.enabled !== nextState.sampleCoverage.enabled || previousState.sampleCoverage.value !== nextState.sampleCoverage.value || previousState.sampleCoverage.invert !== nextState.sampleCoverage.invert) {
    funcs.push(applySampleCoverage);
  }
  return funcs;
}
RenderState.partialApply = function(gl, previousRenderState, renderState, previousPassState, passState, clear2) {
  if (previousRenderState !== renderState) {
    let funcs = renderState._applyFunctions[previousRenderState.id];
    if (!defined_default(funcs)) {
      funcs = createFuncs(previousRenderState, renderState);
      renderState._applyFunctions[previousRenderState.id] = funcs;
    }
    const len = funcs.length;
    for (let i2 = 0; i2 < len; ++i2) {
      funcs[i2](gl, renderState);
    }
  }
  const previousScissorTest = defined_default(previousPassState.scissorTest) ? previousPassState.scissorTest : previousRenderState.scissorTest;
  const scissorTest = defined_default(passState.scissorTest) ? passState.scissorTest : renderState.scissorTest;
  if (previousScissorTest !== scissorTest || clear2) {
    applyScissorTest(gl, renderState, passState);
  }
  const previousBlendingEnabled = defined_default(previousPassState.blendingEnabled) ? previousPassState.blendingEnabled : previousRenderState.blending.enabled;
  const blendingEnabled = defined_default(passState.blendingEnabled) ? passState.blendingEnabled : renderState.blending.enabled;
  if (previousBlendingEnabled !== blendingEnabled || blendingEnabled && previousRenderState.blending !== renderState.blending) {
    applyBlending(gl, renderState, passState);
  }
  if (previousRenderState !== renderState || previousPassState !== passState || previousPassState.context !== passState.context) {
    applyViewport(gl, renderState, passState);
  }
};
RenderState.getState = function(renderState) {
  if (!defined_default(renderState)) {
    throw new DeveloperError_default("renderState is required.");
  }
  return {
    frontFace: renderState.frontFace,
    cull: {
      enabled: renderState.cull.enabled,
      face: renderState.cull.face
    },
    lineWidth: renderState.lineWidth,
    polygonOffset: {
      enabled: renderState.polygonOffset.enabled,
      factor: renderState.polygonOffset.factor,
      units: renderState.polygonOffset.units
    },
    scissorTest: {
      enabled: renderState.scissorTest.enabled,
      rectangle: BoundingRectangle_default.clone(renderState.scissorTest.rectangle)
    },
    depthRange: {
      near: renderState.depthRange.near,
      far: renderState.depthRange.far
    },
    depthTest: {
      enabled: renderState.depthTest.enabled,
      func: renderState.depthTest.func
    },
    colorMask: {
      red: renderState.colorMask.red,
      green: renderState.colorMask.green,
      blue: renderState.colorMask.blue,
      alpha: renderState.colorMask.alpha
    },
    depthMask: renderState.depthMask,
    stencilMask: renderState.stencilMask,
    blending: {
      enabled: renderState.blending.enabled,
      color: Color_default.clone(renderState.blending.color),
      equationRgb: renderState.blending.equationRgb,
      equationAlpha: renderState.blending.equationAlpha,
      functionSourceRgb: renderState.blending.functionSourceRgb,
      functionSourceAlpha: renderState.blending.functionSourceAlpha,
      functionDestinationRgb: renderState.blending.functionDestinationRgb,
      functionDestinationAlpha: renderState.blending.functionDestinationAlpha
    },
    stencilTest: {
      enabled: renderState.stencilTest.enabled,
      frontFunction: renderState.stencilTest.frontFunction,
      backFunction: renderState.stencilTest.backFunction,
      reference: renderState.stencilTest.reference,
      mask: renderState.stencilTest.mask,
      frontOperation: {
        fail: renderState.stencilTest.frontOperation.fail,
        zFail: renderState.stencilTest.frontOperation.zFail,
        zPass: renderState.stencilTest.frontOperation.zPass
      },
      backOperation: {
        fail: renderState.stencilTest.backOperation.fail,
        zFail: renderState.stencilTest.backOperation.zFail,
        zPass: renderState.stencilTest.backOperation.zPass
      }
    },
    sampleCoverage: {
      enabled: renderState.sampleCoverage.enabled,
      value: renderState.sampleCoverage.value,
      invert: renderState.sampleCoverage.invert
    },
    viewport: defined_default(renderState.viewport) ? BoundingRectangle_default.clone(renderState.viewport) : void 0
  };
};
var RenderState_default = RenderState;

// node_modules/cesium/Source/Renderer/AutomaticUniforms.js
var viewerPositionWCScratch = new Cartesian3_default();
function AutomaticUniform(options) {
  this._size = options.size;
  this._datatype = options.datatype;
  this.getValue = options.getValue;
}
var datatypeToGlsl = {};
datatypeToGlsl[WebGLConstants_default.FLOAT] = "float";
datatypeToGlsl[WebGLConstants_default.FLOAT_VEC2] = "vec2";
datatypeToGlsl[WebGLConstants_default.FLOAT_VEC3] = "vec3";
datatypeToGlsl[WebGLConstants_default.FLOAT_VEC4] = "vec4";
datatypeToGlsl[WebGLConstants_default.INT] = "int";
datatypeToGlsl[WebGLConstants_default.INT_VEC2] = "ivec2";
datatypeToGlsl[WebGLConstants_default.INT_VEC3] = "ivec3";
datatypeToGlsl[WebGLConstants_default.INT_VEC4] = "ivec4";
datatypeToGlsl[WebGLConstants_default.BOOL] = "bool";
datatypeToGlsl[WebGLConstants_default.BOOL_VEC2] = "bvec2";
datatypeToGlsl[WebGLConstants_default.BOOL_VEC3] = "bvec3";
datatypeToGlsl[WebGLConstants_default.BOOL_VEC4] = "bvec4";
datatypeToGlsl[WebGLConstants_default.FLOAT_MAT2] = "mat2";
datatypeToGlsl[WebGLConstants_default.FLOAT_MAT3] = "mat3";
datatypeToGlsl[WebGLConstants_default.FLOAT_MAT4] = "mat4";
datatypeToGlsl[WebGLConstants_default.SAMPLER_2D] = "sampler2D";
datatypeToGlsl[WebGLConstants_default.SAMPLER_CUBE] = "samplerCube";
AutomaticUniform.prototype.getDeclaration = function(name) {
  let declaration = `uniform ${datatypeToGlsl[this._datatype]} ${name}`;
  const size = this._size;
  if (size === 1) {
    declaration += ";";
  } else {
    declaration += `[${size.toString()}];`;
  }
  return declaration;
};
var AutomaticUniforms = {
  czm_viewport: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC4,
    getValue: function(uniformState) {
      return uniformState.viewportCartesian4;
    }
  }),
  czm_viewportOrthographic: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.viewportOrthographic;
    }
  }),
  czm_viewportTransformation: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.viewportTransformation;
    }
  }),
  czm_globeDepthTexture: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.SAMPLER_2D,
    getValue: function(uniformState) {
      return uniformState.globeDepthTexture;
    }
  }),
  czm_model: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.model;
    }
  }),
  czm_inverseModel: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.inverseModel;
    }
  }),
  czm_view: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.view;
    }
  }),
  czm_view3D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.view3D;
    }
  }),
  czm_viewRotation: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT3,
    getValue: function(uniformState) {
      return uniformState.viewRotation;
    }
  }),
  czm_viewRotation3D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT3,
    getValue: function(uniformState) {
      return uniformState.viewRotation3D;
    }
  }),
  czm_inverseView: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.inverseView;
    }
  }),
  czm_inverseView3D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.inverseView3D;
    }
  }),
  czm_inverseViewRotation: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT3,
    getValue: function(uniformState) {
      return uniformState.inverseViewRotation;
    }
  }),
  czm_inverseViewRotation3D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT3,
    getValue: function(uniformState) {
      return uniformState.inverseViewRotation3D;
    }
  }),
  czm_projection: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.projection;
    }
  }),
  czm_inverseProjection: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.inverseProjection;
    }
  }),
  czm_infiniteProjection: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.infiniteProjection;
    }
  }),
  czm_modelView: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.modelView;
    }
  }),
  czm_modelView3D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.modelView3D;
    }
  }),
  czm_modelViewRelativeToEye: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.modelViewRelativeToEye;
    }
  }),
  czm_inverseModelView: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.inverseModelView;
    }
  }),
  czm_inverseModelView3D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.inverseModelView3D;
    }
  }),
  czm_viewProjection: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.viewProjection;
    }
  }),
  czm_inverseViewProjection: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.inverseViewProjection;
    }
  }),
  czm_modelViewProjection: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.modelViewProjection;
    }
  }),
  czm_inverseModelViewProjection: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.inverseModelViewProjection;
    }
  }),
  czm_modelViewProjectionRelativeToEye: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.modelViewProjectionRelativeToEye;
    }
  }),
  czm_modelViewInfiniteProjection: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT4,
    getValue: function(uniformState) {
      return uniformState.modelViewInfiniteProjection;
    }
  }),
  czm_orthographicIn3D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.orthographicIn3D ? 1 : 0;
    }
  }),
  czm_normal: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT3,
    getValue: function(uniformState) {
      return uniformState.normal;
    }
  }),
  czm_normal3D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT3,
    getValue: function(uniformState) {
      return uniformState.normal3D;
    }
  }),
  czm_inverseNormal: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT3,
    getValue: function(uniformState) {
      return uniformState.inverseNormal;
    }
  }),
  czm_inverseNormal3D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT3,
    getValue: function(uniformState) {
      return uniformState.inverseNormal3D;
    }
  }),
  czm_eyeHeight: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.eyeHeight;
    }
  }),
  czm_eyeHeight2D: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC2,
    getValue: function(uniformState) {
      return uniformState.eyeHeight2D;
    }
  }),
  czm_entireFrustum: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC2,
    getValue: function(uniformState) {
      return uniformState.entireFrustum;
    }
  }),
  czm_currentFrustum: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC2,
    getValue: function(uniformState) {
      return uniformState.currentFrustum;
    }
  }),
  czm_frustumPlanes: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC4,
    getValue: function(uniformState) {
      return uniformState.frustumPlanes;
    }
  }),
  czm_farDepthFromNearPlusOne: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.farDepthFromNearPlusOne;
    }
  }),
  czm_log2FarDepthFromNearPlusOne: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.log2FarDepthFromNearPlusOne;
    }
  }),
  czm_oneOverLog2FarDepthFromNearPlusOne: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.oneOverLog2FarDepthFromNearPlusOne;
    }
  }),
  czm_sunPositionWC: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.sunPositionWC;
    }
  }),
  czm_sunPositionColumbusView: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.sunPositionColumbusView;
    }
  }),
  czm_sunDirectionEC: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.sunDirectionEC;
    }
  }),
  czm_sunDirectionWC: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.sunDirectionWC;
    }
  }),
  czm_moonDirectionEC: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.moonDirectionEC;
    }
  }),
  czm_lightDirectionEC: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.lightDirectionEC;
    }
  }),
  czm_lightDirectionWC: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.lightDirectionWC;
    }
  }),
  czm_lightColor: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.lightColor;
    }
  }),
  czm_lightColorHdr: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.lightColorHdr;
    }
  }),
  czm_encodedCameraPositionMCHigh: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.encodedCameraPositionMCHigh;
    }
  }),
  czm_encodedCameraPositionMCLow: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.encodedCameraPositionMCLow;
    }
  }),
  czm_viewerPositionWC: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return Matrix4_default.getTranslation(
        uniformState.inverseView,
        viewerPositionWCScratch
      );
    }
  }),
  czm_frameNumber: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.frameState.frameNumber;
    }
  }),
  czm_morphTime: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.frameState.morphTime;
    }
  }),
  czm_sceneMode: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.frameState.mode;
    }
  }),
  czm_pass: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.pass;
    }
  }),
  czm_backgroundColor: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC4,
    getValue: function(uniformState) {
      return uniformState.backgroundColor;
    }
  }),
  czm_brdfLut: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.SAMPLER_2D,
    getValue: function(uniformState) {
      return uniformState.brdfLut;
    }
  }),
  czm_environmentMap: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.SAMPLER_CUBE,
    getValue: function(uniformState) {
      return uniformState.environmentMap;
    }
  }),
  czm_specularEnvironmentMaps: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.SAMPLER_2D,
    getValue: function(uniformState) {
      return uniformState.specularEnvironmentMaps;
    }
  }),
  czm_specularEnvironmentMapSize: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC2,
    getValue: function(uniformState) {
      return uniformState.specularEnvironmentMapsDimensions;
    }
  }),
  czm_specularEnvironmentMapsMaximumLOD: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.specularEnvironmentMapsMaximumLOD;
    }
  }),
  czm_sphericalHarmonicCoefficients: new AutomaticUniform({
    size: 9,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.sphericalHarmonicCoefficients;
    }
  }),
  czm_temeToPseudoFixed: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_MAT3,
    getValue: function(uniformState) {
      return uniformState.temeToPseudoFixedMatrix;
    }
  }),
  czm_pixelRatio: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.pixelRatio;
    }
  }),
  czm_fogDensity: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.fogDensity;
    }
  }),
  czm_splitPosition: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.splitPosition;
    }
  }),
  czm_imagerySplitPosition: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.imagerySplitPosition;
    }
  }),
  czm_geometricToleranceOverMeter: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.geometricToleranceOverMeter;
    }
  }),
  czm_minimumDisableDepthTestDistance: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.minimumDisableDepthTestDistance;
    }
  }),
  czm_invertClassificationColor: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC4,
    getValue: function(uniformState) {
      return uniformState.invertClassificationColor;
    }
  }),
  czm_gamma: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT,
    getValue: function(uniformState) {
      return uniformState.gamma;
    }
  }),
  czm_ellipsoidRadii: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.ellipsoid.radii;
    }
  }),
  czm_ellipsoidInverseRadii: new AutomaticUniform({
    size: 1,
    datatype: WebGLConstants_default.FLOAT_VEC3,
    getValue: function(uniformState) {
      return uniformState.ellipsoid.oneOverRadii;
    }
  })
};
var AutomaticUniforms_default = AutomaticUniforms;

// node_modules/cesium/Source/Renderer/createUniform.js
function createUniform2(gl, activeUniform, uniformName, location2) {
  switch (activeUniform.type) {
    case gl.FLOAT:
      return new UniformFloat(gl, activeUniform, uniformName, location2);
    case gl.FLOAT_VEC2:
      return new UniformFloatVec2(gl, activeUniform, uniformName, location2);
    case gl.FLOAT_VEC3:
      return new UniformFloatVec3(gl, activeUniform, uniformName, location2);
    case gl.FLOAT_VEC4:
      return new UniformFloatVec4(gl, activeUniform, uniformName, location2);
    case gl.SAMPLER_2D:
    case gl.SAMPLER_CUBE:
      return new UniformSampler(gl, activeUniform, uniformName, location2);
    case gl.INT:
    case gl.BOOL:
      return new UniformInt(gl, activeUniform, uniformName, location2);
    case gl.INT_VEC2:
    case gl.BOOL_VEC2:
      return new UniformIntVec2(gl, activeUniform, uniformName, location2);
    case gl.INT_VEC3:
    case gl.BOOL_VEC3:
      return new UniformIntVec3(gl, activeUniform, uniformName, location2);
    case gl.INT_VEC4:
    case gl.BOOL_VEC4:
      return new UniformIntVec4(gl, activeUniform, uniformName, location2);
    case gl.FLOAT_MAT2:
      return new UniformMat2(gl, activeUniform, uniformName, location2);
    case gl.FLOAT_MAT3:
      return new UniformMat3(gl, activeUniform, uniformName, location2);
    case gl.FLOAT_MAT4:
      return new UniformMat4(gl, activeUniform, uniformName, location2);
    default:
      throw new RuntimeError_default(
        `Unrecognized uniform type: ${activeUniform.type} for uniform "${uniformName}".`
      );
  }
}
function UniformFloat(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = 0;
  this._gl = gl;
  this._location = location2;
}
UniformFloat.prototype.set = function() {
  if (this.value !== this._value) {
    this._value = this.value;
    this._gl.uniform1f(this._location, this.value);
  }
};
function UniformFloatVec2(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = new Cartesian2_default();
  this._gl = gl;
  this._location = location2;
}
UniformFloatVec2.prototype.set = function() {
  const v7 = this.value;
  if (!Cartesian2_default.equals(v7, this._value)) {
    Cartesian2_default.clone(v7, this._value);
    this._gl.uniform2f(this._location, v7.x, v7.y);
  }
};
function UniformFloatVec3(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = void 0;
  this._gl = gl;
  this._location = location2;
}
UniformFloatVec3.prototype.set = function() {
  const v7 = this.value;
  if (defined_default(v7.red)) {
    if (!Color_default.equals(v7, this._value)) {
      this._value = Color_default.clone(v7, this._value);
      this._gl.uniform3f(this._location, v7.red, v7.green, v7.blue);
    }
  } else if (defined_default(v7.x)) {
    if (!Cartesian3_default.equals(v7, this._value)) {
      this._value = Cartesian3_default.clone(v7, this._value);
      this._gl.uniform3f(this._location, v7.x, v7.y, v7.z);
    }
  } else {
    throw new DeveloperError_default(`Invalid vec3 value for uniform "${this.name}".`);
  }
};
function UniformFloatVec4(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = void 0;
  this._gl = gl;
  this._location = location2;
}
UniformFloatVec4.prototype.set = function() {
  const v7 = this.value;
  if (defined_default(v7.red)) {
    if (!Color_default.equals(v7, this._value)) {
      this._value = Color_default.clone(v7, this._value);
      this._gl.uniform4f(this._location, v7.red, v7.green, v7.blue, v7.alpha);
    }
  } else if (defined_default(v7.x)) {
    if (!Cartesian4_default.equals(v7, this._value)) {
      this._value = Cartesian4_default.clone(v7, this._value);
      this._gl.uniform4f(this._location, v7.x, v7.y, v7.z, v7.w);
    }
  } else {
    throw new DeveloperError_default(`Invalid vec4 value for uniform "${this.name}".`);
  }
};
function UniformSampler(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._gl = gl;
  this._location = location2;
  this.textureUnitIndex = void 0;
}
UniformSampler.prototype.set = function() {
  const gl = this._gl;
  gl.activeTexture(gl.TEXTURE0 + this.textureUnitIndex);
  const v7 = this.value;
  gl.bindTexture(v7._target, v7._texture);
};
UniformSampler.prototype._setSampler = function(textureUnitIndex) {
  this.textureUnitIndex = textureUnitIndex;
  this._gl.uniform1i(this._location, textureUnitIndex);
  return textureUnitIndex + 1;
};
function UniformInt(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = 0;
  this._gl = gl;
  this._location = location2;
}
UniformInt.prototype.set = function() {
  if (this.value !== this._value) {
    this._value = this.value;
    this._gl.uniform1i(this._location, this.value);
  }
};
function UniformIntVec2(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = new Cartesian2_default();
  this._gl = gl;
  this._location = location2;
}
UniformIntVec2.prototype.set = function() {
  const v7 = this.value;
  if (!Cartesian2_default.equals(v7, this._value)) {
    Cartesian2_default.clone(v7, this._value);
    this._gl.uniform2i(this._location, v7.x, v7.y);
  }
};
function UniformIntVec3(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = new Cartesian3_default();
  this._gl = gl;
  this._location = location2;
}
UniformIntVec3.prototype.set = function() {
  const v7 = this.value;
  if (!Cartesian3_default.equals(v7, this._value)) {
    Cartesian3_default.clone(v7, this._value);
    this._gl.uniform3i(this._location, v7.x, v7.y, v7.z);
  }
};
function UniformIntVec4(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = new Cartesian4_default();
  this._gl = gl;
  this._location = location2;
}
UniformIntVec4.prototype.set = function() {
  const v7 = this.value;
  if (!Cartesian4_default.equals(v7, this._value)) {
    Cartesian4_default.clone(v7, this._value);
    this._gl.uniform4i(this._location, v7.x, v7.y, v7.z, v7.w);
  }
};
var scratchUniformArray = new Float32Array(4);
function UniformMat2(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = new Matrix2_default();
  this._gl = gl;
  this._location = location2;
}
UniformMat2.prototype.set = function() {
  if (!Matrix2_default.equalsArray(this.value, this._value, 0)) {
    Matrix2_default.clone(this.value, this._value);
    const array = Matrix2_default.toArray(this.value, scratchUniformArray);
    this._gl.uniformMatrix2fv(this._location, false, array);
  }
};
var scratchMat3Array = new Float32Array(9);
function UniformMat3(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = new Matrix3_default();
  this._gl = gl;
  this._location = location2;
}
UniformMat3.prototype.set = function() {
  if (!Matrix3_default.equalsArray(this.value, this._value, 0)) {
    Matrix3_default.clone(this.value, this._value);
    const array = Matrix3_default.toArray(this.value, scratchMat3Array);
    this._gl.uniformMatrix3fv(this._location, false, array);
  }
};
var scratchMat4Array = new Float32Array(16);
function UniformMat4(gl, activeUniform, uniformName, location2) {
  this.name = uniformName;
  this.value = void 0;
  this._value = new Matrix4_default();
  this._gl = gl;
  this._location = location2;
}
UniformMat4.prototype.set = function() {
  if (!Matrix4_default.equalsArray(this.value, this._value, 0)) {
    Matrix4_default.clone(this.value, this._value);
    const array = Matrix4_default.toArray(this.value, scratchMat4Array);
    this._gl.uniformMatrix4fv(this._location, false, array);
  }
};
var createUniform_default = createUniform2;

// node_modules/cesium/Source/Renderer/createUniformArray.js
function createUniformArray(gl, activeUniform, uniformName, locations) {
  switch (activeUniform.type) {
    case gl.FLOAT:
      return new UniformArrayFloat(gl, activeUniform, uniformName, locations);
    case gl.FLOAT_VEC2:
      return new UniformArrayFloatVec2(
        gl,
        activeUniform,
        uniformName,
        locations
      );
    case gl.FLOAT_VEC3:
      return new UniformArrayFloatVec3(
        gl,
        activeUniform,
        uniformName,
        locations
      );
    case gl.FLOAT_VEC4:
      return new UniformArrayFloatVec4(
        gl,
        activeUniform,
        uniformName,
        locations
      );
    case gl.SAMPLER_2D:
    case gl.SAMPLER_CUBE:
      return new UniformArraySampler(gl, activeUniform, uniformName, locations);
    case gl.INT:
    case gl.BOOL:
      return new UniformArrayInt(gl, activeUniform, uniformName, locations);
    case gl.INT_VEC2:
    case gl.BOOL_VEC2:
      return new UniformArrayIntVec2(gl, activeUniform, uniformName, locations);
    case gl.INT_VEC3:
    case gl.BOOL_VEC3:
      return new UniformArrayIntVec3(gl, activeUniform, uniformName, locations);
    case gl.INT_VEC4:
    case gl.BOOL_VEC4:
      return new UniformArrayIntVec4(gl, activeUniform, uniformName, locations);
    case gl.FLOAT_MAT2:
      return new UniformArrayMat2(gl, activeUniform, uniformName, locations);
    case gl.FLOAT_MAT3:
      return new UniformArrayMat3(gl, activeUniform, uniformName, locations);
    case gl.FLOAT_MAT4:
      return new UniformArrayMat4(gl, activeUniform, uniformName, locations);
    default:
      throw new RuntimeError_default(
        `Unrecognized uniform type: ${activeUniform.type} for uniform "${uniformName}".`
      );
  }
}
function UniformArrayFloat(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Float32Array(length3);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayFloat.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (v7 !== arraybuffer[i2]) {
      arraybuffer[i2] = v7;
      changed = true;
    }
  }
  if (changed) {
    this._gl.uniform1fv(this._location, arraybuffer);
  }
};
function UniformArrayFloatVec2(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Float32Array(length3 * 2);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayFloatVec2.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  let j = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (!Cartesian2_default.equalsArray(v7, arraybuffer, j)) {
      Cartesian2_default.pack(v7, arraybuffer, j);
      changed = true;
    }
    j += 2;
  }
  if (changed) {
    this._gl.uniform2fv(this._location, arraybuffer);
  }
};
function UniformArrayFloatVec3(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Float32Array(length3 * 3);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayFloatVec3.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  let j = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (defined_default(v7.red)) {
      if (v7.red !== arraybuffer[j] || v7.green !== arraybuffer[j + 1] || v7.blue !== arraybuffer[j + 2]) {
        arraybuffer[j] = v7.red;
        arraybuffer[j + 1] = v7.green;
        arraybuffer[j + 2] = v7.blue;
        changed = true;
      }
    } else if (defined_default(v7.x)) {
      if (!Cartesian3_default.equalsArray(v7, arraybuffer, j)) {
        Cartesian3_default.pack(v7, arraybuffer, j);
        changed = true;
      }
    } else {
      throw new DeveloperError_default("Invalid vec3 value.");
    }
    j += 3;
  }
  if (changed) {
    this._gl.uniform3fv(this._location, arraybuffer);
  }
};
function UniformArrayFloatVec4(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Float32Array(length3 * 4);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayFloatVec4.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  let j = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (defined_default(v7.red)) {
      if (!Color_default.equalsArray(v7, arraybuffer, j)) {
        Color_default.pack(v7, arraybuffer, j);
        changed = true;
      }
    } else if (defined_default(v7.x)) {
      if (!Cartesian4_default.equalsArray(v7, arraybuffer, j)) {
        Cartesian4_default.pack(v7, arraybuffer, j);
        changed = true;
      }
    } else {
      throw new DeveloperError_default("Invalid vec4 value.");
    }
    j += 4;
  }
  if (changed) {
    this._gl.uniform4fv(this._location, arraybuffer);
  }
};
function UniformArraySampler(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Float32Array(length3);
  this._gl = gl;
  this._locations = locations;
  this.textureUnitIndex = void 0;
}
UniformArraySampler.prototype.set = function() {
  const gl = this._gl;
  const textureUnitIndex = gl.TEXTURE0 + this.textureUnitIndex;
  const value = this.value;
  const length3 = value.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    gl.activeTexture(textureUnitIndex + i2);
    gl.bindTexture(v7._target, v7._texture);
  }
};
UniformArraySampler.prototype._setSampler = function(textureUnitIndex) {
  this.textureUnitIndex = textureUnitIndex;
  const locations = this._locations;
  const length3 = locations.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const index2 = textureUnitIndex + i2;
    this._gl.uniform1i(locations[i2], index2);
  }
  return textureUnitIndex + length3;
};
function UniformArrayInt(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Int32Array(length3);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayInt.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (v7 !== arraybuffer[i2]) {
      arraybuffer[i2] = v7;
      changed = true;
    }
  }
  if (changed) {
    this._gl.uniform1iv(this._location, arraybuffer);
  }
};
function UniformArrayIntVec2(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Int32Array(length3 * 2);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayIntVec2.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  let j = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (!Cartesian2_default.equalsArray(v7, arraybuffer, j)) {
      Cartesian2_default.pack(v7, arraybuffer, j);
      changed = true;
    }
    j += 2;
  }
  if (changed) {
    this._gl.uniform2iv(this._location, arraybuffer);
  }
};
function UniformArrayIntVec3(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Int32Array(length3 * 3);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayIntVec3.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  let j = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (!Cartesian3_default.equalsArray(v7, arraybuffer, j)) {
      Cartesian3_default.pack(v7, arraybuffer, j);
      changed = true;
    }
    j += 3;
  }
  if (changed) {
    this._gl.uniform3iv(this._location, arraybuffer);
  }
};
function UniformArrayIntVec4(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Int32Array(length3 * 4);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayIntVec4.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  let j = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (!Cartesian4_default.equalsArray(v7, arraybuffer, j)) {
      Cartesian4_default.pack(v7, arraybuffer, j);
      changed = true;
    }
    j += 4;
  }
  if (changed) {
    this._gl.uniform4iv(this._location, arraybuffer);
  }
};
function UniformArrayMat2(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Float32Array(length3 * 4);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayMat2.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  let j = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (!Matrix2_default.equalsArray(v7, arraybuffer, j)) {
      Matrix2_default.pack(v7, arraybuffer, j);
      changed = true;
    }
    j += 4;
  }
  if (changed) {
    this._gl.uniformMatrix2fv(this._location, false, arraybuffer);
  }
};
function UniformArrayMat3(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Float32Array(length3 * 9);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayMat3.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  let j = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (!Matrix3_default.equalsArray(v7, arraybuffer, j)) {
      Matrix3_default.pack(v7, arraybuffer, j);
      changed = true;
    }
    j += 9;
  }
  if (changed) {
    this._gl.uniformMatrix3fv(this._location, false, arraybuffer);
  }
};
function UniformArrayMat4(gl, activeUniform, uniformName, locations) {
  const length3 = locations.length;
  this.name = uniformName;
  this.value = new Array(length3);
  this._value = new Float32Array(length3 * 16);
  this._gl = gl;
  this._location = locations[0];
}
UniformArrayMat4.prototype.set = function() {
  const value = this.value;
  const length3 = value.length;
  const arraybuffer = this._value;
  let changed = false;
  let j = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const v7 = value[i2];
    if (!Matrix4_default.equalsArray(v7, arraybuffer, j)) {
      Matrix4_default.pack(v7, arraybuffer, j);
      changed = true;
    }
    j += 16;
  }
  if (changed) {
    this._gl.uniformMatrix4fv(this._location, false, arraybuffer);
  }
};
var createUniformArray_default = createUniformArray;

// node_modules/cesium/Source/Renderer/ShaderProgram.js
var nextShaderProgramId = 0;
function ShaderProgram(options) {
  let vertexShaderText = options.vertexShaderText;
  let fragmentShaderText = options.fragmentShaderText;
  if (typeof spector !== "undefined") {
    vertexShaderText = vertexShaderText.replace(/^#line/gm, "//#line");
    fragmentShaderText = fragmentShaderText.replace(/^#line/gm, "//#line");
  }
  const modifiedFS = handleUniformPrecisionMismatches(
    vertexShaderText,
    fragmentShaderText
  );
  this._gl = options.gl;
  this._logShaderCompilation = options.logShaderCompilation;
  this._debugShaders = options.debugShaders;
  this._attributeLocations = options.attributeLocations;
  this._program = void 0;
  this._numberOfVertexAttributes = void 0;
  this._vertexAttributes = void 0;
  this._uniformsByName = void 0;
  this._uniforms = void 0;
  this._automaticUniforms = void 0;
  this._manualUniforms = void 0;
  this._duplicateUniformNames = modifiedFS.duplicateUniformNames;
  this._cachedShader = void 0;
  this.maximumTextureUnitIndex = void 0;
  this._vertexShaderSource = options.vertexShaderSource;
  this._vertexShaderText = options.vertexShaderText;
  this._fragmentShaderSource = options.fragmentShaderSource;
  this._fragmentShaderText = modifiedFS.fragmentShaderText;
  this.id = nextShaderProgramId++;
}
ShaderProgram.fromCache = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.context", options.context);
  return options.context.shaderCache.getShaderProgram(options);
};
ShaderProgram.replaceCache = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.context", options.context);
  return options.context.shaderCache.replaceShaderProgram(options);
};
Object.defineProperties(ShaderProgram.prototype, {
  vertexShaderSource: {
    get: function() {
      return this._vertexShaderSource;
    }
  },
  fragmentShaderSource: {
    get: function() {
      return this._fragmentShaderSource;
    }
  },
  vertexAttributes: {
    get: function() {
      initialize2(this);
      return this._vertexAttributes;
    }
  },
  numberOfVertexAttributes: {
    get: function() {
      initialize2(this);
      return this._numberOfVertexAttributes;
    }
  },
  allUniforms: {
    get: function() {
      initialize2(this);
      return this._uniformsByName;
    }
  }
});
function extractUniforms(shaderText) {
  const uniformNames = [];
  const uniformLines = shaderText.match(/uniform.*?(?![^{]*})(?=[=\[;])/g);
  if (defined_default(uniformLines)) {
    const len = uniformLines.length;
    for (let i2 = 0; i2 < len; i2++) {
      const line = uniformLines[i2].trim();
      const name = line.slice(line.lastIndexOf(" ") + 1);
      uniformNames.push(name);
    }
  }
  return uniformNames;
}
function handleUniformPrecisionMismatches(vertexShaderText, fragmentShaderText) {
  const duplicateUniformNames = {};
  if (!ContextLimits_default.highpFloatSupported || !ContextLimits_default.highpIntSupported) {
    let i2, j;
    let uniformName;
    let duplicateName;
    const vertexShaderUniforms = extractUniforms(vertexShaderText);
    const fragmentShaderUniforms = extractUniforms(fragmentShaderText);
    const vertexUniformsCount = vertexShaderUniforms.length;
    const fragmentUniformsCount = fragmentShaderUniforms.length;
    for (i2 = 0; i2 < vertexUniformsCount; i2++) {
      for (j = 0; j < fragmentUniformsCount; j++) {
        if (vertexShaderUniforms[i2] === fragmentShaderUniforms[j]) {
          uniformName = vertexShaderUniforms[i2];
          duplicateName = `czm_mediump_${uniformName}`;
          const re = new RegExp(`${uniformName}\\b`, "g");
          fragmentShaderText = fragmentShaderText.replace(re, duplicateName);
          duplicateUniformNames[duplicateName] = uniformName;
        }
      }
    }
  }
  return {
    fragmentShaderText,
    duplicateUniformNames
  };
}
var consolePrefix = "[Cesium WebGL] ";
function createAndLinkProgram(gl, shader) {
  const vsSource = shader._vertexShaderText;
  const fsSource = shader._fragmentShaderText;
  const vertexShader = gl.createShader(gl.VERTEX_SHADER);
  gl.shaderSource(vertexShader, vsSource);
  gl.compileShader(vertexShader);
  const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
  gl.shaderSource(fragmentShader, fsSource);
  gl.compileShader(fragmentShader);
  const program = gl.createProgram();
  gl.attachShader(program, vertexShader);
  gl.attachShader(program, fragmentShader);
  gl.deleteShader(vertexShader);
  gl.deleteShader(fragmentShader);
  const attributeLocations8 = shader._attributeLocations;
  if (defined_default(attributeLocations8)) {
    for (const attribute in attributeLocations8) {
      if (attributeLocations8.hasOwnProperty(attribute)) {
        gl.bindAttribLocation(
          program,
          attributeLocations8[attribute],
          attribute
        );
      }
    }
  }
  gl.linkProgram(program);
  let log;
  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
    const debugShaders = shader._debugShaders;
    if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
      log = gl.getShaderInfoLog(fragmentShader);
      console.error(`${consolePrefix}Fragment shader compile log: ${log}`);
      if (defined_default(debugShaders)) {
        const fragmentSourceTranslation = debugShaders.getTranslatedShaderSource(
          fragmentShader
        );
        if (fragmentSourceTranslation !== "") {
          console.error(
            `${consolePrefix}Translated fragment shader source:
${fragmentSourceTranslation}`
          );
        } else {
          console.error(`${consolePrefix}Fragment shader translation failed.`);
        }
      }
      gl.deleteProgram(program);
      throw new RuntimeError_default(
        `Fragment shader failed to compile.  Compile log: ${log}`
      );
    }
    if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
      log = gl.getShaderInfoLog(vertexShader);
      console.error(`${consolePrefix}Vertex shader compile log: ${log}`);
      if (defined_default(debugShaders)) {
        const vertexSourceTranslation = debugShaders.getTranslatedShaderSource(
          vertexShader
        );
        if (vertexSourceTranslation !== "") {
          console.error(
            `${consolePrefix}Translated vertex shader source:
${vertexSourceTranslation}`
          );
        } else {
          console.error(`${consolePrefix}Vertex shader translation failed.`);
        }
      }
      gl.deleteProgram(program);
      throw new RuntimeError_default(
        `Vertex shader failed to compile.  Compile log: ${log}`
      );
    }
    log = gl.getProgramInfoLog(program);
    console.error(`${consolePrefix}Shader program link log: ${log}`);
    if (defined_default(debugShaders)) {
      console.error(
        `${consolePrefix}Translated vertex shader source:
${debugShaders.getTranslatedShaderSource(
          vertexShader
        )}`
      );
      console.error(
        `${consolePrefix}Translated fragment shader source:
${debugShaders.getTranslatedShaderSource(
          fragmentShader
        )}`
      );
    }
    gl.deleteProgram(program);
    throw new RuntimeError_default(`Program failed to link.  Link log: ${log}`);
  }
  const logShaderCompilation = shader._logShaderCompilation;
  if (logShaderCompilation) {
    log = gl.getShaderInfoLog(vertexShader);
    if (defined_default(log) && log.length > 0) {
      console.log(`${consolePrefix}Vertex shader compile log: ${log}`);
    }
  }
  if (logShaderCompilation) {
    log = gl.getShaderInfoLog(fragmentShader);
    if (defined_default(log) && log.length > 0) {
      console.log(`${consolePrefix}Fragment shader compile log: ${log}`);
    }
  }
  if (logShaderCompilation) {
    log = gl.getProgramInfoLog(program);
    if (defined_default(log) && log.length > 0) {
      console.log(`${consolePrefix}Shader program link log: ${log}`);
    }
  }
  return program;
}
function findVertexAttributes(gl, program, numberOfAttributes2) {
  const attributes = {};
  for (let i2 = 0; i2 < numberOfAttributes2; ++i2) {
    const attr = gl.getActiveAttrib(program, i2);
    const location2 = gl.getAttribLocation(program, attr.name);
    attributes[attr.name] = {
      name: attr.name,
      type: attr.type,
      index: location2
    };
  }
  return attributes;
}
function findUniforms(gl, program) {
  const uniformsByName = {};
  const uniforms = [];
  const samplerUniforms = [];
  const numberOfUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
  for (let i2 = 0; i2 < numberOfUniforms; ++i2) {
    const activeUniform = gl.getActiveUniform(program, i2);
    const suffix = "[0]";
    const uniformName = activeUniform.name.indexOf(
      suffix,
      activeUniform.name.length - suffix.length
    ) !== -1 ? activeUniform.name.slice(0, activeUniform.name.length - 3) : activeUniform.name;
    if (uniformName.indexOf("gl_") !== 0) {
      if (activeUniform.name.indexOf("[") < 0) {
        const location2 = gl.getUniformLocation(program, uniformName);
        if (location2 !== null) {
          const uniform = createUniform_default(
            gl,
            activeUniform,
            uniformName,
            location2
          );
          uniformsByName[uniformName] = uniform;
          uniforms.push(uniform);
          if (uniform._setSampler) {
            samplerUniforms.push(uniform);
          }
        }
      } else {
        let uniformArray;
        let locations;
        let value;
        let loc;
        const indexOfBracket = uniformName.indexOf("[");
        if (indexOfBracket >= 0) {
          uniformArray = uniformsByName[uniformName.slice(0, indexOfBracket)];
          if (!defined_default(uniformArray)) {
            continue;
          }
          locations = uniformArray._locations;
          if (locations.length <= 1) {
            value = uniformArray.value;
            loc = gl.getUniformLocation(program, uniformName);
            if (loc !== null) {
              locations.push(loc);
              value.push(gl.getUniform(program, loc));
            }
          }
        } else {
          locations = [];
          for (let j = 0; j < activeUniform.size; ++j) {
            loc = gl.getUniformLocation(program, `${uniformName}[${j}]`);
            if (loc !== null) {
              locations.push(loc);
            }
          }
          uniformArray = createUniformArray_default(
            gl,
            activeUniform,
            uniformName,
            locations
          );
          uniformsByName[uniformName] = uniformArray;
          uniforms.push(uniformArray);
          if (uniformArray._setSampler) {
            samplerUniforms.push(uniformArray);
          }
        }
      }
    }
  }
  return {
    uniformsByName,
    uniforms,
    samplerUniforms
  };
}
function partitionUniforms(shader, uniforms) {
  const automaticUniforms = [];
  const manualUniforms = [];
  for (const uniform in uniforms) {
    if (uniforms.hasOwnProperty(uniform)) {
      const uniformObject = uniforms[uniform];
      let uniformName = uniform;
      const duplicateUniform = shader._duplicateUniformNames[uniformName];
      if (defined_default(duplicateUniform)) {
        uniformObject.name = duplicateUniform;
        uniformName = duplicateUniform;
      }
      const automaticUniform = AutomaticUniforms_default[uniformName];
      if (defined_default(automaticUniform)) {
        automaticUniforms.push({
          uniform: uniformObject,
          automaticUniform
        });
      } else {
        manualUniforms.push(uniformObject);
      }
    }
  }
  return {
    automaticUniforms,
    manualUniforms
  };
}
function setSamplerUniforms(gl, program, samplerUniforms) {
  gl.useProgram(program);
  let textureUnitIndex = 0;
  const length3 = samplerUniforms.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    textureUnitIndex = samplerUniforms[i2]._setSampler(textureUnitIndex);
  }
  gl.useProgram(null);
  return textureUnitIndex;
}
function initialize2(shader) {
  if (defined_default(shader._program)) {
    return;
  }
  reinitialize(shader);
}
function reinitialize(shader) {
  const oldProgram = shader._program;
  const gl = shader._gl;
  const program = createAndLinkProgram(gl, shader, shader._debugShaders);
  const numberOfVertexAttributes = gl.getProgramParameter(
    program,
    gl.ACTIVE_ATTRIBUTES
  );
  const uniforms = findUniforms(gl, program);
  const partitionedUniforms = partitionUniforms(
    shader,
    uniforms.uniformsByName
  );
  shader._program = program;
  shader._numberOfVertexAttributes = numberOfVertexAttributes;
  shader._vertexAttributes = findVertexAttributes(
    gl,
    program,
    numberOfVertexAttributes
  );
  shader._uniformsByName = uniforms.uniformsByName;
  shader._uniforms = uniforms.uniforms;
  shader._automaticUniforms = partitionedUniforms.automaticUniforms;
  shader._manualUniforms = partitionedUniforms.manualUniforms;
  shader.maximumTextureUnitIndex = setSamplerUniforms(
    gl,
    program,
    uniforms.samplerUniforms
  );
  if (oldProgram) {
    shader._gl.deleteProgram(oldProgram);
  }
  if (typeof spector !== "undefined") {
    shader._program.__SPECTOR_rebuildProgram = function(vertexSourceCode, fragmentSourceCode, onCompiled, onError) {
      const originalVS = shader._vertexShaderText;
      const originalFS = shader._fragmentShaderText;
      const regex = / ! = /g;
      shader._vertexShaderText = vertexSourceCode.replace(regex, " != ");
      shader._fragmentShaderText = fragmentSourceCode.replace(regex, " != ");
      try {
        reinitialize(shader);
        onCompiled(shader._program);
      } catch (e2) {
        shader._vertexShaderText = originalVS;
        shader._fragmentShaderText = originalFS;
        const errorMatcher = /(?:Compile|Link) error: ([^]*)/;
        const match = errorMatcher.exec(e2.message);
        if (match) {
          onError(match[1]);
        } else {
          onError(e2.message);
        }
      }
    };
  }
}
ShaderProgram.prototype._bind = function() {
  initialize2(this);
  this._gl.useProgram(this._program);
};
ShaderProgram.prototype._setUniforms = function(uniformMap2, uniformState, validate) {
  let len;
  let i2;
  if (defined_default(uniformMap2)) {
    const manualUniforms = this._manualUniforms;
    len = manualUniforms.length;
    for (i2 = 0; i2 < len; ++i2) {
      const mu = manualUniforms[i2];
      mu.value = uniformMap2[mu.name]();
    }
  }
  const automaticUniforms = this._automaticUniforms;
  len = automaticUniforms.length;
  for (i2 = 0; i2 < len; ++i2) {
    const au = automaticUniforms[i2];
    au.uniform.value = au.automaticUniform.getValue(uniformState);
  }
  const uniforms = this._uniforms;
  len = uniforms.length;
  for (i2 = 0; i2 < len; ++i2) {
    uniforms[i2].set();
  }
  if (validate) {
    const gl = this._gl;
    const program = this._program;
    gl.validateProgram(program);
    if (!gl.getProgramParameter(program, gl.VALIDATE_STATUS)) {
      throw new DeveloperError_default(
        `Program validation failed.  Program info log: ${gl.getProgramInfoLog(
          program
        )}`
      );
    }
  }
};
ShaderProgram.prototype.isDestroyed = function() {
  return false;
};
ShaderProgram.prototype.destroy = function() {
  this._cachedShader.cache.releaseShaderProgram(this);
  return void 0;
};
ShaderProgram.prototype.finalDestroy = function() {
  this._gl.deleteProgram(this._program);
  return destroyObject_default(this);
};
var ShaderProgram_default = ShaderProgram;

// node_modules/cesium/Source/Renderer/modernizeShader.js
function modernizeShader(source, isFragmentShader) {
  const outputDeclarationRegex = /#define OUTPUT_DECLARATION/;
  const splitSource = source.split("\n");
  if (/#version 300 es/g.test(source)) {
    return source;
  }
  let outputDeclarationLine = -1;
  let i2, line;
  for (i2 = 0; i2 < splitSource.length; ++i2) {
    line = splitSource[i2];
    if (outputDeclarationRegex.test(line)) {
      outputDeclarationLine = i2;
      break;
    }
  }
  if (outputDeclarationLine === -1) {
    throw new DeveloperError_default("Could not find a #define OUTPUT_DECLARATION!");
  }
  const outputVariables = [];
  for (i2 = 0; i2 < 10; i2++) {
    const fragDataString = `gl_FragData\\[${i2}\\]`;
    const newOutput = `czm_out${i2}`;
    const regex = new RegExp(fragDataString, "g");
    if (regex.test(source)) {
      setAdd(newOutput, outputVariables);
      replaceInSourceString(fragDataString, newOutput, splitSource);
      splitSource.splice(
        outputDeclarationLine,
        0,
        `layout(location = ${i2}) out vec4 ${newOutput};`
      );
      outputDeclarationLine += 1;
    }
  }
  const czmFragColor = "czm_fragColor";
  if (findInSource("gl_FragColor", splitSource)) {
    setAdd(czmFragColor, outputVariables);
    replaceInSourceString("gl_FragColor", czmFragColor, splitSource);
    splitSource.splice(
      outputDeclarationLine,
      0,
      "layout(location = 0) out vec4 czm_fragColor;"
    );
    outputDeclarationLine += 1;
  }
  const variableMap = getVariablePreprocessorBranch(
    outputVariables,
    splitSource
  );
  const lineAdds = {};
  for (i2 = 0; i2 < splitSource.length; i2++) {
    line = splitSource[i2];
    for (const variable in variableMap) {
      if (variableMap.hasOwnProperty(variable)) {
        const matchVar = new RegExp(
          `(layout)[^]+(out)[^]+(${variable})[^]+`,
          "g"
        );
        if (matchVar.test(line)) {
          lineAdds[line] = variable;
        }
      }
    }
  }
  for (const layoutDeclaration in lineAdds) {
    if (lineAdds.hasOwnProperty(layoutDeclaration)) {
      const variableName = lineAdds[layoutDeclaration];
      let lineNumber = splitSource.indexOf(layoutDeclaration);
      const entry = variableMap[variableName];
      const depth = entry.length;
      for (let d = 0; d < depth; d++) {
        splitSource.splice(lineNumber, 0, entry[d]);
      }
      lineNumber += depth + 1;
      for (let d = depth - 1; d >= 0; d--) {
        splitSource.splice(lineNumber, 0, `#endif //${entry[d]}`);
      }
    }
  }
  const webgl2UniqueID = "WEBGL_2";
  const webgl2DefineMacro = `#define ${webgl2UniqueID}`;
  const versionThree = "#version 300 es";
  let foundVersion = false;
  for (i2 = 0; i2 < splitSource.length; i2++) {
    if (/#version/.test(splitSource[i2])) {
      splitSource[i2] = versionThree;
      foundVersion = true;
      break;
    }
  }
  if (!foundVersion) {
    splitSource.splice(0, 0, versionThree);
  }
  splitSource.splice(1, 0, webgl2DefineMacro);
  removeExtension("EXT_draw_buffers", webgl2UniqueID, splitSource);
  removeExtension("EXT_frag_depth", webgl2UniqueID, splitSource);
  removeExtension("OES_standard_derivatives", webgl2UniqueID, splitSource);
  replaceInSourceString("texture2D", "texture", splitSource);
  replaceInSourceString("texture3D", "texture", splitSource);
  replaceInSourceString("textureCube", "texture", splitSource);
  replaceInSourceString("gl_FragDepthEXT", "gl_FragDepth", splitSource);
  if (isFragmentShader) {
    replaceInSourceString("varying", "in", splitSource);
  } else {
    replaceInSourceString("attribute", "in", splitSource);
    replaceInSourceString("varying", "out", splitSource);
  }
  return compileSource(splitSource);
}
function replaceInSourceString(str, replacement, splitSource) {
  const regexStr = `(^|[^\\w])(${str})($|[^\\w])`;
  const regex = new RegExp(regexStr, "g");
  const splitSourceLength = splitSource.length;
  for (let i2 = 0; i2 < splitSourceLength; ++i2) {
    const line = splitSource[i2];
    splitSource[i2] = line.replace(regex, `$1${replacement}$3`);
  }
}
function replaceInSourceRegex(regex, replacement, splitSource) {
  const splitSourceLength = splitSource.length;
  for (let i2 = 0; i2 < splitSourceLength; ++i2) {
    const line = splitSource[i2];
    splitSource[i2] = line.replace(regex, replacement);
  }
}
function findInSource(str, splitSource) {
  const regexStr = `(^|[^\\w])(${str})($|[^\\w])`;
  const regex = new RegExp(regexStr, "g");
  const splitSourceLength = splitSource.length;
  for (let i2 = 0; i2 < splitSourceLength; ++i2) {
    const line = splitSource[i2];
    if (regex.test(line)) {
      return true;
    }
  }
  return false;
}
function compileSource(splitSource) {
  let wholeSource = "";
  const splitSourceLength = splitSource.length;
  for (let i2 = 0; i2 < splitSourceLength; ++i2) {
    wholeSource += `${splitSource[i2]}
`;
  }
  return wholeSource;
}
function setAdd(variable, set2) {
  if (set2.indexOf(variable) === -1) {
    set2.push(variable);
  }
}
function getVariablePreprocessorBranch(layoutVariables, splitSource) {
  const variableMap = {};
  const numLayoutVariables = layoutVariables.length;
  const stack = [];
  for (let i2 = 0; i2 < splitSource.length; ++i2) {
    const line = splitSource[i2];
    const hasIF = /(#ifdef|#if)/g.test(line);
    const hasELSE = /#else/g.test(line);
    const hasENDIF = /#endif/g.test(line);
    if (hasIF) {
      stack.push(line);
    } else if (hasELSE) {
      const top = stack[stack.length - 1];
      let op = top.replace("ifdef", "ifndef");
      if (/if/g.test(op)) {
        op = op.replace(/(#if\s+)(\S*)([^]*)/, "$1!($2)$3");
      }
      stack.pop();
      stack.push(op);
    } else if (hasENDIF) {
      stack.pop();
    } else if (!/layout/g.test(line)) {
      for (let varIndex = 0; varIndex < numLayoutVariables; ++varIndex) {
        const varName = layoutVariables[varIndex];
        if (line.indexOf(varName) !== -1) {
          if (!defined_default(variableMap[varName])) {
            variableMap[varName] = stack.slice();
          } else {
            variableMap[varName] = variableMap[varName].filter(function(x) {
              return stack.indexOf(x) >= 0;
            });
          }
        }
      }
    }
  }
  return variableMap;
}
function removeExtension(name, webgl2UniqueID, splitSource) {
  const regex = `#extension\\s+GL_${name}\\s+:\\s+[a-zA-Z0-9]+\\s*$`;
  replaceInSourceRegex(new RegExp(regex, "g"), "", splitSource);
  replaceInSourceString(`GL_${name}`, webgl2UniqueID, splitSource);
}
var modernizeShader_default = modernizeShader;

// node_modules/cesium/Source/Shaders/Builtin/Constants/degreesPerRadian.js
var degreesPerRadian_default = "/**\n * A built-in GLSL floating-point constant for converting radians to degrees.\n *\n * @alias czm_degreesPerRadian\n * @glslConstant\n *\n * @see CesiumMath.DEGREES_PER_RADIAN\n *\n * @example\n * // GLSL declaration\n * const float czm_degreesPerRadian = ...;\n *\n * // Example\n * float deg = czm_degreesPerRadian * rad;\n */\nconst float czm_degreesPerRadian = 57.29577951308232;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/depthRange.js
var depthRange_default = "/**\n * A built-in GLSL vec2 constant for defining the depth range.\n * This is a workaround to a bug where IE11 does not implement gl_DepthRange.\n *\n * @alias czm_depthRange\n * @glslConstant\n *\n * @example\n * // GLSL declaration\n * float depthRangeNear = czm_depthRange.near;\n * float depthRangeFar = czm_depthRange.far;\n *\n */\nconst czm_depthRangeStruct czm_depthRange = czm_depthRangeStruct(0.0, 1.0);\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/epsilon1.js
var epsilon1_default = "/**\n * 0.1\n *\n * @name czm_epsilon1\n * @glslConstant\n */\nconst float czm_epsilon1 = 0.1;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/epsilon2.js
var epsilon2_default = "/**\n * 0.01\n *\n * @name czm_epsilon2\n * @glslConstant\n */\nconst float czm_epsilon2 = 0.01;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/epsilon3.js
var epsilon3_default = "/**\n * 0.001\n *\n * @name czm_epsilon3\n * @glslConstant\n */\nconst float czm_epsilon3 = 0.001;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/epsilon4.js
var epsilon4_default = "/**\n * 0.0001\n *\n * @name czm_epsilon4\n * @glslConstant\n */\nconst float czm_epsilon4 = 0.0001;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/epsilon5.js
var epsilon5_default = "/**\n * 0.00001\n *\n * @name czm_epsilon5\n * @glslConstant\n */\nconst float czm_epsilon5 = 0.00001;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/epsilon6.js
var epsilon6_default = "/**\n * 0.000001\n *\n * @name czm_epsilon6\n * @glslConstant\n */\nconst float czm_epsilon6 = 0.000001;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/epsilon7.js
var epsilon7_default = "/**\n * 0.0000001\n *\n * @name czm_epsilon7\n * @glslConstant\n */\nconst float czm_epsilon7 = 0.0000001;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/infinity.js
var infinity_default = "/**\n * DOC_TBA\n *\n * @name czm_infinity\n * @glslConstant\n */\nconst float czm_infinity = 5906376272000.0;  // Distance from the Sun to Pluto in meters.  TODO: What is best given lowp, mediump, and highp?\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/oneOverPi.js
var oneOverPi_default = "/**\n * A built-in GLSL floating-point constant for <code>1/pi</code>.\n *\n * @alias czm_oneOverPi\n * @glslConstant\n *\n * @see CesiumMath.ONE_OVER_PI\n *\n * @example\n * // GLSL declaration\n * const float czm_oneOverPi = ...;\n *\n * // Example\n * float pi = 1.0 / czm_oneOverPi;\n */\nconst float czm_oneOverPi = 0.3183098861837907;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/oneOverTwoPi.js
var oneOverTwoPi_default = "/**\n * A built-in GLSL floating-point constant for <code>1/2pi</code>.\n *\n * @alias czm_oneOverTwoPi\n * @glslConstant\n *\n * @see CesiumMath.ONE_OVER_TWO_PI\n *\n * @example\n * // GLSL declaration\n * const float czm_oneOverTwoPi = ...;\n *\n * // Example\n * float pi = 2.0 * czm_oneOverTwoPi;\n */\nconst float czm_oneOverTwoPi = 0.15915494309189535;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passCesium3DTile.js
var passCesium3DTile_default = "/**\n * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE}\n *\n * @name czm_passCesium3DTile\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passCesium3DTile = 4.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passCesium3DTileClassification.js
var passCesium3DTileClassification_default = "/**\n * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE_CLASSIFICATION}\n *\n * @name czm_passCesium3DTileClassification\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passCesium3DTileClassification = 5.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passCesium3DTileClassificationIgnoreShow.js
var passCesium3DTileClassificationIgnoreShow_default = "/**\n * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW}\n *\n * @name czm_passCesium3DTileClassificationIgnoreShow\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passCesium3DTileClassificationIgnoreShow = 6.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passClassification.js
var passClassification_default = "/**\n * The automatic GLSL constant for {@link Pass#CLASSIFICATION}\n *\n * @name czm_passClassification\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passClassification = 7.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passCompute.js
var passCompute_default = "/**\n * The automatic GLSL constant for {@link Pass#COMPUTE}\n *\n * @name czm_passCompute\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passCompute = 1.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passEnvironment.js
var passEnvironment_default = "/**\n * The automatic GLSL constant for {@link Pass#ENVIRONMENT}\n *\n * @name czm_passEnvironment\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passEnvironment = 0.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passGlobe.js
var passGlobe_default = "/**\n * The automatic GLSL constant for {@link Pass#GLOBE}\n *\n * @name czm_passGlobe\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passGlobe = 2.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passOpaque.js
var passOpaque_default = "/**\n * The automatic GLSL constant for {@link Pass#OPAQUE}\n *\n * @name czm_passOpaque\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passOpaque = 7.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passOverlay.js
var passOverlay_default = "/**\n * The automatic GLSL constant for {@link Pass#OVERLAY}\n *\n * @name czm_passOverlay\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passOverlay = 9.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passTerrainClassification.js
var passTerrainClassification_default = "/**\n * The automatic GLSL constant for {@link Pass#TERRAIN_CLASSIFICATION}\n *\n * @name czm_passTerrainClassification\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passTerrainClassification = 3.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/passTranslucent.js
var passTranslucent_default = "/**\n * The automatic GLSL constant for {@link Pass#TRANSLUCENT}\n *\n * @name czm_passTranslucent\n * @glslConstant\n *\n * @see czm_pass\n */\nconst float czm_passTranslucent = 8.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/pi.js
var pi_default = "/**\n * A built-in GLSL floating-point constant for <code>Math.PI</code>.\n *\n * @alias czm_pi\n * @glslConstant\n *\n * @see CesiumMath.PI\n *\n * @example\n * // GLSL declaration\n * const float czm_pi = ...;\n *\n * // Example\n * float twoPi = 2.0 * czm_pi;\n */\nconst float czm_pi = 3.141592653589793;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/piOverFour.js
var piOverFour_default = "/**\n * A built-in GLSL floating-point constant for <code>pi/4</code>.\n *\n * @alias czm_piOverFour\n * @glslConstant\n *\n * @see CesiumMath.PI_OVER_FOUR\n *\n * @example\n * // GLSL declaration\n * const float czm_piOverFour = ...;\n *\n * // Example\n * float pi = 4.0 * czm_piOverFour;\n */\nconst float czm_piOverFour = 0.7853981633974483;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/piOverSix.js
var piOverSix_default = "/**\n * A built-in GLSL floating-point constant for <code>pi/6</code>.\n *\n * @alias czm_piOverSix\n * @glslConstant\n *\n * @see CesiumMath.PI_OVER_SIX\n *\n * @example\n * // GLSL declaration\n * const float czm_piOverSix = ...;\n *\n * // Example\n * float pi = 6.0 * czm_piOverSix;\n */\nconst float czm_piOverSix = 0.5235987755982988;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/piOverThree.js
var piOverThree_default = "/**\n * A built-in GLSL floating-point constant for <code>pi/3</code>.\n *\n * @alias czm_piOverThree\n * @glslConstant\n *\n * @see CesiumMath.PI_OVER_THREE\n *\n * @example\n * // GLSL declaration\n * const float czm_piOverThree = ...;\n *\n * // Example\n * float pi = 3.0 * czm_piOverThree;\n */\nconst float czm_piOverThree = 1.0471975511965976;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/piOverTwo.js
var piOverTwo_default = "/**\n * A built-in GLSL floating-point constant for <code>pi/2</code>.\n *\n * @alias czm_piOverTwo\n * @glslConstant\n *\n * @see CesiumMath.PI_OVER_TWO\n *\n * @example\n * // GLSL declaration\n * const float czm_piOverTwo = ...;\n *\n * // Example\n * float pi = 2.0 * czm_piOverTwo;\n */\nconst float czm_piOverTwo = 1.5707963267948966;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/radiansPerDegree.js
var radiansPerDegree_default = "/**\n * A built-in GLSL floating-point constant for converting degrees to radians.\n *\n * @alias czm_radiansPerDegree\n * @glslConstant\n *\n * @see CesiumMath.RADIANS_PER_DEGREE\n *\n * @example\n * // GLSL declaration\n * const float czm_radiansPerDegree = ...;\n *\n * // Example\n * float rad = czm_radiansPerDegree * deg;\n */\nconst float czm_radiansPerDegree = 0.017453292519943295;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/sceneMode2D.js
var sceneMode2D_default = "/**\n * The constant identifier for the 2D {@link SceneMode}\n *\n * @name czm_sceneMode2D\n * @glslConstant\n * @see czm_sceneMode\n * @see czm_sceneModeColumbusView\n * @see czm_sceneMode3D\n * @see czm_sceneModeMorphing\n */\nconst float czm_sceneMode2D = 2.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/sceneMode3D.js
var sceneMode3D_default = "/**\n * The constant identifier for the 3D {@link SceneMode}\n *\n * @name czm_sceneMode3D\n * @glslConstant\n * @see czm_sceneMode\n * @see czm_sceneMode2D\n * @see czm_sceneModeColumbusView\n * @see czm_sceneModeMorphing\n */\nconst float czm_sceneMode3D = 3.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/sceneModeColumbusView.js
var sceneModeColumbusView_default = "/**\n * The constant identifier for the Columbus View {@link SceneMode}\n *\n * @name czm_sceneModeColumbusView\n * @glslConstant\n * @see czm_sceneMode\n * @see czm_sceneMode2D\n * @see czm_sceneMode3D\n * @see czm_sceneModeMorphing\n */\nconst float czm_sceneModeColumbusView = 1.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/sceneModeMorphing.js
var sceneModeMorphing_default = "/**\n * The constant identifier for the Morphing {@link SceneMode}\n *\n * @name czm_sceneModeMorphing\n * @glslConstant\n * @see czm_sceneMode\n * @see czm_sceneMode2D\n * @see czm_sceneModeColumbusView\n * @see czm_sceneMode3D\n */\nconst float czm_sceneModeMorphing = 0.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/solarRadius.js
var solarRadius_default = "/**\n * A built-in GLSL floating-point constant for one solar radius.\n *\n * @alias czm_solarRadius\n * @glslConstant\n *\n * @see CesiumMath.SOLAR_RADIUS\n *\n * @example\n * // GLSL declaration\n * const float czm_solarRadius = ...;\n */\nconst float czm_solarRadius = 695500000.0;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/threePiOver2.js
var threePiOver2_default = "/**\n * A built-in GLSL floating-point constant for <code>3pi/2</code>.\n *\n * @alias czm_threePiOver2\n * @glslConstant\n *\n * @see CesiumMath.THREE_PI_OVER_TWO\n *\n * @example\n * // GLSL declaration\n * const float czm_threePiOver2 = ...;\n *\n * // Example\n * float pi = (2.0 / 3.0) * czm_threePiOver2;\n */\nconst float czm_threePiOver2 = 4.71238898038469;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/twoPi.js
var twoPi_default = "/**\n * A built-in GLSL floating-point constant for <code>2pi</code>.\n *\n * @alias czm_twoPi\n * @glslConstant\n *\n * @see CesiumMath.TWO_PI\n *\n * @example\n * // GLSL declaration\n * const float czm_twoPi = ...;\n *\n * // Example\n * float pi = czm_twoPi / 2.0;\n */\nconst float czm_twoPi = 6.283185307179586;\n";

// node_modules/cesium/Source/Shaders/Builtin/Constants/webMercatorMaxLatitude.js
var webMercatorMaxLatitude_default = "/**\n * The maximum latitude, in radians, both North and South, supported by a Web Mercator\n * (EPSG:3857) projection.  Technically, the Mercator projection is defined\n * for any latitude up to (but not including) 90 degrees, but it makes sense\n * to cut it off sooner because it grows exponentially with increasing latitude.\n * The logic behind this particular cutoff value, which is the one used by\n * Google Maps, Bing Maps, and Esri, is that it makes the projection\n * square.  That is, the rectangle is equal in the X and Y directions.\n *\n * The constant value is computed as follows:\n *   czm_pi * 0.5 - (2.0 * atan(exp(-czm_pi)))\n *\n * @name czm_webMercatorMaxLatitude\n * @glslConstant\n */\nconst float czm_webMercatorMaxLatitude = 1.4844222297453324;\n";

// node_modules/cesium/Source/Shaders/Builtin/Structs/depthRangeStruct.js
var depthRangeStruct_default = "/**\n * @name czm_depthRangeStruct\n * @glslStruct\n */\nstruct czm_depthRangeStruct\n{\n    float near;\n    float far;\n};\n";

// node_modules/cesium/Source/Shaders/Builtin/Structs/material.js
var material_default = "/**\n * Holds material information that can be used for lighting. Returned by all czm_getMaterial functions.\n *\n * @name czm_material\n * @glslStruct\n *\n * @property {vec3} diffuse Incoming light that scatters evenly in all directions.\n * @property {float} specular Intensity of incoming light reflecting in a single direction.\n * @property {float} shininess The sharpness of the specular reflection.  Higher values create a smaller, more focused specular highlight.\n * @property {vec3} normal Surface's normal in eye coordinates. It is used for effects such as normal mapping. The default is the surface's unmodified normal.\n * @property {vec3} emission Light emitted by the material equally in all directions. The default is vec3(0.0), which emits no light.\n * @property {float} alpha Alpha of this material. 0.0 is completely transparent; 1.0 is completely opaque.\n */\nstruct czm_material\n{\n    vec3 diffuse;\n    float specular;\n    float shininess;\n    vec3 normal;\n    vec3 emission;\n    float alpha;\n};\n";

// node_modules/cesium/Source/Shaders/Builtin/Structs/materialInput.js
var materialInput_default = "/**\n * Used as input to every material's czm_getMaterial function.\n *\n * @name czm_materialInput\n * @glslStruct\n *\n * @property {float} s 1D texture coordinates.\n * @property {vec2} st 2D texture coordinates.\n * @property {vec3} str 3D texture coordinates.\n * @property {vec3} normalEC Unperturbed surface normal in eye coordinates.\n * @property {mat3} tangentToEyeMatrix Matrix for converting a tangent space normal to eye space.\n * @property {vec3} positionToEyeEC Vector from the fragment to the eye in eye coordinates.  The magnitude is the distance in meters from the fragment to the eye.\n * @property {float} height The height of the terrain in meters above or below the WGS84 ellipsoid.  Only available for globe materials.\n * @property {float} slope The slope of the terrain in radians.  0 is flat; pi/2 is vertical.  Only available for globe materials.\n * @property {float} aspect The aspect of the terrain in radians.  0 is East, pi/2 is North, pi is West, 3pi/2 is South.  Only available for globe materials.\n */\nstruct czm_materialInput\n{\n    float s;\n    vec2 st;\n    vec3 str;\n    vec3 normalEC;\n    mat3 tangentToEyeMatrix;\n    vec3 positionToEyeEC;\n    float height;\n    float slope;\n    float aspect;\n};\n";

// node_modules/cesium/Source/Shaders/Builtin/Structs/modelMaterial.js
var modelMaterial_default = "/**\n * Struct for representing a material for a {@link ModelExperimental}. The model\n * rendering pipeline will pass this struct between material, custom shaders,\n * and lighting stages. This is not to be confused with {@link czm_material}\n * which is used by the older Fabric materials system, although they are similar\n *\n * @name czm_modelMaterial\n * @glslStruct\n *\n * @property {vec3} diffuse Incoming light that scatters evenly in all directions.\n * @property {float} alpha Alpha of this material. 0.0 is completely transparent; 1.0 is completely opaque.\n * @property {vec3} specular Color of reflected light at normal incidence in PBR materials. This is sometimes referred to as f0 in the literature.\n * @property {float} roughness A number from 0.0 to 1.0 representing how rough the surface is. Values near 0.0 produce glossy surfaces, while values near 1.0 produce rough surfaces.\n * @property {vec3} normalEC Surface's normal in eye coordinates. It is used for effects such as normal mapping. The default is the surface's unmodified normal.\n * @property {float} occlusion Ambient occlusion recieved at this point on the material. 1.0 means fully lit, 0.0 means fully occluded.\n * @property {vec3} emissive Light emitted by the material equally in all directions. The default is vec3(0.0), which emits no light.\n */\nstruct czm_modelMaterial {\n    vec3 diffuse;\n    float alpha;\n    vec3 specular;\n    float roughness;\n    vec3 normalEC;\n    float occlusion;\n    vec3 emissive;\n};\n";

// node_modules/cesium/Source/Shaders/Builtin/Structs/modelVertexOutput.js
var modelVertexOutput_default = "/**\n * Struct for representing the output of a custom vertex shader.\n * \n * @name czm_modelVertexOutput\n * @glslStruct\n *\n * @see {@link CustomShader}\n * @see {@link ModelExperimental}\n *\n * @property {vec3} positionMC The position of the vertex in model coordinates\n * @property {float} pointSize A custom value for gl_PointSize. This is only used for point primitives. \n */\nstruct czm_modelVertexOutput {\n  vec3 positionMC;\n  float pointSize;\n};\n";

// node_modules/cesium/Source/Shaders/Builtin/Structs/pbrParameters.js
var pbrParameters_default = "/**\n * Parameters for {@link czm_pbrLighting}\n *\n * @name czm_material\n * @glslStruct\n *\n * @property {vec3} diffuseColor the diffuse color of the material for the lambert term of the rendering equation\n * @property {float} roughness a value from 0.0 to 1.0 that indicates how rough the surface of the material is.\n * @property {vec3} f0 The reflectance of the material at normal incidence\n */\nstruct czm_pbrParameters\n{\n    vec3 diffuseColor;\n    float roughness;\n    vec3 f0;\n};\n";

// node_modules/cesium/Source/Shaders/Builtin/Structs/ray.js
var ray_default = "/**\n * DOC_TBA\n *\n * @name czm_ray\n * @glslStruct\n */\nstruct czm_ray\n{\n    vec3 origin;\n    vec3 direction;\n};\n";

// node_modules/cesium/Source/Shaders/Builtin/Structs/raySegment.js
var raySegment_default = "/**\n * DOC_TBA\n *\n * @name czm_raySegment\n * @glslStruct\n */\nstruct czm_raySegment\n{\n    float start;\n    float stop;\n};\n\n/**\n * DOC_TBA\n *\n * @name czm_emptyRaySegment\n * @glslConstant \n */\nconst czm_raySegment czm_emptyRaySegment = czm_raySegment(-czm_infinity, -czm_infinity);\n\n/**\n * DOC_TBA\n *\n * @name czm_fullRaySegment\n * @glslConstant \n */\nconst czm_raySegment czm_fullRaySegment = czm_raySegment(0.0, czm_infinity);\n";

// node_modules/cesium/Source/Shaders/Builtin/Structs/shadowParameters.js
var shadowParameters_default = "struct czm_shadowParameters\n{\n#ifdef USE_CUBE_MAP_SHADOW\n    vec3 texCoords;\n#else\n    vec2 texCoords;\n#endif\n\n    float depthBias;\n    float depth;\n    float nDotL;\n    vec2 texelStepSize;\n    float normalShadingSmooth;\n    float darkness;\n};\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/HSBToRGB.js
var HSBToRGB_default = "/**\n * Converts an HSB color (hue, saturation, brightness) to RGB\n * HSB <-> RGB conversion with minimal branching: {@link http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl}\n *\n * @name czm_HSBToRGB\n * @glslFunction\n * \n * @param {vec3} hsb The color in HSB.\n *\n * @returns {vec3} The color in RGB.\n *\n * @example\n * vec3 hsb = czm_RGBToHSB(rgb);\n * hsb.z *= 0.1;\n * rgb = czm_HSBToRGB(hsb);\n */\n\nconst vec4 K_HSB2RGB = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n\nvec3 czm_HSBToRGB(vec3 hsb)\n{\n    vec3 p = abs(fract(hsb.xxx + K_HSB2RGB.xyz) * 6.0 - K_HSB2RGB.www);\n    return hsb.z * mix(K_HSB2RGB.xxx, clamp(p - K_HSB2RGB.xxx, 0.0, 1.0), hsb.y);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/HSLToRGB.js
var HSLToRGB_default = "/**\n * Converts an HSL color (hue, saturation, lightness) to RGB\n * HSL <-> RGB conversion: {@link http://www.chilliant.com/rgb2hsv.html}\n *\n * @name czm_HSLToRGB\n * @glslFunction\n * \n * @param {vec3} rgb The color in HSL.\n *\n * @returns {vec3} The color in RGB.\n *\n * @example\n * vec3 hsl = czm_RGBToHSL(rgb);\n * hsl.z *= 0.1;\n * rgb = czm_HSLToRGB(hsl);\n */\n\nvec3 hueToRGB(float hue)\n{\n    float r = abs(hue * 6.0 - 3.0) - 1.0;\n    float g = 2.0 - abs(hue * 6.0 - 2.0);\n    float b = 2.0 - abs(hue * 6.0 - 4.0);\n    return clamp(vec3(r, g, b), 0.0, 1.0);\n}\n\nvec3 czm_HSLToRGB(vec3 hsl)\n{\n    vec3 rgb = hueToRGB(hsl.x);\n    float c = (1.0 - abs(2.0 * hsl.z - 1.0)) * hsl.y;\n    return (rgb - 0.5) * c + hsl.z;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/RGBToHSB.js
var RGBToHSB_default = "/**\n * Converts an RGB color to HSB (hue, saturation, brightness)\n * HSB <-> RGB conversion with minimal branching: {@link http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl}\n *\n * @name czm_RGBToHSB\n * @glslFunction\n * \n * @param {vec3} rgb The color in RGB.\n *\n * @returns {vec3} The color in HSB.\n *\n * @example\n * vec3 hsb = czm_RGBToHSB(rgb);\n * hsb.z *= 0.1;\n * rgb = czm_HSBToRGB(hsb);\n */\n\nconst vec4 K_RGB2HSB = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n\nvec3 czm_RGBToHSB(vec3 rgb)\n{\n    vec4 p = mix(vec4(rgb.bg, K_RGB2HSB.wz), vec4(rgb.gb, K_RGB2HSB.xy), step(rgb.b, rgb.g));\n    vec4 q = mix(vec4(p.xyw, rgb.r), vec4(rgb.r, p.yzx), step(p.x, rgb.r));\n\n    float d = q.x - min(q.w, q.y);\n    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + czm_epsilon7)), d / (q.x + czm_epsilon7), q.x);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/RGBToHSL.js
var RGBToHSL_default = "/**\n * Converts an RGB color to HSL (hue, saturation, lightness)\n * HSL <-> RGB conversion: {@link http://www.chilliant.com/rgb2hsv.html}\n *\n * @name czm_RGBToHSL\n * @glslFunction\n * \n * @param {vec3} rgb The color in RGB.\n *\n * @returns {vec3} The color in HSL.\n *\n * @example\n * vec3 hsl = czm_RGBToHSL(rgb);\n * hsl.z *= 0.1;\n * rgb = czm_HSLToRGB(hsl);\n */\n \nvec3 RGBtoHCV(vec3 rgb)\n{\n    // Based on work by Sam Hocevar and Emil Persson\n    vec4 p = (rgb.g < rgb.b) ? vec4(rgb.bg, -1.0, 2.0 / 3.0) : vec4(rgb.gb, 0.0, -1.0 / 3.0);\n    vec4 q = (rgb.r < p.x) ? vec4(p.xyw, rgb.r) : vec4(rgb.r, p.yzx);\n    float c = q.x - min(q.w, q.y);\n    float h = abs((q.w - q.y) / (6.0 * c + czm_epsilon7) + q.z);\n    return vec3(h, c, q.x);\n}\n\nvec3 czm_RGBToHSL(vec3 rgb)\n{\n    vec3 hcv = RGBtoHCV(rgb);\n    float l = hcv.z - hcv.y * 0.5;\n    float s = hcv.y / (1.0 - abs(l * 2.0 - 1.0) + czm_epsilon7);\n    return vec3(hcv.x, s, l);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/RGBToXYZ.js
var RGBToXYZ_default = "/**\n * Converts an RGB color to CIE Yxy.\n * <p>The conversion is described in\n * {@link http://content.gpwiki.org/index.php/D3DBook:High-Dynamic_Range_Rendering#Luminance_Transform|Luminance Transform}\n * </p>\n * \n * @name czm_RGBToXYZ\n * @glslFunction\n * \n * @param {vec3} rgb The color in RGB.\n *\n * @returns {vec3} The color in CIE Yxy.\n *\n * @example\n * vec3 xyz = czm_RGBToXYZ(rgb);\n * xyz.x = max(xyz.x - luminanceThreshold, 0.0);\n * rgb = czm_XYZToRGB(xyz);\n */\nvec3 czm_RGBToXYZ(vec3 rgb)\n{\n    const mat3 RGB2XYZ = mat3(0.4124, 0.2126, 0.0193,\n                              0.3576, 0.7152, 0.1192,\n                              0.1805, 0.0722, 0.9505);\n    vec3 xyz = RGB2XYZ * rgb;\n    vec3 Yxy;\n    Yxy.r = xyz.g;\n    float temp = dot(vec3(1.0), xyz);\n    Yxy.gb = xyz.rg / temp;\n    return Yxy;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/XYZToRGB.js
var XYZToRGB_default = "/**\n * Converts a CIE Yxy color to RGB.\n * <p>The conversion is described in\n * {@link http://content.gpwiki.org/index.php/D3DBook:High-Dynamic_Range_Rendering#Luminance_Transform|Luminance Transform}\n * </p>\n * \n * @name czm_XYZToRGB\n * @glslFunction\n * \n * @param {vec3} Yxy The color in CIE Yxy.\n *\n * @returns {vec3} The color in RGB.\n *\n * @example\n * vec3 xyz = czm_RGBToXYZ(rgb);\n * xyz.x = max(xyz.x - luminanceThreshold, 0.0);\n * rgb = czm_XYZToRGB(xyz);\n */\nvec3 czm_XYZToRGB(vec3 Yxy)\n{\n    const mat3 XYZ2RGB = mat3( 3.2405, -0.9693,  0.0556,\n                              -1.5371,  1.8760, -0.2040,\n                              -0.4985,  0.0416,  1.0572);\n    vec3 xyz;\n    xyz.r = Yxy.r * Yxy.g / Yxy.b;\n    xyz.g = Yxy.r;\n    xyz.b = Yxy.r * (1.0 - Yxy.g - Yxy.b) / Yxy.b;\n    \n    return XYZ2RGB * xyz;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/acesTonemapping.js
var acesTonemapping_default = "// See:\n//    https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/\n\nvec3 czm_acesTonemapping(vec3 color) {\n    float g = 0.985;\n    float a = 0.065;\n    float b = 0.0001;\n    float c = 0.433;\n    float d = 0.238;\n\n    color = (color * (color + a) - b) / (color * (g * color + c) + d);\n\n    color = clamp(color, 0.0, 1.0);\n\n    return color;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/alphaWeight.js
var alphaWeight_default = "/**\n * @private\n */\nfloat czm_alphaWeight(float a)\n{\n    float z = (gl_FragCoord.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];\n\n    // See Weighted Blended Order-Independent Transparency for examples of different weighting functions:\n    // http://jcgt.org/published/0002/02/09/\n    return pow(a + 0.01, 4.0) + max(1e-2, min(3.0 * 1e3, 0.003 / (1e-5 + pow(abs(z) / 200.0, 4.0))));\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/antialias.js
var antialias_default = "/**\n * Procedural anti-aliasing by blurring two colors that meet at a sharp edge.\n *\n * @name czm_antialias\n * @glslFunction\n *\n * @param {vec4} color1 The color on one side of the edge.\n * @param {vec4} color2 The color on the other side of the edge.\n * @param {vec4} currentcolor The current color, either <code>color1</code> or <code>color2</code>.\n * @param {float} dist The distance to the edge in texture coordinates.\n * @param {float} [fuzzFactor=0.1] Controls the blurriness between the two colors.\n * @returns {vec4} The anti-aliased color.\n *\n * @example\n * // GLSL declarations\n * vec4 czm_antialias(vec4 color1, vec4 color2, vec4 currentColor, float dist, float fuzzFactor);\n * vec4 czm_antialias(vec4 color1, vec4 color2, vec4 currentColor, float dist);\n *\n * // get the color for a material that has a sharp edge at the line y = 0.5 in texture space\n * float dist = abs(textureCoordinates.t - 0.5);\n * vec4 currentColor = mix(bottomColor, topColor, step(0.5, textureCoordinates.t));\n * vec4 color = czm_antialias(bottomColor, topColor, currentColor, dist, 0.1);\n */\nvec4 czm_antialias(vec4 color1, vec4 color2, vec4 currentColor, float dist, float fuzzFactor)\n{\n    float val1 = clamp(dist / fuzzFactor, 0.0, 1.0);\n    float val2 = clamp((dist - 0.5) / fuzzFactor, 0.0, 1.0);\n    val1 = val1 * (1.0 - val2);\n    val1 = val1 * val1 * (3.0 - (2.0 * val1));\n    val1 = pow(val1, 0.5); //makes the transition nicer\n    \n    vec4 midColor = (color1 + color2) * 0.5;\n    return mix(midColor, currentColor, val1);\n}\n\nvec4 czm_antialias(vec4 color1, vec4 color2, vec4 currentColor, float dist)\n{\n    return czm_antialias(color1, color2, currentColor, dist, 0.1);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/approximateSphericalCoordinates.js
var approximateSphericalCoordinates_default = "/**\n * Approximately computes spherical coordinates given a normal.\n * Uses approximate inverse trigonometry for speed and consistency,\n * since inverse trigonometry can differ from vendor-to-vendor and when compared with the CPU.\n *\n * @name czm_approximateSphericalCoordinates\n * @glslFunction\n *\n * @param {vec3} normal arbitrary-length normal.\n *\n * @returns {vec2} Approximate latitude and longitude spherical coordinates.\n */\nvec2 czm_approximateSphericalCoordinates(vec3 normal) {\n    // Project into plane with vertical for latitude\n    float latitudeApproximation = czm_fastApproximateAtan(sqrt(normal.x * normal.x + normal.y * normal.y), normal.z);\n    float longitudeApproximation = czm_fastApproximateAtan(normal.x, normal.y);\n    return vec2(latitudeApproximation, longitudeApproximation);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/backFacing.js
var backFacing_default = "/**\n * Determines if the fragment is back facing\n *\n * @name czm_backFacing\n * @glslFunction \n * \n * @returns {bool} <code>true</code> if the fragment is back facing; otherwise, <code>false</code>.\n */\nbool czm_backFacing()\n{\n    // !gl_FrontFacing doesn't work as expected on Mac/Intel so use the more verbose form instead. See https://github.com/CesiumGS/cesium/pull/8494.\n    return gl_FrontFacing == false;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/branchFreeTernary.js
var branchFreeTernary_default = "/**\n * Branchless ternary operator to be used when it's inexpensive to explicitly\n * evaluate both possibilities for a float expression.\n *\n * @name czm_branchFreeTernary\n * @glslFunction\n *\n * @param {bool} comparison A comparison statement\n * @param {float} a Value to return if the comparison is true.\n * @param {float} b Value to return if the comparison is false.\n *\n * @returns {float} equivalent of comparison ? a : b\n */\nfloat czm_branchFreeTernary(bool comparison, float a, float b) {\n    float useA = float(comparison);\n    return a * useA + b * (1.0 - useA);\n}\n\n/**\n * Branchless ternary operator to be used when it's inexpensive to explicitly\n * evaluate both possibilities for a vec2 expression.\n *\n * @name czm_branchFreeTernary\n * @glslFunction\n *\n * @param {bool} comparison A comparison statement\n * @param {vec2} a Value to return if the comparison is true.\n * @param {vec2} b Value to return if the comparison is false.\n *\n * @returns {vec2} equivalent of comparison ? a : b\n */\nvec2 czm_branchFreeTernary(bool comparison, vec2 a, vec2 b) {\n    float useA = float(comparison);\n    return a * useA + b * (1.0 - useA);\n}\n\n/**\n * Branchless ternary operator to be used when it's inexpensive to explicitly\n * evaluate both possibilities for a vec3 expression.\n *\n * @name czm_branchFreeTernary\n * @glslFunction\n *\n * @param {bool} comparison A comparison statement\n * @param {vec3} a Value to return if the comparison is true.\n * @param {vec3} b Value to return if the comparison is false.\n *\n * @returns {vec3} equivalent of comparison ? a : b\n */\nvec3 czm_branchFreeTernary(bool comparison, vec3 a, vec3 b) {\n    float useA = float(comparison);\n    return a * useA + b * (1.0 - useA);\n}\n\n/**\n * Branchless ternary operator to be used when it's inexpensive to explicitly\n * evaluate both possibilities for a vec4 expression.\n *\n * @name czm_branchFreeTernary\n * @glslFunction\n *\n * @param {bool} comparison A comparison statement\n * @param {vec3} a Value to return if the comparison is true.\n * @param {vec3} b Value to return if the comparison is false.\n *\n * @returns {vec3} equivalent of comparison ? a : b\n */\nvec4 czm_branchFreeTernary(bool comparison, vec4 a, vec4 b) {\n    float useA = float(comparison);\n    return a * useA + b * (1.0 - useA);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/cascadeColor.js
var cascadeColor_default = "\nvec4 czm_cascadeColor(vec4 weights)\n{\n    return vec4(1.0, 0.0, 0.0, 1.0) * weights.x +\n           vec4(0.0, 1.0, 0.0, 1.0) * weights.y +\n           vec4(0.0, 0.0, 1.0, 1.0) * weights.z +\n           vec4(1.0, 0.0, 1.0, 1.0) * weights.w;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/cascadeDistance.js
var cascadeDistance_default = "\nuniform vec4 shadowMap_cascadeDistances;\n\nfloat czm_cascadeDistance(vec4 weights)\n{\n    return dot(shadowMap_cascadeDistances, weights);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/cascadeMatrix.js
var cascadeMatrix_default = "\nuniform mat4 shadowMap_cascadeMatrices[4];\n\nmat4 czm_cascadeMatrix(vec4 weights)\n{\n    return shadowMap_cascadeMatrices[0] * weights.x +\n           shadowMap_cascadeMatrices[1] * weights.y +\n           shadowMap_cascadeMatrices[2] * weights.z +\n           shadowMap_cascadeMatrices[3] * weights.w;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/cascadeWeights.js
var cascadeWeights_default = "\nuniform vec4 shadowMap_cascadeSplits[2];\n\nvec4 czm_cascadeWeights(float depthEye)\n{\n    // One component is set to 1.0 and all others set to 0.0.\n    vec4 near = step(shadowMap_cascadeSplits[0], vec4(depthEye));\n    vec4 far = step(depthEye, shadowMap_cascadeSplits[1]);\n    return near * far;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/columbusViewMorph.js
var columbusViewMorph_default = "/**\n * DOC_TBA\n *\n * @name czm_columbusViewMorph\n * @glslFunction\n */\nvec4 czm_columbusViewMorph(vec4 position2D, vec4 position3D, float time)\n{\n    // Just linear for now.\n    vec3 p = mix(position2D.xyz, position3D.xyz, time);\n    return vec4(p, 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/computePosition.js
var computePosition_default = "/**\n * Returns a position in model coordinates relative to eye taking into\n * account the current scene mode: 3D, 2D, or Columbus view.\n * <p>\n * This uses standard position attributes, <code>position3DHigh</code>, \n * <code>position3DLow</code>, <code>position2DHigh</code>, and <code>position2DLow</code>, \n * and should be used when writing a vertex shader for an {@link Appearance}.\n * </p>\n *\n * @name czm_computePosition\n * @glslFunction\n *\n * @returns {vec4} The position relative to eye.\n *\n * @example\n * vec4 p = czm_computePosition();\n * v_positionEC = (czm_modelViewRelativeToEye * p).xyz;\n * gl_Position = czm_modelViewProjectionRelativeToEye * p;\n *\n * @see czm_translateRelativeToEye\n */\nvec4 czm_computePosition();\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/cosineAndSine.js
var cosineAndSine_default = "/**\n * @private\n */\nvec2 cordic(float angle)\n{\n// Scale the vector by the appropriate factor for the 24 iterations to follow.\n    vec2 vector = vec2(6.0725293500888267e-1, 0.0);\n// Iteration 1\n    float sense = (angle < 0.0) ? -1.0 : 1.0;\n //   float factor = sense * 1.0;  // 2^-0\n    mat2 rotation = mat2(1.0, sense, -sense, 1.0);\n    vector = rotation * vector;\n    angle -= sense * 7.8539816339744828e-1;  // atan(2^-0)\n// Iteration 2\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    float factor = sense * 5.0e-1;  // 2^-1\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 4.6364760900080609e-1;  // atan(2^-1)\n// Iteration 3\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 2.5e-1;  // 2^-2\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 2.4497866312686414e-1;  // atan(2^-2)\n// Iteration 4\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 1.25e-1;  // 2^-3\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 1.2435499454676144e-1;  // atan(2^-3)\n// Iteration 5\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 6.25e-2;  // 2^-4\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 6.2418809995957350e-2;  // atan(2^-4)\n// Iteration 6\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 3.125e-2;  // 2^-5\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 3.1239833430268277e-2;  // atan(2^-5)\n// Iteration 7\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 1.5625e-2;  // 2^-6\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 1.5623728620476831e-2;  // atan(2^-6)\n// Iteration 8\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 7.8125e-3;  // 2^-7\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 7.8123410601011111e-3;  // atan(2^-7)\n// Iteration 9\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 3.90625e-3;  // 2^-8\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 3.9062301319669718e-3;  // atan(2^-8)\n// Iteration 10\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 1.953125e-3;  // 2^-9\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 1.9531225164788188e-3;  // atan(2^-9)\n// Iteration 11\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 9.765625e-4;  // 2^-10\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 9.7656218955931946e-4;  // atan(2^-10)\n// Iteration 12\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 4.8828125e-4;  // 2^-11\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 4.8828121119489829e-4;  // atan(2^-11)\n// Iteration 13\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 2.44140625e-4;  // 2^-12\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 2.4414062014936177e-4;  // atan(2^-12)\n// Iteration 14\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 1.220703125e-4;  // 2^-13\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 1.2207031189367021e-4;  // atan(2^-13)\n// Iteration 15\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 6.103515625e-5;  // 2^-14\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 6.1035156174208773e-5;  // atan(2^-14)\n// Iteration 16\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 3.0517578125e-5;  // 2^-15\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 3.0517578115526096e-5;  // atan(2^-15)\n// Iteration 17\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 1.52587890625e-5;  // 2^-16\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 1.5258789061315762e-5;  // atan(2^-16)\n// Iteration 18\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 7.62939453125e-6;  // 2^-17\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 7.6293945311019700e-6;  // atan(2^-17)\n// Iteration 19\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 3.814697265625e-6;  // 2^-18\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 3.8146972656064961e-6;  // atan(2^-18)\n// Iteration 20\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 1.9073486328125e-6;  // 2^-19\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 1.9073486328101870e-6;  // atan(2^-19)\n// Iteration 21\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 9.5367431640625e-7;  // 2^-20\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 9.5367431640596084e-7;  // atan(2^-20)\n// Iteration 22\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 4.76837158203125e-7;  // 2^-21\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 4.7683715820308884e-7;  // atan(2^-21)\n// Iteration 23\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 2.384185791015625e-7;  // 2^-22\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n    angle -= sense * 2.3841857910155797e-7;  // atan(2^-22)\n// Iteration 24\n    sense = (angle < 0.0) ? -1.0 : 1.0;\n    factor = sense * 1.1920928955078125e-7;  // 2^-23\n    rotation[0][1] = factor;\n    rotation[1][0] = -factor;\n    vector = rotation * vector;\n//    angle -= sense * 1.1920928955078068e-7;  // atan(2^-23)\n\n    return vector;\n}\n\n/**\n * Computes the cosine and sine of the provided angle using the CORDIC algorithm.\n *\n * @name czm_cosineAndSine\n * @glslFunction\n *\n * @param {float} angle The angle in radians.\n *\n * @returns {vec2} The resulting cosine of the angle (as the x coordinate) and sine of the angle (as the y coordinate).\n *\n * @example\n * vec2 v = czm_cosineAndSine(czm_piOverSix);\n * float cosine = v.x;\n * float sine = v.y;\n */\nvec2 czm_cosineAndSine(float angle)\n{\n    if (angle < -czm_piOverTwo || angle > czm_piOverTwo)\n    {\n        if (angle < 0.0)\n        {\n            return -cordic(angle + czm_pi);\n        }\n        else\n        {\n            return -cordic(angle - czm_pi);\n        }\n    }\n    else\n    {\n        return cordic(angle);\n    }\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/decompressTextureCoordinates.js
var decompressTextureCoordinates_default = "/**\n * Decompresses texture coordinates that were packed into a single float.\n *\n * @name czm_decompressTextureCoordinates\n * @glslFunction\n *\n * @param {float} encoded The compressed texture coordinates.\n * @returns {vec2} The decompressed texture coordinates.\n */\n vec2 czm_decompressTextureCoordinates(float encoded)\n {\n    float temp = encoded / 4096.0;\n    float xZeroTo4095 = floor(temp);\n    float stx = xZeroTo4095 / 4095.0;\n    float sty = (encoded - xZeroTo4095 * 4096.0) / 4095.0;\n    return vec2(stx, sty);\n }\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/defaultPbrMaterial.js
var defaultPbrMaterial_default = "/**\n * Get default parameters for physically based rendering. These defaults\n * describe a rough dielectric (non-metal) surface (e.g. rough plastic).\n *\n * @return {czm_pbrParameters} Default parameters for {@link czm_pbrLighting}\n */\nczm_pbrParameters czm_defaultPbrMaterial()\n{\n    czm_pbrParameters results;\n    results.diffuseColor = vec3(1.0);\n    results.roughness = 1.0;\n\n    const vec3 REFLECTANCE_DIELECTRIC = vec3(0.04);\n    results.f0 = REFLECTANCE_DIELECTRIC;\n    return results;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/depthClamp.js
var depthClamp_default = "// emulated noperspective\n#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)\nvarying float v_WindowZ;\n#endif\n\n/**\n * Emulates GL_DEPTH_CLAMP, which is not available in WebGL 1 or 2.\n * GL_DEPTH_CLAMP clamps geometry that is outside the near and far planes, \n * capping the shadow volume. More information here: \n * https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_depth_clamp.txt.\n *\n * When GL_EXT_frag_depth is available we emulate GL_DEPTH_CLAMP by ensuring \n * no geometry gets clipped by setting the clip space z value to 0.0 and then\n * sending the unaltered screen space z value (using emulated noperspective\n * interpolation) to the frag shader where it is clamped to [0,1] and then\n * written with gl_FragDepth (see czm_writeDepthClamp). This technique is based on:\n * https://stackoverflow.com/questions/5960757/how-to-emulate-gl-depth-clamp-nv.\n *\n * When GL_EXT_frag_depth is not available, which is the case on some mobile \n * devices, we must attempt to fix this only in the vertex shader. \n * The approach is to clamp the z value to the far plane, which closes the \n * shadow volume but also distorts the geometry, so there can still be artifacts\n * on frustum seams.\n *\n * @name czm_depthClamp\n * @glslFunction\n *\n * @param {vec4} coords The vertex in clip coordinates.\n * @returns {vec4} The modified vertex.\n *\n * @example\n * gl_Position = czm_depthClamp(czm_modelViewProjection * vec4(position, 1.0));\n *\n * @see czm_writeDepthClamp\n */\nvec4 czm_depthClamp(vec4 coords)\n{\n#ifndef LOG_DEPTH\n#ifdef GL_EXT_frag_depth\n    v_WindowZ = (0.5 * (coords.z / coords.w) + 0.5) * coords.w;\n    coords.z = 0.0;\n#else\n    coords.z = min(coords.z, coords.w);\n#endif\n#endif\n    return coords;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/eastNorthUpToEyeCoordinates.js
var eastNorthUpToEyeCoordinates_default = "/**\n * Computes a 3x3 rotation matrix that transforms vectors from an ellipsoid's east-north-up coordinate system \n * to eye coordinates.  In east-north-up coordinates, x points east, y points north, and z points along the \n * surface normal.  East-north-up can be used as an ellipsoid's tangent space for operations such as bump mapping.\n * <br /><br />\n * The ellipsoid is assumed to be centered at the model coordinate's origin.\n *\n * @name czm_eastNorthUpToEyeCoordinates\n * @glslFunction\n *\n * @param {vec3} positionMC The position on the ellipsoid in model coordinates.\n * @param {vec3} normalEC The normalized ellipsoid surface normal, at <code>positionMC</code>, in eye coordinates.\n *\n * @returns {mat3} A 3x3 rotation matrix that transforms vectors from the east-north-up coordinate system to eye coordinates.\n *\n * @example\n * // Transform a vector defined in the east-north-up coordinate \n * // system, (0, 0, 1) which is the surface normal, to eye \n * // coordinates.\n * mat3 m = czm_eastNorthUpToEyeCoordinates(positionMC, normalEC);\n * vec3 normalEC = m * vec3(0.0, 0.0, 1.0);\n */\nmat3 czm_eastNorthUpToEyeCoordinates(vec3 positionMC, vec3 normalEC)\n{\n    vec3 tangentMC = normalize(vec3(-positionMC.y, positionMC.x, 0.0));  // normalized surface tangent in model coordinates\n    vec3 tangentEC = normalize(czm_normal3D * tangentMC);                // normalized surface tangent in eye coordiantes\n    vec3 bitangentEC = normalize(cross(normalEC, tangentEC));            // normalized surface bitangent in eye coordinates\n\n    return mat3(\n        tangentEC.x,   tangentEC.y,   tangentEC.z,\n        bitangentEC.x, bitangentEC.y, bitangentEC.z,\n        normalEC.x,    normalEC.y,    normalEC.z);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/ellipsoidContainsPoint.js
var ellipsoidContainsPoint_default = "/**\n * DOC_TBA\n *\n * @name czm_ellipsoidContainsPoint\n * @glslFunction\n *\n */\nbool czm_ellipsoidContainsPoint(vec3 ellipsoid_inverseRadii, vec3 point)\n{\n    vec3 scaled = ellipsoid_inverseRadii * (czm_inverseModelView * vec4(point, 1.0)).xyz;\n    return (dot(scaled, scaled) <= 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/ellipsoidWgs84TextureCoordinates.js
var ellipsoidWgs84TextureCoordinates_default = "/**\n * DOC_TBA\n *\n * @name czm_ellipsoidWgs84TextureCoordinates\n * @glslFunction\n */\nvec2 czm_ellipsoidWgs84TextureCoordinates(vec3 normal)\n{\n    return vec2(atan(normal.y, normal.x) * czm_oneOverTwoPi + 0.5, asin(normal.z) * czm_oneOverPi + 0.5);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/equalsEpsilon.js
var equalsEpsilon_default = "/**\n * Compares <code>left</code> and <code>right</code> componentwise. Returns <code>true</code>\n * if they are within <code>epsilon</code> and <code>false</code> otherwise. The inputs\n * <code>left</code> and <code>right</code> can be <code>float</code>s, <code>vec2</code>s,\n * <code>vec3</code>s, or <code>vec4</code>s.\n *\n * @name czm_equalsEpsilon\n * @glslFunction\n *\n * @param {} left The first vector.\n * @param {} right The second vector.\n * @param {float} epsilon The epsilon to use for equality testing.\n * @returns {bool} <code>true</code> if the components are within <code>epsilon</code> and <code>false</code> otherwise.\n *\n * @example\n * // GLSL declarations\n * bool czm_equalsEpsilon(float left, float right, float epsilon);\n * bool czm_equalsEpsilon(vec2 left, vec2 right, float epsilon);\n * bool czm_equalsEpsilon(vec3 left, vec3 right, float epsilon);\n * bool czm_equalsEpsilon(vec4 left, vec4 right, float epsilon);\n */\nbool czm_equalsEpsilon(vec4 left, vec4 right, float epsilon) {\n    return all(lessThanEqual(abs(left - right), vec4(epsilon)));\n}\n\nbool czm_equalsEpsilon(vec3 left, vec3 right, float epsilon) {\n    return all(lessThanEqual(abs(left - right), vec3(epsilon)));\n}\n\nbool czm_equalsEpsilon(vec2 left, vec2 right, float epsilon) {\n    return all(lessThanEqual(abs(left - right), vec2(epsilon)));\n}\n\nbool czm_equalsEpsilon(float left, float right, float epsilon) {\n    return (abs(left - right) <= epsilon);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/eyeOffset.js
var eyeOffset_default = "/**\n * DOC_TBA\n *\n * @name czm_eyeOffset\n * @glslFunction\n *\n * @param {vec4} positionEC DOC_TBA.\n * @param {vec3} eyeOffset DOC_TBA.\n *\n * @returns {vec4} DOC_TBA.\n */\nvec4 czm_eyeOffset(vec4 positionEC, vec3 eyeOffset)\n{\n    // This equation is approximate in x and y.\n    vec4 p = positionEC;\n    vec4 zEyeOffset = normalize(p) * eyeOffset.z;\n    p.xy += eyeOffset.xy + zEyeOffset.xy;\n    p.z += zEyeOffset.z;\n    return p;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/eyeToWindowCoordinates.js
var eyeToWindowCoordinates_default = "/**\n * Transforms a position from eye to window coordinates.  The transformation\n * from eye to clip coordinates is done using {@link czm_projection}.\n * The transform from normalized device coordinates to window coordinates is\n * done using {@link czm_viewportTransformation}, which assumes a depth range\n * of <code>near = 0</code> and <code>far = 1</code>.\n * <br /><br />\n * This transform is useful when there is a need to manipulate window coordinates\n * in a vertex shader as done by {@link BillboardCollection}.\n *\n * @name czm_eyeToWindowCoordinates\n * @glslFunction\n *\n * @param {vec4} position The position in eye coordinates to transform.\n *\n * @returns {vec4} The transformed position in window coordinates.\n *\n * @see czm_modelToWindowCoordinates\n * @see czm_projection\n * @see czm_viewportTransformation\n * @see BillboardCollection\n *\n * @example\n * vec4 positionWC = czm_eyeToWindowCoordinates(positionEC);\n */\nvec4 czm_eyeToWindowCoordinates(vec4 positionEC)\n{\n    vec4 q = czm_projection * positionEC;                        // clip coordinates\n    q.xyz /= q.w;                                                // normalized device coordinates\n    q.xyz = (czm_viewportTransformation * vec4(q.xyz, 1.0)).xyz; // window coordinates\n    return q;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/fastApproximateAtan.js
var fastApproximateAtan_default = `/**
 * Approxiamtes atan over the range [0, 1]. Safe to flip output for negative input.
 *
 * Based on Michal Drobot's approximation from ShaderFastLibs, which in turn is based on
 * "Efficient approximations for the arctangent function," Rajan, S. Sichun Wang Inkol, R. Joyal, A., May 2006.
 * Adapted from ShaderFastLibs under MIT License.
 *
 * Chosen for the following characteristics over range [0, 1]:
 * - basically no error at 0 and 1, important for getting around range limit (naive atan2 via atan requires infinite range atan)
 * - no visible artifacts from first-derivative discontinuities, unlike latitude via range-reduced sqrt asin approximations (at equator)
 *
 * The original code is x * (-0.1784 * abs(x) - 0.0663 * x * x + 1.0301);
 * Removed the abs() in here because it isn't needed, the input range is guaranteed as [0, 1] by how we're approximating atan2.
 *
 * @name czm_fastApproximateAtan
 * @glslFunction
 *
 * @param {float} x Value between 0 and 1 inclusive.
 *
 * @returns {float} Approximation of atan(x)
 */
float czm_fastApproximateAtan(float x) {
    return x * (-0.1784 * x - 0.0663 * x * x + 1.0301);
}

/**
 * Approximation of atan2.
 *
 * Range reduction math based on nvidia's cg reference implementation for atan2: http://developer.download.nvidia.com/cg/atan2.html
 * However, we replaced their atan curve with Michael Drobot's (see above).
 *
 * @name czm_fastApproximateAtan
 * @glslFunction
 *
 * @param {float} x Value between -1 and 1 inclusive.
 * @param {float} y Value between -1 and 1 inclusive.
 *
 * @returns {float} Approximation of atan2(x, y)
 */
float czm_fastApproximateAtan(float x, float y) {
    // atan approximations are usually only reliable over [-1, 1], or, in our case, [0, 1] due to modifications.
    // So range-reduce using abs and by flipping whether x or y is on top.
    float t = abs(x); // t used as swap and atan result.
    float opposite = abs(y);
    float adjacent = max(t, opposite);
    opposite = min(t, opposite);

    t = czm_fastApproximateAtan(opposite / adjacent);

    // Undo range reduction
    t = czm_branchFreeTernary(abs(y) > abs(x), czm_piOverTwo - t, t);
    t = czm_branchFreeTernary(x < 0.0, czm_pi - t, t);
    t = czm_branchFreeTernary(y < 0.0, -t, t);
    return t;
}
`;

// node_modules/cesium/Source/Shaders/Builtin/Functions/fog.js
var fog_default = "/**\n * Gets the color with fog at a distance from the camera.\n *\n * @name czm_fog\n * @glslFunction\n *\n * @param {float} distanceToCamera The distance to the camera in meters.\n * @param {vec3} color The original color.\n * @param {vec3} fogColor The color of the fog.\n *\n * @returns {vec3} The color adjusted for fog at the distance from the camera.\n */\nvec3 czm_fog(float distanceToCamera, vec3 color, vec3 fogColor)\n{\n    float scalar = distanceToCamera * czm_fogDensity;\n    float fog = 1.0 - exp(-(scalar * scalar));\n    return mix(color, fogColor, fog);\n}\n\n/**\n * Gets the color with fog at a distance from the camera.\n *\n * @name czm_fog\n * @glslFunction\n *\n * @param {float} distanceToCamera The distance to the camera in meters.\n * @param {vec3} color The original color.\n * @param {vec3} fogColor The color of the fog.\n * @param {float} fogModifierConstant A constant to modify the appearance of fog.\n *\n * @returns {vec3} The color adjusted for fog at the distance from the camera.\n */\nvec3 czm_fog(float distanceToCamera, vec3 color, vec3 fogColor, float fogModifierConstant)\n{\n    float scalar = distanceToCamera * czm_fogDensity;\n    float fog = 1.0 - exp(-((fogModifierConstant * scalar + fogModifierConstant) * (scalar * (1.0 + fogModifierConstant))));\n    return mix(color, fogColor, fog);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/gammaCorrect.js
var gammaCorrect_default = "/**\n * Converts a color from RGB space to linear space.\n *\n * @name czm_gammaCorrect\n * @glslFunction\n *\n * @param {vec3} color The color in RGB space.\n * @returns {vec3} The color in linear space.\n */\nvec3 czm_gammaCorrect(vec3 color) {\n#ifdef HDR\n    color = pow(color, vec3(czm_gamma));\n#endif\n    return color;\n}\n\nvec4 czm_gammaCorrect(vec4 color) {\n#ifdef HDR\n    color.rgb = pow(color.rgb, vec3(czm_gamma));\n#endif\n    return color;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/geodeticSurfaceNormal.js
var geodeticSurfaceNormal_default = "/**\n * DOC_TBA\n *\n * @name czm_geodeticSurfaceNormal\n * @glslFunction\n *\n * @param {vec3} positionOnEllipsoid DOC_TBA\n * @param {vec3} ellipsoidCenter DOC_TBA\n * @param {vec3} oneOverEllipsoidRadiiSquared DOC_TBA\n * \n * @returns {vec3} DOC_TBA.\n */\nvec3 czm_geodeticSurfaceNormal(vec3 positionOnEllipsoid, vec3 ellipsoidCenter, vec3 oneOverEllipsoidRadiiSquared)\n{\n    return normalize((positionOnEllipsoid - ellipsoidCenter) * oneOverEllipsoidRadiiSquared);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/getDefaultMaterial.js
var getDefaultMaterial_default = "/**\n * An czm_material with default values. Every material's czm_getMaterial\n * should use this default material as a base for the material it returns.\n * The default normal value is given by materialInput.normalEC.\n *\n * @name czm_getDefaultMaterial\n * @glslFunction\n *\n * @param {czm_materialInput} input The input used to construct the default material.\n *\n * @returns {czm_material} The default material.\n *\n * @see czm_materialInput\n * @see czm_material\n * @see czm_getMaterial\n */\nczm_material czm_getDefaultMaterial(czm_materialInput materialInput)\n{\n    czm_material material;\n    material.diffuse = vec3(0.0);\n    material.specular = 0.0;\n    material.shininess = 1.0;\n    material.normal = materialInput.normalEC;\n    material.emission = vec3(0.0);\n    material.alpha = 1.0;\n    return material;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/getLambertDiffuse.js
var getLambertDiffuse_default = "/**\n * Calculates the intensity of diffusely reflected light.\n *\n * @name czm_getLambertDiffuse\n * @glslFunction\n *\n * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.\n * @param {vec3} normalEC The surface normal in eye coordinates.\n *\n * @returns {float} The intensity of the diffuse reflection.\n *\n * @see czm_phong\n *\n * @example\n * float diffuseIntensity = czm_getLambertDiffuse(lightDirectionEC, normalEC);\n * float specularIntensity = czm_getSpecular(lightDirectionEC, toEyeEC, normalEC, 200);\n * vec3 color = (diffuseColor * diffuseIntensity) + (specularColor * specularIntensity);\n */\nfloat czm_getLambertDiffuse(vec3 lightDirectionEC, vec3 normalEC)\n{\n    return max(dot(lightDirectionEC, normalEC), 0.0);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/getSpecular.js
var getSpecular_default = "/**\n * Calculates the specular intensity of reflected light.\n *\n * @name czm_getSpecular\n * @glslFunction\n *\n * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.\n * @param {vec3} toEyeEC Unit vector pointing to the eye position in eye coordinates.\n * @param {vec3} normalEC The surface normal in eye coordinates.\n * @param {float} shininess The sharpness of the specular reflection.  Higher values create a smaller, more focused specular highlight.\n *\n * @returns {float} The intensity of the specular highlight.\n *\n * @see czm_phong\n *\n * @example\n * float diffuseIntensity = czm_getLambertDiffuse(lightDirectionEC, normalEC);\n * float specularIntensity = czm_getSpecular(lightDirectionEC, toEyeEC, normalEC, 200);\n * vec3 color = (diffuseColor * diffuseIntensity) + (specularColor * specularIntensity);\n */\nfloat czm_getSpecular(vec3 lightDirectionEC, vec3 toEyeEC, vec3 normalEC, float shininess)\n{\n    vec3 toReflectedLight = reflect(-lightDirectionEC, normalEC);\n    float specular = max(dot(toReflectedLight, toEyeEC), 0.0);\n\n    // pow has undefined behavior if both parameters <= 0.\n    // Prevent this by making sure shininess is at least czm_epsilon2.\n    return pow(specular, max(shininess, czm_epsilon2));\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/getWaterNoise.js
var getWaterNoise_default = "/**\n * @private\n */\nvec4 czm_getWaterNoise(sampler2D normalMap, vec2 uv, float time, float angleInRadians)\n{\n    float cosAngle = cos(angleInRadians);\n    float sinAngle = sin(angleInRadians);\n\n    // time dependent sampling directions\n    vec2 s0 = vec2(1.0/17.0, 0.0);\n    vec2 s1 = vec2(-1.0/29.0, 0.0);\n    vec2 s2 = vec2(1.0/101.0, 1.0/59.0);\n    vec2 s3 = vec2(-1.0/109.0, -1.0/57.0);\n\n    // rotate sampling direction by specified angle\n    s0 = vec2((cosAngle * s0.x) - (sinAngle * s0.y), (sinAngle * s0.x) + (cosAngle * s0.y));\n    s1 = vec2((cosAngle * s1.x) - (sinAngle * s1.y), (sinAngle * s1.x) + (cosAngle * s1.y));\n    s2 = vec2((cosAngle * s2.x) - (sinAngle * s2.y), (sinAngle * s2.x) + (cosAngle * s2.y));\n    s3 = vec2((cosAngle * s3.x) - (sinAngle * s3.y), (sinAngle * s3.x) + (cosAngle * s3.y));\n\n    vec2 uv0 = (uv/103.0) + (time * s0);\n    vec2 uv1 = uv/107.0 + (time * s1) + vec2(0.23);\n    vec2 uv2 = uv/vec2(897.0, 983.0) + (time * s2) + vec2(0.51);\n    vec2 uv3 = uv/vec2(991.0, 877.0) + (time * s3) + vec2(0.71);\n\n    uv0 = fract(uv0);\n    uv1 = fract(uv1);\n    uv2 = fract(uv2);\n    uv3 = fract(uv3);\n    vec4 noise = (texture2D(normalMap, uv0)) +\n                 (texture2D(normalMap, uv1)) +\n                 (texture2D(normalMap, uv2)) +\n                 (texture2D(normalMap, uv3));\n\n    // average and scale to between -1 and 1\n    return ((noise / 4.0) - 0.5) * 2.0;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/hue.js
var hue_default = "/**\n * Adjusts the hue of a color.\n * \n * @name czm_hue\n * @glslFunction\n * \n * @param {vec3} rgb The color.\n * @param {float} adjustment The amount to adjust the hue of the color in radians.\n *\n * @returns {float} The color with the hue adjusted.\n *\n * @example\n * vec3 adjustHue = czm_hue(color, czm_pi); // The same as czm_hue(color, -czm_pi)\n */\nvec3 czm_hue(vec3 rgb, float adjustment)\n{\n    const mat3 toYIQ = mat3(0.299,     0.587,     0.114,\n                            0.595716, -0.274453, -0.321263,\n                            0.211456, -0.522591,  0.311135);\n    const mat3 toRGB = mat3(1.0,  0.9563,  0.6210,\n                            1.0, -0.2721, -0.6474,\n                            1.0, -1.107,   1.7046);\n    \n    vec3 yiq = toYIQ * rgb;\n    float hue = atan(yiq.z, yiq.y) + adjustment;\n    float chroma = sqrt(yiq.z * yiq.z + yiq.y * yiq.y);\n    \n    vec3 color = vec3(yiq.x, chroma * cos(hue), chroma * sin(hue));\n    return toRGB * color;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/inverseGamma.js
var inverseGamma_default = "/**\n * Converts a color in linear space to RGB space.\n *\n * @name czm_inverseGamma\n * @glslFunction\n *\n * @param {vec3} color The color in linear space.\n * @returns {vec3} The color in RGB space.\n */\nvec3 czm_inverseGamma(vec3 color) {\n    return pow(color, vec3(1.0 / czm_gamma));\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/isEmpty.js
var isEmpty_default = "/**\n * Determines if a time interval is empty.\n *\n * @name czm_isEmpty\n * @glslFunction \n * \n * @param {czm_raySegment} interval The interval to test.\n * \n * @returns {bool} <code>true</code> if the time interval is empty; otherwise, <code>false</code>.\n *\n * @example\n * bool b0 = czm_isEmpty(czm_emptyRaySegment);      // true\n * bool b1 = czm_isEmpty(czm_raySegment(0.0, 1.0)); // false\n * bool b2 = czm_isEmpty(czm_raySegment(1.0, 1.0)); // false, contains 1.0.\n */\nbool czm_isEmpty(czm_raySegment interval)\n{\n    return (interval.stop < 0.0);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/isFull.js
var isFull_default = "/**\n * Determines if a time interval is empty.\n *\n * @name czm_isFull\n * @glslFunction \n * \n * @param {czm_raySegment} interval The interval to test.\n * \n * @returns {bool} <code>true</code> if the time interval is empty; otherwise, <code>false</code>.\n *\n * @example\n * bool b0 = czm_isEmpty(czm_emptyRaySegment);      // true\n * bool b1 = czm_isEmpty(czm_raySegment(0.0, 1.0)); // false\n * bool b2 = czm_isEmpty(czm_raySegment(1.0, 1.0)); // false, contains 1.0.\n */\nbool czm_isFull(czm_raySegment interval)\n{\n    return (interval.start == 0.0 && interval.stop == czm_infinity);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/latitudeToWebMercatorFraction.js
var latitudeToWebMercatorFraction_default = "/**\n * Computes the fraction of a Web Wercator rectangle at which a given geodetic latitude is located.\n *\n * @name czm_latitudeToWebMercatorFraction\n * @glslFunction\n *\n * @param {float} latitude The geodetic latitude, in radians.\n * @param {float} southMercatorY The Web Mercator coordinate of the southern boundary of the rectangle.\n * @param {float} oneOverMercatorHeight The total height of the rectangle in Web Mercator coordinates.\n *\n * @returns {float} The fraction of the rectangle at which the latitude occurs.  If the latitude is the southern\n *          boundary of the rectangle, the return value will be zero.  If it is the northern boundary, the return\n *          value will be 1.0.  Latitudes in between are mapped according to the Web Mercator projection.\n */ \nfloat czm_latitudeToWebMercatorFraction(float latitude, float southMercatorY, float oneOverMercatorHeight)\n{\n    float sinLatitude = sin(latitude);\n    float mercatorY = 0.5 * log((1.0 + sinLatitude) / (1.0 - sinLatitude));\n    \n    return (mercatorY - southMercatorY) * oneOverMercatorHeight;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/lineDistance.js
var lineDistance_default = "/**\n * Computes distance from an point in 2D to a line in 2D.\n *\n * @name czm_lineDistance\n * @glslFunction\n *\n * param {vec2} point1 A point along the line.\n * param {vec2} point2 A point along the line.\n * param {vec2} point A point that may or may not be on the line.\n * returns {float} The distance from the point to the line.\n */\nfloat czm_lineDistance(vec2 point1, vec2 point2, vec2 point) {\n    return abs((point2.y - point1.y) * point.x - (point2.x - point1.x) * point.y + point2.x * point1.y - point2.y * point1.x) / distance(point2, point1);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/linearToSrgb.js
var linearToSrgb_default = "/**\n * Converts a linear RGB color to an sRGB color.\n *\n * @param {vec3|vec4} linearIn The color in linear color space.\n * @returns {vec3|vec4} The color in sRGB color space. The vector type matches the input.\n */\nvec3 czm_linearToSrgb(vec3 linearIn) \n{\n    return pow(linearIn, vec3(1.0/2.2));\n}\n\nvec4 czm_linearToSrgb(vec4 linearIn) \n{\n    vec3 srgbOut = pow(linearIn.rgb, vec3(1.0/2.2));\n    return vec4(srgbOut, linearIn.a);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/luminance.js
var luminance_default = "/**\n * Computes the luminance of a color. \n *\n * @name czm_luminance\n * @glslFunction\n *\n * @param {vec3} rgb The color.\n * \n * @returns {float} The luminance.\n *\n * @example\n * float light = czm_luminance(vec3(0.0)); // 0.0\n * float dark = czm_luminance(vec3(1.0));  // ~1.0 \n */\nfloat czm_luminance(vec3 rgb)\n{\n    // Algorithm from Chapter 10 of Graphics Shaders.\n    const vec3 W = vec3(0.2125, 0.7154, 0.0721);\n    return dot(rgb, W);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/metersPerPixel.js
var metersPerPixel_default = "/**\n * Computes the size of a pixel in meters at a distance from the eye.\n * <p>\n * Use this version when passing in a custom pixel ratio. For example, passing in 1.0 will return meters per native device pixel.\n * </p>\n * @name czm_metersPerPixel\n * @glslFunction\n *\n * @param {vec3} positionEC The position to get the meters per pixel in eye coordinates.\n * @param {float} pixelRatio The scaling factor from pixel space to coordinate space\n *\n * @returns {float} The meters per pixel at positionEC.\n */\nfloat czm_metersPerPixel(vec4 positionEC, float pixelRatio)\n{\n    float width = czm_viewport.z;\n    float height = czm_viewport.w;\n    float pixelWidth;\n    float pixelHeight;\n\n    float top = czm_frustumPlanes.x;\n    float bottom = czm_frustumPlanes.y;\n    float left = czm_frustumPlanes.z;\n    float right = czm_frustumPlanes.w;\n\n    if (czm_sceneMode == czm_sceneMode2D || czm_orthographicIn3D == 1.0)\n    {\n        float frustumWidth = right - left;\n        float frustumHeight = top - bottom;\n        pixelWidth = frustumWidth / width;\n        pixelHeight = frustumHeight / height;\n    }\n    else\n    {\n        float distanceToPixel = -positionEC.z;\n        float inverseNear = 1.0 / czm_currentFrustum.x;\n        float tanTheta = top * inverseNear;\n        pixelHeight = 2.0 * distanceToPixel * tanTheta / height;\n        tanTheta = right * inverseNear;\n        pixelWidth = 2.0 * distanceToPixel * tanTheta / width;\n    }\n\n    return max(pixelWidth, pixelHeight) * pixelRatio;\n}\n\n/**\n * Computes the size of a pixel in meters at a distance from the eye.\n * <p>\n * Use this version when scaling by pixel ratio.\n * </p>\n * @name czm_metersPerPixel\n * @glslFunction\n *\n * @param {vec3} positionEC The position to get the meters per pixel in eye coordinates.\n *\n * @returns {float} The meters per pixel at positionEC.\n */\nfloat czm_metersPerPixel(vec4 positionEC)\n{\n    return czm_metersPerPixel(positionEC, czm_pixelRatio);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/modelToWindowCoordinates.js
var modelToWindowCoordinates_default = "/**\n * Transforms a position from model to window coordinates.  The transformation\n * from model to clip coordinates is done using {@link czm_modelViewProjection}.\n * The transform from normalized device coordinates to window coordinates is\n * done using {@link czm_viewportTransformation}, which assumes a depth range\n * of <code>near = 0</code> and <code>far = 1</code>.\n * <br /><br />\n * This transform is useful when there is a need to manipulate window coordinates\n * in a vertex shader as done by {@link BillboardCollection}.\n * <br /><br />\n * This function should not be confused with {@link czm_viewportOrthographic},\n * which is an orthographic projection matrix that transforms from window \n * coordinates to clip coordinates.\n *\n * @name czm_modelToWindowCoordinates\n * @glslFunction\n *\n * @param {vec4} position The position in model coordinates to transform.\n *\n * @returns {vec4} The transformed position in window coordinates.\n *\n * @see czm_eyeToWindowCoordinates\n * @see czm_modelViewProjection\n * @see czm_viewportTransformation\n * @see czm_viewportOrthographic\n * @see BillboardCollection\n *\n * @example\n * vec4 positionWC = czm_modelToWindowCoordinates(positionMC);\n */\nvec4 czm_modelToWindowCoordinates(vec4 position)\n{\n    vec4 q = czm_modelViewProjection * position;                // clip coordinates\n    q.xyz /= q.w;                                                // normalized device coordinates\n    q.xyz = (czm_viewportTransformation * vec4(q.xyz, 1.0)).xyz; // window coordinates\n    return q;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/multiplyWithColorBalance.js
var multiplyWithColorBalance_default = "/**\n * DOC_TBA\n *\n * @name czm_multiplyWithColorBalance\n * @glslFunction\n */\nvec3 czm_multiplyWithColorBalance(vec3 left, vec3 right)\n{\n    // Algorithm from Chapter 10 of Graphics Shaders.\n    const vec3 W = vec3(0.2125, 0.7154, 0.0721);\n    \n    vec3 target = left * right;\n    float leftLuminance = dot(left, W);\n    float rightLuminance = dot(right, W);\n    float targetLuminance = dot(target, W);\n    \n    return ((leftLuminance + rightLuminance) / (2.0 * targetLuminance)) * target;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/nearFarScalar.js
var nearFarScalar_default = "/**\n * Computes a value that scales with distance.  The scaling is clamped at the near and\n * far distances, and does not extrapolate.  This function works with the\n * {@link NearFarScalar} JavaScript class.\n *\n * @name czm_nearFarScalar\n * @glslFunction\n *\n * @param {vec4} nearFarScalar A vector with 4 components: Near distance (x), Near value (y), Far distance (z), Far value (w).\n * @param {float} cameraDistSq The square of the current distance from the camera.\n *\n * @returns {float} The value at this distance.\n */\nfloat czm_nearFarScalar(vec4 nearFarScalar, float cameraDistSq)\n{\n    float valueAtMin = nearFarScalar.y;\n    float valueAtMax = nearFarScalar.w;\n    float nearDistanceSq = nearFarScalar.x * nearFarScalar.x;\n    float farDistanceSq = nearFarScalar.z * nearFarScalar.z;\n\n    float t = (cameraDistSq - nearDistanceSq) / (farDistanceSq - nearDistanceSq);\n\n    t = pow(clamp(t, 0.0, 1.0), 0.2);\n\n    return mix(valueAtMin, valueAtMax, t);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/octDecode.js
var octDecode_default = ` /**
  * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component Cartesian vector.
  * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
  * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
  *
  * @name czm_octDecode
  * @param {vec2} encoded The oct-encoded, unit-length vector
  * @param {float} range The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.
  * @returns {vec3} The decoded and normalized vector
  */
  vec3 czm_octDecode(vec2 encoded, float range)
  {
      if (encoded.x == 0.0 && encoded.y == 0.0) {
          return vec3(0.0, 0.0, 0.0);
      }

     encoded = encoded / range * 2.0 - 1.0;
     vec3 v = vec3(encoded.x, encoded.y, 1.0 - abs(encoded.x) - abs(encoded.y));
     if (v.z < 0.0)
     {
         v.xy = (1.0 - abs(v.yx)) * czm_signNotZero(v.xy);
     }

     return normalize(v);
  }

/**
 * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component Cartesian vector.
 * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
 * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
 *
 * @name czm_octDecode
 * @param {vec2} encoded The oct-encoded, unit-length vector
 * @returns {vec3} The decoded and normalized vector
 */
 vec3 czm_octDecode(vec2 encoded)
 {
    return czm_octDecode(encoded, 255.0);
 }

 /**
 * Decodes a unit-length vector in 'oct' encoding packed into a floating-point number to a normalized 3-component Cartesian vector.
 * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
 * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
 *
 * @name czm_octDecode
 * @param {float} encoded The oct-encoded, unit-length vector
 * @returns {vec3} The decoded and normalized vector
 */
 vec3 czm_octDecode(float encoded)
 {
    float temp = encoded / 256.0;
    float x = floor(temp);
    float y = (temp - x) * 256.0;
    return czm_octDecode(vec2(x, y));
 }

/**
 * Decodes three unit-length vectors in 'oct' encoding packed into two floating-point numbers to normalized 3-component Cartesian vectors.
 * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
 * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
 *
 * @name czm_octDecode
 * @param {vec2} encoded The packed oct-encoded, unit-length vectors.
 * @param {vec3} vector1 One decoded and normalized vector.
 * @param {vec3} vector2 One decoded and normalized vector.
 * @param {vec3} vector3 One decoded and normalized vector.
 */
  void czm_octDecode(vec2 encoded, out vec3 vector1, out vec3 vector2, out vec3 vector3)
 {
    float temp = encoded.x / 65536.0;
    float x = floor(temp);
    float encodedFloat1 = (temp - x) * 65536.0;

    temp = encoded.y / 65536.0;
    float y = floor(temp);
    float encodedFloat2 = (temp - y) * 65536.0;

    vector1 = czm_octDecode(encodedFloat1);
    vector2 = czm_octDecode(encodedFloat2);
    vector3 = czm_octDecode(vec2(x, y));
 }

`;

// node_modules/cesium/Source/Shaders/Builtin/Functions/packDepth.js
var packDepth_default = "/**\n * Packs a depth value into a vec3 that can be represented by unsigned bytes.\n *\n * @name czm_packDepth\n * @glslFunction\n *\n * @param {float} depth The floating-point depth.\n * @returns {vec3} The packed depth.\n */\nvec4 czm_packDepth(float depth)\n{\n    // See Aras Pranckevi\u010Dius' post Encoding Floats to RGBA\n    // http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/\n    vec4 enc = vec4(1.0, 255.0, 65025.0, 16581375.0) * depth;\n    enc = fract(enc);\n    enc -= enc.yzww * vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0);\n    return enc;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/pbrLighting.js
var pbrLighting_default = "vec3 lambertianDiffuse(vec3 diffuseColor)\n{\n    return diffuseColor / czm_pi;\n}\n\nvec3 fresnelSchlick2(vec3 f0, vec3 f90, float VdotH)\n{\n    return f0 + (f90 - f0) * pow(clamp(1.0 - VdotH, 0.0, 1.0), 5.0);\n}\n\nfloat smithVisibilityG1(float NdotV, float roughness)\n{\n    // this is the k value for direct lighting.\n    // for image based lighting it will be roughness^2 / 2\n    float k = (roughness + 1.0) * (roughness + 1.0) / 8.0;\n    return NdotV / (NdotV * (1.0 - k) + k);\n}\n\nfloat smithVisibilityGGX(float roughness, float NdotL, float NdotV)\n{\n    return (\n        smithVisibilityG1(NdotL, roughness) *\n        smithVisibilityG1(NdotV, roughness)\n    );\n}\n\nfloat GGX(float roughness, float NdotH)\n{\n    float roughnessSquared = roughness * roughness;\n    float f = (NdotH * roughnessSquared - NdotH) * NdotH + 1.0;\n    return roughnessSquared / (czm_pi * f * f);\n}\n\n/**\n * Compute the diffuse and specular contributions using physically based\n * rendering. This function only handles direct lighting.\n * <p>\n * This function only handles the lighting calculations. Metallic/roughness\n * and specular/glossy must be handled separately. See {@czm_pbrMetallicRoughnessMaterial}, {@czm_pbrSpecularGlossinessMaterial} and {@czm_defaultPbrMaterial}\n * </p>\n *\n * @name czm_pbrlighting\n * @glslFunction\n *\n * @param {vec3} positionEC The position of the fragment in eye coordinates\n * @param {vec3} normalEC The surface normal in eye coordinates\n * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.\n * @param {vec3} lightColorHdr radiance of the light source. This is a HDR value.\n * @param {czm_pbrParameters} The computed PBR parameters.\n * @return {vec3} The computed HDR color\n *\n * @example\n * czm_pbrParameters pbrParameters = czm_pbrMetallicRoughnessMaterial(\n *  baseColor,\n *  metallic,\n *  roughness\n * );\n * vec3 color = czm_pbrlighting(\n *  positionEC,\n *  normalEC,\n *  lightDirectionEC,\n *  lightColorHdr,\n *  pbrParameters);\n */\nvec3 czm_pbrLighting(\n    vec3 positionEC,\n    vec3 normalEC,\n    vec3 lightDirectionEC,\n    vec3 lightColorHdr,\n    czm_pbrParameters pbrParameters\n)\n{\n    vec3 v = -normalize(positionEC);\n    vec3 l = normalize(lightDirectionEC);\n    vec3 h = normalize(v + l);\n    vec3 n = normalEC;\n    float NdotL = clamp(dot(n, l), 0.001, 1.0);\n    float NdotV = abs(dot(n, v)) + 0.001;\n    float NdotH = clamp(dot(n, h), 0.0, 1.0);\n    float LdotH = clamp(dot(l, h), 0.0, 1.0);\n    float VdotH = clamp(dot(v, h), 0.0, 1.0);\n\n    vec3 f0 = pbrParameters.f0;\n    float reflectance = max(max(f0.r, f0.g), f0.b);\n    vec3 f90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));\n    vec3 F = fresnelSchlick2(f0, f90, VdotH);\n\n    float alpha = pbrParameters.roughness;\n    float G = smithVisibilityGGX(alpha, NdotL, NdotV);\n    float D = GGX(alpha, NdotH);\n    vec3 specularContribution = F * G * D / (4.0 * NdotL * NdotV);\n\n    vec3 diffuseColor = pbrParameters.diffuseColor;\n    // F here represents the specular contribution\n    vec3 diffuseContribution = (1.0 - F) * lambertianDiffuse(diffuseColor);\n\n    // Lo = (diffuse + specular) * Li * NdotL\n    return (diffuseContribution + specularContribution) * NdotL * lightColorHdr;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/pbrMetallicRoughnessMaterial.js
var pbrMetallicRoughnessMaterial_default = "/**\n * Compute parameters for physically based rendering using the\n * metallic/roughness workflow. All inputs are linear; sRGB texture values must\n * be decoded beforehand\n *\n * @name czm_pbrMetallicRoughnessMaterial\n * @glslFunction\n *\n * @param {vec3} baseColor For dielectrics, this is the base color. For metals, this is the f0 value (reflectance at normal incidence)\n * @param {float} metallic 0.0 indicates dielectric. 1.0 indicates metal. Values in between are allowed (e.g. to model rust or dirt);\n * @param {float} roughness A value between 0.0 and 1.0\n * @return {czm_pbrParameters} parameters to pass into {@link czm_pbrLighting}\n */\nczm_pbrParameters czm_pbrMetallicRoughnessMaterial(\n    vec3 baseColor,\n    float metallic,\n    float roughness\n) \n{\n    czm_pbrParameters results;\n\n    // roughness is authored as perceptual roughness\n    // square it to get material roughness\n    roughness = clamp(roughness, 0.0, 1.0);\n    results.roughness = roughness * roughness;\n\n    // dielectrics us f0 = 0.04, metals use albedo as f0\n    metallic = clamp(metallic, 0.0, 1.0);\n    const vec3 REFLECTANCE_DIELECTRIC = vec3(0.04);\n    vec3 f0 = mix(REFLECTANCE_DIELECTRIC, baseColor, metallic);\n    results.f0 = f0;\n\n    // diffuse only applies to dielectrics.\n    results.diffuseColor = baseColor * (1.0 - f0) * (1.0 - metallic);\n\n    return results;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/pbrSpecularGlossinessMaterial.js
var pbrSpecularGlossinessMaterial_default = "/**\n * Compute parameters for physically based rendering using the\n * specular/glossy workflow. All inputs are linear; sRGB texture values must\n * be decoded beforehand\n *\n * @name czm_pbrSpecularGlossinessMaterial\n * @glslFunction\n *\n * @param {vec3} diffuse The diffuse color for dielectrics (non-metals)\n * @param {vec3} specular The reflectance at normal incidence (f0)\n * @param {float} glossiness A number from 0.0 to 1.0 indicating how smooth the surface is.\n * @return {czm_pbrParameters} parameters to pass into {@link czm_pbrLighting}\n */\nczm_pbrParameters czm_pbrSpecularGlossinessMaterial(\n    vec3 diffuse,\n    vec3 specular,\n    float glossiness\n) \n{\n    czm_pbrParameters results;\n\n    // glossiness is the opposite of roughness, but easier for artists to use.\n    float roughness = 1.0 - glossiness;\n    results.roughness = roughness * roughness;\n\n    results.diffuseColor = diffuse * (1.0 - max(max(specular.r, specular.g), specular.b));\n    results.f0 = specular;\n\n    return results;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/phong.js
var phong_default = "float czm_private_getLambertDiffuseOfMaterial(vec3 lightDirectionEC, czm_material material)\n{\n    return czm_getLambertDiffuse(lightDirectionEC, material.normal);\n}\n\nfloat czm_private_getSpecularOfMaterial(vec3 lightDirectionEC, vec3 toEyeEC, czm_material material)\n{\n    return czm_getSpecular(lightDirectionEC, toEyeEC, material.normal, material.shininess);\n}\n\n/**\n * Computes a color using the Phong lighting model.\n *\n * @name czm_phong\n * @glslFunction\n *\n * @param {vec3} toEye A normalized vector from the fragment to the eye in eye coordinates.\n * @param {czm_material} material The fragment's material.\n *\n * @returns {vec4} The computed color.\n *\n * @example\n * vec3 positionToEyeEC = // ...\n * czm_material material = // ...\n * vec3 lightDirectionEC = // ...\n * gl_FragColor = czm_phong(normalize(positionToEyeEC), material, lightDirectionEC);\n *\n * @see czm_getMaterial\n */\nvec4 czm_phong(vec3 toEye, czm_material material, vec3 lightDirectionEC)\n{\n    // Diffuse from directional light sources at eye (for top-down)\n    float diffuse = czm_private_getLambertDiffuseOfMaterial(vec3(0.0, 0.0, 1.0), material);\n    if (czm_sceneMode == czm_sceneMode3D) {\n        // (and horizon views in 3D)\n        diffuse += czm_private_getLambertDiffuseOfMaterial(vec3(0.0, 1.0, 0.0), material);\n    }\n\n    float specular = czm_private_getSpecularOfMaterial(lightDirectionEC, toEye, material);\n\n    // Temporary workaround for adding ambient.\n    vec3 materialDiffuse = material.diffuse * 0.5;\n\n    vec3 ambient = materialDiffuse;\n    vec3 color = ambient + material.emission;\n    color += materialDiffuse * diffuse * czm_lightColor;\n    color += material.specular * specular * czm_lightColor;\n\n    return vec4(color, material.alpha);\n}\n\nvec4 czm_private_phong(vec3 toEye, czm_material material, vec3 lightDirectionEC)\n{\n    float diffuse = czm_private_getLambertDiffuseOfMaterial(lightDirectionEC, material);\n    float specular = czm_private_getSpecularOfMaterial(lightDirectionEC, toEye, material);\n\n    vec3 ambient = vec3(0.0);\n    vec3 color = ambient + material.emission;\n    color += material.diffuse * diffuse * czm_lightColor;\n    color += material.specular * specular * czm_lightColor;\n\n    return vec4(color, material.alpha);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/planeDistance.js
var planeDistance_default = "/**\n * Computes distance from a point to a plane.\n *\n * @name czm_planeDistance\n * @glslFunction\n *\n * param {vec4} plane A Plane in Hessian Normal Form. See Plane.js\n * param {vec3} point A point in the same space as the plane.\n * returns {float} The distance from the point to the plane.\n */\nfloat czm_planeDistance(vec4 plane, vec3 point) {\n    return (dot(plane.xyz, point) + plane.w);\n}\n\n/**\n * Computes distance from a point to a plane.\n *\n * @name czm_planeDistance\n * @glslFunction\n *\n * param {vec3} planeNormal Normal for a plane in Hessian Normal Form. See Plane.js\n * param {float} planeDistance Distance for a plane in Hessian Normal form. See Plane.js\n * param {vec3} point A point in the same space as the plane.\n * returns {float} The distance from the point to the plane.\n */\nfloat czm_planeDistance(vec3 planeNormal, float planeDistance, vec3 point) {\n    return (dot(planeNormal, point) + planeDistance);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/pointAlongRay.js
var pointAlongRay_default = "/**\n * Computes the point along a ray at the given time.  <code>time</code> can be positive, negative, or zero.\n *\n * @name czm_pointAlongRay\n * @glslFunction\n *\n * @param {czm_ray} ray The ray to compute the point along.\n * @param {float} time The time along the ray.\n * \n * @returns {vec3} The point along the ray at the given time.\n * \n * @example\n * czm_ray ray = czm_ray(vec3(0.0), vec3(1.0, 0.0, 0.0)); // origin, direction\n * vec3 v = czm_pointAlongRay(ray, 2.0); // (2.0, 0.0, 0.0)\n */\nvec3 czm_pointAlongRay(czm_ray ray, float time)\n{\n    return ray.origin + (time * ray.direction);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/rayEllipsoidIntersectionInterval.js
var rayEllipsoidIntersectionInterval_default = "/**\n * DOC_TBA\n *\n * @name czm_rayEllipsoidIntersectionInterval\n * @glslFunction\n */\nczm_raySegment czm_rayEllipsoidIntersectionInterval(czm_ray ray, vec3 ellipsoid_center, vec3 ellipsoid_inverseRadii)\n{\n   // ray and ellipsoid center in eye coordinates.  radii in model coordinates.\n    vec3 q = ellipsoid_inverseRadii * (czm_inverseModelView * vec4(ray.origin, 1.0)).xyz;\n    vec3 w = ellipsoid_inverseRadii * (czm_inverseModelView * vec4(ray.direction, 0.0)).xyz;\n\n    q = q - ellipsoid_inverseRadii * (czm_inverseModelView * vec4(ellipsoid_center, 1.0)).xyz;\n\n    float q2 = dot(q, q);\n    float qw = dot(q, w);\n\n    if (q2 > 1.0) // Outside ellipsoid.\n    {\n        if (qw >= 0.0) // Looking outward or tangent (0 intersections).\n        {\n            return czm_emptyRaySegment;\n        }\n        else // qw < 0.0.\n        {\n            float qw2 = qw * qw;\n            float difference = q2 - 1.0; // Positively valued.\n            float w2 = dot(w, w);\n            float product = w2 * difference;\n\n            if (qw2 < product) // Imaginary roots (0 intersections).\n            {\n                return czm_emptyRaySegment;\n            }\n            else if (qw2 > product) // Distinct roots (2 intersections).\n            {\n                float discriminant = qw * qw - product;\n                float temp = -qw + sqrt(discriminant); // Avoid cancellation.\n                float root0 = temp / w2;\n                float root1 = difference / temp;\n                if (root0 < root1)\n                {\n                    czm_raySegment i = czm_raySegment(root0, root1);\n                    return i;\n                }\n                else\n                {\n                    czm_raySegment i = czm_raySegment(root1, root0);\n                    return i;\n                }\n            }\n            else // qw2 == product.  Repeated roots (2 intersections).\n            {\n                float root = sqrt(difference / w2);\n                czm_raySegment i = czm_raySegment(root, root);\n                return i;\n            }\n        }\n    }\n    else if (q2 < 1.0) // Inside ellipsoid (2 intersections).\n    {\n        float difference = q2 - 1.0; // Negatively valued.\n        float w2 = dot(w, w);\n        float product = w2 * difference; // Negatively valued.\n        float discriminant = qw * qw - product;\n        float temp = -qw + sqrt(discriminant); // Positively valued.\n        czm_raySegment i = czm_raySegment(0.0, temp / w2);\n        return i;\n    }\n    else // q2 == 1.0. On ellipsoid.\n    {\n        if (qw < 0.0) // Looking inward.\n        {\n            float w2 = dot(w, w);\n            czm_raySegment i = czm_raySegment(0.0, -qw / w2);\n            return i;\n        }\n        else // qw >= 0.0.  Looking outward or tangent.\n        {\n            return czm_emptyRaySegment;\n        }\n    }\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/raySphereIntersectionInterval.js
var raySphereIntersectionInterval_default = "/**\n * Compute the intersection interval of a ray with a sphere.\n *\n * @name czm_raySphereIntersectionInterval\n * @glslFunction\n *\n * @param {czm_ray} ray The ray.\n * @param {vec3} center The center of the sphere.\n * @param {float} radius The radius of the sphere.\n * @return {czm_raySegment} The intersection interval of the ray with the sphere.\n */\nczm_raySegment czm_raySphereIntersectionInterval(czm_ray ray, vec3 center, float radius)\n{\n    vec3 o = ray.origin;\n    vec3 d = ray.direction;\n\n    vec3 oc = o - center;\n\n    float a = dot(d, d);\n    float b = 2.0 * dot(d, oc);\n    float c = dot(oc, oc) - (radius * radius);\n\n    float det = (b * b) - (4.0 * a * c);\n\n    if (det < 0.0) {\n        return czm_emptyRaySegment;\n    }\n\n    float sqrtDet = sqrt(det);\n\n    float t0 = (-b - sqrtDet) / (2.0 * a);\n    float t1 = (-b + sqrtDet) / (2.0 * a);\n\n    czm_raySegment result = czm_raySegment(t0, t1);\n    return result;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/readDepth.js
var readDepth_default = "float czm_readDepth(sampler2D depthTexture, vec2 texCoords)\n{\n    return czm_reverseLogDepth(texture2D(depthTexture, texCoords).r);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/readNonPerspective.js
var readNonPerspective_default = "/**\n * Reads a value previously transformed with {@link czm_writeNonPerspective}\n * by dividing it by `w`, the value used in the perspective divide.\n * This function is intended to be called in a fragment shader to access a\n * `varying` that should not be subject to perspective interpolation.\n * For example, screen-space texture coordinates. The value should have been\n * previously written in the vertex shader with a call to\n * {@link czm_writeNonPerspective}.\n *\n * @name czm_readNonPerspective\n * @glslFunction\n *\n * @param {float|vec2|vec3|vec4} value The non-perspective value to be read.\n * @param {float} oneOverW One over the perspective divide value, `w`. Usually this is simply `gl_FragCoord.w`.\n * @returns {float|vec2|vec3|vec4} The usable value.\n */\nfloat czm_readNonPerspective(float value, float oneOverW) {\n    return value * oneOverW;\n}\n\nvec2 czm_readNonPerspective(vec2 value, float oneOverW) {\n    return value * oneOverW;\n}\n\nvec3 czm_readNonPerspective(vec3 value, float oneOverW) {\n    return value * oneOverW;\n}\n\nvec4 czm_readNonPerspective(vec4 value, float oneOverW) {\n    return value * oneOverW;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/reverseLogDepth.js
var reverseLogDepth_default = "float czm_reverseLogDepth(float logZ)\n{\n#ifdef LOG_DEPTH\n    float near = czm_currentFrustum.x;\n    float far = czm_currentFrustum.y;\n    float log2Depth = logZ * czm_log2FarDepthFromNearPlusOne;\n    float depthFromNear = pow(2.0, log2Depth) - 1.0;\n    return far * (1.0 - near / (depthFromNear + near)) / (far - near);\n#endif\n    return logZ;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/round.js
var round_default = "/**\n * Round a floating point value. This function exists because round() doesn't\n * exist in GLSL 1.00. \n *\n * @param {float|vec2|vec3|vec4} value The value to round\n * @param {float|vec2|vec3|vec3} The rounded value. The type matches the input.\n */\nfloat czm_round(float value) {\n  return floor(value + 0.5);\n}\n\nvec2 czm_round(vec2 value) {\n  return floor(value + 0.5);\n}\n\nvec3 czm_round(vec3 value) {\n  return floor(value + 0.5);\n}\n\nvec4 czm_round(vec4 value) {\n  return floor(value + 0.5);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/sampleOctahedralProjection.js
var sampleOctahedralProjection_default = "/**\n * Samples the 4 neighboring pixels and return the weighted average.\n *\n * @private\n */\nvec3 czm_sampleOctahedralProjectionWithFiltering(sampler2D projectedMap, vec2 textureSize, vec3 direction, float lod)\n{\n    direction /= dot(vec3(1.0), abs(direction));\n    vec2 rev = abs(direction.zx) - vec2(1.0);\n    vec2 neg = vec2(direction.x < 0.0 ? rev.x : -rev.x,\n                    direction.z < 0.0 ? rev.y : -rev.y);\n    vec2 uv = direction.y < 0.0 ? neg : direction.xz;\n    vec2 coord = 0.5 * uv + vec2(0.5);\n    vec2 pixel = 1.0 / textureSize;\n\n    if (lod > 0.0)\n    {\n        // Each subseqeuent mip level is half the size\n        float scale = 1.0 / pow(2.0, lod);\n        float offset = ((textureSize.y + 1.0) / textureSize.x);\n\n        coord.x *= offset;\n        coord *= scale;\n\n        coord.x += offset + pixel.x;\n        coord.y += (1.0 - (1.0 / pow(2.0, lod - 1.0))) + pixel.y * (lod - 1.0) * 2.0;\n    }\n    else\n    {\n        coord.x *= (textureSize.y / textureSize.x);\n    }\n\n    // Do bilinear filtering\n    #ifndef OES_texture_float_linear\n        vec3 color1 = texture2D(projectedMap, coord + vec2(0.0, pixel.y)).rgb;\n        vec3 color2 = texture2D(projectedMap, coord + vec2(pixel.x, 0.0)).rgb;\n        vec3 color3 = texture2D(projectedMap, coord + pixel).rgb;\n        vec3 color4 = texture2D(projectedMap, coord).rgb;\n\n        vec2 texturePosition = coord * textureSize;\n\n        float fu = fract(texturePosition.x);\n        float fv = fract(texturePosition.y);\n\n        vec3 average1 = mix(color4, color2, fu);\n        vec3 average2 = mix(color1, color3, fu);\n\n        vec3 color = mix(average1, average2, fv);\n    #else\n        vec3 color = texture2D(projectedMap, coord).rgb;\n    #endif\n\n    return color;\n}\n\n\n/**\n * Samples from a cube map that has been projected using an octahedral projection from the given direction.\n *\n * @name czm_sampleOctahedralProjection\n * @glslFunction\n *\n * @param {sampler2D} projectedMap The texture with the octahedral projected cube map.\n * @param {vec2} textureSize The width and height dimensions in pixels of the projected map.\n * @param {vec3} direction The normalized direction used to sample the cube map.\n * @param {float} lod The level of detail to sample.\n * @param {float} maxLod The maximum level of detail.\n * @returns {vec3} The color of the cube map at the direction.\n */\nvec3 czm_sampleOctahedralProjection(sampler2D projectedMap, vec2 textureSize, vec3 direction, float lod, float maxLod) {\n    float currentLod = floor(lod + 0.5);\n    float nextLod = min(currentLod + 1.0, maxLod);\n\n    vec3 colorCurrentLod = czm_sampleOctahedralProjectionWithFiltering(projectedMap, textureSize, direction, currentLod);\n    vec3 colorNextLod = czm_sampleOctahedralProjectionWithFiltering(projectedMap, textureSize, direction, nextLod);\n\n    return mix(colorNextLod, colorCurrentLod, nextLod - lod);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/saturation.js
var saturation_default = "/**\n * Adjusts the saturation of a color.\n * \n * @name czm_saturation\n * @glslFunction\n * \n * @param {vec3} rgb The color.\n * @param {float} adjustment The amount to adjust the saturation of the color.\n *\n * @returns {float} The color with the saturation adjusted.\n *\n * @example\n * vec3 greyScale = czm_saturation(color, 0.0);\n * vec3 doubleSaturation = czm_saturation(color, 2.0);\n */\nvec3 czm_saturation(vec3 rgb, float adjustment)\n{\n    // Algorithm from Chapter 16 of OpenGL Shading Language\n    const vec3 W = vec3(0.2125, 0.7154, 0.0721);\n    vec3 intensity = vec3(dot(rgb, W));\n    return mix(intensity, rgb, adjustment);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/shadowDepthCompare.js
var shadowDepthCompare_default = "\nfloat czm_sampleShadowMap(highp samplerCube shadowMap, vec3 d)\n{\n    return czm_unpackDepth(textureCube(shadowMap, d));\n}\n\nfloat czm_sampleShadowMap(highp sampler2D shadowMap, vec2 uv)\n{\n#ifdef USE_SHADOW_DEPTH_TEXTURE\n    return texture2D(shadowMap, uv).r;\n#else\n    return czm_unpackDepth(texture2D(shadowMap, uv));\n#endif\n}\n\nfloat czm_shadowDepthCompare(samplerCube shadowMap, vec3 uv, float depth)\n{\n    return step(depth, czm_sampleShadowMap(shadowMap, uv));\n}\n\nfloat czm_shadowDepthCompare(sampler2D shadowMap, vec2 uv, float depth)\n{\n    return step(depth, czm_sampleShadowMap(shadowMap, uv));\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/shadowVisibility.js
var shadowVisibility_default = "\nfloat czm_private_shadowVisibility(float visibility, float nDotL, float normalShadingSmooth, float darkness)\n{\n#ifdef USE_NORMAL_SHADING\n#ifdef USE_NORMAL_SHADING_SMOOTH\n    float strength = clamp(nDotL / normalShadingSmooth, 0.0, 1.0);\n#else\n    float strength = step(0.0, nDotL);\n#endif\n    visibility *= strength;\n#endif\n\n    visibility = max(visibility, darkness);\n    return visibility;\n}\n\n#ifdef USE_CUBE_MAP_SHADOW\nfloat czm_shadowVisibility(samplerCube shadowMap, czm_shadowParameters shadowParameters)\n{\n    float depthBias = shadowParameters.depthBias;\n    float depth = shadowParameters.depth;\n    float nDotL = shadowParameters.nDotL;\n    float normalShadingSmooth = shadowParameters.normalShadingSmooth;\n    float darkness = shadowParameters.darkness;\n    vec3 uvw = shadowParameters.texCoords;\n\n    depth -= depthBias;\n    float visibility = czm_shadowDepthCompare(shadowMap, uvw, depth);\n    return czm_private_shadowVisibility(visibility, nDotL, normalShadingSmooth, darkness);\n}\n#else\nfloat czm_shadowVisibility(sampler2D shadowMap, czm_shadowParameters shadowParameters)\n{\n    float depthBias = shadowParameters.depthBias;\n    float depth = shadowParameters.depth;\n    float nDotL = shadowParameters.nDotL;\n    float normalShadingSmooth = shadowParameters.normalShadingSmooth;\n    float darkness = shadowParameters.darkness;\n    vec2 uv = shadowParameters.texCoords;\n\n    depth -= depthBias;\n#ifdef USE_SOFT_SHADOWS\n    vec2 texelStepSize = shadowParameters.texelStepSize;\n    float radius = 1.0;\n    float dx0 = -texelStepSize.x * radius;\n    float dy0 = -texelStepSize.y * radius;\n    float dx1 = texelStepSize.x * radius;\n    float dy1 = texelStepSize.y * radius;\n    float visibility = (\n        czm_shadowDepthCompare(shadowMap, uv, depth) +\n        czm_shadowDepthCompare(shadowMap, uv + vec2(dx0, dy0), depth) +\n        czm_shadowDepthCompare(shadowMap, uv + vec2(0.0, dy0), depth) +\n        czm_shadowDepthCompare(shadowMap, uv + vec2(dx1, dy0), depth) +\n        czm_shadowDepthCompare(shadowMap, uv + vec2(dx0, 0.0), depth) +\n        czm_shadowDepthCompare(shadowMap, uv + vec2(dx1, 0.0), depth) +\n        czm_shadowDepthCompare(shadowMap, uv + vec2(dx0, dy1), depth) +\n        czm_shadowDepthCompare(shadowMap, uv + vec2(0.0, dy1), depth) +\n        czm_shadowDepthCompare(shadowMap, uv + vec2(dx1, dy1), depth)\n    ) * (1.0 / 9.0);\n#else\n    float visibility = czm_shadowDepthCompare(shadowMap, uv, depth);\n#endif\n\n    return czm_private_shadowVisibility(visibility, nDotL, normalShadingSmooth, darkness);\n}\n#endif\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/signNotZero.js
var signNotZero_default = "/**\n * Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.  This is similar to the GLSL\n * built-in function <code>sign</code> except that returns 1.0 instead of 0.0 when the input value is 0.0.\n * \n * @name czm_signNotZero\n * @glslFunction\n *\n * @param {} value The value for which to determine the sign.\n * @returns {} 1.0 if the value is positive or zero, -1.0 if the value is negative.\n */\nfloat czm_signNotZero(float value)\n{\n    return value >= 0.0 ? 1.0 : -1.0;\n}\n\nvec2 czm_signNotZero(vec2 value)\n{\n    return vec2(czm_signNotZero(value.x), czm_signNotZero(value.y));\n}\n\nvec3 czm_signNotZero(vec3 value)\n{\n    return vec3(czm_signNotZero(value.x), czm_signNotZero(value.y), czm_signNotZero(value.z));\n}\n\nvec4 czm_signNotZero(vec4 value)\n{\n    return vec4(czm_signNotZero(value.x), czm_signNotZero(value.y), czm_signNotZero(value.z), czm_signNotZero(value.w));\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/sphericalHarmonics.js
var sphericalHarmonics_default = "/**\n * Computes a color from the third order spherical harmonic coefficients and a normalized direction vector.\n * <p>\n * The order of the coefficients is [L00, L1_1, L10, L11, L2_2, L2_1, L20, L21, L22].\n * </p>\n *\n * @name czm_sphericalHarmonics\n * @glslFunction\n *\n * @param {vec3} normal The normalized direction.\n * @param {vec3[9]} coefficients The third order spherical harmonic coefficients.\n * @returns {vec3} The color at the direction.\n *\n * @see https://graphics.stanford.edu/papers/envmap/envmap.pdf\n */\nvec3 czm_sphericalHarmonics(vec3 normal, vec3 coefficients[9])\n{\n    vec3 L00 = coefficients[0];\n    vec3 L1_1 = coefficients[1];\n    vec3 L10 = coefficients[2];\n    vec3 L11 = coefficients[3];\n    vec3 L2_2 = coefficients[4];\n    vec3 L2_1 = coefficients[5];\n    vec3 L20 = coefficients[6];\n    vec3 L21 = coefficients[7];\n    vec3 L22 = coefficients[8];\n\n    float x = normal.x;\n    float y = normal.y;\n    float z = normal.z;\n\n    return\n          L00\n        + L1_1 * y\n        + L10 * z\n        + L11 * x\n        + L2_2 * (y * x)\n        + L2_1 * (y * z)\n        + L20 * (3.0 * z * z - 1.0)\n        + L21 * (z * x)\n        + L22 * (x * x - y * y);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/srgbToLinear.js
var srgbToLinear_default = "/**\n * Converts an sRGB color to a linear RGB color.\n *\n * @param {vec3|vec4} srgbIn The color in sRGB space\n * @returns {vec3|vec4} The color in linear color space. The vector type matches the input.\n */\nvec3 czm_srgbToLinear(vec3 srgbIn)\n{\n    return pow(srgbIn, vec3(2.2));\n}\n\nvec4 czm_srgbToLinear(vec4 srgbIn) \n{\n    vec3 linearOut = pow(srgbIn.rgb, vec3(2.2));\n    return vec4(linearOut, srgbIn.a);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/tangentToEyeSpaceMatrix.js
var tangentToEyeSpaceMatrix_default = "/**\n * Creates a matrix that transforms vectors from tangent space to eye space.\n *\n * @name czm_tangentToEyeSpaceMatrix\n * @glslFunction\n *\n * @param {vec3} normalEC The normal vector in eye coordinates.\n * @param {vec3} tangentEC The tangent vector in eye coordinates.\n * @param {vec3} bitangentEC The bitangent vector in eye coordinates.\n *\n * @returns {mat3} The matrix that transforms from tangent space to eye space.\n *\n * @example\n * mat3 tangentToEye = czm_tangentToEyeSpaceMatrix(normalEC, tangentEC, bitangentEC);\n * vec3 normal = tangentToEye * texture2D(normalMap, st).xyz;\n */\nmat3 czm_tangentToEyeSpaceMatrix(vec3 normalEC, vec3 tangentEC, vec3 bitangentEC)\n{\n    vec3 normal = normalize(normalEC);\n    vec3 tangent = normalize(tangentEC);\n    vec3 bitangent = normalize(bitangentEC);\n    return mat3(tangent.x  , tangent.y  , tangent.z,\n                bitangent.x, bitangent.y, bitangent.z,\n                normal.x   , normal.y   , normal.z);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/transformPlane.js
var transformPlane_default = "/**\n * Transforms a plane.\n * \n * @name czm_transformPlane\n * @glslFunction\n *\n * @param {vec4} plane The plane in Hessian Normal Form.\n * @param {mat4} transform The inverse-transpose of a transformation matrix.\n */\nvec4 czm_transformPlane(vec4 plane, mat4 transform) {\n    vec4 transformedPlane = transform * plane;\n    // Convert the transformed plane to Hessian Normal Form\n    float normalMagnitude = length(transformedPlane.xyz);\n    return transformedPlane / normalMagnitude;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/translateRelativeToEye.js
var translateRelativeToEye_default = "/**\n * Translates a position (or any <code>vec3</code>) that was encoded with {@link EncodedCartesian3},\n * and then provided to the shader as separate <code>high</code> and <code>low</code> bits to\n * be relative to the eye.  As shown in the example, the position can then be transformed in eye\n * or clip coordinates using {@link czm_modelViewRelativeToEye} or {@link czm_modelViewProjectionRelativeToEye},\n * respectively.\n * <p>\n * This technique, called GPU RTE, eliminates jittering artifacts when using large coordinates as\n * described in {@link http://help.agi.com/AGIComponents/html/BlogPrecisionsPrecisions.htm|Precisions, Precisions}.\n * </p>\n *\n * @name czm_translateRelativeToEye\n * @glslFunction\n *\n * @param {vec3} high The position's high bits.\n * @param {vec3} low The position's low bits.\n * @returns {vec3} The position translated to be relative to the camera's position.\n *\n * @example\n * attribute vec3 positionHigh;\n * attribute vec3 positionLow;\n *\n * void main()\n * {\n *   vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);\n *   gl_Position = czm_modelViewProjectionRelativeToEye * p;\n * }\n *\n * @see czm_modelViewRelativeToEye\n * @see czm_modelViewProjectionRelativeToEye\n * @see czm_computePosition\n * @see EncodedCartesian3\n */\nvec4 czm_translateRelativeToEye(vec3 high, vec3 low)\n{\n    vec3 highDifference = high - czm_encodedCameraPositionMCHigh;\n    vec3 lowDifference = low - czm_encodedCameraPositionMCLow;\n\n    return vec4(highDifference + lowDifference, 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/translucentPhong.js
var translucentPhong_default = "/**\n * @private\n */\nvec4 czm_translucentPhong(vec3 toEye, czm_material material, vec3 lightDirectionEC)\n{\n    // Diffuse from directional light sources at eye (for top-down and horizon views)\n    float diffuse = czm_getLambertDiffuse(vec3(0.0, 0.0, 1.0), material.normal);\n\n    if (czm_sceneMode == czm_sceneMode3D) {\n        // (and horizon views in 3D)\n        diffuse += czm_getLambertDiffuse(vec3(0.0, 1.0, 0.0), material.normal);\n    }\n\n    diffuse = clamp(diffuse, 0.0, 1.0);\n\n    float specular = czm_getSpecular(lightDirectionEC, toEye, material.normal, material.shininess);\n\n    // Temporary workaround for adding ambient.\n    vec3 materialDiffuse = material.diffuse * 0.5;\n\n    vec3 ambient = materialDiffuse;\n    vec3 color = ambient + material.emission;\n    color += materialDiffuse * diffuse * czm_lightColor;\n    color += material.specular * specular * czm_lightColor;\n\n    return vec4(color, material.alpha);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/transpose.js
var transpose_default = "/**\n * Returns the transpose of the matrix.  The input <code>matrix</code> can be\n * a <code>mat2</code>, <code>mat3</code>, or <code>mat4</code>.\n *\n * @name czm_transpose\n * @glslFunction\n *\n * @param {} matrix The matrix to transpose.\n *\n * @returns {} The transposed matrix.\n *\n * @example\n * // GLSL declarations\n * mat2 czm_transpose(mat2 matrix);\n * mat3 czm_transpose(mat3 matrix);\n * mat4 czm_transpose(mat4 matrix);\n *\n * // Transpose a 3x3 rotation matrix to find its inverse.\n * mat3 eastNorthUpToEye = czm_eastNorthUpToEyeCoordinates(\n *     positionMC, normalEC);\n * mat3 eyeToEastNorthUp = czm_transpose(eastNorthUpToEye);\n */\nmat2 czm_transpose(mat2 matrix)\n{\n    return mat2(\n        matrix[0][0], matrix[1][0],\n        matrix[0][1], matrix[1][1]);\n}\n\nmat3 czm_transpose(mat3 matrix)\n{\n    return mat3(\n        matrix[0][0], matrix[1][0], matrix[2][0],\n        matrix[0][1], matrix[1][1], matrix[2][1],\n        matrix[0][2], matrix[1][2], matrix[2][2]);\n}\n\nmat4 czm_transpose(mat4 matrix)\n{\n    return mat4(\n        matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0],\n        matrix[0][1], matrix[1][1], matrix[2][1], matrix[3][1],\n        matrix[0][2], matrix[1][2], matrix[2][2], matrix[3][2],\n        matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]);\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/unpackDepth.js
var unpackDepth_default = "/**\n * Unpacks a vec4 depth value to a float in [0, 1) range.\n *\n * @name czm_unpackDepth\n * @glslFunction\n *\n * @param {vec4} packedDepth The packed depth.\n *\n * @returns {float} The floating-point depth in [0, 1) range.\n */\n float czm_unpackDepth(vec4 packedDepth)\n {\n    // See Aras Pranckevi\u010Dius' post Encoding Floats to RGBA\n    // http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/\n    return dot(packedDepth, vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0));\n }\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/unpackFloat.js
var unpackFloat_default = "/**\n * Unpack an IEEE 754 single-precision float that is packed as a little-endian unsigned normalized vec4.\n *\n * @name czm_unpackFloat\n * @glslFunction\n *\n * @param {vec4} packedFloat The packed float.\n *\n * @returns {float} The floating-point depth in arbitrary range.\n */\nfloat czm_unpackFloat(vec4 packedFloat)\n{\n    // Convert to [0.0, 255.0] and round to integer\n    packedFloat = floor(packedFloat * 255.0 + 0.5);\n    float sign = 1.0 - step(128.0, packedFloat[3]) * 2.0;\n    float exponent = 2.0 * mod(packedFloat[3], 128.0) + step(128.0, packedFloat[2]) - 127.0;    \n    if (exponent == -127.0)\n    {\n        return 0.0;\n    }\n    float mantissa = mod(packedFloat[2], 128.0) * 65536.0 + packedFloat[1] * 256.0 + packedFloat[0] + float(0x800000);\n    float result = sign * exp2(exponent - 23.0) * mantissa;\n    return result;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/unpackUint.js
var unpackUint_default = "/**\n * Unpack unsigned integers of 1-4 bytes. in WebGL 1, there is no uint type,\n * so the return value is an int.\n * <p>\n * There are also precision limitations in WebGL 1. highp int is still limited\n * to 24 bits. Above the value of 2^24 = 16777216, precision loss may occur.\n * </p>\n *\n * @param {float|vec2|vec3|vec4} packed The packed value. For vectors, the components are listed in little-endian order.\n *\n * @return {int} The unpacked value.\n */\n int czm_unpackUint(float packedValue) {\n   float rounded = czm_round(packedValue * 255.0);\n   return int(rounded);\n }\n\n int czm_unpackUint(vec2 packedValue) {\n   vec2 rounded = czm_round(packedValue * 255.0);\n   return int(dot(rounded, vec2(1.0, 256.0)));\n }\n\n int czm_unpackUint(vec3 packedValue) {\n   vec3 rounded = czm_round(packedValue * 255.0);\n   return int(dot(rounded, vec3(1.0, 256.0, 65536.0)));\n }\n\n int czm_unpackUint(vec4 packedValue) {\n   vec4 rounded = czm_round(packedValue * 255.0);\n   return int(dot(rounded, vec4(1.0, 256.0, 65536.0, 16777216.0)));\n }\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/valueTransform.js
var valueTransform_default = "/**\n * Transform metadata values following the EXT_structural_metadata spec\n * by multiplying by scale and adding the offset. Operations are always\n * performed component-wise, even for matrices.\n * \n * @param {float|vec2|vec3|vec4|mat2|mat3|mat4} offset The offset to add\n * @param {float|vec2|vec3|vec4|mat2|mat3|mat4} scale The scale factor to multiply\n * @param {float|vec2|vec3|vec4|mat2|mat3|mat4} value The original value.\n *\n * @return {float|vec2|vec3|vec4|mat2|mat3|mat4} The transformed value of the same scalar/vector/matrix type as the input.\n */\nfloat czm_valueTransform(float offset, float scale, float value) {\n  return scale * value + offset;\n}\n\nvec2 czm_valueTransform(vec2 offset, vec2 scale, vec2 value) {\n  return scale * value + offset;\n}\n\nvec3 czm_valueTransform(vec3 offset, vec3 scale, vec3 value) {\n  return scale * value + offset;\n}\n\nvec4 czm_valueTransform(vec4 offset, vec4 scale, vec4 value) {\n  return scale * value + offset;\n}\n\nmat2 czm_valueTransform(mat2 offset, mat2 scale, mat2 value) {\n  return matrixCompMult(scale, value) + offset;\n}\n\nmat3 czm_valueTransform(mat3 offset, mat3 scale, mat3 value) {\n  return matrixCompMult(scale, value) + offset;\n}\n\nmat4 czm_valueTransform(mat4 offset, mat4 scale, mat4 value) {\n  return matrixCompMult(scale, value) + offset;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/vertexLogDepth.js
var vertexLogDepth_default = "#ifdef LOG_DEPTH\n// 1.0 at the near plane, increasing linearly from there.\nvarying float v_depthFromNearPlusOne;\n#ifdef SHADOW_MAP\nvarying vec3 v_logPositionEC;\n#endif\n#endif\n\nvec4 czm_updatePositionDepth(vec4 coords) {\n#if defined(LOG_DEPTH)\n\n#ifdef SHADOW_MAP\n    vec3 logPositionEC = (czm_inverseProjection * coords).xyz;\n    v_logPositionEC = logPositionEC;\n#endif\n\n    // With the very high far/near ratios used with the logarithmic depth\n    // buffer, floating point rounding errors can cause linear depth values\n    // to end up on the wrong side of the far plane, even for vertices that\n    // are really nowhere near it. Since we always write a correct logarithmic\n    // depth value in the fragment shader anyway, we just need to make sure\n    // such errors don't cause the primitive to be clipped entirely before\n    // we even get to the fragment shader.\n    coords.z = clamp(coords.z / coords.w, -1.0, 1.0) * coords.w;\n#endif\n\n    return coords;\n}\n\n/**\n * Writes the logarithmic depth to gl_Position using the already computed gl_Position.\n *\n * @name czm_vertexLogDepth\n * @glslFunction\n */\nvoid czm_vertexLogDepth()\n{\n#ifdef LOG_DEPTH\n    v_depthFromNearPlusOne = (gl_Position.w - czm_currentFrustum.x) + 1.0;\n    gl_Position = czm_updatePositionDepth(gl_Position);\n#endif\n}\n\n/**\n * Writes the logarithmic depth to gl_Position using the provided clip coordinates.\n * <p>\n * An example use case for this function would be moving the vertex in window coordinates\n * before converting back to clip coordinates. Use the original vertex clip coordinates.\n * </p>\n * @name czm_vertexLogDepth\n * @glslFunction\n *\n * @param {vec4} clipCoords The vertex in clip coordinates.\n *\n * @example\n * czm_vertexLogDepth(czm_projection * vec4(positionEyeCoordinates, 1.0));\n */\nvoid czm_vertexLogDepth(vec4 clipCoords)\n{\n#ifdef LOG_DEPTH\n    v_depthFromNearPlusOne = (clipCoords.w - czm_currentFrustum.x) + 1.0;\n    czm_updatePositionDepth(clipCoords);\n#endif\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/windowToEyeCoordinates.js
var windowToEyeCoordinates_default = "/**\n * Transforms a position from window to eye coordinates.\n * The transform from window to normalized device coordinates is done using components\n * of (@link czm_viewport} and {@link czm_viewportTransformation} instead of calculating\n * the inverse of <code>czm_viewportTransformation</code>. The transformation from\n * normalized device coordinates to clip coordinates is done using <code>fragmentCoordinate.w</code>,\n * which is expected to be the scalar used in the perspective divide. The transformation\n * from clip to eye coordinates is done using {@link czm_inverseProjection}.\n *\n * @name czm_windowToEyeCoordinates\n * @glslFunction\n *\n * @param {vec4} fragmentCoordinate The position in window coordinates to transform.\n *\n * @returns {vec4} The transformed position in eye coordinates.\n *\n * @see czm_modelToWindowCoordinates\n * @see czm_eyeToWindowCoordinates\n * @see czm_inverseProjection\n * @see czm_viewport\n * @see czm_viewportTransformation\n *\n * @example\n * vec4 positionEC = czm_windowToEyeCoordinates(gl_FragCoord);\n */\nvec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)\n{\n    // Reconstruct NDC coordinates\n    float x = 2.0 * (fragmentCoordinate.x - czm_viewport.x) / czm_viewport.z - 1.0;\n    float y = 2.0 * (fragmentCoordinate.y - czm_viewport.y) / czm_viewport.w - 1.0;\n    float z = (fragmentCoordinate.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];\n    vec4 q = vec4(x, y, z, 1.0);\n\n    // Reverse the perspective division to obtain clip coordinates.\n    q /= fragmentCoordinate.w;\n\n    // Reverse the projection transformation to obtain eye coordinates.\n    if (!(czm_inverseProjection == mat4(0.0))) // IE and Edge sometimes do something weird with != between mat4s\n    {\n        q = czm_inverseProjection * q;\n    }\n    else\n    {\n        float top = czm_frustumPlanes.x;\n        float bottom = czm_frustumPlanes.y;\n        float left = czm_frustumPlanes.z;\n        float right = czm_frustumPlanes.w;\n\n        float near = czm_currentFrustum.x;\n        float far = czm_currentFrustum.y;\n\n        q.x = (q.x * (right - left) + left + right) * 0.5;\n        q.y = (q.y * (top - bottom) + bottom + top) * 0.5;\n        q.z = (q.z * (near - far) - near - far) * 0.5;\n        q.w = 1.0;\n    }\n\n    return q;\n}\n\n/**\n * Transforms a position given as window x/y and a depth or a log depth from window to eye coordinates.\n * This function produces more accurate results for window positions with log depth than\n * conventionally unpacking the log depth using czm_reverseLogDepth and using the standard version\n * of czm_windowToEyeCoordinates.\n *\n * @name czm_windowToEyeCoordinates\n * @glslFunction\n *\n * @param {vec2} fragmentCoordinateXY The XY position in window coordinates to transform.\n * @param {float} depthOrLogDepth A depth or log depth for the fragment.\n *\n * @see czm_modelToWindowCoordinates\n * @see czm_eyeToWindowCoordinates\n * @see czm_inverseProjection\n * @see czm_viewport\n * @see czm_viewportTransformation\n *\n * @returns {vec4} The transformed position in eye coordinates.\n */\nvec4 czm_windowToEyeCoordinates(vec2 fragmentCoordinateXY, float depthOrLogDepth)\n{\n    // See reverseLogDepth.glsl. This is separate to re-use the pow.\n#ifdef LOG_DEPTH\n    float near = czm_currentFrustum.x;\n    float far = czm_currentFrustum.y;\n    float log2Depth = depthOrLogDepth * czm_log2FarDepthFromNearPlusOne;\n    float depthFromNear = pow(2.0, log2Depth) - 1.0;\n    float depthFromCamera = depthFromNear + near;\n    vec4 windowCoord = vec4(fragmentCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);\n    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);\n    eyeCoordinate.w = 1.0 / depthFromCamera; // Better precision\n    return eyeCoordinate;\n#else\n    vec4 windowCoord = vec4(fragmentCoordinateXY, depthOrLogDepth, 1.0);\n    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);\n#endif\n    return eyeCoordinate;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/writeDepthClamp.js
var writeDepthClamp_default = "// emulated noperspective\n#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)\nvarying float v_WindowZ;\n#endif\n\n/**\n * Emulates GL_DEPTH_CLAMP. Clamps a fragment to the near and far plane\n * by writing the fragment's depth. See czm_depthClamp for more details.\n * <p>\n * The shader must enable the GL_EXT_frag_depth extension.\n * </p>\n *\n * @name czm_writeDepthClamp\n * @glslFunction\n *\n * @example\n * gl_FragColor = color;\n * czm_writeDepthClamp();\n *\n * @see czm_depthClamp\n */\nvoid czm_writeDepthClamp()\n{\n#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)\n    gl_FragDepthEXT = clamp(v_WindowZ * gl_FragCoord.w, 0.0, 1.0);\n#endif\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/writeLogDepth.js
var writeLogDepth_default = "#ifdef LOG_DEPTH\nvarying float v_depthFromNearPlusOne;\n\n#ifdef POLYGON_OFFSET\nuniform vec2 u_polygonOffset;\n#endif\n\n#endif\n\n/**\n * Writes the fragment depth to the logarithmic depth buffer.\n * <p>\n * Use this when the vertex shader does not call {@link czm_vertexlogDepth}, for example, when\n * ray-casting geometry using a full screen quad.\n * </p>\n * @name czm_writeLogDepth\n * @glslFunction\n *\n * @param {float} depth The depth coordinate, where 1.0 is on the near plane and\n *                      depth increases in eye-space units from there\n *\n * @example\n * czm_writeLogDepth((czm_projection * v_positionEyeCoordinates).w + 1.0);\n */\nvoid czm_writeLogDepth(float depth)\n{\n#if defined(GL_EXT_frag_depth) && defined(LOG_DEPTH)\n    // Discard the vertex if it's not between the near and far planes.\n    // We allow a bit of epsilon on the near plane comparison because a 1.0\n    // from the vertex shader (indicating the vertex should be _on_ the near\n    // plane) will not necessarily come here as exactly 1.0.\n    if (depth <= 0.9999999 || depth > czm_farDepthFromNearPlusOne) {\n        discard;\n    }\n\n#ifdef POLYGON_OFFSET\n    // Polygon offset: m * factor + r * units\n    float factor = u_polygonOffset[0];\n    float units = u_polygonOffset[1];\n\n    // If we can't compute derivatives, just leave out the factor I guess?\n#ifdef GL_OES_standard_derivatives\n    // m = sqrt(dZdX^2 + dZdY^2);\n    float x = dFdx(depth);\n    float y = dFdy(depth);\n    float m = sqrt(x * x + y * y);\n\n    // Apply the factor before computing the log depth.\n    depth += m * factor;\n#endif\n\n#endif\n\n    gl_FragDepthEXT = log2(depth) * czm_oneOverLog2FarDepthFromNearPlusOne;\n\n#ifdef POLYGON_OFFSET\n    // Apply the units after the log depth.\n    gl_FragDepthEXT += czm_epsilon7 * units;\n#endif\n\n#endif\n}\n\n/**\n * Writes the fragment depth to the logarithmic depth buffer.\n * <p>\n * Use this when the vertex shader calls {@link czm_vertexlogDepth}.\n * </p>\n *\n * @name czm_writeLogDepth\n * @glslFunction\n */\nvoid czm_writeLogDepth() {\n#ifdef LOG_DEPTH\n    czm_writeLogDepth(v_depthFromNearPlusOne);\n#endif\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/Functions/writeNonPerspective.js
var writeNonPerspective_default = "/**\n * Transforms a value for non-perspective interpolation by multiplying\n * it by w, the value used in the perspective divide. This function is\n * intended to be called in a vertex shader to compute the value of a\n * `varying` that should not be subject to perspective interpolation.\n * For example, screen-space texture coordinates. The fragment shader\n * must call {@link czm_readNonPerspective} to retrieve the final\n * non-perspective value.\n *\n * @name czm_writeNonPerspective\n * @glslFunction\n *\n * @param {float|vec2|vec3|vec4} value The value to be interpolated without accounting for perspective.\n * @param {float} w The perspective divide value. Usually this is the computed `gl_Position.w`.\n * @returns {float|vec2|vec3|vec4} The transformed value, intended to be stored in a `varying` and read in the\n *          fragment shader with {@link czm_readNonPerspective}.\n */\nfloat czm_writeNonPerspective(float value, float w) {\n    return value * w;\n}\n\nvec2 czm_writeNonPerspective(vec2 value, float w) {\n    return value * w;\n}\n\nvec3 czm_writeNonPerspective(vec3 value, float w) {\n    return value * w;\n}\n\nvec4 czm_writeNonPerspective(vec4 value, float w) {\n    return value * w;\n}\n";

// node_modules/cesium/Source/Shaders/Builtin/CzmBuiltins.js
var CzmBuiltins_default = {
  czm_degreesPerRadian: degreesPerRadian_default,
  czm_depthRange: depthRange_default,
  czm_epsilon1: epsilon1_default,
  czm_epsilon2: epsilon2_default,
  czm_epsilon3: epsilon3_default,
  czm_epsilon4: epsilon4_default,
  czm_epsilon5: epsilon5_default,
  czm_epsilon6: epsilon6_default,
  czm_epsilon7: epsilon7_default,
  czm_infinity: infinity_default,
  czm_oneOverPi: oneOverPi_default,
  czm_oneOverTwoPi: oneOverTwoPi_default,
  czm_passCesium3DTile: passCesium3DTile_default,
  czm_passCesium3DTileClassification: passCesium3DTileClassification_default,
  czm_passCesium3DTileClassificationIgnoreShow: passCesium3DTileClassificationIgnoreShow_default,
  czm_passClassification: passClassification_default,
  czm_passCompute: passCompute_default,
  czm_passEnvironment: passEnvironment_default,
  czm_passGlobe: passGlobe_default,
  czm_passOpaque: passOpaque_default,
  czm_passOverlay: passOverlay_default,
  czm_passTerrainClassification: passTerrainClassification_default,
  czm_passTranslucent: passTranslucent_default,
  czm_pi: pi_default,
  czm_piOverFour: piOverFour_default,
  czm_piOverSix: piOverSix_default,
  czm_piOverThree: piOverThree_default,
  czm_piOverTwo: piOverTwo_default,
  czm_radiansPerDegree: radiansPerDegree_default,
  czm_sceneMode2D: sceneMode2D_default,
  czm_sceneMode3D: sceneMode3D_default,
  czm_sceneModeColumbusView: sceneModeColumbusView_default,
  czm_sceneModeMorphing: sceneModeMorphing_default,
  czm_solarRadius: solarRadius_default,
  czm_threePiOver2: threePiOver2_default,
  czm_twoPi: twoPi_default,
  czm_webMercatorMaxLatitude: webMercatorMaxLatitude_default,
  czm_depthRangeStruct: depthRangeStruct_default,
  czm_material: material_default,
  czm_materialInput: materialInput_default,
  czm_modelMaterial: modelMaterial_default,
  czm_modelVertexOutput: modelVertexOutput_default,
  czm_pbrParameters: pbrParameters_default,
  czm_ray: ray_default,
  czm_raySegment: raySegment_default,
  czm_shadowParameters: shadowParameters_default,
  czm_HSBToRGB: HSBToRGB_default,
  czm_HSLToRGB: HSLToRGB_default,
  czm_RGBToHSB: RGBToHSB_default,
  czm_RGBToHSL: RGBToHSL_default,
  czm_RGBToXYZ: RGBToXYZ_default,
  czm_XYZToRGB: XYZToRGB_default,
  czm_acesTonemapping: acesTonemapping_default,
  czm_alphaWeight: alphaWeight_default,
  czm_antialias: antialias_default,
  czm_approximateSphericalCoordinates: approximateSphericalCoordinates_default,
  czm_backFacing: backFacing_default,
  czm_branchFreeTernary: branchFreeTernary_default,
  czm_cascadeColor: cascadeColor_default,
  czm_cascadeDistance: cascadeDistance_default,
  czm_cascadeMatrix: cascadeMatrix_default,
  czm_cascadeWeights: cascadeWeights_default,
  czm_columbusViewMorph: columbusViewMorph_default,
  czm_computePosition: computePosition_default,
  czm_cosineAndSine: cosineAndSine_default,
  czm_decompressTextureCoordinates: decompressTextureCoordinates_default,
  czm_defaultPbrMaterial: defaultPbrMaterial_default,
  czm_depthClamp: depthClamp_default,
  czm_eastNorthUpToEyeCoordinates: eastNorthUpToEyeCoordinates_default,
  czm_ellipsoidContainsPoint: ellipsoidContainsPoint_default,
  czm_ellipsoidWgs84TextureCoordinates: ellipsoidWgs84TextureCoordinates_default,
  czm_equalsEpsilon: equalsEpsilon_default,
  czm_eyeOffset: eyeOffset_default,
  czm_eyeToWindowCoordinates: eyeToWindowCoordinates_default,
  czm_fastApproximateAtan: fastApproximateAtan_default,
  czm_fog: fog_default,
  czm_gammaCorrect: gammaCorrect_default,
  czm_geodeticSurfaceNormal: geodeticSurfaceNormal_default,
  czm_getDefaultMaterial: getDefaultMaterial_default,
  czm_getLambertDiffuse: getLambertDiffuse_default,
  czm_getSpecular: getSpecular_default,
  czm_getWaterNoise: getWaterNoise_default,
  czm_hue: hue_default,
  czm_inverseGamma: inverseGamma_default,
  czm_isEmpty: isEmpty_default,
  czm_isFull: isFull_default,
  czm_latitudeToWebMercatorFraction: latitudeToWebMercatorFraction_default,
  czm_lineDistance: lineDistance_default,
  czm_linearToSrgb: linearToSrgb_default,
  czm_luminance: luminance_default,
  czm_metersPerPixel: metersPerPixel_default,
  czm_modelToWindowCoordinates: modelToWindowCoordinates_default,
  czm_multiplyWithColorBalance: multiplyWithColorBalance_default,
  czm_nearFarScalar: nearFarScalar_default,
  czm_octDecode: octDecode_default,
  czm_packDepth: packDepth_default,
  czm_pbrLighting: pbrLighting_default,
  czm_pbrMetallicRoughnessMaterial: pbrMetallicRoughnessMaterial_default,
  czm_pbrSpecularGlossinessMaterial: pbrSpecularGlossinessMaterial_default,
  czm_phong: phong_default,
  czm_planeDistance: planeDistance_default,
  czm_pointAlongRay: pointAlongRay_default,
  czm_rayEllipsoidIntersectionInterval: rayEllipsoidIntersectionInterval_default,
  czm_raySphereIntersectionInterval: raySphereIntersectionInterval_default,
  czm_readDepth: readDepth_default,
  czm_readNonPerspective: readNonPerspective_default,
  czm_reverseLogDepth: reverseLogDepth_default,
  czm_round: round_default,
  czm_sampleOctahedralProjection: sampleOctahedralProjection_default,
  czm_saturation: saturation_default,
  czm_shadowDepthCompare: shadowDepthCompare_default,
  czm_shadowVisibility: shadowVisibility_default,
  czm_signNotZero: signNotZero_default,
  czm_sphericalHarmonics: sphericalHarmonics_default,
  czm_srgbToLinear: srgbToLinear_default,
  czm_tangentToEyeSpaceMatrix: tangentToEyeSpaceMatrix_default,
  czm_transformPlane: transformPlane_default,
  czm_translateRelativeToEye: translateRelativeToEye_default,
  czm_translucentPhong: translucentPhong_default,
  czm_transpose: transpose_default,
  czm_unpackDepth: unpackDepth_default,
  czm_unpackFloat: unpackFloat_default,
  czm_unpackUint: unpackUint_default,
  czm_valueTransform: valueTransform_default,
  czm_vertexLogDepth: vertexLogDepth_default,
  czm_windowToEyeCoordinates: windowToEyeCoordinates_default,
  czm_writeDepthClamp: writeDepthClamp_default,
  czm_writeLogDepth: writeLogDepth_default,
  czm_writeNonPerspective: writeNonPerspective_default
};

// node_modules/cesium/Source/Renderer/ShaderSource.js
function removeComments(source) {
  source = source.replace(/\/\/.*/g, "");
  return source.replace(/\/\*\*[\s\S]*?\*\//gm, function(match) {
    const numberOfLines = match.match(/\n/gm).length;
    let replacement = "";
    for (let lineNumber = 0; lineNumber < numberOfLines; ++lineNumber) {
      replacement += "\n";
    }
    return replacement;
  });
}
function getDependencyNode(name, glslSource, nodes) {
  let dependencyNode;
  for (let i2 = 0; i2 < nodes.length; ++i2) {
    if (nodes[i2].name === name) {
      dependencyNode = nodes[i2];
    }
  }
  if (!defined_default(dependencyNode)) {
    glslSource = removeComments(glslSource);
    dependencyNode = {
      name,
      glslSource,
      dependsOn: [],
      requiredBy: [],
      evaluated: false
    };
    nodes.push(dependencyNode);
  }
  return dependencyNode;
}
function generateDependencies(currentNode, dependencyNodes) {
  if (currentNode.evaluated) {
    return;
  }
  currentNode.evaluated = true;
  let czmMatches = currentNode.glslSource.match(/\bczm_[a-zA-Z0-9_]*/g);
  if (defined_default(czmMatches) && czmMatches !== null) {
    czmMatches = czmMatches.filter(function(elem, pos) {
      return czmMatches.indexOf(elem) === pos;
    });
    czmMatches.forEach(function(element) {
      if (element !== currentNode.name && ShaderSource._czmBuiltinsAndUniforms.hasOwnProperty(element)) {
        const referencedNode = getDependencyNode(
          element,
          ShaderSource._czmBuiltinsAndUniforms[element],
          dependencyNodes
        );
        currentNode.dependsOn.push(referencedNode);
        referencedNode.requiredBy.push(currentNode);
        generateDependencies(referencedNode, dependencyNodes);
      }
    });
  }
}
function sortDependencies(dependencyNodes) {
  const nodesWithoutIncomingEdges = [];
  const allNodes = [];
  while (dependencyNodes.length > 0) {
    const node = dependencyNodes.pop();
    allNodes.push(node);
    if (node.requiredBy.length === 0) {
      nodesWithoutIncomingEdges.push(node);
    }
  }
  while (nodesWithoutIncomingEdges.length > 0) {
    const currentNode = nodesWithoutIncomingEdges.shift();
    dependencyNodes.push(currentNode);
    for (let i2 = 0; i2 < currentNode.dependsOn.length; ++i2) {
      const referencedNode = currentNode.dependsOn[i2];
      const index2 = referencedNode.requiredBy.indexOf(currentNode);
      referencedNode.requiredBy.splice(index2, 1);
      if (referencedNode.requiredBy.length === 0) {
        nodesWithoutIncomingEdges.push(referencedNode);
      }
    }
  }
  const badNodes = [];
  for (let j = 0; j < allNodes.length; ++j) {
    if (allNodes[j].requiredBy.length !== 0) {
      badNodes.push(allNodes[j]);
    }
  }
  if (badNodes.length !== 0) {
    let message = "A circular dependency was found in the following built-in functions/structs/constants: \n";
    for (let k = 0; k < badNodes.length; ++k) {
      message = `${message + badNodes[k].name}
`;
    }
    throw new DeveloperError_default(message);
  }
}
function getBuiltinsAndAutomaticUniforms(shaderSource) {
  const dependencyNodes = [];
  const root = getDependencyNode("main", shaderSource, dependencyNodes);
  generateDependencies(root, dependencyNodes);
  sortDependencies(dependencyNodes);
  let builtinsSource = "";
  for (let i2 = dependencyNodes.length - 1; i2 >= 0; --i2) {
    builtinsSource = `${builtinsSource + dependencyNodes[i2].glslSource}
`;
  }
  return builtinsSource.replace(root.glslSource, "");
}
function combineShader(shaderSource, isFragmentShader, context) {
  let i2;
  let length3;
  let combinedSources = "";
  const sources = shaderSource.sources;
  if (defined_default(sources)) {
    for (i2 = 0, length3 = sources.length; i2 < length3; ++i2) {
      combinedSources += `
#line 0
${sources[i2]}`;
    }
  }
  combinedSources = removeComments(combinedSources);
  let version;
  combinedSources = combinedSources.replace(/#version\s+(.*?)\n/gm, function(match, group1) {
    if (defined_default(version) && version !== group1) {
      throw new DeveloperError_default(
        `inconsistent versions found: ${version} and ${group1}`
      );
    }
    version = group1;
    return "\n";
  });
  const extensions = [];
  combinedSources = combinedSources.replace(/#extension.*\n/gm, function(match) {
    extensions.push(match);
    return "\n";
  });
  combinedSources = combinedSources.replace(
    /precision\s(lowp|mediump|highp)\s(float|int);/,
    ""
  );
  const pickColorQualifier = shaderSource.pickColorQualifier;
  if (defined_default(pickColorQualifier)) {
    combinedSources = ShaderSource.createPickFragmentShaderSource(
      combinedSources,
      pickColorQualifier
    );
  }
  let result = "";
  if (defined_default(version)) {
    result = `#version ${version}
`;
  }
  const extensionsLength = extensions.length;
  for (i2 = 0; i2 < extensionsLength; i2++) {
    result += extensions[i2];
  }
  if (isFragmentShader) {
    result += "#ifdef GL_FRAGMENT_PRECISION_HIGH\n    precision highp float;\n    precision highp int;\n#else\n    precision mediump float;\n    precision mediump int;\n    #define highp mediump\n#endif\n\n";
  }
  const defines = shaderSource.defines;
  if (defined_default(defines)) {
    for (i2 = 0, length3 = defines.length; i2 < length3; ++i2) {
      const define2 = defines[i2];
      if (define2.length !== 0) {
        result += `#define ${define2}
`;
      }
    }
  }
  if (context.webgl2) {
    result += "#define OUTPUT_DECLARATION\n\n";
  }
  if (context.textureFloatLinear) {
    result += "#define OES_texture_float_linear\n\n";
  }
  if (context.floatingPointTexture) {
    result += "#define OES_texture_float\n\n";
  }
  if (shaderSource.includeBuiltIns) {
    result += getBuiltinsAndAutomaticUniforms(combinedSources);
  }
  result += "\n#line 0\n";
  result += combinedSources;
  if (context.webgl2) {
    result = modernizeShader_default(result, isFragmentShader, true);
  }
  return result;
}
function ShaderSource(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const pickColorQualifier = options.pickColorQualifier;
  if (defined_default(pickColorQualifier) && pickColorQualifier !== "uniform" && pickColorQualifier !== "varying") {
    throw new DeveloperError_default(
      "options.pickColorQualifier must be 'uniform' or 'varying'."
    );
  }
  this.defines = defined_default(options.defines) ? options.defines.slice(0) : [];
  this.sources = defined_default(options.sources) ? options.sources.slice(0) : [];
  this.pickColorQualifier = pickColorQualifier;
  this.includeBuiltIns = defaultValue_default(options.includeBuiltIns, true);
}
ShaderSource.prototype.clone = function() {
  return new ShaderSource({
    sources: this.sources,
    defines: this.defines,
    pickColorQualifier: this.pickColorQualifier,
    includeBuiltIns: this.includeBuiltIns
  });
};
ShaderSource.replaceMain = function(source, renamedMain) {
  renamedMain = `void ${renamedMain}()`;
  return source.replace(/void\s+main\s*\(\s*(?:void)?\s*\)/g, renamedMain);
};
ShaderSource.prototype.createCombinedVertexShader = function(context) {
  return combineShader(this, false, context);
};
ShaderSource.prototype.createCombinedFragmentShader = function(context) {
  return combineShader(this, true, context);
};
ShaderSource._czmBuiltinsAndUniforms = {};
for (const builtinName in CzmBuiltins_default) {
  if (CzmBuiltins_default.hasOwnProperty(builtinName)) {
    ShaderSource._czmBuiltinsAndUniforms[builtinName] = CzmBuiltins_default[builtinName];
  }
}
for (const uniformName in AutomaticUniforms_default) {
  if (AutomaticUniforms_default.hasOwnProperty(uniformName)) {
    const uniform = AutomaticUniforms_default[uniformName];
    if (typeof uniform.getDeclaration === "function") {
      ShaderSource._czmBuiltinsAndUniforms[uniformName] = uniform.getDeclaration(uniformName);
    }
  }
}
ShaderSource.createPickVertexShaderSource = function(vertexShaderSource) {
  const renamedVS = ShaderSource.replaceMain(
    vertexShaderSource,
    "czm_old_main"
  );
  const pickMain = "attribute vec4 pickColor; \nvarying vec4 czm_pickColor; \nvoid main() \n{ \n    czm_old_main(); \n    czm_pickColor = pickColor; \n}";
  return `${renamedVS}
${pickMain}`;
};
ShaderSource.createPickFragmentShaderSource = function(fragmentShaderSource, pickColorQualifier) {
  const renamedFS = ShaderSource.replaceMain(
    fragmentShaderSource,
    "czm_old_main"
  );
  const pickMain = `${pickColorQualifier} vec4 czm_pickColor; 
void main() 
{ 
    czm_old_main(); 
    if (gl_FragColor.a == 0.0) { 
       discard; 
    } 
    gl_FragColor = czm_pickColor; 
}`;
  return `${renamedFS}
${pickMain}`;
};
function containsString(shaderSource, string) {
  const sources = shaderSource.sources;
  const sourcesLength = sources.length;
  for (let i2 = 0; i2 < sourcesLength; ++i2) {
    if (sources[i2].indexOf(string) !== -1) {
      return true;
    }
  }
  return false;
}
function findFirstString(shaderSource, strings2) {
  const stringsLength = strings2.length;
  for (let i2 = 0; i2 < stringsLength; ++i2) {
    const string = strings2[i2];
    if (containsString(shaderSource, string)) {
      return string;
    }
  }
  return void 0;
}
var normalVaryingNames = ["v_normalEC", "v_normal"];
ShaderSource.findNormalVarying = function(shaderSource) {
  if (containsString(shaderSource, "#ifdef HAS_NORMALS")) {
    if (containsString(shaderSource, "#define HAS_NORMALS")) {
      return "v_normalEC";
    }
    return void 0;
  }
  return findFirstString(shaderSource, normalVaryingNames);
};
var positionVaryingNames = ["v_positionEC"];
ShaderSource.findPositionVarying = function(shaderSource) {
  return findFirstString(shaderSource, positionVaryingNames);
};
var ShaderSource_default = ShaderSource;

// node_modules/cesium/Source/Shaders/ShadowVolumeAppearanceVS.js
var ShadowVolumeAppearanceVS_default = 'attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute float batchId;\n\n#ifdef EXTRUDED_GEOMETRY\nattribute vec3 extrudeDirection;\n\nuniform float u_globeMinimumAltitude;\n#endif // EXTRUDED_GEOMETRY\n\n#ifdef PER_INSTANCE_COLOR\nvarying vec4 v_color;\n#endif // PER_INSTANCE_COLOR\n\n#ifdef TEXTURE_COORDINATES\n#ifdef SPHERICAL\nvarying vec4 v_sphericalExtents;\n#else // SPHERICAL\nvarying vec2 v_inversePlaneExtents;\nvarying vec4 v_westPlane;\nvarying vec4 v_southPlane;\n#endif // SPHERICAL\nvarying vec3 v_uvMinAndSphericalLongitudeRotation;\nvarying vec3 v_uMaxAndInverseDistance;\nvarying vec3 v_vMaxAndInverseDistance;\n#endif // TEXTURE_COORDINATES\n\nvoid main()\n{\n    vec4 position = czm_computePosition();\n\n#ifdef EXTRUDED_GEOMETRY\n    float delta = min(u_globeMinimumAltitude, czm_geometricToleranceOverMeter * length(position.xyz));\n    delta *= czm_sceneMode == czm_sceneMode3D ? 1.0 : 0.0;\n\n    //extrudeDirection is zero for the top layer\n    position = position + vec4(extrudeDirection * delta, 0.0);\n#endif\n\n#ifdef TEXTURE_COORDINATES\n#ifdef SPHERICAL\n    v_sphericalExtents = czm_batchTable_sphericalExtents(batchId);\n    v_uvMinAndSphericalLongitudeRotation.z = czm_batchTable_longitudeRotation(batchId);\n#else // SPHERICAL\n#ifdef COLUMBUS_VIEW_2D\n    vec4 planes2D_high = czm_batchTable_planes2D_HIGH(batchId);\n    vec4 planes2D_low = czm_batchTable_planes2D_LOW(batchId);\n\n    // If the primitive is split across the IDL (planes2D_high.x > planes2D_high.w):\n    // - If this vertex is on the east side of the IDL (position3DLow.y > 0.0, comparison with position3DHigh may produce artifacts)\n    // - existing "east" is on the wrong side of the world, far away (planes2D_high/low.w)\n    // - so set "east" as beyond the eastmost extent of the projection (idlSplitNewPlaneHiLow)\n    vec2 idlSplitNewPlaneHiLow = vec2(EAST_MOST_X_HIGH - (WEST_MOST_X_HIGH - planes2D_high.w), EAST_MOST_X_LOW - (WEST_MOST_X_LOW - planes2D_low.w));\n    bool idlSplit = planes2D_high.x > planes2D_high.w && position3DLow.y > 0.0;\n    planes2D_high.w = czm_branchFreeTernary(idlSplit, idlSplitNewPlaneHiLow.x, planes2D_high.w);\n    planes2D_low.w = czm_branchFreeTernary(idlSplit, idlSplitNewPlaneHiLow.y, planes2D_low.w);\n\n    // - else, if this vertex is on the west side of the IDL (position3DLow.y < 0.0)\n    // - existing "west" is on the wrong side of the world, far away (planes2D_high/low.x)\n    // - so set "west" as beyond the westmost extent of the projection (idlSplitNewPlaneHiLow)\n    idlSplit = planes2D_high.x > planes2D_high.w && position3DLow.y < 0.0;\n    idlSplitNewPlaneHiLow = vec2(WEST_MOST_X_HIGH - (EAST_MOST_X_HIGH - planes2D_high.x), WEST_MOST_X_LOW - (EAST_MOST_X_LOW - planes2D_low.x));\n    planes2D_high.x = czm_branchFreeTernary(idlSplit, idlSplitNewPlaneHiLow.x, planes2D_high.x);\n    planes2D_low.x = czm_branchFreeTernary(idlSplit, idlSplitNewPlaneHiLow.y, planes2D_low.x);\n\n    vec3 southWestCorner = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(vec3(0.0, planes2D_high.xy), vec3(0.0, planes2D_low.xy))).xyz;\n    vec3 northWestCorner = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(vec3(0.0, planes2D_high.x, planes2D_high.z), vec3(0.0, planes2D_low.x, planes2D_low.z))).xyz;\n    vec3 southEastCorner = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(vec3(0.0, planes2D_high.w, planes2D_high.y), vec3(0.0, planes2D_low.w, planes2D_low.y))).xyz;\n#else // COLUMBUS_VIEW_2D\n    // 3D case has smaller "plane extents," so planes encoded as a 64 bit position and 2 vec3s for distances/direction\n    vec3 southWestCorner = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(czm_batchTable_southWest_HIGH(batchId), czm_batchTable_southWest_LOW(batchId))).xyz;\n    vec3 northWestCorner = czm_normal * czm_batchTable_northward(batchId) + southWestCorner;\n    vec3 southEastCorner = czm_normal * czm_batchTable_eastward(batchId) + southWestCorner;\n#endif // COLUMBUS_VIEW_2D\n\n    vec3 eastWard = southEastCorner - southWestCorner;\n    float eastExtent = length(eastWard);\n    eastWard /= eastExtent;\n\n    vec3 northWard = northWestCorner - southWestCorner;\n    float northExtent = length(northWard);\n    northWard /= northExtent;\n\n    v_westPlane = vec4(eastWard, -dot(eastWard, southWestCorner));\n    v_southPlane = vec4(northWard, -dot(northWard, southWestCorner));\n    v_inversePlaneExtents = vec2(1.0 / eastExtent, 1.0 / northExtent);\n#endif // SPHERICAL\n    vec4 uvMinAndExtents = czm_batchTable_uvMinAndExtents(batchId);\n    vec4 uMaxVmax = czm_batchTable_uMaxVmax(batchId);\n\n    v_uMaxAndInverseDistance = vec3(uMaxVmax.xy, uvMinAndExtents.z);\n    v_vMaxAndInverseDistance = vec3(uMaxVmax.zw, uvMinAndExtents.w);\n    v_uvMinAndSphericalLongitudeRotation.xy = uvMinAndExtents.xy;\n#endif // TEXTURE_COORDINATES\n\n#ifdef PER_INSTANCE_COLOR\n    v_color = czm_batchTable_color(batchId);\n#endif\n\n    gl_Position = czm_depthClamp(czm_modelViewProjectionRelativeToEye * position);\n}\n';

// node_modules/cesium/Source/Shaders/ShadowVolumeFS.js
var ShadowVolumeFS_default = "#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n#endif\n\n#ifdef VECTOR_TILE\nuniform vec4 u_highlightColor;\n#endif\n\nvoid main(void)\n{\n#ifdef VECTOR_TILE\n    gl_FragColor = czm_gammaCorrect(u_highlightColor);\n#else\n    gl_FragColor = vec4(1.0);\n#endif\n    czm_writeDepthClamp();\n}\n";

// node_modules/cesium/Source/Scene/ClassificationType.js
var ClassificationType = {
  TERRAIN: 0,
  CESIUM_3D_TILE: 1,
  BOTH: 2
};
ClassificationType.NUMBER_OF_CLASSIFICATION_TYPES = 3;
var ClassificationType_default = Object.freeze(ClassificationType);

// node_modules/cesium/Source/Scene/DepthFunction.js
var DepthFunction = {
  NEVER: WebGLConstants_default.NEVER,
  LESS: WebGLConstants_default.LESS,
  EQUAL: WebGLConstants_default.EQUAL,
  LESS_OR_EQUAL: WebGLConstants_default.LEQUAL,
  GREATER: WebGLConstants_default.GREATER,
  NOT_EQUAL: WebGLConstants_default.NOTEQUAL,
  GREATER_OR_EQUAL: WebGLConstants_default.GEQUAL,
  ALWAYS: WebGLConstants_default.ALWAYS
};
var DepthFunction_default = Object.freeze(DepthFunction);

// node_modules/cesium/Source/Renderer/BufferUsage.js
var BufferUsage = {
  STREAM_DRAW: WebGLConstants_default.STREAM_DRAW,
  STATIC_DRAW: WebGLConstants_default.STATIC_DRAW,
  DYNAMIC_DRAW: WebGLConstants_default.DYNAMIC_DRAW,
  validate: function(bufferUsage) {
    return bufferUsage === BufferUsage.STREAM_DRAW || bufferUsage === BufferUsage.STATIC_DRAW || bufferUsage === BufferUsage.DYNAMIC_DRAW;
  }
};
var BufferUsage_default = Object.freeze(BufferUsage);

// node_modules/cesium/Source/Renderer/Buffer.js
function Buffer2(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.context", options.context);
  if (!defined_default(options.typedArray) && !defined_default(options.sizeInBytes)) {
    throw new DeveloperError_default(
      "Either options.sizeInBytes or options.typedArray is required."
    );
  }
  if (defined_default(options.typedArray) && defined_default(options.sizeInBytes)) {
    throw new DeveloperError_default(
      "Cannot pass in both options.sizeInBytes and options.typedArray."
    );
  }
  if (defined_default(options.typedArray)) {
    Check_default.typeOf.object("options.typedArray", options.typedArray);
    Check_default.typeOf.number(
      "options.typedArray.byteLength",
      options.typedArray.byteLength
    );
  }
  if (!BufferUsage_default.validate(options.usage)) {
    throw new DeveloperError_default("usage is invalid.");
  }
  const gl = options.context._gl;
  const bufferTarget = options.bufferTarget;
  const typedArray = options.typedArray;
  let sizeInBytes = options.sizeInBytes;
  const usage = options.usage;
  const hasArray = defined_default(typedArray);
  if (hasArray) {
    sizeInBytes = typedArray.byteLength;
  }
  Check_default.typeOf.number.greaterThan("sizeInBytes", sizeInBytes, 0);
  const buffer = gl.createBuffer();
  gl.bindBuffer(bufferTarget, buffer);
  gl.bufferData(bufferTarget, hasArray ? typedArray : sizeInBytes, usage);
  gl.bindBuffer(bufferTarget, null);
  this._gl = gl;
  this._webgl2 = options.context._webgl2;
  this._bufferTarget = bufferTarget;
  this._sizeInBytes = sizeInBytes;
  this._usage = usage;
  this._buffer = buffer;
  this.vertexArrayDestroyable = true;
}
Buffer2.createVertexBuffer = function(options) {
  Check_default.defined("options.context", options.context);
  return new Buffer2({
    context: options.context,
    bufferTarget: WebGLConstants_default.ARRAY_BUFFER,
    typedArray: options.typedArray,
    sizeInBytes: options.sizeInBytes,
    usage: options.usage
  });
};
Buffer2.createIndexBuffer = function(options) {
  Check_default.defined("options.context", options.context);
  if (!IndexDatatype_default.validate(options.indexDatatype)) {
    throw new DeveloperError_default("Invalid indexDatatype.");
  }
  if (options.indexDatatype === IndexDatatype_default.UNSIGNED_INT && !options.context.elementIndexUint) {
    throw new DeveloperError_default(
      "IndexDatatype.UNSIGNED_INT requires OES_element_index_uint, which is not supported on this system.  Check context.elementIndexUint."
    );
  }
  const context = options.context;
  const indexDatatype = options.indexDatatype;
  const bytesPerIndex = IndexDatatype_default.getSizeInBytes(indexDatatype);
  const buffer = new Buffer2({
    context,
    bufferTarget: WebGLConstants_default.ELEMENT_ARRAY_BUFFER,
    typedArray: options.typedArray,
    sizeInBytes: options.sizeInBytes,
    usage: options.usage
  });
  const numberOfIndices = buffer.sizeInBytes / bytesPerIndex;
  Object.defineProperties(buffer, {
    indexDatatype: {
      get: function() {
        return indexDatatype;
      }
    },
    bytesPerIndex: {
      get: function() {
        return bytesPerIndex;
      }
    },
    numberOfIndices: {
      get: function() {
        return numberOfIndices;
      }
    }
  });
  return buffer;
};
Object.defineProperties(Buffer2.prototype, {
  sizeInBytes: {
    get: function() {
      return this._sizeInBytes;
    }
  },
  usage: {
    get: function() {
      return this._usage;
    }
  }
});
Buffer2.prototype._getBuffer = function() {
  return this._buffer;
};
Buffer2.prototype.copyFromArrayView = function(arrayView, offsetInBytes) {
  offsetInBytes = defaultValue_default(offsetInBytes, 0);
  Check_default.defined("arrayView", arrayView);
  Check_default.typeOf.number.lessThanOrEquals(
    "offsetInBytes + arrayView.byteLength",
    offsetInBytes + arrayView.byteLength,
    this._sizeInBytes
  );
  const gl = this._gl;
  const target = this._bufferTarget;
  gl.bindBuffer(target, this._buffer);
  gl.bufferSubData(target, offsetInBytes, arrayView);
  gl.bindBuffer(target, null);
};
Buffer2.prototype.copyFromBuffer = function(readBuffer, readOffset, writeOffset, sizeInBytes) {
  if (!this._webgl2) {
    throw new DeveloperError_default("A WebGL 2 context is required.");
  }
  if (!defined_default(readBuffer)) {
    throw new DeveloperError_default("readBuffer must be defined.");
  }
  if (!defined_default(sizeInBytes) || sizeInBytes <= 0) {
    throw new DeveloperError_default(
      "sizeInBytes must be defined and be greater than zero."
    );
  }
  if (!defined_default(readOffset) || readOffset < 0 || readOffset + sizeInBytes > readBuffer._sizeInBytes) {
    throw new DeveloperError_default(
      "readOffset must be greater than or equal to zero and readOffset + sizeInBytes must be less than of equal to readBuffer.sizeInBytes."
    );
  }
  if (!defined_default(writeOffset) || writeOffset < 0 || writeOffset + sizeInBytes > this._sizeInBytes) {
    throw new DeveloperError_default(
      "writeOffset must be greater than or equal to zero and writeOffset + sizeInBytes must be less than of equal to this.sizeInBytes."
    );
  }
  if (this._buffer === readBuffer._buffer && (writeOffset >= readOffset && writeOffset < readOffset + sizeInBytes || readOffset > writeOffset && readOffset < writeOffset + sizeInBytes)) {
    throw new DeveloperError_default(
      "When readBuffer is equal to this, the ranges [readOffset + sizeInBytes) and [writeOffset, writeOffset + sizeInBytes) must not overlap."
    );
  }
  if (this._bufferTarget === WebGLConstants_default.ELEMENT_ARRAY_BUFFER && readBuffer._bufferTarget !== WebGLConstants_default.ELEMENT_ARRAY_BUFFER || this._bufferTarget !== WebGLConstants_default.ELEMENT_ARRAY_BUFFER && readBuffer._bufferTarget === WebGLConstants_default.ELEMENT_ARRAY_BUFFER) {
    throw new DeveloperError_default(
      "Can not copy an index buffer into another buffer type."
    );
  }
  const readTarget = WebGLConstants_default.COPY_READ_BUFFER;
  const writeTarget = WebGLConstants_default.COPY_WRITE_BUFFER;
  const gl = this._gl;
  gl.bindBuffer(writeTarget, this._buffer);
  gl.bindBuffer(readTarget, readBuffer._buffer);
  gl.copyBufferSubData(
    readTarget,
    writeTarget,
    readOffset,
    writeOffset,
    sizeInBytes
  );
  gl.bindBuffer(writeTarget, null);
  gl.bindBuffer(readTarget, null);
};
Buffer2.prototype.getBufferData = function(arrayView, sourceOffset, destinationOffset, length3) {
  sourceOffset = defaultValue_default(sourceOffset, 0);
  destinationOffset = defaultValue_default(destinationOffset, 0);
  if (!this._webgl2) {
    throw new DeveloperError_default("A WebGL 2 context is required.");
  }
  if (!defined_default(arrayView)) {
    throw new DeveloperError_default("arrayView is required.");
  }
  let copyLength;
  let elementSize;
  let arrayLength = arrayView.byteLength;
  if (!defined_default(length3)) {
    if (defined_default(arrayLength)) {
      copyLength = arrayLength - destinationOffset;
      elementSize = 1;
    } else {
      arrayLength = arrayView.length;
      copyLength = arrayLength - destinationOffset;
      elementSize = arrayView.BYTES_PER_ELEMENT;
    }
  } else {
    copyLength = length3;
    if (defined_default(arrayLength)) {
      elementSize = 1;
    } else {
      arrayLength = arrayView.length;
      elementSize = arrayView.BYTES_PER_ELEMENT;
    }
  }
  if (destinationOffset < 0 || destinationOffset > arrayLength) {
    throw new DeveloperError_default(
      "destinationOffset must be greater than zero and less than the arrayView length."
    );
  }
  if (destinationOffset + copyLength > arrayLength) {
    throw new DeveloperError_default(
      "destinationOffset + length must be less than or equal to the arrayViewLength."
    );
  }
  if (sourceOffset < 0 || sourceOffset > this._sizeInBytes) {
    throw new DeveloperError_default(
      "sourceOffset must be greater than zero and less than the buffers size."
    );
  }
  if (sourceOffset + copyLength * elementSize > this._sizeInBytes) {
    throw new DeveloperError_default(
      "sourceOffset + length must be less than the buffers size."
    );
  }
  const gl = this._gl;
  const target = WebGLConstants_default.COPY_READ_BUFFER;
  gl.bindBuffer(target, this._buffer);
  gl.getBufferSubData(
    target,
    sourceOffset,
    arrayView,
    destinationOffset,
    length3
  );
  gl.bindBuffer(target, null);
};
Buffer2.prototype.isDestroyed = function() {
  return false;
};
Buffer2.prototype.destroy = function() {
  this._gl.deleteBuffer(this._buffer);
  return destroyObject_default(this);
};
var Buffer_default = Buffer2;

// node_modules/cesium/Source/Renderer/VertexArray.js
function addAttribute(attributes, attribute, index2, context) {
  const hasVertexBuffer = defined_default(attribute.vertexBuffer);
  const hasValue = defined_default(attribute.value);
  const componentsPerAttribute = attribute.value ? attribute.value.length : attribute.componentsPerAttribute;
  if (!hasVertexBuffer && !hasValue) {
    throw new DeveloperError_default("attribute must have a vertexBuffer or a value.");
  }
  if (hasVertexBuffer && hasValue) {
    throw new DeveloperError_default(
      "attribute cannot have both a vertexBuffer and a value.  It must have either a vertexBuffer property defining per-vertex data or a value property defining data for all vertices."
    );
  }
  if (componentsPerAttribute !== 1 && componentsPerAttribute !== 2 && componentsPerAttribute !== 3 && componentsPerAttribute !== 4) {
    if (hasValue) {
      throw new DeveloperError_default(
        "attribute.value.length must be in the range [1, 4]."
      );
    }
    throw new DeveloperError_default(
      "attribute.componentsPerAttribute must be in the range [1, 4]."
    );
  }
  if (defined_default(attribute.componentDatatype) && !ComponentDatatype_default.validate(attribute.componentDatatype)) {
    throw new DeveloperError_default(
      "attribute must have a valid componentDatatype or not specify it."
    );
  }
  if (defined_default(attribute.strideInBytes) && attribute.strideInBytes > 255) {
    throw new DeveloperError_default(
      "attribute must have a strideInBytes less than or equal to 255 or not specify it."
    );
  }
  if (defined_default(attribute.instanceDivisor) && attribute.instanceDivisor > 0 && !context.instancedArrays) {
    throw new DeveloperError_default("instanced arrays is not supported");
  }
  if (defined_default(attribute.instanceDivisor) && attribute.instanceDivisor < 0) {
    throw new DeveloperError_default(
      "attribute must have an instanceDivisor greater than or equal to zero"
    );
  }
  if (defined_default(attribute.instanceDivisor) && hasValue) {
    throw new DeveloperError_default(
      "attribute cannot have have an instanceDivisor if it is not backed by a buffer"
    );
  }
  if (defined_default(attribute.instanceDivisor) && attribute.instanceDivisor > 0 && attribute.index === 0) {
    throw new DeveloperError_default(
      "attribute zero cannot have an instanceDivisor greater than 0"
    );
  }
  const attr = {
    index: defaultValue_default(attribute.index, index2),
    enabled: defaultValue_default(attribute.enabled, true),
    vertexBuffer: attribute.vertexBuffer,
    value: hasValue ? attribute.value.slice(0) : void 0,
    componentsPerAttribute,
    componentDatatype: defaultValue_default(
      attribute.componentDatatype,
      ComponentDatatype_default.FLOAT
    ),
    normalize: defaultValue_default(attribute.normalize, false),
    offsetInBytes: defaultValue_default(attribute.offsetInBytes, 0),
    strideInBytes: defaultValue_default(attribute.strideInBytes, 0),
    instanceDivisor: defaultValue_default(attribute.instanceDivisor, 0)
  };
  if (hasVertexBuffer) {
    attr.vertexAttrib = function(gl) {
      const index3 = this.index;
      gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer._getBuffer());
      gl.vertexAttribPointer(
        index3,
        this.componentsPerAttribute,
        this.componentDatatype,
        this.normalize,
        this.strideInBytes,
        this.offsetInBytes
      );
      gl.enableVertexAttribArray(index3);
      if (this.instanceDivisor > 0) {
        context.glVertexAttribDivisor(index3, this.instanceDivisor);
        context._vertexAttribDivisors[index3] = this.instanceDivisor;
        context._previousDrawInstanced = true;
      }
    };
    attr.disableVertexAttribArray = function(gl) {
      gl.disableVertexAttribArray(this.index);
      if (this.instanceDivisor > 0) {
        context.glVertexAttribDivisor(index2, 0);
      }
    };
  } else {
    switch (attr.componentsPerAttribute) {
      case 1:
        attr.vertexAttrib = function(gl) {
          gl.vertexAttrib1fv(this.index, this.value);
        };
        break;
      case 2:
        attr.vertexAttrib = function(gl) {
          gl.vertexAttrib2fv(this.index, this.value);
        };
        break;
      case 3:
        attr.vertexAttrib = function(gl) {
          gl.vertexAttrib3fv(this.index, this.value);
        };
        break;
      case 4:
        attr.vertexAttrib = function(gl) {
          gl.vertexAttrib4fv(this.index, this.value);
        };
        break;
    }
    attr.disableVertexAttribArray = function(gl) {
    };
  }
  attributes.push(attr);
}
function bind(gl, attributes, indexBuffer) {
  for (let i2 = 0; i2 < attributes.length; ++i2) {
    const attribute = attributes[i2];
    if (attribute.enabled) {
      attribute.vertexAttrib(gl);
    }
  }
  if (defined_default(indexBuffer)) {
    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer._getBuffer());
  }
}
function VertexArray(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.context", options.context);
  Check_default.defined("options.attributes", options.attributes);
  const context = options.context;
  const gl = context._gl;
  const attributes = options.attributes;
  const indexBuffer = options.indexBuffer;
  let i2;
  const vaAttributes = [];
  let numberOfVertices = 1;
  let hasInstancedAttributes = false;
  let hasConstantAttributes = false;
  let length3 = attributes.length;
  for (i2 = 0; i2 < length3; ++i2) {
    addAttribute(vaAttributes, attributes[i2], i2, context);
  }
  length3 = vaAttributes.length;
  for (i2 = 0; i2 < length3; ++i2) {
    const attribute = vaAttributes[i2];
    if (defined_default(attribute.vertexBuffer) && attribute.instanceDivisor === 0) {
      const bytes = attribute.strideInBytes || attribute.componentsPerAttribute * ComponentDatatype_default.getSizeInBytes(attribute.componentDatatype);
      numberOfVertices = attribute.vertexBuffer.sizeInBytes / bytes;
      break;
    }
  }
  for (i2 = 0; i2 < length3; ++i2) {
    if (vaAttributes[i2].instanceDivisor > 0) {
      hasInstancedAttributes = true;
    }
    if (defined_default(vaAttributes[i2].value)) {
      hasConstantAttributes = true;
    }
  }
  const uniqueIndices = {};
  for (i2 = 0; i2 < length3; ++i2) {
    const index2 = vaAttributes[i2].index;
    if (uniqueIndices[index2]) {
      throw new DeveloperError_default(
        `Index ${index2} is used by more than one attribute.`
      );
    }
    uniqueIndices[index2] = true;
  }
  let vao;
  if (context.vertexArrayObject) {
    vao = context.glCreateVertexArray();
    context.glBindVertexArray(vao);
    bind(gl, vaAttributes, indexBuffer);
    context.glBindVertexArray(null);
  }
  this._numberOfVertices = numberOfVertices;
  this._hasInstancedAttributes = hasInstancedAttributes;
  this._hasConstantAttributes = hasConstantAttributes;
  this._context = context;
  this._gl = gl;
  this._vao = vao;
  this._attributes = vaAttributes;
  this._indexBuffer = indexBuffer;
}
function computeNumberOfVertices(attribute) {
  return attribute.values.length / attribute.componentsPerAttribute;
}
function computeAttributeSizeInBytes(attribute) {
  return ComponentDatatype_default.getSizeInBytes(attribute.componentDatatype) * attribute.componentsPerAttribute;
}
function interleaveAttributes(attributes) {
  let j;
  let name;
  let attribute;
  const names = [];
  for (name in attributes) {
    if (attributes.hasOwnProperty(name) && defined_default(attributes[name]) && defined_default(attributes[name].values)) {
      names.push(name);
      if (attributes[name].componentDatatype === ComponentDatatype_default.DOUBLE) {
        attributes[name].componentDatatype = ComponentDatatype_default.FLOAT;
        attributes[name].values = ComponentDatatype_default.createTypedArray(
          ComponentDatatype_default.FLOAT,
          attributes[name].values
        );
      }
    }
  }
  let numberOfVertices;
  const namesLength = names.length;
  if (namesLength > 0) {
    numberOfVertices = computeNumberOfVertices(attributes[names[0]]);
    for (j = 1; j < namesLength; ++j) {
      const currentNumberOfVertices = computeNumberOfVertices(
        attributes[names[j]]
      );
      if (currentNumberOfVertices !== numberOfVertices) {
        throw new RuntimeError_default(
          `${"Each attribute list must have the same number of vertices.  Attribute "}${names[j]} has a different number of vertices (${currentNumberOfVertices.toString()}) than attribute ${names[0]} (${numberOfVertices.toString()}).`
        );
      }
    }
  }
  names.sort(function(left, right) {
    return ComponentDatatype_default.getSizeInBytes(attributes[right].componentDatatype) - ComponentDatatype_default.getSizeInBytes(attributes[left].componentDatatype);
  });
  let vertexSizeInBytes = 0;
  const offsetsInBytes = {};
  for (j = 0; j < namesLength; ++j) {
    name = names[j];
    attribute = attributes[name];
    offsetsInBytes[name] = vertexSizeInBytes;
    vertexSizeInBytes += computeAttributeSizeInBytes(attribute);
  }
  if (vertexSizeInBytes > 0) {
    const maxComponentSizeInBytes = ComponentDatatype_default.getSizeInBytes(
      attributes[names[0]].componentDatatype
    );
    const remainder = vertexSizeInBytes % maxComponentSizeInBytes;
    if (remainder !== 0) {
      vertexSizeInBytes += maxComponentSizeInBytes - remainder;
    }
    const vertexBufferSizeInBytes = numberOfVertices * vertexSizeInBytes;
    const buffer = new ArrayBuffer(vertexBufferSizeInBytes);
    const views = {};
    for (j = 0; j < namesLength; ++j) {
      name = names[j];
      const sizeInBytes = ComponentDatatype_default.getSizeInBytes(
        attributes[name].componentDatatype
      );
      views[name] = {
        pointer: ComponentDatatype_default.createTypedArray(
          attributes[name].componentDatatype,
          buffer
        ),
        index: offsetsInBytes[name] / sizeInBytes,
        strideInComponentType: vertexSizeInBytes / sizeInBytes
      };
    }
    for (j = 0; j < numberOfVertices; ++j) {
      for (let n2 = 0; n2 < namesLength; ++n2) {
        name = names[n2];
        attribute = attributes[name];
        const values = attribute.values;
        const view = views[name];
        const pointer = view.pointer;
        const numberOfComponents = attribute.componentsPerAttribute;
        for (let k = 0; k < numberOfComponents; ++k) {
          pointer[view.index + k] = values[j * numberOfComponents + k];
        }
        view.index += view.strideInComponentType;
      }
    }
    return {
      buffer,
      offsetsInBytes,
      vertexSizeInBytes
    };
  }
  return void 0;
}
VertexArray.fromGeometry = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.context", options.context);
  const context = options.context;
  const geometry = defaultValue_default(options.geometry, defaultValue_default.EMPTY_OBJECT);
  const bufferUsage = defaultValue_default(
    options.bufferUsage,
    BufferUsage_default.DYNAMIC_DRAW
  );
  const attributeLocations8 = defaultValue_default(
    options.attributeLocations,
    defaultValue_default.EMPTY_OBJECT
  );
  const interleave = defaultValue_default(options.interleave, false);
  const createdVAAttributes = options.vertexArrayAttributes;
  let name;
  let attribute;
  let vertexBuffer;
  const vaAttributes = defined_default(createdVAAttributes) ? createdVAAttributes : [];
  const attributes = geometry.attributes;
  if (interleave) {
    const interleavedAttributes = interleaveAttributes(attributes);
    if (defined_default(interleavedAttributes)) {
      vertexBuffer = Buffer_default.createVertexBuffer({
        context,
        typedArray: interleavedAttributes.buffer,
        usage: bufferUsage
      });
      const offsetsInBytes = interleavedAttributes.offsetsInBytes;
      const strideInBytes = interleavedAttributes.vertexSizeInBytes;
      for (name in attributes) {
        if (attributes.hasOwnProperty(name) && defined_default(attributes[name])) {
          attribute = attributes[name];
          if (defined_default(attribute.values)) {
            vaAttributes.push({
              index: attributeLocations8[name],
              vertexBuffer,
              componentDatatype: attribute.componentDatatype,
              componentsPerAttribute: attribute.componentsPerAttribute,
              normalize: attribute.normalize,
              offsetInBytes: offsetsInBytes[name],
              strideInBytes
            });
          } else {
            vaAttributes.push({
              index: attributeLocations8[name],
              value: attribute.value,
              componentDatatype: attribute.componentDatatype,
              normalize: attribute.normalize
            });
          }
        }
      }
    }
  } else {
    for (name in attributes) {
      if (attributes.hasOwnProperty(name) && defined_default(attributes[name])) {
        attribute = attributes[name];
        let componentDatatype = attribute.componentDatatype;
        if (componentDatatype === ComponentDatatype_default.DOUBLE) {
          componentDatatype = ComponentDatatype_default.FLOAT;
        }
        vertexBuffer = void 0;
        if (defined_default(attribute.values)) {
          vertexBuffer = Buffer_default.createVertexBuffer({
            context,
            typedArray: ComponentDatatype_default.createTypedArray(
              componentDatatype,
              attribute.values
            ),
            usage: bufferUsage
          });
        }
        vaAttributes.push({
          index: attributeLocations8[name],
          vertexBuffer,
          value: attribute.value,
          componentDatatype,
          componentsPerAttribute: attribute.componentsPerAttribute,
          normalize: attribute.normalize
        });
      }
    }
  }
  let indexBuffer;
  const indices2 = geometry.indices;
  if (defined_default(indices2)) {
    if (Geometry_default.computeNumberOfVertices(geometry) >= Math_default.SIXTY_FOUR_KILOBYTES && context.elementIndexUint) {
      indexBuffer = Buffer_default.createIndexBuffer({
        context,
        typedArray: new Uint32Array(indices2),
        usage: bufferUsage,
        indexDatatype: IndexDatatype_default.UNSIGNED_INT
      });
    } else {
      indexBuffer = Buffer_default.createIndexBuffer({
        context,
        typedArray: new Uint16Array(indices2),
        usage: bufferUsage,
        indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
      });
    }
  }
  return new VertexArray({
    context,
    attributes: vaAttributes,
    indexBuffer
  });
};
Object.defineProperties(VertexArray.prototype, {
  numberOfAttributes: {
    get: function() {
      return this._attributes.length;
    }
  },
  numberOfVertices: {
    get: function() {
      return this._numberOfVertices;
    }
  },
  indexBuffer: {
    get: function() {
      return this._indexBuffer;
    }
  }
});
VertexArray.prototype.getAttribute = function(index2) {
  Check_default.defined("index", index2);
  return this._attributes[index2];
};
function setVertexAttribDivisor(vertexArray) {
  const context = vertexArray._context;
  const hasInstancedAttributes = vertexArray._hasInstancedAttributes;
  if (!hasInstancedAttributes && !context._previousDrawInstanced) {
    return;
  }
  context._previousDrawInstanced = hasInstancedAttributes;
  const divisors = context._vertexAttribDivisors;
  const attributes = vertexArray._attributes;
  const maxAttributes = ContextLimits_default.maximumVertexAttributes;
  let i2;
  if (hasInstancedAttributes) {
    const length3 = attributes.length;
    for (i2 = 0; i2 < length3; ++i2) {
      const attribute = attributes[i2];
      if (attribute.enabled) {
        const divisor = attribute.instanceDivisor;
        const index2 = attribute.index;
        if (divisor !== divisors[index2]) {
          context.glVertexAttribDivisor(index2, divisor);
          divisors[index2] = divisor;
        }
      }
    }
  } else {
    for (i2 = 0; i2 < maxAttributes; ++i2) {
      if (divisors[i2] > 0) {
        context.glVertexAttribDivisor(i2, 0);
        divisors[i2] = 0;
      }
    }
  }
}
function setConstantAttributes(vertexArray, gl) {
  const attributes = vertexArray._attributes;
  const length3 = attributes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const attribute = attributes[i2];
    if (attribute.enabled && defined_default(attribute.value)) {
      attribute.vertexAttrib(gl);
    }
  }
}
VertexArray.prototype._bind = function() {
  if (defined_default(this._vao)) {
    this._context.glBindVertexArray(this._vao);
    if (this._context.instancedArrays) {
      setVertexAttribDivisor(this);
    }
    if (this._hasConstantAttributes) {
      setConstantAttributes(this, this._gl);
    }
  } else {
    bind(this._gl, this._attributes, this._indexBuffer);
  }
};
VertexArray.prototype._unBind = function() {
  if (defined_default(this._vao)) {
    this._context.glBindVertexArray(null);
  } else {
    const attributes = this._attributes;
    const gl = this._gl;
    for (let i2 = 0; i2 < attributes.length; ++i2) {
      const attribute = attributes[i2];
      if (attribute.enabled) {
        attribute.disableVertexAttribArray(gl);
      }
    }
    if (this._indexBuffer) {
      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
    }
  }
};
VertexArray.prototype.isDestroyed = function() {
  return false;
};
VertexArray.prototype.destroy = function() {
  const attributes = this._attributes;
  for (let i2 = 0; i2 < attributes.length; ++i2) {
    const vertexBuffer = attributes[i2].vertexBuffer;
    if (defined_default(vertexBuffer) && !vertexBuffer.isDestroyed() && vertexBuffer.vertexArrayDestroyable) {
      vertexBuffer.destroy();
    }
  }
  const indexBuffer = this._indexBuffer;
  if (defined_default(indexBuffer) && !indexBuffer.isDestroyed() && indexBuffer.vertexArrayDestroyable) {
    indexBuffer.destroy();
  }
  if (defined_default(this._vao)) {
    this._context.glDeleteVertexArray(this._vao);
  }
  return destroyObject_default(this);
};
var VertexArray_default = VertexArray;

// node_modules/cesium/Source/Scene/BatchTable.js
function BatchTable(context, attributes, numberOfInstances) {
  if (!defined_default(context)) {
    throw new DeveloperError_default("context is required");
  }
  if (!defined_default(attributes)) {
    throw new DeveloperError_default("attributes is required");
  }
  if (!defined_default(numberOfInstances)) {
    throw new DeveloperError_default("numberOfInstances is required");
  }
  this._attributes = attributes;
  this._numberOfInstances = numberOfInstances;
  if (attributes.length === 0) {
    return;
  }
  const pixelDatatype = getDatatype(attributes);
  const textureFloatSupported = context.floatingPointTexture;
  const packFloats = pixelDatatype === PixelDatatype_default.FLOAT && !textureFloatSupported;
  const offsets = createOffsets(attributes, packFloats);
  const stride = getStride(offsets, attributes, packFloats);
  const maxNumberOfInstancesPerRow = Math.floor(
    ContextLimits_default.maximumTextureSize / stride
  );
  const instancesPerWidth = Math.min(
    numberOfInstances,
    maxNumberOfInstancesPerRow
  );
  const width = stride * instancesPerWidth;
  const height = Math.ceil(numberOfInstances / instancesPerWidth);
  const stepX = 1 / width;
  const centerX = stepX * 0.5;
  const stepY = 1 / height;
  const centerY = stepY * 0.5;
  this._textureDimensions = new Cartesian2_default(width, height);
  this._textureStep = new Cartesian4_default(stepX, centerX, stepY, centerY);
  this._pixelDatatype = !packFloats ? pixelDatatype : PixelDatatype_default.UNSIGNED_BYTE;
  this._packFloats = packFloats;
  this._offsets = offsets;
  this._stride = stride;
  this._texture = void 0;
  const batchLength = 4 * width * height;
  this._batchValues = pixelDatatype === PixelDatatype_default.FLOAT && !packFloats ? new Float32Array(batchLength) : new Uint8Array(batchLength);
  this._batchValuesDirty = false;
}
Object.defineProperties(BatchTable.prototype, {
  attributes: {
    get: function() {
      return this._attributes;
    }
  },
  numberOfInstances: {
    get: function() {
      return this._numberOfInstances;
    }
  }
});
function getDatatype(attributes) {
  let foundFloatDatatype = false;
  const length3 = attributes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (attributes[i2].componentDatatype !== ComponentDatatype_default.UNSIGNED_BYTE) {
      foundFloatDatatype = true;
      break;
    }
  }
  return foundFloatDatatype ? PixelDatatype_default.FLOAT : PixelDatatype_default.UNSIGNED_BYTE;
}
function getAttributeType(attributes, attributeIndex) {
  const componentsPerAttribute = attributes[attributeIndex].componentsPerAttribute;
  if (componentsPerAttribute === 2) {
    return Cartesian2_default;
  } else if (componentsPerAttribute === 3) {
    return Cartesian3_default;
  } else if (componentsPerAttribute === 4) {
    return Cartesian4_default;
  }
  return Number;
}
function createOffsets(attributes, packFloats) {
  const offsets = new Array(attributes.length);
  let currentOffset = 0;
  const attributesLength = attributes.length;
  for (let i2 = 0; i2 < attributesLength; ++i2) {
    const attribute = attributes[i2];
    const componentDatatype = attribute.componentDatatype;
    offsets[i2] = currentOffset;
    if (componentDatatype !== ComponentDatatype_default.UNSIGNED_BYTE && packFloats) {
      currentOffset += 4;
    } else {
      ++currentOffset;
    }
  }
  return offsets;
}
function getStride(offsets, attributes, packFloats) {
  const length3 = offsets.length;
  const lastOffset = offsets[length3 - 1];
  const lastAttribute = attributes[length3 - 1];
  const componentDatatype = lastAttribute.componentDatatype;
  if (componentDatatype !== ComponentDatatype_default.UNSIGNED_BYTE && packFloats) {
    return lastOffset + 4;
  }
  return lastOffset + 1;
}
var scratchPackedFloatCartesian4 = new Cartesian4_default();
function getPackedFloat(array, index2, result) {
  let packed = Cartesian4_default.unpack(array, index2, scratchPackedFloatCartesian4);
  const x = Cartesian4_default.unpackFloat(packed);
  packed = Cartesian4_default.unpack(array, index2 + 4, scratchPackedFloatCartesian4);
  const y = Cartesian4_default.unpackFloat(packed);
  packed = Cartesian4_default.unpack(array, index2 + 8, scratchPackedFloatCartesian4);
  const z = Cartesian4_default.unpackFloat(packed);
  packed = Cartesian4_default.unpack(array, index2 + 12, scratchPackedFloatCartesian4);
  const w = Cartesian4_default.unpackFloat(packed);
  return Cartesian4_default.fromElements(x, y, z, w, result);
}
function setPackedAttribute(value, array, index2) {
  let packed = Cartesian4_default.packFloat(value.x, scratchPackedFloatCartesian4);
  Cartesian4_default.pack(packed, array, index2);
  packed = Cartesian4_default.packFloat(value.y, packed);
  Cartesian4_default.pack(packed, array, index2 + 4);
  packed = Cartesian4_default.packFloat(value.z, packed);
  Cartesian4_default.pack(packed, array, index2 + 8);
  packed = Cartesian4_default.packFloat(value.w, packed);
  Cartesian4_default.pack(packed, array, index2 + 12);
}
var scratchGetAttributeCartesian4 = new Cartesian4_default();
BatchTable.prototype.getBatchedAttribute = function(instanceIndex, attributeIndex, result) {
  if (instanceIndex < 0 || instanceIndex >= this._numberOfInstances) {
    throw new DeveloperError_default("instanceIndex is out of range.");
  }
  if (attributeIndex < 0 || attributeIndex >= this._attributes.length) {
    throw new DeveloperError_default("attributeIndex is out of range");
  }
  const attributes = this._attributes;
  const offset2 = this._offsets[attributeIndex];
  const stride = this._stride;
  const index2 = 4 * stride * instanceIndex + 4 * offset2;
  let value;
  if (this._packFloats && attributes[attributeIndex].componentDatatype !== PixelDatatype_default.UNSIGNED_BYTE) {
    value = getPackedFloat(
      this._batchValues,
      index2,
      scratchGetAttributeCartesian4
    );
  } else {
    value = Cartesian4_default.unpack(
      this._batchValues,
      index2,
      scratchGetAttributeCartesian4
    );
  }
  const attributeType = getAttributeType(attributes, attributeIndex);
  if (defined_default(attributeType.fromCartesian4)) {
    return attributeType.fromCartesian4(value, result);
  } else if (defined_default(attributeType.clone)) {
    return attributeType.clone(value, result);
  }
  return value.x;
};
var setAttributeScratchValues = [
  void 0,
  void 0,
  new Cartesian2_default(),
  new Cartesian3_default(),
  new Cartesian4_default()
];
var setAttributeScratchCartesian4 = new Cartesian4_default();
BatchTable.prototype.setBatchedAttribute = function(instanceIndex, attributeIndex, value) {
  if (instanceIndex < 0 || instanceIndex >= this._numberOfInstances) {
    throw new DeveloperError_default("instanceIndex is out of range.");
  }
  if (attributeIndex < 0 || attributeIndex >= this._attributes.length) {
    throw new DeveloperError_default("attributeIndex is out of range");
  }
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required.");
  }
  const attributes = this._attributes;
  const result = setAttributeScratchValues[attributes[attributeIndex].componentsPerAttribute];
  const currentAttribute = this.getBatchedAttribute(
    instanceIndex,
    attributeIndex,
    result
  );
  const attributeType = getAttributeType(this._attributes, attributeIndex);
  const entriesEqual = defined_default(attributeType.equals) ? attributeType.equals(currentAttribute, value) : currentAttribute === value;
  if (entriesEqual) {
    return;
  }
  const attributeValue = setAttributeScratchCartesian4;
  attributeValue.x = defined_default(value.x) ? value.x : value;
  attributeValue.y = defined_default(value.y) ? value.y : 0;
  attributeValue.z = defined_default(value.z) ? value.z : 0;
  attributeValue.w = defined_default(value.w) ? value.w : 0;
  const offset2 = this._offsets[attributeIndex];
  const stride = this._stride;
  const index2 = 4 * stride * instanceIndex + 4 * offset2;
  if (this._packFloats && attributes[attributeIndex].componentDatatype !== PixelDatatype_default.UNSIGNED_BYTE) {
    setPackedAttribute(attributeValue, this._batchValues, index2);
  } else {
    Cartesian4_default.pack(attributeValue, this._batchValues, index2);
  }
  this._batchValuesDirty = true;
};
function createTexture(batchTable, context) {
  const dimensions = batchTable._textureDimensions;
  batchTable._texture = new Texture_default({
    context,
    pixelFormat: PixelFormat_default.RGBA,
    pixelDatatype: batchTable._pixelDatatype,
    width: dimensions.x,
    height: dimensions.y,
    sampler: Sampler_default.NEAREST,
    flipY: false
  });
}
function updateTexture(batchTable) {
  const dimensions = batchTable._textureDimensions;
  batchTable._texture.copyFrom({
    source: {
      width: dimensions.x,
      height: dimensions.y,
      arrayBufferView: batchTable._batchValues
    }
  });
}
BatchTable.prototype.update = function(frameState) {
  if (defined_default(this._texture) && !this._batchValuesDirty || this._attributes.length === 0) {
    return;
  }
  this._batchValuesDirty = false;
  if (!defined_default(this._texture)) {
    createTexture(this, frameState.context);
  }
  updateTexture(this);
};
BatchTable.prototype.getUniformMapCallback = function() {
  const that = this;
  return function(uniformMap2) {
    if (that._attributes.length === 0) {
      return uniformMap2;
    }
    const batchUniformMap = {
      batchTexture: function() {
        return that._texture;
      },
      batchTextureDimensions: function() {
        return that._textureDimensions;
      },
      batchTextureStep: function() {
        return that._textureStep;
      }
    };
    return combine_default(uniformMap2, batchUniformMap);
  };
};
function getGlslComputeSt(batchTable) {
  const stride = batchTable._stride;
  if (batchTable._textureDimensions.y === 1) {
    return `${"uniform vec4 batchTextureStep; \nvec2 computeSt(float batchId) \n{ \n    float stepX = batchTextureStep.x; \n    float centerX = batchTextureStep.y; \n    float numberOfAttributes = float("}${stride}); 
    return vec2(centerX + (batchId * numberOfAttributes * stepX), 0.5); 
} 
`;
  }
  return `${"uniform vec4 batchTextureStep; \nuniform vec2 batchTextureDimensions; \nvec2 computeSt(float batchId) \n{ \n    float stepX = batchTextureStep.x; \n    float centerX = batchTextureStep.y; \n    float stepY = batchTextureStep.z; \n    float centerY = batchTextureStep.w; \n    float numberOfAttributes = float("}${stride}); 
    float xId = mod(batchId * numberOfAttributes, batchTextureDimensions.x); 
    float yId = floor(batchId * numberOfAttributes / batchTextureDimensions.x); 
    return vec2(centerX + (xId * stepX), centerY + (yId * stepY)); 
} 
`;
}
function getComponentType(componentsPerAttribute) {
  if (componentsPerAttribute === 1) {
    return "float";
  }
  return `vec${componentsPerAttribute}`;
}
function getComponentSwizzle(componentsPerAttribute) {
  if (componentsPerAttribute === 1) {
    return ".x";
  } else if (componentsPerAttribute === 2) {
    return ".xy";
  } else if (componentsPerAttribute === 3) {
    return ".xyz";
  }
  return "";
}
function getGlslAttributeFunction(batchTable, attributeIndex) {
  const attributes = batchTable._attributes;
  const attribute = attributes[attributeIndex];
  const componentsPerAttribute = attribute.componentsPerAttribute;
  const functionName = attribute.functionName;
  const functionReturnType = getComponentType(componentsPerAttribute);
  const functionReturnValue = getComponentSwizzle(componentsPerAttribute);
  const offset2 = batchTable._offsets[attributeIndex];
  let glslFunction = `${functionReturnType} ${functionName}(float batchId) 
{ 
    vec2 st = computeSt(batchId); 
    st.x += batchTextureStep.x * float(${offset2}); 
`;
  if (batchTable._packFloats && attribute.componentDatatype !== PixelDatatype_default.UNSIGNED_BYTE) {
    glslFunction += "vec4 textureValue; \ntextureValue.x = czm_unpackFloat(texture2D(batchTexture, st)); \ntextureValue.y = czm_unpackFloat(texture2D(batchTexture, st + vec2(batchTextureStep.x, 0.0))); \ntextureValue.z = czm_unpackFloat(texture2D(batchTexture, st + vec2(batchTextureStep.x * 2.0, 0.0))); \ntextureValue.w = czm_unpackFloat(texture2D(batchTexture, st + vec2(batchTextureStep.x * 3.0, 0.0))); \n";
  } else {
    glslFunction += "    vec4 textureValue = texture2D(batchTexture, st); \n";
  }
  glslFunction += `    ${functionReturnType} value = textureValue${functionReturnValue}; 
`;
  if (batchTable._pixelDatatype === PixelDatatype_default.UNSIGNED_BYTE && attribute.componentDatatype === ComponentDatatype_default.UNSIGNED_BYTE && !attribute.normalize) {
    glslFunction += "value *= 255.0; \n";
  } else if (batchTable._pixelDatatype === PixelDatatype_default.FLOAT && attribute.componentDatatype === ComponentDatatype_default.UNSIGNED_BYTE && attribute.normalize) {
    glslFunction += "value /= 255.0; \n";
  }
  glslFunction += "    return value; \n} \n";
  return glslFunction;
}
BatchTable.prototype.getVertexShaderCallback = function() {
  const attributes = this._attributes;
  if (attributes.length === 0) {
    return function(source) {
      return source;
    };
  }
  let batchTableShader = "uniform highp sampler2D batchTexture; \n";
  batchTableShader += `${getGlslComputeSt(this)}
`;
  const length3 = attributes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    batchTableShader += getGlslAttributeFunction(this, i2);
  }
  return function(source) {
    const mainIndex = source.indexOf("void main");
    const beforeMain = source.substring(0, mainIndex);
    const afterMain = source.substring(mainIndex);
    return `${beforeMain}
${batchTableShader}
${afterMain}`;
  };
};
BatchTable.prototype.isDestroyed = function() {
  return false;
};
BatchTable.prototype.destroy = function() {
  this._texture = this._texture && this._texture.destroy();
  return destroyObject_default(this);
};
var BatchTable_default = BatchTable;

// node_modules/cesium/Source/Scene/PrimitivePipeline.js
function transformToWorldCoordinates(instances, primitiveModelMatrix, scene3DOnly) {
  let toWorld = !scene3DOnly;
  const length3 = instances.length;
  let i2;
  if (!toWorld && length3 > 1) {
    const modelMatrix = instances[0].modelMatrix;
    for (i2 = 1; i2 < length3; ++i2) {
      if (!Matrix4_default.equals(modelMatrix, instances[i2].modelMatrix)) {
        toWorld = true;
        break;
      }
    }
  }
  if (toWorld) {
    for (i2 = 0; i2 < length3; ++i2) {
      if (defined_default(instances[i2].geometry)) {
        GeometryPipeline_default.transformToWorldCoordinates(instances[i2]);
      }
    }
  } else {
    Matrix4_default.multiplyTransformation(
      primitiveModelMatrix,
      instances[0].modelMatrix,
      primitiveModelMatrix
    );
  }
}
function addGeometryBatchId(geometry, batchId) {
  const attributes = geometry.attributes;
  const positionAttr = attributes.position;
  const numberOfComponents = positionAttr.values.length / positionAttr.componentsPerAttribute;
  attributes.batchId = new GeometryAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 1,
    values: new Float32Array(numberOfComponents)
  });
  const values = attributes.batchId.values;
  for (let j = 0; j < numberOfComponents; ++j) {
    values[j] = batchId;
  }
}
function addBatchIds(instances) {
  const length3 = instances.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const instance = instances[i2];
    if (defined_default(instance.geometry)) {
      addGeometryBatchId(instance.geometry, i2);
    } else if (defined_default(instance.westHemisphereGeometry) && defined_default(instance.eastHemisphereGeometry)) {
      addGeometryBatchId(instance.westHemisphereGeometry, i2);
      addGeometryBatchId(instance.eastHemisphereGeometry, i2);
    }
  }
}
function geometryPipeline(parameters) {
  const instances = parameters.instances;
  const projection = parameters.projection;
  const uintIndexSupport = parameters.elementIndexUintSupported;
  const scene3DOnly = parameters.scene3DOnly;
  const vertexCacheOptimize = parameters.vertexCacheOptimize;
  const compressVertices = parameters.compressVertices;
  const modelMatrix = parameters.modelMatrix;
  let i2;
  let geometry;
  let primitiveType;
  let length3 = instances.length;
  for (i2 = 0; i2 < length3; ++i2) {
    if (defined_default(instances[i2].geometry)) {
      primitiveType = instances[i2].geometry.primitiveType;
      break;
    }
  }
  for (i2 = 1; i2 < length3; ++i2) {
    if (defined_default(instances[i2].geometry) && instances[i2].geometry.primitiveType !== primitiveType) {
      throw new DeveloperError_default(
        "All instance geometries must have the same primitiveType."
      );
    }
  }
  transformToWorldCoordinates(instances, modelMatrix, scene3DOnly);
  if (!scene3DOnly) {
    for (i2 = 0; i2 < length3; ++i2) {
      if (defined_default(instances[i2].geometry)) {
        GeometryPipeline_default.splitLongitude(instances[i2]);
      }
    }
  }
  addBatchIds(instances);
  if (vertexCacheOptimize) {
    for (i2 = 0; i2 < length3; ++i2) {
      const instance = instances[i2];
      if (defined_default(instance.geometry)) {
        GeometryPipeline_default.reorderForPostVertexCache(instance.geometry);
        GeometryPipeline_default.reorderForPreVertexCache(instance.geometry);
      } else if (defined_default(instance.westHemisphereGeometry) && defined_default(instance.eastHemisphereGeometry)) {
        GeometryPipeline_default.reorderForPostVertexCache(
          instance.westHemisphereGeometry
        );
        GeometryPipeline_default.reorderForPreVertexCache(
          instance.westHemisphereGeometry
        );
        GeometryPipeline_default.reorderForPostVertexCache(
          instance.eastHemisphereGeometry
        );
        GeometryPipeline_default.reorderForPreVertexCache(
          instance.eastHemisphereGeometry
        );
      }
    }
  }
  let geometries = GeometryPipeline_default.combineInstances(instances);
  length3 = geometries.length;
  for (i2 = 0; i2 < length3; ++i2) {
    geometry = geometries[i2];
    const attributes = geometry.attributes;
    if (!scene3DOnly) {
      for (const name in attributes) {
        if (attributes.hasOwnProperty(name) && attributes[name].componentDatatype === ComponentDatatype_default.DOUBLE) {
          const name3D = `${name}3D`;
          const name2D = `${name}2D`;
          GeometryPipeline_default.projectTo2D(
            geometry,
            name,
            name3D,
            name2D,
            projection
          );
          if (defined_default(geometry.boundingSphere) && name === "position") {
            geometry.boundingSphereCV = BoundingSphere_default.fromVertices(
              geometry.attributes.position2D.values
            );
          }
          GeometryPipeline_default.encodeAttribute(
            geometry,
            name3D,
            `${name3D}High`,
            `${name3D}Low`
          );
          GeometryPipeline_default.encodeAttribute(
            geometry,
            name2D,
            `${name2D}High`,
            `${name2D}Low`
          );
        }
      }
    } else {
      for (const name in attributes) {
        if (attributes.hasOwnProperty(name) && attributes[name].componentDatatype === ComponentDatatype_default.DOUBLE) {
          GeometryPipeline_default.encodeAttribute(
            geometry,
            name,
            `${name}3DHigh`,
            `${name}3DLow`
          );
        }
      }
    }
    if (compressVertices) {
      GeometryPipeline_default.compressVertices(geometry);
    }
  }
  if (!uintIndexSupport) {
    let splitGeometries = [];
    length3 = geometries.length;
    for (i2 = 0; i2 < length3; ++i2) {
      geometry = geometries[i2];
      splitGeometries = splitGeometries.concat(
        GeometryPipeline_default.fitToUnsignedShortIndices(geometry)
      );
    }
    geometries = splitGeometries;
  }
  return geometries;
}
function createPickOffsets(instances, geometryName, geometries, pickOffsets) {
  let offset2;
  let indexCount;
  let geometryIndex;
  const offsetIndex = pickOffsets.length - 1;
  if (offsetIndex >= 0) {
    const pickOffset = pickOffsets[offsetIndex];
    offset2 = pickOffset.offset + pickOffset.count;
    geometryIndex = pickOffset.index;
    indexCount = geometries[geometryIndex].indices.length;
  } else {
    offset2 = 0;
    geometryIndex = 0;
    indexCount = geometries[geometryIndex].indices.length;
  }
  const length3 = instances.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const instance = instances[i2];
    const geometry = instance[geometryName];
    if (!defined_default(geometry)) {
      continue;
    }
    const count = geometry.indices.length;
    if (offset2 + count > indexCount) {
      offset2 = 0;
      indexCount = geometries[++geometryIndex].indices.length;
    }
    pickOffsets.push({
      index: geometryIndex,
      offset: offset2,
      count
    });
    offset2 += count;
  }
}
function createInstancePickOffsets(instances, geometries) {
  const pickOffsets = [];
  createPickOffsets(instances, "geometry", geometries, pickOffsets);
  createPickOffsets(
    instances,
    "westHemisphereGeometry",
    geometries,
    pickOffsets
  );
  createPickOffsets(
    instances,
    "eastHemisphereGeometry",
    geometries,
    pickOffsets
  );
  return pickOffsets;
}
var PrimitivePipeline = {};
PrimitivePipeline.combineGeometry = function(parameters) {
  let geometries;
  let attributeLocations8;
  const instances = parameters.instances;
  const length3 = instances.length;
  let pickOffsets;
  let offsetInstanceExtend;
  let hasOffset = false;
  if (length3 > 0) {
    geometries = geometryPipeline(parameters);
    if (geometries.length > 0) {
      attributeLocations8 = GeometryPipeline_default.createAttributeLocations(
        geometries[0]
      );
      if (parameters.createPickOffsets) {
        pickOffsets = createInstancePickOffsets(instances, geometries);
      }
    }
    if (defined_default(instances[0].attributes) && defined_default(instances[0].attributes.offset)) {
      offsetInstanceExtend = new Array(length3);
      hasOffset = true;
    }
  }
  const boundingSpheres = new Array(length3);
  const boundingSpheresCV = new Array(length3);
  for (let i2 = 0; i2 < length3; ++i2) {
    const instance = instances[i2];
    const geometry = instance.geometry;
    if (defined_default(geometry)) {
      boundingSpheres[i2] = geometry.boundingSphere;
      boundingSpheresCV[i2] = geometry.boundingSphereCV;
      if (hasOffset) {
        offsetInstanceExtend[i2] = instance.geometry.offsetAttribute;
      }
    }
    const eastHemisphereGeometry = instance.eastHemisphereGeometry;
    const westHemisphereGeometry = instance.westHemisphereGeometry;
    if (defined_default(eastHemisphereGeometry) && defined_default(westHemisphereGeometry)) {
      if (defined_default(eastHemisphereGeometry.boundingSphere) && defined_default(westHemisphereGeometry.boundingSphere)) {
        boundingSpheres[i2] = BoundingSphere_default.union(
          eastHemisphereGeometry.boundingSphere,
          westHemisphereGeometry.boundingSphere
        );
      }
      if (defined_default(eastHemisphereGeometry.boundingSphereCV) && defined_default(westHemisphereGeometry.boundingSphereCV)) {
        boundingSpheresCV[i2] = BoundingSphere_default.union(
          eastHemisphereGeometry.boundingSphereCV,
          westHemisphereGeometry.boundingSphereCV
        );
      }
    }
  }
  return {
    geometries,
    modelMatrix: parameters.modelMatrix,
    attributeLocations: attributeLocations8,
    pickOffsets,
    offsetInstanceExtend,
    boundingSpheres,
    boundingSpheresCV
  };
};
function transferGeometry(geometry, transferableObjects) {
  const attributes = geometry.attributes;
  for (const name in attributes) {
    if (attributes.hasOwnProperty(name)) {
      const attribute = attributes[name];
      if (defined_default(attribute) && defined_default(attribute.values)) {
        transferableObjects.push(attribute.values.buffer);
      }
    }
  }
  if (defined_default(geometry.indices)) {
    transferableObjects.push(geometry.indices.buffer);
  }
}
function transferGeometries(geometries, transferableObjects) {
  const length3 = geometries.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    transferGeometry(geometries[i2], transferableObjects);
  }
}
function countCreateGeometryResults(items) {
  let count = 1;
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const geometry = items[i2];
    ++count;
    if (!defined_default(geometry)) {
      continue;
    }
    const attributes = geometry.attributes;
    count += 7 + 2 * BoundingSphere_default.packedLength + (defined_default(geometry.indices) ? geometry.indices.length : 0);
    for (const property in attributes) {
      if (attributes.hasOwnProperty(property) && defined_default(attributes[property])) {
        const attribute = attributes[property];
        count += 5 + attribute.values.length;
      }
    }
  }
  return count;
}
PrimitivePipeline.packCreateGeometryResults = function(items, transferableObjects) {
  const packedData = new Float64Array(countCreateGeometryResults(items));
  const stringTable = [];
  const stringHash = {};
  const length3 = items.length;
  let count = 0;
  packedData[count++] = length3;
  for (let i2 = 0; i2 < length3; i2++) {
    const geometry = items[i2];
    const validGeometry = defined_default(geometry);
    packedData[count++] = validGeometry ? 1 : 0;
    if (!validGeometry) {
      continue;
    }
    packedData[count++] = geometry.primitiveType;
    packedData[count++] = geometry.geometryType;
    packedData[count++] = defaultValue_default(geometry.offsetAttribute, -1);
    const validBoundingSphere = defined_default(geometry.boundingSphere) ? 1 : 0;
    packedData[count++] = validBoundingSphere;
    if (validBoundingSphere) {
      BoundingSphere_default.pack(geometry.boundingSphere, packedData, count);
    }
    count += BoundingSphere_default.packedLength;
    const validBoundingSphereCV = defined_default(geometry.boundingSphereCV) ? 1 : 0;
    packedData[count++] = validBoundingSphereCV;
    if (validBoundingSphereCV) {
      BoundingSphere_default.pack(geometry.boundingSphereCV, packedData, count);
    }
    count += BoundingSphere_default.packedLength;
    const attributes = geometry.attributes;
    const attributesToWrite = [];
    for (const property in attributes) {
      if (attributes.hasOwnProperty(property) && defined_default(attributes[property])) {
        attributesToWrite.push(property);
        if (!defined_default(stringHash[property])) {
          stringHash[property] = stringTable.length;
          stringTable.push(property);
        }
      }
    }
    packedData[count++] = attributesToWrite.length;
    for (let q = 0; q < attributesToWrite.length; q++) {
      const name = attributesToWrite[q];
      const attribute = attributes[name];
      packedData[count++] = stringHash[name];
      packedData[count++] = attribute.componentDatatype;
      packedData[count++] = attribute.componentsPerAttribute;
      packedData[count++] = attribute.normalize ? 1 : 0;
      packedData[count++] = attribute.values.length;
      packedData.set(attribute.values, count);
      count += attribute.values.length;
    }
    const indicesLength = defined_default(geometry.indices) ? geometry.indices.length : 0;
    packedData[count++] = indicesLength;
    if (indicesLength > 0) {
      packedData.set(geometry.indices, count);
      count += indicesLength;
    }
  }
  transferableObjects.push(packedData.buffer);
  return {
    stringTable,
    packedData
  };
};
PrimitivePipeline.unpackCreateGeometryResults = function(createGeometryResult) {
  const stringTable = createGeometryResult.stringTable;
  const packedGeometry = createGeometryResult.packedData;
  let i2;
  const result = new Array(packedGeometry[0]);
  let resultIndex = 0;
  let packedGeometryIndex = 1;
  while (packedGeometryIndex < packedGeometry.length) {
    const valid = packedGeometry[packedGeometryIndex++] === 1;
    if (!valid) {
      result[resultIndex++] = void 0;
      continue;
    }
    const primitiveType = packedGeometry[packedGeometryIndex++];
    const geometryType = packedGeometry[packedGeometryIndex++];
    let offsetAttribute = packedGeometry[packedGeometryIndex++];
    if (offsetAttribute === -1) {
      offsetAttribute = void 0;
    }
    let boundingSphere;
    let boundingSphereCV;
    const validBoundingSphere = packedGeometry[packedGeometryIndex++] === 1;
    if (validBoundingSphere) {
      boundingSphere = BoundingSphere_default.unpack(
        packedGeometry,
        packedGeometryIndex
      );
    }
    packedGeometryIndex += BoundingSphere_default.packedLength;
    const validBoundingSphereCV = packedGeometry[packedGeometryIndex++] === 1;
    if (validBoundingSphereCV) {
      boundingSphereCV = BoundingSphere_default.unpack(
        packedGeometry,
        packedGeometryIndex
      );
    }
    packedGeometryIndex += BoundingSphere_default.packedLength;
    let length3;
    let values;
    let componentsPerAttribute;
    const attributes = new GeometryAttributes_default();
    const numAttributes = packedGeometry[packedGeometryIndex++];
    for (i2 = 0; i2 < numAttributes; i2++) {
      const name = stringTable[packedGeometry[packedGeometryIndex++]];
      const componentDatatype = packedGeometry[packedGeometryIndex++];
      componentsPerAttribute = packedGeometry[packedGeometryIndex++];
      const normalize2 = packedGeometry[packedGeometryIndex++] !== 0;
      length3 = packedGeometry[packedGeometryIndex++];
      values = ComponentDatatype_default.createTypedArray(componentDatatype, length3);
      for (let valuesIndex = 0; valuesIndex < length3; valuesIndex++) {
        values[valuesIndex] = packedGeometry[packedGeometryIndex++];
      }
      attributes[name] = new GeometryAttribute_default({
        componentDatatype,
        componentsPerAttribute,
        normalize: normalize2,
        values
      });
    }
    let indices2;
    length3 = packedGeometry[packedGeometryIndex++];
    if (length3 > 0) {
      const numberOfVertices = values.length / componentsPerAttribute;
      indices2 = IndexDatatype_default.createTypedArray(numberOfVertices, length3);
      for (i2 = 0; i2 < length3; i2++) {
        indices2[i2] = packedGeometry[packedGeometryIndex++];
      }
    }
    result[resultIndex++] = new Geometry_default({
      primitiveType,
      geometryType,
      boundingSphere,
      boundingSphereCV,
      indices: indices2,
      attributes,
      offsetAttribute
    });
  }
  return result;
};
function packInstancesForCombine(instances, transferableObjects) {
  const length3 = instances.length;
  const packedData = new Float64Array(1 + length3 * 19);
  let count = 0;
  packedData[count++] = length3;
  for (let i2 = 0; i2 < length3; i2++) {
    const instance = instances[i2];
    Matrix4_default.pack(instance.modelMatrix, packedData, count);
    count += Matrix4_default.packedLength;
    if (defined_default(instance.attributes) && defined_default(instance.attributes.offset)) {
      const values = instance.attributes.offset.value;
      packedData[count] = values[0];
      packedData[count + 1] = values[1];
      packedData[count + 2] = values[2];
    }
    count += 3;
  }
  transferableObjects.push(packedData.buffer);
  return packedData;
}
function unpackInstancesForCombine(data) {
  const packedInstances = data;
  const result = new Array(packedInstances[0]);
  let count = 0;
  let i2 = 1;
  while (i2 < packedInstances.length) {
    const modelMatrix = Matrix4_default.unpack(packedInstances, i2);
    let attributes;
    i2 += Matrix4_default.packedLength;
    if (defined_default(packedInstances[i2])) {
      attributes = {
        offset: new OffsetGeometryInstanceAttribute_default(
          packedInstances[i2],
          packedInstances[i2 + 1],
          packedInstances[i2 + 2]
        )
      };
    }
    i2 += 3;
    result[count++] = {
      modelMatrix,
      attributes
    };
  }
  return result;
}
PrimitivePipeline.packCombineGeometryParameters = function(parameters, transferableObjects) {
  const createGeometryResults = parameters.createGeometryResults;
  const length3 = createGeometryResults.length;
  for (let i2 = 0; i2 < length3; i2++) {
    transferableObjects.push(createGeometryResults[i2].packedData.buffer);
  }
  return {
    createGeometryResults: parameters.createGeometryResults,
    packedInstances: packInstancesForCombine(
      parameters.instances,
      transferableObjects
    ),
    ellipsoid: parameters.ellipsoid,
    isGeographic: parameters.projection instanceof GeographicProjection_default,
    elementIndexUintSupported: parameters.elementIndexUintSupported,
    scene3DOnly: parameters.scene3DOnly,
    vertexCacheOptimize: parameters.vertexCacheOptimize,
    compressVertices: parameters.compressVertices,
    modelMatrix: parameters.modelMatrix,
    createPickOffsets: parameters.createPickOffsets
  };
};
PrimitivePipeline.unpackCombineGeometryParameters = function(packedParameters) {
  const instances = unpackInstancesForCombine(packedParameters.packedInstances);
  const createGeometryResults = packedParameters.createGeometryResults;
  const length3 = createGeometryResults.length;
  let instanceIndex = 0;
  for (let resultIndex = 0; resultIndex < length3; resultIndex++) {
    const geometries = PrimitivePipeline.unpackCreateGeometryResults(
      createGeometryResults[resultIndex]
    );
    const geometriesLength = geometries.length;
    for (let geometryIndex = 0; geometryIndex < geometriesLength; geometryIndex++) {
      const geometry = geometries[geometryIndex];
      const instance = instances[instanceIndex];
      instance.geometry = geometry;
      ++instanceIndex;
    }
  }
  const ellipsoid = Ellipsoid_default.clone(packedParameters.ellipsoid);
  const projection = packedParameters.isGeographic ? new GeographicProjection_default(ellipsoid) : new WebMercatorProjection_default(ellipsoid);
  return {
    instances,
    ellipsoid,
    projection,
    elementIndexUintSupported: packedParameters.elementIndexUintSupported,
    scene3DOnly: packedParameters.scene3DOnly,
    vertexCacheOptimize: packedParameters.vertexCacheOptimize,
    compressVertices: packedParameters.compressVertices,
    modelMatrix: Matrix4_default.clone(packedParameters.modelMatrix),
    createPickOffsets: packedParameters.createPickOffsets
  };
};
function packBoundingSpheres(boundingSpheres) {
  const length3 = boundingSpheres.length;
  const bufferLength = 1 + (BoundingSphere_default.packedLength + 1) * length3;
  const buffer = new Float32Array(bufferLength);
  let bufferIndex = 0;
  buffer[bufferIndex++] = length3;
  for (let i2 = 0; i2 < length3; ++i2) {
    const bs = boundingSpheres[i2];
    if (!defined_default(bs)) {
      buffer[bufferIndex++] = 0;
    } else {
      buffer[bufferIndex++] = 1;
      BoundingSphere_default.pack(boundingSpheres[i2], buffer, bufferIndex);
    }
    bufferIndex += BoundingSphere_default.packedLength;
  }
  return buffer;
}
function unpackBoundingSpheres(buffer) {
  const result = new Array(buffer[0]);
  let count = 0;
  let i2 = 1;
  while (i2 < buffer.length) {
    if (buffer[i2++] === 1) {
      result[count] = BoundingSphere_default.unpack(buffer, i2);
    }
    ++count;
    i2 += BoundingSphere_default.packedLength;
  }
  return result;
}
PrimitivePipeline.packCombineGeometryResults = function(results, transferableObjects) {
  if (defined_default(results.geometries)) {
    transferGeometries(results.geometries, transferableObjects);
  }
  const packedBoundingSpheres = packBoundingSpheres(results.boundingSpheres);
  const packedBoundingSpheresCV = packBoundingSpheres(
    results.boundingSpheresCV
  );
  transferableObjects.push(
    packedBoundingSpheres.buffer,
    packedBoundingSpheresCV.buffer
  );
  return {
    geometries: results.geometries,
    attributeLocations: results.attributeLocations,
    modelMatrix: results.modelMatrix,
    pickOffsets: results.pickOffsets,
    offsetInstanceExtend: results.offsetInstanceExtend,
    boundingSpheres: packedBoundingSpheres,
    boundingSpheresCV: packedBoundingSpheresCV
  };
};
PrimitivePipeline.unpackCombineGeometryResults = function(packedResult) {
  return {
    geometries: packedResult.geometries,
    attributeLocations: packedResult.attributeLocations,
    modelMatrix: packedResult.modelMatrix,
    pickOffsets: packedResult.pickOffsets,
    offsetInstanceExtend: packedResult.offsetInstanceExtend,
    boundingSpheres: unpackBoundingSpheres(packedResult.boundingSpheres),
    boundingSpheresCV: unpackBoundingSpheres(packedResult.boundingSpheresCV)
  };
};
var PrimitivePipeline_default = PrimitivePipeline;

// node_modules/cesium/Source/Scene/PrimitiveState.js
var PrimitiveState = {
  READY: 0,
  CREATING: 1,
  CREATED: 2,
  COMBINING: 3,
  COMBINED: 4,
  COMPLETE: 5,
  FAILED: 6
};
var PrimitiveState_default = Object.freeze(PrimitiveState);

// node_modules/cesium/Source/Scene/SceneMode.js
var SceneMode = {
  MORPHING: 0,
  COLUMBUS_VIEW: 1,
  SCENE2D: 2,
  SCENE3D: 3
};
SceneMode.getMorphTime = function(value) {
  if (value === SceneMode.SCENE3D) {
    return 1;
  } else if (value === SceneMode.MORPHING) {
    return void 0;
  }
  return 0;
};
var SceneMode_default = Object.freeze(SceneMode);

// node_modules/cesium/Source/Scene/ShadowMode.js
var ShadowMode = {
  DISABLED: 0,
  ENABLED: 1,
  CAST_ONLY: 2,
  RECEIVE_ONLY: 3
};
ShadowMode.NUMBER_OF_SHADOW_MODES = 4;
ShadowMode.castShadows = function(shadowMode) {
  return shadowMode === ShadowMode.ENABLED || shadowMode === ShadowMode.CAST_ONLY;
};
ShadowMode.receiveShadows = function(shadowMode) {
  return shadowMode === ShadowMode.ENABLED || shadowMode === ShadowMode.RECEIVE_ONLY;
};
ShadowMode.fromCastReceive = function(castShadows, receiveShadows) {
  if (castShadows && receiveShadows) {
    return ShadowMode.ENABLED;
  } else if (castShadows) {
    return ShadowMode.CAST_ONLY;
  } else if (receiveShadows) {
    return ShadowMode.RECEIVE_ONLY;
  }
  return ShadowMode.DISABLED;
};
var ShadowMode_default = Object.freeze(ShadowMode);

// node_modules/cesium/Source/Scene/Primitive.js
function Primitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.geometryInstances = options.geometryInstances;
  this.appearance = options.appearance;
  this._appearance = void 0;
  this._material = void 0;
  this.depthFailAppearance = options.depthFailAppearance;
  this._depthFailAppearance = void 0;
  this._depthFailMaterial = void 0;
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._modelMatrix = new Matrix4_default();
  this.show = defaultValue_default(options.show, true);
  this._vertexCacheOptimize = defaultValue_default(options.vertexCacheOptimize, false);
  this._interleave = defaultValue_default(options.interleave, false);
  this._releaseGeometryInstances = defaultValue_default(
    options.releaseGeometryInstances,
    true
  );
  this._allowPicking = defaultValue_default(options.allowPicking, true);
  this._asynchronous = defaultValue_default(options.asynchronous, true);
  this._compressVertices = defaultValue_default(options.compressVertices, true);
  this.cull = defaultValue_default(options.cull, true);
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this.rtcCenter = options.rtcCenter;
  if (defined_default(this.rtcCenter) && (!defined_default(this.geometryInstances) || Array.isArray(this.geometryInstances) && this.geometryInstances.length !== 1)) {
    throw new DeveloperError_default(
      "Relative-to-center rendering only supports one geometry instance."
    );
  }
  this.shadows = defaultValue_default(options.shadows, ShadowMode_default.DISABLED);
  this._translucent = void 0;
  this._state = PrimitiveState_default.READY;
  this._geometries = [];
  this._error = void 0;
  this._numberOfInstances = 0;
  this._boundingSpheres = [];
  this._boundingSphereWC = [];
  this._boundingSphereCV = [];
  this._boundingSphere2D = [];
  this._boundingSphereMorph = [];
  this._perInstanceAttributeCache = [];
  this._instanceIds = [];
  this._lastPerInstanceAttributeIndex = 0;
  this._va = [];
  this._attributeLocations = void 0;
  this._primitiveType = void 0;
  this._frontFaceRS = void 0;
  this._backFaceRS = void 0;
  this._sp = void 0;
  this._depthFailAppearance = void 0;
  this._spDepthFail = void 0;
  this._frontFaceDepthFailRS = void 0;
  this._backFaceDepthFailRS = void 0;
  this._pickIds = [];
  this._colorCommands = [];
  this._pickCommands = [];
  this._createBoundingVolumeFunction = options._createBoundingVolumeFunction;
  this._createRenderStatesFunction = options._createRenderStatesFunction;
  this._createShaderProgramFunction = options._createShaderProgramFunction;
  this._createCommandsFunction = options._createCommandsFunction;
  this._updateAndQueueCommandsFunction = options._updateAndQueueCommandsFunction;
  this._createPickOffsets = options._createPickOffsets;
  this._pickOffsets = void 0;
  this._createGeometryResults = void 0;
  this._ready = false;
  this._readyPromise = defer_default();
  this._batchTable = void 0;
  this._batchTableAttributeIndices = void 0;
  this._offsetInstanceExtend = void 0;
  this._batchTableOffsetAttribute2DIndex = void 0;
  this._batchTableOffsetsUpdated = false;
  this._instanceBoundingSpheres = void 0;
  this._instanceBoundingSpheresCV = void 0;
  this._tempBoundingSpheres = void 0;
  this._recomputeBoundingSpheres = false;
  this._batchTableBoundingSpheresUpdated = false;
  this._batchTableBoundingSphereAttributeIndices = void 0;
}
Object.defineProperties(Primitive.prototype, {
  vertexCacheOptimize: {
    get: function() {
      return this._vertexCacheOptimize;
    }
  },
  interleave: {
    get: function() {
      return this._interleave;
    }
  },
  releaseGeometryInstances: {
    get: function() {
      return this._releaseGeometryInstances;
    }
  },
  allowPicking: {
    get: function() {
      return this._allowPicking;
    }
  },
  asynchronous: {
    get: function() {
      return this._asynchronous;
    }
  },
  compressVertices: {
    get: function() {
      return this._compressVertices;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  }
});
function getCommonPerInstanceAttributeNames(instances) {
  const length3 = instances.length;
  const attributesInAllInstances = [];
  const attributes0 = instances[0].attributes;
  let name;
  for (name in attributes0) {
    if (attributes0.hasOwnProperty(name) && defined_default(attributes0[name])) {
      const attribute = attributes0[name];
      let inAllInstances = true;
      for (let i2 = 1; i2 < length3; ++i2) {
        const otherAttribute = instances[i2].attributes[name];
        if (!defined_default(otherAttribute) || attribute.componentDatatype !== otherAttribute.componentDatatype || attribute.componentsPerAttribute !== otherAttribute.componentsPerAttribute || attribute.normalize !== otherAttribute.normalize) {
          inAllInstances = false;
          break;
        }
      }
      if (inAllInstances) {
        attributesInAllInstances.push(name);
      }
    }
  }
  return attributesInAllInstances;
}
var scratchGetAttributeCartesian2 = new Cartesian2_default();
var scratchGetAttributeCartesian3 = new Cartesian3_default();
var scratchGetAttributeCartesian42 = new Cartesian4_default();
function getAttributeValue(value) {
  const componentsPerAttribute = value.length;
  if (componentsPerAttribute === 1) {
    return value[0];
  } else if (componentsPerAttribute === 2) {
    return Cartesian2_default.unpack(value, 0, scratchGetAttributeCartesian2);
  } else if (componentsPerAttribute === 3) {
    return Cartesian3_default.unpack(value, 0, scratchGetAttributeCartesian3);
  } else if (componentsPerAttribute === 4) {
    return Cartesian4_default.unpack(value, 0, scratchGetAttributeCartesian42);
  }
}
function createBatchTable(primitive, context) {
  const geometryInstances = primitive.geometryInstances;
  const instances = Array.isArray(geometryInstances) ? geometryInstances : [geometryInstances];
  const numberOfInstances = instances.length;
  if (numberOfInstances === 0) {
    return;
  }
  const names = getCommonPerInstanceAttributeNames(instances);
  const length3 = names.length;
  const attributes = [];
  const attributeIndices = {};
  const boundingSphereAttributeIndices = {};
  let offset2DIndex;
  const firstInstance = instances[0];
  let instanceAttributes = firstInstance.attributes;
  let i2;
  let name;
  let attribute;
  for (i2 = 0; i2 < length3; ++i2) {
    name = names[i2];
    attribute = instanceAttributes[name];
    attributeIndices[name] = i2;
    attributes.push({
      functionName: `czm_batchTable_${name}`,
      componentDatatype: attribute.componentDatatype,
      componentsPerAttribute: attribute.componentsPerAttribute,
      normalize: attribute.normalize
    });
  }
  if (names.indexOf("distanceDisplayCondition") !== -1) {
    attributes.push(
      {
        functionName: "czm_batchTable_boundingSphereCenter3DHigh",
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3
      },
      {
        functionName: "czm_batchTable_boundingSphereCenter3DLow",
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3
      },
      {
        functionName: "czm_batchTable_boundingSphereCenter2DHigh",
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3
      },
      {
        functionName: "czm_batchTable_boundingSphereCenter2DLow",
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3
      },
      {
        functionName: "czm_batchTable_boundingSphereRadius",
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 1
      }
    );
    boundingSphereAttributeIndices.center3DHigh = attributes.length - 5;
    boundingSphereAttributeIndices.center3DLow = attributes.length - 4;
    boundingSphereAttributeIndices.center2DHigh = attributes.length - 3;
    boundingSphereAttributeIndices.center2DLow = attributes.length - 2;
    boundingSphereAttributeIndices.radius = attributes.length - 1;
  }
  if (names.indexOf("offset") !== -1) {
    attributes.push({
      functionName: "czm_batchTable_offset2D",
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3
    });
    offset2DIndex = attributes.length - 1;
  }
  attributes.push({
    functionName: "czm_batchTable_pickColor",
    componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
    componentsPerAttribute: 4,
    normalize: true
  });
  const attributesLength = attributes.length;
  const batchTable = new BatchTable_default(context, attributes, numberOfInstances);
  for (i2 = 0; i2 < numberOfInstances; ++i2) {
    const instance = instances[i2];
    instanceAttributes = instance.attributes;
    for (let j = 0; j < length3; ++j) {
      name = names[j];
      attribute = instanceAttributes[name];
      const value = getAttributeValue(attribute.value);
      const attributeIndex = attributeIndices[name];
      batchTable.setBatchedAttribute(i2, attributeIndex, value);
    }
    const pickObject = {
      primitive: defaultValue_default(instance.pickPrimitive, primitive)
    };
    if (defined_default(instance.id)) {
      pickObject.id = instance.id;
    }
    const pickId = context.createPickId(pickObject);
    primitive._pickIds.push(pickId);
    const pickColor = pickId.color;
    const color = scratchGetAttributeCartesian42;
    color.x = Color_default.floatToByte(pickColor.red);
    color.y = Color_default.floatToByte(pickColor.green);
    color.z = Color_default.floatToByte(pickColor.blue);
    color.w = Color_default.floatToByte(pickColor.alpha);
    batchTable.setBatchedAttribute(i2, attributesLength - 1, color);
  }
  primitive._batchTable = batchTable;
  primitive._batchTableAttributeIndices = attributeIndices;
  primitive._batchTableBoundingSphereAttributeIndices = boundingSphereAttributeIndices;
  primitive._batchTableOffsetAttribute2DIndex = offset2DIndex;
}
function cloneAttribute(attribute) {
  let clonedValues;
  if (Array.isArray(attribute.values)) {
    clonedValues = attribute.values.slice(0);
  } else {
    clonedValues = new attribute.values.constructor(attribute.values);
  }
  return new GeometryAttribute_default({
    componentDatatype: attribute.componentDatatype,
    componentsPerAttribute: attribute.componentsPerAttribute,
    normalize: attribute.normalize,
    values: clonedValues
  });
}
function cloneGeometry(geometry) {
  const attributes = geometry.attributes;
  const newAttributes = new GeometryAttributes_default();
  for (const property in attributes) {
    if (attributes.hasOwnProperty(property) && defined_default(attributes[property])) {
      newAttributes[property] = cloneAttribute(attributes[property]);
    }
  }
  let indices2;
  if (defined_default(geometry.indices)) {
    const sourceValues = geometry.indices;
    if (Array.isArray(sourceValues)) {
      indices2 = sourceValues.slice(0);
    } else {
      indices2 = new sourceValues.constructor(sourceValues);
    }
  }
  return new Geometry_default({
    attributes: newAttributes,
    indices: indices2,
    primitiveType: geometry.primitiveType,
    boundingSphere: BoundingSphere_default.clone(geometry.boundingSphere)
  });
}
function cloneInstance(instance, geometry) {
  return {
    geometry,
    attributes: instance.attributes,
    modelMatrix: Matrix4_default.clone(instance.modelMatrix),
    pickPrimitive: instance.pickPrimitive,
    id: instance.id
  };
}
var positionRegex = /attribute\s+vec(?:3|4)\s+(.*)3DHigh;/g;
Primitive._modifyShaderPosition = function(primitive, vertexShaderSource, scene3DOnly) {
  let match;
  let forwardDecl = "";
  let attributes = "";
  let computeFunctions = "";
  while ((match = positionRegex.exec(vertexShaderSource)) !== null) {
    const name = match[1];
    const functionName = `vec4 czm_compute${name[0].toUpperCase()}${name.substr(
      1
    )}()`;
    if (functionName !== "vec4 czm_computePosition()") {
      forwardDecl += `${functionName};
`;
    }
    if (!defined_default(primitive.rtcCenter)) {
      if (!scene3DOnly) {
        attributes += `attribute vec3 ${name}2DHigh;
attribute vec3 ${name}2DLow;
`;
        computeFunctions += `${functionName}
{
    vec4 p;
    if (czm_morphTime == 1.0)
    {
        p = czm_translateRelativeToEye(${name}3DHigh, ${name}3DLow);
    }
    else if (czm_morphTime == 0.0)
    {
        p = czm_translateRelativeToEye(${name}2DHigh.zxy, ${name}2DLow.zxy);
    }
    else
    {
        p = czm_columbusViewMorph(
                czm_translateRelativeToEye(${name}2DHigh.zxy, ${name}2DLow.zxy),
                czm_translateRelativeToEye(${name}3DHigh, ${name}3DLow),
                czm_morphTime);
    }
    return p;
}

`;
      } else {
        computeFunctions += `${functionName}
{
    return czm_translateRelativeToEye(${name}3DHigh, ${name}3DLow);
}

`;
      }
    } else {
      vertexShaderSource = vertexShaderSource.replace(
        /attribute\s+vec(?:3|4)\s+position3DHigh;/g,
        ""
      );
      vertexShaderSource = vertexShaderSource.replace(
        /attribute\s+vec(?:3|4)\s+position3DLow;/g,
        ""
      );
      forwardDecl += "uniform mat4 u_modifiedModelView;\n";
      attributes += "attribute vec4 position;\n";
      computeFunctions += `${functionName}
{
    return u_modifiedModelView * position;
}

`;
      vertexShaderSource = vertexShaderSource.replace(
        /czm_modelViewRelativeToEye\s+\*\s+/g,
        ""
      );
      vertexShaderSource = vertexShaderSource.replace(
        /czm_modelViewProjectionRelativeToEye/g,
        "czm_projection"
      );
    }
  }
  return [forwardDecl, attributes, vertexShaderSource, computeFunctions].join(
    "\n"
  );
};
Primitive._appendShowToShader = function(primitive, vertexShaderSource) {
  if (!defined_default(primitive._batchTableAttributeIndices.show)) {
    return vertexShaderSource;
  }
  const renamedVS = ShaderSource_default.replaceMain(
    vertexShaderSource,
    "czm_non_show_main"
  );
  const showMain = "void main() \n{ \n    czm_non_show_main(); \n    gl_Position *= czm_batchTable_show(batchId); \n}";
  return `${renamedVS}
${showMain}`;
};
Primitive._updateColorAttribute = function(primitive, vertexShaderSource, isDepthFail) {
  if (!defined_default(primitive._batchTableAttributeIndices.color) && !defined_default(primitive._batchTableAttributeIndices.depthFailColor)) {
    return vertexShaderSource;
  }
  if (vertexShaderSource.search(/attribute\s+vec4\s+color;/g) === -1) {
    return vertexShaderSource;
  }
  if (isDepthFail && !defined_default(primitive._batchTableAttributeIndices.depthFailColor)) {
    throw new DeveloperError_default(
      "A depthFailColor per-instance attribute is required when using a depth fail appearance that uses a color attribute."
    );
  }
  let modifiedVS = vertexShaderSource;
  modifiedVS = modifiedVS.replace(/attribute\s+vec4\s+color;/g, "");
  if (!isDepthFail) {
    modifiedVS = modifiedVS.replace(
      /(\b)color(\b)/g,
      "$1czm_batchTable_color(batchId)$2"
    );
  } else {
    modifiedVS = modifiedVS.replace(
      /(\b)color(\b)/g,
      "$1czm_batchTable_depthFailColor(batchId)$2"
    );
  }
  return modifiedVS;
};
function appendPickToVertexShader(source) {
  const renamedVS = ShaderSource_default.replaceMain(source, "czm_non_pick_main");
  const pickMain = "varying vec4 v_pickColor; \nvoid main() \n{ \n    czm_non_pick_main(); \n    v_pickColor = czm_batchTable_pickColor(batchId); \n}";
  return `${renamedVS}
${pickMain}`;
}
function appendPickToFragmentShader(source) {
  return `varying vec4 v_pickColor;
${source}`;
}
Primitive._updatePickColorAttribute = function(source) {
  let vsPick = source.replace(/attribute\s+vec4\s+pickColor;/g, "");
  vsPick = vsPick.replace(
    /(\b)pickColor(\b)/g,
    "$1czm_batchTable_pickColor(batchId)$2"
  );
  return vsPick;
};
Primitive._appendOffsetToShader = function(primitive, vertexShaderSource) {
  if (!defined_default(primitive._batchTableAttributeIndices.offset)) {
    return vertexShaderSource;
  }
  let attr = "attribute float batchId;\n";
  attr += "attribute float applyOffset;";
  let modifiedShader = vertexShaderSource.replace(
    /attribute\s+float\s+batchId;/g,
    attr
  );
  let str = "vec4 $1 = czm_computePosition();\n";
  str += "    if (czm_sceneMode == czm_sceneMode3D)\n";
  str += "    {\n";
  str += "        $1 = $1 + vec4(czm_batchTable_offset(batchId) * applyOffset, 0.0);";
  str += "    }\n";
  str += "    else\n";
  str += "    {\n";
  str += "        $1 = $1 + vec4(czm_batchTable_offset2D(batchId) * applyOffset, 0.0);";
  str += "    }\n";
  modifiedShader = modifiedShader.replace(
    /vec4\s+([A-Za-z0-9_]+)\s+=\s+czm_computePosition\(\);/g,
    str
  );
  return modifiedShader;
};
Primitive._appendDistanceDisplayConditionToShader = function(primitive, vertexShaderSource, scene3DOnly) {
  if (!defined_default(primitive._batchTableAttributeIndices.distanceDisplayCondition)) {
    return vertexShaderSource;
  }
  const renamedVS = ShaderSource_default.replaceMain(
    vertexShaderSource,
    "czm_non_distanceDisplayCondition_main"
  );
  let distanceDisplayConditionMain = "void main() \n{ \n    czm_non_distanceDisplayCondition_main(); \n    vec2 distanceDisplayCondition = czm_batchTable_distanceDisplayCondition(batchId);\n    vec3 boundingSphereCenter3DHigh = czm_batchTable_boundingSphereCenter3DHigh(batchId);\n    vec3 boundingSphereCenter3DLow = czm_batchTable_boundingSphereCenter3DLow(batchId);\n    float boundingSphereRadius = czm_batchTable_boundingSphereRadius(batchId);\n";
  if (!scene3DOnly) {
    distanceDisplayConditionMain += "    vec3 boundingSphereCenter2DHigh = czm_batchTable_boundingSphereCenter2DHigh(batchId);\n    vec3 boundingSphereCenter2DLow = czm_batchTable_boundingSphereCenter2DLow(batchId);\n    vec4 centerRTE;\n    if (czm_morphTime == 1.0)\n    {\n        centerRTE = czm_translateRelativeToEye(boundingSphereCenter3DHigh, boundingSphereCenter3DLow);\n    }\n    else if (czm_morphTime == 0.0)\n    {\n        centerRTE = czm_translateRelativeToEye(boundingSphereCenter2DHigh.zxy, boundingSphereCenter2DLow.zxy);\n    }\n    else\n    {\n        centerRTE = czm_columbusViewMorph(\n                czm_translateRelativeToEye(boundingSphereCenter2DHigh.zxy, boundingSphereCenter2DLow.zxy),\n                czm_translateRelativeToEye(boundingSphereCenter3DHigh, boundingSphereCenter3DLow),\n                czm_morphTime);\n    }\n";
  } else {
    distanceDisplayConditionMain += "    vec4 centerRTE = czm_translateRelativeToEye(boundingSphereCenter3DHigh, boundingSphereCenter3DLow);\n";
  }
  distanceDisplayConditionMain += "    float radiusSq = boundingSphereRadius * boundingSphereRadius; \n    float distanceSq; \n    if (czm_sceneMode == czm_sceneMode2D) \n    { \n        distanceSq = czm_eyeHeight2D.y - radiusSq; \n    } \n    else \n    { \n        distanceSq = dot(centerRTE.xyz, centerRTE.xyz) - radiusSq; \n    } \n    distanceSq = max(distanceSq, 0.0); \n    float nearSq = distanceDisplayCondition.x * distanceDisplayCondition.x; \n    float farSq = distanceDisplayCondition.y * distanceDisplayCondition.y; \n    float show = (distanceSq >= nearSq && distanceSq <= farSq) ? 1.0 : 0.0; \n    gl_Position *= show; \n}";
  return `${renamedVS}
${distanceDisplayConditionMain}`;
};
function modifyForEncodedNormals(primitive, vertexShaderSource) {
  if (!primitive.compressVertices) {
    return vertexShaderSource;
  }
  const containsNormal = vertexShaderSource.search(/attribute\s+vec3\s+normal;/g) !== -1;
  const containsSt = vertexShaderSource.search(/attribute\s+vec2\s+st;/g) !== -1;
  if (!containsNormal && !containsSt) {
    return vertexShaderSource;
  }
  const containsTangent = vertexShaderSource.search(/attribute\s+vec3\s+tangent;/g) !== -1;
  const containsBitangent = vertexShaderSource.search(/attribute\s+vec3\s+bitangent;/g) !== -1;
  let numComponents = containsSt && containsNormal ? 2 : 1;
  numComponents += containsTangent || containsBitangent ? 1 : 0;
  const type = numComponents > 1 ? `vec${numComponents}` : "float";
  const attributeName = "compressedAttributes";
  const attributeDecl = `attribute ${type} ${attributeName};`;
  let globalDecl = "";
  let decode = "";
  if (containsSt) {
    globalDecl += "vec2 st;\n";
    const stComponent = numComponents > 1 ? `${attributeName}.x` : attributeName;
    decode += `    st = czm_decompressTextureCoordinates(${stComponent});
`;
  }
  if (containsNormal && containsTangent && containsBitangent) {
    globalDecl += "vec3 normal;\nvec3 tangent;\nvec3 bitangent;\n";
    decode += `    czm_octDecode(${attributeName}.${containsSt ? "yz" : "xy"}, normal, tangent, bitangent);
`;
  } else {
    if (containsNormal) {
      globalDecl += "vec3 normal;\n";
      decode += `    normal = czm_octDecode(${attributeName}${numComponents > 1 ? `.${containsSt ? "y" : "x"}` : ""});
`;
    }
    if (containsTangent) {
      globalDecl += "vec3 tangent;\n";
      decode += `    tangent = czm_octDecode(${attributeName}.${containsSt && containsNormal ? "z" : "y"});
`;
    }
    if (containsBitangent) {
      globalDecl += "vec3 bitangent;\n";
      decode += `    bitangent = czm_octDecode(${attributeName}.${containsSt && containsNormal ? "z" : "y"});
`;
    }
  }
  let modifiedVS = vertexShaderSource;
  modifiedVS = modifiedVS.replace(/attribute\s+vec3\s+normal;/g, "");
  modifiedVS = modifiedVS.replace(/attribute\s+vec2\s+st;/g, "");
  modifiedVS = modifiedVS.replace(/attribute\s+vec3\s+tangent;/g, "");
  modifiedVS = modifiedVS.replace(/attribute\s+vec3\s+bitangent;/g, "");
  modifiedVS = ShaderSource_default.replaceMain(modifiedVS, "czm_non_compressed_main");
  const compressedMain = `${"void main() \n{ \n"}${decode}    czm_non_compressed_main(); 
}`;
  return [attributeDecl, globalDecl, modifiedVS, compressedMain].join("\n");
}
function depthClampVS(vertexShaderSource) {
  let modifiedVS = ShaderSource_default.replaceMain(
    vertexShaderSource,
    "czm_non_depth_clamp_main"
  );
  modifiedVS += "void main() {\n    czm_non_depth_clamp_main();\n    gl_Position = czm_depthClamp(gl_Position);}\n";
  return modifiedVS;
}
function depthClampFS(fragmentShaderSource) {
  let modifiedFS = ShaderSource_default.replaceMain(
    fragmentShaderSource,
    "czm_non_depth_clamp_main"
  );
  modifiedFS += "void main() {\n    czm_non_depth_clamp_main();\n#if defined(GL_EXT_frag_depth)\n    #if defined(LOG_DEPTH)\n        czm_writeLogDepth();\n    #else\n        czm_writeDepthClamp();\n    #endif\n#endif\n}\n";
  modifiedFS = `${"#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n#endif\n"}${modifiedFS}`;
  return modifiedFS;
}
function validateShaderMatching(shaderProgram, attributeLocations8) {
  const shaderAttributes = shaderProgram.vertexAttributes;
  for (const name in shaderAttributes) {
    if (shaderAttributes.hasOwnProperty(name)) {
      if (!defined_default(attributeLocations8[name])) {
        throw new DeveloperError_default(
          `Appearance/Geometry mismatch.  The appearance requires vertex shader attribute input '${name}', which was not computed as part of the Geometry.  Use the appearance's vertexFormat property when constructing the geometry.`
        );
      }
    }
  }
}
function getUniformFunction(uniforms, name) {
  return function() {
    return uniforms[name];
  };
}
var numberOfCreationWorkers = Math.max(
  FeatureDetection_default.hardwareConcurrency - 1,
  1
);
var createGeometryTaskProcessors;
var combineGeometryTaskProcessor = new TaskProcessor_default("combineGeometry");
function loadAsynchronous(primitive, frameState) {
  let instances;
  let geometry;
  let i2;
  let j;
  const instanceIds = primitive._instanceIds;
  if (primitive._state === PrimitiveState_default.READY) {
    instances = Array.isArray(primitive.geometryInstances) ? primitive.geometryInstances : [primitive.geometryInstances];
    const length3 = primitive._numberOfInstances = instances.length;
    const promises = [];
    let subTasks = [];
    for (i2 = 0; i2 < length3; ++i2) {
      geometry = instances[i2].geometry;
      instanceIds.push(instances[i2].id);
      if (!defined_default(geometry._workerName)) {
        throw new DeveloperError_default(
          "_workerName must be defined for asynchronous geometry."
        );
      }
      subTasks.push({
        moduleName: geometry._workerName,
        geometry
      });
    }
    if (!defined_default(createGeometryTaskProcessors)) {
      createGeometryTaskProcessors = new Array(numberOfCreationWorkers);
      for (i2 = 0; i2 < numberOfCreationWorkers; i2++) {
        createGeometryTaskProcessors[i2] = new TaskProcessor_default("createGeometry");
      }
    }
    let subTask;
    subTasks = subdivideArray_default(subTasks, numberOfCreationWorkers);
    for (i2 = 0; i2 < subTasks.length; i2++) {
      let packedLength = 0;
      const workerSubTasks = subTasks[i2];
      const workerSubTasksLength = workerSubTasks.length;
      for (j = 0; j < workerSubTasksLength; ++j) {
        subTask = workerSubTasks[j];
        geometry = subTask.geometry;
        if (defined_default(geometry.constructor.pack)) {
          subTask.offset = packedLength;
          packedLength += defaultValue_default(
            geometry.constructor.packedLength,
            geometry.packedLength
          );
        }
      }
      let subTaskTransferableObjects;
      if (packedLength > 0) {
        const array = new Float64Array(packedLength);
        subTaskTransferableObjects = [array.buffer];
        for (j = 0; j < workerSubTasksLength; ++j) {
          subTask = workerSubTasks[j];
          geometry = subTask.geometry;
          if (defined_default(geometry.constructor.pack)) {
            geometry.constructor.pack(geometry, array, subTask.offset);
            subTask.geometry = array;
          }
        }
      }
      promises.push(
        createGeometryTaskProcessors[i2].scheduleTask(
          {
            subTasks: subTasks[i2]
          },
          subTaskTransferableObjects
        )
      );
    }
    primitive._state = PrimitiveState_default.CREATING;
    Promise.all(promises).then(function(results) {
      primitive._createGeometryResults = results;
      primitive._state = PrimitiveState_default.CREATED;
    }).catch(function(error) {
      setReady(primitive, frameState, PrimitiveState_default.FAILED, error);
    });
  } else if (primitive._state === PrimitiveState_default.CREATED) {
    const transferableObjects = [];
    instances = Array.isArray(primitive.geometryInstances) ? primitive.geometryInstances : [primitive.geometryInstances];
    const scene3DOnly = frameState.scene3DOnly;
    const projection = frameState.mapProjection;
    const promise = combineGeometryTaskProcessor.scheduleTask(
      PrimitivePipeline_default.packCombineGeometryParameters(
        {
          createGeometryResults: primitive._createGeometryResults,
          instances,
          ellipsoid: projection.ellipsoid,
          projection,
          elementIndexUintSupported: frameState.context.elementIndexUint,
          scene3DOnly,
          vertexCacheOptimize: primitive.vertexCacheOptimize,
          compressVertices: primitive.compressVertices,
          modelMatrix: primitive.modelMatrix,
          createPickOffsets: primitive._createPickOffsets
        },
        transferableObjects
      ),
      transferableObjects
    );
    primitive._createGeometryResults = void 0;
    primitive._state = PrimitiveState_default.COMBINING;
    Promise.resolve(promise).then(function(packedResult) {
      const result = PrimitivePipeline_default.unpackCombineGeometryResults(
        packedResult
      );
      primitive._geometries = result.geometries;
      primitive._attributeLocations = result.attributeLocations;
      primitive.modelMatrix = Matrix4_default.clone(
        result.modelMatrix,
        primitive.modelMatrix
      );
      primitive._pickOffsets = result.pickOffsets;
      primitive._offsetInstanceExtend = result.offsetInstanceExtend;
      primitive._instanceBoundingSpheres = result.boundingSpheres;
      primitive._instanceBoundingSpheresCV = result.boundingSpheresCV;
      if (defined_default(primitive._geometries) && primitive._geometries.length > 0) {
        primitive._recomputeBoundingSpheres = true;
        primitive._state = PrimitiveState_default.COMBINED;
      } else {
        setReady(primitive, frameState, PrimitiveState_default.FAILED, void 0);
      }
    }).catch(function(error) {
      setReady(primitive, frameState, PrimitiveState_default.FAILED, error);
    });
  }
}
function loadSynchronous(primitive, frameState) {
  const instances = Array.isArray(primitive.geometryInstances) ? primitive.geometryInstances : [primitive.geometryInstances];
  const length3 = primitive._numberOfInstances = instances.length;
  const clonedInstances = new Array(length3);
  const instanceIds = primitive._instanceIds;
  let instance;
  let i2;
  let geometryIndex = 0;
  for (i2 = 0; i2 < length3; i2++) {
    instance = instances[i2];
    const geometry = instance.geometry;
    let createdGeometry;
    if (defined_default(geometry.attributes) && defined_default(geometry.primitiveType)) {
      createdGeometry = cloneGeometry(geometry);
    } else {
      createdGeometry = geometry.constructor.createGeometry(geometry);
    }
    clonedInstances[geometryIndex++] = cloneInstance(instance, createdGeometry);
    instanceIds.push(instance.id);
  }
  clonedInstances.length = geometryIndex;
  const scene3DOnly = frameState.scene3DOnly;
  const projection = frameState.mapProjection;
  const result = PrimitivePipeline_default.combineGeometry({
    instances: clonedInstances,
    ellipsoid: projection.ellipsoid,
    projection,
    elementIndexUintSupported: frameState.context.elementIndexUint,
    scene3DOnly,
    vertexCacheOptimize: primitive.vertexCacheOptimize,
    compressVertices: primitive.compressVertices,
    modelMatrix: primitive.modelMatrix,
    createPickOffsets: primitive._createPickOffsets
  });
  primitive._geometries = result.geometries;
  primitive._attributeLocations = result.attributeLocations;
  primitive.modelMatrix = Matrix4_default.clone(
    result.modelMatrix,
    primitive.modelMatrix
  );
  primitive._pickOffsets = result.pickOffsets;
  primitive._offsetInstanceExtend = result.offsetInstanceExtend;
  primitive._instanceBoundingSpheres = result.boundingSpheres;
  primitive._instanceBoundingSpheresCV = result.boundingSpheresCV;
  if (defined_default(primitive._geometries) && primitive._geometries.length > 0) {
    primitive._recomputeBoundingSpheres = true;
    primitive._state = PrimitiveState_default.COMBINED;
  } else {
    setReady(primitive, frameState, PrimitiveState_default.FAILED, void 0);
  }
}
function recomputeBoundingSpheres(primitive, frameState) {
  const offsetIndex = primitive._batchTableAttributeIndices.offset;
  if (!primitive._recomputeBoundingSpheres || !defined_default(offsetIndex)) {
    primitive._recomputeBoundingSpheres = false;
    return;
  }
  let i2;
  const offsetInstanceExtend = primitive._offsetInstanceExtend;
  const boundingSpheres = primitive._instanceBoundingSpheres;
  const length3 = boundingSpheres.length;
  let newBoundingSpheres = primitive._tempBoundingSpheres;
  if (!defined_default(newBoundingSpheres)) {
    newBoundingSpheres = new Array(length3);
    for (i2 = 0; i2 < length3; i2++) {
      newBoundingSpheres[i2] = new BoundingSphere_default();
    }
    primitive._tempBoundingSpheres = newBoundingSpheres;
  }
  for (i2 = 0; i2 < length3; ++i2) {
    let newBS = newBoundingSpheres[i2];
    const offset2 = primitive._batchTable.getBatchedAttribute(
      i2,
      offsetIndex,
      new Cartesian3_default()
    );
    newBS = boundingSpheres[i2].clone(newBS);
    transformBoundingSphere(newBS, offset2, offsetInstanceExtend[i2]);
  }
  const combinedBS = [];
  const combinedWestBS = [];
  const combinedEastBS = [];
  for (i2 = 0; i2 < length3; ++i2) {
    const bs = newBoundingSpheres[i2];
    const minX = bs.center.x - bs.radius;
    if (minX > 0 || BoundingSphere_default.intersectPlane(bs, Plane_default.ORIGIN_ZX_PLANE) !== Intersect_default.INTERSECTING) {
      combinedBS.push(bs);
    } else {
      combinedWestBS.push(bs);
      combinedEastBS.push(bs);
    }
  }
  let resultBS1 = combinedBS[0];
  let resultBS2 = combinedEastBS[0];
  let resultBS3 = combinedWestBS[0];
  for (i2 = 1; i2 < combinedBS.length; i2++) {
    resultBS1 = BoundingSphere_default.union(resultBS1, combinedBS[i2]);
  }
  for (i2 = 1; i2 < combinedEastBS.length; i2++) {
    resultBS2 = BoundingSphere_default.union(resultBS2, combinedEastBS[i2]);
  }
  for (i2 = 1; i2 < combinedWestBS.length; i2++) {
    resultBS3 = BoundingSphere_default.union(resultBS3, combinedWestBS[i2]);
  }
  const result = [];
  if (defined_default(resultBS1)) {
    result.push(resultBS1);
  }
  if (defined_default(resultBS2)) {
    result.push(resultBS2);
  }
  if (defined_default(resultBS3)) {
    result.push(resultBS3);
  }
  for (i2 = 0; i2 < result.length; i2++) {
    const boundingSphere = result[i2].clone(primitive._boundingSpheres[i2]);
    primitive._boundingSpheres[i2] = boundingSphere;
    primitive._boundingSphereCV[i2] = BoundingSphere_default.projectTo2D(
      boundingSphere,
      frameState.mapProjection,
      primitive._boundingSphereCV[i2]
    );
  }
  Primitive._updateBoundingVolumes(
    primitive,
    frameState,
    primitive.modelMatrix,
    true
  );
  primitive._recomputeBoundingSpheres = false;
}
var scratchBoundingSphereCenterEncoded = new EncodedCartesian3_default();
var scratchBoundingSphereCartographic = new Cartographic_default();
var scratchBoundingSphereCenter2D = new Cartesian3_default();
var scratchBoundingSphere3 = new BoundingSphere_default();
function updateBatchTableBoundingSpheres(primitive, frameState) {
  const hasDistanceDisplayCondition = defined_default(
    primitive._batchTableAttributeIndices.distanceDisplayCondition
  );
  if (!hasDistanceDisplayCondition || primitive._batchTableBoundingSpheresUpdated) {
    return;
  }
  const indices2 = primitive._batchTableBoundingSphereAttributeIndices;
  const center3DHighIndex = indices2.center3DHigh;
  const center3DLowIndex = indices2.center3DLow;
  const center2DHighIndex = indices2.center2DHigh;
  const center2DLowIndex = indices2.center2DLow;
  const radiusIndex = indices2.radius;
  const projection = frameState.mapProjection;
  const ellipsoid = projection.ellipsoid;
  const batchTable = primitive._batchTable;
  const boundingSpheres = primitive._instanceBoundingSpheres;
  const length3 = boundingSpheres.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    let boundingSphere = boundingSpheres[i2];
    if (!defined_default(boundingSphere)) {
      continue;
    }
    const modelMatrix = primitive.modelMatrix;
    if (defined_default(modelMatrix)) {
      boundingSphere = BoundingSphere_default.transform(
        boundingSphere,
        modelMatrix,
        scratchBoundingSphere3
      );
    }
    const center = boundingSphere.center;
    const radius = boundingSphere.radius;
    let encodedCenter = EncodedCartesian3_default.fromCartesian(
      center,
      scratchBoundingSphereCenterEncoded
    );
    batchTable.setBatchedAttribute(i2, center3DHighIndex, encodedCenter.high);
    batchTable.setBatchedAttribute(i2, center3DLowIndex, encodedCenter.low);
    if (!frameState.scene3DOnly) {
      const cartographic2 = ellipsoid.cartesianToCartographic(
        center,
        scratchBoundingSphereCartographic
      );
      const center2D = projection.project(
        cartographic2,
        scratchBoundingSphereCenter2D
      );
      encodedCenter = EncodedCartesian3_default.fromCartesian(
        center2D,
        scratchBoundingSphereCenterEncoded
      );
      batchTable.setBatchedAttribute(i2, center2DHighIndex, encodedCenter.high);
      batchTable.setBatchedAttribute(i2, center2DLowIndex, encodedCenter.low);
    }
    batchTable.setBatchedAttribute(i2, radiusIndex, radius);
  }
  primitive._batchTableBoundingSpheresUpdated = true;
}
var offsetScratchCartesian = new Cartesian3_default();
var offsetCenterScratch = new Cartesian3_default();
function updateBatchTableOffsets(primitive, frameState) {
  const hasOffset = defined_default(primitive._batchTableAttributeIndices.offset);
  if (!hasOffset || primitive._batchTableOffsetsUpdated || frameState.scene3DOnly) {
    return;
  }
  const index2D = primitive._batchTableOffsetAttribute2DIndex;
  const projection = frameState.mapProjection;
  const ellipsoid = projection.ellipsoid;
  const batchTable = primitive._batchTable;
  const boundingSpheres = primitive._instanceBoundingSpheres;
  const length3 = boundingSpheres.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    let boundingSphere = boundingSpheres[i2];
    if (!defined_default(boundingSphere)) {
      continue;
    }
    const offset2 = batchTable.getBatchedAttribute(
      i2,
      primitive._batchTableAttributeIndices.offset
    );
    if (Cartesian3_default.equals(offset2, Cartesian3_default.ZERO)) {
      batchTable.setBatchedAttribute(i2, index2D, Cartesian3_default.ZERO);
      continue;
    }
    const modelMatrix = primitive.modelMatrix;
    if (defined_default(modelMatrix)) {
      boundingSphere = BoundingSphere_default.transform(
        boundingSphere,
        modelMatrix,
        scratchBoundingSphere3
      );
    }
    let center = boundingSphere.center;
    center = ellipsoid.scaleToGeodeticSurface(center, offsetCenterScratch);
    let cartographic2 = ellipsoid.cartesianToCartographic(
      center,
      scratchBoundingSphereCartographic
    );
    const center2D = projection.project(
      cartographic2,
      scratchBoundingSphereCenter2D
    );
    const newPoint = Cartesian3_default.add(offset2, center, offsetScratchCartesian);
    cartographic2 = ellipsoid.cartesianToCartographic(newPoint, cartographic2);
    const newPointProjected = projection.project(
      cartographic2,
      offsetScratchCartesian
    );
    const newVector = Cartesian3_default.subtract(
      newPointProjected,
      center2D,
      offsetScratchCartesian
    );
    const x = newVector.x;
    newVector.x = newVector.z;
    newVector.z = newVector.y;
    newVector.y = x;
    batchTable.setBatchedAttribute(i2, index2D, newVector);
  }
  primitive._batchTableOffsetsUpdated = true;
}
function createVertexArray(primitive, frameState) {
  const attributeLocations8 = primitive._attributeLocations;
  const geometries = primitive._geometries;
  const scene3DOnly = frameState.scene3DOnly;
  const context = frameState.context;
  const va = [];
  const length3 = geometries.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const geometry = geometries[i2];
    va.push(
      VertexArray_default.fromGeometry({
        context,
        geometry,
        attributeLocations: attributeLocations8,
        bufferUsage: BufferUsage_default.STATIC_DRAW,
        interleave: primitive._interleave
      })
    );
    if (defined_default(primitive._createBoundingVolumeFunction)) {
      primitive._createBoundingVolumeFunction(frameState, geometry);
    } else {
      primitive._boundingSpheres.push(
        BoundingSphere_default.clone(geometry.boundingSphere)
      );
      primitive._boundingSphereWC.push(new BoundingSphere_default());
      if (!scene3DOnly) {
        const center = geometry.boundingSphereCV.center;
        const x = center.x;
        const y = center.y;
        const z = center.z;
        center.x = z;
        center.y = x;
        center.z = y;
        primitive._boundingSphereCV.push(
          BoundingSphere_default.clone(geometry.boundingSphereCV)
        );
        primitive._boundingSphere2D.push(new BoundingSphere_default());
        primitive._boundingSphereMorph.push(new BoundingSphere_default());
      }
    }
  }
  primitive._va = va;
  primitive._primitiveType = geometries[0].primitiveType;
  if (primitive.releaseGeometryInstances) {
    primitive.geometryInstances = void 0;
  }
  primitive._geometries = void 0;
  setReady(primitive, frameState, PrimitiveState_default.COMPLETE, void 0);
}
function createRenderStates(primitive, context, appearance, twoPasses) {
  let renderState = appearance.getRenderState();
  let rs;
  if (twoPasses) {
    rs = clone_default(renderState, false);
    rs.cull = {
      enabled: true,
      face: CullFace_default.BACK
    };
    primitive._frontFaceRS = RenderState_default.fromCache(rs);
    rs.cull.face = CullFace_default.FRONT;
    primitive._backFaceRS = RenderState_default.fromCache(rs);
  } else {
    primitive._frontFaceRS = RenderState_default.fromCache(renderState);
    primitive._backFaceRS = primitive._frontFaceRS;
  }
  rs = clone_default(renderState, false);
  if (defined_default(primitive._depthFailAppearance)) {
    rs.depthTest.enabled = false;
  }
  if (defined_default(primitive._depthFailAppearance)) {
    renderState = primitive._depthFailAppearance.getRenderState();
    rs = clone_default(renderState, false);
    rs.depthTest.func = DepthFunction_default.GREATER;
    if (twoPasses) {
      rs.cull = {
        enabled: true,
        face: CullFace_default.BACK
      };
      primitive._frontFaceDepthFailRS = RenderState_default.fromCache(rs);
      rs.cull.face = CullFace_default.FRONT;
      primitive._backFaceDepthFailRS = RenderState_default.fromCache(rs);
    } else {
      primitive._frontFaceDepthFailRS = RenderState_default.fromCache(rs);
      primitive._backFaceDepthFailRS = primitive._frontFaceRS;
    }
  }
}
function createShaderProgram(primitive, frameState, appearance) {
  const context = frameState.context;
  const attributeLocations8 = primitive._attributeLocations;
  let vs = primitive._batchTable.getVertexShaderCallback()(
    appearance.vertexShaderSource
  );
  vs = Primitive._appendOffsetToShader(primitive, vs);
  vs = Primitive._appendShowToShader(primitive, vs);
  vs = Primitive._appendDistanceDisplayConditionToShader(
    primitive,
    vs,
    frameState.scene3DOnly
  );
  vs = appendPickToVertexShader(vs);
  vs = Primitive._updateColorAttribute(primitive, vs, false);
  vs = modifyForEncodedNormals(primitive, vs);
  vs = Primitive._modifyShaderPosition(primitive, vs, frameState.scene3DOnly);
  let fs = appearance.getFragmentShaderSource();
  fs = appendPickToFragmentShader(fs);
  primitive._sp = ShaderProgram_default.replaceCache({
    context,
    shaderProgram: primitive._sp,
    vertexShaderSource: vs,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations8
  });
  validateShaderMatching(primitive._sp, attributeLocations8);
  if (defined_default(primitive._depthFailAppearance)) {
    vs = primitive._batchTable.getVertexShaderCallback()(
      primitive._depthFailAppearance.vertexShaderSource
    );
    vs = Primitive._appendShowToShader(primitive, vs);
    vs = Primitive._appendDistanceDisplayConditionToShader(
      primitive,
      vs,
      frameState.scene3DOnly
    );
    vs = appendPickToVertexShader(vs);
    vs = Primitive._updateColorAttribute(primitive, vs, true);
    vs = modifyForEncodedNormals(primitive, vs);
    vs = Primitive._modifyShaderPosition(primitive, vs, frameState.scene3DOnly);
    vs = depthClampVS(vs);
    fs = primitive._depthFailAppearance.getFragmentShaderSource();
    fs = appendPickToFragmentShader(fs);
    fs = depthClampFS(fs);
    primitive._spDepthFail = ShaderProgram_default.replaceCache({
      context,
      shaderProgram: primitive._spDepthFail,
      vertexShaderSource: vs,
      fragmentShaderSource: fs,
      attributeLocations: attributeLocations8
    });
    validateShaderMatching(primitive._spDepthFail, attributeLocations8);
  }
}
var modifiedModelViewScratch = new Matrix4_default();
var rtcScratch = new Cartesian3_default();
function getUniforms(primitive, appearance, material, frameState) {
  const materialUniformMap = defined_default(material) ? material._uniforms : void 0;
  const appearanceUniformMap = {};
  const appearanceUniforms = appearance.uniforms;
  if (defined_default(appearanceUniforms)) {
    for (const name in appearanceUniforms) {
      if (appearanceUniforms.hasOwnProperty(name)) {
        if (defined_default(materialUniformMap) && defined_default(materialUniformMap[name])) {
          throw new DeveloperError_default(
            `Appearance and material have a uniform with the same name: ${name}`
          );
        }
        appearanceUniformMap[name] = getUniformFunction(
          appearanceUniforms,
          name
        );
      }
    }
  }
  let uniforms = combine_default(appearanceUniformMap, materialUniformMap);
  uniforms = primitive._batchTable.getUniformMapCallback()(uniforms);
  if (defined_default(primitive.rtcCenter)) {
    uniforms.u_modifiedModelView = function() {
      const viewMatrix = frameState.context.uniformState.view;
      Matrix4_default.multiply(
        viewMatrix,
        primitive._modelMatrix,
        modifiedModelViewScratch
      );
      Matrix4_default.multiplyByPoint(
        modifiedModelViewScratch,
        primitive.rtcCenter,
        rtcScratch
      );
      Matrix4_default.setTranslation(
        modifiedModelViewScratch,
        rtcScratch,
        modifiedModelViewScratch
      );
      return modifiedModelViewScratch;
    };
  }
  return uniforms;
}
function createCommands(primitive, appearance, material, translucent, twoPasses, colorCommands, pickCommands, frameState) {
  const uniforms = getUniforms(primitive, appearance, material, frameState);
  let depthFailUniforms;
  if (defined_default(primitive._depthFailAppearance)) {
    depthFailUniforms = getUniforms(
      primitive,
      primitive._depthFailAppearance,
      primitive._depthFailAppearance.material,
      frameState
    );
  }
  const pass = translucent ? Pass_default.TRANSLUCENT : Pass_default.OPAQUE;
  let multiplier = twoPasses ? 2 : 1;
  multiplier *= defined_default(primitive._depthFailAppearance) ? 2 : 1;
  colorCommands.length = primitive._va.length * multiplier;
  const length3 = colorCommands.length;
  let vaIndex = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    let colorCommand;
    if (twoPasses) {
      colorCommand = colorCommands[i2];
      if (!defined_default(colorCommand)) {
        colorCommand = colorCommands[i2] = new DrawCommand_default({
          owner: primitive,
          primitiveType: primitive._primitiveType
        });
      }
      colorCommand.vertexArray = primitive._va[vaIndex];
      colorCommand.renderState = primitive._backFaceRS;
      colorCommand.shaderProgram = primitive._sp;
      colorCommand.uniformMap = uniforms;
      colorCommand.pass = pass;
      ++i2;
    }
    colorCommand = colorCommands[i2];
    if (!defined_default(colorCommand)) {
      colorCommand = colorCommands[i2] = new DrawCommand_default({
        owner: primitive,
        primitiveType: primitive._primitiveType
      });
    }
    colorCommand.vertexArray = primitive._va[vaIndex];
    colorCommand.renderState = primitive._frontFaceRS;
    colorCommand.shaderProgram = primitive._sp;
    colorCommand.uniformMap = uniforms;
    colorCommand.pass = pass;
    if (defined_default(primitive._depthFailAppearance)) {
      if (twoPasses) {
        ++i2;
        colorCommand = colorCommands[i2];
        if (!defined_default(colorCommand)) {
          colorCommand = colorCommands[i2] = new DrawCommand_default({
            owner: primitive,
            primitiveType: primitive._primitiveType
          });
        }
        colorCommand.vertexArray = primitive._va[vaIndex];
        colorCommand.renderState = primitive._backFaceDepthFailRS;
        colorCommand.shaderProgram = primitive._spDepthFail;
        colorCommand.uniformMap = depthFailUniforms;
        colorCommand.pass = pass;
      }
      ++i2;
      colorCommand = colorCommands[i2];
      if (!defined_default(colorCommand)) {
        colorCommand = colorCommands[i2] = new DrawCommand_default({
          owner: primitive,
          primitiveType: primitive._primitiveType
        });
      }
      colorCommand.vertexArray = primitive._va[vaIndex];
      colorCommand.renderState = primitive._frontFaceDepthFailRS;
      colorCommand.shaderProgram = primitive._spDepthFail;
      colorCommand.uniformMap = depthFailUniforms;
      colorCommand.pass = pass;
    }
    ++vaIndex;
  }
}
Primitive._updateBoundingVolumes = function(primitive, frameState, modelMatrix, forceUpdate) {
  let i2;
  let length3;
  let boundingSphere;
  if (forceUpdate || !Matrix4_default.equals(modelMatrix, primitive._modelMatrix)) {
    Matrix4_default.clone(modelMatrix, primitive._modelMatrix);
    length3 = primitive._boundingSpheres.length;
    for (i2 = 0; i2 < length3; ++i2) {
      boundingSphere = primitive._boundingSpheres[i2];
      if (defined_default(boundingSphere)) {
        primitive._boundingSphereWC[i2] = BoundingSphere_default.transform(
          boundingSphere,
          modelMatrix,
          primitive._boundingSphereWC[i2]
        );
        if (!frameState.scene3DOnly) {
          primitive._boundingSphere2D[i2] = BoundingSphere_default.clone(
            primitive._boundingSphereCV[i2],
            primitive._boundingSphere2D[i2]
          );
          primitive._boundingSphere2D[i2].center.x = 0;
          primitive._boundingSphereMorph[i2] = BoundingSphere_default.union(
            primitive._boundingSphereWC[i2],
            primitive._boundingSphereCV[i2]
          );
        }
      }
    }
  }
  const pixelSize = primitive.appearance.pixelSize;
  if (defined_default(pixelSize)) {
    length3 = primitive._boundingSpheres.length;
    for (i2 = 0; i2 < length3; ++i2) {
      boundingSphere = primitive._boundingSpheres[i2];
      const boundingSphereWC = primitive._boundingSphereWC[i2];
      const pixelSizeInMeters = frameState.camera.getPixelSize(
        boundingSphere,
        frameState.context.drawingBufferWidth,
        frameState.context.drawingBufferHeight
      );
      const sizeInMeters = pixelSizeInMeters * pixelSize;
      boundingSphereWC.radius = boundingSphere.radius + sizeInMeters;
    }
  }
};
function updateAndQueueCommands(primitive, frameState, colorCommands, pickCommands, modelMatrix, cull, debugShowBoundingVolume2, twoPasses) {
  if (frameState.mode !== SceneMode_default.SCENE3D && !Matrix4_default.equals(modelMatrix, Matrix4_default.IDENTITY)) {
    throw new DeveloperError_default(
      "Primitive.modelMatrix is only supported in 3D mode."
    );
  }
  Primitive._updateBoundingVolumes(primitive, frameState, modelMatrix);
  let boundingSpheres;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    boundingSpheres = primitive._boundingSphereWC;
  } else if (frameState.mode === SceneMode_default.COLUMBUS_VIEW) {
    boundingSpheres = primitive._boundingSphereCV;
  } else if (frameState.mode === SceneMode_default.SCENE2D && defined_default(primitive._boundingSphere2D)) {
    boundingSpheres = primitive._boundingSphere2D;
  } else if (defined_default(primitive._boundingSphereMorph)) {
    boundingSpheres = primitive._boundingSphereMorph;
  }
  const commandList = frameState.commandList;
  const passes = frameState.passes;
  if (passes.render || passes.pick) {
    const allowPicking = primitive.allowPicking;
    const castShadows = ShadowMode_default.castShadows(primitive.shadows);
    const receiveShadows = ShadowMode_default.receiveShadows(primitive.shadows);
    const colorLength = colorCommands.length;
    let factor2 = twoPasses ? 2 : 1;
    factor2 *= defined_default(primitive._depthFailAppearance) ? 2 : 1;
    for (let j = 0; j < colorLength; ++j) {
      const sphereIndex = Math.floor(j / factor2);
      const colorCommand = colorCommands[j];
      colorCommand.modelMatrix = modelMatrix;
      colorCommand.boundingVolume = boundingSpheres[sphereIndex];
      colorCommand.cull = cull;
      colorCommand.debugShowBoundingVolume = debugShowBoundingVolume2;
      colorCommand.castShadows = castShadows;
      colorCommand.receiveShadows = receiveShadows;
      if (allowPicking) {
        colorCommand.pickId = "v_pickColor";
      } else {
        colorCommand.pickId = void 0;
      }
      commandList.push(colorCommand);
    }
  }
}
Primitive.prototype.update = function(frameState) {
  if (!defined_default(this.geometryInstances) && this._va.length === 0 || defined_default(this.geometryInstances) && Array.isArray(this.geometryInstances) && this.geometryInstances.length === 0 || !defined_default(this.appearance) || frameState.mode !== SceneMode_default.SCENE3D && frameState.scene3DOnly || !frameState.passes.render && !frameState.passes.pick) {
    return;
  }
  if (defined_default(this._error)) {
    throw this._error;
  }
  if (defined_default(this.rtcCenter) && !frameState.scene3DOnly) {
    throw new DeveloperError_default(
      "RTC rendering is only available for 3D only scenes."
    );
  }
  if (this._state === PrimitiveState_default.FAILED) {
    return;
  }
  const context = frameState.context;
  if (!defined_default(this._batchTable)) {
    createBatchTable(this, context);
  }
  if (this._batchTable.attributes.length > 0) {
    if (ContextLimits_default.maximumVertexTextureImageUnits === 0) {
      throw new RuntimeError_default(
        "Vertex texture fetch support is required to render primitives with per-instance attributes. The maximum number of vertex texture image units must be greater than zero."
      );
    }
    this._batchTable.update(frameState);
  }
  if (this._state !== PrimitiveState_default.COMPLETE && this._state !== PrimitiveState_default.COMBINED) {
    if (this.asynchronous) {
      loadAsynchronous(this, frameState);
    } else {
      loadSynchronous(this, frameState);
    }
  }
  if (this._state === PrimitiveState_default.COMBINED) {
    updateBatchTableBoundingSpheres(this, frameState);
    updateBatchTableOffsets(this, frameState);
    createVertexArray(this, frameState);
  }
  if (!this.show || this._state !== PrimitiveState_default.COMPLETE) {
    return;
  }
  if (!this._batchTableOffsetsUpdated) {
    updateBatchTableOffsets(this, frameState);
  }
  if (this._recomputeBoundingSpheres) {
    recomputeBoundingSpheres(this, frameState);
  }
  const appearance = this.appearance;
  const material = appearance.material;
  let createRS = false;
  let createSP = false;
  if (this._appearance !== appearance) {
    this._appearance = appearance;
    this._material = material;
    createRS = true;
    createSP = true;
  } else if (this._material !== material) {
    this._material = material;
    createSP = true;
  }
  const depthFailAppearance = this.depthFailAppearance;
  const depthFailMaterial = defined_default(depthFailAppearance) ? depthFailAppearance.material : void 0;
  if (this._depthFailAppearance !== depthFailAppearance) {
    this._depthFailAppearance = depthFailAppearance;
    this._depthFailMaterial = depthFailMaterial;
    createRS = true;
    createSP = true;
  } else if (this._depthFailMaterial !== depthFailMaterial) {
    this._depthFailMaterial = depthFailMaterial;
    createSP = true;
  }
  const translucent = this._appearance.isTranslucent();
  if (this._translucent !== translucent) {
    this._translucent = translucent;
    createRS = true;
  }
  if (defined_default(this._material)) {
    this._material.update(context);
  }
  const twoPasses = appearance.closed && translucent;
  if (createRS) {
    const rsFunc = defaultValue_default(
      this._createRenderStatesFunction,
      createRenderStates
    );
    rsFunc(this, context, appearance, twoPasses);
  }
  if (createSP) {
    const spFunc = defaultValue_default(
      this._createShaderProgramFunction,
      createShaderProgram
    );
    spFunc(this, frameState, appearance);
  }
  if (createRS || createSP) {
    const commandFunc = defaultValue_default(
      this._createCommandsFunction,
      createCommands
    );
    commandFunc(
      this,
      appearance,
      material,
      translucent,
      twoPasses,
      this._colorCommands,
      this._pickCommands,
      frameState
    );
  }
  const updateAndQueueCommandsFunc = defaultValue_default(
    this._updateAndQueueCommandsFunction,
    updateAndQueueCommands
  );
  updateAndQueueCommandsFunc(
    this,
    frameState,
    this._colorCommands,
    this._pickCommands,
    this.modelMatrix,
    this.cull,
    this.debugShowBoundingVolume,
    twoPasses
  );
};
var offsetBoundingSphereScratch1 = new BoundingSphere_default();
var offsetBoundingSphereScratch2 = new BoundingSphere_default();
function transformBoundingSphere(boundingSphere, offset2, offsetAttribute) {
  if (offsetAttribute === GeometryOffsetAttribute_default.TOP) {
    const origBS = BoundingSphere_default.clone(
      boundingSphere,
      offsetBoundingSphereScratch1
    );
    const offsetBS = BoundingSphere_default.clone(
      boundingSphere,
      offsetBoundingSphereScratch2
    );
    offsetBS.center = Cartesian3_default.add(offsetBS.center, offset2, offsetBS.center);
    boundingSphere = BoundingSphere_default.union(origBS, offsetBS, boundingSphere);
  } else if (offsetAttribute === GeometryOffsetAttribute_default.ALL) {
    boundingSphere.center = Cartesian3_default.add(
      boundingSphere.center,
      offset2,
      boundingSphere.center
    );
  }
  return boundingSphere;
}
function createGetFunction(batchTable, instanceIndex, attributeIndex) {
  return function() {
    const attributeValue = batchTable.getBatchedAttribute(
      instanceIndex,
      attributeIndex
    );
    const attribute = batchTable.attributes[attributeIndex];
    const componentsPerAttribute = attribute.componentsPerAttribute;
    const value = ComponentDatatype_default.createTypedArray(
      attribute.componentDatatype,
      componentsPerAttribute
    );
    if (defined_default(attributeValue.constructor.pack)) {
      attributeValue.constructor.pack(attributeValue, value, 0);
    } else {
      value[0] = attributeValue;
    }
    return value;
  };
}
function createSetFunction(batchTable, instanceIndex, attributeIndex, primitive, name) {
  return function(value) {
    if (!defined_default(value) || !defined_default(value.length) || value.length < 1 || value.length > 4) {
      throw new DeveloperError_default(
        "value must be and array with length between 1 and 4."
      );
    }
    const attributeValue = getAttributeValue(value);
    batchTable.setBatchedAttribute(
      instanceIndex,
      attributeIndex,
      attributeValue
    );
    if (name === "offset") {
      primitive._recomputeBoundingSpheres = true;
      primitive._batchTableOffsetsUpdated = false;
    }
  };
}
var offsetScratch3 = new Cartesian3_default();
function createBoundingSphereProperties(primitive, properties, index2) {
  properties.boundingSphere = {
    get: function() {
      let boundingSphere = primitive._instanceBoundingSpheres[index2];
      if (defined_default(boundingSphere)) {
        boundingSphere = boundingSphere.clone();
        const modelMatrix = primitive.modelMatrix;
        const offset2 = properties.offset;
        if (defined_default(offset2)) {
          transformBoundingSphere(
            boundingSphere,
            Cartesian3_default.fromArray(offset2.get(), 0, offsetScratch3),
            primitive._offsetInstanceExtend[index2]
          );
        }
        if (defined_default(modelMatrix)) {
          boundingSphere = BoundingSphere_default.transform(
            boundingSphere,
            modelMatrix
          );
        }
      }
      return boundingSphere;
    }
  };
  properties.boundingSphereCV = {
    get: function() {
      return primitive._instanceBoundingSpheresCV[index2];
    }
  };
}
function createPickIdProperty(primitive, properties, index2) {
  properties.pickId = {
    get: function() {
      return primitive._pickIds[index2];
    }
  };
}
Primitive.prototype.getGeometryInstanceAttributes = function(id) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required");
  }
  if (!defined_default(this._batchTable)) {
    throw new DeveloperError_default(
      "must call update before calling getGeometryInstanceAttributes"
    );
  }
  let index2 = -1;
  const lastIndex = this._lastPerInstanceAttributeIndex;
  const ids = this._instanceIds;
  const length3 = ids.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const curIndex = (lastIndex + i2) % length3;
    if (id === ids[curIndex]) {
      index2 = curIndex;
      break;
    }
  }
  if (index2 === -1) {
    return void 0;
  }
  let attributes = this._perInstanceAttributeCache[index2];
  if (defined_default(attributes)) {
    return attributes;
  }
  const batchTable = this._batchTable;
  const perInstanceAttributeIndices = this._batchTableAttributeIndices;
  attributes = {};
  const properties = {};
  for (const name in perInstanceAttributeIndices) {
    if (perInstanceAttributeIndices.hasOwnProperty(name)) {
      const attributeIndex = perInstanceAttributeIndices[name];
      properties[name] = {
        get: createGetFunction(batchTable, index2, attributeIndex),
        set: createSetFunction(batchTable, index2, attributeIndex, this, name)
      };
    }
  }
  createBoundingSphereProperties(this, properties, index2);
  createPickIdProperty(this, properties, index2);
  Object.defineProperties(attributes, properties);
  this._lastPerInstanceAttributeIndex = index2;
  this._perInstanceAttributeCache[index2] = attributes;
  return attributes;
};
Primitive.prototype.isDestroyed = function() {
  return false;
};
Primitive.prototype.destroy = function() {
  let length3;
  let i2;
  this._sp = this._sp && this._sp.destroy();
  this._spDepthFail = this._spDepthFail && this._spDepthFail.destroy();
  const va = this._va;
  length3 = va.length;
  for (i2 = 0; i2 < length3; ++i2) {
    va[i2].destroy();
  }
  this._va = void 0;
  const pickIds = this._pickIds;
  length3 = pickIds.length;
  for (i2 = 0; i2 < length3; ++i2) {
    pickIds[i2].destroy();
  }
  this._pickIds = void 0;
  this._batchTable = this._batchTable && this._batchTable.destroy();
  this._instanceIds = void 0;
  this._perInstanceAttributeCache = void 0;
  this._attributeLocations = void 0;
  return destroyObject_default(this);
};
function setReady(primitive, frameState, state, error) {
  primitive._error = error;
  primitive._state = state;
  frameState.afterRender.push(function() {
    primitive._ready = primitive._state === PrimitiveState_default.COMPLETE || primitive._state === PrimitiveState_default.FAILED;
    if (!defined_default(error)) {
      primitive._readyPromise.resolve(primitive);
    } else {
      primitive._readyPromise.reject(error);
    }
  });
}
var Primitive_default = Primitive;

// node_modules/cesium/Source/Shaders/ShadowVolumeAppearanceFS.js
var ShadowVolumeAppearanceFS_default = "#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n#endif\n\n#ifdef TEXTURE_COORDINATES\n#ifdef SPHERICAL\nvarying vec4 v_sphericalExtents;\n#else // SPHERICAL\nvarying vec2 v_inversePlaneExtents;\nvarying vec4 v_westPlane;\nvarying vec4 v_southPlane;\n#endif // SPHERICAL\nvarying vec3 v_uvMinAndSphericalLongitudeRotation;\nvarying vec3 v_uMaxAndInverseDistance;\nvarying vec3 v_vMaxAndInverseDistance;\n#endif // TEXTURE_COORDINATES\n\n#ifdef PER_INSTANCE_COLOR\nvarying vec4 v_color;\n#endif\n\n#ifdef NORMAL_EC\nvec3 getEyeCoordinate3FromWindowCoordinate(vec2 fragCoord, float logDepthOrDepth) {\n    vec4 eyeCoordinate = czm_windowToEyeCoordinates(fragCoord, logDepthOrDepth);\n    return eyeCoordinate.xyz / eyeCoordinate.w;\n}\n\nvec3 vectorFromOffset(vec4 eyeCoordinate, vec2 positiveOffset) {\n    vec2 glFragCoordXY = gl_FragCoord.xy;\n    // Sample depths at both offset and negative offset\n    float upOrRightLogDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, (glFragCoordXY + positiveOffset) / czm_viewport.zw));\n    float downOrLeftLogDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, (glFragCoordXY - positiveOffset) / czm_viewport.zw));\n    // Explicitly evaluate both paths\n    // Necessary for multifrustum and for edges of the screen\n    bvec2 upOrRightInBounds = lessThan(glFragCoordXY + positiveOffset, czm_viewport.zw);\n    float useUpOrRight = float(upOrRightLogDepth > 0.0 && upOrRightInBounds.x && upOrRightInBounds.y);\n    float useDownOrLeft = float(useUpOrRight == 0.0);\n    vec3 upOrRightEC = getEyeCoordinate3FromWindowCoordinate(glFragCoordXY + positiveOffset, upOrRightLogDepth);\n    vec3 downOrLeftEC = getEyeCoordinate3FromWindowCoordinate(glFragCoordXY - positiveOffset, downOrLeftLogDepth);\n    return (upOrRightEC - (eyeCoordinate.xyz / eyeCoordinate.w)) * useUpOrRight + ((eyeCoordinate.xyz / eyeCoordinate.w) - downOrLeftEC) * useDownOrLeft;\n}\n#endif // NORMAL_EC\n\nvoid main(void)\n{\n#ifdef REQUIRES_EC\n    float logDepthOrDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, gl_FragCoord.xy / czm_viewport.zw));\n    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth);\n#endif\n\n#ifdef REQUIRES_WC\n    vec4 worldCoordinate4 = czm_inverseView * eyeCoordinate;\n    vec3 worldCoordinate = worldCoordinate4.xyz / worldCoordinate4.w;\n#endif\n\n#ifdef TEXTURE_COORDINATES\n    vec2 uv;\n#ifdef SPHERICAL\n    // Treat world coords as a sphere normal for spherical coordinates\n    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(worldCoordinate);\n    sphericalLatLong.y += v_uvMinAndSphericalLongitudeRotation.z;\n    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);\n    uv.x = (sphericalLatLong.y - v_sphericalExtents.y) * v_sphericalExtents.w;\n    uv.y = (sphericalLatLong.x - v_sphericalExtents.x) * v_sphericalExtents.z;\n#else // SPHERICAL\n    // Unpack planes and transform to eye space\n    uv.x = czm_planeDistance(v_westPlane, eyeCoordinate.xyz / eyeCoordinate.w) * v_inversePlaneExtents.x;\n    uv.y = czm_planeDistance(v_southPlane, eyeCoordinate.xyz / eyeCoordinate.w) * v_inversePlaneExtents.y;\n#endif // SPHERICAL\n#endif // TEXTURE_COORDINATES\n\n#ifdef PICK\n#ifdef CULL_FRAGMENTS\n    // When classifying translucent geometry, logDepthOrDepth == 0.0\n    // indicates a region that should not be classified, possibly due to there\n    // being opaque pixels there in another buffer.\n    // Check for logDepthOrDepth != 0.0 to make sure this should be classified.\n    if (0.0 <= uv.x && uv.x <= 1.0 && 0.0 <= uv.y && uv.y <= 1.0 || logDepthOrDepth != 0.0) {\n        gl_FragColor.a = 1.0; // 0.0 alpha leads to discard from ShaderSource.createPickFragmentShaderSource\n        czm_writeDepthClamp();\n    }\n#else // CULL_FRAGMENTS\n        gl_FragColor.a = 1.0;\n#endif // CULL_FRAGMENTS\n#else // PICK\n\n#ifdef CULL_FRAGMENTS\n    // When classifying translucent geometry, logDepthOrDepth == 0.0\n    // indicates a region that should not be classified, possibly due to there\n    // being opaque pixels there in another buffer.\n    if (uv.x <= 0.0 || 1.0 <= uv.x || uv.y <= 0.0 || 1.0 <= uv.y || logDepthOrDepth == 0.0) {\n        discard;\n    }\n#endif\n\n#ifdef NORMAL_EC\n    // Compute normal by sampling adjacent pixels in 2x2 block in screen space\n    vec3 downUp = vectorFromOffset(eyeCoordinate, vec2(0.0, 1.0));\n    vec3 leftRight = vectorFromOffset(eyeCoordinate, vec2(1.0, 0.0));\n    vec3 normalEC = normalize(cross(leftRight, downUp));\n#endif\n\n\n#ifdef PER_INSTANCE_COLOR\n\n    vec4 color = czm_gammaCorrect(v_color);\n#ifdef FLAT\n    gl_FragColor = color;\n#else // FLAT\n    czm_materialInput materialInput;\n    materialInput.normalEC = normalEC;\n    materialInput.positionToEyeEC = -eyeCoordinate.xyz;\n    czm_material material = czm_getDefaultMaterial(materialInput);\n    material.diffuse = color.rgb;\n    material.alpha = color.a;\n\n    gl_FragColor = czm_phong(normalize(-eyeCoordinate.xyz), material, czm_lightDirectionEC);\n#endif // FLAT\n\n    // Premultiply alpha. Required for classification primitives on translucent globe.\n    gl_FragColor.rgb *= gl_FragColor.a;\n\n#else // PER_INSTANCE_COLOR\n\n    // Material support.\n    // USES_ is distinct from REQUIRES_, because some things are dependencies of each other or\n    // dependencies for culling but might not actually be used by the material.\n\n    czm_materialInput materialInput;\n\n#ifdef USES_NORMAL_EC\n    materialInput.normalEC = normalEC;\n#endif\n\n#ifdef USES_POSITION_TO_EYE_EC\n    materialInput.positionToEyeEC = -eyeCoordinate.xyz;\n#endif\n\n#ifdef USES_TANGENT_TO_EYE\n    materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(worldCoordinate, normalEC);\n#endif\n\n#ifdef USES_ST\n    // Remap texture coordinates from computed (approximately aligned with cartographic space) to the desired\n    // texture coordinate system, which typically forms a tight oriented bounding box around the geometry.\n    // Shader is provided a set of reference points for remapping.\n    materialInput.st.x = czm_lineDistance(v_uvMinAndSphericalLongitudeRotation.xy, v_uMaxAndInverseDistance.xy, uv) * v_uMaxAndInverseDistance.z;\n    materialInput.st.y = czm_lineDistance(v_uvMinAndSphericalLongitudeRotation.xy, v_vMaxAndInverseDistance.xy, uv) * v_vMaxAndInverseDistance.z;\n#endif\n\n    czm_material material = czm_getMaterial(materialInput);\n\n#ifdef FLAT\n    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n#else // FLAT\n    gl_FragColor = czm_phong(normalize(-eyeCoordinate.xyz), material, czm_lightDirectionEC);\n#endif // FLAT\n\n    // Premultiply alpha. Required for classification primitives on translucent globe.\n    gl_FragColor.rgb *= gl_FragColor.a;\n\n#endif // PER_INSTANCE_COLOR\n    czm_writeDepthClamp();\n#endif // PICK\n}\n";

// node_modules/cesium/Source/Scene/ShadowVolumeAppearance.js
function ShadowVolumeAppearance(extentsCulling, planarExtents, appearance) {
  Check_default.typeOf.bool("extentsCulling", extentsCulling);
  Check_default.typeOf.bool("planarExtents", planarExtents);
  Check_default.typeOf.object("appearance", appearance);
  this._projectionExtentDefines = {
    eastMostYhighDefine: "",
    eastMostYlowDefine: "",
    westMostYhighDefine: "",
    westMostYlowDefine: ""
  };
  const colorShaderDependencies = new ShaderDependencies();
  colorShaderDependencies.requiresTextureCoordinates = extentsCulling;
  colorShaderDependencies.requiresEC = !appearance.flat;
  const pickShaderDependencies = new ShaderDependencies();
  pickShaderDependencies.requiresTextureCoordinates = extentsCulling;
  if (appearance instanceof PerInstanceColorAppearance_default) {
    colorShaderDependencies.requiresNormalEC = !appearance.flat;
  } else {
    const materialShaderSource = `${appearance.material.shaderSource}
${appearance.fragmentShaderSource}`;
    colorShaderDependencies.normalEC = materialShaderSource.indexOf("materialInput.normalEC") !== -1 || materialShaderSource.indexOf("czm_getDefaultMaterial") !== -1;
    colorShaderDependencies.positionToEyeEC = materialShaderSource.indexOf("materialInput.positionToEyeEC") !== -1;
    colorShaderDependencies.tangentToEyeMatrix = materialShaderSource.indexOf("materialInput.tangentToEyeMatrix") !== -1;
    colorShaderDependencies.st = materialShaderSource.indexOf("materialInput.st") !== -1;
  }
  this._colorShaderDependencies = colorShaderDependencies;
  this._pickShaderDependencies = pickShaderDependencies;
  this._appearance = appearance;
  this._extentsCulling = extentsCulling;
  this._planarExtents = planarExtents;
}
ShadowVolumeAppearance.prototype.createFragmentShader = function(columbusView2D) {
  Check_default.typeOf.bool("columbusView2D", columbusView2D);
  const appearance = this._appearance;
  const dependencies = this._colorShaderDependencies;
  const defines = [];
  if (!columbusView2D && !this._planarExtents) {
    defines.push("SPHERICAL");
  }
  if (dependencies.requiresEC) {
    defines.push("REQUIRES_EC");
  }
  if (dependencies.requiresWC) {
    defines.push("REQUIRES_WC");
  }
  if (dependencies.requiresTextureCoordinates) {
    defines.push("TEXTURE_COORDINATES");
  }
  if (this._extentsCulling) {
    defines.push("CULL_FRAGMENTS");
  }
  if (dependencies.requiresNormalEC) {
    defines.push("NORMAL_EC");
  }
  if (appearance instanceof PerInstanceColorAppearance_default) {
    defines.push("PER_INSTANCE_COLOR");
  }
  if (dependencies.normalEC) {
    defines.push("USES_NORMAL_EC");
  }
  if (dependencies.positionToEyeEC) {
    defines.push("USES_POSITION_TO_EYE_EC");
  }
  if (dependencies.tangentToEyeMatrix) {
    defines.push("USES_TANGENT_TO_EYE");
  }
  if (dependencies.st) {
    defines.push("USES_ST");
  }
  if (appearance.flat) {
    defines.push("FLAT");
  }
  let materialSource = "";
  if (!(appearance instanceof PerInstanceColorAppearance_default)) {
    materialSource = appearance.material.shaderSource;
  }
  return new ShaderSource_default({
    defines,
    sources: [materialSource, ShadowVolumeAppearanceFS_default]
  });
};
ShadowVolumeAppearance.prototype.createPickFragmentShader = function(columbusView2D) {
  Check_default.typeOf.bool("columbusView2D", columbusView2D);
  const dependencies = this._pickShaderDependencies;
  const defines = ["PICK"];
  if (!columbusView2D && !this._planarExtents) {
    defines.push("SPHERICAL");
  }
  if (dependencies.requiresEC) {
    defines.push("REQUIRES_EC");
  }
  if (dependencies.requiresWC) {
    defines.push("REQUIRES_WC");
  }
  if (dependencies.requiresTextureCoordinates) {
    defines.push("TEXTURE_COORDINATES");
  }
  if (this._extentsCulling) {
    defines.push("CULL_FRAGMENTS");
  }
  return new ShaderSource_default({
    defines,
    sources: [ShadowVolumeAppearanceFS_default],
    pickColorQualifier: "varying"
  });
};
ShadowVolumeAppearance.prototype.createVertexShader = function(defines, vertexShaderSource, columbusView2D, mapProjection) {
  Check_default.defined("defines", defines);
  Check_default.typeOf.string("vertexShaderSource", vertexShaderSource);
  Check_default.typeOf.bool("columbusView2D", columbusView2D);
  Check_default.defined("mapProjection", mapProjection);
  return createShadowVolumeAppearanceVS(
    this._colorShaderDependencies,
    this._planarExtents,
    columbusView2D,
    defines,
    vertexShaderSource,
    this._appearance,
    mapProjection,
    this._projectionExtentDefines
  );
};
ShadowVolumeAppearance.prototype.createPickVertexShader = function(defines, vertexShaderSource, columbusView2D, mapProjection) {
  Check_default.defined("defines", defines);
  Check_default.typeOf.string("vertexShaderSource", vertexShaderSource);
  Check_default.typeOf.bool("columbusView2D", columbusView2D);
  Check_default.defined("mapProjection", mapProjection);
  return createShadowVolumeAppearanceVS(
    this._pickShaderDependencies,
    this._planarExtents,
    columbusView2D,
    defines,
    vertexShaderSource,
    void 0,
    mapProjection,
    this._projectionExtentDefines
  );
};
var longitudeExtentsCartesianScratch = new Cartesian3_default();
var longitudeExtentsCartographicScratch = new Cartographic_default();
var longitudeExtentsEncodeScratch = {
  high: 0,
  low: 0
};
function createShadowVolumeAppearanceVS(shaderDependencies, planarExtents, columbusView2D, defines, vertexShaderSource, appearance, mapProjection, projectionExtentDefines) {
  const allDefines = defines.slice();
  if (projectionExtentDefines.eastMostYhighDefine === "") {
    const eastMostCartographic = longitudeExtentsCartographicScratch;
    eastMostCartographic.longitude = Math_default.PI;
    eastMostCartographic.latitude = 0;
    eastMostCartographic.height = 0;
    const eastMostCartesian = mapProjection.project(
      eastMostCartographic,
      longitudeExtentsCartesianScratch
    );
    let encoded = EncodedCartesian3_default.encode(
      eastMostCartesian.x,
      longitudeExtentsEncodeScratch
    );
    projectionExtentDefines.eastMostYhighDefine = `EAST_MOST_X_HIGH ${encoded.high.toFixed(
      `${encoded.high}`.length + 1
    )}`;
    projectionExtentDefines.eastMostYlowDefine = `EAST_MOST_X_LOW ${encoded.low.toFixed(
      `${encoded.low}`.length + 1
    )}`;
    const westMostCartographic = longitudeExtentsCartographicScratch;
    westMostCartographic.longitude = -Math_default.PI;
    westMostCartographic.latitude = 0;
    westMostCartographic.height = 0;
    const westMostCartesian = mapProjection.project(
      westMostCartographic,
      longitudeExtentsCartesianScratch
    );
    encoded = EncodedCartesian3_default.encode(
      westMostCartesian.x,
      longitudeExtentsEncodeScratch
    );
    projectionExtentDefines.westMostYhighDefine = `WEST_MOST_X_HIGH ${encoded.high.toFixed(
      `${encoded.high}`.length + 1
    )}`;
    projectionExtentDefines.westMostYlowDefine = `WEST_MOST_X_LOW ${encoded.low.toFixed(
      `${encoded.low}`.length + 1
    )}`;
  }
  if (columbusView2D) {
    allDefines.push(projectionExtentDefines.eastMostYhighDefine);
    allDefines.push(projectionExtentDefines.eastMostYlowDefine);
    allDefines.push(projectionExtentDefines.westMostYhighDefine);
    allDefines.push(projectionExtentDefines.westMostYlowDefine);
  }
  if (defined_default(appearance) && appearance instanceof PerInstanceColorAppearance_default) {
    allDefines.push("PER_INSTANCE_COLOR");
  }
  if (shaderDependencies.requiresTextureCoordinates) {
    allDefines.push("TEXTURE_COORDINATES");
    if (!(planarExtents || columbusView2D)) {
      allDefines.push("SPHERICAL");
    }
    if (columbusView2D) {
      allDefines.push("COLUMBUS_VIEW_2D");
    }
  }
  return new ShaderSource_default({
    defines: allDefines,
    sources: [vertexShaderSource]
  });
}
function ShaderDependencies() {
  this._requiresEC = false;
  this._requiresWC = false;
  this._requiresNormalEC = false;
  this._requiresTextureCoordinates = false;
  this._usesNormalEC = false;
  this._usesPositionToEyeEC = false;
  this._usesTangentToEyeMat = false;
  this._usesSt = false;
}
Object.defineProperties(ShaderDependencies.prototype, {
  requiresEC: {
    get: function() {
      return this._requiresEC;
    },
    set: function(value) {
      this._requiresEC = value || this._requiresEC;
    }
  },
  requiresWC: {
    get: function() {
      return this._requiresWC;
    },
    set: function(value) {
      this._requiresWC = value || this._requiresWC;
      this.requiresEC = this._requiresWC;
    }
  },
  requiresNormalEC: {
    get: function() {
      return this._requiresNormalEC;
    },
    set: function(value) {
      this._requiresNormalEC = value || this._requiresNormalEC;
      this.requiresEC = this._requiresNormalEC;
    }
  },
  requiresTextureCoordinates: {
    get: function() {
      return this._requiresTextureCoordinates;
    },
    set: function(value) {
      this._requiresTextureCoordinates = value || this._requiresTextureCoordinates;
      this.requiresWC = this._requiresTextureCoordinates;
    }
  },
  normalEC: {
    set: function(value) {
      this.requiresNormalEC = value;
      this._usesNormalEC = value;
    },
    get: function() {
      return this._usesNormalEC;
    }
  },
  tangentToEyeMatrix: {
    set: function(value) {
      this.requiresWC = value;
      this.requiresNormalEC = value;
      this._usesTangentToEyeMat = value;
    },
    get: function() {
      return this._usesTangentToEyeMat;
    }
  },
  positionToEyeEC: {
    set: function(value) {
      this.requiresEC = value;
      this._usesPositionToEyeEC = value;
    },
    get: function() {
      return this._usesPositionToEyeEC;
    }
  },
  st: {
    set: function(value) {
      this.requiresTextureCoordinates = value;
      this._usesSt = value;
    },
    get: function() {
      return this._usesSt;
    }
  }
});
function pointLineDistance(point1, point2, point) {
  return Math.abs(
    (point2.y - point1.y) * point.x - (point2.x - point1.x) * point.y + point2.x * point1.y - point2.y * point1.x
  ) / Cartesian2_default.distance(point2, point1);
}
var points2DScratch3 = [
  new Cartesian2_default(),
  new Cartesian2_default(),
  new Cartesian2_default(),
  new Cartesian2_default()
];
function addTextureCoordinateRotationAttributes(attributes, textureCoordinateRotationPoints4) {
  const points2D = points2DScratch3;
  const minXYCorner = Cartesian2_default.unpack(
    textureCoordinateRotationPoints4,
    0,
    points2D[0]
  );
  const maxYCorner = Cartesian2_default.unpack(
    textureCoordinateRotationPoints4,
    2,
    points2D[1]
  );
  const maxXCorner = Cartesian2_default.unpack(
    textureCoordinateRotationPoints4,
    4,
    points2D[2]
  );
  attributes.uMaxVmax = new GeometryInstanceAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 4,
    normalize: false,
    value: [maxYCorner.x, maxYCorner.y, maxXCorner.x, maxXCorner.y]
  });
  const inverseExtentX = 1 / pointLineDistance(minXYCorner, maxYCorner, maxXCorner);
  const inverseExtentY = 1 / pointLineDistance(minXYCorner, maxXCorner, maxYCorner);
  attributes.uvMinAndExtents = new GeometryInstanceAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 4,
    normalize: false,
    value: [minXYCorner.x, minXYCorner.y, inverseExtentX, inverseExtentY]
  });
}
var cartographicScratch2 = new Cartographic_default();
var cornerScratch = new Cartesian3_default();
var northWestScratch = new Cartesian3_default();
var southEastScratch = new Cartesian3_default();
var highLowScratch = { high: 0, low: 0 };
function add2DTextureCoordinateAttributes(rectangle, projection, attributes) {
  const carto = cartographicScratch2;
  carto.height = 0;
  carto.longitude = rectangle.west;
  carto.latitude = rectangle.south;
  const southWestCorner = projection.project(carto, cornerScratch);
  carto.latitude = rectangle.north;
  const northWest = projection.project(carto, northWestScratch);
  carto.longitude = rectangle.east;
  carto.latitude = rectangle.south;
  const southEast = projection.project(carto, southEastScratch);
  const valuesHigh = [0, 0, 0, 0];
  const valuesLow = [0, 0, 0, 0];
  let encoded = EncodedCartesian3_default.encode(southWestCorner.x, highLowScratch);
  valuesHigh[0] = encoded.high;
  valuesLow[0] = encoded.low;
  encoded = EncodedCartesian3_default.encode(southWestCorner.y, highLowScratch);
  valuesHigh[1] = encoded.high;
  valuesLow[1] = encoded.low;
  encoded = EncodedCartesian3_default.encode(northWest.y, highLowScratch);
  valuesHigh[2] = encoded.high;
  valuesLow[2] = encoded.low;
  encoded = EncodedCartesian3_default.encode(southEast.x, highLowScratch);
  valuesHigh[3] = encoded.high;
  valuesLow[3] = encoded.low;
  attributes.planes2D_HIGH = new GeometryInstanceAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 4,
    normalize: false,
    value: valuesHigh
  });
  attributes.planes2D_LOW = new GeometryInstanceAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 4,
    normalize: false,
    value: valuesLow
  });
}
var enuMatrixScratch = new Matrix4_default();
var inverseEnuScratch = new Matrix4_default();
var rectanglePointCartesianScratch = new Cartesian3_default();
var rectangleCenterScratch3 = new Cartographic_default();
var pointsCartographicScratch = [
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default()
];
function computeRectangleBounds(rectangle, ellipsoid, height, southWestCornerResult, eastVectorResult, northVectorResult) {
  const centerCartographic = Rectangle_default.center(
    rectangle,
    rectangleCenterScratch3
  );
  centerCartographic.height = height;
  const centerCartesian2 = Cartographic_default.toCartesian(
    centerCartographic,
    ellipsoid,
    rectanglePointCartesianScratch
  );
  const enuMatrix = Transforms_default.eastNorthUpToFixedFrame(
    centerCartesian2,
    ellipsoid,
    enuMatrixScratch
  );
  const inverseEnu = Matrix4_default.inverse(enuMatrix, inverseEnuScratch);
  const west = rectangle.west;
  const east = rectangle.east;
  const north = rectangle.north;
  const south = rectangle.south;
  const cartographics = pointsCartographicScratch;
  cartographics[0].latitude = south;
  cartographics[0].longitude = west;
  cartographics[1].latitude = north;
  cartographics[1].longitude = west;
  cartographics[2].latitude = north;
  cartographics[2].longitude = east;
  cartographics[3].latitude = south;
  cartographics[3].longitude = east;
  const longitudeCenter = (west + east) * 0.5;
  const latitudeCenter = (north + south) * 0.5;
  cartographics[4].latitude = south;
  cartographics[4].longitude = longitudeCenter;
  cartographics[5].latitude = north;
  cartographics[5].longitude = longitudeCenter;
  cartographics[6].latitude = latitudeCenter;
  cartographics[6].longitude = west;
  cartographics[7].latitude = latitudeCenter;
  cartographics[7].longitude = east;
  let minX = Number.POSITIVE_INFINITY;
  let maxX = Number.NEGATIVE_INFINITY;
  let minY = Number.POSITIVE_INFINITY;
  let maxY = Number.NEGATIVE_INFINITY;
  for (let i2 = 0; i2 < 8; i2++) {
    cartographics[i2].height = height;
    const pointCartesian = Cartographic_default.toCartesian(
      cartographics[i2],
      ellipsoid,
      rectanglePointCartesianScratch
    );
    Matrix4_default.multiplyByPoint(inverseEnu, pointCartesian, pointCartesian);
    pointCartesian.z = 0;
    minX = Math.min(minX, pointCartesian.x);
    maxX = Math.max(maxX, pointCartesian.x);
    minY = Math.min(minY, pointCartesian.y);
    maxY = Math.max(maxY, pointCartesian.y);
  }
  const southWestCorner = southWestCornerResult;
  southWestCorner.x = minX;
  southWestCorner.y = minY;
  southWestCorner.z = 0;
  Matrix4_default.multiplyByPoint(enuMatrix, southWestCorner, southWestCorner);
  const southEastCorner = eastVectorResult;
  southEastCorner.x = maxX;
  southEastCorner.y = minY;
  southEastCorner.z = 0;
  Matrix4_default.multiplyByPoint(enuMatrix, southEastCorner, southEastCorner);
  Cartesian3_default.subtract(southEastCorner, southWestCorner, eastVectorResult);
  const northWestCorner = northVectorResult;
  northWestCorner.x = minX;
  northWestCorner.y = maxY;
  northWestCorner.z = 0;
  Matrix4_default.multiplyByPoint(enuMatrix, northWestCorner, northWestCorner);
  Cartesian3_default.subtract(northWestCorner, southWestCorner, northVectorResult);
}
var eastwardScratch = new Cartesian3_default();
var northwardScratch = new Cartesian3_default();
var encodeScratch2 = new EncodedCartesian3_default();
ShadowVolumeAppearance.getPlanarTextureCoordinateAttributes = function(boundingRectangle, textureCoordinateRotationPoints4, ellipsoid, projection, height) {
  Check_default.typeOf.object("boundingRectangle", boundingRectangle);
  Check_default.defined(
    "textureCoordinateRotationPoints",
    textureCoordinateRotationPoints4
  );
  Check_default.typeOf.object("ellipsoid", ellipsoid);
  Check_default.typeOf.object("projection", projection);
  const corner = cornerScratch;
  const eastward = eastwardScratch;
  const northward = northwardScratch;
  computeRectangleBounds(
    boundingRectangle,
    ellipsoid,
    defaultValue_default(height, 0),
    corner,
    eastward,
    northward
  );
  const attributes = {};
  addTextureCoordinateRotationAttributes(
    attributes,
    textureCoordinateRotationPoints4
  );
  const encoded = EncodedCartesian3_default.fromCartesian(corner, encodeScratch2);
  attributes.southWest_HIGH = new GeometryInstanceAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 3,
    normalize: false,
    value: Cartesian3_default.pack(encoded.high, [0, 0, 0])
  });
  attributes.southWest_LOW = new GeometryInstanceAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 3,
    normalize: false,
    value: Cartesian3_default.pack(encoded.low, [0, 0, 0])
  });
  attributes.eastward = new GeometryInstanceAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 3,
    normalize: false,
    value: Cartesian3_default.pack(eastward, [0, 0, 0])
  });
  attributes.northward = new GeometryInstanceAttribute_default({
    componentDatatype: ComponentDatatype_default.FLOAT,
    componentsPerAttribute: 3,
    normalize: false,
    value: Cartesian3_default.pack(northward, [0, 0, 0])
  });
  add2DTextureCoordinateAttributes(boundingRectangle, projection, attributes);
  return attributes;
};
var spherePointScratch = new Cartesian3_default();
function latLongToSpherical(latitude, longitude, ellipsoid, result) {
  const cartographic2 = cartographicScratch2;
  cartographic2.latitude = latitude;
  cartographic2.longitude = longitude;
  cartographic2.height = 0;
  const spherePoint = Cartographic_default.toCartesian(
    cartographic2,
    ellipsoid,
    spherePointScratch
  );
  const magXY = Math.sqrt(
    spherePoint.x * spherePoint.x + spherePoint.y * spherePoint.y
  );
  const sphereLatitude = Math_default.fastApproximateAtan2(magXY, spherePoint.z);
  const sphereLongitude = Math_default.fastApproximateAtan2(
    spherePoint.x,
    spherePoint.y
  );
  result.x = sphereLatitude;
  result.y = sphereLongitude;
  return result;
}
var sphericalScratch = new Cartesian2_default();
ShadowVolumeAppearance.getSphericalExtentGeometryInstanceAttributes = function(boundingRectangle, textureCoordinateRotationPoints4, ellipsoid, projection) {
  Check_default.typeOf.object("boundingRectangle", boundingRectangle);
  Check_default.defined(
    "textureCoordinateRotationPoints",
    textureCoordinateRotationPoints4
  );
  Check_default.typeOf.object("ellipsoid", ellipsoid);
  Check_default.typeOf.object("projection", projection);
  const southWestExtents = latLongToSpherical(
    boundingRectangle.south,
    boundingRectangle.west,
    ellipsoid,
    sphericalScratch
  );
  let south = southWestExtents.x;
  let west = southWestExtents.y;
  const northEastExtents = latLongToSpherical(
    boundingRectangle.north,
    boundingRectangle.east,
    ellipsoid,
    sphericalScratch
  );
  let north = northEastExtents.x;
  let east = northEastExtents.y;
  let rotationRadians = 0;
  if (west > east) {
    rotationRadians = Math_default.PI - west;
    west = -Math_default.PI;
    east += rotationRadians;
  }
  south -= Math_default.EPSILON5;
  west -= Math_default.EPSILON5;
  north += Math_default.EPSILON5;
  east += Math_default.EPSILON5;
  const longitudeRangeInverse = 1 / (east - west);
  const latitudeRangeInverse = 1 / (north - south);
  const attributes = {
    sphericalExtents: new GeometryInstanceAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 4,
      normalize: false,
      value: [south, west, latitudeRangeInverse, longitudeRangeInverse]
    }),
    longitudeRotation: new GeometryInstanceAttribute_default({
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 1,
      normalize: false,
      value: [rotationRadians]
    })
  };
  addTextureCoordinateRotationAttributes(
    attributes,
    textureCoordinateRotationPoints4
  );
  add2DTextureCoordinateAttributes(boundingRectangle, projection, attributes);
  return attributes;
};
ShadowVolumeAppearance.hasAttributesForTextureCoordinatePlanes = function(attributes) {
  return defined_default(attributes.southWest_HIGH) && defined_default(attributes.southWest_LOW) && defined_default(attributes.northward) && defined_default(attributes.eastward) && defined_default(attributes.planes2D_HIGH) && defined_default(attributes.planes2D_LOW) && defined_default(attributes.uMaxVmax) && defined_default(attributes.uvMinAndExtents);
};
ShadowVolumeAppearance.hasAttributesForSphericalExtents = function(attributes) {
  return defined_default(attributes.sphericalExtents) && defined_default(attributes.longitudeRotation) && defined_default(attributes.planes2D_HIGH) && defined_default(attributes.planes2D_LOW) && defined_default(attributes.uMaxVmax) && defined_default(attributes.uvMinAndExtents);
};
function shouldUseSpherical(rectangle) {
  return Math.max(rectangle.width, rectangle.height) > ShadowVolumeAppearance.MAX_WIDTH_FOR_PLANAR_EXTENTS;
}
ShadowVolumeAppearance.shouldUseSphericalCoordinates = function(rectangle) {
  Check_default.typeOf.object("rectangle", rectangle);
  return shouldUseSpherical(rectangle);
};
ShadowVolumeAppearance.MAX_WIDTH_FOR_PLANAR_EXTENTS = Math_default.toRadians(1);
var ShadowVolumeAppearance_default = ShadowVolumeAppearance;

// node_modules/cesium/Source/Scene/StencilFunction.js
var StencilFunction = {
  NEVER: WebGLConstants_default.NEVER,
  LESS: WebGLConstants_default.LESS,
  EQUAL: WebGLConstants_default.EQUAL,
  LESS_OR_EQUAL: WebGLConstants_default.LEQUAL,
  GREATER: WebGLConstants_default.GREATER,
  NOT_EQUAL: WebGLConstants_default.NOTEQUAL,
  GREATER_OR_EQUAL: WebGLConstants_default.GEQUAL,
  ALWAYS: WebGLConstants_default.ALWAYS
};
var StencilFunction_default = Object.freeze(StencilFunction);

// node_modules/cesium/Source/Scene/StencilOperation.js
var StencilOperation = {
  ZERO: WebGLConstants_default.ZERO,
  KEEP: WebGLConstants_default.KEEP,
  REPLACE: WebGLConstants_default.REPLACE,
  INCREMENT: WebGLConstants_default.INCR,
  DECREMENT: WebGLConstants_default.DECR,
  INVERT: WebGLConstants_default.INVERT,
  INCREMENT_WRAP: WebGLConstants_default.INCR_WRAP,
  DECREMENT_WRAP: WebGLConstants_default.DECR_WRAP
};
var StencilOperation_default = Object.freeze(StencilOperation);

// node_modules/cesium/Source/Scene/StencilConstants.js
var StencilConstants = {
  CESIUM_3D_TILE_MASK: 128,
  SKIP_LOD_MASK: 112,
  SKIP_LOD_BIT_SHIFT: 4,
  CLASSIFICATION_MASK: 15
};
StencilConstants.setCesium3DTileBit = function() {
  return {
    enabled: true,
    frontFunction: StencilFunction_default.ALWAYS,
    frontOperation: {
      fail: StencilOperation_default.KEEP,
      zFail: StencilOperation_default.KEEP,
      zPass: StencilOperation_default.REPLACE
    },
    backFunction: StencilFunction_default.ALWAYS,
    backOperation: {
      fail: StencilOperation_default.KEEP,
      zFail: StencilOperation_default.KEEP,
      zPass: StencilOperation_default.REPLACE
    },
    reference: StencilConstants.CESIUM_3D_TILE_MASK,
    mask: StencilConstants.CESIUM_3D_TILE_MASK
  };
};
var StencilConstants_default = Object.freeze(StencilConstants);

// node_modules/cesium/Source/Scene/ClassificationPrimitive.js
function ClassificationPrimitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const geometryInstances = options.geometryInstances;
  this.geometryInstances = geometryInstances;
  this.show = defaultValue_default(options.show, true);
  this.classificationType = defaultValue_default(
    options.classificationType,
    ClassificationType_default.BOTH
  );
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this.debugShowShadowVolume = defaultValue_default(
    options.debugShowShadowVolume,
    false
  );
  this._debugShowShadowVolume = false;
  this._extruded = defaultValue_default(options._extruded, false);
  this._uniformMap = options._uniformMap;
  this._sp = void 0;
  this._spStencil = void 0;
  this._spPick = void 0;
  this._spColor = void 0;
  this._spPick2D = void 0;
  this._spColor2D = void 0;
  this._rsStencilDepthPass = void 0;
  this._rsStencilDepthPass3DTiles = void 0;
  this._rsColorPass = void 0;
  this._rsPickPass = void 0;
  this._commandsIgnoreShow = [];
  this._ready = false;
  this._readyPromise = defer_default();
  this._primitive = void 0;
  this._pickPrimitive = options._pickPrimitive;
  this._hasSphericalExtentsAttribute = false;
  this._hasPlanarExtentsAttributes = false;
  this._hasPerColorAttribute = false;
  this.appearance = options.appearance;
  this._createBoundingVolumeFunction = options._createBoundingVolumeFunction;
  this._updateAndQueueCommandsFunction = options._updateAndQueueCommandsFunction;
  this._usePickOffsets = false;
  this._primitiveOptions = {
    geometryInstances: void 0,
    appearance: void 0,
    vertexCacheOptimize: defaultValue_default(options.vertexCacheOptimize, false),
    interleave: defaultValue_default(options.interleave, false),
    releaseGeometryInstances: defaultValue_default(
      options.releaseGeometryInstances,
      true
    ),
    allowPicking: defaultValue_default(options.allowPicking, true),
    asynchronous: defaultValue_default(options.asynchronous, true),
    compressVertices: defaultValue_default(options.compressVertices, true),
    _createBoundingVolumeFunction: void 0,
    _createRenderStatesFunction: void 0,
    _createShaderProgramFunction: void 0,
    _createCommandsFunction: void 0,
    _updateAndQueueCommandsFunction: void 0,
    _createPickOffsets: true
  };
}
Object.defineProperties(ClassificationPrimitive.prototype, {
  vertexCacheOptimize: {
    get: function() {
      return this._primitiveOptions.vertexCacheOptimize;
    }
  },
  interleave: {
    get: function() {
      return this._primitiveOptions.interleave;
    }
  },
  releaseGeometryInstances: {
    get: function() {
      return this._primitiveOptions.releaseGeometryInstances;
    }
  },
  allowPicking: {
    get: function() {
      return this._primitiveOptions.allowPicking;
    }
  },
  asynchronous: {
    get: function() {
      return this._primitiveOptions.asynchronous;
    }
  },
  compressVertices: {
    get: function() {
      return this._primitiveOptions.compressVertices;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  _needs2DShader: {
    get: function() {
      return this._hasPlanarExtentsAttributes || this._hasSphericalExtentsAttribute;
    }
  }
});
ClassificationPrimitive.isSupported = function(scene) {
  return scene.context.stencilBuffer;
};
function getStencilDepthRenderState(enableStencil, mask3DTiles) {
  const stencilFunction = mask3DTiles ? StencilFunction_default.EQUAL : StencilFunction_default.ALWAYS;
  return {
    colorMask: {
      red: false,
      green: false,
      blue: false,
      alpha: false
    },
    stencilTest: {
      enabled: enableStencil,
      frontFunction: stencilFunction,
      frontOperation: {
        fail: StencilOperation_default.KEEP,
        zFail: StencilOperation_default.DECREMENT_WRAP,
        zPass: StencilOperation_default.KEEP
      },
      backFunction: stencilFunction,
      backOperation: {
        fail: StencilOperation_default.KEEP,
        zFail: StencilOperation_default.INCREMENT_WRAP,
        zPass: StencilOperation_default.KEEP
      },
      reference: StencilConstants_default.CESIUM_3D_TILE_MASK,
      mask: StencilConstants_default.CESIUM_3D_TILE_MASK
    },
    stencilMask: StencilConstants_default.CLASSIFICATION_MASK,
    depthTest: {
      enabled: true,
      func: DepthFunction_default.LESS_OR_EQUAL
    },
    depthMask: false
  };
}
function getColorRenderState(enableStencil) {
  return {
    stencilTest: {
      enabled: enableStencil,
      frontFunction: StencilFunction_default.NOT_EQUAL,
      frontOperation: {
        fail: StencilOperation_default.ZERO,
        zFail: StencilOperation_default.ZERO,
        zPass: StencilOperation_default.ZERO
      },
      backFunction: StencilFunction_default.NOT_EQUAL,
      backOperation: {
        fail: StencilOperation_default.ZERO,
        zFail: StencilOperation_default.ZERO,
        zPass: StencilOperation_default.ZERO
      },
      reference: 0,
      mask: StencilConstants_default.CLASSIFICATION_MASK
    },
    stencilMask: StencilConstants_default.CLASSIFICATION_MASK,
    depthTest: {
      enabled: false
    },
    depthMask: false,
    blending: BlendingState_default.PRE_MULTIPLIED_ALPHA_BLEND
  };
}
var pickRenderState = {
  stencilTest: {
    enabled: true,
    frontFunction: StencilFunction_default.NOT_EQUAL,
    frontOperation: {
      fail: StencilOperation_default.ZERO,
      zFail: StencilOperation_default.ZERO,
      zPass: StencilOperation_default.ZERO
    },
    backFunction: StencilFunction_default.NOT_EQUAL,
    backOperation: {
      fail: StencilOperation_default.ZERO,
      zFail: StencilOperation_default.ZERO,
      zPass: StencilOperation_default.ZERO
    },
    reference: 0,
    mask: StencilConstants_default.CLASSIFICATION_MASK
  },
  stencilMask: StencilConstants_default.CLASSIFICATION_MASK,
  depthTest: {
    enabled: false
  },
  depthMask: false
};
function createRenderStates2(classificationPrimitive, context, appearance, twoPasses) {
  if (defined_default(classificationPrimitive._rsStencilDepthPass)) {
    return;
  }
  const stencilEnabled = !classificationPrimitive.debugShowShadowVolume;
  classificationPrimitive._rsStencilDepthPass = RenderState_default.fromCache(
    getStencilDepthRenderState(stencilEnabled, false)
  );
  classificationPrimitive._rsStencilDepthPass3DTiles = RenderState_default.fromCache(
    getStencilDepthRenderState(stencilEnabled, true)
  );
  classificationPrimitive._rsColorPass = RenderState_default.fromCache(
    getColorRenderState(stencilEnabled, false)
  );
  classificationPrimitive._rsPickPass = RenderState_default.fromCache(pickRenderState);
}
function modifyForEncodedNormals2(primitive, vertexShaderSource) {
  if (!primitive.compressVertices) {
    return vertexShaderSource;
  }
  if (vertexShaderSource.search(/attribute\s+vec3\s+extrudeDirection;/g) !== -1) {
    const attributeName = "compressedAttributes";
    const attributeDecl = `attribute vec2 ${attributeName};`;
    const globalDecl = "vec3 extrudeDirection;\n";
    const decode = `    extrudeDirection = czm_octDecode(${attributeName}, 65535.0);
`;
    let modifiedVS = vertexShaderSource;
    modifiedVS = modifiedVS.replace(
      /attribute\s+vec3\s+extrudeDirection;/g,
      ""
    );
    modifiedVS = ShaderSource_default.replaceMain(
      modifiedVS,
      "czm_non_compressed_main"
    );
    const compressedMain = `${"void main() \n{ \n"}${decode}    czm_non_compressed_main(); 
}`;
    return [attributeDecl, globalDecl, modifiedVS, compressedMain].join("\n");
  }
}
function createShaderProgram2(classificationPrimitive, frameState) {
  const context = frameState.context;
  const primitive = classificationPrimitive._primitive;
  let vs = ShadowVolumeAppearanceVS_default;
  vs = classificationPrimitive._primitive._batchTable.getVertexShaderCallback()(
    vs
  );
  vs = Primitive_default._appendDistanceDisplayConditionToShader(primitive, vs);
  vs = Primitive_default._modifyShaderPosition(
    classificationPrimitive,
    vs,
    frameState.scene3DOnly
  );
  vs = Primitive_default._updateColorAttribute(primitive, vs);
  const planarExtents = classificationPrimitive._hasPlanarExtentsAttributes;
  const cullFragmentsUsingExtents = planarExtents || classificationPrimitive._hasSphericalExtentsAttribute;
  if (classificationPrimitive._extruded) {
    vs = modifyForEncodedNormals2(primitive, vs);
  }
  const extrudedDefine = classificationPrimitive._extruded ? "EXTRUDED_GEOMETRY" : "";
  let vsSource = new ShaderSource_default({
    defines: [extrudedDefine],
    sources: [vs]
  });
  const fsSource = new ShaderSource_default({
    sources: [ShadowVolumeFS_default]
  });
  const attributeLocations8 = classificationPrimitive._primitive._attributeLocations;
  const shadowVolumeAppearance = new ShadowVolumeAppearance_default(
    cullFragmentsUsingExtents,
    planarExtents,
    classificationPrimitive.appearance
  );
  classificationPrimitive._spStencil = ShaderProgram_default.replaceCache({
    context,
    shaderProgram: classificationPrimitive._spStencil,
    vertexShaderSource: vsSource,
    fragmentShaderSource: fsSource,
    attributeLocations: attributeLocations8
  });
  if (classificationPrimitive._primitive.allowPicking) {
    let vsPick = ShaderSource_default.createPickVertexShaderSource(vs);
    vsPick = Primitive_default._appendShowToShader(primitive, vsPick);
    vsPick = Primitive_default._updatePickColorAttribute(vsPick);
    const pickFS3D = shadowVolumeAppearance.createPickFragmentShader(false);
    const pickVS3D = shadowVolumeAppearance.createPickVertexShader(
      [extrudedDefine],
      vsPick,
      false,
      frameState.mapProjection
    );
    classificationPrimitive._spPick = ShaderProgram_default.replaceCache({
      context,
      shaderProgram: classificationPrimitive._spPick,
      vertexShaderSource: pickVS3D,
      fragmentShaderSource: pickFS3D,
      attributeLocations: attributeLocations8
    });
    if (cullFragmentsUsingExtents) {
      let pickProgram2D = context.shaderCache.getDerivedShaderProgram(
        classificationPrimitive._spPick,
        "2dPick"
      );
      if (!defined_default(pickProgram2D)) {
        const pickFS2D = shadowVolumeAppearance.createPickFragmentShader(true);
        const pickVS2D = shadowVolumeAppearance.createPickVertexShader(
          [extrudedDefine],
          vsPick,
          true,
          frameState.mapProjection
        );
        pickProgram2D = context.shaderCache.createDerivedShaderProgram(
          classificationPrimitive._spPick,
          "2dPick",
          {
            vertexShaderSource: pickVS2D,
            fragmentShaderSource: pickFS2D,
            attributeLocations: attributeLocations8
          }
        );
      }
      classificationPrimitive._spPick2D = pickProgram2D;
    }
  } else {
    classificationPrimitive._spPick = ShaderProgram_default.fromCache({
      context,
      vertexShaderSource: vsSource,
      fragmentShaderSource: fsSource,
      attributeLocations: attributeLocations8
    });
  }
  vs = Primitive_default._appendShowToShader(primitive, vs);
  vsSource = new ShaderSource_default({
    defines: [extrudedDefine],
    sources: [vs]
  });
  classificationPrimitive._sp = ShaderProgram_default.replaceCache({
    context,
    shaderProgram: classificationPrimitive._sp,
    vertexShaderSource: vsSource,
    fragmentShaderSource: fsSource,
    attributeLocations: attributeLocations8
  });
  const fsColorSource = shadowVolumeAppearance.createFragmentShader(false);
  const vsColorSource = shadowVolumeAppearance.createVertexShader(
    [extrudedDefine],
    vs,
    false,
    frameState.mapProjection
  );
  classificationPrimitive._spColor = ShaderProgram_default.replaceCache({
    context,
    shaderProgram: classificationPrimitive._spColor,
    vertexShaderSource: vsColorSource,
    fragmentShaderSource: fsColorSource,
    attributeLocations: attributeLocations8
  });
  if (cullFragmentsUsingExtents) {
    let colorProgram2D = context.shaderCache.getDerivedShaderProgram(
      classificationPrimitive._spColor,
      "2dColor"
    );
    if (!defined_default(colorProgram2D)) {
      const fsColorSource2D = shadowVolumeAppearance.createFragmentShader(true);
      const vsColorSource2D = shadowVolumeAppearance.createVertexShader(
        [extrudedDefine],
        vs,
        true,
        frameState.mapProjection
      );
      colorProgram2D = context.shaderCache.createDerivedShaderProgram(
        classificationPrimitive._spColor,
        "2dColor",
        {
          vertexShaderSource: vsColorSource2D,
          fragmentShaderSource: fsColorSource2D,
          attributeLocations: attributeLocations8
        }
      );
    }
    classificationPrimitive._spColor2D = colorProgram2D;
  }
}
function createColorCommands(classificationPrimitive, colorCommands) {
  const primitive = classificationPrimitive._primitive;
  let length3 = primitive._va.length * 2;
  colorCommands.length = length3;
  let i2;
  let command;
  let derivedCommand;
  let vaIndex = 0;
  let uniformMap2 = primitive._batchTable.getUniformMapCallback()(
    classificationPrimitive._uniformMap
  );
  const needs2DShader = classificationPrimitive._needs2DShader;
  for (i2 = 0; i2 < length3; i2 += 2) {
    const vertexArray = primitive._va[vaIndex++];
    command = colorCommands[i2];
    if (!defined_default(command)) {
      command = colorCommands[i2] = new DrawCommand_default({
        owner: classificationPrimitive,
        primitiveType: primitive._primitiveType
      });
    }
    command.vertexArray = vertexArray;
    command.renderState = classificationPrimitive._rsStencilDepthPass;
    command.shaderProgram = classificationPrimitive._sp;
    command.uniformMap = uniformMap2;
    command.pass = Pass_default.TERRAIN_CLASSIFICATION;
    derivedCommand = DrawCommand_default.shallowClone(
      command,
      command.derivedCommands.tileset
    );
    derivedCommand.renderState = classificationPrimitive._rsStencilDepthPass3DTiles;
    derivedCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    command.derivedCommands.tileset = derivedCommand;
    command = colorCommands[i2 + 1];
    if (!defined_default(command)) {
      command = colorCommands[i2 + 1] = new DrawCommand_default({
        owner: classificationPrimitive,
        primitiveType: primitive._primitiveType
      });
    }
    command.vertexArray = vertexArray;
    command.renderState = classificationPrimitive._rsColorPass;
    command.shaderProgram = classificationPrimitive._spColor;
    command.pass = Pass_default.TERRAIN_CLASSIFICATION;
    const appearance = classificationPrimitive.appearance;
    const material = appearance.material;
    if (defined_default(material)) {
      uniformMap2 = combine_default(uniformMap2, material._uniforms);
    }
    command.uniformMap = uniformMap2;
    derivedCommand = DrawCommand_default.shallowClone(
      command,
      command.derivedCommands.tileset
    );
    derivedCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    command.derivedCommands.tileset = derivedCommand;
    if (needs2DShader) {
      let derived2DCommand = DrawCommand_default.shallowClone(
        command,
        command.derivedCommands.appearance2D
      );
      derived2DCommand.shaderProgram = classificationPrimitive._spColor2D;
      command.derivedCommands.appearance2D = derived2DCommand;
      derived2DCommand = DrawCommand_default.shallowClone(
        derivedCommand,
        derivedCommand.derivedCommands.appearance2D
      );
      derived2DCommand.shaderProgram = classificationPrimitive._spColor2D;
      derivedCommand.derivedCommands.appearance2D = derived2DCommand;
    }
  }
  const commandsIgnoreShow = classificationPrimitive._commandsIgnoreShow;
  const spStencil = classificationPrimitive._spStencil;
  let commandIndex = 0;
  length3 = commandsIgnoreShow.length = length3 / 2;
  for (let j = 0; j < length3; ++j) {
    const commandIgnoreShow = commandsIgnoreShow[j] = DrawCommand_default.shallowClone(
      colorCommands[commandIndex],
      commandsIgnoreShow[j]
    );
    commandIgnoreShow.shaderProgram = spStencil;
    commandIgnoreShow.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW;
    commandIndex += 2;
  }
}
function createPickCommands(classificationPrimitive, pickCommands) {
  const usePickOffsets = classificationPrimitive._usePickOffsets;
  const primitive = classificationPrimitive._primitive;
  let length3 = primitive._va.length * 2;
  let pickOffsets;
  let pickIndex = 0;
  let pickOffset;
  if (usePickOffsets) {
    pickOffsets = primitive._pickOffsets;
    length3 = pickOffsets.length * 2;
  }
  pickCommands.length = length3;
  let j;
  let command;
  let derivedCommand;
  let vaIndex = 0;
  const uniformMap2 = primitive._batchTable.getUniformMapCallback()(
    classificationPrimitive._uniformMap
  );
  const needs2DShader = classificationPrimitive._needs2DShader;
  for (j = 0; j < length3; j += 2) {
    let vertexArray = primitive._va[vaIndex++];
    if (usePickOffsets) {
      pickOffset = pickOffsets[pickIndex++];
      vertexArray = primitive._va[pickOffset.index];
    }
    command = pickCommands[j];
    if (!defined_default(command)) {
      command = pickCommands[j] = new DrawCommand_default({
        owner: classificationPrimitive,
        primitiveType: primitive._primitiveType,
        pickOnly: true
      });
    }
    command.vertexArray = vertexArray;
    command.renderState = classificationPrimitive._rsStencilDepthPass;
    command.shaderProgram = classificationPrimitive._sp;
    command.uniformMap = uniformMap2;
    command.pass = Pass_default.TERRAIN_CLASSIFICATION;
    if (usePickOffsets) {
      command.offset = pickOffset.offset;
      command.count = pickOffset.count;
    }
    derivedCommand = DrawCommand_default.shallowClone(
      command,
      command.derivedCommands.tileset
    );
    derivedCommand.renderState = classificationPrimitive._rsStencilDepthPass3DTiles;
    derivedCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    command.derivedCommands.tileset = derivedCommand;
    command = pickCommands[j + 1];
    if (!defined_default(command)) {
      command = pickCommands[j + 1] = new DrawCommand_default({
        owner: classificationPrimitive,
        primitiveType: primitive._primitiveType,
        pickOnly: true
      });
    }
    command.vertexArray = vertexArray;
    command.renderState = classificationPrimitive._rsPickPass;
    command.shaderProgram = classificationPrimitive._spPick;
    command.uniformMap = uniformMap2;
    command.pass = Pass_default.TERRAIN_CLASSIFICATION;
    if (usePickOffsets) {
      command.offset = pickOffset.offset;
      command.count = pickOffset.count;
    }
    derivedCommand = DrawCommand_default.shallowClone(
      command,
      command.derivedCommands.tileset
    );
    derivedCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    command.derivedCommands.tileset = derivedCommand;
    if (needs2DShader) {
      let derived2DCommand = DrawCommand_default.shallowClone(
        command,
        command.derivedCommands.pick2D
      );
      derived2DCommand.shaderProgram = classificationPrimitive._spPick2D;
      command.derivedCommands.pick2D = derived2DCommand;
      derived2DCommand = DrawCommand_default.shallowClone(
        derivedCommand,
        derivedCommand.derivedCommands.pick2D
      );
      derived2DCommand.shaderProgram = classificationPrimitive._spPick2D;
      derivedCommand.derivedCommands.pick2D = derived2DCommand;
    }
  }
}
function createCommands2(classificationPrimitive, appearance, material, translucent, twoPasses, colorCommands, pickCommands) {
  createColorCommands(classificationPrimitive, colorCommands);
  createPickCommands(classificationPrimitive, pickCommands);
}
function boundingVolumeIndex(commandIndex, length3) {
  return Math.floor(commandIndex % length3 / 2);
}
function updateAndQueueRenderCommand(command, frameState, modelMatrix, cull, boundingVolume, debugShowBoundingVolume2) {
  command.modelMatrix = modelMatrix;
  command.boundingVolume = boundingVolume;
  command.cull = cull;
  command.debugShowBoundingVolume = debugShowBoundingVolume2;
  frameState.commandList.push(command);
}
function updateAndQueuePickCommand(command, frameState, modelMatrix, cull, boundingVolume) {
  command.modelMatrix = modelMatrix;
  command.boundingVolume = boundingVolume;
  command.cull = cull;
  frameState.commandList.push(command);
}
function updateAndQueueCommands2(classificationPrimitive, frameState, colorCommands, pickCommands, modelMatrix, cull, debugShowBoundingVolume2, twoPasses) {
  const primitive = classificationPrimitive._primitive;
  Primitive_default._updateBoundingVolumes(primitive, frameState, modelMatrix);
  let boundingVolumes;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    boundingVolumes = primitive._boundingSphereWC;
  } else if (frameState.mode === SceneMode_default.COLUMBUS_VIEW) {
    boundingVolumes = primitive._boundingSphereCV;
  } else if (frameState.mode === SceneMode_default.SCENE2D && defined_default(primitive._boundingSphere2D)) {
    boundingVolumes = primitive._boundingSphere2D;
  } else if (defined_default(primitive._boundingSphereMorph)) {
    boundingVolumes = primitive._boundingSphereMorph;
  }
  const classificationType = classificationPrimitive.classificationType;
  const queueTerrainCommands = classificationType !== ClassificationType_default.CESIUM_3D_TILE;
  const queue3DTilesCommands = classificationType !== ClassificationType_default.TERRAIN;
  const passes = frameState.passes;
  let i2;
  let boundingVolume;
  let command;
  if (passes.render) {
    const colorLength = colorCommands.length;
    for (i2 = 0; i2 < colorLength; ++i2) {
      boundingVolume = boundingVolumes[boundingVolumeIndex(i2, colorLength)];
      if (queueTerrainCommands) {
        command = colorCommands[i2];
        updateAndQueueRenderCommand(
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume,
          debugShowBoundingVolume2
        );
      }
      if (queue3DTilesCommands) {
        command = colorCommands[i2].derivedCommands.tileset;
        updateAndQueueRenderCommand(
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume,
          debugShowBoundingVolume2
        );
      }
    }
    if (frameState.invertClassification) {
      const ignoreShowCommands = classificationPrimitive._commandsIgnoreShow;
      const ignoreShowCommandsLength = ignoreShowCommands.length;
      for (i2 = 0; i2 < ignoreShowCommandsLength; ++i2) {
        boundingVolume = boundingVolumes[i2];
        command = ignoreShowCommands[i2];
        updateAndQueueRenderCommand(
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume,
          debugShowBoundingVolume2
        );
      }
    }
  }
  if (passes.pick) {
    const pickLength = pickCommands.length;
    const pickOffsets = primitive._pickOffsets;
    for (i2 = 0; i2 < pickLength; ++i2) {
      const pickOffset = pickOffsets[boundingVolumeIndex(i2, pickLength)];
      boundingVolume = boundingVolumes[pickOffset.index];
      if (queueTerrainCommands) {
        command = pickCommands[i2];
        updateAndQueuePickCommand(
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume
        );
      }
      if (queue3DTilesCommands) {
        command = pickCommands[i2].derivedCommands.tileset;
        updateAndQueuePickCommand(
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume
        );
      }
    }
  }
}
ClassificationPrimitive.prototype.update = function(frameState) {
  if (!defined_default(this._primitive) && !defined_default(this.geometryInstances)) {
    return;
  }
  let appearance = this.appearance;
  if (defined_default(appearance) && defined_default(appearance.material)) {
    appearance.material.update(frameState.context);
  }
  const that = this;
  const primitiveOptions = this._primitiveOptions;
  if (!defined_default(this._primitive)) {
    const instances = Array.isArray(this.geometryInstances) ? this.geometryInstances : [this.geometryInstances];
    const length3 = instances.length;
    let i2;
    let instance;
    let attributes;
    let hasPerColorAttribute = false;
    let allColorsSame = true;
    let firstColor;
    let hasSphericalExtentsAttribute = false;
    let hasPlanarExtentsAttributes = false;
    if (length3 > 0) {
      attributes = instances[0].attributes;
      hasSphericalExtentsAttribute = ShadowVolumeAppearance_default.hasAttributesForSphericalExtents(
        attributes
      );
      hasPlanarExtentsAttributes = ShadowVolumeAppearance_default.hasAttributesForTextureCoordinatePlanes(
        attributes
      );
      firstColor = attributes.color;
    }
    for (i2 = 0; i2 < length3; i2++) {
      instance = instances[i2];
      const color = instance.attributes.color;
      if (defined_default(color)) {
        hasPerColorAttribute = true;
      } else if (hasPerColorAttribute) {
        throw new DeveloperError_default(
          "All GeometryInstances must have color attributes to use per-instance color."
        );
      }
      allColorsSame = allColorsSame && defined_default(color) && ColorGeometryInstanceAttribute_default.equals(firstColor, color);
    }
    if (!allColorsSame && !hasSphericalExtentsAttribute && !hasPlanarExtentsAttributes) {
      throw new DeveloperError_default(
        "All GeometryInstances must have the same color attribute except via GroundPrimitives"
      );
    }
    if (hasPerColorAttribute && !defined_default(appearance)) {
      appearance = new PerInstanceColorAppearance_default({
        flat: true
      });
      this.appearance = appearance;
    }
    if (!hasPerColorAttribute && appearance instanceof PerInstanceColorAppearance_default) {
      throw new DeveloperError_default(
        "PerInstanceColorAppearance requires color GeometryInstanceAttributes on all GeometryInstances"
      );
    }
    if (defined_default(appearance.material) && !hasSphericalExtentsAttribute && !hasPlanarExtentsAttributes) {
      throw new DeveloperError_default(
        "Materials on ClassificationPrimitives are not supported except via GroundPrimitives"
      );
    }
    this._usePickOffsets = !hasSphericalExtentsAttribute && !hasPlanarExtentsAttributes;
    this._hasSphericalExtentsAttribute = hasSphericalExtentsAttribute;
    this._hasPlanarExtentsAttributes = hasPlanarExtentsAttributes;
    this._hasPerColorAttribute = hasPerColorAttribute;
    const geometryInstances = new Array(length3);
    for (i2 = 0; i2 < length3; ++i2) {
      instance = instances[i2];
      geometryInstances[i2] = new GeometryInstance_default({
        geometry: instance.geometry,
        attributes: instance.attributes,
        modelMatrix: instance.modelMatrix,
        id: instance.id,
        pickPrimitive: defaultValue_default(this._pickPrimitive, that)
      });
    }
    primitiveOptions.appearance = appearance;
    primitiveOptions.geometryInstances = geometryInstances;
    if (defined_default(this._createBoundingVolumeFunction)) {
      primitiveOptions._createBoundingVolumeFunction = function(frameState2, geometry) {
        that._createBoundingVolumeFunction(frameState2, geometry);
      };
    }
    primitiveOptions._createRenderStatesFunction = function(primitive, context, appearance2, twoPasses) {
      createRenderStates2(that, context);
    };
    primitiveOptions._createShaderProgramFunction = function(primitive, frameState2, appearance2) {
      createShaderProgram2(that, frameState2);
    };
    primitiveOptions._createCommandsFunction = function(primitive, appearance2, material, translucent, twoPasses, colorCommands, pickCommands) {
      createCommands2(
        that,
        void 0,
        void 0,
        true,
        false,
        colorCommands,
        pickCommands
      );
    };
    if (defined_default(this._updateAndQueueCommandsFunction)) {
      primitiveOptions._updateAndQueueCommandsFunction = function(primitive, frameState2, colorCommands, pickCommands, modelMatrix, cull, debugShowBoundingVolume2, twoPasses) {
        that._updateAndQueueCommandsFunction(
          primitive,
          frameState2,
          colorCommands,
          pickCommands,
          modelMatrix,
          cull,
          debugShowBoundingVolume2,
          twoPasses
        );
      };
    } else {
      primitiveOptions._updateAndQueueCommandsFunction = function(primitive, frameState2, colorCommands, pickCommands, modelMatrix, cull, debugShowBoundingVolume2, twoPasses) {
        updateAndQueueCommands2(
          that,
          frameState2,
          colorCommands,
          pickCommands,
          modelMatrix,
          cull,
          debugShowBoundingVolume2,
          twoPasses
        );
      };
    }
    this._primitive = new Primitive_default(primitiveOptions);
    this._primitive.readyPromise.then(function(primitive) {
      that._ready = true;
      if (that.releaseGeometryInstances) {
        that.geometryInstances = void 0;
      }
      const error = primitive._error;
      if (!defined_default(error)) {
        that._readyPromise.resolve(that);
      } else {
        that._readyPromise.reject(error);
      }
    });
  }
  if (this.debugShowShadowVolume && !this._debugShowShadowVolume && this._ready) {
    this._debugShowShadowVolume = true;
    this._rsStencilDepthPass = RenderState_default.fromCache(
      getStencilDepthRenderState(false, false)
    );
    this._rsStencilDepthPass3DTiles = RenderState_default.fromCache(
      getStencilDepthRenderState(false, true)
    );
    this._rsColorPass = RenderState_default.fromCache(getColorRenderState(false));
  } else if (!this.debugShowShadowVolume && this._debugShowShadowVolume) {
    this._debugShowShadowVolume = false;
    this._rsStencilDepthPass = RenderState_default.fromCache(
      getStencilDepthRenderState(true, false)
    );
    this._rsStencilDepthPass3DTiles = RenderState_default.fromCache(
      getStencilDepthRenderState(true, true)
    );
    this._rsColorPass = RenderState_default.fromCache(getColorRenderState(true));
  }
  if (this._primitive.appearance !== appearance) {
    if (!this._hasSphericalExtentsAttribute && !this._hasPlanarExtentsAttributes && defined_default(appearance.material)) {
      throw new DeveloperError_default(
        "Materials on ClassificationPrimitives are not supported except via GroundPrimitive"
      );
    }
    if (!this._hasPerColorAttribute && appearance instanceof PerInstanceColorAppearance_default) {
      throw new DeveloperError_default(
        "PerInstanceColorAppearance requires color GeometryInstanceAttribute"
      );
    }
    this._primitive.appearance = appearance;
  }
  this._primitive.show = this.show;
  this._primitive.debugShowBoundingVolume = this.debugShowBoundingVolume;
  this._primitive.update(frameState);
};
ClassificationPrimitive.prototype.getGeometryInstanceAttributes = function(id) {
  if (!defined_default(this._primitive)) {
    throw new DeveloperError_default(
      "must call update before calling getGeometryInstanceAttributes"
    );
  }
  return this._primitive.getGeometryInstanceAttributes(id);
};
ClassificationPrimitive.prototype.isDestroyed = function() {
  return false;
};
ClassificationPrimitive.prototype.destroy = function() {
  this._primitive = this._primitive && this._primitive.destroy();
  this._sp = this._sp && this._sp.destroy();
  this._spPick = this._spPick && this._spPick.destroy();
  this._spColor = this._spColor && this._spColor.destroy();
  this._spPick2D = void 0;
  this._spColor2D = void 0;
  return destroyObject_default(this);
};
var ClassificationPrimitive_default = ClassificationPrimitive;

// node_modules/cesium/Source/Scene/GroundPrimitive.js
var GroundPrimitiveUniformMap = {
  u_globeMinimumAltitude: function() {
    return 55e3;
  }
};
function GroundPrimitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let appearance = options.appearance;
  const geometryInstances = options.geometryInstances;
  if (!defined_default(appearance) && defined_default(geometryInstances)) {
    const geometryInstancesArray = Array.isArray(geometryInstances) ? geometryInstances : [geometryInstances];
    const geometryInstanceCount = geometryInstancesArray.length;
    for (let i2 = 0; i2 < geometryInstanceCount; i2++) {
      const attributes = geometryInstancesArray[i2].attributes;
      if (defined_default(attributes) && defined_default(attributes.color)) {
        appearance = new PerInstanceColorAppearance_default({
          flat: true
        });
        break;
      }
    }
  }
  this.appearance = appearance;
  this.geometryInstances = options.geometryInstances;
  this.show = defaultValue_default(options.show, true);
  this.classificationType = defaultValue_default(
    options.classificationType,
    ClassificationType_default.BOTH
  );
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this.debugShowShadowVolume = defaultValue_default(
    options.debugShowShadowVolume,
    false
  );
  this._boundingVolumes = [];
  this._boundingVolumes2D = [];
  this._ready = false;
  this._readyPromise = defer_default();
  this._primitive = void 0;
  this._maxHeight = void 0;
  this._minHeight = void 0;
  this._maxTerrainHeight = ApproximateTerrainHeights_default._defaultMaxTerrainHeight;
  this._minTerrainHeight = ApproximateTerrainHeights_default._defaultMinTerrainHeight;
  this._boundingSpheresKeys = [];
  this._boundingSpheres = [];
  this._useFragmentCulling = false;
  this._zIndex = void 0;
  const that = this;
  this._classificationPrimitiveOptions = {
    geometryInstances: void 0,
    appearance: void 0,
    vertexCacheOptimize: defaultValue_default(options.vertexCacheOptimize, false),
    interleave: defaultValue_default(options.interleave, false),
    releaseGeometryInstances: defaultValue_default(
      options.releaseGeometryInstances,
      true
    ),
    allowPicking: defaultValue_default(options.allowPicking, true),
    asynchronous: defaultValue_default(options.asynchronous, true),
    compressVertices: defaultValue_default(options.compressVertices, true),
    _createBoundingVolumeFunction: void 0,
    _updateAndQueueCommandsFunction: void 0,
    _pickPrimitive: that,
    _extruded: true,
    _uniformMap: GroundPrimitiveUniformMap
  };
}
Object.defineProperties(GroundPrimitive.prototype, {
  vertexCacheOptimize: {
    get: function() {
      return this._classificationPrimitiveOptions.vertexCacheOptimize;
    }
  },
  interleave: {
    get: function() {
      return this._classificationPrimitiveOptions.interleave;
    }
  },
  releaseGeometryInstances: {
    get: function() {
      return this._classificationPrimitiveOptions.releaseGeometryInstances;
    }
  },
  allowPicking: {
    get: function() {
      return this._classificationPrimitiveOptions.allowPicking;
    }
  },
  asynchronous: {
    get: function() {
      return this._classificationPrimitiveOptions.asynchronous;
    }
  },
  compressVertices: {
    get: function() {
      return this._classificationPrimitiveOptions.compressVertices;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  }
});
GroundPrimitive.isSupported = ClassificationPrimitive_default.isSupported;
function getComputeMaximumHeightFunction(primitive) {
  return function(granularity, ellipsoid) {
    const r2 = ellipsoid.maximumRadius;
    const delta = r2 / Math.cos(granularity * 0.5) - r2;
    return primitive._maxHeight + delta;
  };
}
function getComputeMinimumHeightFunction(primitive) {
  return function(granularity, ellipsoid) {
    return primitive._minHeight;
  };
}
var scratchBVCartesianHigh = new Cartesian3_default();
var scratchBVCartesianLow = new Cartesian3_default();
var scratchBVCartesian = new Cartesian3_default();
var scratchBVCartographic2 = new Cartographic_default();
var scratchBVRectangle = new Rectangle_default();
function getRectangle(frameState, geometry) {
  const ellipsoid = frameState.mapProjection.ellipsoid;
  if (!defined_default(geometry.attributes) || !defined_default(geometry.attributes.position3DHigh)) {
    if (defined_default(geometry.rectangle)) {
      return geometry.rectangle;
    }
    return void 0;
  }
  const highPositions = geometry.attributes.position3DHigh.values;
  const lowPositions = geometry.attributes.position3DLow.values;
  const length3 = highPositions.length;
  let minLat = Number.POSITIVE_INFINITY;
  let minLon = Number.POSITIVE_INFINITY;
  let maxLat = Number.NEGATIVE_INFINITY;
  let maxLon = Number.NEGATIVE_INFINITY;
  for (let i2 = 0; i2 < length3; i2 += 3) {
    const highPosition = Cartesian3_default.unpack(
      highPositions,
      i2,
      scratchBVCartesianHigh
    );
    const lowPosition = Cartesian3_default.unpack(
      lowPositions,
      i2,
      scratchBVCartesianLow
    );
    const position = Cartesian3_default.add(
      highPosition,
      lowPosition,
      scratchBVCartesian
    );
    const cartographic2 = ellipsoid.cartesianToCartographic(
      position,
      scratchBVCartographic2
    );
    const latitude = cartographic2.latitude;
    const longitude = cartographic2.longitude;
    minLat = Math.min(minLat, latitude);
    minLon = Math.min(minLon, longitude);
    maxLat = Math.max(maxLat, latitude);
    maxLon = Math.max(maxLon, longitude);
  }
  const rectangle = scratchBVRectangle;
  rectangle.north = maxLat;
  rectangle.south = minLat;
  rectangle.east = maxLon;
  rectangle.west = minLon;
  return rectangle;
}
function setMinMaxTerrainHeights(primitive, rectangle, ellipsoid) {
  const result = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
    rectangle,
    ellipsoid
  );
  primitive._minTerrainHeight = result.minimumTerrainHeight;
  primitive._maxTerrainHeight = result.maximumTerrainHeight;
}
function createBoundingVolume(groundPrimitive, frameState, geometry) {
  const ellipsoid = frameState.mapProjection.ellipsoid;
  const rectangle = getRectangle(frameState, geometry);
  const obb = OrientedBoundingBox_default.fromRectangle(
    rectangle,
    groundPrimitive._minHeight,
    groundPrimitive._maxHeight,
    ellipsoid
  );
  groundPrimitive._boundingVolumes.push(obb);
  if (!frameState.scene3DOnly) {
    const projection = frameState.mapProjection;
    const boundingVolume = BoundingSphere_default.fromRectangleWithHeights2D(
      rectangle,
      projection,
      groundPrimitive._maxHeight,
      groundPrimitive._minHeight
    );
    Cartesian3_default.fromElements(
      boundingVolume.center.z,
      boundingVolume.center.x,
      boundingVolume.center.y,
      boundingVolume.center
    );
    groundPrimitive._boundingVolumes2D.push(boundingVolume);
  }
}
function boundingVolumeIndex2(commandIndex, length3) {
  return Math.floor(commandIndex % length3 / 2);
}
function updateAndQueueRenderCommand2(groundPrimitive, command, frameState, modelMatrix, cull, boundingVolume, debugShowBoundingVolume2) {
  const classificationPrimitive = groundPrimitive._primitive;
  if (frameState.mode !== SceneMode_default.SCENE3D && command.shaderProgram === classificationPrimitive._spColor && classificationPrimitive._needs2DShader) {
    command = command.derivedCommands.appearance2D;
  }
  command.owner = groundPrimitive;
  command.modelMatrix = modelMatrix;
  command.boundingVolume = boundingVolume;
  command.cull = cull;
  command.debugShowBoundingVolume = debugShowBoundingVolume2;
  frameState.commandList.push(command);
}
function updateAndQueuePickCommand2(groundPrimitive, command, frameState, modelMatrix, cull, boundingVolume) {
  const classificationPrimitive = groundPrimitive._primitive;
  if (frameState.mode !== SceneMode_default.SCENE3D && command.shaderProgram === classificationPrimitive._spPick && classificationPrimitive._needs2DShader) {
    command = command.derivedCommands.pick2D;
  }
  command.owner = groundPrimitive;
  command.modelMatrix = modelMatrix;
  command.boundingVolume = boundingVolume;
  command.cull = cull;
  frameState.commandList.push(command);
}
function updateAndQueueCommands3(groundPrimitive, frameState, colorCommands, pickCommands, modelMatrix, cull, debugShowBoundingVolume2, twoPasses) {
  let boundingVolumes;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    boundingVolumes = groundPrimitive._boundingVolumes;
  } else {
    boundingVolumes = groundPrimitive._boundingVolumes2D;
  }
  const classificationType = groundPrimitive.classificationType;
  const queueTerrainCommands = classificationType !== ClassificationType_default.CESIUM_3D_TILE;
  const queue3DTilesCommands = classificationType !== ClassificationType_default.TERRAIN;
  const passes = frameState.passes;
  const classificationPrimitive = groundPrimitive._primitive;
  let i2;
  let boundingVolume;
  let command;
  if (passes.render) {
    const colorLength = colorCommands.length;
    for (i2 = 0; i2 < colorLength; ++i2) {
      boundingVolume = boundingVolumes[boundingVolumeIndex2(i2, colorLength)];
      if (queueTerrainCommands) {
        command = colorCommands[i2];
        updateAndQueueRenderCommand2(
          groundPrimitive,
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume,
          debugShowBoundingVolume2
        );
      }
      if (queue3DTilesCommands) {
        command = colorCommands[i2].derivedCommands.tileset;
        updateAndQueueRenderCommand2(
          groundPrimitive,
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume,
          debugShowBoundingVolume2
        );
      }
    }
    if (frameState.invertClassification) {
      const ignoreShowCommands = classificationPrimitive._commandsIgnoreShow;
      const ignoreShowCommandsLength = ignoreShowCommands.length;
      for (i2 = 0; i2 < ignoreShowCommandsLength; ++i2) {
        boundingVolume = boundingVolumes[i2];
        command = ignoreShowCommands[i2];
        updateAndQueueRenderCommand2(
          groundPrimitive,
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume,
          debugShowBoundingVolume2
        );
      }
    }
  }
  if (passes.pick) {
    const pickLength = pickCommands.length;
    let pickOffsets;
    if (!groundPrimitive._useFragmentCulling) {
      pickOffsets = classificationPrimitive._primitive._pickOffsets;
    }
    for (i2 = 0; i2 < pickLength; ++i2) {
      boundingVolume = boundingVolumes[boundingVolumeIndex2(i2, pickLength)];
      if (!groundPrimitive._useFragmentCulling) {
        const pickOffset = pickOffsets[boundingVolumeIndex2(i2, pickLength)];
        boundingVolume = boundingVolumes[pickOffset.index];
      }
      if (queueTerrainCommands) {
        command = pickCommands[i2];
        updateAndQueuePickCommand2(
          groundPrimitive,
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume
        );
      }
      if (queue3DTilesCommands) {
        command = pickCommands[i2].derivedCommands.tileset;
        updateAndQueuePickCommand2(
          groundPrimitive,
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume
        );
      }
    }
  }
}
GroundPrimitive.initializeTerrainHeights = function() {
  return ApproximateTerrainHeights_default.initialize();
};
GroundPrimitive.prototype.update = function(frameState) {
  if (!defined_default(this._primitive) && !defined_default(this.geometryInstances)) {
    return;
  }
  if (!ApproximateTerrainHeights_default.initialized) {
    if (!this.asynchronous) {
      throw new DeveloperError_default(
        "For synchronous GroundPrimitives, you must call GroundPrimitive.initializeTerrainHeights() and wait for the returned promise to resolve."
      );
    }
    GroundPrimitive.initializeTerrainHeights();
    return;
  }
  const that = this;
  const primitiveOptions = this._classificationPrimitiveOptions;
  if (!defined_default(this._primitive)) {
    const ellipsoid = frameState.mapProjection.ellipsoid;
    let instance;
    let geometry;
    let instanceType;
    const instances = Array.isArray(this.geometryInstances) ? this.geometryInstances : [this.geometryInstances];
    const length3 = instances.length;
    const groundInstances = new Array(length3);
    let i2;
    let rectangle;
    for (i2 = 0; i2 < length3; ++i2) {
      instance = instances[i2];
      geometry = instance.geometry;
      const instanceRectangle = getRectangle(frameState, geometry);
      if (!defined_default(rectangle)) {
        rectangle = Rectangle_default.clone(instanceRectangle);
      } else if (defined_default(instanceRectangle)) {
        Rectangle_default.union(rectangle, instanceRectangle, rectangle);
      }
      const id = instance.id;
      if (defined_default(id) && defined_default(instanceRectangle)) {
        const boundingSphere = ApproximateTerrainHeights_default.getBoundingSphere(
          instanceRectangle,
          ellipsoid
        );
        this._boundingSpheresKeys.push(id);
        this._boundingSpheres.push(boundingSphere);
      }
      instanceType = geometry.constructor;
      if (!defined_default(instanceType) || !defined_default(instanceType.createShadowVolume)) {
        throw new DeveloperError_default(
          "Not all of the geometry instances have GroundPrimitive support."
        );
      }
    }
    setMinMaxTerrainHeights(this, rectangle, ellipsoid);
    const exaggeration = frameState.terrainExaggeration;
    const exaggerationRelativeHeight = frameState.terrainExaggerationRelativeHeight;
    this._minHeight = TerrainExaggeration_default.getHeight(
      this._minTerrainHeight,
      exaggeration,
      exaggerationRelativeHeight
    );
    this._maxHeight = TerrainExaggeration_default.getHeight(
      this._maxTerrainHeight,
      exaggeration,
      exaggerationRelativeHeight
    );
    const useFragmentCulling = GroundPrimitive._supportsMaterials(
      frameState.context
    );
    this._useFragmentCulling = useFragmentCulling;
    if (useFragmentCulling) {
      let attributes;
      let usePlanarExtents = true;
      for (i2 = 0; i2 < length3; ++i2) {
        instance = instances[i2];
        geometry = instance.geometry;
        rectangle = getRectangle(frameState, geometry);
        if (ShadowVolumeAppearance_default.shouldUseSphericalCoordinates(rectangle)) {
          usePlanarExtents = false;
          break;
        }
      }
      for (i2 = 0; i2 < length3; ++i2) {
        instance = instances[i2];
        geometry = instance.geometry;
        instanceType = geometry.constructor;
        const boundingRectangle = getRectangle(frameState, geometry);
        const textureCoordinateRotationPoints4 = geometry.textureCoordinateRotationPoints;
        if (usePlanarExtents) {
          attributes = ShadowVolumeAppearance_default.getPlanarTextureCoordinateAttributes(
            boundingRectangle,
            textureCoordinateRotationPoints4,
            ellipsoid,
            frameState.mapProjection,
            this._maxHeight
          );
        } else {
          attributes = ShadowVolumeAppearance_default.getSphericalExtentGeometryInstanceAttributes(
            boundingRectangle,
            textureCoordinateRotationPoints4,
            ellipsoid,
            frameState.mapProjection
          );
        }
        const instanceAttributes = instance.attributes;
        for (const attributeKey in instanceAttributes) {
          if (instanceAttributes.hasOwnProperty(attributeKey)) {
            attributes[attributeKey] = instanceAttributes[attributeKey];
          }
        }
        groundInstances[i2] = new GeometryInstance_default({
          geometry: instanceType.createShadowVolume(
            geometry,
            getComputeMinimumHeightFunction(this),
            getComputeMaximumHeightFunction(this)
          ),
          attributes,
          id: instance.id
        });
      }
    } else {
      for (i2 = 0; i2 < length3; ++i2) {
        instance = instances[i2];
        geometry = instance.geometry;
        instanceType = geometry.constructor;
        groundInstances[i2] = new GeometryInstance_default({
          geometry: instanceType.createShadowVolume(
            geometry,
            getComputeMinimumHeightFunction(this),
            getComputeMaximumHeightFunction(this)
          ),
          attributes: instance.attributes,
          id: instance.id
        });
      }
    }
    primitiveOptions.geometryInstances = groundInstances;
    primitiveOptions.appearance = this.appearance;
    primitiveOptions._createBoundingVolumeFunction = function(frameState2, geometry2) {
      createBoundingVolume(that, frameState2, geometry2);
    };
    primitiveOptions._updateAndQueueCommandsFunction = function(primitive, frameState2, colorCommands, pickCommands, modelMatrix, cull, debugShowBoundingVolume2, twoPasses) {
      updateAndQueueCommands3(
        that,
        frameState2,
        colorCommands,
        pickCommands,
        modelMatrix,
        cull,
        debugShowBoundingVolume2,
        twoPasses
      );
    };
    this._primitive = new ClassificationPrimitive_default(primitiveOptions);
    this._primitive.readyPromise.then(function(primitive) {
      that._ready = true;
      if (that.releaseGeometryInstances) {
        that.geometryInstances = void 0;
      }
      const error = primitive._error;
      if (!defined_default(error)) {
        that._readyPromise.resolve(that);
      } else {
        that._readyPromise.reject(error);
      }
    });
  }
  this._primitive.appearance = this.appearance;
  this._primitive.show = this.show;
  this._primitive.debugShowShadowVolume = this.debugShowShadowVolume;
  this._primitive.debugShowBoundingVolume = this.debugShowBoundingVolume;
  this._primitive.update(frameState);
};
GroundPrimitive.prototype.getBoundingSphere = function(id) {
  const index2 = this._boundingSpheresKeys.indexOf(id);
  if (index2 !== -1) {
    return this._boundingSpheres[index2];
  }
  return void 0;
};
GroundPrimitive.prototype.getGeometryInstanceAttributes = function(id) {
  if (!defined_default(this._primitive)) {
    throw new DeveloperError_default(
      "must call update before calling getGeometryInstanceAttributes"
    );
  }
  return this._primitive.getGeometryInstanceAttributes(id);
};
GroundPrimitive.prototype.isDestroyed = function() {
  return false;
};
GroundPrimitive.prototype.destroy = function() {
  this._primitive = this._primitive && this._primitive.destroy();
  return destroyObject_default(this);
};
GroundPrimitive._supportsMaterials = function(context) {
  return context.depthTexture;
};
GroundPrimitive.supportsMaterials = function(scene) {
  Check_default.typeOf.object("scene", scene);
  return GroundPrimitive._supportsMaterials(scene.frameState.context);
};
var GroundPrimitive_default = GroundPrimitive;

// node_modules/cesium/Source/DataSources/MaterialProperty.js
function MaterialProperty() {
  DeveloperError_default.throwInstantiationError();
}
Object.defineProperties(MaterialProperty.prototype, {
  isConstant: {
    get: DeveloperError_default.throwInstantiationError
  },
  definitionChanged: {
    get: DeveloperError_default.throwInstantiationError
  }
});
MaterialProperty.prototype.getType = DeveloperError_default.throwInstantiationError;
MaterialProperty.prototype.getValue = DeveloperError_default.throwInstantiationError;
MaterialProperty.prototype.equals = DeveloperError_default.throwInstantiationError;
MaterialProperty.getValue = function(time, materialProperty, material) {
  let type;
  if (defined_default(materialProperty)) {
    type = materialProperty.getType(time);
    if (defined_default(type)) {
      if (!defined_default(material) || material.type !== type) {
        material = Material_default.fromType(type);
      }
      materialProperty.getValue(time, material.uniforms);
      return material;
    }
  }
  if (!defined_default(material) || material.type !== Material_default.ColorType) {
    material = Material_default.fromType(Material_default.ColorType);
  }
  Color_default.clone(Color_default.WHITE, material.uniforms.color);
  return material;
};
var MaterialProperty_default = MaterialProperty;

// node_modules/cesium/Source/DataSources/DynamicGeometryUpdater.js
function DynamicGeometryUpdater(geometryUpdater, primitives, orderedGroundPrimitives) {
  Check_default.defined("geometryUpdater", geometryUpdater);
  Check_default.defined("primitives", primitives);
  Check_default.defined("orderedGroundPrimitives", orderedGroundPrimitives);
  this._primitives = primitives;
  this._orderedGroundPrimitives = orderedGroundPrimitives;
  this._primitive = void 0;
  this._outlinePrimitive = void 0;
  this._geometryUpdater = geometryUpdater;
  this._options = geometryUpdater._options;
  this._entity = geometryUpdater._entity;
  this._material = void 0;
}
DynamicGeometryUpdater.prototype._isHidden = function(entity, geometry, time) {
  return !entity.isShowing || !entity.isAvailable(time) || !Property_default.getValueOrDefault(geometry.show, time, true);
};
DynamicGeometryUpdater.prototype._setOptions = DeveloperError_default.throwInstantiationError;
DynamicGeometryUpdater.prototype.update = function(time) {
  Check_default.defined("time", time);
  const geometryUpdater = this._geometryUpdater;
  const onTerrain = geometryUpdater._onTerrain;
  const primitives = this._primitives;
  const orderedGroundPrimitives = this._orderedGroundPrimitives;
  if (onTerrain) {
    orderedGroundPrimitives.remove(this._primitive);
  } else {
    primitives.removeAndDestroy(this._primitive);
    primitives.removeAndDestroy(this._outlinePrimitive);
    this._outlinePrimitive = void 0;
  }
  this._primitive = void 0;
  const entity = this._entity;
  const geometry = entity[this._geometryUpdater._geometryPropertyName];
  this._setOptions(entity, geometry, time);
  if (this._isHidden(entity, geometry, time)) {
    return;
  }
  const shadows = this._geometryUpdater.shadowsProperty.getValue(time);
  const options = this._options;
  if (!defined_default(geometry.fill) || geometry.fill.getValue(time)) {
    const fillMaterialProperty = geometryUpdater.fillMaterialProperty;
    const isColorAppearance = fillMaterialProperty instanceof ColorMaterialProperty_default;
    let appearance;
    const closed = geometryUpdater._getIsClosed(options);
    if (isColorAppearance) {
      appearance = new PerInstanceColorAppearance_default({
        closed,
        flat: onTerrain && !geometryUpdater._supportsMaterialsforEntitiesOnTerrain
      });
    } else {
      const material = MaterialProperty_default.getValue(
        time,
        fillMaterialProperty,
        this._material
      );
      this._material = material;
      appearance = new MaterialAppearance_default({
        material,
        translucent: material.isTranslucent(),
        closed
      });
    }
    if (onTerrain) {
      options.vertexFormat = PerInstanceColorAppearance_default.VERTEX_FORMAT;
      this._primitive = orderedGroundPrimitives.add(
        new GroundPrimitive_default({
          geometryInstances: this._geometryUpdater.createFillGeometryInstance(
            time
          ),
          appearance,
          asynchronous: false,
          shadows,
          classificationType: this._geometryUpdater.classificationTypeProperty.getValue(
            time
          )
        }),
        Property_default.getValueOrUndefined(this._geometryUpdater.zIndex, time)
      );
    } else {
      options.vertexFormat = appearance.vertexFormat;
      const fillInstance = this._geometryUpdater.createFillGeometryInstance(
        time
      );
      if (isColorAppearance) {
        appearance.translucent = fillInstance.attributes.color.value[3] !== 255;
      }
      this._primitive = primitives.add(
        new Primitive_default({
          geometryInstances: fillInstance,
          appearance,
          asynchronous: false,
          shadows
        })
      );
    }
  }
  if (!onTerrain && defined_default(geometry.outline) && geometry.outline.getValue(time)) {
    const outlineInstance = this._geometryUpdater.createOutlineGeometryInstance(
      time
    );
    const outlineWidth = Property_default.getValueOrDefault(
      geometry.outlineWidth,
      time,
      1
    );
    this._outlinePrimitive = primitives.add(
      new Primitive_default({
        geometryInstances: outlineInstance,
        appearance: new PerInstanceColorAppearance_default({
          flat: true,
          translucent: outlineInstance.attributes.color.value[3] !== 255,
          renderState: {
            lineWidth: geometryUpdater._scene.clampLineWidth(outlineWidth)
          }
        }),
        asynchronous: false,
        shadows
      })
    );
  }
};
DynamicGeometryUpdater.prototype.getBoundingSphere = function(result) {
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const entity = this._entity;
  const primitive = this._primitive;
  const outlinePrimitive = this._outlinePrimitive;
  let attributes;
  if (defined_default(primitive) && primitive.show && primitive.ready) {
    attributes = primitive.getGeometryInstanceAttributes(entity);
    if (defined_default(attributes) && defined_default(attributes.boundingSphere)) {
      BoundingSphere_default.clone(attributes.boundingSphere, result);
      return BoundingSphereState_default.DONE;
    }
  }
  if (defined_default(outlinePrimitive) && outlinePrimitive.show && outlinePrimitive.ready) {
    attributes = outlinePrimitive.getGeometryInstanceAttributes(entity);
    if (defined_default(attributes) && defined_default(attributes.boundingSphere)) {
      BoundingSphere_default.clone(attributes.boundingSphere, result);
      return BoundingSphereState_default.DONE;
    }
  }
  if (defined_default(primitive) && !primitive.ready || defined_default(outlinePrimitive) && !outlinePrimitive.ready) {
    return BoundingSphereState_default.PENDING;
  }
  return BoundingSphereState_default.FAILED;
};
DynamicGeometryUpdater.prototype.isDestroyed = function() {
  return false;
};
DynamicGeometryUpdater.prototype.destroy = function() {
  const primitives = this._primitives;
  const orderedGroundPrimitives = this._orderedGroundPrimitives;
  if (this._geometryUpdater._onTerrain) {
    orderedGroundPrimitives.remove(this._primitive);
  } else {
    primitives.removeAndDestroy(this._primitive);
  }
  primitives.removeAndDestroy(this._outlinePrimitive);
  destroyObject_default(this);
};
var DynamicGeometryUpdater_default = DynamicGeometryUpdater;

// node_modules/cesium/Source/Shaders/PolylineShadowVolumeFS.js
var PolylineShadowVolumeFS_default = '#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n#endif\n\nvarying vec4 v_startPlaneNormalEcAndHalfWidth;\nvarying vec4 v_endPlaneNormalEcAndBatchId;\nvarying vec4 v_rightPlaneEC; // Technically can compute distance for this here\nvarying vec4 v_endEcAndStartEcX;\nvarying vec4 v_texcoordNormalizationAndStartEcYZ;\n\n#ifdef PER_INSTANCE_COLOR\nvarying vec4 v_color;\n#endif\n\nvoid main(void)\n{\n    float logDepthOrDepth = czm_branchFreeTernary(czm_sceneMode == czm_sceneMode2D, gl_FragCoord.z, czm_unpackDepth(texture2D(czm_globeDepthTexture, gl_FragCoord.xy / czm_viewport.zw)));\n    vec3 ecStart = vec3(v_endEcAndStartEcX.w, v_texcoordNormalizationAndStartEcYZ.zw);\n\n    // Discard for sky\n    if (logDepthOrDepth == 0.0) {\n#ifdef DEBUG_SHOW_VOLUME\n        gl_FragColor = vec4(1.0, 0.0, 0.0, 0.5);\n        return;\n#else // DEBUG_SHOW_VOLUME\n        discard;\n#endif // DEBUG_SHOW_VOLUME\n    }\n\n    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth);\n    eyeCoordinate /= eyeCoordinate.w;\n\n    float halfMaxWidth = v_startPlaneNormalEcAndHalfWidth.w * czm_metersPerPixel(eyeCoordinate);\n    // Check distance of the eye coordinate against the right-facing plane\n    float widthwiseDistance = czm_planeDistance(v_rightPlaneEC, eyeCoordinate.xyz);\n\n    // Check eye coordinate against the mitering planes\n    float distanceFromStart = czm_planeDistance(v_startPlaneNormalEcAndHalfWidth.xyz, -dot(ecStart, v_startPlaneNormalEcAndHalfWidth.xyz), eyeCoordinate.xyz);\n    float distanceFromEnd = czm_planeDistance(v_endPlaneNormalEcAndBatchId.xyz, -dot(v_endEcAndStartEcX.xyz, v_endPlaneNormalEcAndBatchId.xyz), eyeCoordinate.xyz);\n\n    if (abs(widthwiseDistance) > halfMaxWidth || distanceFromStart < 0.0 || distanceFromEnd < 0.0) {\n#ifdef DEBUG_SHOW_VOLUME\n        gl_FragColor = vec4(1.0, 0.0, 0.0, 0.5);\n        return;\n#else // DEBUG_SHOW_VOLUME\n        discard;\n#endif // DEBUG_SHOW_VOLUME\n    }\n\n    // Check distance of the eye coordinate against start and end planes with normals in the right plane.\n    // For computing unskewed lengthwise texture coordinate.\n    // Can also be used for clipping extremely pointy miters, but in practice unnecessary because of miter breaking.\n\n    // aligned plane: cross the right plane normal with miter plane normal, then cross the result with right again to point it more "forward"\n    vec3 alignedPlaneNormal;\n\n    // start aligned plane\n    alignedPlaneNormal = cross(v_rightPlaneEC.xyz, v_startPlaneNormalEcAndHalfWidth.xyz);\n    alignedPlaneNormal = normalize(cross(alignedPlaneNormal, v_rightPlaneEC.xyz));\n    distanceFromStart = czm_planeDistance(alignedPlaneNormal, -dot(alignedPlaneNormal, ecStart), eyeCoordinate.xyz);\n\n    // end aligned plane\n    alignedPlaneNormal = cross(v_rightPlaneEC.xyz, v_endPlaneNormalEcAndBatchId.xyz);\n    alignedPlaneNormal = normalize(cross(alignedPlaneNormal, v_rightPlaneEC.xyz));\n    distanceFromEnd = czm_planeDistance(alignedPlaneNormal, -dot(alignedPlaneNormal, v_endEcAndStartEcX.xyz), eyeCoordinate.xyz);\n\n#ifdef PER_INSTANCE_COLOR\n    gl_FragColor = czm_gammaCorrect(v_color);\n#else // PER_INSTANCE_COLOR\n    // Clamp - distance to aligned planes may be negative due to mitering,\n    // so fragment texture coordinate might be out-of-bounds.\n    float s = clamp(distanceFromStart / (distanceFromStart + distanceFromEnd), 0.0, 1.0);\n    s = (s * v_texcoordNormalizationAndStartEcYZ.x) + v_texcoordNormalizationAndStartEcYZ.y;\n    float t = (widthwiseDistance + halfMaxWidth) / (2.0 * halfMaxWidth);\n\n    czm_materialInput materialInput;\n\n    materialInput.s = s;\n    materialInput.st = vec2(s, t);\n    materialInput.str = vec3(s, t, 0.0);\n\n    czm_material material = czm_getMaterial(materialInput);\n    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n#endif // PER_INSTANCE_COLOR\n\n    // Premultiply alpha. Required for classification primitives on translucent globe.\n    gl_FragColor.rgb *= gl_FragColor.a;\n\n    czm_writeDepthClamp();\n}\n';

// node_modules/cesium/Source/Shaders/PolylineShadowVolumeMorphFS.js
var PolylineShadowVolumeMorphFS_default = "varying vec3 v_forwardDirectionEC;\nvarying vec3 v_texcoordNormalizationAndHalfWidth;\nvarying float v_batchId;\n\n#ifdef PER_INSTANCE_COLOR\nvarying vec4 v_color;\n#else\nvarying vec2 v_alignedPlaneDistances;\nvarying float v_texcoordT;\n#endif\n\nfloat rayPlaneDistanceUnsafe(vec3 origin, vec3 direction, vec3 planeNormal, float planeDistance) {\n    // We don't expect the ray to ever be parallel to the plane\n    return (-planeDistance - dot(planeNormal, origin)) / dot(planeNormal, direction);\n}\n\nvoid main(void)\n{\n    vec4 eyeCoordinate = gl_FragCoord;\n    eyeCoordinate /= eyeCoordinate.w;\n\n#ifdef PER_INSTANCE_COLOR\n    gl_FragColor = czm_gammaCorrect(v_color);\n#else // PER_INSTANCE_COLOR\n    // Use distances for planes aligned with segment to prevent skew in dashing\n    float distanceFromStart = rayPlaneDistanceUnsafe(eyeCoordinate.xyz, -v_forwardDirectionEC, v_forwardDirectionEC.xyz, v_alignedPlaneDistances.x);\n    float distanceFromEnd = rayPlaneDistanceUnsafe(eyeCoordinate.xyz, v_forwardDirectionEC, -v_forwardDirectionEC.xyz, v_alignedPlaneDistances.y);\n\n    // Clamp - distance to aligned planes may be negative due to mitering\n    distanceFromStart = max(0.0, distanceFromStart);\n    distanceFromEnd = max(0.0, distanceFromEnd);\n\n    float s = distanceFromStart / (distanceFromStart + distanceFromEnd);\n    s = (s * v_texcoordNormalizationAndHalfWidth.x) + v_texcoordNormalizationAndHalfWidth.y;\n\n    czm_materialInput materialInput;\n\n    materialInput.s = s;\n    materialInput.st = vec2(s, v_texcoordT);\n    materialInput.str = vec3(s, v_texcoordT, 0.0);\n\n    czm_material material = czm_getMaterial(materialInput);\n    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n#endif // PER_INSTANCE_COLOR\n}\n";

// node_modules/cesium/Source/Shaders/PolylineShadowVolumeMorphVS.js
var PolylineShadowVolumeMorphVS_default = `attribute vec3 position3DHigh;
attribute vec3 position3DLow;

attribute vec4 startHiAndForwardOffsetX;
attribute vec4 startLoAndForwardOffsetY;
attribute vec4 startNormalAndForwardOffsetZ;
attribute vec4 endNormalAndTextureCoordinateNormalizationX;
attribute vec4 rightNormalAndTextureCoordinateNormalizationY;
attribute vec4 startHiLo2D;
attribute vec4 offsetAndRight2D;
attribute vec4 startEndNormals2D;
attribute vec2 texcoordNormalization2D;

attribute float batchId;

varying vec3 v_forwardDirectionEC;
varying vec3 v_texcoordNormalizationAndHalfWidth;
varying float v_batchId;

// For materials
#ifdef WIDTH_VARYING
varying float v_width;
#endif
#ifdef ANGLE_VARYING
varying float v_polylineAngle;
#endif

#ifdef PER_INSTANCE_COLOR
varying vec4 v_color;
#else
varying vec2 v_alignedPlaneDistances;
varying float v_texcoordT;
#endif

// Morphing planes using SLERP or NLERP doesn't seem to work, so instead draw the material directly on the shadow volume.
// Morph views are from very far away and aren't meant to be used precisely, so this should be sufficient.
void main()
{
    v_batchId = batchId;

    // Start position
    vec4 posRelativeToEye2D = czm_translateRelativeToEye(vec3(0.0, startHiLo2D.xy), vec3(0.0, startHiLo2D.zw));
    vec4 posRelativeToEye3D = czm_translateRelativeToEye(startHiAndForwardOffsetX.xyz, startLoAndForwardOffsetY.xyz);
    vec4 posRelativeToEye = czm_columbusViewMorph(posRelativeToEye2D, posRelativeToEye3D, czm_morphTime);
    vec3 posEc2D = (czm_modelViewRelativeToEye * posRelativeToEye2D).xyz;
    vec3 posEc3D = (czm_modelViewRelativeToEye * posRelativeToEye3D).xyz;
    vec3 startEC = (czm_modelViewRelativeToEye * posRelativeToEye).xyz;

    // Start plane
    vec4 startPlane2D;
    vec4 startPlane3D;
    startPlane2D.xyz = czm_normal * vec3(0.0, startEndNormals2D.xy);
    startPlane3D.xyz = czm_normal * startNormalAndForwardOffsetZ.xyz;
    startPlane2D.w = -dot(startPlane2D.xyz, posEc2D);
    startPlane3D.w = -dot(startPlane3D.xyz, posEc3D);

    // Right plane
    vec4 rightPlane2D;
    vec4 rightPlane3D;
    rightPlane2D.xyz = czm_normal * vec3(0.0, offsetAndRight2D.zw);
    rightPlane3D.xyz = czm_normal * rightNormalAndTextureCoordinateNormalizationY.xyz;
    rightPlane2D.w = -dot(rightPlane2D.xyz, posEc2D);
    rightPlane3D.w = -dot(rightPlane3D.xyz, posEc3D);

    // End position
    posRelativeToEye2D = posRelativeToEye2D + vec4(0.0, offsetAndRight2D.xy, 0.0);
    posRelativeToEye3D = posRelativeToEye3D + vec4(startHiAndForwardOffsetX.w, startLoAndForwardOffsetY.w, startNormalAndForwardOffsetZ.w, 0.0);
    posRelativeToEye = czm_columbusViewMorph(posRelativeToEye2D, posRelativeToEye3D, czm_morphTime);
    posEc2D = (czm_modelViewRelativeToEye * posRelativeToEye2D).xyz;
    posEc3D = (czm_modelViewRelativeToEye * posRelativeToEye3D).xyz;
    vec3 endEC = (czm_modelViewRelativeToEye * posRelativeToEye).xyz;
    vec3 forwardEc3D = czm_normal * normalize(vec3(startHiAndForwardOffsetX.w, startLoAndForwardOffsetY.w, startNormalAndForwardOffsetZ.w));
    vec3 forwardEc2D = czm_normal * normalize(vec3(0.0, offsetAndRight2D.xy));

    // End plane
    vec4 endPlane2D;
    vec4 endPlane3D;
    endPlane2D.xyz = czm_normal * vec3(0.0, startEndNormals2D.zw);
    endPlane3D.xyz = czm_normal * endNormalAndTextureCoordinateNormalizationX.xyz;
    endPlane2D.w = -dot(endPlane2D.xyz, posEc2D);
    endPlane3D.w = -dot(endPlane3D.xyz, posEc3D);

    // Forward direction
    v_forwardDirectionEC = normalize(endEC - startEC);

    vec2 cleanTexcoordNormalization2D;
    cleanTexcoordNormalization2D.x = abs(texcoordNormalization2D.x);
    cleanTexcoordNormalization2D.y = czm_branchFreeTernary(texcoordNormalization2D.y > 1.0, 0.0, abs(texcoordNormalization2D.y));
    vec2 cleanTexcoordNormalization3D;
    cleanTexcoordNormalization3D.x = abs(endNormalAndTextureCoordinateNormalizationX.w);
    cleanTexcoordNormalization3D.y = rightNormalAndTextureCoordinateNormalizationY.w;
    cleanTexcoordNormalization3D.y = czm_branchFreeTernary(cleanTexcoordNormalization3D.y > 1.0, 0.0, abs(cleanTexcoordNormalization3D.y));

    v_texcoordNormalizationAndHalfWidth.xy = mix(cleanTexcoordNormalization2D, cleanTexcoordNormalization3D, czm_morphTime);

#ifdef PER_INSTANCE_COLOR
    v_color = czm_batchTable_color(batchId);
#else // PER_INSTANCE_COLOR
    // For computing texture coordinates

    v_alignedPlaneDistances.x = -dot(v_forwardDirectionEC, startEC);
    v_alignedPlaneDistances.y = -dot(-v_forwardDirectionEC, endEC);
#endif // PER_INSTANCE_COLOR

#ifdef WIDTH_VARYING
    float width = czm_batchTable_width(batchId);
    float halfWidth = width * 0.5;
    v_width = width;
    v_texcoordNormalizationAndHalfWidth.z = halfWidth;
#else
    float halfWidth = 0.5 * czm_batchTable_width(batchId);
    v_texcoordNormalizationAndHalfWidth.z = halfWidth;
#endif

    // Compute a normal along which to "push" the position out, extending the miter depending on view distance.
    // Position has already been "pushed" by unit length along miter normal, and miter normals are encoded in the planes.
    // Decode the normal to use at this specific vertex, push the position back, and then push to where it needs to be.
    // Since this is morphing, compute both 3D and 2D positions and then blend.

    // ****** 3D ******
    // Check distance to the end plane and start plane, pick the plane that is closer
    vec4 positionEc3D = czm_modelViewRelativeToEye * czm_translateRelativeToEye(position3DHigh, position3DLow); // w = 1.0, see czm_computePosition
    float absStartPlaneDistance = abs(czm_planeDistance(startPlane3D, positionEc3D.xyz));
    float absEndPlaneDistance = abs(czm_planeDistance(endPlane3D, positionEc3D.xyz));
    vec3 planeDirection = czm_branchFreeTernary(absStartPlaneDistance < absEndPlaneDistance, startPlane3D.xyz, endPlane3D.xyz);
    vec3 upOrDown = normalize(cross(rightPlane3D.xyz, planeDirection)); // Points "up" for start plane, "down" at end plane.
    vec3 normalEC = normalize(cross(planeDirection, upOrDown));         // In practice, the opposite seems to work too.

    // Nudge the top vertex upwards to prevent flickering
    vec3 geodeticSurfaceNormal = normalize(cross(normalEC, forwardEc3D));
    geodeticSurfaceNormal *= float(0.0 <= rightNormalAndTextureCoordinateNormalizationY.w && rightNormalAndTextureCoordinateNormalizationY.w <= 1.0);
    geodeticSurfaceNormal *= MAX_TERRAIN_HEIGHT;
    positionEc3D.xyz += geodeticSurfaceNormal;

    // Determine if this vertex is on the "left" or "right"
    normalEC *= sign(endNormalAndTextureCoordinateNormalizationX.w);

    // A "perfect" implementation would push along normals according to the angle against forward.
    // In practice, just pushing the normal out by halfWidth is sufficient for morph views.
    positionEc3D.xyz += halfWidth * max(0.0, czm_metersPerPixel(positionEc3D)) * normalEC; // prevent artifacts when czm_metersPerPixel is negative (behind camera)

    // ****** 2D ******
    // Check distance to the end plane and start plane, pick the plane that is closer
    vec4 positionEc2D = czm_modelViewRelativeToEye * czm_translateRelativeToEye(position2DHigh.zxy, position2DLow.zxy); // w = 1.0, see czm_computePosition
    absStartPlaneDistance = abs(czm_planeDistance(startPlane2D, positionEc2D.xyz));
    absEndPlaneDistance = abs(czm_planeDistance(endPlane2D, positionEc2D.xyz));
    planeDirection = czm_branchFreeTernary(absStartPlaneDistance < absEndPlaneDistance, startPlane2D.xyz, endPlane2D.xyz);
    upOrDown = normalize(cross(rightPlane2D.xyz, planeDirection)); // Points "up" for start plane, "down" at end plane.
    normalEC = normalize(cross(planeDirection, upOrDown));         // In practice, the opposite seems to work too.

    // Nudge the top vertex upwards to prevent flickering
    geodeticSurfaceNormal = normalize(cross(normalEC, forwardEc2D));
    geodeticSurfaceNormal *= float(0.0 <= texcoordNormalization2D.y && texcoordNormalization2D.y <= 1.0);
    geodeticSurfaceNormal *= MAX_TERRAIN_HEIGHT;
    positionEc2D.xyz += geodeticSurfaceNormal;

    // Determine if this vertex is on the "left" or "right"
    normalEC *= sign(texcoordNormalization2D.x);
#ifndef PER_INSTANCE_COLOR
    // Use vertex's sidedness to compute its texture coordinate.
    v_texcoordT = clamp(sign(texcoordNormalization2D.x), 0.0, 1.0);
#endif

    // A "perfect" implementation would push along normals according to the angle against forward.
    // In practice, just pushing the normal out by halfWidth is sufficient for morph views.
    positionEc2D.xyz += halfWidth * max(0.0, czm_metersPerPixel(positionEc2D)) * normalEC; // prevent artifacts when czm_metersPerPixel is negative (behind camera)

    // Blend for actual position
    gl_Position = czm_projection * mix(positionEc2D, positionEc3D, czm_morphTime);

#ifdef ANGLE_VARYING
    // Approximate relative screen space direction of the line.
    vec2 approxLineDirection = normalize(vec2(v_forwardDirectionEC.x, -v_forwardDirectionEC.y));
    approxLineDirection.y = czm_branchFreeTernary(approxLineDirection.x == 0.0 && approxLineDirection.y == 0.0, -1.0, approxLineDirection.y);
    v_polylineAngle = czm_fastApproximateAtan(approxLineDirection.x, approxLineDirection.y);
#endif
}
`;

// node_modules/cesium/Source/Shaders/PolylineShadowVolumeVS.js
var PolylineShadowVolumeVS_default = 'attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\n\n// In 2D and in 3D, texture coordinate normalization component signs encodes:\n// * X sign - sidedness relative to right plane\n// * Y sign - is negative OR magnitude is greater than 1.0 if vertex is on bottom of volume\n#ifndef COLUMBUS_VIEW_2D\nattribute vec4 startHiAndForwardOffsetX;\nattribute vec4 startLoAndForwardOffsetY;\nattribute vec4 startNormalAndForwardOffsetZ;\nattribute vec4 endNormalAndTextureCoordinateNormalizationX;\nattribute vec4 rightNormalAndTextureCoordinateNormalizationY;\n#else\nattribute vec4 startHiLo2D;\nattribute vec4 offsetAndRight2D;\nattribute vec4 startEndNormals2D;\nattribute vec2 texcoordNormalization2D;\n#endif\n\nattribute float batchId;\n\nvarying vec4 v_startPlaneNormalEcAndHalfWidth;\nvarying vec4 v_endPlaneNormalEcAndBatchId;\nvarying vec4 v_rightPlaneEC;\nvarying vec4 v_endEcAndStartEcX;\nvarying vec4 v_texcoordNormalizationAndStartEcYZ;\n\n// For materials\n#ifdef WIDTH_VARYING\nvarying float v_width;\n#endif\n#ifdef ANGLE_VARYING\nvarying float v_polylineAngle;\n#endif\n\n#ifdef PER_INSTANCE_COLOR\nvarying vec4 v_color;\n#endif\n\nvoid main()\n{\n#ifdef COLUMBUS_VIEW_2D\n    vec3 ecStart = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(vec3(0.0, startHiLo2D.xy), vec3(0.0, startHiLo2D.zw))).xyz;\n\n    vec3 forwardDirectionEC = czm_normal * vec3(0.0, offsetAndRight2D.xy);\n    vec3 ecEnd = forwardDirectionEC + ecStart;\n    forwardDirectionEC = normalize(forwardDirectionEC);\n\n    // Right plane\n    v_rightPlaneEC.xyz = czm_normal * vec3(0.0, offsetAndRight2D.zw);\n    v_rightPlaneEC.w = -dot(v_rightPlaneEC.xyz, ecStart);\n\n    // start plane\n    vec4 startPlaneEC;\n    startPlaneEC.xyz =  czm_normal * vec3(0.0, startEndNormals2D.xy);\n    startPlaneEC.w = -dot(startPlaneEC.xyz, ecStart);\n\n    // end plane\n    vec4 endPlaneEC;\n    endPlaneEC.xyz =  czm_normal * vec3(0.0, startEndNormals2D.zw);\n    endPlaneEC.w = -dot(endPlaneEC.xyz, ecEnd);\n\n    v_texcoordNormalizationAndStartEcYZ.x = abs(texcoordNormalization2D.x);\n    v_texcoordNormalizationAndStartEcYZ.y = texcoordNormalization2D.y;\n\n#else // COLUMBUS_VIEW_2D\n    vec3 ecStart = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(startHiAndForwardOffsetX.xyz, startLoAndForwardOffsetY.xyz)).xyz;\n    vec3 offset = czm_normal * vec3(startHiAndForwardOffsetX.w, startLoAndForwardOffsetY.w, startNormalAndForwardOffsetZ.w);\n    vec3 ecEnd = ecStart + offset;\n\n    vec3 forwardDirectionEC = normalize(offset);\n\n    // start plane\n    vec4 startPlaneEC;\n    startPlaneEC.xyz = czm_normal * startNormalAndForwardOffsetZ.xyz;\n    startPlaneEC.w = -dot(startPlaneEC.xyz, ecStart);\n\n    // end plane\n    vec4 endPlaneEC;\n    endPlaneEC.xyz = czm_normal * endNormalAndTextureCoordinateNormalizationX.xyz;\n    endPlaneEC.w = -dot(endPlaneEC.xyz, ecEnd);\n\n    // Right plane\n    v_rightPlaneEC.xyz = czm_normal * rightNormalAndTextureCoordinateNormalizationY.xyz;\n    v_rightPlaneEC.w = -dot(v_rightPlaneEC.xyz, ecStart);\n\n    v_texcoordNormalizationAndStartEcYZ.x = abs(endNormalAndTextureCoordinateNormalizationX.w);\n    v_texcoordNormalizationAndStartEcYZ.y = rightNormalAndTextureCoordinateNormalizationY.w;\n\n#endif // COLUMBUS_VIEW_2D\n\n    v_endEcAndStartEcX.xyz = ecEnd;\n    v_endEcAndStartEcX.w = ecStart.x;\n    v_texcoordNormalizationAndStartEcYZ.zw = ecStart.yz;\n\n#ifdef PER_INSTANCE_COLOR\n    v_color = czm_batchTable_color(batchId);\n#endif // PER_INSTANCE_COLOR\n\n    // Compute a normal along which to "push" the position out, extending the miter depending on view distance.\n    // Position has already been "pushed" by unit length along miter normal, and miter normals are encoded in the planes.\n    // Decode the normal to use at this specific vertex, push the position back, and then push to where it needs to be.\n    vec4 positionRelativeToEye = czm_computePosition();\n\n    // Check distance to the end plane and start plane, pick the plane that is closer\n    vec4 positionEC = czm_modelViewRelativeToEye * positionRelativeToEye; // w = 1.0, see czm_computePosition\n    float absStartPlaneDistance = abs(czm_planeDistance(startPlaneEC, positionEC.xyz));\n    float absEndPlaneDistance = abs(czm_planeDistance(endPlaneEC, positionEC.xyz));\n    vec3 planeDirection = czm_branchFreeTernary(absStartPlaneDistance < absEndPlaneDistance, startPlaneEC.xyz, endPlaneEC.xyz);\n    vec3 upOrDown = normalize(cross(v_rightPlaneEC.xyz, planeDirection)); // Points "up" for start plane, "down" at end plane.\n    vec3 normalEC = normalize(cross(planeDirection, upOrDown));           // In practice, the opposite seems to work too.\n\n    // Extrude bottom vertices downward for far view distances, like for GroundPrimitives\n    upOrDown = cross(forwardDirectionEC, normalEC);\n    upOrDown = float(czm_sceneMode == czm_sceneMode3D) * upOrDown;\n    upOrDown = float(v_texcoordNormalizationAndStartEcYZ.y > 1.0 || v_texcoordNormalizationAndStartEcYZ.y < 0.0) * upOrDown;\n    upOrDown = min(GLOBE_MINIMUM_ALTITUDE, czm_geometricToleranceOverMeter * length(positionRelativeToEye.xyz)) * upOrDown;\n    positionEC.xyz += upOrDown;\n\n    v_texcoordNormalizationAndStartEcYZ.y = czm_branchFreeTernary(v_texcoordNormalizationAndStartEcYZ.y > 1.0, 0.0, abs(v_texcoordNormalizationAndStartEcYZ.y));\n\n    // Determine distance along normalEC to push for a volume of appropriate width.\n    // Make volumes about double pixel width for a conservative fit - in practice the\n    // extra cost here is minimal compared to the loose volume heights.\n    //\n    // N = normalEC (guaranteed "right-facing")\n    // R = rightEC\n    // p = angle between N and R\n    // w = distance to push along R if R == N\n    // d = distance to push along N\n    //\n    //   N   R\n    //  {  p| }      * cos(p) = dot(N, R) = w / d\n    //  d  |  |w    * d = w / dot(N, R)\n    //    { | }\n    //       o---------- polyline segment ---->\n    //\n    float width = czm_batchTable_width(batchId);\n#ifdef WIDTH_VARYING\n    v_width = width;\n#endif\n\n    v_startPlaneNormalEcAndHalfWidth.xyz = startPlaneEC.xyz;\n    v_startPlaneNormalEcAndHalfWidth.w = width * 0.5;\n\n    v_endPlaneNormalEcAndBatchId.xyz = endPlaneEC.xyz;\n    v_endPlaneNormalEcAndBatchId.w = batchId;\n\n    width = width * max(0.0, czm_metersPerPixel(positionEC)); // width = distance to push along R\n    width = width / dot(normalEC, v_rightPlaneEC.xyz); // width = distance to push along N\n\n    // Determine if this vertex is on the "left" or "right"\n#ifdef COLUMBUS_VIEW_2D\n        normalEC *= sign(texcoordNormalization2D.x);\n#else\n        normalEC *= sign(endNormalAndTextureCoordinateNormalizationX.w);\n#endif\n\n    positionEC.xyz += width * normalEC;\n    gl_Position = czm_depthClamp(czm_projection * positionEC);\n\n#ifdef ANGLE_VARYING\n    // Approximate relative screen space direction of the line.\n    vec2 approxLineDirection = normalize(vec2(forwardDirectionEC.x, -forwardDirectionEC.y));\n    approxLineDirection.y = czm_branchFreeTernary(approxLineDirection.x == 0.0 && approxLineDirection.y == 0.0, -1.0, approxLineDirection.y);\n    v_polylineAngle = czm_fastApproximateAtan(approxLineDirection.x, approxLineDirection.y);\n#endif\n}\n';

// node_modules/cesium/Source/Shaders/Appearances/PolylineColorAppearanceVS.js
var PolylineColorAppearanceVS_default = "attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute vec3 prevPosition3DHigh;\nattribute vec3 prevPosition3DLow;\nattribute vec3 nextPosition3DHigh;\nattribute vec3 nextPosition3DLow;\nattribute vec2 expandAndWidth;\nattribute vec4 color;\nattribute float batchId;\n\nvarying vec4 v_color;\n\nvoid main()\n{\n    float expandDir = expandAndWidth.x;\n    float width = abs(expandAndWidth.y) + 0.5;\n    bool usePrev = expandAndWidth.y < 0.0;\n\n    vec4 p = czm_computePosition();\n    vec4 prev = czm_computePrevPosition();\n    vec4 next = czm_computeNextPosition();\n\n    float angle;\n    vec4 positionWC = getPolylineWindowCoordinates(p, prev, next, expandDir, width, usePrev, angle);\n    gl_Position = czm_viewportOrthographic * positionWC;\n\n    v_color = color;\n}\n";

// node_modules/cesium/Source/Shaders/PolylineCommon.js
var PolylineCommon_default = "void clipLineSegmentToNearPlane(\n    vec3 p0,\n    vec3 p1,\n    out vec4 positionWC,\n    out bool clipped,\n    out bool culledByNearPlane,\n    out vec4 clippedPositionEC)\n{\n    culledByNearPlane = false;\n    clipped = false;\n\n    vec3 p0ToP1 = p1 - p0;\n    float magnitude = length(p0ToP1);\n    vec3 direction = normalize(p0ToP1);\n\n    // Distance that p0 is behind the near plane. Negative means p0 is\n    // in front of the near plane.\n    float endPoint0Distance =  czm_currentFrustum.x + p0.z;\n\n    // Camera looks down -Z.\n    // When moving a point along +Z: LESS VISIBLE\n    //   * Points in front of the camera move closer to the camera.\n    //   * Points behind the camrea move farther away from the camera.\n    // When moving a point along -Z: MORE VISIBLE\n    //   * Points in front of the camera move farther away from the camera.\n    //   * Points behind the camera move closer to the camera.\n\n    // Positive denominator: -Z, becoming more visible\n    // Negative denominator: +Z, becoming less visible\n    // Nearly zero: parallel to near plane\n    float denominator = -direction.z;\n\n    if (endPoint0Distance > 0.0 && abs(denominator) < czm_epsilon7)\n    {\n        // p0 is behind the near plane and the line to p1 is nearly parallel to\n        // the near plane, so cull the segment completely.\n        culledByNearPlane = true;\n    }\n    else if (endPoint0Distance > 0.0)\n    {\n        // p0 is behind the near plane, and the line to p1 is moving distinctly\n        // toward or away from it.\n\n        // t = (-plane distance - dot(plane normal, ray origin)) / dot(plane normal, ray direction)\n        float t = endPoint0Distance / denominator;\n        if (t < 0.0 || t > magnitude)\n        {\n            // Near plane intersection is not between the two points.\n            // We already confirmed p0 is behind the naer plane, so now\n            // we know the entire segment is behind it.\n            culledByNearPlane = true;\n        }\n        else\n        {\n            // Segment crosses the near plane, update p0 to lie exactly on it.\n            p0 = p0 + t * direction;\n\n            // Numerical noise might put us a bit on the wrong side of the near plane.\n            // Don't let that happen.\n            p0.z = min(p0.z, -czm_currentFrustum.x);\n\n            clipped = true;\n        }\n    }\n\n    clippedPositionEC = vec4(p0, 1.0);\n    positionWC = czm_eyeToWindowCoordinates(clippedPositionEC);\n}\n\nvec4 getPolylineWindowCoordinatesEC(vec4 positionEC, vec4 prevEC, vec4 nextEC, float expandDirection, float width, bool usePrevious, out float angle)\n{\n    // expandDirection +1 is to the _left_ when looking from positionEC toward nextEC.\n\n#ifdef POLYLINE_DASH\n    // Compute the window coordinates of the points.\n    vec4 positionWindow = czm_eyeToWindowCoordinates(positionEC);\n    vec4 previousWindow = czm_eyeToWindowCoordinates(prevEC);\n    vec4 nextWindow = czm_eyeToWindowCoordinates(nextEC);\n\n    // Determine the relative screen space direction of the line.\n    vec2 lineDir;\n    if (usePrevious) {\n        lineDir = normalize(positionWindow.xy - previousWindow.xy);\n    }\n    else {\n        lineDir = normalize(nextWindow.xy - positionWindow.xy);\n    }\n    angle = atan(lineDir.x, lineDir.y) - 1.570796327; // precomputed atan(1,0)\n\n    // Quantize the angle so it doesn't change rapidly between segments.\n    angle = floor(angle / czm_piOverFour + 0.5) * czm_piOverFour;\n#endif\n\n    vec4 clippedPrevWC, clippedPrevEC;\n    bool prevSegmentClipped, prevSegmentCulled;\n    clipLineSegmentToNearPlane(prevEC.xyz, positionEC.xyz, clippedPrevWC, prevSegmentClipped, prevSegmentCulled, clippedPrevEC);\n\n    vec4 clippedNextWC, clippedNextEC;\n    bool nextSegmentClipped, nextSegmentCulled;\n    clipLineSegmentToNearPlane(nextEC.xyz, positionEC.xyz, clippedNextWC, nextSegmentClipped, nextSegmentCulled, clippedNextEC);\n\n    bool segmentClipped, segmentCulled;\n    vec4 clippedPositionWC, clippedPositionEC;\n    clipLineSegmentToNearPlane(positionEC.xyz, usePrevious ? prevEC.xyz : nextEC.xyz, clippedPositionWC, segmentClipped, segmentCulled, clippedPositionEC);\n\n    if (segmentCulled)\n    {\n        return vec4(0.0, 0.0, 0.0, 1.0);\n    }\n\n    vec2 directionToPrevWC = normalize(clippedPrevWC.xy - clippedPositionWC.xy);\n    vec2 directionToNextWC = normalize(clippedNextWC.xy - clippedPositionWC.xy);\n\n    // If a segment was culled, we can't use the corresponding direction\n    // computed above. We should never see both of these be true without\n    // `segmentCulled` above also being true.\n    if (prevSegmentCulled)\n    {\n        directionToPrevWC = -directionToNextWC;\n    }\n    else if (nextSegmentCulled)\n    {\n        directionToNextWC = -directionToPrevWC;\n    }\n\n    vec2 thisSegmentForwardWC, otherSegmentForwardWC;\n    if (usePrevious)\n    {\n        thisSegmentForwardWC = -directionToPrevWC;\n        otherSegmentForwardWC = directionToNextWC;\n    }\n    else\n    {\n        thisSegmentForwardWC = directionToNextWC;\n        otherSegmentForwardWC =  -directionToPrevWC;\n    }\n\n    vec2 thisSegmentLeftWC = vec2(-thisSegmentForwardWC.y, thisSegmentForwardWC.x);\n\n    vec2 leftWC = thisSegmentLeftWC;\n    float expandWidth = width * 0.5;\n\n    // When lines are split at the anti-meridian, the position may be at the\n    // same location as the next or previous position, and we need to handle\n    // that to avoid producing NaNs.\n    if (!czm_equalsEpsilon(prevEC.xyz - positionEC.xyz, vec3(0.0), czm_epsilon1) && !czm_equalsEpsilon(nextEC.xyz - positionEC.xyz, vec3(0.0), czm_epsilon1))\n    {\n        vec2 otherSegmentLeftWC = vec2(-otherSegmentForwardWC.y, otherSegmentForwardWC.x);\n\n        vec2 leftSumWC = thisSegmentLeftWC + otherSegmentLeftWC;\n        float leftSumLength = length(leftSumWC);\n        leftWC = leftSumLength < czm_epsilon6 ? thisSegmentLeftWC : (leftSumWC / leftSumLength);\n\n        // The sine of the angle between the two vectors is given by the formula\n        //         |a x b| = |a||b|sin(theta)\n        // which is\n        //     float sinAngle = length(cross(vec3(leftWC, 0.0), vec3(-thisSegmentForwardWC, 0.0)));\n        // Because the z components of both vectors are zero, the x and y coordinate will be zero.\n        // Therefore, the sine of the angle is just the z component of the cross product.\n        vec2 u = -thisSegmentForwardWC;\n        vec2 v = leftWC;\n        float sinAngle = abs(u.x * v.y - u.y * v.x);\n        expandWidth = clamp(expandWidth / sinAngle, 0.0, width * 2.0);\n    }\n\n    vec2 offset = leftWC * expandDirection * expandWidth * czm_pixelRatio;\n    return vec4(clippedPositionWC.xy + offset, -clippedPositionWC.z, 1.0) * (czm_projection * clippedPositionEC).w;\n}\n\nvec4 getPolylineWindowCoordinates(vec4 position, vec4 previous, vec4 next, float expandDirection, float width, bool usePrevious, out float angle)\n{\n    vec4 positionEC = czm_modelViewRelativeToEye * position;\n    vec4 prevEC = czm_modelViewRelativeToEye * previous;\n    vec4 nextEC = czm_modelViewRelativeToEye * next;\n    return getPolylineWindowCoordinatesEC(positionEC, prevEC, nextEC, expandDirection, width, usePrevious, angle);\n}\n";

// node_modules/cesium/Source/Scene/PolylineColorAppearance.js
var defaultVertexShaderSource = `${PolylineCommon_default}
${PolylineColorAppearanceVS_default}`;
var defaultFragmentShaderSource = PerInstanceFlatColorAppearanceFS_default;
if (!FeatureDetection_default.isInternetExplorer()) {
  defaultVertexShaderSource = `#define CLIP_POLYLINE 
${defaultVertexShaderSource}`;
}
function PolylineColorAppearance(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const translucent = defaultValue_default(options.translucent, true);
  const closed = false;
  const vertexFormat = PolylineColorAppearance.VERTEX_FORMAT;
  this.material = void 0;
  this.translucent = translucent;
  this._vertexShaderSource = defaultValue_default(
    options.vertexShaderSource,
    defaultVertexShaderSource
  );
  this._fragmentShaderSource = defaultValue_default(
    options.fragmentShaderSource,
    defaultFragmentShaderSource
  );
  this._renderState = Appearance_default.getDefaultRenderState(
    translucent,
    closed,
    options.renderState
  );
  this._closed = closed;
  this._vertexFormat = vertexFormat;
}
Object.defineProperties(PolylineColorAppearance.prototype, {
  vertexShaderSource: {
    get: function() {
      return this._vertexShaderSource;
    }
  },
  fragmentShaderSource: {
    get: function() {
      return this._fragmentShaderSource;
    }
  },
  renderState: {
    get: function() {
      return this._renderState;
    }
  },
  closed: {
    get: function() {
      return this._closed;
    }
  },
  vertexFormat: {
    get: function() {
      return this._vertexFormat;
    }
  }
});
PolylineColorAppearance.VERTEX_FORMAT = VertexFormat_default.POSITION_ONLY;
PolylineColorAppearance.prototype.getFragmentShaderSource = Appearance_default.prototype.getFragmentShaderSource;
PolylineColorAppearance.prototype.isTranslucent = Appearance_default.prototype.isTranslucent;
PolylineColorAppearance.prototype.getRenderState = Appearance_default.prototype.getRenderState;
var PolylineColorAppearance_default = PolylineColorAppearance;

// node_modules/cesium/Source/Shaders/Appearances/PolylineMaterialAppearanceVS.js
var PolylineMaterialAppearanceVS_default = "attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute vec3 prevPosition3DHigh;\nattribute vec3 prevPosition3DLow;\nattribute vec3 nextPosition3DHigh;\nattribute vec3 nextPosition3DLow;\nattribute vec2 expandAndWidth;\nattribute vec2 st;\nattribute float batchId;\n\nvarying float v_width;\nvarying vec2 v_st;\nvarying float v_polylineAngle;\n\nvoid main()\n{\n    float expandDir = expandAndWidth.x;\n    float width = abs(expandAndWidth.y) + 0.5;\n    bool usePrev = expandAndWidth.y < 0.0;\n\n    vec4 p = czm_computePosition();\n    vec4 prev = czm_computePrevPosition();\n    vec4 next = czm_computeNextPosition();\n\n    float angle;\n    vec4 positionWC = getPolylineWindowCoordinates(p, prev, next, expandDir, width, usePrev, angle);\n    gl_Position = czm_viewportOrthographic * positionWC;\n\n    v_width = width;\n    v_st.s = st.s;\n    v_st.t = czm_writeNonPerspective(st.t, gl_Position.w);\n    v_polylineAngle = angle;\n}\n";

// node_modules/cesium/Source/Shaders/PolylineFS.js
var PolylineFS_default = "#ifdef VECTOR_TILE\nuniform vec4 u_highlightColor;\n#endif\n\nvarying vec2 v_st;\n\nvoid main()\n{\n    czm_materialInput materialInput;\n\n    vec2 st = v_st;\n    st.t = czm_readNonPerspective(st.t, gl_FragCoord.w);\n\n    materialInput.s = st.s;\n    materialInput.st = st;\n    materialInput.str = vec3(st, 0.0);\n\n    czm_material material = czm_getMaterial(materialInput);\n    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n#ifdef VECTOR_TILE\n    gl_FragColor *= u_highlightColor;\n#endif\n\n    czm_writeLogDepth();\n}\n";

// node_modules/cesium/Source/Scene/PolylineMaterialAppearance.js
var defaultVertexShaderSource2 = `${PolylineCommon_default}
${PolylineMaterialAppearanceVS_default}`;
var defaultFragmentShaderSource2 = PolylineFS_default;
if (!FeatureDetection_default.isInternetExplorer()) {
  defaultVertexShaderSource2 = `#define CLIP_POLYLINE 
${defaultVertexShaderSource2}`;
}
function PolylineMaterialAppearance(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const translucent = defaultValue_default(options.translucent, true);
  const closed = false;
  const vertexFormat = PolylineMaterialAppearance.VERTEX_FORMAT;
  this.material = defined_default(options.material) ? options.material : Material_default.fromType(Material_default.ColorType);
  this.translucent = translucent;
  this._vertexShaderSource = defaultValue_default(
    options.vertexShaderSource,
    defaultVertexShaderSource2
  );
  this._fragmentShaderSource = defaultValue_default(
    options.fragmentShaderSource,
    defaultFragmentShaderSource2
  );
  this._renderState = Appearance_default.getDefaultRenderState(
    translucent,
    closed,
    options.renderState
  );
  this._closed = closed;
  this._vertexFormat = vertexFormat;
}
Object.defineProperties(PolylineMaterialAppearance.prototype, {
  vertexShaderSource: {
    get: function() {
      let vs = this._vertexShaderSource;
      if (this.material.shaderSource.search(
        /varying\s+float\s+v_polylineAngle;/g
      ) !== -1) {
        vs = `#define POLYLINE_DASH
${vs}`;
      }
      return vs;
    }
  },
  fragmentShaderSource: {
    get: function() {
      return this._fragmentShaderSource;
    }
  },
  renderState: {
    get: function() {
      return this._renderState;
    }
  },
  closed: {
    get: function() {
      return this._closed;
    }
  },
  vertexFormat: {
    get: function() {
      return this._vertexFormat;
    }
  }
});
PolylineMaterialAppearance.VERTEX_FORMAT = VertexFormat_default.POSITION_AND_ST;
PolylineMaterialAppearance.prototype.getFragmentShaderSource = Appearance_default.prototype.getFragmentShaderSource;
PolylineMaterialAppearance.prototype.isTranslucent = Appearance_default.prototype.isTranslucent;
PolylineMaterialAppearance.prototype.getRenderState = Appearance_default.prototype.getRenderState;
var PolylineMaterialAppearance_default = PolylineMaterialAppearance;

// node_modules/cesium/Source/Scene/GroundPolylinePrimitive.js
function GroundPolylinePrimitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.geometryInstances = options.geometryInstances;
  this._hasPerInstanceColors = true;
  let appearance = options.appearance;
  if (!defined_default(appearance)) {
    appearance = new PolylineMaterialAppearance_default();
  }
  this.appearance = appearance;
  this.show = defaultValue_default(options.show, true);
  this.classificationType = defaultValue_default(
    options.classificationType,
    ClassificationType_default.BOTH
  );
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this._debugShowShadowVolume = defaultValue_default(
    options.debugShowShadowVolume,
    false
  );
  this._primitiveOptions = {
    geometryInstances: void 0,
    appearance: void 0,
    vertexCacheOptimize: false,
    interleave: defaultValue_default(options.interleave, false),
    releaseGeometryInstances: defaultValue_default(
      options.releaseGeometryInstances,
      true
    ),
    allowPicking: defaultValue_default(options.allowPicking, true),
    asynchronous: defaultValue_default(options.asynchronous, true),
    compressVertices: false,
    _createShaderProgramFunction: void 0,
    _createCommandsFunction: void 0,
    _updateAndQueueCommandsFunction: void 0
  };
  this._zIndex = void 0;
  this._ready = false;
  this._readyPromise = defer_default();
  this._primitive = void 0;
  this._sp = void 0;
  this._sp2D = void 0;
  this._spMorph = void 0;
  this._renderState = getRenderState(false);
  this._renderState3DTiles = getRenderState(true);
  this._renderStateMorph = RenderState_default.fromCache({
    cull: {
      enabled: true,
      face: CullFace_default.FRONT
    },
    depthTest: {
      enabled: true
    },
    blending: BlendingState_default.PRE_MULTIPLIED_ALPHA_BLEND,
    depthMask: false
  });
}
Object.defineProperties(GroundPolylinePrimitive.prototype, {
  interleave: {
    get: function() {
      return this._primitiveOptions.interleave;
    }
  },
  releaseGeometryInstances: {
    get: function() {
      return this._primitiveOptions.releaseGeometryInstances;
    }
  },
  allowPicking: {
    get: function() {
      return this._primitiveOptions.allowPicking;
    }
  },
  asynchronous: {
    get: function() {
      return this._primitiveOptions.asynchronous;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  debugShowShadowVolume: {
    get: function() {
      return this._debugShowShadowVolume;
    }
  }
});
GroundPolylinePrimitive.initializeTerrainHeights = function() {
  return ApproximateTerrainHeights_default.initialize();
};
function createShaderProgram3(groundPolylinePrimitive, frameState, appearance) {
  const context = frameState.context;
  const primitive = groundPolylinePrimitive._primitive;
  const attributeLocations8 = primitive._attributeLocations;
  let vs = primitive._batchTable.getVertexShaderCallback()(
    PolylineShadowVolumeVS_default
  );
  vs = Primitive_default._appendShowToShader(primitive, vs);
  vs = Primitive_default._appendDistanceDisplayConditionToShader(primitive, vs);
  vs = Primitive_default._modifyShaderPosition(
    groundPolylinePrimitive,
    vs,
    frameState.scene3DOnly
  );
  let vsMorph = primitive._batchTable.getVertexShaderCallback()(
    PolylineShadowVolumeMorphVS_default
  );
  vsMorph = Primitive_default._appendShowToShader(primitive, vsMorph);
  vsMorph = Primitive_default._appendDistanceDisplayConditionToShader(
    primitive,
    vsMorph
  );
  vsMorph = Primitive_default._modifyShaderPosition(
    groundPolylinePrimitive,
    vsMorph,
    frameState.scene3DOnly
  );
  let fs = primitive._batchTable.getVertexShaderCallback()(
    PolylineShadowVolumeFS_default
  );
  const vsDefines = [
    `GLOBE_MINIMUM_ALTITUDE ${frameState.mapProjection.ellipsoid.minimumRadius.toFixed(
      1
    )}`
  ];
  let colorDefine = "";
  let materialShaderSource = "";
  if (defined_default(appearance.material)) {
    materialShaderSource = defined_default(appearance.material) ? appearance.material.shaderSource : "";
    if (materialShaderSource.search(/varying\s+float\s+v_polylineAngle;/g) !== -1) {
      vsDefines.push("ANGLE_VARYING");
    }
    if (materialShaderSource.search(/varying\s+float\s+v_width;/g) !== -1) {
      vsDefines.push("WIDTH_VARYING");
    }
  } else {
    colorDefine = "PER_INSTANCE_COLOR";
  }
  vsDefines.push(colorDefine);
  const fsDefines = groundPolylinePrimitive.debugShowShadowVolume ? ["DEBUG_SHOW_VOLUME", colorDefine] : [colorDefine];
  const vsColor3D = new ShaderSource_default({
    defines: vsDefines,
    sources: [vs]
  });
  const fsColor3D = new ShaderSource_default({
    defines: fsDefines,
    sources: [materialShaderSource, fs]
  });
  groundPolylinePrimitive._sp = ShaderProgram_default.replaceCache({
    context,
    shaderProgram: primitive._sp,
    vertexShaderSource: vsColor3D,
    fragmentShaderSource: fsColor3D,
    attributeLocations: attributeLocations8
  });
  let colorProgram2D = context.shaderCache.getDerivedShaderProgram(
    groundPolylinePrimitive._sp,
    "2dColor"
  );
  if (!defined_default(colorProgram2D)) {
    const vsColor2D = new ShaderSource_default({
      defines: vsDefines.concat(["COLUMBUS_VIEW_2D"]),
      sources: [vs]
    });
    colorProgram2D = context.shaderCache.createDerivedShaderProgram(
      groundPolylinePrimitive._sp,
      "2dColor",
      {
        context,
        shaderProgram: groundPolylinePrimitive._sp2D,
        vertexShaderSource: vsColor2D,
        fragmentShaderSource: fsColor3D,
        attributeLocations: attributeLocations8
      }
    );
  }
  groundPolylinePrimitive._sp2D = colorProgram2D;
  let colorProgramMorph = context.shaderCache.getDerivedShaderProgram(
    groundPolylinePrimitive._sp,
    "MorphColor"
  );
  if (!defined_default(colorProgramMorph)) {
    const vsColorMorph = new ShaderSource_default({
      defines: vsDefines.concat([
        `MAX_TERRAIN_HEIGHT ${ApproximateTerrainHeights_default._defaultMaxTerrainHeight.toFixed(
          1
        )}`
      ]),
      sources: [vsMorph]
    });
    fs = primitive._batchTable.getVertexShaderCallback()(
      PolylineShadowVolumeMorphFS_default
    );
    const fsColorMorph = new ShaderSource_default({
      defines: fsDefines,
      sources: [materialShaderSource, fs]
    });
    colorProgramMorph = context.shaderCache.createDerivedShaderProgram(
      groundPolylinePrimitive._sp,
      "MorphColor",
      {
        context,
        shaderProgram: groundPolylinePrimitive._spMorph,
        vertexShaderSource: vsColorMorph,
        fragmentShaderSource: fsColorMorph,
        attributeLocations: attributeLocations8
      }
    );
  }
  groundPolylinePrimitive._spMorph = colorProgramMorph;
}
function getRenderState(mask3DTiles) {
  return RenderState_default.fromCache({
    cull: {
      enabled: true
    },
    blending: BlendingState_default.PRE_MULTIPLIED_ALPHA_BLEND,
    depthMask: false,
    stencilTest: {
      enabled: mask3DTiles,
      frontFunction: StencilFunction_default.EQUAL,
      frontOperation: {
        fail: StencilOperation_default.KEEP,
        zFail: StencilOperation_default.KEEP,
        zPass: StencilOperation_default.KEEP
      },
      backFunction: StencilFunction_default.EQUAL,
      backOperation: {
        fail: StencilOperation_default.KEEP,
        zFail: StencilOperation_default.KEEP,
        zPass: StencilOperation_default.KEEP
      },
      reference: StencilConstants_default.CESIUM_3D_TILE_MASK,
      mask: StencilConstants_default.CESIUM_3D_TILE_MASK
    }
  });
}
function createCommands3(groundPolylinePrimitive, appearance, material, translucent, colorCommands, pickCommands) {
  const primitive = groundPolylinePrimitive._primitive;
  const length3 = primitive._va.length;
  colorCommands.length = length3;
  pickCommands.length = length3;
  const isPolylineColorAppearance = appearance instanceof PolylineColorAppearance_default;
  const materialUniforms = isPolylineColorAppearance ? {} : material._uniforms;
  const uniformMap2 = primitive._batchTable.getUniformMapCallback()(
    materialUniforms
  );
  for (let i2 = 0; i2 < length3; i2++) {
    const vertexArray = primitive._va[i2];
    let command = colorCommands[i2];
    if (!defined_default(command)) {
      command = colorCommands[i2] = new DrawCommand_default({
        owner: groundPolylinePrimitive,
        primitiveType: primitive._primitiveType
      });
    }
    command.vertexArray = vertexArray;
    command.renderState = groundPolylinePrimitive._renderState;
    command.shaderProgram = groundPolylinePrimitive._sp;
    command.uniformMap = uniformMap2;
    command.pass = Pass_default.TERRAIN_CLASSIFICATION;
    command.pickId = "czm_batchTable_pickColor(v_endPlaneNormalEcAndBatchId.w)";
    const derivedTilesetCommand = DrawCommand_default.shallowClone(
      command,
      command.derivedCommands.tileset
    );
    derivedTilesetCommand.renderState = groundPolylinePrimitive._renderState3DTiles;
    derivedTilesetCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    command.derivedCommands.tileset = derivedTilesetCommand;
    const derived2DCommand = DrawCommand_default.shallowClone(
      command,
      command.derivedCommands.color2D
    );
    derived2DCommand.shaderProgram = groundPolylinePrimitive._sp2D;
    command.derivedCommands.color2D = derived2DCommand;
    const derived2DTilesetCommand = DrawCommand_default.shallowClone(
      derivedTilesetCommand,
      derivedTilesetCommand.derivedCommands.color2D
    );
    derived2DTilesetCommand.shaderProgram = groundPolylinePrimitive._sp2D;
    derivedTilesetCommand.derivedCommands.color2D = derived2DTilesetCommand;
    const derivedMorphCommand = DrawCommand_default.shallowClone(
      command,
      command.derivedCommands.colorMorph
    );
    derivedMorphCommand.renderState = groundPolylinePrimitive._renderStateMorph;
    derivedMorphCommand.shaderProgram = groundPolylinePrimitive._spMorph;
    derivedMorphCommand.pickId = "czm_batchTable_pickColor(v_batchId)";
    command.derivedCommands.colorMorph = derivedMorphCommand;
  }
}
function updateAndQueueCommand(groundPolylinePrimitive, command, frameState, modelMatrix, cull, boundingVolume, debugShowBoundingVolume2) {
  if (frameState.mode === SceneMode_default.MORPHING) {
    command = command.derivedCommands.colorMorph;
  } else if (frameState.mode !== SceneMode_default.SCENE3D) {
    command = command.derivedCommands.color2D;
  }
  command.modelMatrix = modelMatrix;
  command.boundingVolume = boundingVolume;
  command.cull = cull;
  command.debugShowBoundingVolume = debugShowBoundingVolume2;
  frameState.commandList.push(command);
}
function updateAndQueueCommands4(groundPolylinePrimitive, frameState, colorCommands, pickCommands, modelMatrix, cull, debugShowBoundingVolume2) {
  const primitive = groundPolylinePrimitive._primitive;
  Primitive_default._updateBoundingVolumes(primitive, frameState, modelMatrix);
  let boundingSpheres;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    boundingSpheres = primitive._boundingSphereWC;
  } else if (frameState.mode === SceneMode_default.COLUMBUS_VIEW) {
    boundingSpheres = primitive._boundingSphereCV;
  } else if (frameState.mode === SceneMode_default.SCENE2D && defined_default(primitive._boundingSphere2D)) {
    boundingSpheres = primitive._boundingSphere2D;
  } else if (defined_default(primitive._boundingSphereMorph)) {
    boundingSpheres = primitive._boundingSphereMorph;
  }
  const morphing = frameState.mode === SceneMode_default.MORPHING;
  const classificationType = groundPolylinePrimitive.classificationType;
  const queueTerrainCommands = classificationType !== ClassificationType_default.CESIUM_3D_TILE;
  const queue3DTilesCommands = classificationType !== ClassificationType_default.TERRAIN && !morphing;
  let command;
  const passes = frameState.passes;
  if (passes.render || passes.pick && primitive.allowPicking) {
    const colorLength = colorCommands.length;
    for (let j = 0; j < colorLength; ++j) {
      const boundingVolume = boundingSpheres[j];
      if (queueTerrainCommands) {
        command = colorCommands[j];
        updateAndQueueCommand(
          groundPolylinePrimitive,
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume,
          debugShowBoundingVolume2
        );
      }
      if (queue3DTilesCommands) {
        command = colorCommands[j].derivedCommands.tileset;
        updateAndQueueCommand(
          groundPolylinePrimitive,
          command,
          frameState,
          modelMatrix,
          cull,
          boundingVolume,
          debugShowBoundingVolume2
        );
      }
    }
  }
}
GroundPolylinePrimitive.prototype.update = function(frameState) {
  if (!defined_default(this._primitive) && !defined_default(this.geometryInstances)) {
    return;
  }
  if (!ApproximateTerrainHeights_default.initialized) {
    if (!this.asynchronous) {
      throw new DeveloperError_default(
        "For synchronous GroundPolylinePrimitives, you must call GroundPolylinePrimitives.initializeTerrainHeights() and wait for the returned promise to resolve."
      );
    }
    GroundPolylinePrimitive.initializeTerrainHeights();
    return;
  }
  let i2;
  const that = this;
  const primitiveOptions = this._primitiveOptions;
  if (!defined_default(this._primitive)) {
    const geometryInstances = Array.isArray(this.geometryInstances) ? this.geometryInstances : [this.geometryInstances];
    const geometryInstancesLength = geometryInstances.length;
    const groundInstances = new Array(geometryInstancesLength);
    let attributes;
    for (i2 = 0; i2 < geometryInstancesLength; ++i2) {
      attributes = geometryInstances[i2].attributes;
      if (!defined_default(attributes) || !defined_default(attributes.color)) {
        this._hasPerInstanceColors = false;
        break;
      }
    }
    for (i2 = 0; i2 < geometryInstancesLength; ++i2) {
      const geometryInstance = geometryInstances[i2];
      attributes = {};
      const instanceAttributes = geometryInstance.attributes;
      for (const attributeKey in instanceAttributes) {
        if (instanceAttributes.hasOwnProperty(attributeKey)) {
          attributes[attributeKey] = instanceAttributes[attributeKey];
        }
      }
      if (!defined_default(attributes.width)) {
        attributes.width = new GeometryInstanceAttribute_default({
          componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
          componentsPerAttribute: 1,
          value: [geometryInstance.geometry.width]
        });
      }
      geometryInstance.geometry._scene3DOnly = frameState.scene3DOnly;
      GroundPolylineGeometry_default.setProjectionAndEllipsoid(
        geometryInstance.geometry,
        frameState.mapProjection
      );
      groundInstances[i2] = new GeometryInstance_default({
        geometry: geometryInstance.geometry,
        attributes,
        id: geometryInstance.id,
        pickPrimitive: that
      });
    }
    primitiveOptions.geometryInstances = groundInstances;
    primitiveOptions.appearance = this.appearance;
    primitiveOptions._createShaderProgramFunction = function(primitive, frameState2, appearance) {
      createShaderProgram3(that, frameState2, appearance);
    };
    primitiveOptions._createCommandsFunction = function(primitive, appearance, material, translucent, twoPasses, colorCommands, pickCommands) {
      createCommands3(
        that,
        appearance,
        material,
        translucent,
        colorCommands,
        pickCommands
      );
    };
    primitiveOptions._updateAndQueueCommandsFunction = function(primitive, frameState2, colorCommands, pickCommands, modelMatrix, cull, debugShowBoundingVolume2, twoPasses) {
      updateAndQueueCommands4(
        that,
        frameState2,
        colorCommands,
        pickCommands,
        modelMatrix,
        cull,
        debugShowBoundingVolume2
      );
    };
    this._primitive = new Primitive_default(primitiveOptions);
    this._primitive.readyPromise.then(function(primitive) {
      that._ready = true;
      if (that.releaseGeometryInstances) {
        that.geometryInstances = void 0;
      }
      const error = primitive._error;
      if (!defined_default(error)) {
        that._readyPromise.resolve(that);
      } else {
        that._readyPromise.reject(error);
      }
    });
  }
  if (this.appearance instanceof PolylineColorAppearance_default && !this._hasPerInstanceColors) {
    throw new DeveloperError_default(
      "All GeometryInstances must have color attributes to use PolylineColorAppearance with GroundPolylinePrimitive."
    );
  }
  this._primitive.appearance = this.appearance;
  this._primitive.show = this.show;
  this._primitive.debugShowBoundingVolume = this.debugShowBoundingVolume;
  this._primitive.update(frameState);
};
GroundPolylinePrimitive.prototype.getGeometryInstanceAttributes = function(id) {
  if (!defined_default(this._primitive)) {
    throw new DeveloperError_default(
      "must call update before calling getGeometryInstanceAttributes"
    );
  }
  return this._primitive.getGeometryInstanceAttributes(id);
};
GroundPolylinePrimitive.isSupported = function(scene) {
  return scene.frameState.context.depthTexture;
};
GroundPolylinePrimitive.prototype.isDestroyed = function() {
  return false;
};
GroundPolylinePrimitive.prototype.destroy = function() {
  this._primitive = this._primitive && this._primitive.destroy();
  this._sp = this._sp && this._sp.destroy();
  this._sp2D = void 0;
  this._spMorph = void 0;
  return destroyObject_default(this);
};
var GroundPolylinePrimitive_default = GroundPolylinePrimitive;

// node_modules/cesium/Source/DataSources/ImageMaterialProperty.js
var defaultRepeat = new Cartesian2_default(1, 1);
var defaultTransparent = false;
var defaultColor2 = Color_default.WHITE;
function ImageMaterialProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._definitionChanged = new Event_default();
  this._image = void 0;
  this._imageSubscription = void 0;
  this._repeat = void 0;
  this._repeatSubscription = void 0;
  this._color = void 0;
  this._colorSubscription = void 0;
  this._transparent = void 0;
  this._transparentSubscription = void 0;
  this.image = options.image;
  this.repeat = options.repeat;
  this.color = options.color;
  this.transparent = options.transparent;
}
Object.defineProperties(ImageMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._image) && Property_default.isConstant(this._repeat);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  image: createPropertyDescriptor_default("image"),
  repeat: createPropertyDescriptor_default("repeat"),
  color: createPropertyDescriptor_default("color"),
  transparent: createPropertyDescriptor_default("transparent")
});
ImageMaterialProperty.prototype.getType = function(time) {
  return "Image";
};
ImageMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = {};
  }
  result.image = Property_default.getValueOrUndefined(this._image, time);
  result.repeat = Property_default.getValueOrClonedDefault(
    this._repeat,
    time,
    defaultRepeat,
    result.repeat
  );
  result.color = Property_default.getValueOrClonedDefault(
    this._color,
    time,
    defaultColor2,
    result.color
  );
  if (Property_default.getValueOrDefault(this._transparent, time, defaultTransparent)) {
    result.color.alpha = Math.min(0.99, result.color.alpha);
  }
  return result;
};
ImageMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof ImageMaterialProperty && Property_default.equals(this._image, other._image) && Property_default.equals(this._repeat, other._repeat) && Property_default.equals(this._color, other._color) && Property_default.equals(this._transparent, other._transparent);
};
var ImageMaterialProperty_default = ImageMaterialProperty;

// node_modules/cesium/Source/DataSources/createMaterialPropertyDescriptor.js
function createMaterialProperty(value) {
  if (value instanceof Color_default) {
    return new ColorMaterialProperty_default(value);
  }
  if (typeof value === "string" || value instanceof Resource_default || value instanceof HTMLCanvasElement || value instanceof HTMLVideoElement) {
    const result = new ImageMaterialProperty_default();
    result.image = value;
    return result;
  }
  throw new DeveloperError_default(`Unable to infer material type: ${value}`);
}
function createMaterialPropertyDescriptor(name, configurable) {
  return createPropertyDescriptor_default(name, configurable, createMaterialProperty);
}
var createMaterialPropertyDescriptor_default = createMaterialPropertyDescriptor;

// node_modules/cesium/Source/DataSources/BoxGraphics.js
function BoxGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._dimensions = void 0;
  this._dimensionsSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(BoxGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  dimensions: createPropertyDescriptor_default("dimensions"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  )
});
BoxGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new BoxGraphics(this);
  }
  result.show = this.show;
  result.dimensions = this.dimensions;
  result.heightReference = this.heightReference;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  return result;
};
BoxGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.dimensions = defaultValue_default(this.dimensions, source.dimensions);
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
};
var BoxGraphics_default = BoxGraphics;

// node_modules/cesium/Source/DataSources/PositionProperty.js
function PositionProperty() {
  DeveloperError_default.throwInstantiationError();
}
Object.defineProperties(PositionProperty.prototype, {
  isConstant: {
    get: DeveloperError_default.throwInstantiationError
  },
  definitionChanged: {
    get: DeveloperError_default.throwInstantiationError
  },
  referenceFrame: {
    get: DeveloperError_default.throwInstantiationError
  }
});
PositionProperty.prototype.getValue = DeveloperError_default.throwInstantiationError;
PositionProperty.prototype.getValueInReferenceFrame = DeveloperError_default.throwInstantiationError;
PositionProperty.prototype.equals = DeveloperError_default.throwInstantiationError;
var scratchMatrix3 = new Matrix3_default();
PositionProperty.convertToReferenceFrame = function(time, value, inputFrame, outputFrame, result) {
  if (!defined_default(value)) {
    return value;
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  if (inputFrame === outputFrame) {
    return Cartesian3_default.clone(value, result);
  }
  let icrfToFixed2 = Transforms_default.computeIcrfToFixedMatrix(time, scratchMatrix3);
  if (!defined_default(icrfToFixed2)) {
    icrfToFixed2 = Transforms_default.computeTemeToPseudoFixedMatrix(
      time,
      scratchMatrix3
    );
  }
  if (inputFrame === ReferenceFrame_default.INERTIAL) {
    return Matrix3_default.multiplyByVector(icrfToFixed2, value, result);
  }
  if (inputFrame === ReferenceFrame_default.FIXED) {
    return Matrix3_default.multiplyByVector(
      Matrix3_default.transpose(icrfToFixed2, scratchMatrix3),
      value,
      result
    );
  }
};
var PositionProperty_default = PositionProperty;

// node_modules/cesium/Source/DataSources/ConstantPositionProperty.js
function ConstantPositionProperty(value, referenceFrame) {
  this._definitionChanged = new Event_default();
  this._value = Cartesian3_default.clone(value);
  this._referenceFrame = defaultValue_default(referenceFrame, ReferenceFrame_default.FIXED);
}
Object.defineProperties(ConstantPositionProperty.prototype, {
  isConstant: {
    get: function() {
      return !defined_default(this._value) || this._referenceFrame === ReferenceFrame_default.FIXED;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  referenceFrame: {
    get: function() {
      return this._referenceFrame;
    }
  }
});
ConstantPositionProperty.prototype.getValue = function(time, result) {
  return this.getValueInReferenceFrame(time, ReferenceFrame_default.FIXED, result);
};
ConstantPositionProperty.prototype.setValue = function(value, referenceFrame) {
  let definitionChanged = false;
  if (!Cartesian3_default.equals(this._value, value)) {
    definitionChanged = true;
    this._value = Cartesian3_default.clone(value);
  }
  if (defined_default(referenceFrame) && this._referenceFrame !== referenceFrame) {
    definitionChanged = true;
    this._referenceFrame = referenceFrame;
  }
  if (definitionChanged) {
    this._definitionChanged.raiseEvent(this);
  }
};
ConstantPositionProperty.prototype.getValueInReferenceFrame = function(time, referenceFrame, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  if (!defined_default(referenceFrame)) {
    throw new DeveloperError_default("referenceFrame is required.");
  }
  return PositionProperty_default.convertToReferenceFrame(
    time,
    this._value,
    this._referenceFrame,
    referenceFrame,
    result
  );
};
ConstantPositionProperty.prototype.equals = function(other) {
  return this === other || other instanceof ConstantPositionProperty && Cartesian3_default.equals(this._value, other._value) && this._referenceFrame === other._referenceFrame;
};
var ConstantPositionProperty_default = ConstantPositionProperty;

// node_modules/cesium/Source/DataSources/CorridorGraphics.js
function CorridorGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._positions = void 0;
  this._positionsSubscription = void 0;
  this._width = void 0;
  this._widthSubscription = void 0;
  this._height = void 0;
  this._heightSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._extrudedHeight = void 0;
  this._extrudedHeightSubscription = void 0;
  this._extrudedHeightReference = void 0;
  this._extrudedHeightReferenceSubscription = void 0;
  this._cornerType = void 0;
  this._cornerTypeSubscription = void 0;
  this._granularity = void 0;
  this._granularitySubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this._classificationType = void 0;
  this._classificationTypeSubscription = void 0;
  this._zIndex = void 0;
  this._zIndexSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(CorridorGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  positions: createPropertyDescriptor_default("positions"),
  width: createPropertyDescriptor_default("width"),
  height: createPropertyDescriptor_default("height"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  extrudedHeight: createPropertyDescriptor_default("extrudedHeight"),
  extrudedHeightReference: createPropertyDescriptor_default("extrudedHeightReference"),
  cornerType: createPropertyDescriptor_default("cornerType"),
  granularity: createPropertyDescriptor_default("granularity"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  ),
  classificationType: createPropertyDescriptor_default("classificationType"),
  zIndex: createPropertyDescriptor_default("zIndex")
});
CorridorGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new CorridorGraphics(this);
  }
  result.show = this.show;
  result.positions = this.positions;
  result.width = this.width;
  result.height = this.height;
  result.heightReference = this.heightReference;
  result.extrudedHeight = this.extrudedHeight;
  result.extrudedHeightReference = this.extrudedHeightReference;
  result.cornerType = this.cornerType;
  result.granularity = this.granularity;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  result.classificationType = this.classificationType;
  result.zIndex = this.zIndex;
  return result;
};
CorridorGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.positions = defaultValue_default(this.positions, source.positions);
  this.width = defaultValue_default(this.width, source.width);
  this.height = defaultValue_default(this.height, source.height);
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.extrudedHeight = defaultValue_default(
    this.extrudedHeight,
    source.extrudedHeight
  );
  this.extrudedHeightReference = defaultValue_default(
    this.extrudedHeightReference,
    source.extrudedHeightReference
  );
  this.cornerType = defaultValue_default(this.cornerType, source.cornerType);
  this.granularity = defaultValue_default(this.granularity, source.granularity);
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
  this.classificationType = defaultValue_default(
    this.classificationType,
    source.classificationType
  );
  this.zIndex = defaultValue_default(this.zIndex, source.zIndex);
};
var CorridorGraphics_default = CorridorGraphics;

// node_modules/cesium/Source/DataSources/createRawPropertyDescriptor.js
function createRawProperty(value) {
  return value;
}
function createRawPropertyDescriptor(name, configurable) {
  return createPropertyDescriptor_default(name, configurable, createRawProperty);
}
var createRawPropertyDescriptor_default = createRawPropertyDescriptor;

// node_modules/cesium/Source/DataSources/CylinderGraphics.js
function CylinderGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._length = void 0;
  this._lengthSubscription = void 0;
  this._topRadius = void 0;
  this._topRadiusSubscription = void 0;
  this._bottomRadius = void 0;
  this._bottomRadiusSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._numberOfVerticalLines = void 0;
  this._numberOfVerticalLinesSubscription = void 0;
  this._slices = void 0;
  this._slicesSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(CylinderGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  length: createPropertyDescriptor_default("length"),
  topRadius: createPropertyDescriptor_default("topRadius"),
  bottomRadius: createPropertyDescriptor_default("bottomRadius"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  numberOfVerticalLines: createPropertyDescriptor_default("numberOfVerticalLines"),
  slices: createPropertyDescriptor_default("slices"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  )
});
CylinderGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new CylinderGraphics(this);
  }
  result.show = this.show;
  result.length = this.length;
  result.topRadius = this.topRadius;
  result.bottomRadius = this.bottomRadius;
  result.heightReference = this.heightReference;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.numberOfVerticalLines = this.numberOfVerticalLines;
  result.slices = this.slices;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  return result;
};
CylinderGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.length = defaultValue_default(this.length, source.length);
  this.topRadius = defaultValue_default(this.topRadius, source.topRadius);
  this.bottomRadius = defaultValue_default(this.bottomRadius, source.bottomRadius);
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.numberOfVerticalLines = defaultValue_default(
    this.numberOfVerticalLines,
    source.numberOfVerticalLines
  );
  this.slices = defaultValue_default(this.slices, source.slices);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
};
var CylinderGraphics_default = CylinderGraphics;

// node_modules/cesium/Source/DataSources/EllipseGraphics.js
function EllipseGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._semiMajorAxis = void 0;
  this._semiMajorAxisSubscription = void 0;
  this._semiMinorAxis = void 0;
  this._semiMinorAxisSubscription = void 0;
  this._height = void 0;
  this._heightSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._extrudedHeight = void 0;
  this._extrudedHeightSubscription = void 0;
  this._extrudedHeightReference = void 0;
  this._extrudedHeightReferenceSubscription = void 0;
  this._rotation = void 0;
  this._rotationSubscription = void 0;
  this._stRotation = void 0;
  this._stRotationSubscription = void 0;
  this._granularity = void 0;
  this._granularitySubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._numberOfVerticalLines = void 0;
  this._numberOfVerticalLinesSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this._classificationType = void 0;
  this._classificationTypeSubscription = void 0;
  this._zIndex = void 0;
  this._zIndexSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(EllipseGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  semiMajorAxis: createPropertyDescriptor_default("semiMajorAxis"),
  semiMinorAxis: createPropertyDescriptor_default("semiMinorAxis"),
  height: createPropertyDescriptor_default("height"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  extrudedHeight: createPropertyDescriptor_default("extrudedHeight"),
  extrudedHeightReference: createPropertyDescriptor_default("extrudedHeightReference"),
  rotation: createPropertyDescriptor_default("rotation"),
  stRotation: createPropertyDescriptor_default("stRotation"),
  granularity: createPropertyDescriptor_default("granularity"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  numberOfVerticalLines: createPropertyDescriptor_default("numberOfVerticalLines"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  ),
  classificationType: createPropertyDescriptor_default("classificationType"),
  zIndex: createPropertyDescriptor_default("zIndex")
});
EllipseGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new EllipseGraphics(this);
  }
  result.show = this.show;
  result.semiMajorAxis = this.semiMajorAxis;
  result.semiMinorAxis = this.semiMinorAxis;
  result.height = this.height;
  result.heightReference = this.heightReference;
  result.extrudedHeight = this.extrudedHeight;
  result.extrudedHeightReference = this.extrudedHeightReference;
  result.rotation = this.rotation;
  result.stRotation = this.stRotation;
  result.granularity = this.granularity;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.numberOfVerticalLines = this.numberOfVerticalLines;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  result.classificationType = this.classificationType;
  result.zIndex = this.zIndex;
  return result;
};
EllipseGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.semiMajorAxis = defaultValue_default(this.semiMajorAxis, source.semiMajorAxis);
  this.semiMinorAxis = defaultValue_default(this.semiMinorAxis, source.semiMinorAxis);
  this.height = defaultValue_default(this.height, source.height);
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.extrudedHeight = defaultValue_default(
    this.extrudedHeight,
    source.extrudedHeight
  );
  this.extrudedHeightReference = defaultValue_default(
    this.extrudedHeightReference,
    source.extrudedHeightReference
  );
  this.rotation = defaultValue_default(this.rotation, source.rotation);
  this.stRotation = defaultValue_default(this.stRotation, source.stRotation);
  this.granularity = defaultValue_default(this.granularity, source.granularity);
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.numberOfVerticalLines = defaultValue_default(
    this.numberOfVerticalLines,
    source.numberOfVerticalLines
  );
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
  this.classificationType = defaultValue_default(
    this.classificationType,
    source.classificationType
  );
  this.zIndex = defaultValue_default(this.zIndex, source.zIndex);
};
var EllipseGraphics_default = EllipseGraphics;

// node_modules/cesium/Source/DataSources/EllipsoidGraphics.js
function EllipsoidGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._radii = void 0;
  this._radiiSubscription = void 0;
  this._innerRadii = void 0;
  this._innerRadiiSubscription = void 0;
  this._minimumClock = void 0;
  this._minimumClockSubscription = void 0;
  this._maximumClock = void 0;
  this._maximumClockSubscription = void 0;
  this._minimumCone = void 0;
  this._minimumConeSubscription = void 0;
  this._maximumCone = void 0;
  this._maximumConeSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._stackPartitions = void 0;
  this._stackPartitionsSubscription = void 0;
  this._slicePartitions = void 0;
  this._slicePartitionsSubscription = void 0;
  this._subdivisions = void 0;
  this._subdivisionsSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(EllipsoidGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  radii: createPropertyDescriptor_default("radii"),
  innerRadii: createPropertyDescriptor_default("innerRadii"),
  minimumClock: createPropertyDescriptor_default("minimumClock"),
  maximumClock: createPropertyDescriptor_default("maximumClock"),
  minimumCone: createPropertyDescriptor_default("minimumCone"),
  maximumCone: createPropertyDescriptor_default("maximumCone"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  stackPartitions: createPropertyDescriptor_default("stackPartitions"),
  slicePartitions: createPropertyDescriptor_default("slicePartitions"),
  subdivisions: createPropertyDescriptor_default("subdivisions"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  )
});
EllipsoidGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new EllipsoidGraphics(this);
  }
  result.show = this.show;
  result.radii = this.radii;
  result.innerRadii = this.innerRadii;
  result.minimumClock = this.minimumClock;
  result.maximumClock = this.maximumClock;
  result.minimumCone = this.minimumCone;
  result.maximumCone = this.maximumCone;
  result.heightReference = this.heightReference;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.stackPartitions = this.stackPartitions;
  result.slicePartitions = this.slicePartitions;
  result.subdivisions = this.subdivisions;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  return result;
};
EllipsoidGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.radii = defaultValue_default(this.radii, source.radii);
  this.innerRadii = defaultValue_default(this.innerRadii, source.innerRadii);
  this.minimumClock = defaultValue_default(this.minimumClock, source.minimumClock);
  this.maximumClock = defaultValue_default(this.maximumClock, source.maximumClock);
  this.minimumCone = defaultValue_default(this.minimumCone, source.minimumCone);
  this.maximumCone = defaultValue_default(this.maximumCone, source.maximumCone);
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.stackPartitions = defaultValue_default(
    this.stackPartitions,
    source.stackPartitions
  );
  this.slicePartitions = defaultValue_default(
    this.slicePartitions,
    source.slicePartitions
  );
  this.subdivisions = defaultValue_default(this.subdivisions, source.subdivisions);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
};
var EllipsoidGraphics_default = EllipsoidGraphics;

// node_modules/cesium/Source/DataSources/LabelGraphics.js
function LabelGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._text = void 0;
  this._textSubscription = void 0;
  this._font = void 0;
  this._fontSubscription = void 0;
  this._style = void 0;
  this._styleSubscription = void 0;
  this._scale = void 0;
  this._scaleSubscription = void 0;
  this._showBackground = void 0;
  this._showBackgroundSubscription = void 0;
  this._backgroundColor = void 0;
  this._backgroundColorSubscription = void 0;
  this._backgroundPadding = void 0;
  this._backgroundPaddingSubscription = void 0;
  this._pixelOffset = void 0;
  this._pixelOffsetSubscription = void 0;
  this._eyeOffset = void 0;
  this._eyeOffsetSubscription = void 0;
  this._horizontalOrigin = void 0;
  this._horizontalOriginSubscription = void 0;
  this._verticalOrigin = void 0;
  this._verticalOriginSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._fillColor = void 0;
  this._fillColorSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._translucencyByDistance = void 0;
  this._translucencyByDistanceSubscription = void 0;
  this._pixelOffsetScaleByDistance = void 0;
  this._pixelOffsetScaleByDistanceSubscription = void 0;
  this._scaleByDistance = void 0;
  this._scaleByDistanceSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this._disableDepthTestDistance = void 0;
  this._disableDepthTestDistanceSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(LabelGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  text: createPropertyDescriptor_default("text"),
  font: createPropertyDescriptor_default("font"),
  style: createPropertyDescriptor_default("style"),
  scale: createPropertyDescriptor_default("scale"),
  showBackground: createPropertyDescriptor_default("showBackground"),
  backgroundColor: createPropertyDescriptor_default("backgroundColor"),
  backgroundPadding: createPropertyDescriptor_default("backgroundPadding"),
  pixelOffset: createPropertyDescriptor_default("pixelOffset"),
  eyeOffset: createPropertyDescriptor_default("eyeOffset"),
  horizontalOrigin: createPropertyDescriptor_default("horizontalOrigin"),
  verticalOrigin: createPropertyDescriptor_default("verticalOrigin"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  fillColor: createPropertyDescriptor_default("fillColor"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  translucencyByDistance: createPropertyDescriptor_default("translucencyByDistance"),
  pixelOffsetScaleByDistance: createPropertyDescriptor_default(
    "pixelOffsetScaleByDistance"
  ),
  scaleByDistance: createPropertyDescriptor_default("scaleByDistance"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  ),
  disableDepthTestDistance: createPropertyDescriptor_default(
    "disableDepthTestDistance"
  )
});
LabelGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new LabelGraphics(this);
  }
  result.show = this.show;
  result.text = this.text;
  result.font = this.font;
  result.style = this.style;
  result.scale = this.scale;
  result.showBackground = this.showBackground;
  result.backgroundColor = this.backgroundColor;
  result.backgroundPadding = this.backgroundPadding;
  result.pixelOffset = this.pixelOffset;
  result.eyeOffset = this.eyeOffset;
  result.horizontalOrigin = this.horizontalOrigin;
  result.verticalOrigin = this.verticalOrigin;
  result.heightReference = this.heightReference;
  result.fillColor = this.fillColor;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.translucencyByDistance = this.translucencyByDistance;
  result.pixelOffsetScaleByDistance = this.pixelOffsetScaleByDistance;
  result.scaleByDistance = this.scaleByDistance;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  result.disableDepthTestDistance = this.disableDepthTestDistance;
  return result;
};
LabelGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.text = defaultValue_default(this.text, source.text);
  this.font = defaultValue_default(this.font, source.font);
  this.style = defaultValue_default(this.style, source.style);
  this.scale = defaultValue_default(this.scale, source.scale);
  this.showBackground = defaultValue_default(
    this.showBackground,
    source.showBackground
  );
  this.backgroundColor = defaultValue_default(
    this.backgroundColor,
    source.backgroundColor
  );
  this.backgroundPadding = defaultValue_default(
    this.backgroundPadding,
    source.backgroundPadding
  );
  this.pixelOffset = defaultValue_default(this.pixelOffset, source.pixelOffset);
  this.eyeOffset = defaultValue_default(this.eyeOffset, source.eyeOffset);
  this.horizontalOrigin = defaultValue_default(
    this.horizontalOrigin,
    source.horizontalOrigin
  );
  this.verticalOrigin = defaultValue_default(
    this.verticalOrigin,
    source.verticalOrigin
  );
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.fillColor = defaultValue_default(this.fillColor, source.fillColor);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.translucencyByDistance = defaultValue_default(
    this.translucencyByDistance,
    source.translucencyByDistance
  );
  this.pixelOffsetScaleByDistance = defaultValue_default(
    this.pixelOffsetScaleByDistance,
    source.pixelOffsetScaleByDistance
  );
  this.scaleByDistance = defaultValue_default(
    this.scaleByDistance,
    source.scaleByDistance
  );
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
  this.disableDepthTestDistance = defaultValue_default(
    this.disableDepthTestDistance,
    source.disableDepthTestDistance
  );
};
var LabelGraphics_default = LabelGraphics;

// node_modules/cesium/Source/DataSources/NodeTransformationProperty.js
var defaultNodeTransformation = new TranslationRotationScale_default();
function NodeTransformationProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._definitionChanged = new Event_default();
  this._translation = void 0;
  this._translationSubscription = void 0;
  this._rotation = void 0;
  this._rotationSubscription = void 0;
  this._scale = void 0;
  this._scaleSubscription = void 0;
  this.translation = options.translation;
  this.rotation = options.rotation;
  this.scale = options.scale;
}
Object.defineProperties(NodeTransformationProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._translation) && Property_default.isConstant(this._rotation) && Property_default.isConstant(this._scale);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  translation: createPropertyDescriptor_default("translation"),
  rotation: createPropertyDescriptor_default("rotation"),
  scale: createPropertyDescriptor_default("scale")
});
NodeTransformationProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = new TranslationRotationScale_default();
  }
  result.translation = Property_default.getValueOrClonedDefault(
    this._translation,
    time,
    defaultNodeTransformation.translation,
    result.translation
  );
  result.rotation = Property_default.getValueOrClonedDefault(
    this._rotation,
    time,
    defaultNodeTransformation.rotation,
    result.rotation
  );
  result.scale = Property_default.getValueOrClonedDefault(
    this._scale,
    time,
    defaultNodeTransformation.scale,
    result.scale
  );
  return result;
};
NodeTransformationProperty.prototype.equals = function(other) {
  return this === other || other instanceof NodeTransformationProperty && Property_default.equals(this._translation, other._translation) && Property_default.equals(this._rotation, other._rotation) && Property_default.equals(this._scale, other._scale);
};
var NodeTransformationProperty_default = NodeTransformationProperty;

// node_modules/cesium/Source/DataSources/PropertyBag.js
function PropertyBag(value, createPropertyCallback) {
  this._propertyNames = [];
  this._definitionChanged = new Event_default();
  if (defined_default(value)) {
    this.merge(value, createPropertyCallback);
  }
}
Object.defineProperties(PropertyBag.prototype, {
  propertyNames: {
    get: function() {
      return this._propertyNames;
    }
  },
  isConstant: {
    get: function() {
      const propertyNames = this._propertyNames;
      for (let i2 = 0, len = propertyNames.length; i2 < len; i2++) {
        if (!Property_default.isConstant(this[propertyNames[i2]])) {
          return false;
        }
      }
      return true;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  }
});
PropertyBag.prototype.hasProperty = function(propertyName) {
  return this._propertyNames.indexOf(propertyName) !== -1;
};
function createConstantProperty2(value) {
  return new ConstantProperty_default(value);
}
PropertyBag.prototype.addProperty = function(propertyName, value, createPropertyCallback) {
  const propertyNames = this._propertyNames;
  if (!defined_default(propertyName)) {
    throw new DeveloperError_default("propertyName is required.");
  }
  if (propertyNames.indexOf(propertyName) !== -1) {
    throw new DeveloperError_default(
      `${propertyName} is already a registered property.`
    );
  }
  propertyNames.push(propertyName);
  Object.defineProperty(
    this,
    propertyName,
    createPropertyDescriptor_default(
      propertyName,
      true,
      defaultValue_default(createPropertyCallback, createConstantProperty2)
    )
  );
  if (defined_default(value)) {
    this[propertyName] = value;
  }
  this._definitionChanged.raiseEvent(this);
};
PropertyBag.prototype.removeProperty = function(propertyName) {
  const propertyNames = this._propertyNames;
  const index2 = propertyNames.indexOf(propertyName);
  if (!defined_default(propertyName)) {
    throw new DeveloperError_default("propertyName is required.");
  }
  if (index2 === -1) {
    throw new DeveloperError_default(`${propertyName} is not a registered property.`);
  }
  this._propertyNames.splice(index2, 1);
  delete this[propertyName];
  this._definitionChanged.raiseEvent(this);
};
PropertyBag.prototype.getValue = function(time, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  if (!defined_default(result)) {
    result = {};
  }
  const propertyNames = this._propertyNames;
  for (let i2 = 0, len = propertyNames.length; i2 < len; i2++) {
    const propertyName = propertyNames[i2];
    result[propertyName] = Property_default.getValueOrUndefined(
      this[propertyName],
      time,
      result[propertyName]
    );
  }
  return result;
};
PropertyBag.prototype.merge = function(source, createPropertyCallback) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  const propertyNames = this._propertyNames;
  const sourcePropertyNames = defined_default(source._propertyNames) ? source._propertyNames : Object.keys(source);
  for (let i2 = 0, len = sourcePropertyNames.length; i2 < len; i2++) {
    const name = sourcePropertyNames[i2];
    const targetProperty = this[name];
    const sourceProperty = source[name];
    if (targetProperty === void 0 && propertyNames.indexOf(name) === -1) {
      this.addProperty(name, void 0, createPropertyCallback);
    }
    if (sourceProperty !== void 0) {
      if (targetProperty !== void 0) {
        if (defined_default(targetProperty) && defined_default(targetProperty.merge)) {
          targetProperty.merge(sourceProperty);
        }
      } else if (defined_default(sourceProperty) && defined_default(sourceProperty.merge) && defined_default(sourceProperty.clone)) {
        this[name] = sourceProperty.clone();
      } else {
        this[name] = sourceProperty;
      }
    }
  }
};
function propertiesEqual(a4, b) {
  const aPropertyNames = a4._propertyNames;
  const bPropertyNames = b._propertyNames;
  const len = aPropertyNames.length;
  if (len !== bPropertyNames.length) {
    return false;
  }
  for (let aIndex = 0; aIndex < len; ++aIndex) {
    const name = aPropertyNames[aIndex];
    const bIndex = bPropertyNames.indexOf(name);
    if (bIndex === -1) {
      return false;
    }
    if (!Property_default.equals(a4[name], b[name])) {
      return false;
    }
  }
  return true;
}
PropertyBag.prototype.equals = function(other) {
  return this === other || other instanceof PropertyBag && propertiesEqual(this, other);
};
var PropertyBag_default = PropertyBag;

// node_modules/cesium/Source/DataSources/ModelGraphics.js
function createNodeTransformationProperty(value) {
  return new NodeTransformationProperty_default(value);
}
function createNodeTransformationPropertyBag(value) {
  return new PropertyBag_default(value, createNodeTransformationProperty);
}
function createArticulationStagePropertyBag(value) {
  return new PropertyBag_default(value);
}
function ModelGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._uri = void 0;
  this._uriSubscription = void 0;
  this._scale = void 0;
  this._scaleSubscription = void 0;
  this._minimumPixelSize = void 0;
  this._minimumPixelSizeSubscription = void 0;
  this._maximumScale = void 0;
  this._maximumScaleSubscription = void 0;
  this._incrementallyLoadTextures = void 0;
  this._incrementallyLoadTexturesSubscription = void 0;
  this._runAnimations = void 0;
  this._runAnimationsSubscription = void 0;
  this._clampAnimations = void 0;
  this._clampAnimationsSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._silhouetteColor = void 0;
  this._silhouetteColorSubscription = void 0;
  this._silhouetteSize = void 0;
  this._silhouetteSizeSubscription = void 0;
  this._color = void 0;
  this._colorSubscription = void 0;
  this._colorBlendMode = void 0;
  this._colorBlendModeSubscription = void 0;
  this._colorBlendAmount = void 0;
  this._colorBlendAmountSubscription = void 0;
  this._imageBasedLightingFactor = void 0;
  this._imageBasedLightingFactorSubscription = void 0;
  this._lightColor = void 0;
  this._lightColorSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this._nodeTransformations = void 0;
  this._nodeTransformationsSubscription = void 0;
  this._articulations = void 0;
  this._articulationsSubscription = void 0;
  this._clippingPlanes = void 0;
  this._clippingPlanesSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(ModelGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  uri: createPropertyDescriptor_default("uri"),
  scale: createPropertyDescriptor_default("scale"),
  minimumPixelSize: createPropertyDescriptor_default("minimumPixelSize"),
  maximumScale: createPropertyDescriptor_default("maximumScale"),
  incrementallyLoadTextures: createPropertyDescriptor_default(
    "incrementallyLoadTextures"
  ),
  runAnimations: createPropertyDescriptor_default("runAnimations"),
  clampAnimations: createPropertyDescriptor_default("clampAnimations"),
  shadows: createPropertyDescriptor_default("shadows"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  silhouetteColor: createPropertyDescriptor_default("silhouetteColor"),
  silhouetteSize: createPropertyDescriptor_default("silhouetteSize"),
  color: createPropertyDescriptor_default("color"),
  colorBlendMode: createPropertyDescriptor_default("colorBlendMode"),
  colorBlendAmount: createPropertyDescriptor_default("colorBlendAmount"),
  imageBasedLightingFactor: createPropertyDescriptor_default(
    "imageBasedLightingFactor"
  ),
  lightColor: createPropertyDescriptor_default("lightColor"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  ),
  nodeTransformations: createPropertyDescriptor_default(
    "nodeTransformations",
    void 0,
    createNodeTransformationPropertyBag
  ),
  articulations: createPropertyDescriptor_default(
    "articulations",
    void 0,
    createArticulationStagePropertyBag
  ),
  clippingPlanes: createPropertyDescriptor_default("clippingPlanes")
});
ModelGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new ModelGraphics(this);
  }
  result.show = this.show;
  result.uri = this.uri;
  result.scale = this.scale;
  result.minimumPixelSize = this.minimumPixelSize;
  result.maximumScale = this.maximumScale;
  result.incrementallyLoadTextures = this.incrementallyLoadTextures;
  result.runAnimations = this.runAnimations;
  result.clampAnimations = this.clampAnimations;
  result.heightReference = this._heightReference;
  result.silhouetteColor = this.silhouetteColor;
  result.silhouetteSize = this.silhouetteSize;
  result.color = this.color;
  result.colorBlendMode = this.colorBlendMode;
  result.colorBlendAmount = this.colorBlendAmount;
  result.imageBasedLightingFactor = this.imageBasedLightingFactor;
  result.lightColor = this.lightColor;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  result.nodeTransformations = this.nodeTransformations;
  result.articulations = this.articulations;
  result.clippingPlanes = this.clippingPlanes;
  return result;
};
ModelGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.uri = defaultValue_default(this.uri, source.uri);
  this.scale = defaultValue_default(this.scale, source.scale);
  this.minimumPixelSize = defaultValue_default(
    this.minimumPixelSize,
    source.minimumPixelSize
  );
  this.maximumScale = defaultValue_default(this.maximumScale, source.maximumScale);
  this.incrementallyLoadTextures = defaultValue_default(
    this.incrementallyLoadTextures,
    source.incrementallyLoadTextures
  );
  this.runAnimations = defaultValue_default(this.runAnimations, source.runAnimations);
  this.clampAnimations = defaultValue_default(
    this.clampAnimations,
    source.clampAnimations
  );
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.silhouetteColor = defaultValue_default(
    this.silhouetteColor,
    source.silhouetteColor
  );
  this.silhouetteSize = defaultValue_default(
    this.silhouetteSize,
    source.silhouetteSize
  );
  this.color = defaultValue_default(this.color, source.color);
  this.colorBlendMode = defaultValue_default(
    this.colorBlendMode,
    source.colorBlendMode
  );
  this.colorBlendAmount = defaultValue_default(
    this.colorBlendAmount,
    source.colorBlendAmount
  );
  this.imageBasedLightingFactor = defaultValue_default(
    this.imageBasedLightingFactor,
    source.imageBasedLightingFactor
  );
  this.lightColor = defaultValue_default(this.lightColor, source.lightColor);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
  this.clippingPlanes = defaultValue_default(
    this.clippingPlanes,
    source.clippingPlanes
  );
  const sourceNodeTransformations = source.nodeTransformations;
  if (defined_default(sourceNodeTransformations)) {
    const targetNodeTransformations = this.nodeTransformations;
    if (defined_default(targetNodeTransformations)) {
      targetNodeTransformations.merge(sourceNodeTransformations);
    } else {
      this.nodeTransformations = new PropertyBag_default(
        sourceNodeTransformations,
        createNodeTransformationProperty
      );
    }
  }
  const sourceArticulations = source.articulations;
  if (defined_default(sourceArticulations)) {
    const targetArticulations = this.articulations;
    if (defined_default(targetArticulations)) {
      targetArticulations.merge(sourceArticulations);
    } else {
      this.articulations = new PropertyBag_default(sourceArticulations);
    }
  }
};
var ModelGraphics_default = ModelGraphics;

// node_modules/cesium/Source/DataSources/Cesium3DTilesetGraphics.js
function Cesium3DTilesetGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._uri = void 0;
  this._uriSubscription = void 0;
  this._maximumScreenSpaceError = void 0;
  this._maximumScreenSpaceErrorSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(Cesium3DTilesetGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  uri: createPropertyDescriptor_default("uri"),
  maximumScreenSpaceError: createPropertyDescriptor_default("maximumScreenSpaceError")
});
Cesium3DTilesetGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new Cesium3DTilesetGraphics(this);
  }
  result.show = this.show;
  result.uri = this.uri;
  result.maximumScreenSpaceError = this.maximumScreenSpaceError;
  return result;
};
Cesium3DTilesetGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.uri = defaultValue_default(this.uri, source.uri);
  this.maximumScreenSpaceError = defaultValue_default(
    this.maximumScreenSpaceError,
    source.maximumScreenSpaceError
  );
};
var Cesium3DTilesetGraphics_default = Cesium3DTilesetGraphics;

// node_modules/cesium/Source/DataSources/PathGraphics.js
function PathGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._leadTime = void 0;
  this._leadTimeSubscription = void 0;
  this._trailTime = void 0;
  this._trailTimeSubscription = void 0;
  this._width = void 0;
  this._widthSubscription = void 0;
  this._resolution = void 0;
  this._resolutionSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(PathGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  leadTime: createPropertyDescriptor_default("leadTime"),
  trailTime: createPropertyDescriptor_default("trailTime"),
  width: createPropertyDescriptor_default("width"),
  resolution: createPropertyDescriptor_default("resolution"),
  material: createMaterialPropertyDescriptor_default("material"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  )
});
PathGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new PathGraphics(this);
  }
  result.show = this.show;
  result.leadTime = this.leadTime;
  result.trailTime = this.trailTime;
  result.width = this.width;
  result.resolution = this.resolution;
  result.material = this.material;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  return result;
};
PathGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.leadTime = defaultValue_default(this.leadTime, source.leadTime);
  this.trailTime = defaultValue_default(this.trailTime, source.trailTime);
  this.width = defaultValue_default(this.width, source.width);
  this.resolution = defaultValue_default(this.resolution, source.resolution);
  this.material = defaultValue_default(this.material, source.material);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
};
var PathGraphics_default = PathGraphics;

// node_modules/cesium/Source/DataSources/PlaneGraphics.js
function PlaneGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._plane = void 0;
  this._planeSubscription = void 0;
  this._dimensions = void 0;
  this._dimensionsSubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(PlaneGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  plane: createPropertyDescriptor_default("plane"),
  dimensions: createPropertyDescriptor_default("dimensions"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  )
});
PlaneGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new PlaneGraphics(this);
  }
  result.show = this.show;
  result.plane = this.plane;
  result.dimensions = this.dimensions;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  return result;
};
PlaneGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.plane = defaultValue_default(this.plane, source.plane);
  this.dimensions = defaultValue_default(this.dimensions, source.dimensions);
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
};
var PlaneGraphics_default = PlaneGraphics;

// node_modules/cesium/Source/DataSources/PointGraphics.js
function PointGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._pixelSize = void 0;
  this._pixelSizeSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._color = void 0;
  this._colorSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._scaleByDistance = void 0;
  this._scaleByDistanceSubscription = void 0;
  this._translucencyByDistance = void 0;
  this._translucencyByDistanceSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this._disableDepthTestDistance = void 0;
  this._disableDepthTestDistanceSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(PointGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  pixelSize: createPropertyDescriptor_default("pixelSize"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  color: createPropertyDescriptor_default("color"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  scaleByDistance: createPropertyDescriptor_default("scaleByDistance"),
  translucencyByDistance: createPropertyDescriptor_default("translucencyByDistance"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  ),
  disableDepthTestDistance: createPropertyDescriptor_default(
    "disableDepthTestDistance"
  )
});
PointGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new PointGraphics(this);
  }
  result.show = this.show;
  result.pixelSize = this.pixelSize;
  result.heightReference = this.heightReference;
  result.color = this.color;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.scaleByDistance = this.scaleByDistance;
  result.translucencyByDistance = this._translucencyByDistance;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  result.disableDepthTestDistance = this.disableDepthTestDistance;
  return result;
};
PointGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.pixelSize = defaultValue_default(this.pixelSize, source.pixelSize);
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.color = defaultValue_default(this.color, source.color);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.scaleByDistance = defaultValue_default(
    this.scaleByDistance,
    source.scaleByDistance
  );
  this.translucencyByDistance = defaultValue_default(
    this._translucencyByDistance,
    source.translucencyByDistance
  );
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
  this.disableDepthTestDistance = defaultValue_default(
    this.disableDepthTestDistance,
    source.disableDepthTestDistance
  );
};
var PointGraphics_default = PointGraphics;

// node_modules/cesium/Source/DataSources/PolygonGraphics.js
function createPolygonHierarchyProperty(value) {
  if (Array.isArray(value)) {
    value = new PolygonHierarchy_default(value);
  }
  return new ConstantProperty_default(value);
}
function PolygonGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._hierarchy = void 0;
  this._hierarchySubscription = void 0;
  this._height = void 0;
  this._heightSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._extrudedHeight = void 0;
  this._extrudedHeightSubscription = void 0;
  this._extrudedHeightReference = void 0;
  this._extrudedHeightReferenceSubscription = void 0;
  this._stRotation = void 0;
  this._stRotationSubscription = void 0;
  this._granularity = void 0;
  this._granularitySubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._perPositionHeight = void 0;
  this._perPositionHeightSubscription = void 0;
  this._closeTop = void 0;
  this._closeTopSubscription = void 0;
  this._closeBottom = void 0;
  this._closeBottomSubscription = void 0;
  this._arcType = void 0;
  this._arcTypeSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this._classificationType = void 0;
  this._classificationTypeSubscription = void 0;
  this._zIndex = void 0;
  this._zIndexSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(PolygonGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  hierarchy: createPropertyDescriptor_default(
    "hierarchy",
    void 0,
    createPolygonHierarchyProperty
  ),
  height: createPropertyDescriptor_default("height"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  extrudedHeight: createPropertyDescriptor_default("extrudedHeight"),
  extrudedHeightReference: createPropertyDescriptor_default("extrudedHeightReference"),
  stRotation: createPropertyDescriptor_default("stRotation"),
  granularity: createPropertyDescriptor_default("granularity"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  perPositionHeight: createPropertyDescriptor_default("perPositionHeight"),
  closeTop: createPropertyDescriptor_default("closeTop"),
  closeBottom: createPropertyDescriptor_default("closeBottom"),
  arcType: createPropertyDescriptor_default("arcType"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  ),
  classificationType: createPropertyDescriptor_default("classificationType"),
  zIndex: createPropertyDescriptor_default("zIndex")
});
PolygonGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new PolygonGraphics(this);
  }
  result.show = this.show;
  result.hierarchy = this.hierarchy;
  result.height = this.height;
  result.heightReference = this.heightReference;
  result.extrudedHeight = this.extrudedHeight;
  result.extrudedHeightReference = this.extrudedHeightReference;
  result.stRotation = this.stRotation;
  result.granularity = this.granularity;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.perPositionHeight = this.perPositionHeight;
  result.closeTop = this.closeTop;
  result.closeBottom = this.closeBottom;
  result.arcType = this.arcType;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  result.classificationType = this.classificationType;
  result.zIndex = this.zIndex;
  return result;
};
PolygonGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.hierarchy = defaultValue_default(this.hierarchy, source.hierarchy);
  this.height = defaultValue_default(this.height, source.height);
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.extrudedHeight = defaultValue_default(
    this.extrudedHeight,
    source.extrudedHeight
  );
  this.extrudedHeightReference = defaultValue_default(
    this.extrudedHeightReference,
    source.extrudedHeightReference
  );
  this.stRotation = defaultValue_default(this.stRotation, source.stRotation);
  this.granularity = defaultValue_default(this.granularity, source.granularity);
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.perPositionHeight = defaultValue_default(
    this.perPositionHeight,
    source.perPositionHeight
  );
  this.closeTop = defaultValue_default(this.closeTop, source.closeTop);
  this.closeBottom = defaultValue_default(this.closeBottom, source.closeBottom);
  this.arcType = defaultValue_default(this.arcType, source.arcType);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
  this.classificationType = defaultValue_default(
    this.classificationType,
    source.classificationType
  );
  this.zIndex = defaultValue_default(this.zIndex, source.zIndex);
};
var PolygonGraphics_default = PolygonGraphics;

// node_modules/cesium/Source/DataSources/PolylineGraphics.js
function PolylineGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._positions = void 0;
  this._positionsSubscription = void 0;
  this._width = void 0;
  this._widthSubscription = void 0;
  this._granularity = void 0;
  this._granularitySubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._depthFailMaterial = void 0;
  this._depthFailMaterialSubscription = void 0;
  this._arcType = void 0;
  this._arcTypeSubscription = void 0;
  this._clampToGround = void 0;
  this._clampToGroundSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this._classificationType = void 0;
  this._classificationTypeSubscription = void 0;
  this._zIndex = void 0;
  this._zIndexSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(PolylineGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  positions: createPropertyDescriptor_default("positions"),
  width: createPropertyDescriptor_default("width"),
  granularity: createPropertyDescriptor_default("granularity"),
  material: createMaterialPropertyDescriptor_default("material"),
  depthFailMaterial: createMaterialPropertyDescriptor_default("depthFailMaterial"),
  arcType: createPropertyDescriptor_default("arcType"),
  clampToGround: createPropertyDescriptor_default("clampToGround"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  ),
  classificationType: createPropertyDescriptor_default("classificationType"),
  zIndex: createPropertyDescriptor_default("zIndex")
});
PolylineGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new PolylineGraphics(this);
  }
  result.show = this.show;
  result.positions = this.positions;
  result.width = this.width;
  result.granularity = this.granularity;
  result.material = this.material;
  result.depthFailMaterial = this.depthFailMaterial;
  result.arcType = this.arcType;
  result.clampToGround = this.clampToGround;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  result.classificationType = this.classificationType;
  result.zIndex = this.zIndex;
  return result;
};
PolylineGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.positions = defaultValue_default(this.positions, source.positions);
  this.width = defaultValue_default(this.width, source.width);
  this.granularity = defaultValue_default(this.granularity, source.granularity);
  this.material = defaultValue_default(this.material, source.material);
  this.depthFailMaterial = defaultValue_default(
    this.depthFailMaterial,
    source.depthFailMaterial
  );
  this.arcType = defaultValue_default(this.arcType, source.arcType);
  this.clampToGround = defaultValue_default(this.clampToGround, source.clampToGround);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
  this.classificationType = defaultValue_default(
    this.classificationType,
    source.classificationType
  );
  this.zIndex = defaultValue_default(this.zIndex, source.zIndex);
};
var PolylineGraphics_default = PolylineGraphics;

// node_modules/cesium/Source/DataSources/PolylineVolumeGraphics.js
function PolylineVolumeGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._positions = void 0;
  this._positionsSubscription = void 0;
  this._shape = void 0;
  this._shapeSubscription = void 0;
  this._cornerType = void 0;
  this._cornerTypeSubscription = void 0;
  this._granularity = void 0;
  this._granularitySubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubsription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(PolylineVolumeGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  positions: createPropertyDescriptor_default("positions"),
  shape: createPropertyDescriptor_default("shape"),
  cornerType: createPropertyDescriptor_default("cornerType"),
  granularity: createPropertyDescriptor_default("granularity"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  )
});
PolylineVolumeGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new PolylineVolumeGraphics(this);
  }
  result.show = this.show;
  result.positions = this.positions;
  result.shape = this.shape;
  result.cornerType = this.cornerType;
  result.granularity = this.granularity;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  return result;
};
PolylineVolumeGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.positions = defaultValue_default(this.positions, source.positions);
  this.shape = defaultValue_default(this.shape, source.shape);
  this.cornerType = defaultValue_default(this.cornerType, source.cornerType);
  this.granularity = defaultValue_default(this.granularity, source.granularity);
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
};
var PolylineVolumeGraphics_default = PolylineVolumeGraphics;

// node_modules/cesium/Source/DataSources/RectangleGraphics.js
function RectangleGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._coordinates = void 0;
  this._coordinatesSubscription = void 0;
  this._height = void 0;
  this._heightSubscription = void 0;
  this._heightReference = void 0;
  this._heightReferenceSubscription = void 0;
  this._extrudedHeight = void 0;
  this._extrudedHeightSubscription = void 0;
  this._extrudedHeightReference = void 0;
  this._extrudedHeightReferenceSubscription = void 0;
  this._rotation = void 0;
  this._rotationSubscription = void 0;
  this._stRotation = void 0;
  this._stRotationSubscription = void 0;
  this._granularity = void 0;
  this._granularitySubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distancedisplayConditionSubscription = void 0;
  this._classificationType = void 0;
  this._classificationTypeSubscription = void 0;
  this._zIndex = void 0;
  this._zIndexSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(RectangleGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  coordinates: createPropertyDescriptor_default("coordinates"),
  height: createPropertyDescriptor_default("height"),
  heightReference: createPropertyDescriptor_default("heightReference"),
  extrudedHeight: createPropertyDescriptor_default("extrudedHeight"),
  extrudedHeightReference: createPropertyDescriptor_default("extrudedHeightReference"),
  rotation: createPropertyDescriptor_default("rotation"),
  stRotation: createPropertyDescriptor_default("stRotation"),
  granularity: createPropertyDescriptor_default("granularity"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  ),
  classificationType: createPropertyDescriptor_default("classificationType"),
  zIndex: createPropertyDescriptor_default("zIndex")
});
RectangleGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new RectangleGraphics(this);
  }
  result.show = this.show;
  result.coordinates = this.coordinates;
  result.height = this.height;
  result.heightReference = this.heightReference;
  result.extrudedHeight = this.extrudedHeight;
  result.extrudedHeightReference = this.extrudedHeightReference;
  result.rotation = this.rotation;
  result.stRotation = this.stRotation;
  result.granularity = this.granularity;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  result.classificationType = this.classificationType;
  result.zIndex = this.zIndex;
  return result;
};
RectangleGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.coordinates = defaultValue_default(this.coordinates, source.coordinates);
  this.height = defaultValue_default(this.height, source.height);
  this.heightReference = defaultValue_default(
    this.heightReference,
    source.heightReference
  );
  this.extrudedHeight = defaultValue_default(
    this.extrudedHeight,
    source.extrudedHeight
  );
  this.extrudedHeightReference = defaultValue_default(
    this.extrudedHeightReference,
    source.extrudedHeightReference
  );
  this.rotation = defaultValue_default(this.rotation, source.rotation);
  this.stRotation = defaultValue_default(this.stRotation, source.stRotation);
  this.granularity = defaultValue_default(this.granularity, source.granularity);
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
  this.classificationType = defaultValue_default(
    this.classificationType,
    source.classificationType
  );
  this.zIndex = defaultValue_default(this.zIndex, source.zIndex);
};
var RectangleGraphics_default = RectangleGraphics;

// node_modules/cesium/Source/DataSources/WallGraphics.js
function WallGraphics(options) {
  this._definitionChanged = new Event_default();
  this._show = void 0;
  this._showSubscription = void 0;
  this._positions = void 0;
  this._positionsSubscription = void 0;
  this._minimumHeights = void 0;
  this._minimumHeightsSubscription = void 0;
  this._maximumHeights = void 0;
  this._maximumHeightsSubscription = void 0;
  this._granularity = void 0;
  this._granularitySubscription = void 0;
  this._fill = void 0;
  this._fillSubscription = void 0;
  this._material = void 0;
  this._materialSubscription = void 0;
  this._outline = void 0;
  this._outlineSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this._shadows = void 0;
  this._shadowsSubscription = void 0;
  this._distanceDisplayCondition = void 0;
  this._distanceDisplayConditionSubscription = void 0;
  this.merge(defaultValue_default(options, defaultValue_default.EMPTY_OBJECT));
}
Object.defineProperties(WallGraphics.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  show: createPropertyDescriptor_default("show"),
  positions: createPropertyDescriptor_default("positions"),
  minimumHeights: createPropertyDescriptor_default("minimumHeights"),
  maximumHeights: createPropertyDescriptor_default("maximumHeights"),
  granularity: createPropertyDescriptor_default("granularity"),
  fill: createPropertyDescriptor_default("fill"),
  material: createMaterialPropertyDescriptor_default("material"),
  outline: createPropertyDescriptor_default("outline"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth"),
  shadows: createPropertyDescriptor_default("shadows"),
  distanceDisplayCondition: createPropertyDescriptor_default(
    "distanceDisplayCondition"
  )
});
WallGraphics.prototype.clone = function(result) {
  if (!defined_default(result)) {
    return new WallGraphics(this);
  }
  result.show = this.show;
  result.positions = this.positions;
  result.minimumHeights = this.minimumHeights;
  result.maximumHeights = this.maximumHeights;
  result.granularity = this.granularity;
  result.fill = this.fill;
  result.material = this.material;
  result.outline = this.outline;
  result.outlineColor = this.outlineColor;
  result.outlineWidth = this.outlineWidth;
  result.shadows = this.shadows;
  result.distanceDisplayCondition = this.distanceDisplayCondition;
  return result;
};
WallGraphics.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.show = defaultValue_default(this.show, source.show);
  this.positions = defaultValue_default(this.positions, source.positions);
  this.minimumHeights = defaultValue_default(
    this.minimumHeights,
    source.minimumHeights
  );
  this.maximumHeights = defaultValue_default(
    this.maximumHeights,
    source.maximumHeights
  );
  this.granularity = defaultValue_default(this.granularity, source.granularity);
  this.fill = defaultValue_default(this.fill, source.fill);
  this.material = defaultValue_default(this.material, source.material);
  this.outline = defaultValue_default(this.outline, source.outline);
  this.outlineColor = defaultValue_default(this.outlineColor, source.outlineColor);
  this.outlineWidth = defaultValue_default(this.outlineWidth, source.outlineWidth);
  this.shadows = defaultValue_default(this.shadows, source.shadows);
  this.distanceDisplayCondition = defaultValue_default(
    this.distanceDisplayCondition,
    source.distanceDisplayCondition
  );
};
var WallGraphics_default = WallGraphics;

// node_modules/cesium/Source/DataSources/Entity.js
var cartoScratch2 = new Cartographic_default();
function createConstantPositionProperty(value) {
  return new ConstantPositionProperty_default(value);
}
function createPositionPropertyDescriptor(name) {
  return createPropertyDescriptor_default(
    name,
    void 0,
    createConstantPositionProperty
  );
}
function createPropertyTypeDescriptor(name, Type) {
  return createPropertyDescriptor_default(name, void 0, function(value) {
    if (value instanceof Type) {
      return value;
    }
    return new Type(value);
  });
}
function Entity(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let id = options.id;
  if (!defined_default(id)) {
    id = createGuid_default();
  }
  this._availability = void 0;
  this._id = id;
  this._definitionChanged = new Event_default();
  this._name = options.name;
  this._show = defaultValue_default(options.show, true);
  this._parent = void 0;
  this._propertyNames = [
    "billboard",
    "box",
    "corridor",
    "cylinder",
    "description",
    "ellipse",
    "ellipsoid",
    "label",
    "model",
    "tileset",
    "orientation",
    "path",
    "plane",
    "point",
    "polygon",
    "polyline",
    "polylineVolume",
    "position",
    "properties",
    "rectangle",
    "viewFrom",
    "wall"
  ];
  this._billboard = void 0;
  this._billboardSubscription = void 0;
  this._box = void 0;
  this._boxSubscription = void 0;
  this._corridor = void 0;
  this._corridorSubscription = void 0;
  this._cylinder = void 0;
  this._cylinderSubscription = void 0;
  this._description = void 0;
  this._descriptionSubscription = void 0;
  this._ellipse = void 0;
  this._ellipseSubscription = void 0;
  this._ellipsoid = void 0;
  this._ellipsoidSubscription = void 0;
  this._label = void 0;
  this._labelSubscription = void 0;
  this._model = void 0;
  this._modelSubscription = void 0;
  this._tileset = void 0;
  this._tilesetSubscription = void 0;
  this._orientation = void 0;
  this._orientationSubscription = void 0;
  this._path = void 0;
  this._pathSubscription = void 0;
  this._plane = void 0;
  this._planeSubscription = void 0;
  this._point = void 0;
  this._pointSubscription = void 0;
  this._polygon = void 0;
  this._polygonSubscription = void 0;
  this._polyline = void 0;
  this._polylineSubscription = void 0;
  this._polylineVolume = void 0;
  this._polylineVolumeSubscription = void 0;
  this._position = void 0;
  this._positionSubscription = void 0;
  this._properties = void 0;
  this._propertiesSubscription = void 0;
  this._rectangle = void 0;
  this._rectangleSubscription = void 0;
  this._viewFrom = void 0;
  this._viewFromSubscription = void 0;
  this._wall = void 0;
  this._wallSubscription = void 0;
  this._children = [];
  this.entityCollection = void 0;
  this.parent = options.parent;
  this.merge(options);
}
function updateShow(entity, children, isShowing) {
  const length3 = children.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const child = children[i2];
    const childShow = child._show;
    const oldValue2 = !isShowing && childShow;
    const newValue = isShowing && childShow;
    if (oldValue2 !== newValue) {
      updateShow(child, child._children, isShowing);
    }
  }
  entity._definitionChanged.raiseEvent(
    entity,
    "isShowing",
    isShowing,
    !isShowing
  );
}
Object.defineProperties(Entity.prototype, {
  availability: createRawPropertyDescriptor_default("availability"),
  id: {
    get: function() {
      return this._id;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  name: createRawPropertyDescriptor_default("name"),
  show: {
    get: function() {
      return this._show;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (value === this._show) {
        return;
      }
      const wasShowing = this.isShowing;
      this._show = value;
      const isShowing = this.isShowing;
      if (wasShowing !== isShowing) {
        updateShow(this, this._children, isShowing);
      }
      this._definitionChanged.raiseEvent(this, "show", value, !value);
    }
  },
  isShowing: {
    get: function() {
      return this._show && (!defined_default(this.entityCollection) || this.entityCollection.show) && (!defined_default(this._parent) || this._parent.isShowing);
    }
  },
  parent: {
    get: function() {
      return this._parent;
    },
    set: function(value) {
      const oldValue2 = this._parent;
      if (oldValue2 === value) {
        return;
      }
      const wasShowing = this.isShowing;
      if (defined_default(oldValue2)) {
        const index2 = oldValue2._children.indexOf(this);
        oldValue2._children.splice(index2, 1);
      }
      this._parent = value;
      if (defined_default(value)) {
        value._children.push(this);
      }
      const isShowing = this.isShowing;
      if (wasShowing !== isShowing) {
        updateShow(this, this._children, isShowing);
      }
      this._definitionChanged.raiseEvent(this, "parent", value, oldValue2);
    }
  },
  propertyNames: {
    get: function() {
      return this._propertyNames;
    }
  },
  billboard: createPropertyTypeDescriptor("billboard", BillboardGraphics_default),
  box: createPropertyTypeDescriptor("box", BoxGraphics_default),
  corridor: createPropertyTypeDescriptor("corridor", CorridorGraphics_default),
  cylinder: createPropertyTypeDescriptor("cylinder", CylinderGraphics_default),
  description: createPropertyDescriptor_default("description"),
  ellipse: createPropertyTypeDescriptor("ellipse", EllipseGraphics_default),
  ellipsoid: createPropertyTypeDescriptor("ellipsoid", EllipsoidGraphics_default),
  label: createPropertyTypeDescriptor("label", LabelGraphics_default),
  model: createPropertyTypeDescriptor("model", ModelGraphics_default),
  tileset: createPropertyTypeDescriptor("tileset", Cesium3DTilesetGraphics_default),
  orientation: createPropertyDescriptor_default("orientation"),
  path: createPropertyTypeDescriptor("path", PathGraphics_default),
  plane: createPropertyTypeDescriptor("plane", PlaneGraphics_default),
  point: createPropertyTypeDescriptor("point", PointGraphics_default),
  polygon: createPropertyTypeDescriptor("polygon", PolygonGraphics_default),
  polyline: createPropertyTypeDescriptor("polyline", PolylineGraphics_default),
  polylineVolume: createPropertyTypeDescriptor(
    "polylineVolume",
    PolylineVolumeGraphics_default
  ),
  properties: createPropertyTypeDescriptor("properties", PropertyBag_default),
  position: createPositionPropertyDescriptor("position"),
  rectangle: createPropertyTypeDescriptor("rectangle", RectangleGraphics_default),
  viewFrom: createPropertyDescriptor_default("viewFrom"),
  wall: createPropertyTypeDescriptor("wall", WallGraphics_default)
});
Entity.prototype.isAvailable = function(time) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  const availability = this._availability;
  return !defined_default(availability) || availability.contains(time);
};
Entity.prototype.addProperty = function(propertyName) {
  const propertyNames = this._propertyNames;
  if (!defined_default(propertyName)) {
    throw new DeveloperError_default("propertyName is required.");
  }
  if (propertyNames.indexOf(propertyName) !== -1) {
    throw new DeveloperError_default(
      `${propertyName} is already a registered property.`
    );
  }
  if (propertyName in this) {
    throw new DeveloperError_default(`${propertyName} is a reserved property name.`);
  }
  propertyNames.push(propertyName);
  Object.defineProperty(
    this,
    propertyName,
    createRawPropertyDescriptor_default(propertyName, true)
  );
};
Entity.prototype.removeProperty = function(propertyName) {
  const propertyNames = this._propertyNames;
  const index2 = propertyNames.indexOf(propertyName);
  if (!defined_default(propertyName)) {
    throw new DeveloperError_default("propertyName is required.");
  }
  if (index2 === -1) {
    throw new DeveloperError_default(`${propertyName} is not a registered property.`);
  }
  this._propertyNames.splice(index2, 1);
  delete this[propertyName];
};
Entity.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.name = defaultValue_default(this.name, source.name);
  this.availability = defaultValue_default(this.availability, source.availability);
  const propertyNames = this._propertyNames;
  const sourcePropertyNames = defined_default(source._propertyNames) ? source._propertyNames : Object.keys(source);
  const propertyNamesLength = sourcePropertyNames.length;
  for (let i2 = 0; i2 < propertyNamesLength; i2++) {
    const name = sourcePropertyNames[i2];
    if (name === "parent" || name === "name" || name === "availability") {
      continue;
    }
    const targetProperty = this[name];
    const sourceProperty = source[name];
    if (!defined_default(targetProperty) && propertyNames.indexOf(name) === -1) {
      this.addProperty(name);
    }
    if (defined_default(sourceProperty)) {
      if (defined_default(targetProperty)) {
        if (defined_default(targetProperty.merge)) {
          targetProperty.merge(sourceProperty);
        }
      } else if (defined_default(sourceProperty.merge) && defined_default(sourceProperty.clone)) {
        this[name] = sourceProperty.clone();
      } else {
        this[name] = sourceProperty;
      }
    }
  }
};
var matrix3Scratch2 = new Matrix3_default();
var positionScratch6 = new Cartesian3_default();
var orientationScratch = new Quaternion_default();
Entity.prototype.computeModelMatrix = function(time, result) {
  Check_default.typeOf.object("time", time);
  const position = Property_default.getValueOrUndefined(
    this._position,
    time,
    positionScratch6
  );
  if (!defined_default(position)) {
    return void 0;
  }
  const orientation = Property_default.getValueOrUndefined(
    this._orientation,
    time,
    orientationScratch
  );
  if (!defined_default(orientation)) {
    result = Transforms_default.eastNorthUpToFixedFrame(position, void 0, result);
  } else {
    result = Matrix4_default.fromRotationTranslation(
      Matrix3_default.fromQuaternion(orientation, matrix3Scratch2),
      position,
      result
    );
  }
  return result;
};
Entity.prototype.computeModelMatrixForHeightReference = function(time, heightReferenceProperty, heightOffset, ellipsoid, result) {
  Check_default.typeOf.object("time", time);
  const heightReference = Property_default.getValueOrDefault(
    heightReferenceProperty,
    time,
    HeightReference_default.NONE
  );
  let position = Property_default.getValueOrUndefined(
    this._position,
    time,
    positionScratch6
  );
  if (heightReference === HeightReference_default.NONE || !defined_default(position) || Cartesian3_default.equalsEpsilon(position, Cartesian3_default.ZERO, Math_default.EPSILON8)) {
    return this.computeModelMatrix(time, result);
  }
  const carto = ellipsoid.cartesianToCartographic(position, cartoScratch2);
  if (heightReference === HeightReference_default.CLAMP_TO_GROUND) {
    carto.height = heightOffset;
  } else {
    carto.height += heightOffset;
  }
  position = ellipsoid.cartographicToCartesian(carto, position);
  const orientation = Property_default.getValueOrUndefined(
    this._orientation,
    time,
    orientationScratch
  );
  if (!defined_default(orientation)) {
    result = Transforms_default.eastNorthUpToFixedFrame(position, void 0, result);
  } else {
    result = Matrix4_default.fromRotationTranslation(
      Matrix3_default.fromQuaternion(orientation, matrix3Scratch2),
      position,
      result
    );
  }
  return result;
};
Entity.supportsMaterialsforEntitiesOnTerrain = function(scene) {
  return GroundPrimitive_default.supportsMaterials(scene);
};
Entity.supportsPolylinesOnTerrain = function(scene) {
  return GroundPolylinePrimitive_default.isSupported(scene);
};
var Entity_default = Entity;

// node_modules/cesium/Source/DataSources/GeometryUpdater.js
var defaultMaterial = new ColorMaterialProperty_default(Color_default.WHITE);
var defaultShow = new ConstantProperty_default(true);
var defaultFill = new ConstantProperty_default(true);
var defaultOutline = new ConstantProperty_default(false);
var defaultOutlineColor = new ConstantProperty_default(Color_default.BLACK);
var defaultShadows = new ConstantProperty_default(ShadowMode_default.DISABLED);
var defaultDistanceDisplayCondition = new ConstantProperty_default(
  new DistanceDisplayCondition_default()
);
var defaultClassificationType = new ConstantProperty_default(ClassificationType_default.BOTH);
function GeometryUpdater(options) {
  Check_default.defined("options.entity", options.entity);
  Check_default.defined("options.scene", options.scene);
  Check_default.defined("options.geometryOptions", options.geometryOptions);
  Check_default.defined("options.geometryPropertyName", options.geometryPropertyName);
  Check_default.defined("options.observedPropertyNames", options.observedPropertyNames);
  const entity = options.entity;
  const geometryPropertyName = options.geometryPropertyName;
  this._entity = entity;
  this._scene = options.scene;
  this._fillEnabled = false;
  this._isClosed = false;
  this._onTerrain = false;
  this._dynamic = false;
  this._outlineEnabled = false;
  this._geometryChanged = new Event_default();
  this._showProperty = void 0;
  this._materialProperty = void 0;
  this._showOutlineProperty = void 0;
  this._outlineColorProperty = void 0;
  this._outlineWidth = 1;
  this._shadowsProperty = void 0;
  this._distanceDisplayConditionProperty = void 0;
  this._classificationTypeProperty = void 0;
  this._options = options.geometryOptions;
  this._geometryPropertyName = geometryPropertyName;
  this._id = `${geometryPropertyName}-${entity.id}`;
  this._observedPropertyNames = options.observedPropertyNames;
  this._supportsMaterialsforEntitiesOnTerrain = Entity_default.supportsMaterialsforEntitiesOnTerrain(
    options.scene
  );
}
Object.defineProperties(GeometryUpdater.prototype, {
  id: {
    get: function() {
      return this._id;
    }
  },
  entity: {
    get: function() {
      return this._entity;
    }
  },
  fillEnabled: {
    get: function() {
      return this._fillEnabled;
    }
  },
  hasConstantFill: {
    get: function() {
      return !this._fillEnabled || !defined_default(this._entity.availability) && Property_default.isConstant(this._showProperty) && Property_default.isConstant(this._fillProperty);
    }
  },
  fillMaterialProperty: {
    get: function() {
      return this._materialProperty;
    }
  },
  outlineEnabled: {
    get: function() {
      return this._outlineEnabled;
    }
  },
  hasConstantOutline: {
    get: function() {
      return !this._outlineEnabled || !defined_default(this._entity.availability) && Property_default.isConstant(this._showProperty) && Property_default.isConstant(this._showOutlineProperty);
    }
  },
  outlineColorProperty: {
    get: function() {
      return this._outlineColorProperty;
    }
  },
  outlineWidth: {
    get: function() {
      return this._outlineWidth;
    }
  },
  shadowsProperty: {
    get: function() {
      return this._shadowsProperty;
    }
  },
  distanceDisplayConditionProperty: {
    get: function() {
      return this._distanceDisplayConditionProperty;
    }
  },
  classificationTypeProperty: {
    get: function() {
      return this._classificationTypeProperty;
    }
  },
  isDynamic: {
    get: function() {
      return this._dynamic;
    }
  },
  isClosed: {
    get: function() {
      return this._isClosed;
    }
  },
  onTerrain: {
    get: function() {
      return this._onTerrain;
    }
  },
  geometryChanged: {
    get: function() {
      return this._geometryChanged;
    }
  }
});
GeometryUpdater.prototype.isOutlineVisible = function(time) {
  const entity = this._entity;
  const visible = this._outlineEnabled && entity.isAvailable(time) && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time);
  return defaultValue_default(visible, false);
};
GeometryUpdater.prototype.isFilled = function(time) {
  const entity = this._entity;
  const visible = this._fillEnabled && entity.isAvailable(time) && this._showProperty.getValue(time) && this._fillProperty.getValue(time);
  return defaultValue_default(visible, false);
};
GeometryUpdater.prototype.createFillGeometryInstance = DeveloperError_default.throwInstantiationError;
GeometryUpdater.prototype.createOutlineGeometryInstance = DeveloperError_default.throwInstantiationError;
GeometryUpdater.prototype.isDestroyed = function() {
  return false;
};
GeometryUpdater.prototype.destroy = function() {
  destroyObject_default(this);
};
GeometryUpdater.prototype._isHidden = function(entity, geometry) {
  const show = geometry.show;
  return defined_default(show) && show.isConstant && !show.getValue(Iso8601_default.MINIMUM_VALUE);
};
GeometryUpdater.prototype._isOnTerrain = function(entity, geometry) {
  return false;
};
GeometryUpdater.prototype._getIsClosed = function(options) {
  return true;
};
GeometryUpdater.prototype._isDynamic = DeveloperError_default.throwInstantiationError;
GeometryUpdater.prototype._setStaticOptions = DeveloperError_default.throwInstantiationError;
GeometryUpdater.prototype._onEntityPropertyChanged = function(entity, propertyName, newValue, oldValue2) {
  if (this._observedPropertyNames.indexOf(propertyName) === -1) {
    return;
  }
  const geometry = this._entity[this._geometryPropertyName];
  if (!defined_default(geometry)) {
    if (this._fillEnabled || this._outlineEnabled) {
      this._fillEnabled = false;
      this._outlineEnabled = false;
      this._geometryChanged.raiseEvent(this);
    }
    return;
  }
  const fillProperty = geometry.fill;
  const fillEnabled = defined_default(fillProperty) && fillProperty.isConstant ? fillProperty.getValue(Iso8601_default.MINIMUM_VALUE) : true;
  const outlineProperty = geometry.outline;
  let outlineEnabled = defined_default(outlineProperty);
  if (outlineEnabled && outlineProperty.isConstant) {
    outlineEnabled = outlineProperty.getValue(Iso8601_default.MINIMUM_VALUE);
  }
  if (!fillEnabled && !outlineEnabled) {
    if (this._fillEnabled || this._outlineEnabled) {
      this._fillEnabled = false;
      this._outlineEnabled = false;
      this._geometryChanged.raiseEvent(this);
    }
    return;
  }
  const show = geometry.show;
  if (this._isHidden(entity, geometry)) {
    if (this._fillEnabled || this._outlineEnabled) {
      this._fillEnabled = false;
      this._outlineEnabled = false;
      this._geometryChanged.raiseEvent(this);
    }
    return;
  }
  this._materialProperty = defaultValue_default(geometry.material, defaultMaterial);
  this._fillProperty = defaultValue_default(fillProperty, defaultFill);
  this._showProperty = defaultValue_default(show, defaultShow);
  this._showOutlineProperty = defaultValue_default(geometry.outline, defaultOutline);
  this._outlineColorProperty = outlineEnabled ? defaultValue_default(geometry.outlineColor, defaultOutlineColor) : void 0;
  this._shadowsProperty = defaultValue_default(geometry.shadows, defaultShadows);
  this._distanceDisplayConditionProperty = defaultValue_default(
    geometry.distanceDisplayCondition,
    defaultDistanceDisplayCondition
  );
  this._classificationTypeProperty = defaultValue_default(
    geometry.classificationType,
    defaultClassificationType
  );
  this._fillEnabled = fillEnabled;
  const onTerrain = this._isOnTerrain(entity, geometry) && (this._supportsMaterialsforEntitiesOnTerrain || this._materialProperty instanceof ColorMaterialProperty_default);
  if (outlineEnabled && onTerrain) {
    oneTimeWarning_default(oneTimeWarning_default.geometryOutlines);
    outlineEnabled = false;
  }
  this._onTerrain = onTerrain;
  this._outlineEnabled = outlineEnabled;
  if (this._isDynamic(entity, geometry)) {
    if (!this._dynamic) {
      this._dynamic = true;
      this._geometryChanged.raiseEvent(this);
    }
  } else {
    this._setStaticOptions(entity, geometry);
    this._isClosed = this._getIsClosed(this._options);
    const outlineWidth = geometry.outlineWidth;
    this._outlineWidth = defined_default(outlineWidth) ? outlineWidth.getValue(Iso8601_default.MINIMUM_VALUE) : 1;
    this._dynamic = false;
    this._geometryChanged.raiseEvent(this);
  }
};
GeometryUpdater.prototype.createDynamicUpdater = function(primitives, groundPrimitives) {
  Check_default.defined("primitives", primitives);
  Check_default.defined("groundPrimitives", groundPrimitives);
  if (!this._dynamic) {
    throw new DeveloperError_default(
      "This instance does not represent dynamic geometry."
    );
  }
  return new this.constructor.DynamicGeometryUpdater(
    this,
    primitives,
    groundPrimitives
  );
};
var GeometryUpdater_default = GeometryUpdater;

// node_modules/cesium/Source/DataSources/CallbackProperty.js
function CallbackProperty(callback, isConstant) {
  this._callback = void 0;
  this._isConstant = void 0;
  this._definitionChanged = new Event_default();
  this.setCallback(callback, isConstant);
}
Object.defineProperties(CallbackProperty.prototype, {
  isConstant: {
    get: function() {
      return this._isConstant;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  }
});
CallbackProperty.prototype.getValue = function(time, result) {
  return this._callback(time, result);
};
CallbackProperty.prototype.setCallback = function(callback, isConstant) {
  if (!defined_default(callback)) {
    throw new DeveloperError_default("callback is required.");
  }
  if (!defined_default(isConstant)) {
    throw new DeveloperError_default("isConstant is required.");
  }
  const changed = this._callback !== callback || this._isConstant !== isConstant;
  this._callback = callback;
  this._isConstant = isConstant;
  if (changed) {
    this._definitionChanged.raiseEvent(this);
  }
};
CallbackProperty.prototype.equals = function(other) {
  return this === other || other instanceof CallbackProperty && this._callback === other._callback && this._isConstant === other._isConstant;
};
var CallbackProperty_default = CallbackProperty;

// node_modules/cesium/Source/DataSources/TerrainOffsetProperty.js
var scratchPosition6 = new Cartesian3_default();
var scratchCarto = new Cartographic_default();
function TerrainOffsetProperty(scene, positionProperty, heightReferenceProperty, extrudedHeightReferenceProperty) {
  Check_default.defined("scene", scene);
  Check_default.defined("positionProperty", positionProperty);
  this._scene = scene;
  this._heightReference = heightReferenceProperty;
  this._extrudedHeightReference = extrudedHeightReferenceProperty;
  this._positionProperty = positionProperty;
  this._position = new Cartesian3_default();
  this._cartographicPosition = new Cartographic_default();
  this._normal = new Cartesian3_default();
  this._definitionChanged = new Event_default();
  this._terrainHeight = 0;
  this._removeCallbackFunc = void 0;
  this._removeEventListener = void 0;
  this._removeModeListener = void 0;
  const that = this;
  if (defined_default(scene.globe)) {
    this._removeEventListener = scene.terrainProviderChanged.addEventListener(
      function() {
        that._updateClamping();
      }
    );
    this._removeModeListener = scene.morphComplete.addEventListener(
      function() {
        that._updateClamping();
      }
    );
  }
  if (positionProperty.isConstant) {
    const position = positionProperty.getValue(
      Iso8601_default.MINIMUM_VALUE,
      scratchPosition6
    );
    if (!defined_default(position) || Cartesian3_default.equals(position, Cartesian3_default.ZERO) || !defined_default(scene.globe)) {
      return;
    }
    this._position = Cartesian3_default.clone(position, this._position);
    this._updateClamping();
    this._normal = scene.globe.ellipsoid.geodeticSurfaceNormal(
      position,
      this._normal
    );
  }
}
Object.defineProperties(TerrainOffsetProperty.prototype, {
  isConstant: {
    get: function() {
      return false;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  }
});
TerrainOffsetProperty.prototype._updateClamping = function() {
  if (defined_default(this._removeCallbackFunc)) {
    this._removeCallbackFunc();
  }
  const scene = this._scene;
  const globe = scene.globe;
  const position = this._position;
  if (!defined_default(globe) || Cartesian3_default.equals(position, Cartesian3_default.ZERO)) {
    this._terrainHeight = 0;
    return;
  }
  const ellipsoid = globe.ellipsoid;
  const surface = globe._surface;
  const that = this;
  const cartographicPosition = ellipsoid.cartesianToCartographic(
    position,
    this._cartographicPosition
  );
  const height = globe.getHeight(cartographicPosition);
  if (defined_default(height)) {
    this._terrainHeight = height;
  } else {
    this._terrainHeight = 0;
  }
  function updateFunction(clampedPosition) {
    if (scene.mode === SceneMode_default.SCENE3D) {
      const carto = ellipsoid.cartesianToCartographic(
        clampedPosition,
        scratchCarto
      );
      that._terrainHeight = carto.height;
    } else {
      that._terrainHeight = clampedPosition.x;
    }
    that.definitionChanged.raiseEvent();
  }
  this._removeCallbackFunc = surface.updateHeight(
    cartographicPosition,
    updateFunction
  );
};
TerrainOffsetProperty.prototype.getValue = function(time, result) {
  const heightReference = Property_default.getValueOrDefault(
    this._heightReference,
    time,
    HeightReference_default.NONE
  );
  const extrudedHeightReference = Property_default.getValueOrDefault(
    this._extrudedHeightReference,
    time,
    HeightReference_default.NONE
  );
  if (heightReference === HeightReference_default.NONE && extrudedHeightReference !== HeightReference_default.RELATIVE_TO_GROUND) {
    this._position = Cartesian3_default.clone(Cartesian3_default.ZERO, this._position);
    return Cartesian3_default.clone(Cartesian3_default.ZERO, result);
  }
  if (this._positionProperty.isConstant) {
    return Cartesian3_default.multiplyByScalar(
      this._normal,
      this._terrainHeight,
      result
    );
  }
  const scene = this._scene;
  const position = this._positionProperty.getValue(time, scratchPosition6);
  if (!defined_default(position) || Cartesian3_default.equals(position, Cartesian3_default.ZERO) || !defined_default(scene.globe)) {
    return Cartesian3_default.clone(Cartesian3_default.ZERO, result);
  }
  if (Cartesian3_default.equalsEpsilon(this._position, position, Math_default.EPSILON10)) {
    return Cartesian3_default.multiplyByScalar(
      this._normal,
      this._terrainHeight,
      result
    );
  }
  this._position = Cartesian3_default.clone(position, this._position);
  this._updateClamping();
  const normal2 = scene.globe.ellipsoid.geodeticSurfaceNormal(
    position,
    this._normal
  );
  return Cartesian3_default.multiplyByScalar(normal2, this._terrainHeight, result);
};
TerrainOffsetProperty.prototype.isDestroyed = function() {
  return false;
};
TerrainOffsetProperty.prototype.destroy = function() {
  if (defined_default(this._removeEventListener)) {
    this._removeEventListener();
  }
  if (defined_default(this._removeModeListener)) {
    this._removeModeListener();
  }
  if (defined_default(this._removeCallbackFunc)) {
    this._removeCallbackFunc();
  }
  return destroyObject_default(this);
};
var TerrainOffsetProperty_default = TerrainOffsetProperty;

// node_modules/cesium/Source/DataSources/heightReferenceOnEntityPropertyChanged.js
function heightReferenceOnEntityPropertyChanged(entity, propertyName, newValue, oldValue2) {
  GeometryUpdater_default.prototype._onEntityPropertyChanged.call(
    this,
    entity,
    propertyName,
    newValue,
    oldValue2
  );
  if (this._observedPropertyNames.indexOf(propertyName) === -1) {
    return;
  }
  const geometry = this._entity[this._geometryPropertyName];
  if (!defined_default(geometry)) {
    return;
  }
  if (defined_default(this._terrainOffsetProperty)) {
    this._terrainOffsetProperty.destroy();
    this._terrainOffsetProperty = void 0;
  }
  const heightReferenceProperty = geometry.heightReference;
  if (defined_default(heightReferenceProperty)) {
    const centerPosition = new CallbackProperty_default(
      this._computeCenter.bind(this),
      !this._dynamic
    );
    this._terrainOffsetProperty = new TerrainOffsetProperty_default(
      this._scene,
      centerPosition,
      heightReferenceProperty
    );
  }
}
var heightReferenceOnEntityPropertyChanged_default = heightReferenceOnEntityPropertyChanged;

// node_modules/cesium/Source/DataSources/BoxGeometryUpdater.js
var defaultOffset = Cartesian3_default.ZERO;
var offsetScratch4 = new Cartesian3_default();
var positionScratch7 = new Cartesian3_default();
var scratchColor = new Color_default();
function BoxGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.dimensions = void 0;
  this.offsetAttribute = void 0;
}
function BoxGeometryUpdater(entity, scene) {
  GeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new BoxGeometryOptions(entity),
    geometryPropertyName: "box",
    observedPropertyNames: ["availability", "position", "orientation", "box"]
  });
  this._onEntityPropertyChanged(entity, "box", entity.box, void 0);
}
if (defined_default(Object.create)) {
  BoxGeometryUpdater.prototype = Object.create(GeometryUpdater_default.prototype);
  BoxGeometryUpdater.prototype.constructor = BoxGeometryUpdater;
}
Object.defineProperties(BoxGeometryUpdater.prototype, {
  terrainOffsetProperty: {
    get: function() {
      return this._terrainOffsetProperty;
    }
  }
});
BoxGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const show = new ShowGeometryInstanceAttribute_default(
    isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
    distanceDisplayCondition
  );
  const attributes = {
    show,
    distanceDisplayCondition: distanceDisplayConditionAttribute,
    color: void 0,
    offset: void 0
  };
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    attributes.color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
  }
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset,
        offsetScratch4
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: BoxGeometry_default.fromDimensions(this._options),
    modelMatrix: entity.computeModelMatrixForHeightReference(
      time,
      entity.box.heightReference,
      this._options.dimensions.z * 0.5,
      this._scene.mapProjection.ellipsoid
    ),
    attributes
  });
};
BoxGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._outlineEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent an outlined geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
    ),
    color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      distanceDisplayCondition
    ),
    offset: void 0
  };
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset,
        offsetScratch4
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: BoxOutlineGeometry_default.fromDimensions(this._options),
    modelMatrix: entity.computeModelMatrixForHeightReference(
      time,
      entity.box.heightReference,
      this._options.dimensions.z * 0.5,
      this._scene.mapProjection.ellipsoid
    ),
    attributes
  });
};
BoxGeometryUpdater.prototype._computeCenter = function(time, result) {
  return Property_default.getValueOrUndefined(this._entity.position, time, result);
};
BoxGeometryUpdater.prototype._isHidden = function(entity, box) {
  return !defined_default(box.dimensions) || !defined_default(entity.position) || GeometryUpdater_default.prototype._isHidden.call(this, entity, box);
};
BoxGeometryUpdater.prototype._isDynamic = function(entity, box) {
  return !entity.position.isConstant || !Property_default.isConstant(entity.orientation) || !box.dimensions.isConstant || !Property_default.isConstant(box.outlineWidth);
};
BoxGeometryUpdater.prototype._setStaticOptions = function(entity, box) {
  const heightReference = Property_default.getValueOrDefault(
    box.heightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  const options = this._options;
  options.vertexFormat = this._materialProperty instanceof ColorMaterialProperty_default ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  options.dimensions = box.dimensions.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.dimensions
  );
  options.offsetAttribute = heightReference !== HeightReference_default.NONE ? GeometryOffsetAttribute_default.ALL : void 0;
};
BoxGeometryUpdater.prototype._onEntityPropertyChanged = heightReferenceOnEntityPropertyChanged_default;
BoxGeometryUpdater.DynamicGeometryUpdater = DynamicBoxGeometryUpdater;
function DynamicBoxGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
}
if (defined_default(Object.create)) {
  DynamicBoxGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DynamicBoxGeometryUpdater.prototype.constructor = DynamicBoxGeometryUpdater;
}
DynamicBoxGeometryUpdater.prototype._isHidden = function(entity, box, time) {
  const position = Property_default.getValueOrUndefined(
    entity.position,
    time,
    positionScratch7
  );
  const dimensions = this._options.dimensions;
  return !defined_default(position) || !defined_default(dimensions) || DynamicGeometryUpdater_default.prototype._isHidden.call(this, entity, box, time);
};
DynamicBoxGeometryUpdater.prototype._setOptions = function(entity, box, time) {
  const heightReference = Property_default.getValueOrDefault(
    box.heightReference,
    time,
    HeightReference_default.NONE
  );
  const options = this._options;
  options.dimensions = Property_default.getValueOrUndefined(
    box.dimensions,
    time,
    options.dimensions
  );
  options.offsetAttribute = heightReference !== HeightReference_default.NONE ? GeometryOffsetAttribute_default.ALL : void 0;
};
var BoxGeometryUpdater_default = BoxGeometryUpdater;

// node_modules/cesium/Source/Renderer/ComputeCommand.js
function ComputeCommand(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.vertexArray = options.vertexArray;
  this.fragmentShaderSource = options.fragmentShaderSource;
  this.shaderProgram = options.shaderProgram;
  this.uniformMap = options.uniformMap;
  this.outputTexture = options.outputTexture;
  this.preExecute = options.preExecute;
  this.postExecute = options.postExecute;
  this.canceled = options.canceled;
  this.persists = defaultValue_default(options.persists, false);
  this.pass = Pass_default.COMPUTE;
  this.owner = options.owner;
}
ComputeCommand.prototype.execute = function(computeEngine) {
  computeEngine.execute(this);
};
var ComputeCommand_default = ComputeCommand;

// node_modules/cesium/Source/Shaders/OctahedralProjectionAtlasFS.js
var OctahedralProjectionAtlasFS_default = "varying vec2 v_textureCoordinates;\n\nuniform float originalSize;\nuniform sampler2D texture0;\nuniform sampler2D texture1;\nuniform sampler2D texture2;\nuniform sampler2D texture3;\nuniform sampler2D texture4;\nuniform sampler2D texture5;\n\nconst float yMipLevel1 = 1.0 - (1.0 / pow(2.0, 1.0));\nconst float yMipLevel2 = 1.0 - (1.0 / pow(2.0, 2.0));\nconst float yMipLevel3 = 1.0 - (1.0 / pow(2.0, 3.0));\nconst float yMipLevel4 = 1.0 - (1.0 / pow(2.0, 4.0));\n\nvoid main()\n{\n    vec2 uv = v_textureCoordinates;\n    vec2 textureSize = vec2(originalSize * 1.5 + 2.0, originalSize);\n    vec2 pixel = 1.0 / textureSize;\n\n    float mipLevel = 0.0;\n\n    if (uv.x - pixel.x > (textureSize.y / textureSize.x))\n    {\n        mipLevel = 1.0;\n        if (uv.y - pixel.y > yMipLevel1)\n        {\n            mipLevel = 2.0;\n            if (uv.y - pixel.y * 3.0 > yMipLevel2)\n            {\n                mipLevel = 3.0;\n                if (uv.y - pixel.y * 5.0 > yMipLevel3)\n                {\n                    mipLevel = 4.0;\n                    if (uv.y - pixel.y * 7.0 > yMipLevel4)\n                    {\n                        mipLevel = 5.0;\n                    }\n                }\n            }\n        }\n    }\n\n    if (mipLevel > 0.0)\n    {\n        float scale = pow(2.0, mipLevel);\n\n        uv.y -= (pixel.y * (mipLevel - 1.0) * 2.0);\n        uv.x *= ((textureSize.x - 2.0) / textureSize.y);\n\n        uv.x -= 1.0 + pixel.x;\n        uv.y -= (1.0 - (1.0 / pow(2.0, mipLevel - 1.0)));\n        uv *= scale;\n    }\n    else\n    {\n        uv.x *= (textureSize.x / textureSize.y);\n    }\n\n    if(mipLevel == 0.0)\n    {\n        gl_FragColor = texture2D(texture0, uv);\n    }\n    else if(mipLevel == 1.0)\n    {\n        gl_FragColor = texture2D(texture1, uv);\n    }\n    else if(mipLevel == 2.0)\n    {\n        gl_FragColor = texture2D(texture2, uv);\n    }\n    else if(mipLevel == 3.0)\n    {\n        gl_FragColor = texture2D(texture3, uv);\n    }\n    else if(mipLevel == 4.0)\n    {\n        gl_FragColor = texture2D(texture4, uv);\n    }\n    else if(mipLevel == 5.0)\n    {\n        gl_FragColor = texture2D(texture5, uv);\n    }\n    else\n    {\n        gl_FragColor = vec4(0.0);\n    }\n}\n";

// node_modules/cesium/Source/Shaders/OctahedralProjectionFS.js
var OctahedralProjectionFS_default = "varying vec3 v_cubeMapCoordinates;\nuniform samplerCube cubeMap;\n\nvoid main()\n{\n    vec4 rgba = textureCube(cubeMap, v_cubeMapCoordinates);\n    #ifdef RGBA_NORMALIZED\n        gl_FragColor = vec4(rgba.rgb, 1.0);\n    #else\n        float m = rgba.a * 16.0;\n        vec3 r = rgba.rgb * m;\n        gl_FragColor = vec4(r * r, 1.0);\n    #endif\n}\n";

// node_modules/cesium/Source/Shaders/OctahedralProjectionVS.js
var OctahedralProjectionVS_default = "attribute vec4 position;\nattribute vec3 cubeMapCoordinates;\n\nvarying vec3 v_cubeMapCoordinates;\n\nvoid main()\n{\n    gl_Position = position;\n    v_cubeMapCoordinates = cubeMapCoordinates;\n}\n";

// node_modules/cesium/Source/Scene/OctahedralProjectedCubeMap.js
function OctahedralProjectedCubeMap(url2) {
  this._url = url2;
  this._cubeMapBuffers = void 0;
  this._cubeMaps = void 0;
  this._texture = void 0;
  this._mipTextures = void 0;
  this._va = void 0;
  this._sp = void 0;
  this._maximumMipmapLevel = void 0;
  this._loading = false;
  this._ready = false;
  this._readyPromise = defer_default();
}
Object.defineProperties(OctahedralProjectedCubeMap.prototype, {
  url: {
    get: function() {
      return this._url;
    }
  },
  texture: {
    get: function() {
      return this._texture;
    }
  },
  maximumMipmapLevel: {
    get: function() {
      return this._maximumMipmapLevel;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  }
});
OctahedralProjectedCubeMap.isSupported = function(context) {
  return context.colorBufferHalfFloat && context.halfFloatingPointTexture || context.floatingPointTexture && context.colorBufferFloat;
};
var v12 = new Cartesian3_default(1, 0, 0);
var v22 = new Cartesian3_default(0, 0, 1);
var v3 = new Cartesian3_default(-1, 0, 0);
var v4 = new Cartesian3_default(0, 0, -1);
var v5 = new Cartesian3_default(0, 1, 0);
var v6 = new Cartesian3_default(0, -1, 0);
var cubeMapCoordinates = [v5, v3, v22, v6, v12, v5, v4, v5, v5];
var length = cubeMapCoordinates.length;
var flatCubeMapCoordinates = new Float32Array(length * 3);
var offset = 0;
for (let i2 = 0; i2 < length; ++i2, offset += 3) {
  Cartesian3_default.pack(cubeMapCoordinates[i2], flatCubeMapCoordinates, offset);
}
var flatPositions = new Float32Array([
  -1,
  1,
  -1,
  0,
  0,
  1,
  0,
  0,
  1,
  0,
  1,
  1,
  0,
  -1,
  -1,
  -1,
  1,
  -1
]);
var indices = new Uint16Array([
  0,
  1,
  2,
  2,
  3,
  1,
  7,
  6,
  1,
  3,
  6,
  1,
  2,
  5,
  4,
  3,
  4,
  2,
  4,
  8,
  6,
  3,
  4,
  6
]);
function createVertexArray2(context) {
  const positionBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: flatPositions,
    usage: BufferUsage_default.STATIC_DRAW
  });
  const cubeMapCoordinatesBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: flatCubeMapCoordinates,
    usage: BufferUsage_default.STATIC_DRAW
  });
  const indexBuffer = Buffer_default.createIndexBuffer({
    context,
    typedArray: indices,
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
  });
  const attributes = [
    {
      index: 0,
      vertexBuffer: positionBuffer,
      componentsPerAttribute: 2,
      componentDatatype: ComponentDatatype_default.FLOAT
    },
    {
      index: 1,
      vertexBuffer: cubeMapCoordinatesBuffer,
      componentsPerAttribute: 3,
      componentDatatype: ComponentDatatype_default.FLOAT
    }
  ];
  return new VertexArray_default({
    context,
    attributes,
    indexBuffer
  });
}
function createUniformTexture(texture) {
  return function() {
    return texture;
  };
}
function cleanupResources(map) {
  map._va = map._va && map._va.destroy();
  map._sp = map._sp && map._sp.destroy();
  let i2;
  let length3;
  const cubeMaps = map._cubeMaps;
  if (defined_default(cubeMaps)) {
    length3 = cubeMaps.length;
    for (i2 = 0; i2 < length3; ++i2) {
      cubeMaps[i2].destroy();
    }
  }
  const mipTextures = map._mipTextures;
  if (defined_default(mipTextures)) {
    length3 = mipTextures.length;
    for (i2 = 0; i2 < length3; ++i2) {
      mipTextures[i2].destroy();
    }
  }
  map._va = void 0;
  map._sp = void 0;
  map._cubeMaps = void 0;
  map._cubeMapBuffers = void 0;
  map._mipTextures = void 0;
}
OctahedralProjectedCubeMap.prototype.update = function(frameState) {
  const context = frameState.context;
  if (!OctahedralProjectedCubeMap.isSupported(context)) {
    return;
  }
  if (defined_default(this._texture) && defined_default(this._va)) {
    cleanupResources(this);
  }
  if (defined_default(this._texture)) {
    return;
  }
  if (!defined_default(this._texture) && !this._loading) {
    const cachedTexture = context.textureCache.getTexture(this._url);
    if (defined_default(cachedTexture)) {
      cleanupResources(this);
      this._texture = cachedTexture;
      this._maximumMipmapLevel = this._texture.maximumMipmapLevel;
      this._ready = true;
      this._readyPromise.resolve();
      return;
    }
  }
  const cubeMapBuffers = this._cubeMapBuffers;
  if (!defined_default(cubeMapBuffers) && !this._loading) {
    const that = this;
    loadKTX2_default(this._url).then(function(buffers) {
      that._cubeMapBuffers = buffers;
      that._loading = false;
    }).catch(function(e2) {
      that._readyPromise.reject(e2);
    });
    this._loading = true;
  }
  if (!defined_default(this._cubeMapBuffers)) {
    return;
  }
  const defines = [];
  let pixelDatatype = cubeMapBuffers[0].positiveX.pixelDatatype;
  if (!defined_default(pixelDatatype)) {
    pixelDatatype = context.halfFloatingPointTexture ? PixelDatatype_default.HALF_FLOAT : PixelDatatype_default.FLOAT;
  } else {
    defines.push("RGBA_NORMALIZED");
  }
  const pixelFormat = PixelFormat_default.RGBA;
  const fs = new ShaderSource_default({
    defines,
    sources: [OctahedralProjectionFS_default]
  });
  this._va = createVertexArray2(context);
  this._sp = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: OctahedralProjectionVS_default,
    fragmentShaderSource: fs,
    attributeLocations: {
      position: 0,
      cubeMapCoordinates: 1
    }
  });
  const length3 = Math.min(cubeMapBuffers.length, 6);
  this._maximumMipmapLevel = length3 - 1;
  const cubeMaps = this._cubeMaps = new Array(length3);
  const mipTextures = this._mipTextures = new Array(length3);
  const originalSize = cubeMapBuffers[0].positiveX.width * 2;
  const uniformMap2 = {
    originalSize: function() {
      return originalSize;
    }
  };
  for (let i2 = 0; i2 < length3; ++i2) {
    const positiveY = cubeMapBuffers[i2].positiveY;
    cubeMapBuffers[i2].positiveY = cubeMapBuffers[i2].negativeY;
    cubeMapBuffers[i2].negativeY = positiveY;
    const cubeMap = cubeMaps[i2] = new CubeMap_default({
      context,
      source: cubeMapBuffers[i2],
      pixelDatatype
    });
    const size = cubeMaps[i2].width * 2;
    const mipTexture = mipTextures[i2] = new Texture_default({
      context,
      width: size,
      height: size,
      pixelDatatype,
      pixelFormat
    });
    const command = new ComputeCommand_default({
      vertexArray: this._va,
      shaderProgram: this._sp,
      uniformMap: {
        cubeMap: createUniformTexture(cubeMap)
      },
      outputTexture: mipTexture,
      persists: true,
      owner: this
    });
    frameState.commandList.push(command);
    uniformMap2[`texture${i2}`] = createUniformTexture(mipTexture);
  }
  this._texture = new Texture_default({
    context,
    width: originalSize * 1.5 + 2,
    height: originalSize,
    pixelDatatype,
    pixelFormat
  });
  this._texture.maximumMipmapLevel = this._maximumMipmapLevel;
  context.textureCache.addTexture(this._url, this._texture);
  const atlasCommand = new ComputeCommand_default({
    fragmentShaderSource: OctahedralProjectionAtlasFS_default,
    uniformMap: uniformMap2,
    outputTexture: this._texture,
    persists: false,
    owner: this
  });
  frameState.commandList.push(atlasCommand);
  this._ready = true;
  this._readyPromise.resolve();
};
OctahedralProjectedCubeMap.prototype.isDestroyed = function() {
  return false;
};
OctahedralProjectedCubeMap.prototype.destroy = function() {
  cleanupResources(this);
  this._texture = this._texture && this._texture.destroy();
  return destroyObject_default(this);
};
var OctahedralProjectedCubeMap_default = OctahedralProjectedCubeMap;

// node_modules/cesium/Source/Scene/ImageBasedLighting.js
function ImageBasedLighting(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const imageBasedLightingFactor = defined_default(options.imageBasedLightingFactor) ? Cartesian2_default.clone(options.imageBasedLightingFactor) : new Cartesian2_default(1, 1);
  Check_default.typeOf.object(
    "options.imageBasedLightingFactor",
    imageBasedLightingFactor
  );
  Check_default.typeOf.number.greaterThanOrEquals(
    "options.imageBasedLightingFactor.x",
    imageBasedLightingFactor.x,
    0
  );
  Check_default.typeOf.number.lessThanOrEquals(
    "options.imageBasedLightingFactor.x",
    imageBasedLightingFactor.x,
    1
  );
  Check_default.typeOf.number.greaterThanOrEquals(
    "options.imageBasedLightingFactor.y",
    imageBasedLightingFactor.y,
    0
  );
  Check_default.typeOf.number.lessThanOrEquals(
    "options.imageBasedLightingFactor.y",
    imageBasedLightingFactor.y,
    1
  );
  this._imageBasedLightingFactor = imageBasedLightingFactor;
  const luminanceAtZenith = defaultValue_default(options.luminanceAtZenith, 0.2);
  Check_default.typeOf.number("options.luminanceAtZenith", luminanceAtZenith);
  this._luminanceAtZenith = luminanceAtZenith;
  const sphericalHarmonicCoefficients = options.sphericalHarmonicCoefficients;
  if (defined_default(sphericalHarmonicCoefficients) && (!Array.isArray(sphericalHarmonicCoefficients) || sphericalHarmonicCoefficients.length !== 9)) {
    throw new DeveloperError_default(
      "options.sphericalHarmonicCoefficients must be an array of 9 Cartesian3 values."
    );
  }
  this._sphericalHarmonicCoefficients = sphericalHarmonicCoefficients;
  this._specularEnvironmentMaps = options.specularEnvironmentMaps;
  this._specularEnvironmentMapAtlas = void 0;
  this._specularEnvironmentMapAtlasDirty = true;
  this._specularEnvironmentMapLoaded = false;
  this._previousSpecularEnvironmentMapLoaded = false;
  this._useDefaultSpecularMaps = false;
  this._useDefaultSphericalHarmonics = false;
  this._shouldRegenerateShaders = false;
  this._previousFrameNumber = void 0;
  this._previousImageBasedLightingFactor = Cartesian2_default.clone(
    imageBasedLightingFactor
  );
  this._previousLuminanceAtZenith = luminanceAtZenith;
  this._previousSphericalHarmonicCoefficients = sphericalHarmonicCoefficients;
}
Object.defineProperties(ImageBasedLighting.prototype, {
  imageBasedLightingFactor: {
    get: function() {
      return this._imageBasedLightingFactor;
    },
    set: function(value) {
      Check_default.typeOf.object("imageBasedLightingFactor", value);
      Check_default.typeOf.number.greaterThanOrEquals(
        "imageBasedLightingFactor.x",
        value.x,
        0
      );
      Check_default.typeOf.number.lessThanOrEquals(
        "imageBasedLightingFactor.x",
        value.x,
        1
      );
      Check_default.typeOf.number.greaterThanOrEquals(
        "imageBasedLightingFactor.y",
        value.y,
        0
      );
      Check_default.typeOf.number.lessThanOrEquals(
        "imageBasedLightingFactor.y",
        value.y,
        1
      );
      this._previousImageBasedLightingFactor = Cartesian2_default.clone(
        this._imageBasedLightingFactor,
        this._previousImageBasedLightingFactor
      );
      this._imageBasedLightingFactor = Cartesian2_default.clone(
        value,
        this._imageBasedLightingFactor
      );
    }
  },
  luminanceAtZenith: {
    get: function() {
      return this._luminanceAtZenith;
    },
    set: function(value) {
      this._previousLuminanceAtZenith = this._luminanceAtZenith;
      this._luminanceAtZenith = value;
    }
  },
  sphericalHarmonicCoefficients: {
    get: function() {
      return this._sphericalHarmonicCoefficients;
    },
    set: function(value) {
      if (defined_default(value) && (!Array.isArray(value) || value.length !== 9)) {
        throw new DeveloperError_default(
          "sphericalHarmonicCoefficients must be an array of 9 Cartesian3 values."
        );
      }
      this._previousSphericalHarmonicCoefficients = this._sphericalHarmonicCoefficients;
      this._sphericalHarmonicCoefficients = value;
    }
  },
  specularEnvironmentMaps: {
    get: function() {
      return this._specularEnvironmentMaps;
    },
    set: function(value) {
      if (value !== this._specularEnvironmentMaps) {
        this._specularEnvironmentMapAtlasDirty = this._specularEnvironmentMapAtlasDirty || value !== this._specularEnvironmentMaps;
        this._specularEnvironmentMapLoaded = false;
      }
      this._specularEnvironmentMaps = value;
    }
  },
  enabled: {
    get: function() {
      return this._imageBasedLightingFactor.x > 0 || this._imageBasedLightingFactor.y > 0;
    }
  },
  shouldRegenerateShaders: {
    get: function() {
      return this._shouldRegenerateShaders;
    }
  },
  useDefaultSphericalHarmonics: {
    get: function() {
      return this._useDefaultSphericalHarmonics;
    }
  },
  useSphericalHarmonicCoefficients: {
    get: function() {
      return defined_default(this._sphericalHarmonicCoefficients) || this._useDefaultSphericalHarmonics;
    }
  },
  specularEnvironmentMapAtlas: {
    get: function() {
      return this._specularEnvironmentMapAtlas;
    }
  },
  useDefaultSpecularMaps: {
    get: function() {
      return this._useDefaultSpecularMaps;
    }
  },
  useSpecularEnvironmentMaps: {
    get: function() {
      return defined_default(this._specularEnvironmentMapAtlas) && this._specularEnvironmentMapAtlas.ready || this._useDefaultSpecularMaps;
    }
  }
});
function createSpecularEnvironmentMapAtlas(imageBasedLighting, context) {
  if (!OctahedralProjectedCubeMap_default.isSupported(context)) {
    return;
  }
  imageBasedLighting._specularEnvironmentMapAtlas = imageBasedLighting._specularEnvironmentMapAtlas && imageBasedLighting._specularEnvironmentMapAtlas.destroy();
  if (defined_default(imageBasedLighting._specularEnvironmentMaps)) {
    const atlas = new OctahedralProjectedCubeMap_default(
      imageBasedLighting._specularEnvironmentMaps
    );
    imageBasedLighting._specularEnvironmentMapAtlas = atlas;
    atlas.readyPromise.then(function() {
      imageBasedLighting._specularEnvironmentMapLoaded = true;
    }).catch(function(error) {
      console.error(`Error loading specularEnvironmentMaps: ${error}`);
    });
  }
  imageBasedLighting._shouldRegenerateShaders = true;
}
ImageBasedLighting.prototype.update = function(frameState) {
  if (frameState.frameNumber === this._previousFrameNumber) {
    return;
  }
  this._previousFrameNumber = frameState.frameNumber;
  const context = frameState.context;
  frameState.brdfLutGenerator.update(frameState);
  this._shouldRegenerateShaders = false;
  const iblFactor = this._imageBasedLightingFactor;
  const previousIBLFactor = this._previousImageBasedLightingFactor;
  if (!Cartesian2_default.equals(iblFactor, previousIBLFactor)) {
    this._shouldRegenerateShaders = iblFactor.x > 0 && previousIBLFactor.x === 0 || iblFactor.x === 0 && previousIBLFactor.x > 0;
    this._shouldRegenerateShaders = this._shouldRegenerateShaders || iblFactor.y > 0 && previousIBLFactor.y === 0 || iblFactor.y === 0 && previousIBLFactor.y > 0;
    this._previousImageBasedLightingFactor = Cartesian2_default.clone(
      this._imageBasedLightingFactor,
      this._previousImageBasedLightingFactor
    );
  }
  if (this._luminanceAtZenith !== this._previousLuminanceAtZenith) {
    this._shouldRegenerateShaders = this._shouldRegenerateShaders || defined_default(this._luminanceAtZenith) !== defined_default(this._previousLuminanceAtZenith);
    this._previousLuminanceAtZenith = this._luminanceAtZenith;
  }
  if (this._previousSphericalHarmonicCoefficients !== this._sphericalHarmonicCoefficients) {
    this._shouldRegenerateShaders = this._shouldRegenerateShaders || defined_default(this._previousSphericalHarmonicCoefficients) !== defined_default(this._sphericalHarmonicCoefficients);
    this._previousSphericalHarmonicCoefficients = this._sphericalHarmonicCoefficients;
  }
  this._shouldRegenerateShaders = this._shouldRegenerateShaders || this._previousSpecularEnvironmentMapLoaded !== this._specularEnvironmentMapLoaded;
  this._previousSpecularEnvironmentMapLoaded = this._specularEnvironmentMapLoaded;
  if (this._specularEnvironmentMapAtlasDirty) {
    createSpecularEnvironmentMapAtlas(this, context);
    this._specularEnvironmentMapAtlasDirty = false;
  }
  if (defined_default(this._specularEnvironmentMapAtlas)) {
    this._specularEnvironmentMapAtlas.update(frameState);
  }
  const recompileWithDefaultAtlas = !defined_default(this._specularEnvironmentMapAtlas) && defined_default(frameState.specularEnvironmentMaps) && !this._useDefaultSpecularMaps;
  const recompileWithoutDefaultAtlas = !defined_default(frameState.specularEnvironmentMaps) && this._useDefaultSpecularMaps;
  const recompileWithDefaultSHCoeffs = !defined_default(this._sphericalHarmonicCoefficients) && defined_default(frameState.sphericalHarmonicCoefficients) && !this._useDefaultSphericalHarmonics;
  const recompileWithoutDefaultSHCoeffs = !defined_default(frameState.sphericalHarmonicCoefficients) && this._useDefaultSphericalHarmonics;
  this._shouldRegenerateShaders = this._shouldRegenerateShaders || recompileWithDefaultAtlas || recompileWithoutDefaultAtlas || recompileWithDefaultSHCoeffs || recompileWithoutDefaultSHCoeffs;
  this._useDefaultSpecularMaps = !defined_default(this._specularEnvironmentMapAtlas) && defined_default(frameState.specularEnvironmentMaps);
  this._useDefaultSphericalHarmonics = !defined_default(this._sphericalHarmonicCoefficients) && defined_default(frameState.sphericalHarmonicCoefficients);
};
ImageBasedLighting.prototype.isDestroyed = function() {
  return false;
};
ImageBasedLighting.prototype.destroy = function() {
  this._specularEnvironmentMapAtlas = this._specularEnvironmentMapAtlas && this._specularEnvironmentMapAtlas.destroy();
  return destroyObject_default(this);
};

// node_modules/cesium/Source/Renderer/ClearCommand.js
function ClearCommand(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.color = options.color;
  this.depth = options.depth;
  this.stencil = options.stencil;
  this.renderState = options.renderState;
  this.framebuffer = options.framebuffer;
  this.owner = options.owner;
  this.pass = options.pass;
}
ClearCommand.ALL = Object.freeze(
  new ClearCommand({
    color: new Color_default(0, 0, 0, 0),
    depth: 1,
    stencil: 0
  })
);
ClearCommand.prototype.execute = function(context, passState) {
  context.clear(this, passState);
};
var ClearCommand_default = ClearCommand;

// node_modules/cesium/Source/Scene/Axis.js
var Axis = {
  X: 0,
  Y: 1,
  Z: 2
};
Axis.Y_UP_TO_Z_UP = Matrix4_default.fromRotationTranslation(
  Matrix3_default.fromRotationX(Math_default.PI_OVER_TWO)
);
Axis.Z_UP_TO_Y_UP = Matrix4_default.fromRotationTranslation(
  Matrix3_default.fromRotationX(-Math_default.PI_OVER_TWO)
);
Axis.X_UP_TO_Z_UP = Matrix4_default.fromRotationTranslation(
  Matrix3_default.fromRotationY(-Math_default.PI_OVER_TWO)
);
Axis.Z_UP_TO_X_UP = Matrix4_default.fromRotationTranslation(
  Matrix3_default.fromRotationY(Math_default.PI_OVER_TWO)
);
Axis.X_UP_TO_Y_UP = Matrix4_default.fromRotationTranslation(
  Matrix3_default.fromRotationZ(Math_default.PI_OVER_TWO)
);
Axis.Y_UP_TO_X_UP = Matrix4_default.fromRotationTranslation(
  Matrix3_default.fromRotationZ(-Math_default.PI_OVER_TWO)
);
Axis.fromName = function(name) {
  Check_default.typeOf.string("name", name);
  return Axis[name];
};
var Axis_default = Object.freeze(Axis);

// node_modules/cesium/Source/Scene/Cesium3DContentGroup.js
function Cesium3DContentGroup(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.metadata", options.metadata);
  this._metadata = options.metadata;
}
Object.defineProperties(Cesium3DContentGroup.prototype, {
  metadata: {
    get: function() {
      return this._metadata;
    }
  }
});

// node_modules/cesium/Source/Scene/B3dmParser.js
var B3dmParser = {};
B3dmParser._deprecationWarning = deprecationWarning_default;
var sizeOfUint322 = Uint32Array.BYTES_PER_ELEMENT;
B3dmParser.parse = function(arrayBuffer, byteOffset) {
  const byteStart = defaultValue_default(byteOffset, 0);
  Check_default.defined("arrayBuffer", arrayBuffer);
  byteOffset = byteStart;
  const uint8Array = new Uint8Array(arrayBuffer);
  const view = new DataView(arrayBuffer);
  byteOffset += sizeOfUint322;
  const version = view.getUint32(byteOffset, true);
  if (version !== 1) {
    throw new RuntimeError_default(
      `Only Batched 3D Model version 1 is supported.  Version ${version} is not.`
    );
  }
  byteOffset += sizeOfUint322;
  const byteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint322;
  let featureTableJsonByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint322;
  let featureTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint322;
  let batchTableJsonByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint322;
  let batchTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint322;
  let batchLength;
  if (batchTableJsonByteLength >= 570425344) {
    byteOffset -= sizeOfUint322 * 2;
    batchLength = featureTableJsonByteLength;
    batchTableJsonByteLength = featureTableBinaryByteLength;
    batchTableBinaryByteLength = 0;
    featureTableJsonByteLength = 0;
    featureTableBinaryByteLength = 0;
    B3dmParser._deprecationWarning(
      "b3dm-legacy-header",
      "This b3dm header is using the legacy format [batchLength] [batchTableByteLength]. The new format is [featureTableJsonByteLength] [featureTableBinaryByteLength] [batchTableJsonByteLength] [batchTableBinaryByteLength] from https://github.com/CesiumGS/3d-tiles/tree/main/specification/TileFormats/Batched3DModel."
    );
  } else if (batchTableBinaryByteLength >= 570425344) {
    byteOffset -= sizeOfUint322;
    batchLength = batchTableJsonByteLength;
    batchTableJsonByteLength = featureTableJsonByteLength;
    batchTableBinaryByteLength = featureTableBinaryByteLength;
    featureTableJsonByteLength = 0;
    featureTableBinaryByteLength = 0;
    B3dmParser._deprecationWarning(
      "b3dm-legacy-header",
      "This b3dm header is using the legacy format [batchTableJsonByteLength] [batchTableBinaryByteLength] [batchLength]. The new format is [featureTableJsonByteLength] [featureTableBinaryByteLength] [batchTableJsonByteLength] [batchTableBinaryByteLength] from https://github.com/CesiumGS/3d-tiles/tree/main/specification/TileFormats/Batched3DModel."
    );
  }
  let featureTableJson;
  if (featureTableJsonByteLength === 0) {
    featureTableJson = {
      BATCH_LENGTH: defaultValue_default(batchLength, 0)
    };
  } else {
    featureTableJson = getJsonFromTypedArray_default(
      uint8Array,
      byteOffset,
      featureTableJsonByteLength
    );
    byteOffset += featureTableJsonByteLength;
  }
  const featureTableBinary = new Uint8Array(
    arrayBuffer,
    byteOffset,
    featureTableBinaryByteLength
  );
  byteOffset += featureTableBinaryByteLength;
  let batchTableJson;
  let batchTableBinary;
  if (batchTableJsonByteLength > 0) {
    batchTableJson = getJsonFromTypedArray_default(
      uint8Array,
      byteOffset,
      batchTableJsonByteLength
    );
    byteOffset += batchTableJsonByteLength;
    if (batchTableBinaryByteLength > 0) {
      batchTableBinary = new Uint8Array(
        arrayBuffer,
        byteOffset,
        batchTableBinaryByteLength
      );
      batchTableBinary = new Uint8Array(batchTableBinary);
      byteOffset += batchTableBinaryByteLength;
    }
  }
  const gltfByteLength = byteStart + byteLength - byteOffset;
  if (gltfByteLength === 0) {
    throw new RuntimeError_default("glTF byte length must be greater than 0.");
  }
  let gltfView;
  if (byteOffset % 4 === 0) {
    gltfView = new Uint8Array(arrayBuffer, byteOffset, gltfByteLength);
  } else {
    B3dmParser._deprecationWarning(
      "b3dm-glb-unaligned",
      "The embedded glb is not aligned to a 4-byte boundary."
    );
    gltfView = new Uint8Array(
      uint8Array.subarray(byteOffset, byteOffset + gltfByteLength)
    );
  }
  return {
    batchLength,
    featureTableJson,
    featureTableBinary,
    batchTableJson,
    batchTableBinary,
    gltf: gltfView
  };
};
var B3dmParser_default = B3dmParser;

// node_modules/cesium/Source/Scene/BatchTexture.js
function BatchTexture(options) {
  Check_default.typeOf.number("options.featuresLength", options.featuresLength);
  Check_default.typeOf.object("options.owner", options.owner);
  const featuresLength = options.featuresLength;
  this._showAlphaProperties = void 0;
  this._batchValues = void 0;
  this._batchValuesDirty = false;
  this._batchTexture = void 0;
  this._defaultTexture = void 0;
  this._pickTexture = void 0;
  this._pickIds = [];
  let textureDimensions;
  let textureStep;
  if (featuresLength > 0) {
    const width = Math.min(featuresLength, ContextLimits_default.maximumTextureSize);
    const height = Math.ceil(featuresLength / ContextLimits_default.maximumTextureSize);
    const stepX = 1 / width;
    const centerX = stepX * 0.5;
    const stepY = 1 / height;
    const centerY = stepY * 0.5;
    textureDimensions = new Cartesian2_default(width, height);
    textureStep = new Cartesian4_default(stepX, centerX, stepY, centerY);
  }
  this._translucentFeaturesLength = 0;
  this._featuresLength = featuresLength;
  this._textureDimensions = textureDimensions;
  this._textureStep = textureStep;
  this._owner = options.owner;
  this._statistics = options.statistics;
  this._colorChangedCallback = options.colorChangedCallback;
}
Object.defineProperties(BatchTexture.prototype, {
  translucentFeaturesLength: {
    get: function() {
      return this._translucentFeaturesLength;
    }
  },
  memorySizeInBytes: {
    get: function() {
      let memory = 0;
      if (defined_default(this._pickTexture)) {
        memory += this._pickTexture.sizeInBytes;
      }
      if (defined_default(this._batchTexture)) {
        memory += this._batchTexture.sizeInBytes;
      }
      return memory;
    }
  },
  textureDimensions: {
    get: function() {
      return this._textureDimensions;
    }
  },
  textureStep: {
    get: function() {
      return this._textureStep;
    }
  },
  batchTexture: {
    get: function() {
      return this._batchTexture;
    }
  },
  defaultTexture: {
    get: function() {
      return this._defaultTexture;
    }
  },
  pickTexture: {
    get: function() {
      return this._pickTexture;
    }
  }
});
BatchTexture.DEFAULT_COLOR_VALUE = Color_default.WHITE;
BatchTexture.DEFAULT_SHOW_VALUE = true;
function getByteLength(batchTexture) {
  const dimensions = batchTexture._textureDimensions;
  return dimensions.x * dimensions.y * 4;
}
function getBatchValues(batchTexture) {
  if (!defined_default(batchTexture._batchValues)) {
    const byteLength = getByteLength(batchTexture);
    const bytes = new Uint8Array(byteLength);
    arrayFill_default(bytes, 255);
    batchTexture._batchValues = bytes;
  }
  return batchTexture._batchValues;
}
function getShowAlphaProperties(batchTexture) {
  if (!defined_default(batchTexture._showAlphaProperties)) {
    const byteLength = 2 * batchTexture._featuresLength;
    const bytes = new Uint8Array(byteLength);
    arrayFill_default(bytes, 255);
    batchTexture._showAlphaProperties = bytes;
  }
  return batchTexture._showAlphaProperties;
}
function checkBatchId(batchId, featuresLength) {
  if (!defined_default(batchId) || batchId < 0 || batchId >= featuresLength) {
    throw new DeveloperError_default(
      `batchId is required and between zero and featuresLength - 1 (${featuresLength}` - +")."
    );
  }
}
BatchTexture.prototype.setShow = function(batchId, show) {
  checkBatchId(batchId, this._featuresLength);
  Check_default.typeOf.bool("show", show);
  if (show && !defined_default(this._showAlphaProperties)) {
    return;
  }
  const showAlphaProperties = getShowAlphaProperties(this);
  const propertyOffset = batchId * 2;
  const newShow = show ? 255 : 0;
  if (showAlphaProperties[propertyOffset] !== newShow) {
    showAlphaProperties[propertyOffset] = newShow;
    const batchValues = getBatchValues(this);
    const offset2 = batchId * 4 + 3;
    batchValues[offset2] = show ? showAlphaProperties[propertyOffset + 1] : 0;
    this._batchValuesDirty = true;
  }
};
BatchTexture.prototype.setAllShow = function(show) {
  Check_default.typeOf.bool("show", show);
  const featuresLength = this._featuresLength;
  for (let i2 = 0; i2 < featuresLength; ++i2) {
    this.setShow(i2, show);
  }
};
BatchTexture.prototype.getShow = function(batchId) {
  checkBatchId(batchId, this._featuresLength);
  if (!defined_default(this._showAlphaProperties)) {
    return true;
  }
  const offset2 = batchId * 2;
  return this._showAlphaProperties[offset2] === 255;
};
var scratchColorBytes = new Array(4);
BatchTexture.prototype.setColor = function(batchId, color) {
  checkBatchId(batchId, this._featuresLength);
  Check_default.typeOf.object("color", color);
  if (Color_default.equals(color, BatchTexture.DEFAULT_COLOR_VALUE) && !defined_default(this._batchValues)) {
    return;
  }
  const newColor = color.toBytes(scratchColorBytes);
  const newAlpha = newColor[3];
  const batchValues = getBatchValues(this);
  const offset2 = batchId * 4;
  const showAlphaProperties = getShowAlphaProperties(this);
  const propertyOffset = batchId * 2;
  if (batchValues[offset2] !== newColor[0] || batchValues[offset2 + 1] !== newColor[1] || batchValues[offset2 + 2] !== newColor[2] || showAlphaProperties[propertyOffset + 1] !== newAlpha) {
    batchValues[offset2] = newColor[0];
    batchValues[offset2 + 1] = newColor[1];
    batchValues[offset2 + 2] = newColor[2];
    const wasTranslucent = showAlphaProperties[propertyOffset + 1] !== 255;
    const show = showAlphaProperties[propertyOffset] !== 0;
    batchValues[offset2 + 3] = show ? newAlpha : 0;
    showAlphaProperties[propertyOffset + 1] = newAlpha;
    const isTranslucent2 = newAlpha !== 255;
    if (isTranslucent2 && !wasTranslucent) {
      ++this._translucentFeaturesLength;
    } else if (!isTranslucent2 && wasTranslucent) {
      --this._translucentFeaturesLength;
    }
    this._batchValuesDirty = true;
    if (defined_default(this._colorChangedCallback)) {
      this._colorChangedCallback(batchId, color);
    }
  }
};
BatchTexture.prototype.setAllColor = function(color) {
  Check_default.typeOf.object("color", color);
  const featuresLength = this._featuresLength;
  for (let i2 = 0; i2 < featuresLength; ++i2) {
    this.setColor(i2, color);
  }
};
BatchTexture.prototype.getColor = function(batchId, result) {
  checkBatchId(batchId, this._featuresLength);
  Check_default.typeOf.object("result", result);
  if (!defined_default(this._batchValues)) {
    return Color_default.clone(BatchTexture.DEFAULT_COLOR_VALUE, result);
  }
  const batchValues = this._batchValues;
  const offset2 = batchId * 4;
  const showAlphaProperties = this._showAlphaProperties;
  const propertyOffset = batchId * 2;
  return Color_default.fromBytes(
    batchValues[offset2],
    batchValues[offset2 + 1],
    batchValues[offset2 + 2],
    showAlphaProperties[propertyOffset + 1],
    result
  );
};
BatchTexture.prototype.getPickColor = function(batchId) {
  checkBatchId(batchId, this._featuresLength);
  return this._pickIds[batchId];
};
function createTexture2(batchTexture, context, bytes) {
  const dimensions = batchTexture._textureDimensions;
  return new Texture_default({
    context,
    pixelFormat: PixelFormat_default.RGBA,
    pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
    source: {
      width: dimensions.x,
      height: dimensions.y,
      arrayBufferView: bytes
    },
    flipY: false,
    sampler: Sampler_default.NEAREST
  });
}
function createPickTexture(batchTexture, context) {
  const featuresLength = batchTexture._featuresLength;
  if (!defined_default(batchTexture._pickTexture) && featuresLength > 0) {
    const pickIds = batchTexture._pickIds;
    const byteLength = getByteLength(batchTexture);
    const bytes = new Uint8Array(byteLength);
    const owner = batchTexture._owner;
    const statistics2 = batchTexture._statistics;
    for (let i2 = 0; i2 < featuresLength; ++i2) {
      const pickId = context.createPickId(owner.getFeature(i2));
      pickIds.push(pickId);
      const pickColor = pickId.color;
      const offset2 = i2 * 4;
      bytes[offset2] = Color_default.floatToByte(pickColor.red);
      bytes[offset2 + 1] = Color_default.floatToByte(pickColor.green);
      bytes[offset2 + 2] = Color_default.floatToByte(pickColor.blue);
      bytes[offset2 + 3] = Color_default.floatToByte(pickColor.alpha);
    }
    batchTexture._pickTexture = createTexture2(batchTexture, context, bytes);
    if (defined_default(statistics2)) {
      statistics2.batchTableByteLength += batchTexture._pickTexture.sizeInBytes;
    }
  }
}
function updateBatchTexture(batchTexture) {
  const dimensions = batchTexture._textureDimensions;
  batchTexture._batchTexture.copyFrom({
    source: {
      width: dimensions.x,
      height: dimensions.y,
      arrayBufferView: batchTexture._batchValues
    }
  });
}
BatchTexture.prototype.update = function(tileset, frameState) {
  const context = frameState.context;
  this._defaultTexture = context.defaultTexture;
  const passes = frameState.passes;
  if (passes.pick || passes.postProcess) {
    createPickTexture(this, context);
  }
  if (this._batchValuesDirty) {
    this._batchValuesDirty = false;
    if (!defined_default(this._batchTexture)) {
      this._batchTexture = createTexture2(this, context, this._batchValues);
      if (defined_default(this._statistics)) {
        this._statistics.batchTableByteLength += this._batchTexture.sizeInBytes;
      }
    }
    updateBatchTexture(this);
  }
};
BatchTexture.prototype.isDestroyed = function() {
  return false;
};
BatchTexture.prototype.destroy = function() {
  this._batchTexture = this._batchTexture && this._batchTexture.destroy();
  this._pickTexture = this._pickTexture && this._pickTexture.destroy();
  const pickIds = this._pickIds;
  const length3 = pickIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    pickIds[i2].destroy();
  }
  return destroyObject_default(this);
};

// node_modules/cesium/Source/Scene/getBinaryAccessor.js
var ComponentsPerAttribute = {
  SCALAR: 1,
  VEC2: 2,
  VEC3: 3,
  VEC4: 4,
  MAT2: 4,
  MAT3: 9,
  MAT4: 16
};
var ClassPerType = {
  SCALAR: void 0,
  VEC2: Cartesian2_default,
  VEC3: Cartesian3_default,
  VEC4: Cartesian4_default,
  MAT2: Matrix2_default,
  MAT3: Matrix3_default,
  MAT4: Matrix4_default
};
function getBinaryAccessor(accessor) {
  const componentType = accessor.componentType;
  let componentDatatype;
  if (typeof componentType === "string") {
    componentDatatype = ComponentDatatype_default.fromName(componentType);
  } else {
    componentDatatype = componentType;
  }
  const componentsPerAttribute = ComponentsPerAttribute[accessor.type];
  const classType = ClassPerType[accessor.type];
  return {
    componentsPerAttribute,
    classType,
    createArrayBufferView: function(buffer, byteOffset, length3) {
      return ComponentDatatype_default.createArrayBufferView(
        componentDatatype,
        buffer,
        byteOffset,
        componentsPerAttribute * length3
      );
    }
  };
}
var getBinaryAccessor_default = getBinaryAccessor;

// node_modules/cesium/Source/Scene/BatchTableHierarchy.js
function BatchTableHierarchy(options) {
  this._classes = void 0;
  this._classIds = void 0;
  this._classIndexes = void 0;
  this._parentCounts = void 0;
  this._parentIndexes = void 0;
  this._parentIds = void 0;
  Check_default.typeOf.object("options.extension", options.extension);
  initialize3(this, options.extension, options.binaryBody);
  validateHierarchy(this);
}
function initialize3(hierarchy, hierarchyJson, binaryBody) {
  let i2;
  let classId;
  let binaryAccessor;
  const instancesLength = hierarchyJson.instancesLength;
  const classes = hierarchyJson.classes;
  let classIds = hierarchyJson.classIds;
  let parentCounts = hierarchyJson.parentCounts;
  let parentIds = hierarchyJson.parentIds;
  let parentIdsLength = instancesLength;
  if (defined_default(classIds.byteOffset)) {
    classIds.componentType = defaultValue_default(
      classIds.componentType,
      ComponentDatatype_default.UNSIGNED_SHORT
    );
    classIds.type = AttributeType_default.SCALAR;
    binaryAccessor = getBinaryAccessor_default(classIds);
    classIds = binaryAccessor.createArrayBufferView(
      binaryBody.buffer,
      binaryBody.byteOffset + classIds.byteOffset,
      instancesLength
    );
  }
  let parentIndexes;
  if (defined_default(parentCounts)) {
    if (defined_default(parentCounts.byteOffset)) {
      parentCounts.componentType = defaultValue_default(
        parentCounts.componentType,
        ComponentDatatype_default.UNSIGNED_SHORT
      );
      parentCounts.type = AttributeType_default.SCALAR;
      binaryAccessor = getBinaryAccessor_default(parentCounts);
      parentCounts = binaryAccessor.createArrayBufferView(
        binaryBody.buffer,
        binaryBody.byteOffset + parentCounts.byteOffset,
        instancesLength
      );
    }
    parentIndexes = new Uint16Array(instancesLength);
    parentIdsLength = 0;
    for (i2 = 0; i2 < instancesLength; ++i2) {
      parentIndexes[i2] = parentIdsLength;
      parentIdsLength += parentCounts[i2];
    }
  }
  if (defined_default(parentIds) && defined_default(parentIds.byteOffset)) {
    parentIds.componentType = defaultValue_default(
      parentIds.componentType,
      ComponentDatatype_default.UNSIGNED_SHORT
    );
    parentIds.type = AttributeType_default.SCALAR;
    binaryAccessor = getBinaryAccessor_default(parentIds);
    parentIds = binaryAccessor.createArrayBufferView(
      binaryBody.buffer,
      binaryBody.byteOffset + parentIds.byteOffset,
      parentIdsLength
    );
  }
  const classesLength = classes.length;
  for (i2 = 0; i2 < classesLength; ++i2) {
    const classInstancesLength = classes[i2].length;
    const properties = classes[i2].instances;
    const binaryProperties = getBinaryProperties(
      classInstancesLength,
      properties,
      binaryBody
    );
    classes[i2].instances = combine_default(binaryProperties, properties);
  }
  const classCounts = arrayFill_default(new Array(classesLength), 0);
  const classIndexes = new Uint16Array(instancesLength);
  for (i2 = 0; i2 < instancesLength; ++i2) {
    classId = classIds[i2];
    classIndexes[i2] = classCounts[classId];
    ++classCounts[classId];
  }
  hierarchy._classes = classes;
  hierarchy._classIds = classIds;
  hierarchy._classIndexes = classIndexes;
  hierarchy._parentCounts = parentCounts;
  hierarchy._parentIndexes = parentIndexes;
  hierarchy._parentIds = parentIds;
}
function getBinaryProperties(featuresLength, properties, binaryBody) {
  let binaryProperties;
  for (const name in properties) {
    if (properties.hasOwnProperty(name)) {
      const property = properties[name];
      const byteOffset = property.byteOffset;
      if (defined_default(byteOffset)) {
        const componentType = property.componentType;
        const type = property.type;
        if (!defined_default(componentType)) {
          throw new RuntimeError_default("componentType is required.");
        }
        if (!defined_default(type)) {
          throw new RuntimeError_default("type is required.");
        }
        if (!defined_default(binaryBody)) {
          throw new RuntimeError_default(
            `Property ${name} requires a batch table binary.`
          );
        }
        const binaryAccessor = getBinaryAccessor_default(property);
        const componentCount = binaryAccessor.componentsPerAttribute;
        const classType = binaryAccessor.classType;
        const typedArray = binaryAccessor.createArrayBufferView(
          binaryBody.buffer,
          binaryBody.byteOffset + byteOffset,
          featuresLength
        );
        if (!defined_default(binaryProperties)) {
          binaryProperties = {};
        }
        binaryProperties[name] = {
          typedArray,
          componentCount,
          type: classType
        };
      }
    }
  }
  return binaryProperties;
}
var scratchValidateStack = [];
function validateHierarchy(hierarchy) {
  const stack = scratchValidateStack;
  stack.length = 0;
  const classIds = hierarchy._classIds;
  const instancesLength = classIds.length;
  for (let i2 = 0; i2 < instancesLength; ++i2) {
    validateInstance(hierarchy, i2, stack);
  }
}
function validateInstance(hierarchy, instanceIndex, stack) {
  const parentCounts = hierarchy._parentCounts;
  const parentIds = hierarchy._parentIds;
  const parentIndexes = hierarchy._parentIndexes;
  const classIds = hierarchy._classIds;
  const instancesLength = classIds.length;
  if (!defined_default(parentIds)) {
    return;
  }
  if (instanceIndex >= instancesLength) {
    throw new DeveloperError_default(
      `Parent index ${instanceIndex} exceeds the total number of instances: ${instancesLength}`
    );
  }
  if (stack.indexOf(instanceIndex) > -1) {
    throw new DeveloperError_default(
      "Circular dependency detected in the batch table hierarchy."
    );
  }
  stack.push(instanceIndex);
  const parentCount = defined_default(parentCounts) ? parentCounts[instanceIndex] : 1;
  const parentIndex = defined_default(parentCounts) ? parentIndexes[instanceIndex] : instanceIndex;
  for (let i2 = 0; i2 < parentCount; ++i2) {
    const parentId = parentIds[parentIndex + i2];
    if (parentId !== instanceIndex) {
      validateInstance(hierarchy, parentId, stack);
    }
  }
  stack.pop(instanceIndex);
}
var scratchVisited = [];
var scratchStack = [];
var marker = 0;
function traverseHierarchyMultipleParents(hierarchy, instanceIndex, endConditionCallback) {
  const classIds = hierarchy._classIds;
  const parentCounts = hierarchy._parentCounts;
  const parentIds = hierarchy._parentIds;
  const parentIndexes = hierarchy._parentIndexes;
  const instancesLength = classIds.length;
  const visited = scratchVisited;
  visited.length = Math.max(visited.length, instancesLength);
  const visitedMarker = ++marker;
  const stack = scratchStack;
  stack.length = 0;
  stack.push(instanceIndex);
  while (stack.length > 0) {
    instanceIndex = stack.pop();
    if (visited[instanceIndex] === visitedMarker) {
      continue;
    }
    visited[instanceIndex] = visitedMarker;
    const result = endConditionCallback(hierarchy, instanceIndex);
    if (defined_default(result)) {
      return result;
    }
    const parentCount = parentCounts[instanceIndex];
    const parentIndex = parentIndexes[instanceIndex];
    for (let i2 = 0; i2 < parentCount; ++i2) {
      const parentId = parentIds[parentIndex + i2];
      if (parentId !== instanceIndex) {
        stack.push(parentId);
      }
    }
  }
}
function traverseHierarchySingleParent(hierarchy, instanceIndex, endConditionCallback) {
  let hasParent = true;
  while (hasParent) {
    const result = endConditionCallback(hierarchy, instanceIndex);
    if (defined_default(result)) {
      return result;
    }
    const parentId = hierarchy._parentIds[instanceIndex];
    hasParent = parentId !== instanceIndex;
    instanceIndex = parentId;
  }
}
function traverseHierarchy(hierarchy, instanceIndex, endConditionCallback) {
  const parentCounts = hierarchy._parentCounts;
  const parentIds = hierarchy._parentIds;
  if (!defined_default(parentIds)) {
    return endConditionCallback(hierarchy, instanceIndex);
  } else if (defined_default(parentCounts)) {
    return traverseHierarchyMultipleParents(
      hierarchy,
      instanceIndex,
      endConditionCallback
    );
  }
  return traverseHierarchySingleParent(
    hierarchy,
    instanceIndex,
    endConditionCallback
  );
}
BatchTableHierarchy.prototype.hasProperty = function(batchId, propertyId) {
  const result = traverseHierarchy(this, batchId, function(hierarchy, instanceIndex) {
    const classId = hierarchy._classIds[instanceIndex];
    const instances = hierarchy._classes[classId].instances;
    if (defined_default(instances[propertyId])) {
      return true;
    }
  });
  return defined_default(result);
};
BatchTableHierarchy.prototype.propertyExists = function(propertyId) {
  const classes = this._classes;
  const classesLength = classes.length;
  for (let i2 = 0; i2 < classesLength; ++i2) {
    const instances = classes[i2].instances;
    if (defined_default(instances[propertyId])) {
      return true;
    }
  }
  return false;
};
BatchTableHierarchy.prototype.getPropertyIds = function(batchId, results) {
  results = defined_default(results) ? results : [];
  results.length = 0;
  traverseHierarchy(this, batchId, function(hierarchy, instanceIndex) {
    const classId = hierarchy._classIds[instanceIndex];
    const instances = hierarchy._classes[classId].instances;
    for (const name in instances) {
      if (instances.hasOwnProperty(name)) {
        if (results.indexOf(name) === -1) {
          results.push(name);
        }
      }
    }
  });
  return results;
};
BatchTableHierarchy.prototype.getProperty = function(batchId, propertyId) {
  return traverseHierarchy(this, batchId, function(hierarchy, instanceIndex) {
    const classId = hierarchy._classIds[instanceIndex];
    const instanceClass = hierarchy._classes[classId];
    const indexInClass = hierarchy._classIndexes[instanceIndex];
    const propertyValues = instanceClass.instances[propertyId];
    if (defined_default(propertyValues)) {
      if (defined_default(propertyValues.typedArray)) {
        return getBinaryProperty(propertyValues, indexInClass);
      }
      return clone_default(propertyValues[indexInClass], true);
    }
  });
};
function getBinaryProperty(binaryProperty, index2) {
  const typedArray = binaryProperty.typedArray;
  const componentCount = binaryProperty.componentCount;
  if (componentCount === 1) {
    return typedArray[index2];
  }
  return binaryProperty.type.unpack(typedArray, index2 * componentCount);
}
BatchTableHierarchy.prototype.setProperty = function(batchId, propertyId, value) {
  const result = traverseHierarchy(this, batchId, function(hierarchy, instanceIndex) {
    const classId = hierarchy._classIds[instanceIndex];
    const instanceClass = hierarchy._classes[classId];
    const indexInClass = hierarchy._classIndexes[instanceIndex];
    const propertyValues = instanceClass.instances[propertyId];
    if (defined_default(propertyValues)) {
      if (instanceIndex !== batchId) {
        throw new DeveloperError_default(
          `Inherited property "${propertyId}" is read-only.`
        );
      }
      if (defined_default(propertyValues.typedArray)) {
        setBinaryProperty(propertyValues, indexInClass, value);
      } else {
        propertyValues[indexInClass] = clone_default(value, true);
      }
      return true;
    }
  });
  return defined_default(result);
};
function setBinaryProperty(binaryProperty, index2, value) {
  const typedArray = binaryProperty.typedArray;
  const componentCount = binaryProperty.componentCount;
  if (componentCount === 1) {
    typedArray[index2] = value;
  } else {
    binaryProperty.type.pack(value, typedArray, index2 * componentCount);
  }
}
BatchTableHierarchy.prototype.isClass = function(batchId, className) {
  const result = traverseHierarchy(this, batchId, function(hierarchy, instanceIndex) {
    const classId = hierarchy._classIds[instanceIndex];
    const instanceClass = hierarchy._classes[classId];
    if (instanceClass.name === className) {
      return true;
    }
  });
  return defined_default(result);
};
BatchTableHierarchy.prototype.getClassName = function(batchId) {
  const classId = this._classIds[batchId];
  const instanceClass = this._classes[classId];
  return instanceClass.name;
};

// node_modules/cesium/Source/Scene/Cesium3DTileColorBlendMode.js
var Cesium3DTileColorBlendMode = {
  HIGHLIGHT: 0,
  REPLACE: 1,
  MIX: 2
};
var Cesium3DTileColorBlendMode_default = Object.freeze(Cesium3DTileColorBlendMode);

// node_modules/cesium/Source/Scene/Cesium3DTileBatchTable.js
var DEFAULT_COLOR_VALUE = BatchTexture.DEFAULT_COLOR_VALUE;
var DEFAULT_SHOW_VALUE = BatchTexture.DEFAULT_SHOW_VALUE;
function Cesium3DTileBatchTable(content, featuresLength, batchTableJson, batchTableBinary, colorChangedCallback) {
  this.featuresLength = featuresLength;
  let extensions;
  if (defined_default(batchTableJson)) {
    extensions = batchTableJson.extensions;
  }
  this._extensions = defaultValue_default(extensions, {});
  const properties = initializeProperties(batchTableJson);
  this._properties = properties;
  this._batchTableHierarchy = initializeHierarchy(
    this,
    batchTableJson,
    batchTableBinary
  );
  this._batchTableBinaryProperties = getBinaryProperties2(
    featuresLength,
    properties,
    batchTableBinary
  );
  this._content = content;
  this._batchTexture = new BatchTexture({
    featuresLength,
    colorChangedCallback,
    owner: content,
    statistics: content.tileset.statistics
  });
}
Cesium3DTileBatchTable._deprecationWarning = deprecationWarning_default;
Object.defineProperties(Cesium3DTileBatchTable.prototype, {
  memorySizeInBytes: {
    get: function() {
      return this._batchTexture.memorySizeInBytes;
    }
  }
});
function initializeProperties(jsonHeader) {
  const properties = {};
  if (!defined_default(jsonHeader)) {
    return properties;
  }
  for (const propertyName in jsonHeader) {
    if (jsonHeader.hasOwnProperty(propertyName) && propertyName !== "HIERARCHY" && propertyName !== "extensions" && propertyName !== "extras") {
      properties[propertyName] = clone_default(jsonHeader[propertyName], true);
    }
  }
  return properties;
}
function initializeHierarchy(batchTable, jsonHeader, binaryBody) {
  if (!defined_default(jsonHeader)) {
    return;
  }
  let hierarchy = batchTable._extensions["3DTILES_batch_table_hierarchy"];
  const legacyHierarchy = jsonHeader.HIERARCHY;
  if (defined_default(legacyHierarchy)) {
    Cesium3DTileBatchTable._deprecationWarning(
      "batchTableHierarchyExtension",
      "The batch table HIERARCHY property has been moved to an extension. Use extensions.3DTILES_batch_table_hierarchy instead."
    );
    batchTable._extensions["3DTILES_batch_table_hierarchy"] = legacyHierarchy;
    hierarchy = legacyHierarchy;
  }
  if (!defined_default(hierarchy)) {
    return;
  }
  return new BatchTableHierarchy({
    extension: hierarchy,
    binaryBody
  });
}
function getBinaryProperties2(featuresLength, properties, binaryBody) {
  let binaryProperties;
  for (const name in properties) {
    if (properties.hasOwnProperty(name)) {
      const property = properties[name];
      const byteOffset = property.byteOffset;
      if (defined_default(byteOffset)) {
        const componentType = property.componentType;
        const type = property.type;
        if (!defined_default(componentType)) {
          throw new RuntimeError_default("componentType is required.");
        }
        if (!defined_default(type)) {
          throw new RuntimeError_default("type is required.");
        }
        if (!defined_default(binaryBody)) {
          throw new RuntimeError_default(
            `Property ${name} requires a batch table binary.`
          );
        }
        const binaryAccessor = getBinaryAccessor_default(property);
        const componentCount = binaryAccessor.componentsPerAttribute;
        const classType = binaryAccessor.classType;
        const typedArray = binaryAccessor.createArrayBufferView(
          binaryBody.buffer,
          binaryBody.byteOffset + byteOffset,
          featuresLength
        );
        if (!defined_default(binaryProperties)) {
          binaryProperties = {};
        }
        binaryProperties[name] = {
          typedArray,
          componentCount,
          type: classType
        };
      }
    }
  }
  return binaryProperties;
}
Cesium3DTileBatchTable.getBinaryProperties = function(featuresLength, batchTableJson, batchTableBinary) {
  return getBinaryProperties2(featuresLength, batchTableJson, batchTableBinary);
};
Cesium3DTileBatchTable.prototype.setShow = function(batchId, show) {
  this._batchTexture.setShow(batchId, show);
};
Cesium3DTileBatchTable.prototype.setAllShow = function(show) {
  this._batchTexture.setAllShow(show);
};
Cesium3DTileBatchTable.prototype.getShow = function(batchId) {
  return this._batchTexture.getShow(batchId);
};
Cesium3DTileBatchTable.prototype.setColor = function(batchId, color) {
  this._batchTexture.setColor(batchId, color);
};
Cesium3DTileBatchTable.prototype.setAllColor = function(color) {
  this._batchTexture.setAllColor(color);
};
Cesium3DTileBatchTable.prototype.getColor = function(batchId, result) {
  return this._batchTexture.getColor(batchId, result);
};
Cesium3DTileBatchTable.prototype.getPickColor = function(batchId) {
  return this._batchTexture.getPickColor(batchId);
};
var scratchColor2 = new Color_default();
Cesium3DTileBatchTable.prototype.applyStyle = function(style) {
  if (!defined_default(style)) {
    this.setAllColor(DEFAULT_COLOR_VALUE);
    this.setAllShow(DEFAULT_SHOW_VALUE);
    return;
  }
  const content = this._content;
  const length3 = this.featuresLength;
  for (let i2 = 0; i2 < length3; ++i2) {
    const feature2 = content.getFeature(i2);
    const color = defined_default(style.color) ? defaultValue_default(
      style.color.evaluateColor(feature2, scratchColor2),
      DEFAULT_COLOR_VALUE
    ) : DEFAULT_COLOR_VALUE;
    const show = defined_default(style.show) ? defaultValue_default(style.show.evaluate(feature2), DEFAULT_SHOW_VALUE) : DEFAULT_SHOW_VALUE;
    this.setColor(i2, color);
    this.setShow(i2, show);
  }
};
function getBinaryProperty2(binaryProperty, index2) {
  const typedArray = binaryProperty.typedArray;
  const componentCount = binaryProperty.componentCount;
  if (componentCount === 1) {
    return typedArray[index2];
  }
  return binaryProperty.type.unpack(typedArray, index2 * componentCount);
}
function setBinaryProperty2(binaryProperty, index2, value) {
  const typedArray = binaryProperty.typedArray;
  const componentCount = binaryProperty.componentCount;
  if (componentCount === 1) {
    typedArray[index2] = value;
  } else {
    binaryProperty.type.pack(value, typedArray, index2 * componentCount);
  }
}
function checkBatchId2(batchId, featuresLength) {
  if (!defined_default(batchId) || batchId < 0 || batchId >= featuresLength) {
    throw new DeveloperError_default(
      `batchId is required and between zero and featuresLength - 1 (${featuresLength}` - +")."
    );
  }
}
Cesium3DTileBatchTable.prototype.isClass = function(batchId, className) {
  checkBatchId2(batchId, this.featuresLength);
  Check_default.typeOf.string("className", className);
  const hierarchy = this._batchTableHierarchy;
  if (!defined_default(hierarchy)) {
    return false;
  }
  return hierarchy.isClass(batchId, className);
};
Cesium3DTileBatchTable.prototype.isExactClass = function(batchId, className) {
  Check_default.typeOf.string("className", className);
  return this.getExactClassName(batchId) === className;
};
Cesium3DTileBatchTable.prototype.getExactClassName = function(batchId) {
  checkBatchId2(batchId, this.featuresLength);
  const hierarchy = this._batchTableHierarchy;
  if (!defined_default(hierarchy)) {
    return void 0;
  }
  return hierarchy.getClassName(batchId);
};
Cesium3DTileBatchTable.prototype.hasProperty = function(batchId, name) {
  checkBatchId2(batchId, this.featuresLength);
  Check_default.typeOf.string("name", name);
  return defined_default(this._properties[name]) || defined_default(this._batchTableHierarchy) && this._batchTableHierarchy.hasProperty(batchId, name);
};
Cesium3DTileBatchTable.prototype.hasPropertyBySemantic = function() {
  return false;
};
Cesium3DTileBatchTable.prototype.getPropertyNames = function(batchId, results) {
  checkBatchId2(batchId, this.featuresLength);
  results = defined_default(results) ? results : [];
  results.length = 0;
  const scratchPropertyNames = Object.keys(this._properties);
  results.push.apply(results, scratchPropertyNames);
  if (defined_default(this._batchTableHierarchy)) {
    results.push.apply(
      results,
      this._batchTableHierarchy.getPropertyIds(batchId, scratchPropertyNames)
    );
  }
  return results;
};
Cesium3DTileBatchTable.prototype.getPropertyBySemantic = function(batchId, name) {
  return void 0;
};
Cesium3DTileBatchTable.prototype.getProperty = function(batchId, name) {
  checkBatchId2(batchId, this.featuresLength);
  Check_default.typeOf.string("name", name);
  if (defined_default(this._batchTableBinaryProperties)) {
    const binaryProperty = this._batchTableBinaryProperties[name];
    if (defined_default(binaryProperty)) {
      return getBinaryProperty2(binaryProperty, batchId);
    }
  }
  const propertyValues = this._properties[name];
  if (defined_default(propertyValues)) {
    return clone_default(propertyValues[batchId], true);
  }
  if (defined_default(this._batchTableHierarchy)) {
    const hierarchyProperty = this._batchTableHierarchy.getProperty(
      batchId,
      name
    );
    if (defined_default(hierarchyProperty)) {
      return hierarchyProperty;
    }
  }
  return void 0;
};
Cesium3DTileBatchTable.prototype.setProperty = function(batchId, name, value) {
  const featuresLength = this.featuresLength;
  checkBatchId2(batchId, featuresLength);
  Check_default.typeOf.string("name", name);
  if (defined_default(this._batchTableBinaryProperties)) {
    const binaryProperty = this._batchTableBinaryProperties[name];
    if (defined_default(binaryProperty)) {
      setBinaryProperty2(binaryProperty, batchId, value);
      return;
    }
  }
  if (defined_default(this._batchTableHierarchy)) {
    if (this._batchTableHierarchy.setProperty(batchId, name, value)) {
      return;
    }
  }
  let propertyValues = this._properties[name];
  if (!defined_default(propertyValues)) {
    this._properties[name] = new Array(featuresLength);
    propertyValues = this._properties[name];
  }
  propertyValues[batchId] = clone_default(value, true);
};
function getGlslComputeSt2(batchTable) {
  if (batchTable._batchTexture.textureDimensions.y === 1) {
    return "uniform vec4 tile_textureStep; \nvec2 computeSt(float batchId) \n{ \n    float stepX = tile_textureStep.x; \n    float centerX = tile_textureStep.y; \n    return vec2(centerX + (batchId * stepX), 0.5); \n} \n";
  }
  return "uniform vec4 tile_textureStep; \nuniform vec2 tile_textureDimensions; \nvec2 computeSt(float batchId) \n{ \n    float stepX = tile_textureStep.x; \n    float centerX = tile_textureStep.y; \n    float stepY = tile_textureStep.z; \n    float centerY = tile_textureStep.w; \n    float xId = mod(batchId, tile_textureDimensions.x); \n    float yId = floor(batchId / tile_textureDimensions.x); \n    return vec2(centerX + (xId * stepX), centerY + (yId * stepY)); \n} \n";
}
Cesium3DTileBatchTable.prototype.getVertexShaderCallback = function(handleTranslucent, batchIdAttributeName, diffuseAttributeOrUniformName) {
  if (this.featuresLength === 0) {
    return;
  }
  const that = this;
  return function(source) {
    const renamedSource = modifyDiffuse(
      source,
      diffuseAttributeOrUniformName,
      false
    );
    let newMain;
    if (ContextLimits_default.maximumVertexTextureImageUnits > 0) {
      newMain = "";
      if (handleTranslucent) {
        newMain += "uniform bool tile_translucentCommand; \n";
      }
      newMain += `${"uniform sampler2D tile_batchTexture; \nvarying vec4 tile_featureColor; \nvarying vec2 tile_featureSt; \nvoid main() \n{ \n    vec2 st = computeSt("}${batchIdAttributeName}); 
    vec4 featureProperties = texture2D(tile_batchTexture, st); 
    tile_color(featureProperties); 
    float show = ceil(featureProperties.a); 
    gl_Position *= show; 
`;
      if (handleTranslucent) {
        newMain += "    bool isStyleTranslucent = (featureProperties.a != 1.0); \n    if (czm_pass == czm_passTranslucent) \n    { \n        if (!isStyleTranslucent && !tile_translucentCommand) \n        { \n            gl_Position *= 0.0; \n        } \n    } \n    else \n    { \n        if (isStyleTranslucent) \n        { \n            gl_Position *= 0.0; \n        } \n    } \n";
      }
      newMain += "    tile_featureColor = featureProperties; \n    tile_featureSt = st; \n}";
    } else {
      newMain = `${"varying vec2 tile_featureSt; \nvoid main() \n{ \n    tile_color(vec4(1.0)); \n    tile_featureSt = computeSt("}${batchIdAttributeName}); 
}`;
    }
    return `${renamedSource}
${getGlslComputeSt2(that)}${newMain}`;
  };
};
function getDefaultShader(source, applyHighlight) {
  source = ShaderSource_default.replaceMain(source, "tile_main");
  if (!applyHighlight) {
    return `${source}void tile_color(vec4 tile_featureColor) 
{ 
    tile_main(); 
} 
`;
  }
  return `${source}uniform float tile_colorBlend; 
void tile_color(vec4 tile_featureColor) 
{ 
    tile_main(); 
    tile_featureColor = czm_gammaCorrect(tile_featureColor); 
    gl_FragColor.a *= tile_featureColor.a; 
    float highlight = ceil(tile_colorBlend); 
    gl_FragColor.rgb *= mix(tile_featureColor.rgb, vec3(1.0), highlight); 
} 
`;
}
function replaceDiffuseTextureCalls(source, diffuseAttributeOrUniformName) {
  const functionCall = `texture2D(${diffuseAttributeOrUniformName}`;
  let fromIndex = 0;
  let startIndex = source.indexOf(functionCall, fromIndex);
  let endIndex;
  while (startIndex > -1) {
    let nestedLevel = 0;
    for (let i2 = startIndex; i2 < source.length; ++i2) {
      const character = source.charAt(i2);
      if (character === "(") {
        ++nestedLevel;
      } else if (character === ")") {
        --nestedLevel;
        if (nestedLevel === 0) {
          endIndex = i2 + 1;
          break;
        }
      }
    }
    const extractedFunction = source.slice(startIndex, endIndex);
    const replacedFunction = `tile_diffuse_final(${extractedFunction}, tile_diffuse)`;
    source = source.slice(0, startIndex) + replacedFunction + source.slice(endIndex);
    fromIndex = startIndex + replacedFunction.length;
    startIndex = source.indexOf(functionCall, fromIndex);
  }
  return source;
}
function modifyDiffuse(source, diffuseAttributeOrUniformName, applyHighlight) {
  if (!defined_default(diffuseAttributeOrUniformName)) {
    return getDefaultShader(source, applyHighlight);
  }
  let regex = new RegExp(
    `(uniform|attribute|in)\\s+(vec[34]|sampler2D)\\s+${diffuseAttributeOrUniformName};`
  );
  const uniformMatch = source.match(regex);
  if (!defined_default(uniformMatch)) {
    return getDefaultShader(source, applyHighlight);
  }
  const declaration = uniformMatch[0];
  const type = uniformMatch[2];
  source = ShaderSource_default.replaceMain(source, "tile_main");
  source = source.replace(declaration, "");
  const finalDiffuseFunction = "bool isWhite(vec3 color) \n{ \n    return all(greaterThan(color, vec3(1.0 - czm_epsilon3))); \n} \nvec4 tile_diffuse_final(vec4 sourceDiffuse, vec4 tileDiffuse) \n{ \n    vec4 blendDiffuse = mix(sourceDiffuse, tileDiffuse, tile_colorBlend); \n    vec4 diffuse = isWhite(tileDiffuse.rgb) ? sourceDiffuse : blendDiffuse; \n    return vec4(diffuse.rgb, sourceDiffuse.a); \n} \n";
  const highlight = "    tile_featureColor = czm_gammaCorrect(tile_featureColor); \n    gl_FragColor.a *= tile_featureColor.a; \n    float highlight = ceil(tile_colorBlend); \n    gl_FragColor.rgb *= mix(tile_featureColor.rgb, vec3(1.0), highlight); \n";
  let setColor;
  if (type === "vec3" || type === "vec4") {
    const sourceDiffuse = type === "vec3" ? `vec4(${diffuseAttributeOrUniformName}, 1.0)` : diffuseAttributeOrUniformName;
    const replaceDiffuse = type === "vec3" ? "tile_diffuse.xyz" : "tile_diffuse";
    regex = new RegExp(diffuseAttributeOrUniformName, "g");
    source = source.replace(regex, replaceDiffuse);
    setColor = `    vec4 source = ${sourceDiffuse}; 
    tile_diffuse = tile_diffuse_final(source, tile_featureColor); 
    tile_main(); 
`;
  } else if (type === "sampler2D") {
    source = replaceDiffuseTextureCalls(source, diffuseAttributeOrUniformName);
    setColor = "    tile_diffuse = tile_featureColor; \n    tile_main(); \n";
  }
  source = `${"uniform float tile_colorBlend; \nvec4 tile_diffuse = vec4(1.0); \n"}${finalDiffuseFunction}${declaration}
${source}
void tile_color(vec4 tile_featureColor) 
{ 
${setColor}`;
  if (applyHighlight) {
    source += highlight;
  }
  source += "} \n";
  return source;
}
Cesium3DTileBatchTable.prototype.getFragmentShaderCallback = function(handleTranslucent, diffuseAttributeOrUniformName, hasPremultipliedAlpha) {
  if (this.featuresLength === 0) {
    return;
  }
  return function(source) {
    source = modifyDiffuse(source, diffuseAttributeOrUniformName, true);
    if (ContextLimits_default.maximumVertexTextureImageUnits > 0) {
      source += "uniform sampler2D tile_pickTexture; \nvarying vec2 tile_featureSt; \nvarying vec4 tile_featureColor; \nvoid main() \n{ \n    tile_color(tile_featureColor); \n";
      if (hasPremultipliedAlpha) {
        source += "    gl_FragColor.rgb *= gl_FragColor.a; \n";
      }
      source += "}";
    } else {
      if (handleTranslucent) {
        source += "uniform bool tile_translucentCommand; \n";
      }
      source += "uniform sampler2D tile_pickTexture; \nuniform sampler2D tile_batchTexture; \nvarying vec2 tile_featureSt; \nvoid main() \n{ \n    vec4 featureProperties = texture2D(tile_batchTexture, tile_featureSt); \n    if (featureProperties.a == 0.0) { \n        discard; \n    } \n";
      if (handleTranslucent) {
        source += "    bool isStyleTranslucent = (featureProperties.a != 1.0); \n    if (czm_pass == czm_passTranslucent) \n    { \n        if (!isStyleTranslucent && !tile_translucentCommand) \n        { \n            discard; \n        } \n    } \n    else \n    { \n        if (isStyleTranslucent) \n        { \n            discard; \n        } \n    } \n";
      }
      source += "    tile_color(featureProperties); \n";
      if (hasPremultipliedAlpha) {
        source += "    gl_FragColor.rgb *= gl_FragColor.a; \n";
      }
      source += "} \n";
    }
    return source;
  };
};
Cesium3DTileBatchTable.prototype.getClassificationFragmentShaderCallback = function() {
  if (this.featuresLength === 0) {
    return;
  }
  return function(source) {
    source = ShaderSource_default.replaceMain(source, "tile_main");
    if (ContextLimits_default.maximumVertexTextureImageUnits > 0) {
      source += "uniform sampler2D tile_pickTexture;\nvarying vec2 tile_featureSt; \nvarying vec4 tile_featureColor; \nvoid main() \n{ \n    tile_main(); \n    gl_FragColor = tile_featureColor; \n    gl_FragColor.rgb *= gl_FragColor.a; \n}";
    } else {
      source += "uniform sampler2D tile_batchTexture; \nuniform sampler2D tile_pickTexture;\nvarying vec2 tile_featureSt; \nvoid main() \n{ \n    tile_main(); \n    vec4 featureProperties = texture2D(tile_batchTexture, tile_featureSt); \n    if (featureProperties.a == 0.0) { \n        discard; \n    } \n    gl_FragColor = featureProperties; \n    gl_FragColor.rgb *= gl_FragColor.a; \n} \n";
    }
    return source;
  };
};
function getColorBlend(batchTable) {
  const tileset = batchTable._content.tileset;
  const colorBlendMode = tileset.colorBlendMode;
  const colorBlendAmount = tileset.colorBlendAmount;
  if (colorBlendMode === Cesium3DTileColorBlendMode_default.HIGHLIGHT) {
    return 0;
  }
  if (colorBlendMode === Cesium3DTileColorBlendMode_default.REPLACE) {
    return 1;
  }
  if (colorBlendMode === Cesium3DTileColorBlendMode_default.MIX) {
    return Math_default.clamp(colorBlendAmount, Math_default.EPSILON4, 1);
  }
  throw new DeveloperError_default(`Invalid color blend mode "${colorBlendMode}".`);
}
Cesium3DTileBatchTable.prototype.getUniformMapCallback = function() {
  if (this.featuresLength === 0) {
    return;
  }
  const that = this;
  return function(uniformMap2) {
    const batchUniformMap = {
      tile_batchTexture: function() {
        return defaultValue_default(
          that._batchTexture.batchTexture,
          that._batchTexture.defaultTexture
        );
      },
      tile_textureDimensions: function() {
        return that._batchTexture.textureDimensions;
      },
      tile_textureStep: function() {
        return that._batchTexture.textureStep;
      },
      tile_colorBlend: function() {
        return getColorBlend(that);
      },
      tile_pickTexture: function() {
        return that._batchTexture.pickTexture;
      }
    };
    return combine_default(uniformMap2, batchUniformMap);
  };
};
Cesium3DTileBatchTable.prototype.getPickId = function() {
  return "texture2D(tile_pickTexture, tile_featureSt)";
};
var StyleCommandsNeeded = {
  ALL_OPAQUE: 0,
  ALL_TRANSLUCENT: 1,
  OPAQUE_AND_TRANSLUCENT: 2
};
Cesium3DTileBatchTable.prototype.addDerivedCommands = function(frameState, commandStart) {
  const commandList = frameState.commandList;
  const commandEnd = commandList.length;
  const tile = this._content._tile;
  const finalResolution = tile._finalResolution;
  const tileset = tile.tileset;
  const bivariateVisibilityTest = tileset._skipLevelOfDetail && tileset._hasMixedContent && frameState.context.stencilBuffer;
  const styleCommandsNeeded = getStyleCommandsNeeded(this);
  for (let i2 = commandStart; i2 < commandEnd; ++i2) {
    const command = commandList[i2];
    if (command.pass === Pass_default.COMPUTE) {
      continue;
    }
    let derivedCommands = command.derivedCommands.tileset;
    if (!defined_default(derivedCommands) || command.dirty) {
      derivedCommands = {};
      command.derivedCommands.tileset = derivedCommands;
      derivedCommands.originalCommand = deriveCommand(command);
      command.dirty = false;
    }
    const originalCommand = derivedCommands.originalCommand;
    if (styleCommandsNeeded !== StyleCommandsNeeded.ALL_OPAQUE && command.pass !== Pass_default.TRANSLUCENT) {
      if (!defined_default(derivedCommands.translucent)) {
        derivedCommands.translucent = deriveTranslucentCommand(originalCommand);
      }
    }
    if (styleCommandsNeeded !== StyleCommandsNeeded.ALL_TRANSLUCENT && command.pass !== Pass_default.TRANSLUCENT) {
      if (!defined_default(derivedCommands.opaque)) {
        derivedCommands.opaque = deriveOpaqueCommand(originalCommand);
      }
      if (bivariateVisibilityTest) {
        if (!finalResolution) {
          if (!defined_default(derivedCommands.zback)) {
            derivedCommands.zback = deriveZBackfaceCommand(
              frameState.context,
              originalCommand
            );
          }
          tileset._backfaceCommands.push(derivedCommands.zback);
        }
        if (!defined_default(derivedCommands.stencil) || tile._selectionDepth !== getLastSelectionDepth(derivedCommands.stencil)) {
          if (command.renderState.depthMask) {
            derivedCommands.stencil = deriveStencilCommand(
              originalCommand,
              tile._selectionDepth
            );
          } else {
            derivedCommands.stencil = derivedCommands.opaque;
          }
        }
      }
    }
    const opaqueCommand = bivariateVisibilityTest ? derivedCommands.stencil : derivedCommands.opaque;
    const translucentCommand = derivedCommands.translucent;
    if (command.pass !== Pass_default.TRANSLUCENT) {
      if (styleCommandsNeeded === StyleCommandsNeeded.ALL_OPAQUE) {
        commandList[i2] = opaqueCommand;
      }
      if (styleCommandsNeeded === StyleCommandsNeeded.ALL_TRANSLUCENT) {
        commandList[i2] = translucentCommand;
      }
      if (styleCommandsNeeded === StyleCommandsNeeded.OPAQUE_AND_TRANSLUCENT) {
        commandList[i2] = opaqueCommand;
        commandList.push(translucentCommand);
      }
    } else {
      commandList[i2] = originalCommand;
    }
  }
};
function getStyleCommandsNeeded(batchTable) {
  const translucentFeaturesLength = batchTable._batchTexture.translucentFeaturesLength;
  if (translucentFeaturesLength === 0) {
    return StyleCommandsNeeded.ALL_OPAQUE;
  } else if (translucentFeaturesLength === batchTable.featuresLength) {
    return StyleCommandsNeeded.ALL_TRANSLUCENT;
  }
  return StyleCommandsNeeded.OPAQUE_AND_TRANSLUCENT;
}
function deriveCommand(command) {
  const derivedCommand = DrawCommand_default.shallowClone(command);
  const translucentCommand = derivedCommand.pass === Pass_default.TRANSLUCENT;
  derivedCommand.uniformMap = defined_default(derivedCommand.uniformMap) ? derivedCommand.uniformMap : {};
  derivedCommand.uniformMap.tile_translucentCommand = function() {
    return translucentCommand;
  };
  return derivedCommand;
}
function deriveTranslucentCommand(command) {
  const derivedCommand = DrawCommand_default.shallowClone(command);
  derivedCommand.pass = Pass_default.TRANSLUCENT;
  derivedCommand.renderState = getTranslucentRenderState(command.renderState);
  return derivedCommand;
}
function deriveOpaqueCommand(command) {
  const derivedCommand = DrawCommand_default.shallowClone(command);
  derivedCommand.renderState = getOpaqueRenderState(command.renderState);
  return derivedCommand;
}
function getLogDepthPolygonOffsetFragmentShaderProgram(context, shaderProgram) {
  let shader = context.shaderCache.getDerivedShaderProgram(
    shaderProgram,
    "zBackfaceLogDepth"
  );
  if (!defined_default(shader)) {
    const fs = shaderProgram.fragmentShaderSource.clone();
    fs.defines = defined_default(fs.defines) ? fs.defines.slice(0) : [];
    fs.defines.push("POLYGON_OFFSET");
    fs.sources.unshift(
      "#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n#endif\n"
    );
    shader = context.shaderCache.createDerivedShaderProgram(
      shaderProgram,
      "zBackfaceLogDepth",
      {
        vertexShaderSource: shaderProgram.vertexShaderSource,
        fragmentShaderSource: fs,
        attributeLocations: shaderProgram._attributeLocations
      }
    );
  }
  return shader;
}
function deriveZBackfaceCommand(context, command) {
  const derivedCommand = DrawCommand_default.shallowClone(command);
  const rs = clone_default(derivedCommand.renderState, true);
  rs.cull.enabled = true;
  rs.cull.face = CullFace_default.FRONT;
  rs.colorMask = {
    red: false,
    green: false,
    blue: false,
    alpha: false
  };
  rs.polygonOffset = {
    enabled: true,
    factor: 5,
    units: 5
  };
  rs.stencilTest = StencilConstants_default.setCesium3DTileBit();
  rs.stencilMask = StencilConstants_default.CESIUM_3D_TILE_MASK;
  derivedCommand.renderState = RenderState_default.fromCache(rs);
  derivedCommand.castShadows = false;
  derivedCommand.receiveShadows = false;
  derivedCommand.uniformMap = clone_default(command.uniformMap);
  const polygonOffset = new Cartesian2_default(5, 5);
  derivedCommand.uniformMap.u_polygonOffset = function() {
    return polygonOffset;
  };
  derivedCommand.shaderProgram = getLogDepthPolygonOffsetFragmentShaderProgram(
    context,
    command.shaderProgram
  );
  return derivedCommand;
}
function deriveStencilCommand(command, reference) {
  const derivedCommand = DrawCommand_default.shallowClone(command);
  const rs = clone_default(derivedCommand.renderState, true);
  rs.stencilTest.enabled = true;
  rs.stencilTest.mask = StencilConstants_default.SKIP_LOD_MASK;
  rs.stencilTest.reference = StencilConstants_default.CESIUM_3D_TILE_MASK | reference << StencilConstants_default.SKIP_LOD_BIT_SHIFT;
  rs.stencilTest.frontFunction = StencilFunction_default.GREATER_OR_EQUAL;
  rs.stencilTest.frontOperation.zPass = StencilOperation_default.REPLACE;
  rs.stencilTest.backFunction = StencilFunction_default.GREATER_OR_EQUAL;
  rs.stencilTest.backOperation.zPass = StencilOperation_default.REPLACE;
  rs.stencilMask = StencilConstants_default.CESIUM_3D_TILE_MASK | StencilConstants_default.SKIP_LOD_MASK;
  derivedCommand.renderState = RenderState_default.fromCache(rs);
  return derivedCommand;
}
function getLastSelectionDepth(stencilCommand) {
  const reference = stencilCommand.renderState.stencilTest.reference;
  return (reference & StencilConstants_default.SKIP_LOD_MASK) >>> StencilConstants_default.SKIP_LOD_BIT_SHIFT;
}
function getTranslucentRenderState(renderState) {
  const rs = clone_default(renderState, true);
  rs.cull.enabled = false;
  rs.depthTest.enabled = true;
  rs.depthMask = false;
  rs.blending = BlendingState_default.ALPHA_BLEND;
  rs.stencilTest = StencilConstants_default.setCesium3DTileBit();
  rs.stencilMask = StencilConstants_default.CESIUM_3D_TILE_MASK;
  return RenderState_default.fromCache(rs);
}
function getOpaqueRenderState(renderState) {
  const rs = clone_default(renderState, true);
  rs.stencilTest = StencilConstants_default.setCesium3DTileBit();
  rs.stencilMask = StencilConstants_default.CESIUM_3D_TILE_MASK;
  return RenderState_default.fromCache(rs);
}
Cesium3DTileBatchTable.prototype.update = function(tileset, frameState) {
  this._batchTexture.update(tileset, frameState);
};
Cesium3DTileBatchTable.prototype.isDestroyed = function() {
  return false;
};
Cesium3DTileBatchTable.prototype.destroy = function() {
  this._batchTexture = this._batchTexture && this._batchTexture.destroy();
  return destroyObject_default(this);
};
var Cesium3DTileBatchTable_default = Cesium3DTileBatchTable;

// node_modules/cesium/Source/Scene/Cesium3DTileFeature.js
function Cesium3DTileFeature(content, batchId) {
  this._content = content;
  this._batchId = batchId;
  this._color = void 0;
}
Object.defineProperties(Cesium3DTileFeature.prototype, {
  show: {
    get: function() {
      return this._content.batchTable.getShow(this._batchId);
    },
    set: function(value) {
      this._content.batchTable.setShow(this._batchId, value);
    }
  },
  color: {
    get: function() {
      if (!defined_default(this._color)) {
        this._color = new Color_default();
      }
      return this._content.batchTable.getColor(this._batchId, this._color);
    },
    set: function(value) {
      this._content.batchTable.setColor(this._batchId, value);
    }
  },
  polylinePositions: {
    get: function() {
      if (!defined_default(this._content.getPolylinePositions)) {
        return void 0;
      }
      return this._content.getPolylinePositions(this._batchId);
    }
  },
  content: {
    get: function() {
      return this._content;
    }
  },
  tileset: {
    get: function() {
      return this._content.tileset;
    }
  },
  primitive: {
    get: function() {
      return this._content.tileset;
    }
  },
  featureId: {
    get: function() {
      return this._batchId;
    }
  },
  pickId: {
    get: function() {
      return this._content.batchTable.getPickColor(this._batchId);
    }
  }
});
Cesium3DTileFeature.prototype.hasProperty = function(name) {
  return this._content.batchTable.hasProperty(this._batchId, name);
};
Cesium3DTileFeature.prototype.getPropertyNames = function(results) {
  return this._content.batchTable.getPropertyNames(this._batchId, results);
};
Cesium3DTileFeature.prototype.getProperty = function(name) {
  return this._content.batchTable.getProperty(this._batchId, name);
};
Cesium3DTileFeature.getPropertyInherited = function(content, batchId, name) {
  const batchTable = content.batchTable;
  if (defined_default(batchTable)) {
    if (batchTable.hasPropertyBySemantic(batchId, name)) {
      return batchTable.getPropertyBySemantic(batchId, name);
    }
    if (batchTable.hasProperty(batchId, name)) {
      return batchTable.getProperty(batchId, name);
    }
  }
  const contentMetadata = content.metadata;
  if (defined_default(contentMetadata)) {
    if (contentMetadata.hasPropertyBySemantic(name)) {
      return contentMetadata.getPropertyBySemantic(name);
    }
    if (contentMetadata.hasProperty(name)) {
      return contentMetadata.getProperty(name);
    }
  }
  const tile = content.tile;
  const tileMetadata = tile.metadata;
  if (defined_default(tileMetadata)) {
    if (tileMetadata.hasPropertyBySemantic(name)) {
      return tileMetadata.getPropertyBySemantic(name);
    }
    if (tileMetadata.hasProperty(name)) {
      return tileMetadata.getProperty(name);
    }
  }
  let subtreeMetadata;
  if (defined_default(tile.implicitSubtree)) {
    subtreeMetadata = tile.implicitSubtree.metadata;
  }
  if (defined_default(subtreeMetadata)) {
    if (subtreeMetadata.hasPropertyBySemantic(name)) {
      return subtreeMetadata.getPropertyBySemantic(name);
    }
    if (subtreeMetadata.hasProperty(name)) {
      return subtreeMetadata.getProperty(name);
    }
  }
  const groupMetadata = defined_default(content.group) ? content.group.metadata : void 0;
  if (defined_default(groupMetadata)) {
    if (groupMetadata.hasPropertyBySemantic(name)) {
      return groupMetadata.getPropertyBySemantic(name);
    }
    if (groupMetadata.hasProperty(name)) {
      return groupMetadata.getProperty(name);
    }
  }
  const tilesetMetadata = content.tileset.metadata;
  if (defined_default(tilesetMetadata)) {
    if (tilesetMetadata.hasPropertyBySemantic(name)) {
      return tilesetMetadata.getPropertyBySemantic(name);
    }
    if (tilesetMetadata.hasProperty(name)) {
      return tilesetMetadata.getProperty(name);
    }
  }
  return void 0;
};
Cesium3DTileFeature.prototype.getPropertyInherited = function(name) {
  return Cesium3DTileFeature.getPropertyInherited(
    this._content,
    this._batchId,
    name
  );
};
Cesium3DTileFeature.prototype.setProperty = function(name, value) {
  this._content.batchTable.setProperty(this._batchId, name, value);
  this._content.featurePropertiesDirty = true;
};
Cesium3DTileFeature.prototype.isExactClass = function(className) {
  return this._content.batchTable.isExactClass(this._batchId, className);
};
Cesium3DTileFeature.prototype.isClass = function(className) {
  return this._content.batchTable.isClass(this._batchId, className);
};
Cesium3DTileFeature.prototype.getExactClassName = function() {
  return this._content.batchTable.getExactClassName(this._batchId);
};
var Cesium3DTileFeature_default = Cesium3DTileFeature;

// node_modules/cesium/Source/Scene/Cesium3DTileFeatureTable.js
function Cesium3DTileFeatureTable(featureTableJson, featureTableBinary) {
  this.json = featureTableJson;
  this.buffer = featureTableBinary;
  this._cachedTypedArrays = {};
  this.featuresLength = 0;
}
function getTypedArrayFromBinary(featureTable, semantic, componentType, componentLength, count, byteOffset) {
  const cachedTypedArrays = featureTable._cachedTypedArrays;
  let typedArray = cachedTypedArrays[semantic];
  if (!defined_default(typedArray)) {
    typedArray = ComponentDatatype_default.createArrayBufferView(
      componentType,
      featureTable.buffer.buffer,
      featureTable.buffer.byteOffset + byteOffset,
      count * componentLength
    );
    cachedTypedArrays[semantic] = typedArray;
  }
  return typedArray;
}
function getTypedArrayFromArray(featureTable, semantic, componentType, array) {
  const cachedTypedArrays = featureTable._cachedTypedArrays;
  let typedArray = cachedTypedArrays[semantic];
  if (!defined_default(typedArray)) {
    typedArray = ComponentDatatype_default.createTypedArray(componentType, array);
    cachedTypedArrays[semantic] = typedArray;
  }
  return typedArray;
}
Cesium3DTileFeatureTable.prototype.getGlobalProperty = function(semantic, componentType, componentLength) {
  const jsonValue = this.json[semantic];
  if (!defined_default(jsonValue)) {
    return void 0;
  }
  if (defined_default(jsonValue.byteOffset)) {
    componentType = defaultValue_default(componentType, ComponentDatatype_default.UNSIGNED_INT);
    componentLength = defaultValue_default(componentLength, 1);
    return getTypedArrayFromBinary(
      this,
      semantic,
      componentType,
      componentLength,
      1,
      jsonValue.byteOffset
    );
  }
  return jsonValue;
};
Cesium3DTileFeatureTable.prototype.hasProperty = function(semantic) {
  return defined_default(this.json[semantic]);
};
Cesium3DTileFeatureTable.prototype.getPropertyArray = function(semantic, componentType, componentLength) {
  const jsonValue = this.json[semantic];
  if (!defined_default(jsonValue)) {
    return void 0;
  }
  if (defined_default(jsonValue.byteOffset)) {
    if (defined_default(jsonValue.componentType)) {
      componentType = ComponentDatatype_default.fromName(jsonValue.componentType);
    }
    return getTypedArrayFromBinary(
      this,
      semantic,
      componentType,
      componentLength,
      this.featuresLength,
      jsonValue.byteOffset
    );
  }
  return getTypedArrayFromArray(this, semantic, componentType, jsonValue);
};
Cesium3DTileFeatureTable.prototype.getProperty = function(semantic, componentType, componentLength, featureId, result) {
  const jsonValue = this.json[semantic];
  if (!defined_default(jsonValue)) {
    return void 0;
  }
  const typedArray = this.getPropertyArray(
    semantic,
    componentType,
    componentLength
  );
  if (componentLength === 1) {
    return typedArray[featureId];
  }
  for (let i2 = 0; i2 < componentLength; ++i2) {
    result[i2] = typedArray[componentLength * featureId + i2];
  }
  return result;
};
var Cesium3DTileFeatureTable_default = Cesium3DTileFeatureTable;

// node_modules/cesium/Source/Scene/GltfPipeline/addToArray.js
function addToArray(array, element, checkDuplicates) {
  checkDuplicates = defaultValue_default(checkDuplicates, false);
  if (checkDuplicates) {
    const index2 = array.indexOf(element);
    if (index2 > -1) {
      return index2;
    }
  }
  array.push(element);
  return array.length - 1;
}
var addToArray_default = addToArray;

// node_modules/cesium/Source/Scene/GltfPipeline/usesExtension.js
function usesExtension(gltf, extension) {
  return defined_default(gltf.extensionsUsed) && gltf.extensionsUsed.indexOf(extension) >= 0;
}
var usesExtension_default = usesExtension;

// node_modules/cesium/Source/Scene/GltfPipeline/ForEach.js
function ForEach() {
}
ForEach.objectLegacy = function(objects, handler) {
  if (defined_default(objects)) {
    for (const objectId in objects) {
      if (Object.prototype.hasOwnProperty.call(objects, objectId)) {
        const object2 = objects[objectId];
        const value = handler(object2, objectId);
        if (defined_default(value)) {
          return value;
        }
      }
    }
  }
};
ForEach.object = function(arrayOfObjects, handler) {
  if (defined_default(arrayOfObjects)) {
    const length3 = arrayOfObjects.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const object2 = arrayOfObjects[i2];
      const value = handler(object2, i2);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.topLevel = function(gltf, name, handler) {
  const gltfProperty = gltf[name];
  if (defined_default(gltfProperty) && !Array.isArray(gltfProperty)) {
    return ForEach.objectLegacy(gltfProperty, handler);
  }
  return ForEach.object(gltfProperty, handler);
};
ForEach.accessor = function(gltf, handler) {
  return ForEach.topLevel(gltf, "accessors", handler);
};
ForEach.accessorWithSemantic = function(gltf, semantic, handler) {
  const visited = {};
  return ForEach.mesh(gltf, function(mesh2) {
    return ForEach.meshPrimitive(mesh2, function(primitive) {
      const valueForEach = ForEach.meshPrimitiveAttribute(
        primitive,
        function(accessorId, attributeSemantic) {
          if (attributeSemantic.indexOf(semantic) === 0 && !defined_default(visited[accessorId])) {
            visited[accessorId] = true;
            const value = handler(accessorId);
            if (defined_default(value)) {
              return value;
            }
          }
        }
      );
      if (defined_default(valueForEach)) {
        return valueForEach;
      }
      return ForEach.meshPrimitiveTarget(primitive, function(target) {
        return ForEach.meshPrimitiveTargetAttribute(
          target,
          function(accessorId, attributeSemantic) {
            if (attributeSemantic.indexOf(semantic) === 0 && !defined_default(visited[accessorId])) {
              visited[accessorId] = true;
              const value = handler(accessorId);
              if (defined_default(value)) {
                return value;
              }
            }
          }
        );
      });
    });
  });
};
ForEach.accessorContainingVertexAttributeData = function(gltf, handler) {
  const visited = {};
  return ForEach.mesh(gltf, function(mesh2) {
    return ForEach.meshPrimitive(mesh2, function(primitive) {
      const valueForEach = ForEach.meshPrimitiveAttribute(
        primitive,
        function(accessorId) {
          if (!defined_default(visited[accessorId])) {
            visited[accessorId] = true;
            const value = handler(accessorId);
            if (defined_default(value)) {
              return value;
            }
          }
        }
      );
      if (defined_default(valueForEach)) {
        return valueForEach;
      }
      return ForEach.meshPrimitiveTarget(primitive, function(target) {
        return ForEach.meshPrimitiveTargetAttribute(
          target,
          function(accessorId) {
            if (!defined_default(visited[accessorId])) {
              visited[accessorId] = true;
              const value = handler(accessorId);
              if (defined_default(value)) {
                return value;
              }
            }
          }
        );
      });
    });
  });
};
ForEach.accessorContainingIndexData = function(gltf, handler) {
  const visited = {};
  return ForEach.mesh(gltf, function(mesh2) {
    return ForEach.meshPrimitive(mesh2, function(primitive) {
      const indices2 = primitive.indices;
      if (defined_default(indices2) && !defined_default(visited[indices2])) {
        visited[indices2] = true;
        const value = handler(indices2);
        if (defined_default(value)) {
          return value;
        }
      }
    });
  });
};
ForEach.animation = function(gltf, handler) {
  return ForEach.topLevel(gltf, "animations", handler);
};
ForEach.animationChannel = function(animation, handler) {
  const channels = animation.channels;
  return ForEach.object(channels, handler);
};
ForEach.animationSampler = function(animation, handler) {
  const samplers = animation.samplers;
  return ForEach.object(samplers, handler);
};
ForEach.buffer = function(gltf, handler) {
  return ForEach.topLevel(gltf, "buffers", handler);
};
ForEach.bufferView = function(gltf, handler) {
  return ForEach.topLevel(gltf, "bufferViews", handler);
};
ForEach.camera = function(gltf, handler) {
  return ForEach.topLevel(gltf, "cameras", handler);
};
ForEach.image = function(gltf, handler) {
  return ForEach.topLevel(gltf, "images", handler);
};
ForEach.material = function(gltf, handler) {
  return ForEach.topLevel(gltf, "materials", handler);
};
ForEach.materialValue = function(material, handler) {
  let values = material.values;
  if (defined_default(material.extensions) && defined_default(material.extensions.KHR_techniques_webgl)) {
    values = material.extensions.KHR_techniques_webgl.values;
  }
  for (const name in values) {
    if (Object.prototype.hasOwnProperty.call(values, name)) {
      const value = handler(values[name], name);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.mesh = function(gltf, handler) {
  return ForEach.topLevel(gltf, "meshes", handler);
};
ForEach.meshPrimitive = function(mesh2, handler) {
  const primitives = mesh2.primitives;
  if (defined_default(primitives)) {
    const primitivesLength = primitives.length;
    for (let i2 = 0; i2 < primitivesLength; i2++) {
      const primitive = primitives[i2];
      const value = handler(primitive, i2);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.meshPrimitiveAttribute = function(primitive, handler) {
  const attributes = primitive.attributes;
  for (const semantic in attributes) {
    if (Object.prototype.hasOwnProperty.call(attributes, semantic)) {
      const value = handler(attributes[semantic], semantic);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.meshPrimitiveTarget = function(primitive, handler) {
  const targets = primitive.targets;
  if (defined_default(targets)) {
    const length3 = targets.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      const value = handler(targets[i2], i2);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.meshPrimitiveTargetAttribute = function(target, handler) {
  for (const semantic in target) {
    if (Object.prototype.hasOwnProperty.call(target, semantic)) {
      const accessorId = target[semantic];
      const value = handler(accessorId, semantic);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.node = function(gltf, handler) {
  return ForEach.topLevel(gltf, "nodes", handler);
};
ForEach.nodeInTree = function(gltf, nodeIds, handler) {
  const nodes = gltf.nodes;
  if (defined_default(nodes)) {
    const length3 = nodeIds.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const nodeId = nodeIds[i2];
      const node = nodes[nodeId];
      if (defined_default(node)) {
        let value = handler(node, nodeId);
        if (defined_default(value)) {
          return value;
        }
        const children = node.children;
        if (defined_default(children)) {
          value = ForEach.nodeInTree(gltf, children, handler);
          if (defined_default(value)) {
            return value;
          }
        }
      }
    }
  }
};
ForEach.nodeInScene = function(gltf, scene, handler) {
  const sceneNodeIds = scene.nodes;
  if (defined_default(sceneNodeIds)) {
    return ForEach.nodeInTree(gltf, sceneNodeIds, handler);
  }
};
ForEach.program = function(gltf, handler) {
  if (usesExtension_default(gltf, "KHR_techniques_webgl")) {
    return ForEach.object(
      gltf.extensions.KHR_techniques_webgl.programs,
      handler
    );
  }
  return ForEach.topLevel(gltf, "programs", handler);
};
ForEach.sampler = function(gltf, handler) {
  return ForEach.topLevel(gltf, "samplers", handler);
};
ForEach.scene = function(gltf, handler) {
  return ForEach.topLevel(gltf, "scenes", handler);
};
ForEach.shader = function(gltf, handler) {
  if (usesExtension_default(gltf, "KHR_techniques_webgl")) {
    return ForEach.object(
      gltf.extensions.KHR_techniques_webgl.shaders,
      handler
    );
  }
  return ForEach.topLevel(gltf, "shaders", handler);
};
ForEach.skin = function(gltf, handler) {
  return ForEach.topLevel(gltf, "skins", handler);
};
ForEach.skinJoint = function(skin, handler) {
  const joints = skin.joints;
  if (defined_default(joints)) {
    const jointsLength = joints.length;
    for (let i2 = 0; i2 < jointsLength; i2++) {
      const joint = joints[i2];
      const value = handler(joint);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.techniqueAttribute = function(technique, handler) {
  const attributes = technique.attributes;
  for (const attributeName in attributes) {
    if (Object.prototype.hasOwnProperty.call(attributes, attributeName)) {
      const value = handler(attributes[attributeName], attributeName);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.techniqueUniform = function(technique, handler) {
  const uniforms = technique.uniforms;
  for (const uniformName in uniforms) {
    if (Object.prototype.hasOwnProperty.call(uniforms, uniformName)) {
      const value = handler(uniforms[uniformName], uniformName);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.techniqueParameter = function(technique, handler) {
  const parameters = technique.parameters;
  for (const parameterName in parameters) {
    if (Object.prototype.hasOwnProperty.call(parameters, parameterName)) {
      const value = handler(parameters[parameterName], parameterName);
      if (defined_default(value)) {
        return value;
      }
    }
  }
};
ForEach.technique = function(gltf, handler) {
  if (usesExtension_default(gltf, "KHR_techniques_webgl")) {
    return ForEach.object(
      gltf.extensions.KHR_techniques_webgl.techniques,
      handler
    );
  }
  return ForEach.topLevel(gltf, "techniques", handler);
};
ForEach.texture = function(gltf, handler) {
  return ForEach.topLevel(gltf, "textures", handler);
};
var ForEach_default = ForEach;

// node_modules/cesium/Source/Scene/GltfPipeline/numberOfComponentsForType.js
function numberOfComponentsForType(type) {
  switch (type) {
    case "SCALAR":
      return 1;
    case "VEC2":
      return 2;
    case "VEC3":
      return 3;
    case "VEC4":
    case "MAT2":
      return 4;
    case "MAT3":
      return 9;
    case "MAT4":
      return 16;
  }
}
var numberOfComponentsForType_default = numberOfComponentsForType;

// node_modules/cesium/Source/Scene/GltfPipeline/getAccessorByteStride.js
function getAccessorByteStride(gltf, accessor) {
  const bufferViewId = accessor.bufferView;
  if (defined_default(bufferViewId)) {
    const bufferView = gltf.bufferViews[bufferViewId];
    if (defined_default(bufferView.byteStride) && bufferView.byteStride > 0) {
      return bufferView.byteStride;
    }
  }
  return ComponentDatatype_default.getSizeInBytes(accessor.componentType) * numberOfComponentsForType_default(accessor.type);
}
var getAccessorByteStride_default = getAccessorByteStride;

// node_modules/cesium/Source/Scene/GltfPipeline/addDefaults.js
function addDefaults(gltf) {
  ForEach_default.accessor(gltf, function(accessor) {
    if (defined_default(accessor.bufferView)) {
      accessor.byteOffset = defaultValue_default(accessor.byteOffset, 0);
    }
  });
  ForEach_default.bufferView(gltf, function(bufferView) {
    if (defined_default(bufferView.buffer)) {
      bufferView.byteOffset = defaultValue_default(bufferView.byteOffset, 0);
    }
  });
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      primitive.mode = defaultValue_default(primitive.mode, WebGLConstants_default.TRIANGLES);
      if (!defined_default(primitive.material)) {
        if (!defined_default(gltf.materials)) {
          gltf.materials = [];
        }
        const defaultMaterial4 = {
          name: "default"
        };
        primitive.material = addToArray_default(gltf.materials, defaultMaterial4);
      }
    });
  });
  ForEach_default.accessorContainingVertexAttributeData(gltf, function(accessorId) {
    const accessor = gltf.accessors[accessorId];
    const bufferViewId = accessor.bufferView;
    accessor.normalized = defaultValue_default(accessor.normalized, false);
    if (defined_default(bufferViewId)) {
      const bufferView = gltf.bufferViews[bufferViewId];
      bufferView.byteStride = getAccessorByteStride_default(gltf, accessor);
      bufferView.target = WebGLConstants_default.ARRAY_BUFFER;
    }
  });
  ForEach_default.accessorContainingIndexData(gltf, function(accessorId) {
    const accessor = gltf.accessors[accessorId];
    const bufferViewId = accessor.bufferView;
    if (defined_default(bufferViewId)) {
      const bufferView = gltf.bufferViews[bufferViewId];
      bufferView.target = WebGLConstants_default.ELEMENT_ARRAY_BUFFER;
    }
  });
  ForEach_default.material(gltf, function(material) {
    const extensions = defaultValue_default(
      material.extensions,
      defaultValue_default.EMPTY_OBJECT
    );
    const materialsCommon = extensions.KHR_materials_common;
    if (defined_default(materialsCommon)) {
      const technique = materialsCommon.technique;
      const values = defined_default(materialsCommon.values) ? materialsCommon.values : {};
      materialsCommon.values = values;
      values.ambient = defined_default(values.ambient) ? values.ambient : [0, 0, 0, 1];
      values.emission = defined_default(values.emission) ? values.emission : [0, 0, 0, 1];
      values.transparency = defaultValue_default(values.transparency, 1);
      values.transparent = defaultValue_default(values.transparent, false);
      values.doubleSided = defaultValue_default(values.doubleSided, false);
      if (technique !== "CONSTANT") {
        values.diffuse = defined_default(values.diffuse) ? values.diffuse : [0, 0, 0, 1];
        if (technique !== "LAMBERT") {
          values.specular = defined_default(values.specular) ? values.specular : [0, 0, 0, 1];
          values.shininess = defaultValue_default(values.shininess, 0);
        }
      }
      return;
    }
    material.emissiveFactor = defaultValue_default(
      material.emissiveFactor,
      [0, 0, 0]
    );
    material.alphaMode = defaultValue_default(material.alphaMode, "OPAQUE");
    material.doubleSided = defaultValue_default(material.doubleSided, false);
    if (material.alphaMode === "MASK") {
      material.alphaCutoff = defaultValue_default(material.alphaCutoff, 0.5);
    }
    const techniquesExtension = extensions.KHR_techniques_webgl;
    if (defined_default(techniquesExtension)) {
      ForEach_default.materialValue(material, function(materialValue) {
        if (defined_default(materialValue.index)) {
          addTextureDefaults(materialValue);
        }
      });
    }
    addTextureDefaults(material.emissiveTexture);
    addTextureDefaults(material.normalTexture);
    addTextureDefaults(material.occlusionTexture);
    const pbrMetallicRoughness = material.pbrMetallicRoughness;
    if (defined_default(pbrMetallicRoughness)) {
      pbrMetallicRoughness.baseColorFactor = defaultValue_default(
        pbrMetallicRoughness.baseColorFactor,
        [1, 1, 1, 1]
      );
      pbrMetallicRoughness.metallicFactor = defaultValue_default(
        pbrMetallicRoughness.metallicFactor,
        1
      );
      pbrMetallicRoughness.roughnessFactor = defaultValue_default(
        pbrMetallicRoughness.roughnessFactor,
        1
      );
      addTextureDefaults(pbrMetallicRoughness.baseColorTexture);
      addTextureDefaults(pbrMetallicRoughness.metallicRoughnessTexture);
    }
    const pbrSpecularGlossiness = extensions.KHR_materials_pbrSpecularGlossiness;
    if (defined_default(pbrSpecularGlossiness)) {
      pbrSpecularGlossiness.diffuseFactor = defaultValue_default(
        pbrSpecularGlossiness.diffuseFactor,
        [1, 1, 1, 1]
      );
      pbrSpecularGlossiness.specularFactor = defaultValue_default(
        pbrSpecularGlossiness.specularFactor,
        [1, 1, 1]
      );
      pbrSpecularGlossiness.glossinessFactor = defaultValue_default(
        pbrSpecularGlossiness.glossinessFactor,
        1
      );
      addTextureDefaults(pbrSpecularGlossiness.specularGlossinessTexture);
    }
  });
  ForEach_default.animation(gltf, function(animation) {
    ForEach_default.animationSampler(animation, function(sampler) {
      sampler.interpolation = defaultValue_default(sampler.interpolation, "LINEAR");
    });
  });
  const animatedNodes = getAnimatedNodes(gltf);
  ForEach_default.node(gltf, function(node, id) {
    const animated = defined_default(animatedNodes[id]);
    if (animated || defined_default(node.translation) || defined_default(node.rotation) || defined_default(node.scale)) {
      node.translation = defaultValue_default(node.translation, [0, 0, 0]);
      node.rotation = defaultValue_default(node.rotation, [0, 0, 0, 1]);
      node.scale = defaultValue_default(node.scale, [1, 1, 1]);
    } else {
      node.matrix = defaultValue_default(
        node.matrix,
        [
          1,
          0,
          0,
          0,
          0,
          1,
          0,
          0,
          0,
          0,
          1,
          0,
          0,
          0,
          0,
          1
        ]
      );
    }
  });
  ForEach_default.sampler(gltf, function(sampler) {
    sampler.wrapS = defaultValue_default(sampler.wrapS, WebGLConstants_default.REPEAT);
    sampler.wrapT = defaultValue_default(sampler.wrapT, WebGLConstants_default.REPEAT);
  });
  if (defined_default(gltf.scenes) && !defined_default(gltf.scene)) {
    gltf.scene = 0;
  }
  return gltf;
}
function getAnimatedNodes(gltf) {
  const nodes = {};
  ForEach_default.animation(gltf, function(animation) {
    ForEach_default.animationChannel(animation, function(channel) {
      const target = channel.target;
      const nodeId = target.node;
      const path = target.path;
      if (path === "translation" || path === "rotation" || path === "scale") {
        nodes[nodeId] = true;
      }
    });
  });
  return nodes;
}
function addTextureDefaults(texture) {
  if (defined_default(texture)) {
    texture.texCoord = defaultValue_default(texture.texCoord, 0);
  }
}
var addDefaults_default = addDefaults;

// node_modules/cesium/Source/Scene/GltfPipeline/addPipelineExtras.js
function addPipelineExtras(gltf) {
  ForEach_default.shader(gltf, function(shader) {
    addExtras(shader);
  });
  ForEach_default.buffer(gltf, function(buffer) {
    addExtras(buffer);
  });
  ForEach_default.image(gltf, function(image) {
    addExtras(image);
  });
  addExtras(gltf);
  return gltf;
}
function addExtras(object2) {
  object2.extras = defined_default(object2.extras) ? object2.extras : {};
  object2.extras._pipeline = defined_default(object2.extras._pipeline) ? object2.extras._pipeline : {};
}
var addPipelineExtras_default = addPipelineExtras;

// node_modules/cesium/Source/Scene/GltfPipeline/removeExtensionsRequired.js
function removeExtensionsRequired(gltf, extension) {
  const extensionsRequired = gltf.extensionsRequired;
  if (defined_default(extensionsRequired)) {
    const index2 = extensionsRequired.indexOf(extension);
    if (index2 >= 0) {
      extensionsRequired.splice(index2, 1);
    }
    if (extensionsRequired.length === 0) {
      delete gltf.extensionsRequired;
    }
  }
}
var removeExtensionsRequired_default = removeExtensionsRequired;

// node_modules/cesium/Source/Scene/GltfPipeline/removeExtensionsUsed.js
function removeExtensionsUsed(gltf, extension) {
  const extensionsUsed = gltf.extensionsUsed;
  if (defined_default(extensionsUsed)) {
    const index2 = extensionsUsed.indexOf(extension);
    if (index2 >= 0) {
      extensionsUsed.splice(index2, 1);
    }
    removeExtensionsRequired_default(gltf, extension);
    if (extensionsUsed.length === 0) {
      delete gltf.extensionsUsed;
    }
  }
}
var removeExtensionsUsed_default = removeExtensionsUsed;

// node_modules/cesium/Source/Scene/GltfPipeline/parseGlb.js
var sizeOfUint323 = 4;
function parseGlb(glb) {
  const magic = getMagic_default(glb);
  if (magic !== "glTF") {
    throw new RuntimeError_default("File is not valid binary glTF");
  }
  const header = readHeader(glb, 0, 5);
  const version = header[1];
  if (version !== 1 && version !== 2) {
    throw new RuntimeError_default("Binary glTF version is not 1 or 2");
  }
  if (version === 1) {
    return parseGlbVersion1(glb, header);
  }
  return parseGlbVersion2(glb, header);
}
function readHeader(glb, byteOffset, count) {
  const dataView = new DataView(glb.buffer);
  const header = new Array(count);
  for (let i2 = 0; i2 < count; ++i2) {
    header[i2] = dataView.getUint32(
      glb.byteOffset + byteOffset + i2 * sizeOfUint323,
      true
    );
  }
  return header;
}
function parseGlbVersion1(glb, header) {
  const length3 = header[2];
  const contentLength = header[3];
  const contentFormat = header[4];
  if (contentFormat !== 0) {
    throw new RuntimeError_default("Binary glTF scene format is not JSON");
  }
  const jsonStart = 20;
  const binaryStart = jsonStart + contentLength;
  const contentString = getStringFromTypedArray_default(glb, jsonStart, contentLength);
  const gltf = JSON.parse(contentString);
  addPipelineExtras_default(gltf);
  const binaryBuffer = glb.subarray(binaryStart, length3);
  const buffers = gltf.buffers;
  if (defined_default(buffers) && Object.keys(buffers).length > 0) {
    const binaryGltfBuffer = defaultValue_default(
      buffers.binary_glTF,
      buffers.KHR_binary_glTF
    );
    if (defined_default(binaryGltfBuffer)) {
      binaryGltfBuffer.extras._pipeline.source = binaryBuffer;
      delete binaryGltfBuffer.uri;
    }
  }
  removeExtensionsUsed_default(gltf, "KHR_binary_glTF");
  return gltf;
}
function parseGlbVersion2(glb, header) {
  const length3 = header[2];
  let byteOffset = 12;
  let gltf;
  let binaryBuffer;
  while (byteOffset < length3) {
    const chunkHeader = readHeader(glb, byteOffset, 2);
    const chunkLength = chunkHeader[0];
    const chunkType = chunkHeader[1];
    byteOffset += 8;
    const chunkBuffer = glb.subarray(byteOffset, byteOffset + chunkLength);
    byteOffset += chunkLength;
    if (chunkType === 1313821514) {
      const jsonString = getStringFromTypedArray_default(chunkBuffer);
      gltf = JSON.parse(jsonString);
      addPipelineExtras_default(gltf);
    } else if (chunkType === 5130562) {
      binaryBuffer = chunkBuffer;
    }
  }
  if (defined_default(gltf) && defined_default(binaryBuffer)) {
    const buffers = gltf.buffers;
    if (defined_default(buffers) && buffers.length > 0) {
      const buffer = buffers[0];
      buffer.extras._pipeline.source = binaryBuffer;
    }
  }
  return gltf;
}
var parseGlb_default = parseGlb;

// node_modules/cesium/Source/Scene/GltfPipeline/addExtensionsUsed.js
function addExtensionsUsed(gltf, extension) {
  let extensionsUsed = gltf.extensionsUsed;
  if (!defined_default(extensionsUsed)) {
    extensionsUsed = [];
    gltf.extensionsUsed = extensionsUsed;
  }
  addToArray_default(extensionsUsed, extension, true);
}
var addExtensionsUsed_default = addExtensionsUsed;

// node_modules/cesium/Source/Scene/GltfPipeline/getComponentReader.js
function getComponentReader(componentType) {
  switch (componentType) {
    case ComponentDatatype_default.BYTE:
      return function(dataView, byteOffset, numberOfComponents, componentTypeByteLength, result) {
        for (let i2 = 0; i2 < numberOfComponents; ++i2) {
          result[i2] = dataView.getInt8(
            byteOffset + i2 * componentTypeByteLength
          );
        }
      };
    case ComponentDatatype_default.UNSIGNED_BYTE:
      return function(dataView, byteOffset, numberOfComponents, componentTypeByteLength, result) {
        for (let i2 = 0; i2 < numberOfComponents; ++i2) {
          result[i2] = dataView.getUint8(
            byteOffset + i2 * componentTypeByteLength
          );
        }
      };
    case ComponentDatatype_default.SHORT:
      return function(dataView, byteOffset, numberOfComponents, componentTypeByteLength, result) {
        for (let i2 = 0; i2 < numberOfComponents; ++i2) {
          result[i2] = dataView.getInt16(
            byteOffset + i2 * componentTypeByteLength,
            true
          );
        }
      };
    case ComponentDatatype_default.UNSIGNED_SHORT:
      return function(dataView, byteOffset, numberOfComponents, componentTypeByteLength, result) {
        for (let i2 = 0; i2 < numberOfComponents; ++i2) {
          result[i2] = dataView.getUint16(
            byteOffset + i2 * componentTypeByteLength,
            true
          );
        }
      };
    case ComponentDatatype_default.INT:
      return function(dataView, byteOffset, numberOfComponents, componentTypeByteLength, result) {
        for (let i2 = 0; i2 < numberOfComponents; ++i2) {
          result[i2] = dataView.getInt32(
            byteOffset + i2 * componentTypeByteLength,
            true
          );
        }
      };
    case ComponentDatatype_default.UNSIGNED_INT:
      return function(dataView, byteOffset, numberOfComponents, componentTypeByteLength, result) {
        for (let i2 = 0; i2 < numberOfComponents; ++i2) {
          result[i2] = dataView.getUint32(
            byteOffset + i2 * componentTypeByteLength,
            true
          );
        }
      };
    case ComponentDatatype_default.FLOAT:
      return function(dataView, byteOffset, numberOfComponents, componentTypeByteLength, result) {
        for (let i2 = 0; i2 < numberOfComponents; ++i2) {
          result[i2] = dataView.getFloat32(
            byteOffset + i2 * componentTypeByteLength,
            true
          );
        }
      };
    case ComponentDatatype_default.DOUBLE:
      return function(dataView, byteOffset, numberOfComponents, componentTypeByteLength, result) {
        for (let i2 = 0; i2 < numberOfComponents; ++i2) {
          result[i2] = dataView.getFloat64(
            byteOffset + i2 * componentTypeByteLength,
            true
          );
        }
      };
  }
}
var getComponentReader_default = getComponentReader;

// node_modules/cesium/Source/Scene/GltfPipeline/findAccessorMinMax.js
function findAccessorMinMax(gltf, accessor) {
  const bufferViews = gltf.bufferViews;
  const buffers = gltf.buffers;
  const bufferViewId = accessor.bufferView;
  const numberOfComponents = numberOfComponentsForType_default(accessor.type);
  if (!defined_default(accessor.bufferView)) {
    return {
      min: arrayFill_default(new Array(numberOfComponents), 0),
      max: arrayFill_default(new Array(numberOfComponents), 0)
    };
  }
  const min3 = arrayFill_default(
    new Array(numberOfComponents),
    Number.POSITIVE_INFINITY
  );
  const max3 = arrayFill_default(
    new Array(numberOfComponents),
    Number.NEGATIVE_INFINITY
  );
  const bufferView = bufferViews[bufferViewId];
  const bufferId = bufferView.buffer;
  const buffer = buffers[bufferId];
  const source = buffer.extras._pipeline.source;
  const count = accessor.count;
  const byteStride = getAccessorByteStride_default(gltf, accessor);
  let byteOffset = accessor.byteOffset + bufferView.byteOffset + source.byteOffset;
  const componentType = accessor.componentType;
  const componentTypeByteLength = ComponentDatatype_default.getSizeInBytes(componentType);
  const dataView = new DataView(source.buffer);
  const components = new Array(numberOfComponents);
  const componentReader = getComponentReader_default(componentType);
  for (let i2 = 0; i2 < count; i2++) {
    componentReader(
      dataView,
      byteOffset,
      numberOfComponents,
      componentTypeByteLength,
      components
    );
    for (let j = 0; j < numberOfComponents; j++) {
      const value = components[j];
      min3[j] = Math.min(min3[j], value);
      max3[j] = Math.max(max3[j], value);
    }
    byteOffset += byteStride;
  }
  return {
    min: min3,
    max: max3
  };
}
var findAccessorMinMax_default = findAccessorMinMax;

// node_modules/cesium/Source/Scene/GltfPipeline/moveTechniqueRenderStates.js
var defaultBlendEquation = [WebGLConstants_default.FUNC_ADD, WebGLConstants_default.FUNC_ADD];
var defaultBlendFactors = [
  WebGLConstants_default.ONE,
  WebGLConstants_default.ZERO,
  WebGLConstants_default.ONE,
  WebGLConstants_default.ZERO
];
function isStateEnabled(renderStates, state) {
  const enabled = renderStates.enable;
  if (!defined_default(enabled)) {
    return false;
  }
  return enabled.indexOf(state) > -1;
}
var supportedBlendFactors = [
  WebGLConstants_default.ZERO,
  WebGLConstants_default.ONE,
  WebGLConstants_default.SRC_COLOR,
  WebGLConstants_default.ONE_MINUS_SRC_COLOR,
  WebGLConstants_default.SRC_ALPHA,
  WebGLConstants_default.ONE_MINUS_SRC_ALPHA,
  WebGLConstants_default.DST_ALPHA,
  WebGLConstants_default.ONE_MINUS_DST_ALPHA,
  WebGLConstants_default.DST_COLOR,
  WebGLConstants_default.ONE_MINUS_DST_COLOR
];
function getSupportedBlendFactors(value, defaultValue2) {
  if (!defined_default(value)) {
    return defaultValue2;
  }
  for (let i2 = 0; i2 < 4; i2++) {
    if (supportedBlendFactors.indexOf(value[i2]) === -1) {
      return defaultValue2;
    }
  }
  return value;
}
function moveTechniqueRenderStates(gltf) {
  const blendingForTechnique = {};
  const materialPropertiesForTechnique = {};
  const techniquesLegacy = gltf.techniques;
  if (!defined_default(techniquesLegacy)) {
    return gltf;
  }
  ForEach_default.technique(gltf, function(techniqueLegacy, techniqueIndex) {
    const renderStates = techniqueLegacy.states;
    if (defined_default(renderStates)) {
      const materialProperties = materialPropertiesForTechnique[techniqueIndex] = {};
      if (isStateEnabled(renderStates, WebGLConstants_default.BLEND)) {
        materialProperties.alphaMode = "BLEND";
        const blendFunctions = renderStates.functions;
        if (defined_default(blendFunctions) && (defined_default(blendFunctions.blendEquationSeparate) || defined_default(blendFunctions.blendFuncSeparate))) {
          blendingForTechnique[techniqueIndex] = {
            blendEquation: defaultValue_default(
              blendFunctions.blendEquationSeparate,
              defaultBlendEquation
            ),
            blendFactors: getSupportedBlendFactors(
              blendFunctions.blendFuncSeparate,
              defaultBlendFactors
            )
          };
        }
      }
      if (!isStateEnabled(renderStates, WebGLConstants_default.CULL_FACE)) {
        materialProperties.doubleSided = true;
      }
      delete techniqueLegacy.states;
    }
  });
  if (Object.keys(blendingForTechnique).length > 0) {
    if (!defined_default(gltf.extensions)) {
      gltf.extensions = {};
    }
    addExtensionsUsed_default(gltf, "KHR_blend");
  }
  ForEach_default.material(gltf, function(material) {
    if (defined_default(material.technique)) {
      const materialProperties = materialPropertiesForTechnique[material.technique];
      ForEach_default.objectLegacy(materialProperties, function(value, property) {
        material[property] = value;
      });
      const blending = blendingForTechnique[material.technique];
      if (defined_default(blending)) {
        if (!defined_default(material.extensions)) {
          material.extensions = {};
        }
        material.extensions.KHR_blend = blending;
      }
    }
  });
  return gltf;
}
var moveTechniqueRenderStates_default = moveTechniqueRenderStates;

// node_modules/cesium/Source/Scene/GltfPipeline/addExtensionsRequired.js
function addExtensionsRequired(gltf, extension) {
  let extensionsRequired = gltf.extensionsRequired;
  if (!defined_default(extensionsRequired)) {
    extensionsRequired = [];
    gltf.extensionsRequired = extensionsRequired;
  }
  addToArray_default(extensionsRequired, extension, true);
  addExtensionsUsed_default(gltf, extension);
}
var addExtensionsRequired_default = addExtensionsRequired;

// node_modules/cesium/Source/Scene/GltfPipeline/moveTechniquesToExtension.js
function moveTechniquesToExtension(gltf) {
  const techniquesLegacy = gltf.techniques;
  const mappedUniforms = {};
  const updatedTechniqueIndices = {};
  const seenPrograms = {};
  if (defined_default(techniquesLegacy)) {
    const extension = {
      programs: [],
      shaders: [],
      techniques: []
    };
    const glExtensions = gltf.glExtensionsUsed;
    delete gltf.glExtensionsUsed;
    ForEach_default.technique(gltf, function(techniqueLegacy, techniqueId) {
      const technique = {
        name: techniqueLegacy.name,
        program: void 0,
        attributes: {},
        uniforms: {}
      };
      let parameterLegacy;
      ForEach_default.techniqueAttribute(
        techniqueLegacy,
        function(parameterName, attributeName) {
          parameterLegacy = techniqueLegacy.parameters[parameterName];
          technique.attributes[attributeName] = {
            semantic: parameterLegacy.semantic
          };
        }
      );
      ForEach_default.techniqueUniform(
        techniqueLegacy,
        function(parameterName, uniformName) {
          parameterLegacy = techniqueLegacy.parameters[parameterName];
          technique.uniforms[uniformName] = {
            count: parameterLegacy.count,
            node: parameterLegacy.node,
            type: parameterLegacy.type,
            semantic: parameterLegacy.semantic,
            value: parameterLegacy.value
          };
          if (!defined_default(mappedUniforms[techniqueId])) {
            mappedUniforms[techniqueId] = {};
          }
          mappedUniforms[techniqueId][parameterName] = uniformName;
        }
      );
      if (!defined_default(seenPrograms[techniqueLegacy.program])) {
        const programLegacy = gltf.programs[techniqueLegacy.program];
        const program = {
          name: programLegacy.name,
          fragmentShader: void 0,
          vertexShader: void 0,
          glExtensions
        };
        const fs = gltf.shaders[programLegacy.fragmentShader];
        program.fragmentShader = addToArray_default(extension.shaders, fs, true);
        const vs = gltf.shaders[programLegacy.vertexShader];
        program.vertexShader = addToArray_default(extension.shaders, vs, true);
        technique.program = addToArray_default(extension.programs, program);
        seenPrograms[techniqueLegacy.program] = technique.program;
      } else {
        technique.program = seenPrograms[techniqueLegacy.program];
      }
      updatedTechniqueIndices[techniqueId] = addToArray_default(
        extension.techniques,
        technique
      );
    });
    if (extension.techniques.length > 0) {
      if (!defined_default(gltf.extensions)) {
        gltf.extensions = {};
      }
      gltf.extensions.KHR_techniques_webgl = extension;
      addExtensionsUsed_default(gltf, "KHR_techniques_webgl");
      addExtensionsRequired_default(gltf, "KHR_techniques_webgl");
    }
  }
  ForEach_default.material(gltf, function(material) {
    if (defined_default(material.technique)) {
      const materialExtension = {
        technique: updatedTechniqueIndices[material.technique]
      };
      ForEach_default.objectLegacy(material.values, function(value, parameterName) {
        if (!defined_default(materialExtension.values)) {
          materialExtension.values = {};
        }
        const uniformName = mappedUniforms[material.technique][parameterName];
        materialExtension.values[uniformName] = value;
      });
      if (!defined_default(material.extensions)) {
        material.extensions = {};
      }
      material.extensions.KHR_techniques_webgl = materialExtension;
    }
    delete material.technique;
    delete material.values;
  });
  delete gltf.techniques;
  delete gltf.programs;
  delete gltf.shaders;
  return gltf;
}
var moveTechniquesToExtension_default = moveTechniquesToExtension;

// node_modules/cesium/Source/Scene/GltfPipeline/forEachTextureInMaterial.js
function forEachTextureInMaterial(material, handler) {
  Check_default.typeOf.object("material", material);
  Check_default.defined("handler", handler);
  const pbrMetallicRoughness = material.pbrMetallicRoughness;
  if (defined_default(pbrMetallicRoughness)) {
    if (defined_default(pbrMetallicRoughness.baseColorTexture)) {
      const textureInfo = pbrMetallicRoughness.baseColorTexture;
      const value2 = handler(textureInfo.index, textureInfo);
      if (defined_default(value2)) {
        return value2;
      }
    }
    if (defined_default(pbrMetallicRoughness.metallicRoughnessTexture)) {
      const textureInfo = pbrMetallicRoughness.metallicRoughnessTexture;
      const value2 = handler(textureInfo.index, textureInfo);
      if (defined_default(value2)) {
        return value2;
      }
    }
  }
  if (defined_default(material.extensions)) {
    const pbrSpecularGlossiness = material.extensions.KHR_materials_pbrSpecularGlossiness;
    if (defined_default(pbrSpecularGlossiness)) {
      if (defined_default(pbrSpecularGlossiness.diffuseTexture)) {
        const textureInfo = pbrSpecularGlossiness.diffuseTexture;
        const value2 = handler(textureInfo.index, textureInfo);
        if (defined_default(value2)) {
          return value2;
        }
      }
      if (defined_default(pbrSpecularGlossiness.specularGlossinessTexture)) {
        const textureInfo = pbrSpecularGlossiness.specularGlossinessTexture;
        const value2 = handler(textureInfo.index, textureInfo);
        if (defined_default(value2)) {
          return value2;
        }
      }
    }
    const materialsCommon = material.extensions.KHR_materials_common;
    if (defined_default(materialsCommon)) {
      const diffuse = materialsCommon.values.diffuse;
      const ambient = materialsCommon.values.ambient;
      const emission = materialsCommon.values.emission;
      const specular = materialsCommon.values.specular;
      if (defined_default(diffuse) && defined_default(diffuse.index)) {
        const value2 = handler(diffuse.index, diffuse);
        if (defined_default(value2)) {
          return value2;
        }
      }
      if (defined_default(ambient) && defined_default(ambient.index)) {
        const value2 = handler(ambient.index, ambient);
        if (defined_default(value2)) {
          return value2;
        }
      }
      if (defined_default(emission) && defined_default(emission.index)) {
        const value2 = handler(emission.index, emission);
        if (defined_default(value2)) {
          return value2;
        }
      }
      if (defined_default(specular) && defined_default(specular.index)) {
        const value2 = handler(specular.index, specular);
        if (defined_default(value2)) {
          return value2;
        }
      }
    }
  }
  const value = ForEach_default.materialValue(material, function(materialValue) {
    if (defined_default(materialValue.index)) {
      const value2 = handler(materialValue.index, materialValue);
      if (defined_default(value2)) {
        return value2;
      }
    }
  });
  if (defined_default(value)) {
    return value;
  }
  if (defined_default(material.emissiveTexture)) {
    const textureInfo = material.emissiveTexture;
    const value2 = handler(textureInfo.index, textureInfo);
    if (defined_default(value2)) {
      return value2;
    }
  }
  if (defined_default(material.normalTexture)) {
    const textureInfo = material.normalTexture;
    const value2 = handler(textureInfo.index, textureInfo);
    if (defined_default(value2)) {
      return value2;
    }
  }
  if (defined_default(material.occlusionTexture)) {
    const textureInfo = material.occlusionTexture;
    const value2 = handler(textureInfo.index, textureInfo);
    if (defined_default(value2)) {
      return value2;
    }
  }
}
var forEachTextureInMaterial_default = forEachTextureInMaterial;

// node_modules/cesium/Source/Scene/GltfPipeline/removeUnusedElements.js
var allElementTypes = [
  "mesh",
  "node",
  "material",
  "accessor",
  "bufferView",
  "buffer",
  "texture",
  "sampler",
  "image"
];
function removeUnusedElements(gltf, elementTypes) {
  elementTypes = defaultValue_default(elementTypes, allElementTypes);
  allElementTypes.forEach(function(type) {
    if (elementTypes.indexOf(type) > -1) {
      removeUnusedElementsByType(gltf, type);
    }
  });
  return gltf;
}
var TypeToGltfElementName = {
  accessor: "accessors",
  buffer: "buffers",
  bufferView: "bufferViews",
  image: "images",
  node: "nodes",
  material: "materials",
  mesh: "meshes",
  sampler: "samplers",
  texture: "textures"
};
function removeUnusedElementsByType(gltf, type) {
  const name = TypeToGltfElementName[type];
  const arrayOfObjects = gltf[name];
  if (defined_default(arrayOfObjects)) {
    let removed = 0;
    const usedIds = getListOfElementsIdsInUse[type](gltf);
    const length3 = arrayOfObjects.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      if (!usedIds[i2]) {
        Remove[type](gltf, i2 - removed);
        removed++;
      }
    }
  }
}
function Remove() {
}
Remove.accessor = function(gltf, accessorId) {
  const accessors = gltf.accessors;
  accessors.splice(accessorId, 1);
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      ForEach_default.meshPrimitiveAttribute(
        primitive,
        function(attributeAccessorId, semantic) {
          if (attributeAccessorId > accessorId) {
            primitive.attributes[semantic]--;
          }
        }
      );
      ForEach_default.meshPrimitiveTarget(primitive, function(target) {
        ForEach_default.meshPrimitiveTargetAttribute(
          target,
          function(attributeAccessorId, semantic) {
            if (attributeAccessorId > accessorId) {
              target[semantic]--;
            }
          }
        );
      });
      const indices2 = primitive.indices;
      if (defined_default(indices2) && indices2 > accessorId) {
        primitive.indices--;
      }
    });
  });
  ForEach_default.skin(gltf, function(skin) {
    if (defined_default(skin.inverseBindMatrices) && skin.inverseBindMatrices > accessorId) {
      skin.inverseBindMatrices--;
    }
  });
  ForEach_default.animation(gltf, function(animation) {
    ForEach_default.animationSampler(animation, function(sampler) {
      if (defined_default(sampler.input) && sampler.input > accessorId) {
        sampler.input--;
      }
      if (defined_default(sampler.output) && sampler.output > accessorId) {
        sampler.output--;
      }
    });
  });
};
Remove.buffer = function(gltf, bufferId) {
  const buffers = gltf.buffers;
  buffers.splice(bufferId, 1);
  ForEach_default.bufferView(gltf, function(bufferView) {
    if (defined_default(bufferView.buffer) && bufferView.buffer > bufferId) {
      bufferView.buffer--;
    }
    if (defined_default(bufferView.extensions) && defined_default(bufferView.extensions.EXT_meshopt_compression)) {
      bufferView.extensions.EXT_meshopt_compression.buffer--;
    }
  });
};
Remove.bufferView = function(gltf, bufferViewId) {
  const bufferViews = gltf.bufferViews;
  bufferViews.splice(bufferViewId, 1);
  ForEach_default.accessor(gltf, function(accessor) {
    if (defined_default(accessor.bufferView) && accessor.bufferView > bufferViewId) {
      accessor.bufferView--;
    }
  });
  ForEach_default.shader(gltf, function(shader) {
    if (defined_default(shader.bufferView) && shader.bufferView > bufferViewId) {
      shader.bufferView--;
    }
  });
  ForEach_default.image(gltf, function(image) {
    if (defined_default(image.bufferView) && image.bufferView > bufferViewId) {
      image.bufferView--;
    }
  });
  if (usesExtension_default(gltf, "KHR_draco_mesh_compression")) {
    ForEach_default.mesh(gltf, function(mesh2) {
      ForEach_default.meshPrimitive(mesh2, function(primitive) {
        if (defined_default(primitive.extensions) && defined_default(primitive.extensions.KHR_draco_mesh_compression)) {
          if (primitive.extensions.KHR_draco_mesh_compression.bufferView > bufferViewId) {
            primitive.extensions.KHR_draco_mesh_compression.bufferView--;
          }
        }
      });
    });
  }
  if (usesExtension_default(gltf, "EXT_feature_metadata")) {
    const extension = gltf.extensions.EXT_feature_metadata;
    const featureTables = extension.featureTables;
    for (const featureTableId in featureTables) {
      if (featureTables.hasOwnProperty(featureTableId)) {
        const featureTable = featureTables[featureTableId];
        const properties = featureTable.properties;
        if (defined_default(properties)) {
          for (const propertyId in properties) {
            if (properties.hasOwnProperty(propertyId)) {
              const property = properties[propertyId];
              if (defined_default(property.bufferView) && property.bufferView > bufferViewId) {
                property.bufferView--;
              }
              if (defined_default(property.arrayOffsetBufferView) && property.arrayOffsetBufferView > bufferViewId) {
                property.arrayOffsetBufferView--;
              }
              if (defined_default(property.stringOffsetBufferView) && property.stringOffsetBufferView > bufferViewId) {
                property.stringOffsetBufferView--;
              }
            }
          }
        }
      }
    }
  }
};
Remove.image = function(gltf, imageId) {
  const images = gltf.images;
  images.splice(imageId, 1);
  ForEach_default.texture(gltf, function(texture) {
    if (defined_default(texture.source)) {
      if (texture.source > imageId) {
        --texture.source;
      }
    }
    const ext = texture.extensions;
    if (defined_default(ext) && defined_default(ext.EXT_texture_webp) && ext.EXT_texture_webp.source > imageId) {
      --texture.extensions.EXT_texture_webp.source;
    } else if (defined_default(ext) && defined_default(ext.KHR_texture_basisu) && ext.KHR_texture_basisu.source > imageId) {
      --texture.extensions.KHR_texture_basisu.source;
    }
  });
};
Remove.mesh = function(gltf, meshId) {
  const meshes = gltf.meshes;
  meshes.splice(meshId, 1);
  ForEach_default.node(gltf, function(node) {
    if (defined_default(node.mesh)) {
      if (node.mesh > meshId) {
        node.mesh--;
      } else if (node.mesh === meshId) {
        delete node.mesh;
      }
    }
  });
};
Remove.node = function(gltf, nodeId) {
  const nodes = gltf.nodes;
  nodes.splice(nodeId, 1);
  ForEach_default.skin(gltf, function(skin) {
    if (defined_default(skin.skeleton) && skin.skeleton > nodeId) {
      skin.skeleton--;
    }
    skin.joints = skin.joints.map(function(x) {
      return x > nodeId ? x - 1 : x;
    });
  });
  ForEach_default.animation(gltf, function(animation) {
    ForEach_default.animationChannel(animation, function(channel) {
      if (defined_default(channel.target) && defined_default(channel.target.node) && channel.target.node > nodeId) {
        channel.target.node--;
      }
    });
  });
  ForEach_default.technique(gltf, function(technique) {
    ForEach_default.techniqueUniform(technique, function(uniform) {
      if (defined_default(uniform.node) && uniform.node > nodeId) {
        uniform.node--;
      }
    });
  });
  ForEach_default.node(gltf, function(node) {
    if (!defined_default(node.children)) {
      return;
    }
    node.children = node.children.filter(function(x) {
      return x !== nodeId;
    }).map(function(x) {
      return x > nodeId ? x - 1 : x;
    });
  });
  ForEach_default.scene(gltf, function(scene) {
    scene.nodes = scene.nodes.filter(function(x) {
      return x !== nodeId;
    }).map(function(x) {
      return x > nodeId ? x - 1 : x;
    });
  });
};
Remove.material = function(gltf, materialId) {
  const materials = gltf.materials;
  materials.splice(materialId, 1);
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      if (defined_default(primitive.material) && primitive.material > materialId) {
        primitive.material--;
      }
    });
  });
};
Remove.sampler = function(gltf, samplerId) {
  const samplers = gltf.samplers;
  samplers.splice(samplerId, 1);
  ForEach_default.texture(gltf, function(texture) {
    if (defined_default(texture.sampler)) {
      if (texture.sampler > samplerId) {
        --texture.sampler;
      }
    }
  });
};
Remove.texture = function(gltf, textureId) {
  const textures = gltf.textures;
  textures.splice(textureId, 1);
  ForEach_default.material(gltf, function(material) {
    forEachTextureInMaterial_default(material, function(textureIndex, textureInfo) {
      if (textureInfo.index > textureId) {
        --textureInfo.index;
      }
    });
  });
  if (usesExtension_default(gltf, "EXT_feature_metadata")) {
    ForEach_default.mesh(gltf, function(mesh2) {
      ForEach_default.meshPrimitive(mesh2, function(primitive) {
        const extensions = primitive.extensions;
        if (defined_default(extensions) && defined_default(extensions.EXT_feature_metadata)) {
          const extension2 = extensions.EXT_feature_metadata;
          const featureIdTextures = extension2.featureIdTextures;
          if (defined_default(featureIdTextures)) {
            const featureIdTexturesLength = featureIdTextures.length;
            for (let i2 = 0; i2 < featureIdTexturesLength; ++i2) {
              const featureIdTexture = featureIdTextures[i2];
              const textureInfo = featureIdTexture.featureIds.texture;
              if (textureInfo.index > textureId) {
                --textureInfo.index;
              }
            }
          }
        }
      });
    });
    const extension = gltf.extensions.EXT_feature_metadata;
    const featureTextures = extension.featureTextures;
    for (const featureTextureId in featureTextures) {
      if (featureTextures.hasOwnProperty(featureTextureId)) {
        const featureTexture = featureTextures[featureTextureId];
        const properties = featureTexture.properties;
        if (defined_default(properties)) {
          for (const propertyId in properties) {
            if (properties.hasOwnProperty(propertyId)) {
              const property = properties[propertyId];
              const textureInfo = property.texture;
              if (textureInfo.index > textureId) {
                --textureInfo.index;
              }
            }
          }
        }
      }
    }
  }
};
function getListOfElementsIdsInUse() {
}
getListOfElementsIdsInUse.accessor = function(gltf) {
  const usedAccessorIds = {};
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      ForEach_default.meshPrimitiveAttribute(primitive, function(accessorId) {
        usedAccessorIds[accessorId] = true;
      });
      ForEach_default.meshPrimitiveTarget(primitive, function(target) {
        ForEach_default.meshPrimitiveTargetAttribute(target, function(accessorId) {
          usedAccessorIds[accessorId] = true;
        });
      });
      const indices2 = primitive.indices;
      if (defined_default(indices2)) {
        usedAccessorIds[indices2] = true;
      }
    });
  });
  ForEach_default.skin(gltf, function(skin) {
    if (defined_default(skin.inverseBindMatrices)) {
      usedAccessorIds[skin.inverseBindMatrices] = true;
    }
  });
  ForEach_default.animation(gltf, function(animation) {
    ForEach_default.animationSampler(animation, function(sampler) {
      if (defined_default(sampler.input)) {
        usedAccessorIds[sampler.input] = true;
      }
      if (defined_default(sampler.output)) {
        usedAccessorIds[sampler.output] = true;
      }
    });
  });
  if (usesExtension_default(gltf, "EXT_mesh_gpu_instancing")) {
    ForEach_default.node(gltf, function(node) {
      if (defined_default(node.extensions) && defined_default(node.extensions.EXT_mesh_gpu_instancing)) {
        Object.keys(node.extensions.EXT_mesh_gpu_instancing.attributes).forEach(
          function(key) {
            const attributeAccessorId = node.extensions.EXT_mesh_gpu_instancing.attributes[key];
            usedAccessorIds[attributeAccessorId] = true;
          }
        );
      }
    });
  }
  return usedAccessorIds;
};
getListOfElementsIdsInUse.buffer = function(gltf) {
  const usedBufferIds = {};
  ForEach_default.bufferView(gltf, function(bufferView) {
    if (defined_default(bufferView.buffer)) {
      usedBufferIds[bufferView.buffer] = true;
    }
    if (defined_default(bufferView.extensions) && defined_default(bufferView.extensions.EXT_meshopt_compression)) {
      usedBufferIds[bufferView.extensions.EXT_meshopt_compression.buffer] = true;
    }
  });
  return usedBufferIds;
};
getListOfElementsIdsInUse.bufferView = function(gltf) {
  const usedBufferViewIds = {};
  ForEach_default.accessor(gltf, function(accessor) {
    if (defined_default(accessor.bufferView)) {
      usedBufferViewIds[accessor.bufferView] = true;
    }
  });
  ForEach_default.shader(gltf, function(shader) {
    if (defined_default(shader.bufferView)) {
      usedBufferViewIds[shader.bufferView] = true;
    }
  });
  ForEach_default.image(gltf, function(image) {
    if (defined_default(image.bufferView)) {
      usedBufferViewIds[image.bufferView] = true;
    }
  });
  if (usesExtension_default(gltf, "KHR_draco_mesh_compression")) {
    ForEach_default.mesh(gltf, function(mesh2) {
      ForEach_default.meshPrimitive(mesh2, function(primitive) {
        if (defined_default(primitive.extensions) && defined_default(primitive.extensions.KHR_draco_mesh_compression)) {
          usedBufferViewIds[primitive.extensions.KHR_draco_mesh_compression.bufferView] = true;
        }
      });
    });
  }
  if (usesExtension_default(gltf, "EXT_feature_metadata")) {
    const extension = gltf.extensions.EXT_feature_metadata;
    const featureTables = extension.featureTables;
    for (const featureTableId in featureTables) {
      if (featureTables.hasOwnProperty(featureTableId)) {
        const featureTable = featureTables[featureTableId];
        const properties = featureTable.properties;
        if (defined_default(properties)) {
          for (const propertyId in properties) {
            if (properties.hasOwnProperty(propertyId)) {
              const property = properties[propertyId];
              if (defined_default(property.bufferView)) {
                usedBufferViewIds[property.bufferView] = true;
              }
              if (defined_default(property.arrayOffsetBufferView)) {
                usedBufferViewIds[property.arrayOffsetBufferView] = true;
              }
              if (defined_default(property.stringOffsetBufferView)) {
                usedBufferViewIds[property.stringOffsetBufferView] = true;
              }
            }
          }
        }
      }
    }
  }
  return usedBufferViewIds;
};
getListOfElementsIdsInUse.image = function(gltf) {
  const usedImageIds = {};
  ForEach_default.texture(gltf, function(texture) {
    if (defined_default(texture.source)) {
      usedImageIds[texture.source] = true;
    }
    if (defined_default(texture.extensions) && defined_default(texture.extensions.EXT_texture_webp)) {
      usedImageIds[texture.extensions.EXT_texture_webp.source] = true;
    } else if (defined_default(texture.extensions) && defined_default(texture.extensions.KHR_texture_basisu)) {
      usedImageIds[texture.extensions.KHR_texture_basisu.source] = true;
    }
  });
  return usedImageIds;
};
getListOfElementsIdsInUse.mesh = function(gltf) {
  const usedMeshIds = {};
  ForEach_default.node(gltf, function(node) {
    if (defined_default(node.mesh && defined_default(gltf.meshes))) {
      const mesh2 = gltf.meshes[node.mesh];
      if (defined_default(mesh2) && defined_default(mesh2.primitives) && mesh2.primitives.length > 0) {
        usedMeshIds[node.mesh] = true;
      }
    }
  });
  return usedMeshIds;
};
function nodeIsEmpty(gltf, nodeId, usedNodeIds) {
  const node = gltf.nodes[nodeId];
  if (defined_default(node.mesh) || defined_default(node.camera) || defined_default(node.skin) || defined_default(node.weights) || defined_default(node.extras) || defined_default(node.extensions) && Object.keys(node.extensions).length !== 0 || defined_default(usedNodeIds[nodeId])) {
    return false;
  }
  return !defined_default(node.children) || node.children.filter(function(n2) {
    return !nodeIsEmpty(gltf, n2, usedNodeIds);
  }).length === 0;
}
getListOfElementsIdsInUse.node = function(gltf) {
  const usedNodeIds = {};
  ForEach_default.skin(gltf, function(skin) {
    if (defined_default(skin.skeleton)) {
      usedNodeIds[skin.skeleton] = true;
    }
    ForEach_default.skinJoint(skin, function(joint) {
      usedNodeIds[joint] = true;
    });
  });
  ForEach_default.animation(gltf, function(animation) {
    ForEach_default.animationChannel(animation, function(channel) {
      if (defined_default(channel.target) && defined_default(channel.target.node)) {
        usedNodeIds[channel.target.node] = true;
      }
    });
  });
  ForEach_default.technique(gltf, function(technique) {
    ForEach_default.techniqueUniform(technique, function(uniform) {
      if (defined_default(uniform.node)) {
        usedNodeIds[uniform.node] = true;
      }
    });
  });
  ForEach_default.node(gltf, function(node, nodeId) {
    if (!nodeIsEmpty(gltf, nodeId, usedNodeIds)) {
      usedNodeIds[nodeId] = true;
    }
  });
  return usedNodeIds;
};
getListOfElementsIdsInUse.material = function(gltf) {
  const usedMaterialIds = {};
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      if (defined_default(primitive.material)) {
        usedMaterialIds[primitive.material] = true;
      }
    });
  });
  return usedMaterialIds;
};
getListOfElementsIdsInUse.texture = function(gltf) {
  const usedTextureIds = {};
  ForEach_default.material(gltf, function(material) {
    forEachTextureInMaterial_default(material, function(textureId) {
      usedTextureIds[textureId] = true;
    });
  });
  if (usesExtension_default(gltf, "EXT_feature_metadata")) {
    ForEach_default.mesh(gltf, function(mesh2) {
      ForEach_default.meshPrimitive(mesh2, function(primitive) {
        const extensions = primitive.extensions;
        if (defined_default(extensions) && defined_default(extensions.EXT_feature_metadata)) {
          const extension2 = extensions.EXT_feature_metadata;
          const featureIdTextures = extension2.featureIdTextures;
          if (defined_default(featureIdTextures)) {
            const featureIdTexturesLength = featureIdTextures.length;
            for (let i2 = 0; i2 < featureIdTexturesLength; ++i2) {
              const featureIdTexture = featureIdTextures[i2];
              const textureInfo = featureIdTexture.featureIds.texture;
              usedTextureIds[textureInfo.index] = true;
            }
          }
        }
      });
    });
    const extension = gltf.extensions.EXT_feature_metadata;
    const featureTextures = extension.featureTextures;
    for (const featureTextureId in featureTextures) {
      if (featureTextures.hasOwnProperty(featureTextureId)) {
        const featureTexture = featureTextures[featureTextureId];
        const properties = featureTexture.properties;
        if (defined_default(properties)) {
          for (const propertyId in properties) {
            if (properties.hasOwnProperty(propertyId)) {
              const property = properties[propertyId];
              const textureInfo = property.texture;
              usedTextureIds[textureInfo.index] = true;
            }
          }
        }
      }
    }
  }
  return usedTextureIds;
};
getListOfElementsIdsInUse.sampler = function(gltf) {
  const usedSamplerIds = {};
  ForEach_default.texture(gltf, function(texture) {
    if (defined_default(texture.sampler)) {
      usedSamplerIds[texture.sampler] = true;
    }
  });
  return usedSamplerIds;
};
var removeUnusedElements_default = removeUnusedElements;

// node_modules/cesium/Source/Scene/GltfPipeline/addBuffer.js
function addBuffer(gltf, buffer) {
  const newBuffer = {
    byteLength: buffer.length,
    extras: {
      _pipeline: {
        source: buffer
      }
    }
  };
  const bufferId = addToArray_default(gltf.buffers, newBuffer);
  const bufferView = {
    buffer: bufferId,
    byteOffset: 0,
    byteLength: buffer.length
  };
  return addToArray_default(gltf.bufferViews, bufferView);
}
var addBuffer_default = addBuffer;

// node_modules/cesium/Source/Scene/GltfPipeline/readAccessorPacked.js
function readAccessorPacked(gltf, accessor) {
  const byteStride = getAccessorByteStride_default(gltf, accessor);
  const componentTypeByteLength = ComponentDatatype_default.getSizeInBytes(
    accessor.componentType
  );
  const numberOfComponents = numberOfComponentsForType_default(accessor.type);
  const count = accessor.count;
  const values = new Array(numberOfComponents * count);
  if (!defined_default(accessor.bufferView)) {
    arrayFill_default(values, 0);
    return values;
  }
  const bufferView = gltf.bufferViews[accessor.bufferView];
  const source = gltf.buffers[bufferView.buffer].extras._pipeline.source;
  let byteOffset = accessor.byteOffset + bufferView.byteOffset + source.byteOffset;
  const dataView = new DataView(source.buffer);
  const components = new Array(numberOfComponents);
  const componentReader = getComponentReader_default(accessor.componentType);
  for (let i2 = 0; i2 < count; ++i2) {
    componentReader(
      dataView,
      byteOffset,
      numberOfComponents,
      componentTypeByteLength,
      components
    );
    for (let j = 0; j < numberOfComponents; ++j) {
      values[i2 * numberOfComponents + j] = components[j];
    }
    byteOffset += byteStride;
  }
  return values;
}
var readAccessorPacked_default = readAccessorPacked;

// node_modules/cesium/Source/Scene/GltfPipeline/updateAccessorComponentTypes.js
function updateAccessorComponentTypes(gltf) {
  let componentType;
  ForEach_default.accessorWithSemantic(gltf, "JOINTS_0", function(accessorId) {
    const accessor = gltf.accessors[accessorId];
    componentType = accessor.componentType;
    if (componentType === WebGLConstants_default.BYTE) {
      convertType(gltf, accessor, ComponentDatatype_default.UNSIGNED_BYTE);
    } else if (componentType !== WebGLConstants_default.UNSIGNED_BYTE && componentType !== WebGLConstants_default.UNSIGNED_SHORT) {
      convertType(gltf, accessor, ComponentDatatype_default.UNSIGNED_SHORT);
    }
  });
  ForEach_default.accessorWithSemantic(gltf, "WEIGHTS_0", function(accessorId) {
    const accessor = gltf.accessors[accessorId];
    componentType = accessor.componentType;
    if (componentType === WebGLConstants_default.BYTE) {
      convertType(gltf, accessor, ComponentDatatype_default.UNSIGNED_BYTE);
    } else if (componentType === WebGLConstants_default.SHORT) {
      convertType(gltf, accessor, ComponentDatatype_default.UNSIGNED_SHORT);
    }
  });
  return gltf;
}
function convertType(gltf, accessor, updatedComponentType) {
  const typedArray = ComponentDatatype_default.createTypedArray(
    updatedComponentType,
    readAccessorPacked_default(gltf, accessor)
  );
  const newBuffer = new Uint8Array(typedArray.buffer);
  accessor.bufferView = addBuffer_default(gltf, newBuffer);
  accessor.componentType = updatedComponentType;
  accessor.byteOffset = 0;
}
var updateAccessorComponentTypes_default = updateAccessorComponentTypes;

// node_modules/cesium/Source/Scene/GltfPipeline/updateVersion.js
var updateFunctions = {
  0.8: glTF08to10,
  "1.0": glTF10to20,
  "2.0": void 0
};
function updateVersion(gltf, options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const targetVersion = options.targetVersion;
  let version = gltf.version;
  gltf.asset = defaultValue_default(gltf.asset, {
    version: "1.0"
  });
  gltf.asset.version = defaultValue_default(gltf.asset.version, "1.0");
  version = defaultValue_default(version, gltf.asset.version).toString();
  if (!Object.prototype.hasOwnProperty.call(updateFunctions, version)) {
    if (defined_default(version)) {
      version = version.substring(0, 3);
    }
    if (!Object.prototype.hasOwnProperty.call(updateFunctions, version)) {
      version = "1.0";
    }
  }
  let updateFunction = updateFunctions[version];
  while (defined_default(updateFunction)) {
    if (version === targetVersion) {
      break;
    }
    updateFunction(gltf, options);
    version = gltf.asset.version;
    updateFunction = updateFunctions[version];
  }
  return gltf;
}
function updateInstanceTechniques(gltf) {
  const materials = gltf.materials;
  for (const materialId in materials) {
    if (Object.prototype.hasOwnProperty.call(materials, materialId)) {
      const material = materials[materialId];
      const instanceTechnique = material.instanceTechnique;
      if (defined_default(instanceTechnique)) {
        material.technique = instanceTechnique.technique;
        material.values = instanceTechnique.values;
        delete material.instanceTechnique;
      }
    }
  }
}
function setPrimitiveModes(gltf) {
  const meshes = gltf.meshes;
  for (const meshId in meshes) {
    if (Object.prototype.hasOwnProperty.call(meshes, meshId)) {
      const mesh2 = meshes[meshId];
      const primitives = mesh2.primitives;
      if (defined_default(primitives)) {
        const primitivesLength = primitives.length;
        for (let i2 = 0; i2 < primitivesLength; ++i2) {
          const primitive = primitives[i2];
          const defaultMode = defaultValue_default(
            primitive.primitive,
            WebGLConstants_default.TRIANGLES
          );
          primitive.mode = defaultValue_default(primitive.mode, defaultMode);
          delete primitive.primitive;
        }
      }
    }
  }
}
function updateNodes(gltf) {
  const nodes = gltf.nodes;
  const axis = new Cartesian3_default();
  const quat = new Quaternion_default();
  for (const nodeId in nodes) {
    if (Object.prototype.hasOwnProperty.call(nodes, nodeId)) {
      const node = nodes[nodeId];
      if (defined_default(node.rotation)) {
        const rotation = node.rotation;
        Cartesian3_default.fromArray(rotation, 0, axis);
        Quaternion_default.fromAxisAngle(axis, rotation[3], quat);
        node.rotation = [quat.x, quat.y, quat.z, quat.w];
      }
      const instanceSkin = node.instanceSkin;
      if (defined_default(instanceSkin)) {
        node.skeletons = instanceSkin.skeletons;
        node.skin = instanceSkin.skin;
        node.meshes = instanceSkin.meshes;
        delete node.instanceSkin;
      }
    }
  }
}
function updateAnimations(gltf) {
  const animations = gltf.animations;
  const accessors = gltf.accessors;
  const bufferViews = gltf.bufferViews;
  const buffers = gltf.buffers;
  const updatedAccessors = {};
  const axis = new Cartesian3_default();
  const quat = new Quaternion_default();
  for (const animationId in animations) {
    if (Object.prototype.hasOwnProperty.call(animations, animationId)) {
      const animation = animations[animationId];
      const channels = animation.channels;
      const parameters = animation.parameters;
      const samplers = animation.samplers;
      if (defined_default(channels)) {
        const channelsLength = channels.length;
        for (let i2 = 0; i2 < channelsLength; ++i2) {
          const channel = channels[i2];
          if (channel.target.path === "rotation") {
            const accessorId = parameters[samplers[channel.sampler].output];
            if (defined_default(updatedAccessors[accessorId])) {
              continue;
            }
            updatedAccessors[accessorId] = true;
            const accessor = accessors[accessorId];
            const bufferView = bufferViews[accessor.bufferView];
            const buffer = buffers[bufferView.buffer];
            const source = buffer.extras._pipeline.source;
            const byteOffset = source.byteOffset + bufferView.byteOffset + accessor.byteOffset;
            const componentType = accessor.componentType;
            const count = accessor.count;
            const componentsLength = numberOfComponentsForType_default(accessor.type);
            const length3 = accessor.count * componentsLength;
            const typedArray = ComponentDatatype_default.createArrayBufferView(
              componentType,
              source.buffer,
              byteOffset,
              length3
            );
            for (let j = 0; j < count; j++) {
              const offset2 = j * componentsLength;
              Cartesian3_default.unpack(typedArray, offset2, axis);
              const angle = typedArray[offset2 + 3];
              Quaternion_default.fromAxisAngle(axis, angle, quat);
              Quaternion_default.pack(quat, typedArray, offset2);
            }
          }
        }
      }
    }
  }
}
function removeTechniquePasses(gltf) {
  const techniques = gltf.techniques;
  for (const techniqueId in techniques) {
    if (Object.prototype.hasOwnProperty.call(techniques, techniqueId)) {
      const technique = techniques[techniqueId];
      const passes = technique.passes;
      if (defined_default(passes)) {
        const passName = defaultValue_default(technique.pass, "defaultPass");
        if (Object.prototype.hasOwnProperty.call(passes, passName)) {
          const pass = passes[passName];
          const instanceProgram = pass.instanceProgram;
          technique.attributes = defaultValue_default(
            technique.attributes,
            instanceProgram.attributes
          );
          technique.program = defaultValue_default(
            technique.program,
            instanceProgram.program
          );
          technique.uniforms = defaultValue_default(
            technique.uniforms,
            instanceProgram.uniforms
          );
          technique.states = defaultValue_default(technique.states, pass.states);
        }
        delete technique.passes;
        delete technique.pass;
      }
    }
  }
}
function glTF08to10(gltf) {
  if (!defined_default(gltf.asset)) {
    gltf.asset = {};
  }
  const asset = gltf.asset;
  asset.version = "1.0";
  if (typeof asset.profile === "string") {
    const split = asset.profile.split(" ");
    asset.profile = {
      api: split[0],
      version: split[1]
    };
  } else {
    asset.profile = {};
  }
  if (defined_default(gltf.version)) {
    delete gltf.version;
  }
  updateInstanceTechniques(gltf);
  setPrimitiveModes(gltf);
  updateNodes(gltf);
  updateAnimations(gltf);
  removeTechniquePasses(gltf);
  if (defined_default(gltf.allExtensions)) {
    gltf.extensionsUsed = gltf.allExtensions;
    delete gltf.allExtensions;
  }
  if (defined_default(gltf.lights)) {
    const extensions = defaultValue_default(gltf.extensions, {});
    gltf.extensions = extensions;
    const materialsCommon = defaultValue_default(extensions.KHR_materials_common, {});
    extensions.KHR_materials_common = materialsCommon;
    materialsCommon.lights = gltf.lights;
    delete gltf.lights;
    addExtensionsUsed_default(gltf, "KHR_materials_common");
  }
}
function removeAnimationSamplersIndirection(gltf) {
  const animations = gltf.animations;
  for (const animationId in animations) {
    if (Object.prototype.hasOwnProperty.call(animations, animationId)) {
      const animation = animations[animationId];
      const parameters = animation.parameters;
      if (defined_default(parameters)) {
        const samplers = animation.samplers;
        for (const samplerId in samplers) {
          if (Object.prototype.hasOwnProperty.call(samplers, samplerId)) {
            const sampler = samplers[samplerId];
            sampler.input = parameters[sampler.input];
            sampler.output = parameters[sampler.output];
          }
        }
        delete animation.parameters;
      }
    }
  }
}
function objectToArray(object2, mapping) {
  const array = [];
  for (const id in object2) {
    if (Object.prototype.hasOwnProperty.call(object2, id)) {
      const value = object2[id];
      mapping[id] = array.length;
      array.push(value);
      if (!defined_default(value.name)) {
        value.name = id;
      }
    }
  }
  return array;
}
function objectsToArrays(gltf) {
  let i2;
  const globalMapping = {
    accessors: {},
    animations: {},
    buffers: {},
    bufferViews: {},
    cameras: {},
    images: {},
    materials: {},
    meshes: {},
    nodes: {},
    programs: {},
    samplers: {},
    scenes: {},
    shaders: {},
    skins: {},
    textures: {},
    techniques: {}
  };
  let jointName;
  const jointNameToId = {};
  const nodes = gltf.nodes;
  for (const id in nodes) {
    if (Object.prototype.hasOwnProperty.call(nodes, id)) {
      jointName = nodes[id].jointName;
      if (defined_default(jointName)) {
        jointNameToId[jointName] = id;
      }
    }
  }
  for (const topLevelId in gltf) {
    if (Object.prototype.hasOwnProperty.call(gltf, topLevelId) && defined_default(globalMapping[topLevelId])) {
      const objectMapping = {};
      const object2 = gltf[topLevelId];
      gltf[topLevelId] = objectToArray(object2, objectMapping);
      globalMapping[topLevelId] = objectMapping;
    }
  }
  for (jointName in jointNameToId) {
    if (Object.prototype.hasOwnProperty.call(jointNameToId, jointName)) {
      jointNameToId[jointName] = globalMapping.nodes[jointNameToId[jointName]];
    }
  }
  if (defined_default(gltf.scene)) {
    gltf.scene = globalMapping.scenes[gltf.scene];
  }
  ForEach_default.bufferView(gltf, function(bufferView) {
    if (defined_default(bufferView.buffer)) {
      bufferView.buffer = globalMapping.buffers[bufferView.buffer];
    }
  });
  ForEach_default.accessor(gltf, function(accessor) {
    if (defined_default(accessor.bufferView)) {
      accessor.bufferView = globalMapping.bufferViews[accessor.bufferView];
    }
  });
  ForEach_default.shader(gltf, function(shader) {
    const extensions = shader.extensions;
    if (defined_default(extensions)) {
      const binaryGltf = extensions.KHR_binary_glTF;
      if (defined_default(binaryGltf)) {
        shader.bufferView = globalMapping.bufferViews[binaryGltf.bufferView];
        delete extensions.KHR_binary_glTF;
      }
      if (Object.keys(extensions).length === 0) {
        delete shader.extensions;
      }
    }
  });
  ForEach_default.program(gltf, function(program) {
    if (defined_default(program.vertexShader)) {
      program.vertexShader = globalMapping.shaders[program.vertexShader];
    }
    if (defined_default(program.fragmentShader)) {
      program.fragmentShader = globalMapping.shaders[program.fragmentShader];
    }
  });
  ForEach_default.technique(gltf, function(technique) {
    if (defined_default(technique.program)) {
      technique.program = globalMapping.programs[technique.program];
    }
    ForEach_default.techniqueParameter(technique, function(parameter) {
      if (defined_default(parameter.node)) {
        parameter.node = globalMapping.nodes[parameter.node];
      }
      const value = parameter.value;
      if (typeof value === "string") {
        parameter.value = {
          index: globalMapping.textures[value]
        };
      }
    });
  });
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      if (defined_default(primitive.indices)) {
        primitive.indices = globalMapping.accessors[primitive.indices];
      }
      ForEach_default.meshPrimitiveAttribute(
        primitive,
        function(accessorId, semantic) {
          primitive.attributes[semantic] = globalMapping.accessors[accessorId];
        }
      );
      if (defined_default(primitive.material)) {
        primitive.material = globalMapping.materials[primitive.material];
      }
    });
  });
  ForEach_default.node(gltf, function(node) {
    let children = node.children;
    if (defined_default(children)) {
      const childrenLength = children.length;
      for (i2 = 0; i2 < childrenLength; ++i2) {
        children[i2] = globalMapping.nodes[children[i2]];
      }
    }
    if (defined_default(node.meshes)) {
      const meshes = node.meshes;
      const meshesLength = meshes.length;
      if (meshesLength > 0) {
        node.mesh = globalMapping.meshes[meshes[0]];
        for (i2 = 1; i2 < meshesLength; ++i2) {
          const meshNode = {
            mesh: globalMapping.meshes[meshes[i2]]
          };
          const meshNodeId = addToArray_default(gltf.nodes, meshNode);
          if (!defined_default(children)) {
            children = [];
            node.children = children;
          }
          children.push(meshNodeId);
        }
      }
      delete node.meshes;
    }
    if (defined_default(node.camera)) {
      node.camera = globalMapping.cameras[node.camera];
    }
    if (defined_default(node.skin)) {
      node.skin = globalMapping.skins[node.skin];
    }
    if (defined_default(node.skeletons)) {
      const skeletons = node.skeletons;
      const skeletonsLength = skeletons.length;
      if (skeletonsLength > 0 && defined_default(node.skin)) {
        const skin = gltf.skins[node.skin];
        skin.skeleton = globalMapping.nodes[skeletons[0]];
      }
      delete node.skeletons;
    }
    if (defined_default(node.jointName)) {
      delete node.jointName;
    }
  });
  ForEach_default.skin(gltf, function(skin) {
    if (defined_default(skin.inverseBindMatrices)) {
      skin.inverseBindMatrices = globalMapping.accessors[skin.inverseBindMatrices];
    }
    const jointNames = skin.jointNames;
    if (defined_default(jointNames)) {
      const joints = [];
      const jointNamesLength = jointNames.length;
      for (i2 = 0; i2 < jointNamesLength; ++i2) {
        joints[i2] = jointNameToId[jointNames[i2]];
      }
      skin.joints = joints;
      delete skin.jointNames;
    }
  });
  ForEach_default.scene(gltf, function(scene) {
    const sceneNodes = scene.nodes;
    if (defined_default(sceneNodes)) {
      const sceneNodesLength = sceneNodes.length;
      for (i2 = 0; i2 < sceneNodesLength; ++i2) {
        sceneNodes[i2] = globalMapping.nodes[sceneNodes[i2]];
      }
    }
  });
  ForEach_default.animation(gltf, function(animation) {
    const samplerMapping = {};
    animation.samplers = objectToArray(animation.samplers, samplerMapping);
    ForEach_default.animationSampler(animation, function(sampler) {
      sampler.input = globalMapping.accessors[sampler.input];
      sampler.output = globalMapping.accessors[sampler.output];
    });
    ForEach_default.animationChannel(animation, function(channel) {
      channel.sampler = samplerMapping[channel.sampler];
      const target = channel.target;
      if (defined_default(target)) {
        target.node = globalMapping.nodes[target.id];
        delete target.id;
      }
    });
  });
  ForEach_default.material(gltf, function(material) {
    if (defined_default(material.technique)) {
      material.technique = globalMapping.techniques[material.technique];
    }
    ForEach_default.materialValue(material, function(value, name) {
      if (typeof value === "string") {
        material.values[name] = {
          index: globalMapping.textures[value]
        };
      }
    });
    const extensions = material.extensions;
    if (defined_default(extensions)) {
      const materialsCommon = extensions.KHR_materials_common;
      if (defined_default(materialsCommon)) {
        ForEach_default.materialValue(materialsCommon, function(value, name) {
          if (typeof value === "string") {
            materialsCommon.values[name] = {
              index: globalMapping.textures[value]
            };
          }
        });
      }
    }
  });
  ForEach_default.image(gltf, function(image) {
    const extensions = image.extensions;
    if (defined_default(extensions)) {
      const binaryGltf = extensions.KHR_binary_glTF;
      if (defined_default(binaryGltf)) {
        image.bufferView = globalMapping.bufferViews[binaryGltf.bufferView];
        image.mimeType = binaryGltf.mimeType;
        delete extensions.KHR_binary_glTF;
      }
      if (Object.keys(extensions).length === 0) {
        delete image.extensions;
      }
    }
  });
  ForEach_default.texture(gltf, function(texture) {
    if (defined_default(texture.sampler)) {
      texture.sampler = globalMapping.samplers[texture.sampler];
    }
    if (defined_default(texture.source)) {
      texture.source = globalMapping.images[texture.source];
    }
  });
}
function removeAnimationSamplerNames(gltf) {
  ForEach_default.animation(gltf, function(animation) {
    ForEach_default.animationSampler(animation, function(sampler) {
      delete sampler.name;
    });
  });
}
function removeEmptyArrays(gltf) {
  for (const topLevelId in gltf) {
    if (Object.prototype.hasOwnProperty.call(gltf, topLevelId)) {
      const array = gltf[topLevelId];
      if (Array.isArray(array) && array.length === 0) {
        delete gltf[topLevelId];
      }
    }
  }
  ForEach_default.node(gltf, function(node) {
    if (defined_default(node.children) && node.children.length === 0) {
      delete node.children;
    }
  });
}
function stripAsset(gltf) {
  const asset = gltf.asset;
  delete asset.profile;
  delete asset.premultipliedAlpha;
}
var knownExtensions = {
  CESIUM_RTC: true,
  KHR_materials_common: true,
  WEB3D_quantized_attributes: true
};
function requireKnownExtensions(gltf) {
  const extensionsUsed = gltf.extensionsUsed;
  gltf.extensionsRequired = defaultValue_default(gltf.extensionsRequired, []);
  if (defined_default(extensionsUsed)) {
    const extensionsUsedLength = extensionsUsed.length;
    for (let i2 = 0; i2 < extensionsUsedLength; ++i2) {
      const extension = extensionsUsed[i2];
      if (defined_default(knownExtensions[extension])) {
        gltf.extensionsRequired.push(extension);
      }
    }
  }
}
function removeBufferType(gltf) {
  ForEach_default.buffer(gltf, function(buffer) {
    delete buffer.type;
  });
}
function removeTextureProperties(gltf) {
  ForEach_default.texture(gltf, function(texture) {
    delete texture.format;
    delete texture.internalFormat;
    delete texture.target;
    delete texture.type;
  });
}
function requireAttributeSetIndex(gltf) {
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      ForEach_default.meshPrimitiveAttribute(
        primitive,
        function(accessorId, semantic) {
          if (semantic === "TEXCOORD") {
            primitive.attributes.TEXCOORD_0 = accessorId;
          } else if (semantic === "COLOR") {
            primitive.attributes.COLOR_0 = accessorId;
          }
        }
      );
      delete primitive.attributes.TEXCOORD;
      delete primitive.attributes.COLOR;
    });
  });
  ForEach_default.technique(gltf, function(technique) {
    ForEach_default.techniqueParameter(technique, function(parameter) {
      const semantic = parameter.semantic;
      if (defined_default(semantic)) {
        if (semantic === "TEXCOORD") {
          parameter.semantic = "TEXCOORD_0";
        } else if (semantic === "COLOR") {
          parameter.semantic = "COLOR_0";
        }
      }
    });
  });
}
var knownSemantics = {
  POSITION: true,
  NORMAL: true,
  TANGENT: true
};
var indexedSemantics = {
  COLOR: "COLOR",
  JOINT: "JOINTS",
  JOINTS: "JOINTS",
  TEXCOORD: "TEXCOORD",
  WEIGHT: "WEIGHTS",
  WEIGHTS: "WEIGHTS"
};
function underscoreApplicationSpecificSemantics(gltf) {
  const mappedSemantics = {};
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      ForEach_default.meshPrimitiveAttribute(
        primitive,
        function(accessorId, semantic) {
          if (semantic.charAt(0) !== "_") {
            const setIndex = semantic.search(/_[0-9]+/g);
            let strippedSemantic = semantic;
            let suffix = "_0";
            if (setIndex >= 0) {
              strippedSemantic = semantic.substring(0, setIndex);
              suffix = semantic.substring(setIndex);
            }
            let newSemantic;
            const indexedSemantic = indexedSemantics[strippedSemantic];
            if (defined_default(indexedSemantic)) {
              newSemantic = indexedSemantic + suffix;
              mappedSemantics[semantic] = newSemantic;
            } else if (!defined_default(knownSemantics[strippedSemantic])) {
              newSemantic = "_" + semantic;
              mappedSemantics[semantic] = newSemantic;
            }
          }
        }
      );
      for (const semantic in mappedSemantics) {
        if (Object.prototype.hasOwnProperty.call(mappedSemantics, semantic)) {
          const mappedSemantic = mappedSemantics[semantic];
          const accessorId = primitive.attributes[semantic];
          if (defined_default(accessorId)) {
            delete primitive.attributes[semantic];
            primitive.attributes[mappedSemantic] = accessorId;
          }
        }
      }
    });
  });
  ForEach_default.technique(gltf, function(technique) {
    ForEach_default.techniqueParameter(technique, function(parameter) {
      const mappedSemantic = mappedSemantics[parameter.semantic];
      if (defined_default(mappedSemantic)) {
        parameter.semantic = mappedSemantic;
      }
    });
  });
}
function clampCameraParameters(gltf) {
  ForEach_default.camera(gltf, function(camera) {
    const perspective = camera.perspective;
    if (defined_default(perspective)) {
      const aspectRatio = perspective.aspectRatio;
      if (defined_default(aspectRatio) && aspectRatio === 0) {
        delete perspective.aspectRatio;
      }
      const yfov = perspective.yfov;
      if (defined_default(yfov) && yfov === 0) {
        perspective.yfov = 1;
      }
    }
  });
}
function computeAccessorByteStride(gltf, accessor) {
  return defined_default(accessor.byteStride) && accessor.byteStride !== 0 ? accessor.byteStride : getAccessorByteStride_default(gltf, accessor);
}
function requireByteLength(gltf) {
  ForEach_default.buffer(gltf, function(buffer) {
    if (!defined_default(buffer.byteLength)) {
      buffer.byteLength = buffer.extras._pipeline.source.length;
    }
  });
  ForEach_default.accessor(gltf, function(accessor) {
    const bufferViewId = accessor.bufferView;
    if (defined_default(bufferViewId)) {
      const bufferView = gltf.bufferViews[bufferViewId];
      const accessorByteStride = computeAccessorByteStride(gltf, accessor);
      const accessorByteEnd = accessor.byteOffset + accessor.count * accessorByteStride;
      bufferView.byteLength = Math.max(
        defaultValue_default(bufferView.byteLength, 0),
        accessorByteEnd
      );
    }
  });
}
function moveByteStrideToBufferView(gltf) {
  let i2;
  let j;
  let bufferView;
  const bufferViews = gltf.bufferViews;
  const bufferViewHasVertexAttributes = {};
  ForEach_default.accessorContainingVertexAttributeData(gltf, function(accessorId) {
    const accessor = gltf.accessors[accessorId];
    if (defined_default(accessor.bufferView)) {
      bufferViewHasVertexAttributes[accessor.bufferView] = true;
    }
  });
  const bufferViewMap = {};
  ForEach_default.accessor(gltf, function(accessor) {
    if (defined_default(accessor.bufferView)) {
      bufferViewMap[accessor.bufferView] = defaultValue_default(
        bufferViewMap[accessor.bufferView],
        []
      );
      bufferViewMap[accessor.bufferView].push(accessor);
    }
  });
  for (const bufferViewId in bufferViewMap) {
    if (Object.prototype.hasOwnProperty.call(bufferViewMap, bufferViewId)) {
      bufferView = bufferViews[bufferViewId];
      const accessors = bufferViewMap[bufferViewId];
      accessors.sort(function(a4, b) {
        return a4.byteOffset - b.byteOffset;
      });
      let currentByteOffset = 0;
      let currentIndex = 0;
      const accessorsLength = accessors.length;
      for (i2 = 0; i2 < accessorsLength; ++i2) {
        let accessor = accessors[i2];
        const accessorByteStride = computeAccessorByteStride(gltf, accessor);
        const accessorByteOffset = accessor.byteOffset;
        const accessorByteLength = accessor.count * accessorByteStride;
        delete accessor.byteStride;
        const hasNextAccessor = i2 < accessorsLength - 1;
        const nextAccessorByteStride = hasNextAccessor ? computeAccessorByteStride(gltf, accessors[i2 + 1]) : void 0;
        if (accessorByteStride !== nextAccessorByteStride) {
          const newBufferView = clone_default(bufferView, true);
          if (bufferViewHasVertexAttributes[bufferViewId]) {
            newBufferView.byteStride = accessorByteStride;
          }
          newBufferView.byteOffset += currentByteOffset;
          newBufferView.byteLength = accessorByteOffset + accessorByteLength - currentByteOffset;
          const newBufferViewId = addToArray_default(bufferViews, newBufferView);
          for (j = currentIndex; j <= i2; ++j) {
            accessor = accessors[j];
            accessor.bufferView = newBufferViewId;
            accessor.byteOffset = accessor.byteOffset - currentByteOffset;
          }
          currentByteOffset = hasNextAccessor ? accessors[i2 + 1].byteOffset : void 0;
          currentIndex = i2 + 1;
        }
      }
    }
  }
  removeUnusedElements_default(gltf, ["accessor", "bufferView", "buffer"]);
}
function requirePositionAccessorMinMax(gltf) {
  ForEach_default.accessorWithSemantic(gltf, "POSITION", function(accessorId) {
    const accessor = gltf.accessors[accessorId];
    if (!defined_default(accessor.min) || !defined_default(accessor.max)) {
      const minMax = findAccessorMinMax_default(gltf, accessor);
      accessor.min = minMax.min;
      accessor.max = minMax.max;
    }
  });
}
function isNodeEmpty(node) {
  return (!defined_default(node.children) || node.children.length === 0) && (!defined_default(node.meshes) || node.meshes.length === 0) && !defined_default(node.camera) && !defined_default(node.skin) && !defined_default(node.skeletons) && !defined_default(node.jointName) && (!defined_default(node.translation) || Cartesian3_default.fromArray(node.translation).equals(Cartesian3_default.ZERO)) && (!defined_default(node.scale) || Cartesian3_default.fromArray(node.scale).equals(new Cartesian3_default(1, 1, 1))) && (!defined_default(node.rotation) || Cartesian4_default.fromArray(node.rotation).equals(
    new Cartesian4_default(0, 0, 0, 1)
  )) && (!defined_default(node.matrix) || Matrix4_default.fromColumnMajorArray(node.matrix).equals(Matrix4_default.IDENTITY)) && !defined_default(node.extensions) && !defined_default(node.extras);
}
function deleteNode(gltf, nodeId) {
  ForEach_default.scene(gltf, function(scene) {
    const sceneNodes = scene.nodes;
    if (defined_default(sceneNodes)) {
      const sceneNodesLength = sceneNodes.length;
      for (let i2 = sceneNodesLength; i2 >= 0; --i2) {
        if (sceneNodes[i2] === nodeId) {
          sceneNodes.splice(i2, 1);
          return;
        }
      }
    }
  });
  ForEach_default.node(gltf, function(parentNode, parentNodeId) {
    if (defined_default(parentNode.children)) {
      const index2 = parentNode.children.indexOf(nodeId);
      if (index2 > -1) {
        parentNode.children.splice(index2, 1);
        if (isNodeEmpty(parentNode)) {
          deleteNode(gltf, parentNodeId);
        }
      }
    }
  });
  delete gltf.nodes[nodeId];
}
function removeEmptyNodes(gltf) {
  ForEach_default.node(gltf, function(node, nodeId) {
    if (isNodeEmpty(node)) {
      deleteNode(gltf, nodeId);
    }
  });
  return gltf;
}
function requireAnimationAccessorMinMax(gltf) {
  ForEach_default.animation(gltf, function(animation) {
    ForEach_default.animationSampler(animation, function(sampler) {
      const accessor = gltf.accessors[sampler.input];
      if (!defined_default(accessor.min) || !defined_default(accessor.max)) {
        const minMax = findAccessorMinMax_default(gltf, accessor);
        accessor.min = minMax.min;
        accessor.max = minMax.max;
      }
    });
  });
}
function glTF10to20(gltf) {
  gltf.asset = defaultValue_default(gltf.asset, {});
  gltf.asset.version = "2.0";
  updateInstanceTechniques(gltf);
  removeAnimationSamplersIndirection(gltf);
  removeEmptyNodes(gltf);
  objectsToArrays(gltf);
  removeAnimationSamplerNames(gltf);
  stripAsset(gltf);
  requireKnownExtensions(gltf);
  requireByteLength(gltf);
  moveByteStrideToBufferView(gltf);
  requirePositionAccessorMinMax(gltf);
  requireAnimationAccessorMinMax(gltf);
  removeBufferType(gltf);
  removeTextureProperties(gltf);
  requireAttributeSetIndex(gltf);
  underscoreApplicationSpecificSemantics(gltf);
  updateAccessorComponentTypes_default(gltf);
  clampCameraParameters(gltf);
  moveTechniqueRenderStates_default(gltf);
  moveTechniquesToExtension_default(gltf);
  removeEmptyArrays(gltf);
}
var updateVersion_default = updateVersion;

// node_modules/cesium/Source/Scene/ModelLoadResources.js
function ModelLoadResources() {
  this.initialized = false;
  this.resourcesParsed = false;
  this.vertexBuffersToCreate = new Queue_default();
  this.indexBuffersToCreate = new Queue_default();
  this.buffers = {};
  this.pendingBufferLoads = 0;
  this.programsToCreate = new Queue_default();
  this.shaders = {};
  this.pendingShaderLoads = 0;
  this.texturesToCreate = new Queue_default();
  this.pendingTextureLoads = 0;
  this.texturesToCreateFromBufferView = new Queue_default();
  this.pendingBufferViewToImage = 0;
  this.createSamplers = true;
  this.createSkins = true;
  this.createRuntimeAnimations = true;
  this.createVertexArrays = true;
  this.createRenderStates = true;
  this.createUniformMaps = true;
  this.createRuntimeNodes = true;
  this.createdBufferViews = {};
  this.primitivesToDecode = new Queue_default();
  this.activeDecodingTasks = 0;
  this.pendingDecodingCache = false;
  this.skinnedNodesIds = [];
}
function getSubarray(array, offset2, length3) {
  return array.subarray(offset2, offset2 + length3);
}
ModelLoadResources.prototype.getBuffer = function(bufferView) {
  return getSubarray(
    this.buffers[bufferView.buffer],
    bufferView.byteOffset,
    bufferView.byteLength
  );
};
ModelLoadResources.prototype.finishedPendingBufferLoads = function() {
  return this.pendingBufferLoads === 0;
};
ModelLoadResources.prototype.finishedBuffersCreation = function() {
  return this.pendingBufferLoads === 0 && this.vertexBuffersToCreate.length === 0 && this.indexBuffersToCreate.length === 0;
};
ModelLoadResources.prototype.finishedProgramCreation = function() {
  return this.pendingShaderLoads === 0 && this.programsToCreate.length === 0;
};
ModelLoadResources.prototype.finishedTextureCreation = function() {
  const finishedPendingLoads = this.pendingTextureLoads === 0;
  const finishedResourceCreation = this.texturesToCreate.length === 0 && this.texturesToCreateFromBufferView.length === 0;
  return finishedPendingLoads && finishedResourceCreation;
};
ModelLoadResources.prototype.finishedEverythingButTextureCreation = function() {
  const finishedPendingLoads = this.pendingBufferLoads === 0 && this.pendingShaderLoads === 0;
  const finishedResourceCreation = this.vertexBuffersToCreate.length === 0 && this.indexBuffersToCreate.length === 0 && this.programsToCreate.length === 0 && this.pendingBufferViewToImage === 0;
  return this.finishedDecoding() && finishedPendingLoads && finishedResourceCreation;
};
ModelLoadResources.prototype.finishedDecoding = function() {
  return this.primitivesToDecode.length === 0 && this.activeDecodingTasks === 0 && !this.pendingDecodingCache;
};
ModelLoadResources.prototype.finished = function() {
  return this.finishedDecoding() && this.finishedTextureCreation() && this.finishedEverythingButTextureCreation();
};
var ModelLoadResources_default = ModelLoadResources;

// node_modules/cesium/Source/Scene/ModelUtility.js
var ModelUtility = {};
ModelUtility.updateForwardAxis = function(model) {
  const cachedSourceVersion = model.gltf.extras.sourceVersion;
  if (defined_default(cachedSourceVersion) && cachedSourceVersion !== "2.0" || ModelUtility.getAssetVersion(model.gltf) !== "2.0") {
    model._gltfForwardAxis = Axis_default.X;
  }
};
ModelUtility.getAssetVersion = function(gltf) {
  if (!defined_default(gltf.asset) || !defined_default(gltf.asset.version)) {
    return "1.0";
  }
  return gltf.asset.version;
};
ModelUtility.splitIncompatibleMaterials = function(gltf) {
  const accessors = gltf.accessors;
  const materials = gltf.materials;
  const primitiveInfoByMaterial = {};
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      let materialIndex = primitive.material;
      const material = materials[materialIndex];
      const jointAccessorId = primitive.attributes.JOINTS_0;
      let componentType;
      let accessorType;
      if (defined_default(jointAccessorId)) {
        const jointAccessor = accessors[jointAccessorId];
        componentType = jointAccessor.componentType;
        accessorType = jointAccessor.type;
      }
      const isSkinned = defined_default(jointAccessorId) && accessorType === "VEC4";
      const hasVertexColors = defined_default(primitive.attributes.COLOR_0);
      const hasMorphTargets = defined_default(primitive.targets);
      const hasNormals = defined_default(primitive.attributes.NORMAL);
      const hasTangents = defined_default(primitive.attributes.TANGENT);
      const hasTexCoords = defined_default(primitive.attributes.TEXCOORD_0);
      const hasTexCoord1 = hasTexCoords && defined_default(primitive.attributes.TEXCOORD_1);
      const hasOutline = defined_default(primitive.extensions) && defined_default(primitive.extensions.CESIUM_primitive_outline);
      const primitiveInfo = primitiveInfoByMaterial[materialIndex];
      if (!defined_default(primitiveInfo)) {
        primitiveInfoByMaterial[materialIndex] = {
          skinning: {
            skinned: isSkinned,
            componentType
          },
          hasVertexColors,
          hasMorphTargets,
          hasNormals,
          hasTangents,
          hasTexCoords,
          hasTexCoord1,
          hasOutline
        };
      } else if (primitiveInfo.skinning.skinned !== isSkinned || primitiveInfo.hasVertexColors !== hasVertexColors || primitiveInfo.hasMorphTargets !== hasMorphTargets || primitiveInfo.hasNormals !== hasNormals || primitiveInfo.hasTangents !== hasTangents || primitiveInfo.hasTexCoords !== hasTexCoords || primitiveInfo.hasTexCoord1 !== hasTexCoord1 || primitiveInfo.hasOutline !== hasOutline) {
        const clonedMaterial = clone_default(material, true);
        materialIndex = addToArray_default(materials, clonedMaterial);
        primitive.material = materialIndex;
        primitiveInfoByMaterial[materialIndex] = {
          skinning: {
            skinned: isSkinned,
            componentType
          },
          hasVertexColors,
          hasMorphTargets,
          hasNormals,
          hasTangents,
          hasTexCoords,
          hasTexCoord1,
          hasOutline
        };
      }
    });
  });
  return primitiveInfoByMaterial;
};
ModelUtility.getShaderVariable = function(type) {
  if (type === "SCALAR") {
    return "float";
  }
  return type.toLowerCase();
};
ModelUtility.ModelState = {
  NEEDS_LOAD: 0,
  LOADING: 1,
  LOADED: 2,
  FAILED: 3
};
ModelUtility.getFailedLoadFunction = function(model, type, path) {
  return function(error) {
    model._state = ModelUtility.ModelState.FAILED;
    let message = `Failed to load ${type}: ${path}`;
    if (defined_default(error)) {
      message += `
${error.message}`;
    }
    model._readyPromise.reject(new RuntimeError_default(message));
  };
};
ModelUtility.parseBuffers = function(model, bufferLoad2) {
  const loadResources = model._loadResources;
  ForEach_default.buffer(model.gltf, function(buffer, bufferViewId) {
    if (defined_default(buffer.extras._pipeline.source)) {
      loadResources.buffers[bufferViewId] = buffer.extras._pipeline.source;
    } else if (defined_default(bufferLoad2)) {
      const bufferResource = model._resource.getDerivedResource({
        url: buffer.uri
      });
      ++loadResources.pendingBufferLoads;
      bufferResource.fetchArrayBuffer().then(bufferLoad2(model, bufferViewId)).catch(
        ModelUtility.getFailedLoadFunction(
          model,
          "buffer",
          bufferResource.url
        )
      );
    }
  });
};
var aMinScratch = new Cartesian3_default();
var aMaxScratch = new Cartesian3_default();
ModelUtility.computeBoundingSphere = function(model) {
  const gltf = model.gltf;
  const gltfNodes = gltf.nodes;
  const gltfMeshes = gltf.meshes;
  const rootNodes = gltf.scenes[gltf.scene].nodes;
  const rootNodesLength = rootNodes.length;
  const nodeStack = [];
  const min3 = new Cartesian3_default(
    Number.MAX_VALUE,
    Number.MAX_VALUE,
    Number.MAX_VALUE
  );
  const max3 = new Cartesian3_default(
    -Number.MAX_VALUE,
    -Number.MAX_VALUE,
    -Number.MAX_VALUE
  );
  for (let i2 = 0; i2 < rootNodesLength; ++i2) {
    let n2 = gltfNodes[rootNodes[i2]];
    n2._transformToRoot = ModelUtility.getTransform(n2);
    nodeStack.push(n2);
    while (nodeStack.length > 0) {
      n2 = nodeStack.pop();
      const transformToRoot = n2._transformToRoot;
      const meshId = n2.mesh;
      if (defined_default(meshId)) {
        const mesh2 = gltfMeshes[meshId];
        const primitives = mesh2.primitives;
        const primitivesLength = primitives.length;
        for (let m = 0; m < primitivesLength; ++m) {
          const positionAccessor = primitives[m].attributes.POSITION;
          if (defined_default(positionAccessor)) {
            const minMax = ModelUtility.getAccessorMinMax(
              gltf,
              positionAccessor
            );
            if (defined_default(minMax.min) && defined_default(minMax.max)) {
              const aMin = Cartesian3_default.fromArray(minMax.min, 0, aMinScratch);
              const aMax = Cartesian3_default.fromArray(minMax.max, 0, aMaxScratch);
              Matrix4_default.multiplyByPoint(transformToRoot, aMin, aMin);
              Matrix4_default.multiplyByPoint(transformToRoot, aMax, aMax);
              Cartesian3_default.minimumByComponent(min3, aMin, min3);
              Cartesian3_default.maximumByComponent(max3, aMax, max3);
            }
          }
        }
      }
      const children = n2.children;
      if (defined_default(children)) {
        const childrenLength = children.length;
        for (let k = 0; k < childrenLength; ++k) {
          const child = gltfNodes[children[k]];
          child._transformToRoot = ModelUtility.getTransform(child);
          Matrix4_default.multiplyTransformation(
            transformToRoot,
            child._transformToRoot,
            child._transformToRoot
          );
          nodeStack.push(child);
        }
      }
      delete n2._transformToRoot;
    }
  }
  const boundingSphere = BoundingSphere_default.fromCornerPoints(min3, max3);
  if (model._forwardAxis === Axis_default.Z) {
    BoundingSphere_default.transformWithoutScale(
      boundingSphere,
      Axis_default.Z_UP_TO_X_UP,
      boundingSphere
    );
  }
  if (model._upAxis === Axis_default.Y) {
    BoundingSphere_default.transformWithoutScale(
      boundingSphere,
      Axis_default.Y_UP_TO_Z_UP,
      boundingSphere
    );
  } else if (model._upAxis === Axis_default.X) {
    BoundingSphere_default.transformWithoutScale(
      boundingSphere,
      Axis_default.X_UP_TO_Z_UP,
      boundingSphere
    );
  }
  return boundingSphere;
};
function techniqueAttributeForSemantic(technique, semantic) {
  return ForEach_default.techniqueAttribute(technique, function(attribute, attributeName) {
    if (attribute.semantic === semantic) {
      return attributeName;
    }
  });
}
function ensureSemanticExistenceForPrimitive(gltf, primitive) {
  const accessors = gltf.accessors;
  const materials = gltf.materials;
  const techniquesWebgl = gltf.extensions.KHR_techniques_webgl;
  const techniques = techniquesWebgl.techniques;
  const programs = techniquesWebgl.programs;
  const shaders = techniquesWebgl.shaders;
  const targets = primitive.targets;
  const attributes = primitive.attributes;
  for (const target in targets) {
    if (targets.hasOwnProperty(target)) {
      const targetAttributes = targets[target];
      for (const attribute in targetAttributes) {
        if (attribute !== "extras") {
          attributes[`${attribute}_${target}`] = targetAttributes[attribute];
        }
      }
    }
  }
  const material = materials[primitive.material];
  const technique = techniques[material.extensions.KHR_techniques_webgl.technique];
  const program = programs[technique.program];
  const vertexShader = shaders[program.vertexShader];
  for (const semantic in attributes) {
    if (attributes.hasOwnProperty(semantic)) {
      if (!defined_default(techniqueAttributeForSemantic(technique, semantic))) {
        const accessorId = attributes[semantic];
        const accessor = accessors[accessorId];
        let lowerCase = semantic.toLowerCase();
        if (lowerCase.charAt(0) === "_") {
          lowerCase = lowerCase.slice(1);
        }
        const attributeName = `a_${lowerCase}`;
        technique.attributes[attributeName] = {
          semantic,
          type: accessor.componentType
        };
        const pipelineExtras = vertexShader.extras._pipeline;
        let shaderText = pipelineExtras.source;
        shaderText = `attribute ${ModelUtility.getShaderVariable(
          accessor.type
        )} ${attributeName};
${shaderText}`;
        pipelineExtras.source = shaderText;
      }
    }
  }
}
ModelUtility.ensureSemanticExistence = function(gltf) {
  ForEach_default.mesh(gltf, function(mesh2) {
    ForEach_default.meshPrimitive(mesh2, function(primitive) {
      ensureSemanticExistenceForPrimitive(gltf, primitive);
    });
  });
  return gltf;
};
ModelUtility.createAttributeLocations = function(technique, precreatedAttributes) {
  const attributeLocations8 = {};
  let hasIndex0 = false;
  let i2 = 1;
  ForEach_default.techniqueAttribute(technique, function(attribute, attributeName) {
    if (/pos/i.test(attributeName) && !hasIndex0) {
      attributeLocations8[attributeName] = 0;
      hasIndex0 = true;
    } else {
      attributeLocations8[attributeName] = i2++;
    }
  });
  if (defined_default(precreatedAttributes)) {
    for (const attributeName in precreatedAttributes) {
      if (precreatedAttributes.hasOwnProperty(attributeName)) {
        attributeLocations8[attributeName] = i2++;
      }
    }
  }
  return attributeLocations8;
};
ModelUtility.getAccessorMinMax = function(gltf, accessorId) {
  const accessor = gltf.accessors[accessorId];
  const extensions = accessor.extensions;
  let accessorMin = accessor.min;
  let accessorMax = accessor.max;
  if (defined_default(extensions)) {
    const quantizedAttributes = extensions.WEB3D_quantized_attributes;
    if (defined_default(quantizedAttributes)) {
      accessorMin = quantizedAttributes.decodedMin;
      accessorMax = quantizedAttributes.decodedMax;
    }
  }
  return {
    min: accessorMin,
    max: accessorMax
  };
};
function getTechniqueAttributeOrUniformFunction(gltf, technique, semantic, ignoreNodes) {
  if (usesExtension_default(gltf, "KHR_techniques_webgl")) {
    return function(attributeOrUniform, attributeOrUniformName) {
      if (attributeOrUniform.semantic === semantic && (!ignoreNodes || !defined_default(attributeOrUniform.node))) {
        return attributeOrUniformName;
      }
    };
  }
  return function(parameterName, attributeOrUniformName) {
    const attributeOrUniform = technique.parameters[parameterName];
    if (attributeOrUniform.semantic === semantic && (!ignoreNodes || !defined_default(attributeOrUniform.node))) {
      return attributeOrUniformName;
    }
  };
}
ModelUtility.getAttributeOrUniformBySemantic = function(gltf, semantic, programId, ignoreNodes) {
  return ForEach_default.technique(gltf, function(technique) {
    if (defined_default(programId) && technique.program !== programId) {
      return;
    }
    const value = ForEach_default.techniqueAttribute(
      technique,
      getTechniqueAttributeOrUniformFunction(
        gltf,
        technique,
        semantic,
        ignoreNodes
      )
    );
    if (defined_default(value)) {
      return value;
    }
    return ForEach_default.techniqueUniform(
      technique,
      getTechniqueAttributeOrUniformFunction(
        gltf,
        technique,
        semantic,
        ignoreNodes
      )
    );
  });
};
ModelUtility.getDiffuseAttributeOrUniform = function(gltf, programId) {
  let diffuseUniformName = ModelUtility.getAttributeOrUniformBySemantic(
    gltf,
    "COLOR_0",
    programId
  );
  if (!defined_default(diffuseUniformName)) {
    diffuseUniformName = ModelUtility.getAttributeOrUniformBySemantic(
      gltf,
      "_3DTILESDIFFUSE",
      programId
    );
  }
  return diffuseUniformName;
};
var nodeTranslationScratch = new Cartesian3_default();
var nodeQuaternionScratch = new Quaternion_default();
var nodeScaleScratch = new Cartesian3_default();
ModelUtility.getTransform = function(node, result) {
  if (defined_default(node.matrix)) {
    return Matrix4_default.fromColumnMajorArray(node.matrix, result);
  }
  return Matrix4_default.fromTranslationQuaternionRotationScale(
    Cartesian3_default.fromArray(node.translation, 0, nodeTranslationScratch),
    Quaternion_default.unpack(node.rotation, 0, nodeQuaternionScratch),
    Cartesian3_default.fromArray(node.scale, 0, nodeScaleScratch),
    result
  );
};
ModelUtility.getUsedExtensions = function(gltf) {
  const extensionsUsed = gltf.extensionsUsed;
  const cachedExtensionsUsed = {};
  if (defined_default(extensionsUsed)) {
    const extensionsUsedLength = extensionsUsed.length;
    for (let i2 = 0; i2 < extensionsUsedLength; i2++) {
      const extension = extensionsUsed[i2];
      cachedExtensionsUsed[extension] = true;
    }
  }
  return cachedExtensionsUsed;
};
ModelUtility.getRequiredExtensions = function(gltf) {
  const extensionsRequired = gltf.extensionsRequired;
  const cachedExtensionsRequired = {};
  if (defined_default(extensionsRequired)) {
    const extensionsRequiredLength = extensionsRequired.length;
    for (let i2 = 0; i2 < extensionsRequiredLength; i2++) {
      const extension = extensionsRequired[i2];
      cachedExtensionsRequired[extension] = true;
    }
  }
  return cachedExtensionsRequired;
};
ModelUtility.supportedExtensions = {
  AGI_articulations: true,
  CESIUM_RTC: true,
  EXT_texture_webp: true,
  KHR_blend: true,
  KHR_binary_glTF: true,
  KHR_texture_basisu: true,
  KHR_draco_mesh_compression: true,
  KHR_materials_common: true,
  KHR_techniques_webgl: true,
  KHR_materials_unlit: true,
  KHR_materials_pbrSpecularGlossiness: true,
  KHR_texture_transform: true,
  WEB3D_quantized_attributes: true
};
ModelUtility.checkSupportedExtensions = function(extensionsRequired, browserSupportsWebp) {
  for (const extension in extensionsRequired) {
    if (extensionsRequired.hasOwnProperty(extension)) {
      if (!ModelUtility.supportedExtensions[extension]) {
        throw new RuntimeError_default(`Unsupported glTF Extension: ${extension}`);
      }
      if (extension === "EXT_texture_webp" && browserSupportsWebp === false) {
        throw new RuntimeError_default(
          "Loaded model requires WebP but browser does not support it."
        );
      }
    }
  }
};
ModelUtility.checkSupportedGlExtensions = function(extensionsUsed, context) {
  if (defined_default(extensionsUsed)) {
    const glExtensionsUsedLength = extensionsUsed.length;
    for (let i2 = 0; i2 < glExtensionsUsedLength; i2++) {
      const extension = extensionsUsed[i2];
      if (extension !== "OES_element_index_uint") {
        throw new RuntimeError_default(`Unsupported WebGL Extension: ${extension}`);
      } else if (!context.elementIndexUint) {
        throw new RuntimeError_default(
          "OES_element_index_uint WebGL extension is not enabled."
        );
      }
    }
  }
};
function replaceAllButFirstInString(string, find, replace) {
  find += "(?!\\w)";
  find = new RegExp(find, "g");
  const index2 = string.search(find);
  return string.replace(find, function(match, offset2) {
    return index2 === offset2 ? match : replace;
  });
}
function getQuantizedAttributes(gltf, accessorId) {
  const accessor = gltf.accessors[accessorId];
  const extensions = accessor.extensions;
  if (defined_default(extensions)) {
    return extensions.WEB3D_quantized_attributes;
  }
  return void 0;
}
function getAttributeVariableName(gltf, primitive, attributeSemantic) {
  const materialId = primitive.material;
  const material = gltf.materials[materialId];
  if (!usesExtension_default(gltf, "KHR_techniques_webgl") || !defined_default(material.extensions) || !defined_default(material.extensions.KHR_techniques_webgl)) {
    return;
  }
  const techniqueId = material.extensions.KHR_techniques_webgl.technique;
  const techniquesWebgl = gltf.extensions.KHR_techniques_webgl;
  const technique = techniquesWebgl.techniques[techniqueId];
  return ForEach_default.techniqueAttribute(technique, function(attribute, attributeName) {
    const semantic = attribute.semantic;
    if (semantic === attributeSemantic) {
      return attributeName;
    }
  });
}
ModelUtility.modifyShaderForDracoQuantizedAttributes = function(gltf, primitive, shader, decodedAttributes) {
  const quantizedUniforms = {};
  for (let attributeSemantic in decodedAttributes) {
    if (decodedAttributes.hasOwnProperty(attributeSemantic)) {
      const attribute = decodedAttributes[attributeSemantic];
      const quantization = attribute.quantization;
      if (!defined_default(quantization)) {
        continue;
      }
      const attributeVarName = getAttributeVariableName(
        gltf,
        primitive,
        attributeSemantic
      );
      if (attributeSemantic.charAt(0) === "_") {
        attributeSemantic = attributeSemantic.substring(1);
      }
      const decodeUniformVarName = `gltf_u_dec_${attributeSemantic.toLowerCase()}`;
      if (!defined_default(quantizedUniforms[decodeUniformVarName])) {
        const newMain = `gltf_decoded_${attributeSemantic}`;
        const decodedAttributeVarName = attributeVarName.replace(
          "a_",
          "gltf_a_dec_"
        );
        const size = attribute.componentsPerAttribute;
        shader = replaceAllButFirstInString(
          shader,
          attributeVarName,
          decodedAttributeVarName
        );
        let variableType;
        if (quantization.octEncoded) {
          variableType = "vec3";
        } else if (size > 1) {
          variableType = `vec${size}`;
        } else {
          variableType = "float";
        }
        shader = `${variableType} ${decodedAttributeVarName};
${shader}`;
        const vec3Color = size === 3 && attributeSemantic === "COLOR_0";
        if (vec3Color) {
          shader = replaceAllButFirstInString(
            shader,
            decodedAttributeVarName,
            `vec4(${decodedAttributeVarName}, 1.0)`
          );
        }
        let decode = "";
        if (quantization.octEncoded) {
          const decodeUniformVarNameRangeConstant = `${decodeUniformVarName}_rangeConstant`;
          shader = `uniform float ${decodeUniformVarNameRangeConstant};
${shader}`;
          decode = `${"\nvoid main() {\n    "}${decodedAttributeVarName} = czm_octDecode(${attributeVarName}.xy, ${decodeUniformVarNameRangeConstant}).zxy;
    ${newMain}();
}
`;
        } else {
          const decodeUniformVarNameNormConstant = `${decodeUniformVarName}_normConstant`;
          const decodeUniformVarNameMin = `${decodeUniformVarName}_min`;
          shader = `uniform float ${decodeUniformVarNameNormConstant};
uniform ${variableType} ${decodeUniformVarNameMin};
${shader}`;
          const attributeVarAccess = vec3Color ? ".xyz" : "";
          decode = `${"\nvoid main() {\n    "}${decodedAttributeVarName} = ${decodeUniformVarNameMin} + ${attributeVarName}${attributeVarAccess} * ${decodeUniformVarNameNormConstant};
    ${newMain}();
}
`;
        }
        shader = ShaderSource_default.replaceMain(shader, newMain);
        shader += decode;
      }
    }
  }
  return {
    shader
  };
};
ModelUtility.modifyShaderForQuantizedAttributes = function(gltf, primitive, shader) {
  const quantizedUniforms = {};
  const attributes = primitive.attributes;
  for (let attributeSemantic in attributes) {
    if (attributes.hasOwnProperty(attributeSemantic)) {
      const attributeVarName = getAttributeVariableName(
        gltf,
        primitive,
        attributeSemantic
      );
      const accessorId = primitive.attributes[attributeSemantic];
      if (attributeSemantic.charAt(0) === "_") {
        attributeSemantic = attributeSemantic.substring(1);
      }
      const decodeUniformVarName = `gltf_u_dec_${attributeSemantic.toLowerCase()}`;
      const decodeUniformVarNameScale = `${decodeUniformVarName}_scale`;
      const decodeUniformVarNameTranslate = `${decodeUniformVarName}_translate`;
      if (!defined_default(quantizedUniforms[decodeUniformVarName]) && !defined_default(quantizedUniforms[decodeUniformVarNameScale])) {
        const quantizedAttributes = getQuantizedAttributes(gltf, accessorId);
        if (defined_default(quantizedAttributes)) {
          const decodeMatrix = quantizedAttributes.decodeMatrix;
          const newMain = `gltf_decoded_${attributeSemantic}`;
          const decodedAttributeVarName = attributeVarName.replace(
            "a_",
            "gltf_a_dec_"
          );
          const size = Math.floor(Math.sqrt(decodeMatrix.length));
          shader = replaceAllButFirstInString(
            shader,
            attributeVarName,
            decodedAttributeVarName
          );
          let variableType;
          if (size > 2) {
            variableType = `vec${size - 1}`;
          } else {
            variableType = "float";
          }
          shader = `${variableType} ${decodedAttributeVarName};
${shader}`;
          let decode = "";
          if (size === 5) {
            shader = `uniform mat4 ${decodeUniformVarNameScale};
${shader}`;
            shader = `uniform vec4 ${decodeUniformVarNameTranslate};
${shader}`;
            decode = `${"\nvoid main() {\n    "}${decodedAttributeVarName} = ${decodeUniformVarNameScale} * ${attributeVarName} + ${decodeUniformVarNameTranslate};
    ${newMain}();
}
`;
            quantizedUniforms[decodeUniformVarNameScale] = { mat: 4 };
            quantizedUniforms[decodeUniformVarNameTranslate] = { vec: 4 };
          } else {
            shader = `uniform mat${size} ${decodeUniformVarName};
${shader}`;
            decode = `${"\nvoid main() {\n    "}${decodedAttributeVarName} = ${variableType}(${decodeUniformVarName} * vec${size}(${attributeVarName},1.0));
    ${newMain}();
}
`;
            quantizedUniforms[decodeUniformVarName] = { mat: size };
          }
          shader = ShaderSource_default.replaceMain(shader, newMain);
          shader += decode;
        }
      }
    }
  }
  return {
    shader,
    uniforms: quantizedUniforms
  };
};
function getScalarUniformFunction(value) {
  const that = {
    value,
    clone: function(source, result) {
      return source;
    },
    func: function() {
      return that.value;
    }
  };
  return that;
}
function getVec2UniformFunction(value) {
  const that = {
    value: Cartesian2_default.fromArray(value),
    clone: Cartesian2_default.clone,
    func: function() {
      return that.value;
    }
  };
  return that;
}
function getVec3UniformFunction(value) {
  const that = {
    value: Cartesian3_default.fromArray(value),
    clone: Cartesian3_default.clone,
    func: function() {
      return that.value;
    }
  };
  return that;
}
function getVec4UniformFunction(value) {
  const that = {
    value: Cartesian4_default.fromArray(value),
    clone: Cartesian4_default.clone,
    func: function() {
      return that.value;
    }
  };
  return that;
}
function getMat2UniformFunction(value) {
  const that = {
    value: Matrix2_default.fromColumnMajorArray(value),
    clone: Matrix2_default.clone,
    func: function() {
      return that.value;
    }
  };
  return that;
}
function getMat3UniformFunction(value) {
  const that = {
    value: Matrix3_default.fromColumnMajorArray(value),
    clone: Matrix3_default.clone,
    func: function() {
      return that.value;
    }
  };
  return that;
}
function getMat4UniformFunction(value) {
  const that = {
    value: Matrix4_default.fromColumnMajorArray(value),
    clone: Matrix4_default.clone,
    func: function() {
      return that.value;
    }
  };
  return that;
}
function DelayLoadedTextureUniform(value, textures, defaultTexture) {
  this._value = void 0;
  this._textureId = value.index;
  this._textures = textures;
  this._defaultTexture = defaultTexture;
}
Object.defineProperties(DelayLoadedTextureUniform.prototype, {
  value: {
    get: function() {
      if (!defined_default(this._value)) {
        const texture = this._textures[this._textureId];
        if (defined_default(texture)) {
          this._value = texture;
        } else {
          return this._defaultTexture;
        }
      }
      return this._value;
    },
    set: function(value) {
      this._value = value;
    }
  }
});
DelayLoadedTextureUniform.prototype.clone = function(source) {
  return source;
};
DelayLoadedTextureUniform.prototype.func = void 0;
function getTextureUniformFunction(value, textures, defaultTexture) {
  const uniform = new DelayLoadedTextureUniform(
    value,
    textures,
    defaultTexture
  );
  uniform.func = function() {
    return uniform.value;
  };
  return uniform;
}
var gltfUniformFunctions = {};
gltfUniformFunctions[WebGLConstants_default.FLOAT] = getScalarUniformFunction;
gltfUniformFunctions[WebGLConstants_default.FLOAT_VEC2] = getVec2UniformFunction;
gltfUniformFunctions[WebGLConstants_default.FLOAT_VEC3] = getVec3UniformFunction;
gltfUniformFunctions[WebGLConstants_default.FLOAT_VEC4] = getVec4UniformFunction;
gltfUniformFunctions[WebGLConstants_default.INT] = getScalarUniformFunction;
gltfUniformFunctions[WebGLConstants_default.INT_VEC2] = getVec2UniformFunction;
gltfUniformFunctions[WebGLConstants_default.INT_VEC3] = getVec3UniformFunction;
gltfUniformFunctions[WebGLConstants_default.INT_VEC4] = getVec4UniformFunction;
gltfUniformFunctions[WebGLConstants_default.BOOL] = getScalarUniformFunction;
gltfUniformFunctions[WebGLConstants_default.BOOL_VEC2] = getVec2UniformFunction;
gltfUniformFunctions[WebGLConstants_default.BOOL_VEC3] = getVec3UniformFunction;
gltfUniformFunctions[WebGLConstants_default.BOOL_VEC4] = getVec4UniformFunction;
gltfUniformFunctions[WebGLConstants_default.FLOAT_MAT2] = getMat2UniformFunction;
gltfUniformFunctions[WebGLConstants_default.FLOAT_MAT3] = getMat3UniformFunction;
gltfUniformFunctions[WebGLConstants_default.FLOAT_MAT4] = getMat4UniformFunction;
gltfUniformFunctions[WebGLConstants_default.SAMPLER_2D] = getTextureUniformFunction;
ModelUtility.createUniformFunction = function(type, value, textures, defaultTexture) {
  return gltfUniformFunctions[type](value, textures, defaultTexture);
};
function scaleFromMatrix5Array(matrix) {
  return [
    matrix[0],
    matrix[1],
    matrix[2],
    matrix[3],
    matrix[5],
    matrix[6],
    matrix[7],
    matrix[8],
    matrix[10],
    matrix[11],
    matrix[12],
    matrix[13],
    matrix[15],
    matrix[16],
    matrix[17],
    matrix[18]
  ];
}
function translateFromMatrix5Array(matrix) {
  return [matrix[20], matrix[21], matrix[22], matrix[23]];
}
ModelUtility.createUniformsForDracoQuantizedAttributes = function(decodedAttributes) {
  const uniformMap2 = {};
  for (let attribute in decodedAttributes) {
    if (decodedAttributes.hasOwnProperty(attribute)) {
      const decodedData = decodedAttributes[attribute];
      const quantization = decodedData.quantization;
      if (!defined_default(quantization)) {
        continue;
      }
      if (attribute.charAt(0) === "_") {
        attribute = attribute.substring(1);
      }
      const uniformVarName = `gltf_u_dec_${attribute.toLowerCase()}`;
      if (quantization.octEncoded) {
        const uniformVarNameRangeConstant = `${uniformVarName}_rangeConstant`;
        const rangeConstant = (1 << quantization.quantizationBits) - 1;
        uniformMap2[uniformVarNameRangeConstant] = getScalarUniformFunction(
          rangeConstant
        ).func;
        continue;
      }
      const uniformVarNameNormConstant = `${uniformVarName}_normConstant`;
      const normConstant = quantization.range / (1 << quantization.quantizationBits);
      uniformMap2[uniformVarNameNormConstant] = getScalarUniformFunction(
        normConstant
      ).func;
      const uniformVarNameMin = `${uniformVarName}_min`;
      switch (decodedData.componentsPerAttribute) {
        case 1:
          uniformMap2[uniformVarNameMin] = getScalarUniformFunction(
            quantization.minValues
          ).func;
          break;
        case 2:
          uniformMap2[uniformVarNameMin] = getVec2UniformFunction(
            quantization.minValues
          ).func;
          break;
        case 3:
          uniformMap2[uniformVarNameMin] = getVec3UniformFunction(
            quantization.minValues
          ).func;
          break;
        case 4:
          uniformMap2[uniformVarNameMin] = getVec4UniformFunction(
            quantization.minValues
          ).func;
          break;
      }
    }
  }
  return uniformMap2;
};
ModelUtility.createUniformsForQuantizedAttributes = function(gltf, primitive, quantizedUniforms) {
  const accessors = gltf.accessors;
  const setUniforms = {};
  const uniformMap2 = {};
  const attributes = primitive.attributes;
  for (let attribute in attributes) {
    if (attributes.hasOwnProperty(attribute)) {
      const accessorId = attributes[attribute];
      const a4 = accessors[accessorId];
      const extensions = a4.extensions;
      if (attribute.charAt(0) === "_") {
        attribute = attribute.substring(1);
      }
      if (defined_default(extensions)) {
        const quantizedAttributes = extensions.WEB3D_quantized_attributes;
        if (defined_default(quantizedAttributes)) {
          const decodeMatrix = quantizedAttributes.decodeMatrix;
          const uniformVariable = `gltf_u_dec_${attribute.toLowerCase()}`;
          let uniformVariableScale;
          let uniformVariableTranslate;
          switch (a4.type) {
            case AttributeType_default.SCALAR:
              uniformMap2[uniformVariable] = getMat2UniformFunction(
                decodeMatrix
              ).func;
              setUniforms[uniformVariable] = true;
              break;
            case AttributeType_default.VEC2:
              uniformMap2[uniformVariable] = getMat3UniformFunction(
                decodeMatrix
              ).func;
              setUniforms[uniformVariable] = true;
              break;
            case AttributeType_default.VEC3:
              uniformMap2[uniformVariable] = getMat4UniformFunction(
                decodeMatrix
              ).func;
              setUniforms[uniformVariable] = true;
              break;
            case AttributeType_default.VEC4:
              uniformVariableScale = `${uniformVariable}_scale`;
              uniformVariableTranslate = `${uniformVariable}_translate`;
              uniformMap2[uniformVariableScale] = getMat4UniformFunction(
                scaleFromMatrix5Array(decodeMatrix)
              ).func;
              uniformMap2[uniformVariableTranslate] = getVec4UniformFunction(
                translateFromMatrix5Array(decodeMatrix)
              ).func;
              setUniforms[uniformVariableScale] = true;
              setUniforms[uniformVariableTranslate] = true;
              break;
          }
        }
      }
    }
  }
  for (const quantizedUniform in quantizedUniforms) {
    if (quantizedUniforms.hasOwnProperty(quantizedUniform)) {
      if (!setUniforms[quantizedUniform]) {
        const properties = quantizedUniforms[quantizedUniform];
        if (defined_default(properties.mat)) {
          if (properties.mat === 2) {
            uniformMap2[quantizedUniform] = getMat2UniformFunction(
              Matrix2_default.IDENTITY
            ).func;
          } else if (properties.mat === 3) {
            uniformMap2[quantizedUniform] = getMat3UniformFunction(
              Matrix3_default.IDENTITY
            ).func;
          } else if (properties.mat === 4) {
            uniformMap2[quantizedUniform] = getMat4UniformFunction(
              Matrix4_default.IDENTITY
            ).func;
          }
        }
        if (defined_default(properties.vec)) {
          if (properties.vec === 4) {
            uniformMap2[quantizedUniform] = getVec4UniformFunction([
              0,
              0,
              0,
              0
            ]).func;
          }
        }
      }
    }
  }
  return uniformMap2;
};
var scratchTranslationRtc = new Cartesian3_default();
var gltfSemanticUniforms = {
  MODEL: function(uniformState, model) {
    return function() {
      return uniformState.model;
    };
  },
  VIEW: function(uniformState, model) {
    return function() {
      return uniformState.view;
    };
  },
  PROJECTION: function(uniformState, model) {
    return function() {
      return uniformState.projection;
    };
  },
  MODELVIEW: function(uniformState, model) {
    return function() {
      return uniformState.modelView;
    };
  },
  CESIUM_RTC_MODELVIEW: function(uniformState, model) {
    const mvRtc = new Matrix4_default();
    return function() {
      if (defined_default(model._rtcCenter)) {
        Matrix4_default.getTranslation(uniformState.model, scratchTranslationRtc);
        Cartesian3_default.add(
          scratchTranslationRtc,
          model._rtcCenter,
          scratchTranslationRtc
        );
        Matrix4_default.multiplyByPoint(
          uniformState.view,
          scratchTranslationRtc,
          scratchTranslationRtc
        );
        return Matrix4_default.setTranslation(
          uniformState.modelView,
          scratchTranslationRtc,
          mvRtc
        );
      }
      return uniformState.modelView;
    };
  },
  MODELVIEWPROJECTION: function(uniformState, model) {
    return function() {
      return uniformState.modelViewProjection;
    };
  },
  MODELINVERSE: function(uniformState, model) {
    return function() {
      return uniformState.inverseModel;
    };
  },
  VIEWINVERSE: function(uniformState, model) {
    return function() {
      return uniformState.inverseView;
    };
  },
  PROJECTIONINVERSE: function(uniformState, model) {
    return function() {
      return uniformState.inverseProjection;
    };
  },
  MODELVIEWINVERSE: function(uniformState, model) {
    return function() {
      return uniformState.inverseModelView;
    };
  },
  MODELVIEWPROJECTIONINVERSE: function(uniformState, model) {
    return function() {
      return uniformState.inverseModelViewProjection;
    };
  },
  MODELINVERSETRANSPOSE: function(uniformState, model) {
    return function() {
      return uniformState.inverseTransposeModel;
    };
  },
  MODELVIEWINVERSETRANSPOSE: function(uniformState, model) {
    return function() {
      return uniformState.normal;
    };
  },
  VIEWPORT: function(uniformState, model) {
    return function() {
      return uniformState.viewportCartesian4;
    };
  }
};
ModelUtility.getGltfSemanticUniforms = function() {
  return gltfSemanticUniforms;
};
var ModelUtility_default = ModelUtility;

// node_modules/cesium/Source/Scene/processModelMaterialsCommon.js
function processModelMaterialsCommon(gltf, options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(gltf)) {
    return;
  }
  if (!usesExtension_default(gltf, "KHR_materials_common")) {
    return;
  }
  if (!usesExtension_default(gltf, "KHR_techniques_webgl")) {
    if (!defined_default(gltf.extensions)) {
      gltf.extensions = {};
    }
    gltf.extensions.KHR_techniques_webgl = {
      programs: [],
      shaders: [],
      techniques: []
    };
    gltf.extensionsUsed.push("KHR_techniques_webgl");
    gltf.extensionsRequired.push("KHR_techniques_webgl");
  }
  const techniquesWebgl = gltf.extensions.KHR_techniques_webgl;
  lightDefaults(gltf);
  const lightParameters = generateLightParameters(gltf);
  const primitiveByMaterial = ModelUtility_default.splitIncompatibleMaterials(gltf);
  const techniques = {};
  let generatedTechniques = false;
  ForEach_default.material(gltf, function(material, materialIndex) {
    if (defined_default(material.extensions) && defined_default(material.extensions.KHR_materials_common)) {
      const khrMaterialsCommon = material.extensions.KHR_materials_common;
      const primitiveInfo = primitiveByMaterial[materialIndex];
      const techniqueKey = getTechniqueKey(khrMaterialsCommon, primitiveInfo);
      let technique = techniques[techniqueKey];
      if (!defined_default(technique)) {
        technique = generateTechnique(
          gltf,
          techniquesWebgl,
          primitiveInfo,
          khrMaterialsCommon,
          lightParameters,
          options.addBatchIdToGeneratedShaders
        );
        techniques[techniqueKey] = technique;
        generatedTechniques = true;
      }
      const materialValues = {};
      const values = khrMaterialsCommon.values;
      let uniformName;
      for (const valueName in values) {
        if (values.hasOwnProperty(valueName) && valueName !== "transparent" && valueName !== "doubleSided") {
          uniformName = `u_${valueName.toLowerCase()}`;
          materialValues[uniformName] = values[valueName];
        }
      }
      material.extensions.KHR_techniques_webgl = {
        technique,
        values: materialValues
      };
      material.alphaMode = "OPAQUE";
      if (khrMaterialsCommon.transparent) {
        material.alphaMode = "BLEND";
      }
      if (khrMaterialsCommon.doubleSided) {
        material.doubleSided = true;
      }
    }
  });
  if (!generatedTechniques) {
    return gltf;
  }
  ModelUtility_default.ensureSemanticExistence(gltf);
  return gltf;
}
function generateLightParameters(gltf) {
  const result = {};
  let lights;
  if (defined_default(gltf.extensions) && defined_default(gltf.extensions.KHR_materials_common)) {
    lights = gltf.extensions.KHR_materials_common.lights;
  }
  if (defined_default(lights)) {
    const nodes = gltf.nodes;
    for (const nodeName in nodes) {
      if (nodes.hasOwnProperty(nodeName)) {
        const node = nodes[nodeName];
        if (defined_default(node.extensions) && defined_default(node.extensions.KHR_materials_common)) {
          const nodeLightId = node.extensions.KHR_materials_common.light;
          if (defined_default(nodeLightId) && defined_default(lights[nodeLightId])) {
            lights[nodeLightId].node = nodeName;
          }
          delete node.extensions.KHR_materials_common;
        }
      }
    }
    let lightCount = 0;
    for (const lightName in lights) {
      if (lights.hasOwnProperty(lightName)) {
        const light = lights[lightName];
        const lightType = light.type;
        if (lightType !== "ambient" && !defined_default(light.node)) {
          delete lights[lightName];
          continue;
        }
        const lightBaseName = `light${lightCount.toString()}`;
        light.baseName = lightBaseName;
        let ambient;
        let directional;
        let point;
        let spot;
        switch (lightType) {
          case "ambient":
            ambient = light.ambient;
            result[`${lightBaseName}Color`] = {
              type: WebGLConstants_default.FLOAT_VEC3,
              value: ambient.color
            };
            break;
          case "directional":
            directional = light.directional;
            result[`${lightBaseName}Color`] = {
              type: WebGLConstants_default.FLOAT_VEC3,
              value: directional.color
            };
            if (defined_default(light.node)) {
              result[`${lightBaseName}Transform`] = {
                node: light.node,
                semantic: "MODELVIEW",
                type: WebGLConstants_default.FLOAT_MAT4
              };
            }
            break;
          case "point":
            point = light.point;
            result[`${lightBaseName}Color`] = {
              type: WebGLConstants_default.FLOAT_VEC3,
              value: point.color
            };
            if (defined_default(light.node)) {
              result[`${lightBaseName}Transform`] = {
                node: light.node,
                semantic: "MODELVIEW",
                type: WebGLConstants_default.FLOAT_MAT4
              };
            }
            result[`${lightBaseName}Attenuation`] = {
              type: WebGLConstants_default.FLOAT_VEC3,
              value: [
                point.constantAttenuation,
                point.linearAttenuation,
                point.quadraticAttenuation
              ]
            };
            break;
          case "spot":
            spot = light.spot;
            result[`${lightBaseName}Color`] = {
              type: WebGLConstants_default.FLOAT_VEC3,
              value: spot.color
            };
            if (defined_default(light.node)) {
              result[`${lightBaseName}Transform`] = {
                node: light.node,
                semantic: "MODELVIEW",
                type: WebGLConstants_default.FLOAT_MAT4
              };
              result[`${lightBaseName}InverseTransform`] = {
                node: light.node,
                semantic: "MODELVIEWINVERSE",
                type: WebGLConstants_default.FLOAT_MAT4,
                useInFragment: true
              };
            }
            result[`${lightBaseName}Attenuation`] = {
              type: WebGLConstants_default.FLOAT_VEC3,
              value: [
                spot.constantAttenuation,
                spot.linearAttenuation,
                spot.quadraticAttenuation
              ]
            };
            result[`${lightBaseName}FallOff`] = {
              type: WebGLConstants_default.FLOAT_VEC2,
              value: [spot.fallOffAngle, spot.fallOffExponent]
            };
            break;
        }
        ++lightCount;
      }
    }
  }
  return result;
}
function generateTechnique(gltf, techniquesWebgl, primitiveInfo, khrMaterialsCommon, lightParameters, addBatchIdToGeneratedShaders) {
  if (!defined_default(khrMaterialsCommon)) {
    khrMaterialsCommon = {};
  }
  addBatchIdToGeneratedShaders = defaultValue_default(
    addBatchIdToGeneratedShaders,
    false
  );
  const techniques = techniquesWebgl.techniques;
  const shaders = techniquesWebgl.shaders;
  const programs = techniquesWebgl.programs;
  const lightingModel = khrMaterialsCommon.technique.toUpperCase();
  let lights;
  if (defined_default(gltf.extensions) && defined_default(gltf.extensions.KHR_materials_common)) {
    lights = gltf.extensions.KHR_materials_common.lights;
  }
  const parameterValues = khrMaterialsCommon.values;
  const jointCount = defaultValue_default(khrMaterialsCommon.jointCount, 0);
  let skinningInfo;
  let hasSkinning = false;
  let hasVertexColors = false;
  if (defined_default(primitiveInfo)) {
    skinningInfo = primitiveInfo.skinning;
    hasSkinning = skinningInfo.skinned;
    hasVertexColors = primitiveInfo.hasVertexColors;
  }
  let vertexShader = "precision highp float;\n";
  let fragmentShader = "precision highp float;\n";
  const hasNormals = lightingModel !== "CONSTANT";
  const techniqueUniforms = {
    u_modelViewMatrix: {
      semantic: usesExtension_default(gltf, "CESIUM_RTC") ? "CESIUM_RTC_MODELVIEW" : "MODELVIEW",
      type: WebGLConstants_default.FLOAT_MAT4
    },
    u_projectionMatrix: {
      semantic: "PROJECTION",
      type: WebGLConstants_default.FLOAT_MAT4
    }
  };
  if (hasNormals) {
    techniqueUniforms.u_normalMatrix = {
      semantic: "MODELVIEWINVERSETRANSPOSE",
      type: WebGLConstants_default.FLOAT_MAT3
    };
  }
  if (hasSkinning) {
    techniqueUniforms.u_jointMatrix = {
      count: jointCount,
      semantic: "JOINTMATRIX",
      type: WebGLConstants_default.FLOAT_MAT4
    };
  }
  let uniformName;
  let hasTexCoords = false;
  for (const name in parameterValues) {
    if (parameterValues.hasOwnProperty(name) && name !== "transparent" && name !== "doubleSided") {
      const uniformType = getKHRMaterialsCommonValueType(
        name,
        parameterValues[name]
      );
      uniformName = `u_${name.toLowerCase()}`;
      if (!hasTexCoords && uniformType === WebGLConstants_default.SAMPLER_2D) {
        hasTexCoords = true;
      }
      techniqueUniforms[uniformName] = {
        type: uniformType
      };
    }
  }
  if (defined_default(techniqueUniforms.u_diffuse)) {
    techniqueUniforms.u_diffuse.semantic = "_3DTILESDIFFUSE";
  }
  if (defined_default(lightParameters)) {
    for (const lightParamName in lightParameters) {
      if (lightParameters.hasOwnProperty(lightParamName)) {
        uniformName = `u_${lightParamName}`;
        techniqueUniforms[uniformName] = lightParameters[lightParamName];
      }
    }
  }
  for (uniformName in techniqueUniforms) {
    if (techniqueUniforms.hasOwnProperty(uniformName)) {
      const uniform = techniqueUniforms[uniformName];
      const arraySize = defined_default(uniform.count) ? `[${uniform.count}]` : "";
      if (uniform.type !== WebGLConstants_default.FLOAT_MAT3 && uniform.type !== WebGLConstants_default.FLOAT_MAT4 || uniform.useInFragment) {
        fragmentShader += `uniform ${webGLConstantToGlslType_default(
          uniform.type
        )} ${uniformName}${arraySize};
`;
        delete uniform.useInFragment;
      } else {
        vertexShader += `uniform ${webGLConstantToGlslType_default(
          uniform.type
        )} ${uniformName}${arraySize};
`;
      }
    }
  }
  let vertexShaderMain = "";
  if (hasSkinning) {
    vertexShaderMain += "    mat4 skinMatrix =\n        a_weight.x * u_jointMatrix[int(a_joint.x)] +\n        a_weight.y * u_jointMatrix[int(a_joint.y)] +\n        a_weight.z * u_jointMatrix[int(a_joint.z)] +\n        a_weight.w * u_jointMatrix[int(a_joint.w)];\n";
  }
  const techniqueAttributes = {
    a_position: {
      semantic: "POSITION"
    }
  };
  vertexShader += "attribute vec3 a_position;\n";
  vertexShader += "varying vec3 v_positionEC;\n";
  if (hasSkinning) {
    vertexShaderMain += "  vec4 pos = u_modelViewMatrix * skinMatrix * vec4(a_position,1.0);\n";
  } else {
    vertexShaderMain += "  vec4 pos = u_modelViewMatrix * vec4(a_position,1.0);\n";
  }
  vertexShaderMain += "  v_positionEC = pos.xyz;\n";
  vertexShaderMain += "  gl_Position = u_projectionMatrix * pos;\n";
  fragmentShader += "varying vec3 v_positionEC;\n";
  if (hasNormals) {
    techniqueAttributes.a_normal = {
      semantic: "NORMAL"
    };
    vertexShader += "attribute vec3 a_normal;\n";
    vertexShader += "varying vec3 v_normal;\n";
    if (hasSkinning) {
      vertexShaderMain += "  v_normal = u_normalMatrix * mat3(skinMatrix) * a_normal;\n";
    } else {
      vertexShaderMain += "  v_normal = u_normalMatrix * a_normal;\n";
    }
    fragmentShader += "varying vec3 v_normal;\n";
  }
  let v_texcoord;
  if (hasTexCoords) {
    techniqueAttributes.a_texcoord_0 = {
      semantic: "TEXCOORD_0"
    };
    v_texcoord = "v_texcoord_0";
    vertexShader += "attribute vec2 a_texcoord_0;\n";
    vertexShader += `varying vec2 ${v_texcoord};
`;
    vertexShaderMain += `  ${v_texcoord} = a_texcoord_0;
`;
    fragmentShader += `varying vec2 ${v_texcoord};
`;
  }
  if (hasSkinning) {
    techniqueAttributes.a_joint = {
      semantic: "JOINTS_0"
    };
    techniqueAttributes.a_weight = {
      semantic: "WEIGHTS_0"
    };
    vertexShader += "attribute vec4 a_joint;\n";
    vertexShader += "attribute vec4 a_weight;\n";
  }
  if (hasVertexColors) {
    techniqueAttributes.a_vertexColor = {
      semantic: "COLOR_0"
    };
    vertexShader += "attribute vec4 a_vertexColor;\n";
    vertexShader += "varying vec4 v_vertexColor;\n";
    vertexShaderMain += "  v_vertexColor = a_vertexColor;\n";
    fragmentShader += "varying vec4 v_vertexColor;\n";
  }
  if (addBatchIdToGeneratedShaders) {
    techniqueAttributes.a_batchId = {
      semantic: "_BATCHID"
    };
    vertexShader += "attribute float a_batchId;\n";
  }
  const hasSpecular = hasNormals && (lightingModel === "BLINN" || lightingModel === "PHONG") && defined_default(techniqueUniforms.u_specular) && defined_default(techniqueUniforms.u_shininess) && techniqueUniforms.u_shininess > 0;
  let hasNonAmbientLights = false;
  let hasAmbientLights = false;
  let fragmentLightingBlock = "";
  for (const lightName in lights) {
    if (lights.hasOwnProperty(lightName)) {
      const light = lights[lightName];
      const lightType = light.type.toLowerCase();
      const lightBaseName = light.baseName;
      fragmentLightingBlock += "  {\n";
      const lightColorName = `u_${lightBaseName}Color`;
      if (lightType === "ambient") {
        hasAmbientLights = true;
        fragmentLightingBlock += `    ambientLight += ${lightColorName};
`;
      } else if (hasNormals) {
        hasNonAmbientLights = true;
        const varyingDirectionName = `v_${lightBaseName}Direction`;
        const varyingPositionName = `v_${lightBaseName}Position`;
        if (lightType !== "point") {
          vertexShader += `varying vec3 ${varyingDirectionName};
`;
          fragmentShader += `varying vec3 ${varyingDirectionName};
`;
          vertexShaderMain += `  ${varyingDirectionName} = mat3(u_${lightBaseName}Transform) * vec3(0.,0.,1.);
`;
          if (lightType === "directional") {
            fragmentLightingBlock += `    vec3 l = normalize(${varyingDirectionName});
`;
          }
        }
        if (lightType !== "directional") {
          vertexShader += `varying vec3 ${varyingPositionName};
`;
          fragmentShader += `varying vec3 ${varyingPositionName};
`;
          vertexShaderMain += `  ${varyingPositionName} = u_${lightBaseName}Transform[3].xyz;
`;
          fragmentLightingBlock += `    vec3 VP = ${varyingPositionName} - v_positionEC;
`;
          fragmentLightingBlock += "    vec3 l = normalize(VP);\n";
          fragmentLightingBlock += "    float range = length(VP);\n";
          fragmentLightingBlock += `    float attenuation = 1.0 / (u_${lightBaseName}Attenuation.x + `;
          fragmentLightingBlock += `(u_${lightBaseName}Attenuation.y * range) + `;
          fragmentLightingBlock += `(u_${lightBaseName}Attenuation.z * range * range));
`;
        } else {
          fragmentLightingBlock += "    float attenuation = 1.0;\n";
        }
        if (lightType === "spot") {
          fragmentLightingBlock += `    float spotDot = dot(l, normalize(${varyingDirectionName}));
`;
          fragmentLightingBlock += `    if (spotDot < cos(u_${lightBaseName}FallOff.x * 0.5))
`;
          fragmentLightingBlock += "    {\n";
          fragmentLightingBlock += "      attenuation = 0.0;\n";
          fragmentLightingBlock += "    }\n";
          fragmentLightingBlock += "    else\n";
          fragmentLightingBlock += "    {\n";
          fragmentLightingBlock += `        attenuation *= max(0.0, pow(spotDot, u_${lightBaseName}FallOff.y));
`;
          fragmentLightingBlock += "    }\n";
        }
        fragmentLightingBlock += `    diffuseLight += ${lightColorName}* max(dot(normal,l), 0.) * attenuation;
`;
        if (hasSpecular) {
          if (lightingModel === "BLINN") {
            fragmentLightingBlock += "    vec3 h = normalize(l + viewDir);\n";
            fragmentLightingBlock += "    float specularIntensity = max(0., pow(max(dot(normal, h), 0.), u_shininess)) * attenuation;\n";
          } else {
            fragmentLightingBlock += "    vec3 reflectDir = reflect(-l, normal);\n";
            fragmentLightingBlock += "    float specularIntensity = max(0., pow(max(dot(reflectDir, viewDir), 0.), u_shininess)) * attenuation;\n";
          }
          fragmentLightingBlock += `    specularLight += ${lightColorName} * specularIntensity;
`;
        }
      }
      fragmentLightingBlock += "  }\n";
    }
  }
  if (!hasAmbientLights) {
    fragmentLightingBlock += "  ambientLight += vec3(0.2, 0.2, 0.2);\n";
  }
  if (!hasNonAmbientLights && lightingModel !== "CONSTANT") {
    fragmentShader += "#ifdef USE_CUSTOM_LIGHT_COLOR \n";
    fragmentShader += "uniform vec3 gltf_lightColor; \n";
    fragmentShader += "#endif \n";
    fragmentLightingBlock += "#ifndef USE_CUSTOM_LIGHT_COLOR \n";
    fragmentLightingBlock += "    vec3 lightColor = czm_lightColor;\n";
    fragmentLightingBlock += "#else \n";
    fragmentLightingBlock += "    vec3 lightColor = gltf_lightColor;\n";
    fragmentLightingBlock += "#endif \n";
    fragmentLightingBlock += "  vec3 l = normalize(czm_lightDirectionEC);\n";
    const minimumLighting = "0.2";
    fragmentLightingBlock += `  diffuseLight += lightColor * max(dot(normal,l), ${minimumLighting});
`;
    if (hasSpecular) {
      if (lightingModel === "BLINN") {
        fragmentLightingBlock += "  vec3 h = normalize(l + viewDir);\n";
        fragmentLightingBlock += "  float specularIntensity = max(0., pow(max(dot(normal, h), 0.), u_shininess));\n";
      } else {
        fragmentLightingBlock += "  vec3 reflectDir = reflect(-l, normal);\n";
        fragmentLightingBlock += "  float specularIntensity = max(0., pow(max(dot(reflectDir, viewDir), 0.), u_shininess));\n";
      }
      fragmentLightingBlock += "  specularLight += lightColor * specularIntensity;\n";
    }
  }
  vertexShader += "void main(void) {\n";
  vertexShader += vertexShaderMain;
  vertexShader += "}\n";
  fragmentShader += "void main(void) {\n";
  let colorCreationBlock = "  vec3 color = vec3(0.0, 0.0, 0.0);\n";
  if (hasNormals) {
    fragmentShader += "  vec3 normal = normalize(v_normal);\n";
    if (khrMaterialsCommon.doubleSided) {
      fragmentShader += "  if (czm_backFacing())\n";
      fragmentShader += "  {\n";
      fragmentShader += "    normal = -normal;\n";
      fragmentShader += "  }\n";
    }
  }
  let finalColorComputation;
  if (lightingModel !== "CONSTANT") {
    if (defined_default(techniqueUniforms.u_diffuse)) {
      if (techniqueUniforms.u_diffuse.type === WebGLConstants_default.SAMPLER_2D) {
        fragmentShader += `  vec4 diffuse = texture2D(u_diffuse, ${v_texcoord});
`;
      } else {
        fragmentShader += "  vec4 diffuse = u_diffuse;\n";
      }
      fragmentShader += "  vec3 diffuseLight = vec3(0.0, 0.0, 0.0);\n";
      colorCreationBlock += "  color += diffuse.rgb * diffuseLight;\n";
    }
    if (hasSpecular) {
      if (techniqueUniforms.u_specular.type === WebGLConstants_default.SAMPLER_2D) {
        fragmentShader += `  vec3 specular = texture2D(u_specular, ${v_texcoord}).rgb;
`;
      } else {
        fragmentShader += "  vec3 specular = u_specular.rgb;\n";
      }
      fragmentShader += "  vec3 specularLight = vec3(0.0, 0.0, 0.0);\n";
      colorCreationBlock += "  color += specular * specularLight;\n";
    }
    if (defined_default(techniqueUniforms.u_transparency)) {
      finalColorComputation = "  gl_FragColor = vec4(color * diffuse.a * u_transparency, diffuse.a * u_transparency);\n";
    } else {
      finalColorComputation = "  gl_FragColor = vec4(color * diffuse.a, diffuse.a);\n";
    }
  } else if (defined_default(techniqueUniforms.u_transparency)) {
    finalColorComputation = "  gl_FragColor = vec4(color * u_transparency, u_transparency);\n";
  } else {
    finalColorComputation = "  gl_FragColor = vec4(color, 1.0);\n";
  }
  if (hasVertexColors) {
    colorCreationBlock += "  color *= v_vertexColor.rgb;\n";
  }
  if (defined_default(techniqueUniforms.u_emission)) {
    if (techniqueUniforms.u_emission.type === WebGLConstants_default.SAMPLER_2D) {
      fragmentShader += `  vec3 emission = texture2D(u_emission, ${v_texcoord}).rgb;
`;
    } else {
      fragmentShader += "  vec3 emission = u_emission.rgb;\n";
    }
    colorCreationBlock += "  color += emission;\n";
  }
  if (defined_default(techniqueUniforms.u_ambient) || lightingModel !== "CONSTANT") {
    if (defined_default(techniqueUniforms.u_ambient)) {
      if (techniqueUniforms.u_ambient.type === WebGLConstants_default.SAMPLER_2D) {
        fragmentShader += `  vec3 ambient = texture2D(u_ambient, ${v_texcoord}).rgb;
`;
      } else {
        fragmentShader += "  vec3 ambient = u_ambient.rgb;\n";
      }
    } else {
      fragmentShader += "  vec3 ambient = diffuse.rgb;\n";
    }
    colorCreationBlock += "  color += ambient * ambientLight;\n";
  }
  fragmentShader += "  vec3 viewDir = -normalize(v_positionEC);\n";
  fragmentShader += "  vec3 ambientLight = vec3(0.0, 0.0, 0.0);\n";
  fragmentShader += fragmentLightingBlock;
  fragmentShader += colorCreationBlock;
  fragmentShader += finalColorComputation;
  fragmentShader += "}\n";
  const vertexShaderId = addToArray_default(shaders, {
    type: WebGLConstants_default.VERTEX_SHADER,
    extras: {
      _pipeline: {
        source: vertexShader,
        extension: ".glsl"
      }
    }
  });
  const fragmentShaderId = addToArray_default(shaders, {
    type: WebGLConstants_default.FRAGMENT_SHADER,
    extras: {
      _pipeline: {
        source: fragmentShader,
        extension: ".glsl"
      }
    }
  });
  const programId = addToArray_default(programs, {
    fragmentShader: fragmentShaderId,
    vertexShader: vertexShaderId
  });
  const techniqueId = addToArray_default(techniques, {
    attributes: techniqueAttributes,
    program: programId,
    uniforms: techniqueUniforms
  });
  return techniqueId;
}
function getKHRMaterialsCommonValueType(paramName, paramValue) {
  let value;
  if (defined_default(paramValue.value)) {
    value = paramValue.value;
  } else if (defined_default(paramValue.index)) {
    value = [paramValue.index];
  } else {
    value = paramValue;
  }
  switch (paramName) {
    case "ambient":
      return value.length === 1 ? WebGLConstants_default.SAMPLER_2D : WebGLConstants_default.FLOAT_VEC4;
    case "diffuse":
      return value.length === 1 ? WebGLConstants_default.SAMPLER_2D : WebGLConstants_default.FLOAT_VEC4;
    case "emission":
      return value.length === 1 ? WebGLConstants_default.SAMPLER_2D : WebGLConstants_default.FLOAT_VEC4;
    case "specular":
      return value.length === 1 ? WebGLConstants_default.SAMPLER_2D : WebGLConstants_default.FLOAT_VEC4;
    case "shininess":
      return WebGLConstants_default.FLOAT;
    case "transparency":
      return WebGLConstants_default.FLOAT;
    case "transparent":
      return WebGLConstants_default.BOOL;
    case "doubleSided":
      return WebGLConstants_default.BOOL;
  }
}
function getTechniqueKey(khrMaterialsCommon, primitiveInfo) {
  let techniqueKey = "";
  techniqueKey += `technique:${khrMaterialsCommon.technique};`;
  const values = khrMaterialsCommon.values;
  const keys = Object.keys(values).sort();
  const keysCount = keys.length;
  for (let i2 = 0; i2 < keysCount; ++i2) {
    const name = keys[i2];
    if (values.hasOwnProperty(name)) {
      techniqueKey += `${name}:${getKHRMaterialsCommonValueType(
        name,
        values[name]
      )}`;
      techniqueKey += ";";
    }
  }
  const jointCount = defaultValue_default(khrMaterialsCommon.jointCount, 0);
  techniqueKey += `${jointCount.toString()};`;
  if (defined_default(primitiveInfo)) {
    const skinningInfo = primitiveInfo.skinning;
    if (jointCount > 0) {
      techniqueKey += `${skinningInfo.type};`;
    }
    techniqueKey += primitiveInfo.hasVertexColors;
  }
  return techniqueKey;
}
function lightDefaults(gltf) {
  const khrMaterialsCommon = gltf.extensions.KHR_materials_common;
  if (!defined_default(khrMaterialsCommon) || !defined_default(khrMaterialsCommon.lights)) {
    return;
  }
  const lights = khrMaterialsCommon.lights;
  const lightsLength = lights.length;
  for (let lightId = 0; lightId < lightsLength; lightId++) {
    const light = lights[lightId];
    if (light.type === "ambient") {
      if (!defined_default(light.ambient)) {
        light.ambient = {};
      }
      const ambientLight = light.ambient;
      if (!defined_default(ambientLight.color)) {
        ambientLight.color = [1, 1, 1];
      }
    } else if (light.type === "directional") {
      if (!defined_default(light.directional)) {
        light.directional = {};
      }
      const directionalLight = light.directional;
      if (!defined_default(directionalLight.color)) {
        directionalLight.color = [1, 1, 1];
      }
    } else if (light.type === "point") {
      if (!defined_default(light.point)) {
        light.point = {};
      }
      const pointLight = light.point;
      if (!defined_default(pointLight.color)) {
        pointLight.color = [1, 1, 1];
      }
      pointLight.constantAttenuation = defaultValue_default(
        pointLight.constantAttenuation,
        1
      );
      pointLight.linearAttenuation = defaultValue_default(
        pointLight.linearAttenuation,
        0
      );
      pointLight.quadraticAttenuation = defaultValue_default(
        pointLight.quadraticAttenuation,
        0
      );
    } else if (light.type === "spot") {
      if (!defined_default(light.spot)) {
        light.spot = {};
      }
      const spotLight = light.spot;
      if (!defined_default(spotLight.color)) {
        spotLight.color = [1, 1, 1];
      }
      spotLight.constantAttenuation = defaultValue_default(
        spotLight.constantAttenuation,
        1
      );
      spotLight.fallOffAngle = defaultValue_default(spotLight.fallOffAngle, 3.14159265);
      spotLight.fallOffExponent = defaultValue_default(spotLight.fallOffExponent, 0);
      spotLight.linearAttenuation = defaultValue_default(
        spotLight.linearAttenuation,
        0
      );
      spotLight.quadraticAttenuation = defaultValue_default(
        spotLight.quadraticAttenuation,
        0
      );
    }
  }
}
var processModelMaterialsCommon_default = processModelMaterialsCommon;

// node_modules/cesium/Source/Scene/processPbrMaterials.js
function processPbrMaterials(gltf, options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (usesExtension_default(gltf, "KHR_techniques_webgl")) {
    return gltf;
  }
  if (!defined_default(gltf.materials) || gltf.materials.length === 0) {
    return gltf;
  }
  if (!defined_default(gltf.extensions)) {
    gltf.extensions = {};
  }
  if (!defined_default(gltf.extensionsUsed)) {
    gltf.extensionsUsed = [];
  }
  if (!defined_default(gltf.extensionsRequired)) {
    gltf.extensionsRequired = [];
  }
  gltf.extensions.KHR_techniques_webgl = {
    programs: [],
    shaders: [],
    techniques: []
  };
  gltf.extensionsUsed.push("KHR_techniques_webgl");
  gltf.extensionsRequired.push("KHR_techniques_webgl");
  const primitiveByMaterial = ModelUtility_default.splitIncompatibleMaterials(gltf);
  ForEach_default.material(gltf, function(material, materialIndex) {
    const generatedMaterialValues = {};
    const technique = generateTechnique2(
      gltf,
      material,
      materialIndex,
      generatedMaterialValues,
      primitiveByMaterial,
      options
    );
    if (!defined_default(material.extensions)) {
      material.extensions = {};
    }
    material.extensions.KHR_techniques_webgl = {
      values: generatedMaterialValues,
      technique
    };
  });
  ModelUtility_default.ensureSemanticExistence(gltf);
  return gltf;
}
function isSpecularGlossinessMaterial(material) {
  return defined_default(material.extensions) && defined_default(material.extensions.KHR_materials_pbrSpecularGlossiness);
}
function addTextureCoordinates(gltf, textureName, generatedMaterialValues, defaultTexCoord, result) {
  let texCoord;
  const texInfo = generatedMaterialValues[textureName];
  if (defined_default(texInfo) && defined_default(texInfo.texCoord) && texInfo.texCoord === 1) {
    defaultTexCoord = defaultTexCoord.replace("0", "1");
  }
  if (defined_default(generatedMaterialValues[`${textureName}Offset`])) {
    texCoord = `${textureName}Coord`;
    result.fragmentShaderMain += `    vec2 ${texCoord} = computeTexCoord(${defaultTexCoord}, ${textureName}Offset, ${textureName}Rotation, ${textureName}Scale);
`;
  } else {
    texCoord = defaultTexCoord;
  }
  return texCoord;
}
var DEFAULT_TEXTURE_OFFSET = [0, 0];
var DEFAULT_TEXTURE_ROTATION = [0];
var DEFAULT_TEXTURE_SCALE = [1, 1];
function handleKHRTextureTransform(parameterName, value, generatedMaterialValues) {
  if (parameterName.indexOf("Texture") === -1 || !defined_default(value.extensions) || !defined_default(value.extensions.KHR_texture_transform)) {
    return;
  }
  const uniformName = `u_${parameterName}`;
  const extension = value.extensions.KHR_texture_transform;
  generatedMaterialValues[`${uniformName}Offset`] = defaultValue_default(
    extension.offset,
    DEFAULT_TEXTURE_OFFSET
  );
  generatedMaterialValues[`${uniformName}Rotation`] = defaultValue_default(
    extension.rotation,
    DEFAULT_TEXTURE_ROTATION
  );
  generatedMaterialValues[`${uniformName}Scale`] = defaultValue_default(
    extension.scale,
    DEFAULT_TEXTURE_SCALE
  );
  if (defined_default(value.texCoord) && defined_default(extension.texCoord)) {
    generatedMaterialValues[uniformName].texCoord = extension.texCoord;
  }
}
function generateTechnique2(gltf, material, materialIndex, generatedMaterialValues, primitiveByMaterial, options) {
  const addBatchIdToGeneratedShaders = defaultValue_default(
    options.addBatchIdToGeneratedShaders,
    false
  );
  const techniquesWebgl = gltf.extensions.KHR_techniques_webgl;
  const techniques = techniquesWebgl.techniques;
  const shaders = techniquesWebgl.shaders;
  const programs = techniquesWebgl.programs;
  const useSpecGloss = isSpecularGlossinessMaterial(material);
  let uniformName;
  let parameterName;
  let value;
  const pbrMetallicRoughness = material.pbrMetallicRoughness;
  if (defined_default(pbrMetallicRoughness) && !useSpecGloss) {
    for (parameterName in pbrMetallicRoughness) {
      if (pbrMetallicRoughness.hasOwnProperty(parameterName)) {
        value = pbrMetallicRoughness[parameterName];
        uniformName = `u_${parameterName}`;
        generatedMaterialValues[uniformName] = value;
        handleKHRTextureTransform(
          parameterName,
          value,
          generatedMaterialValues
        );
      }
    }
  }
  if (useSpecGloss) {
    const pbrSpecularGlossiness = material.extensions.KHR_materials_pbrSpecularGlossiness;
    for (parameterName in pbrSpecularGlossiness) {
      if (pbrSpecularGlossiness.hasOwnProperty(parameterName)) {
        value = pbrSpecularGlossiness[parameterName];
        uniformName = `u_${parameterName}`;
        generatedMaterialValues[uniformName] = value;
        handleKHRTextureTransform(
          parameterName,
          value,
          generatedMaterialValues
        );
      }
    }
  }
  for (const additional in material) {
    if (material.hasOwnProperty(additional) && (additional.indexOf("Texture") >= 0 || additional.indexOf("Factor") >= 0)) {
      value = material[additional];
      uniformName = `u_${additional}`;
      generatedMaterialValues[uniformName] = value;
      handleKHRTextureTransform(additional, value, generatedMaterialValues);
    }
  }
  let vertexShader = "precision highp float;\n";
  let fragmentShader = "precision highp float;\n";
  let skin;
  if (defined_default(gltf.skins)) {
    skin = gltf.skins[0];
  }
  const joints = defined_default(skin) ? skin.joints : [];
  const jointCount = joints.length;
  const primitiveInfo = primitiveByMaterial[materialIndex];
  let skinningInfo;
  let hasSkinning = false;
  let hasVertexColors = false;
  let hasMorphTargets = false;
  let hasNormals = false;
  let hasTangents = false;
  let hasTexCoords = false;
  let hasTexCoord1 = false;
  let hasOutline = false;
  let isUnlit = false;
  if (defined_default(primitiveInfo)) {
    skinningInfo = primitiveInfo.skinning;
    hasSkinning = skinningInfo.skinned && joints.length > 0;
    hasVertexColors = primitiveInfo.hasVertexColors;
    hasMorphTargets = primitiveInfo.hasMorphTargets;
    hasNormals = primitiveInfo.hasNormals;
    hasTangents = primitiveInfo.hasTangents;
    hasTexCoords = primitiveInfo.hasTexCoords;
    hasTexCoord1 = primitiveInfo.hasTexCoord1;
    hasOutline = primitiveInfo.hasOutline;
  }
  let morphTargets;
  if (hasMorphTargets) {
    ForEach_default.mesh(gltf, function(mesh2) {
      ForEach_default.meshPrimitive(mesh2, function(primitive) {
        if (primitive.material === materialIndex) {
          const targets = primitive.targets;
          if (defined_default(targets)) {
            morphTargets = targets;
          }
        }
      });
    });
  }
  const techniqueUniforms = {
    u_modelViewMatrix: {
      semantic: usesExtension_default(gltf, "CESIUM_RTC") ? "CESIUM_RTC_MODELVIEW" : "MODELVIEW",
      type: WebGLConstants_default.FLOAT_MAT4
    },
    u_projectionMatrix: {
      semantic: "PROJECTION",
      type: WebGLConstants_default.FLOAT_MAT4
    }
  };
  if (defined_default(material.extensions) && defined_default(material.extensions.KHR_materials_unlit)) {
    isUnlit = true;
  }
  if (hasNormals) {
    techniqueUniforms.u_normalMatrix = {
      semantic: "MODELVIEWINVERSETRANSPOSE",
      type: WebGLConstants_default.FLOAT_MAT3
    };
  }
  if (hasSkinning) {
    techniqueUniforms.u_jointMatrix = {
      count: jointCount,
      semantic: "JOINTMATRIX",
      type: WebGLConstants_default.FLOAT_MAT4
    };
  }
  if (hasMorphTargets) {
    techniqueUniforms.u_morphWeights = {
      count: morphTargets.length,
      semantic: "MORPHWEIGHTS",
      type: WebGLConstants_default.FLOAT
    };
  }
  const alphaMode = material.alphaMode;
  if (defined_default(alphaMode) && alphaMode === "MASK") {
    techniqueUniforms.u_alphaCutoff = {
      semantic: "ALPHACUTOFF",
      type: WebGLConstants_default.FLOAT
    };
  }
  for (uniformName in generatedMaterialValues) {
    if (generatedMaterialValues.hasOwnProperty(uniformName)) {
      techniqueUniforms[uniformName] = {
        type: getPBRValueType(uniformName)
      };
    }
  }
  const baseColorUniform = defaultValue_default(
    techniqueUniforms.u_baseColorTexture,
    techniqueUniforms.u_baseColorFactor
  );
  if (defined_default(baseColorUniform)) {
    baseColorUniform.semantic = "_3DTILESDIFFUSE";
  }
  for (uniformName in techniqueUniforms) {
    if (techniqueUniforms.hasOwnProperty(uniformName)) {
      const uniform = techniqueUniforms[uniformName];
      const arraySize = defined_default(uniform.count) ? `[${uniform.count}]` : "";
      if (uniform.type !== WebGLConstants_default.FLOAT_MAT3 && uniform.type !== WebGLConstants_default.FLOAT_MAT4 && uniformName !== "u_morphWeights" || uniform.useInFragment) {
        fragmentShader += `uniform ${webGLConstantToGlslType_default(
          uniform.type
        )} ${uniformName}${arraySize};
`;
        delete uniform.useInFragment;
      } else {
        vertexShader += `uniform ${webGLConstantToGlslType_default(
          uniform.type
        )} ${uniformName}${arraySize};
`;
      }
    }
  }
  if (hasOutline) {
    fragmentShader += "uniform sampler2D u_outlineTexture;\n";
  }
  let vertexShaderMain = "";
  if (hasSkinning) {
    vertexShaderMain += "    mat4 skinMatrix =\n        a_weight.x * u_jointMatrix[int(a_joint.x)] +\n        a_weight.y * u_jointMatrix[int(a_joint.y)] +\n        a_weight.z * u_jointMatrix[int(a_joint.z)] +\n        a_weight.w * u_jointMatrix[int(a_joint.w)];\n";
  }
  const techniqueAttributes = {
    a_position: {
      semantic: "POSITION"
    }
  };
  if (hasOutline) {
    techniqueAttributes.a_outlineCoordinates = {
      semantic: "_OUTLINE_COORDINATES"
    };
  }
  vertexShader += "attribute vec3 a_position;\n";
  if (hasNormals) {
    vertexShader += "varying vec3 v_positionEC;\n";
  }
  if (hasOutline) {
    vertexShader += "attribute vec3 a_outlineCoordinates;\n";
    vertexShader += "varying vec3 v_outlineCoordinates;\n";
  }
  vertexShaderMain += "    vec3 weightedPosition = a_position;\n";
  if (hasNormals) {
    vertexShaderMain += "    vec3 weightedNormal = a_normal;\n";
  }
  if (hasTangents) {
    vertexShaderMain += "    vec4 weightedTangent = a_tangent;\n";
  }
  if (hasMorphTargets) {
    for (let k = 0; k < morphTargets.length; k++) {
      const targetAttributes = morphTargets[k];
      for (const targetAttribute in targetAttributes) {
        if (targetAttributes.hasOwnProperty(targetAttribute) && targetAttribute !== "extras") {
          const attributeName = `a_${targetAttribute}_${k}`;
          techniqueAttributes[attributeName] = {
            semantic: `${targetAttribute}_${k}`
          };
          vertexShader += `attribute vec3 ${attributeName};
`;
          if (targetAttribute === "POSITION") {
            vertexShaderMain += `    weightedPosition += u_morphWeights[${k}] * ${attributeName};
`;
          } else if (targetAttribute === "NORMAL") {
            vertexShaderMain += `    weightedNormal += u_morphWeights[${k}] * ${attributeName};
`;
          } else if (hasTangents && targetAttribute === "TANGENT") {
            vertexShaderMain += `    weightedTangent.xyz += u_morphWeights[${k}] * ${attributeName};
`;
          }
        }
      }
    }
  }
  if (hasSkinning) {
    vertexShaderMain += "    vec4 position = skinMatrix * vec4(weightedPosition, 1.0);\n";
  } else {
    vertexShaderMain += "    vec4 position = vec4(weightedPosition, 1.0);\n";
  }
  vertexShaderMain += "    position = u_modelViewMatrix * position;\n";
  if (hasNormals) {
    vertexShaderMain += "    v_positionEC = position.xyz;\n";
  }
  vertexShaderMain += "    gl_Position = u_projectionMatrix * position;\n";
  if (hasOutline) {
    vertexShaderMain += "    v_outlineCoordinates = a_outlineCoordinates;\n";
  }
  if (hasNormals) {
    techniqueAttributes.a_normal = {
      semantic: "NORMAL"
    };
    vertexShader += "attribute vec3 a_normal;\n";
    if (!isUnlit) {
      vertexShader += "varying vec3 v_normal;\n";
      if (hasSkinning) {
        vertexShaderMain += "    v_normal = u_normalMatrix * mat3(skinMatrix) * weightedNormal;\n";
      } else {
        vertexShaderMain += "    v_normal = u_normalMatrix * weightedNormal;\n";
      }
      fragmentShader += "varying vec3 v_normal;\n";
    }
    fragmentShader += "varying vec3 v_positionEC;\n";
  }
  if (hasTangents) {
    techniqueAttributes.a_tangent = {
      semantic: "TANGENT"
    };
    vertexShader += "attribute vec4 a_tangent;\n";
    vertexShader += "varying vec4 v_tangent;\n";
    vertexShaderMain += "    v_tangent.xyz = u_normalMatrix * weightedTangent.xyz;\n";
    vertexShaderMain += "    v_tangent.w = weightedTangent.w;\n";
    fragmentShader += "varying vec4 v_tangent;\n";
  }
  if (hasOutline) {
    fragmentShader += "varying vec3 v_outlineCoordinates;\n";
  }
  let fragmentShaderMain = "";
  let v_texCoord;
  let normalTexCoord;
  let baseColorTexCoord;
  let specularGlossinessTexCoord;
  let diffuseTexCoord;
  let metallicRoughnessTexCoord;
  let occlusionTexCoord;
  let emissiveTexCoord;
  if (hasTexCoords) {
    techniqueAttributes.a_texcoord_0 = {
      semantic: "TEXCOORD_0"
    };
    v_texCoord = "v_texcoord_0";
    vertexShader += "attribute vec2 a_texcoord_0;\n";
    vertexShader += `varying vec2 ${v_texCoord};
`;
    vertexShaderMain += `    ${v_texCoord} = a_texcoord_0;
`;
    fragmentShader += `varying vec2 ${v_texCoord};
`;
    if (hasTexCoord1) {
      techniqueAttributes.a_texcoord_1 = {
        semantic: "TEXCOORD_1"
      };
      const v_texCoord1 = v_texCoord.replace("0", "1");
      vertexShader += "attribute vec2 a_texcoord_1;\n";
      vertexShader += `varying vec2 ${v_texCoord1};
`;
      vertexShaderMain += `    ${v_texCoord1} = a_texcoord_1;
`;
      fragmentShader += `varying vec2 ${v_texCoord1};
`;
    }
    const result = {
      fragmentShaderMain
    };
    normalTexCoord = addTextureCoordinates(
      gltf,
      "u_normalTexture",
      generatedMaterialValues,
      v_texCoord,
      result
    );
    baseColorTexCoord = addTextureCoordinates(
      gltf,
      "u_baseColorTexture",
      generatedMaterialValues,
      v_texCoord,
      result
    );
    specularGlossinessTexCoord = addTextureCoordinates(
      gltf,
      "u_specularGlossinessTexture",
      generatedMaterialValues,
      v_texCoord,
      result
    );
    diffuseTexCoord = addTextureCoordinates(
      gltf,
      "u_diffuseTexture",
      generatedMaterialValues,
      v_texCoord,
      result
    );
    metallicRoughnessTexCoord = addTextureCoordinates(
      gltf,
      "u_metallicRoughnessTexture",
      generatedMaterialValues,
      v_texCoord,
      result
    );
    occlusionTexCoord = addTextureCoordinates(
      gltf,
      "u_occlusionTexture",
      generatedMaterialValues,
      v_texCoord,
      result
    );
    emissiveTexCoord = addTextureCoordinates(
      gltf,
      "u_emissiveTexture",
      generatedMaterialValues,
      v_texCoord,
      result
    );
    fragmentShaderMain = result.fragmentShaderMain;
  }
  if (hasSkinning) {
    techniqueAttributes.a_joint = {
      semantic: "JOINTS_0"
    };
    techniqueAttributes.a_weight = {
      semantic: "WEIGHTS_0"
    };
    vertexShader += "attribute vec4 a_joint;\n";
    vertexShader += "attribute vec4 a_weight;\n";
  }
  if (hasVertexColors) {
    techniqueAttributes.a_vertexColor = {
      semantic: "COLOR_0"
    };
    vertexShader += "attribute vec4 a_vertexColor;\n";
    vertexShader += "varying vec4 v_vertexColor;\n";
    vertexShaderMain += "  v_vertexColor = a_vertexColor;\n";
    fragmentShader += "varying vec4 v_vertexColor;\n";
  }
  if (addBatchIdToGeneratedShaders) {
    techniqueAttributes.a_batchId = {
      semantic: "_BATCHID"
    };
    vertexShader += "attribute float a_batchId;\n";
  }
  vertexShader += "void main(void) \n{\n";
  vertexShader += vertexShaderMain;
  vertexShader += "}\n";
  if (hasNormals && !isUnlit) {
    fragmentShader += "const float M_PI = 3.141592653589793;\n";
    fragmentShader += "vec3 lambertianDiffuse(vec3 diffuseColor) \n{\n    return diffuseColor / M_PI;\n}\n\n";
    fragmentShader += "vec3 fresnelSchlick2(vec3 f0, vec3 f90, float VdotH) \n{\n    return f0 + (f90 - f0) * pow(clamp(1.0 - VdotH, 0.0, 1.0), 5.0);\n}\n\n";
    fragmentShader += "vec3 fresnelSchlick(float metalness, float VdotH) \n{\n    return metalness + (vec3(1.0) - metalness) * pow(1.0 - VdotH, 5.0);\n}\n\n";
    fragmentShader += "float smithVisibilityG1(float NdotV, float roughness) \n{\n    float k = (roughness + 1.0) * (roughness + 1.0) / 8.0;\n    return NdotV / (NdotV * (1.0 - k) + k);\n}\n\n";
    fragmentShader += "float smithVisibilityGGX(float roughness, float NdotL, float NdotV) \n{\n    return smithVisibilityG1(NdotL, roughness) * smithVisibilityG1(NdotV, roughness);\n}\n\n";
    fragmentShader += "float GGX(float roughness, float NdotH) \n{\n    float roughnessSquared = roughness * roughness;\n    float f = (NdotH * roughnessSquared - NdotH) * NdotH + 1.0;\n    return roughnessSquared / (M_PI * f * f);\n}\n\n";
  }
  fragmentShader += "vec3 SRGBtoLINEAR3(vec3 srgbIn) \n{\n    return pow(srgbIn, vec3(2.2));\n}\n\n";
  fragmentShader += "vec4 SRGBtoLINEAR4(vec4 srgbIn) \n{\n    vec3 linearOut = pow(srgbIn.rgb, vec3(2.2));\n    return vec4(linearOut, srgbIn.a);\n}\n\n";
  fragmentShader += "vec3 applyTonemapping(vec3 linearIn) \n{\n#ifndef HDR \n    return czm_acesTonemapping(linearIn);\n#else \n    return linearIn;\n#endif \n}\n\n";
  fragmentShader += "vec3 LINEARtoSRGB(vec3 linearIn) \n{\n#ifndef HDR \n    return pow(linearIn, vec3(1.0/2.2));\n#else \n    return linearIn;\n#endif \n}\n\n";
  fragmentShader += "vec2 computeTexCoord(vec2 texCoords, vec2 offset, float rotation, vec2 scale) \n{\n    rotation = -rotation; \n    mat3 transform = mat3(\n        cos(rotation) * scale.x, sin(rotation) * scale.x, 0.0, \n       -sin(rotation) * scale.y, cos(rotation) * scale.y, 0.0, \n        offset.x, offset.y, 1.0); \n    vec2 transformedTexCoords = (transform * vec3(fract(texCoords), 1.0)).xy; \n    return transformedTexCoords; \n}\n\n";
  fragmentShader += "#ifdef USE_IBL_LIGHTING \n";
  fragmentShader += "uniform vec2 gltf_iblFactor; \n";
  fragmentShader += "#endif \n";
  fragmentShader += "#ifdef USE_CUSTOM_LIGHT_COLOR \n";
  fragmentShader += "uniform vec3 gltf_lightColor; \n";
  fragmentShader += "#endif \n";
  fragmentShader += "void main(void) \n{\n";
  fragmentShader += fragmentShaderMain;
  if (hasNormals && !isUnlit) {
    fragmentShader += "    vec3 ng = normalize(v_normal);\n";
    fragmentShader += "    vec3 positionWC = vec3(czm_inverseView * vec4(v_positionEC, 1.0));\n";
    if (defined_default(generatedMaterialValues.u_normalTexture)) {
      if (hasTangents) {
        fragmentShader += "    vec3 t = normalize(v_tangent.xyz);\n";
        fragmentShader += "    vec3 b = normalize(cross(ng, t) * v_tangent.w);\n";
        fragmentShader += "    mat3 tbn = mat3(t, b, ng);\n";
        fragmentShader += `    vec3 n = texture2D(u_normalTexture, ${normalTexCoord}).rgb;
`;
        fragmentShader += "    n = normalize(tbn * (2.0 * n - 1.0));\n";
      } else {
        fragmentShader = `${"#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n#endif\n"}${fragmentShader}`;
        fragmentShader += "#ifdef GL_OES_standard_derivatives\n";
        fragmentShader += "    vec3 pos_dx = dFdx(v_positionEC);\n";
        fragmentShader += "    vec3 pos_dy = dFdy(v_positionEC);\n";
        fragmentShader += `    vec3 tex_dx = dFdx(vec3(${normalTexCoord},0.0));
`;
        fragmentShader += `    vec3 tex_dy = dFdy(vec3(${normalTexCoord},0.0));
`;
        fragmentShader += "    vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);\n";
        fragmentShader += "    t = normalize(t - ng * dot(ng, t));\n";
        fragmentShader += "    vec3 b = normalize(cross(ng, t));\n";
        fragmentShader += "    mat3 tbn = mat3(t, b, ng);\n";
        fragmentShader += `    vec3 n = texture2D(u_normalTexture, ${normalTexCoord}).rgb;
`;
        fragmentShader += "    n = normalize(tbn * (2.0 * n - 1.0));\n";
        fragmentShader += "#else\n";
        fragmentShader += "    vec3 n = ng;\n";
        fragmentShader += "#endif\n";
      }
    } else {
      fragmentShader += "    vec3 n = ng;\n";
    }
    if (material.doubleSided) {
      fragmentShader += "    if (czm_backFacing())\n";
      fragmentShader += "    {\n";
      fragmentShader += "        n = -n;\n";
      fragmentShader += "    }\n";
    }
  }
  if (defined_default(generatedMaterialValues.u_baseColorTexture)) {
    fragmentShader += `    vec4 baseColorWithAlpha = SRGBtoLINEAR4(texture2D(u_baseColorTexture, ${baseColorTexCoord}));
`;
    if (defined_default(generatedMaterialValues.u_baseColorFactor)) {
      fragmentShader += "    baseColorWithAlpha *= u_baseColorFactor;\n";
    }
  } else if (defined_default(generatedMaterialValues.u_baseColorFactor)) {
    fragmentShader += "    vec4 baseColorWithAlpha = u_baseColorFactor;\n";
  } else {
    fragmentShader += "    vec4 baseColorWithAlpha = vec4(1.0);\n";
  }
  if (hasVertexColors) {
    fragmentShader += "    baseColorWithAlpha *= v_vertexColor;\n";
  }
  fragmentShader += "    vec3 baseColor = baseColorWithAlpha.rgb;\n";
  if (hasNormals && !isUnlit) {
    if (useSpecGloss) {
      if (defined_default(generatedMaterialValues.u_specularGlossinessTexture)) {
        fragmentShader += `    vec4 specularGlossiness = SRGBtoLINEAR4(texture2D(u_specularGlossinessTexture, ${specularGlossinessTexCoord}));
`;
        fragmentShader += "    vec3 specular = specularGlossiness.rgb;\n";
        fragmentShader += "    float glossiness = specularGlossiness.a;\n";
        if (defined_default(generatedMaterialValues.u_specularFactor)) {
          fragmentShader += "    specular *= u_specularFactor;\n";
        }
        if (defined_default(generatedMaterialValues.u_glossinessFactor)) {
          fragmentShader += "    glossiness *= u_glossinessFactor;\n";
        }
      } else {
        if (defined_default(generatedMaterialValues.u_specularFactor)) {
          fragmentShader += "    vec3 specular = clamp(u_specularFactor, vec3(0.0), vec3(1.0));\n";
        } else {
          fragmentShader += "    vec3 specular = vec3(1.0);\n";
        }
        if (defined_default(generatedMaterialValues.u_glossinessFactor)) {
          fragmentShader += "    float glossiness = clamp(u_glossinessFactor, 0.0, 1.0);\n";
        } else {
          fragmentShader += "    float glossiness = 1.0;\n";
        }
      }
      if (defined_default(generatedMaterialValues.u_diffuseTexture)) {
        fragmentShader += `    vec4 diffuse = SRGBtoLINEAR4(texture2D(u_diffuseTexture, ${diffuseTexCoord}));
`;
        if (defined_default(generatedMaterialValues.u_diffuseFactor)) {
          fragmentShader += "    diffuse *= u_diffuseFactor;\n";
        }
      } else if (defined_default(generatedMaterialValues.u_diffuseFactor)) {
        fragmentShader += "    vec4 diffuse = clamp(u_diffuseFactor, vec4(0.0), vec4(1.0));\n";
      } else {
        fragmentShader += "    vec4 diffuse = vec4(1.0);\n";
      }
      fragmentShader += "    baseColorWithAlpha.a = diffuse.a;\n";
    } else if (defined_default(generatedMaterialValues.u_metallicRoughnessTexture)) {
      fragmentShader += `    vec3 metallicRoughness = texture2D(u_metallicRoughnessTexture, ${metallicRoughnessTexCoord}).rgb;
`;
      fragmentShader += "    float metalness = clamp(metallicRoughness.b, 0.0, 1.0);\n";
      fragmentShader += "    float roughness = clamp(metallicRoughness.g, 0.04, 1.0);\n";
      if (defined_default(generatedMaterialValues.u_metallicFactor)) {
        fragmentShader += "    metalness *= u_metallicFactor;\n";
      }
      if (defined_default(generatedMaterialValues.u_roughnessFactor)) {
        fragmentShader += "    roughness *= u_roughnessFactor;\n";
      }
    } else {
      if (defined_default(generatedMaterialValues.u_metallicFactor)) {
        fragmentShader += "    float metalness = clamp(u_metallicFactor, 0.0, 1.0);\n";
      } else {
        fragmentShader += "    float metalness = 1.0;\n";
      }
      if (defined_default(generatedMaterialValues.u_roughnessFactor)) {
        fragmentShader += "    float roughness = clamp(u_roughnessFactor, 0.04, 1.0);\n";
      } else {
        fragmentShader += "    float roughness = 1.0;\n";
      }
    }
    fragmentShader += "    vec3 v = -normalize(v_positionEC);\n";
    fragmentShader += "#ifndef USE_CUSTOM_LIGHT_COLOR \n";
    fragmentShader += "    vec3 lightColorHdr = czm_lightColorHdr;\n";
    fragmentShader += "#else \n";
    fragmentShader += "    vec3 lightColorHdr = gltf_lightColor;\n";
    fragmentShader += "#endif \n";
    fragmentShader += "    vec3 l = normalize(czm_lightDirectionEC);\n";
    fragmentShader += "    vec3 h = normalize(v + l);\n";
    fragmentShader += "    float NdotL = clamp(dot(n, l), 0.001, 1.0);\n";
    fragmentShader += "    float NdotV = abs(dot(n, v)) + 0.001;\n";
    fragmentShader += "    float NdotH = clamp(dot(n, h), 0.0, 1.0);\n";
    fragmentShader += "    float LdotH = clamp(dot(l, h), 0.0, 1.0);\n";
    fragmentShader += "    float VdotH = clamp(dot(v, h), 0.0, 1.0);\n";
    fragmentShader += "    vec3 f0 = vec3(0.04);\n";
    if (useSpecGloss) {
      fragmentShader += "    float roughness = 1.0 - glossiness;\n";
      fragmentShader += "    vec3 diffuseColor = diffuse.rgb * (1.0 - max(max(specular.r, specular.g), specular.b));\n";
      fragmentShader += "    vec3 specularColor = specular;\n";
    } else {
      fragmentShader += "    vec3 diffuseColor = baseColor * (1.0 - metalness) * (1.0 - f0);\n";
      fragmentShader += "    vec3 specularColor = mix(f0, baseColor, metalness);\n";
    }
    fragmentShader += "    float alpha = roughness * roughness;\n";
    fragmentShader += "    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);\n";
    fragmentShader += "    vec3 r90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));\n";
    fragmentShader += "    vec3 r0 = specularColor.rgb;\n";
    fragmentShader += "    vec3 F = fresnelSchlick2(r0, r90, VdotH);\n";
    fragmentShader += "    float G = smithVisibilityGGX(alpha, NdotL, NdotV);\n";
    fragmentShader += "    float D = GGX(alpha, NdotH);\n";
    fragmentShader += "    vec3 diffuseContribution = (1.0 - F) * lambertianDiffuse(diffuseColor);\n";
    fragmentShader += "    vec3 specularContribution = F * G * D / (4.0 * NdotL * NdotV);\n";
    fragmentShader += "    vec3 color = NdotL * lightColorHdr * (diffuseContribution + specularContribution);\n";
    fragmentShader += "#if defined(USE_IBL_LIGHTING) && !defined(DIFFUSE_IBL) && !defined(SPECULAR_IBL) \n";
    fragmentShader += "    vec3 r = normalize(czm_inverseViewRotation * normalize(reflect(v, n)));\n";
    fragmentShader += "    float vertexRadius = length(positionWC);\n";
    fragmentShader += "    float horizonDotNadir = 1.0 - min(1.0, czm_ellipsoidRadii.x / vertexRadius);\n";
    fragmentShader += "    float reflectionDotNadir = dot(r, normalize(positionWC));\n";
    fragmentShader += "    r.x = -r.x;\n";
    fragmentShader += "    r = -normalize(czm_temeToPseudoFixed * r);\n";
    fragmentShader += "    r.x = -r.x;\n";
    fragmentShader += "    float inverseRoughness = 1.04 - roughness;\n";
    fragmentShader += "    inverseRoughness *= inverseRoughness;\n";
    fragmentShader += "    vec3 sceneSkyBox = textureCube(czm_environmentMap, r).rgb * inverseRoughness;\n";
    fragmentShader += "    float atmosphereHeight = 0.05;\n";
    fragmentShader += "    float blendRegionSize = 0.1 * ((1.0 - inverseRoughness) * 8.0 + 1.1 - horizonDotNadir);\n";
    fragmentShader += "    float blendRegionOffset = roughness * -1.0;\n";
    fragmentShader += "    float farAboveHorizon = clamp(horizonDotNadir - blendRegionSize * 0.5 + blendRegionOffset, 1.0e-10 - blendRegionSize, 0.99999);\n";
    fragmentShader += "    float aroundHorizon = clamp(horizonDotNadir + blendRegionSize * 0.5, 1.0e-10 - blendRegionSize, 0.99999);\n";
    fragmentShader += "    float farBelowHorizon = clamp(horizonDotNadir + blendRegionSize * 1.5, 1.0e-10 - blendRegionSize, 0.99999);\n";
    fragmentShader += "    float smoothstepHeight = smoothstep(0.0, atmosphereHeight, horizonDotNadir);\n";
    fragmentShader += "    vec3 belowHorizonColor = mix(vec3(0.1, 0.15, 0.25), vec3(0.4, 0.7, 0.9), smoothstepHeight);\n";
    fragmentShader += "    vec3 nadirColor = belowHorizonColor * 0.5;\n";
    fragmentShader += "    vec3 aboveHorizonColor = mix(vec3(0.9, 1.0, 1.2), belowHorizonColor, roughness * 0.5);\n";
    fragmentShader += "    vec3 blueSkyColor = mix(vec3(0.18, 0.26, 0.48), aboveHorizonColor, reflectionDotNadir * inverseRoughness * 0.5 + 0.75);\n";
    fragmentShader += "    vec3 zenithColor = mix(blueSkyColor, sceneSkyBox, smoothstepHeight);\n";
    fragmentShader += "    vec3 blueSkyDiffuseColor = vec3(0.7, 0.85, 0.9);\n";
    fragmentShader += "    float diffuseIrradianceFromEarth = (1.0 - horizonDotNadir) * (reflectionDotNadir * 0.25 + 0.75) * smoothstepHeight;\n";
    fragmentShader += "    float diffuseIrradianceFromSky = (1.0 - smoothstepHeight) * (1.0 - (reflectionDotNadir * 0.25 + 0.25));\n";
    fragmentShader += "    vec3 diffuseIrradiance = blueSkyDiffuseColor * clamp(diffuseIrradianceFromEarth + diffuseIrradianceFromSky, 0.0, 1.0);\n";
    fragmentShader += "    float notDistantRough = (1.0 - horizonDotNadir * roughness * 0.8);\n";
    fragmentShader += "    vec3 specularIrradiance = mix(zenithColor, aboveHorizonColor, smoothstep(farAboveHorizon, aroundHorizon, reflectionDotNadir) * notDistantRough);\n";
    fragmentShader += "    specularIrradiance = mix(specularIrradiance, belowHorizonColor, smoothstep(aroundHorizon, farBelowHorizon, reflectionDotNadir) * inverseRoughness);\n";
    fragmentShader += "    specularIrradiance = mix(specularIrradiance, nadirColor, smoothstep(farBelowHorizon, 1.0, reflectionDotNadir) * inverseRoughness);\n";
    fragmentShader += "#ifdef USE_SUN_LUMINANCE \n";
    fragmentShader += "    float LdotZenith = clamp(dot(normalize(czm_inverseViewRotation * l), normalize(positionWC * -1.0)), 0.001, 1.0);\n";
    fragmentShader += "    float S = acos(LdotZenith);\n";
    fragmentShader += "    float NdotZenith = clamp(dot(normalize(czm_inverseViewRotation * n), normalize(positionWC * -1.0)), 0.001, 1.0);\n";
    fragmentShader += "    float gamma = acos(NdotL);\n";
    fragmentShader += "    float numerator = ((0.91 + 10.0 * exp(-3.0 * gamma) + 0.45 * pow(NdotL, 2.0)) * (1.0 - exp(-0.32 / NdotZenith)));\n";
    fragmentShader += "    float denominator = (0.91 + 10.0 * exp(-3.0 * S) + 0.45 * pow(LdotZenith,2.0)) * (1.0 - exp(-0.32));\n";
    fragmentShader += "    float luminance = gltf_luminanceAtZenith * (numerator / denominator);\n";
    fragmentShader += "#endif \n";
    fragmentShader += "    vec2 brdfLut = texture2D(czm_brdfLut, vec2(NdotV, roughness)).rg;\n";
    fragmentShader += "    vec3 IBLColor = (diffuseIrradiance * diffuseColor * gltf_iblFactor.x) + (specularIrradiance * SRGBtoLINEAR3(specularColor * brdfLut.x + brdfLut.y) * gltf_iblFactor.y);\n";
    fragmentShader += "    float maximumComponent = max(max(lightColorHdr.x, lightColorHdr.y), lightColorHdr.z);\n";
    fragmentShader += "    vec3 lightColor = lightColorHdr / max(maximumComponent, 1.0);\n";
    fragmentShader += "    IBLColor *= lightColor;\n";
    fragmentShader += "#ifdef USE_SUN_LUMINANCE \n";
    fragmentShader += "    color += IBLColor * luminance;\n";
    fragmentShader += "#else \n";
    fragmentShader += "    color += IBLColor; \n";
    fragmentShader += "#endif \n";
    fragmentShader += "#elif defined(DIFFUSE_IBL) || defined(SPECULAR_IBL) \n";
    fragmentShader += "    const mat3 yUpToZUp = mat3(-1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0); \n";
    fragmentShader += "    vec3 cubeDir = normalize(yUpToZUp * gltf_iblReferenceFrameMatrix * normalize(reflect(-v, n))); \n";
    fragmentShader += "#ifdef DIFFUSE_IBL \n";
    fragmentShader += "#ifdef CUSTOM_SPHERICAL_HARMONICS \n";
    fragmentShader += "    vec3 diffuseIrradiance = czm_sphericalHarmonics(cubeDir, gltf_sphericalHarmonicCoefficients); \n";
    fragmentShader += "#else \n";
    fragmentShader += "    vec3 diffuseIrradiance = czm_sphericalHarmonics(cubeDir, czm_sphericalHarmonicCoefficients); \n";
    fragmentShader += "#endif \n";
    fragmentShader += "#else \n";
    fragmentShader += "    vec3 diffuseIrradiance = vec3(0.0); \n";
    fragmentShader += "#endif \n";
    fragmentShader += "#ifdef SPECULAR_IBL \n";
    fragmentShader += "    vec2 brdfLut = texture2D(czm_brdfLut, vec2(NdotV, roughness)).rg;\n";
    fragmentShader += "#ifdef CUSTOM_SPECULAR_IBL \n";
    fragmentShader += "    vec3 specularIBL = czm_sampleOctahedralProjection(gltf_specularMap, gltf_specularMapSize, cubeDir,  roughness * gltf_maxSpecularLOD, gltf_maxSpecularLOD);\n";
    fragmentShader += "#else \n";
    fragmentShader += "    vec3 specularIBL = czm_sampleOctahedralProjection(czm_specularEnvironmentMaps, czm_specularEnvironmentMapSize, cubeDir,  roughness * czm_specularEnvironmentMapsMaximumLOD, czm_specularEnvironmentMapsMaximumLOD);\n";
    fragmentShader += "#endif \n";
    fragmentShader += "    specularIBL *= F * brdfLut.x + brdfLut.y;\n";
    fragmentShader += "#else \n";
    fragmentShader += "    vec3 specularIBL = vec3(0.0); \n";
    fragmentShader += "#endif \n";
    fragmentShader += "    color += diffuseIrradiance * diffuseColor + specularColor * specularIBL;\n";
    fragmentShader += "#endif \n";
  } else {
    fragmentShader += "    vec3 color = baseColor;\n";
  }
  if (!isUnlit) {
    if (defined_default(generatedMaterialValues.u_occlusionTexture)) {
      fragmentShader += `    color *= texture2D(u_occlusionTexture, ${occlusionTexCoord}).r;
`;
    }
    if (defined_default(generatedMaterialValues.u_emissiveTexture)) {
      fragmentShader += `    vec3 emissive = SRGBtoLINEAR3(texture2D(u_emissiveTexture, ${emissiveTexCoord}).rgb);
`;
      if (defined_default(generatedMaterialValues.u_emissiveFactor)) {
        fragmentShader += "    emissive *= u_emissiveFactor;\n";
      }
      fragmentShader += "    color += emissive;\n";
    } else if (defined_default(generatedMaterialValues.u_emissiveFactor)) {
      fragmentShader += "    color += u_emissiveFactor;\n";
    }
  }
  if (!isUnlit) {
    fragmentShader += "    color = applyTonemapping(color);\n";
  }
  fragmentShader += "    color = LINEARtoSRGB(color);\n";
  if (hasOutline) {
    fragmentShader += "    float outlineness = max(\n";
    fragmentShader += "        texture2D(u_outlineTexture, vec2(v_outlineCoordinates.x, 0.5)).r,\n";
    fragmentShader += "        max(\n";
    fragmentShader += "          texture2D(u_outlineTexture, vec2(v_outlineCoordinates.y, 0.5)).r,\n";
    fragmentShader += "          texture2D(u_outlineTexture, vec2(v_outlineCoordinates.z, 0.5)).r));\n";
    fragmentShader += "    color = mix(color, vec3(0.0, 0.0, 0.0), outlineness);\n";
  }
  if (defined_default(alphaMode)) {
    if (alphaMode === "MASK") {
      fragmentShader += "    if (baseColorWithAlpha.a < u_alphaCutoff) {\n";
      fragmentShader += "        discard;\n";
      fragmentShader += "    }\n";
      fragmentShader += "    gl_FragColor = vec4(color, 1.0);\n";
    } else if (alphaMode === "BLEND") {
      fragmentShader += "    gl_FragColor = vec4(color, baseColorWithAlpha.a);\n";
    } else {
      fragmentShader += "    gl_FragColor = vec4(color, 1.0);\n";
    }
  } else {
    fragmentShader += "    gl_FragColor = vec4(color, 1.0);\n";
  }
  fragmentShader += "}\n";
  const vertexShaderId = addToArray_default(shaders, {
    type: WebGLConstants_default.VERTEX_SHADER,
    extras: {
      _pipeline: {
        source: vertexShader,
        extension: ".glsl"
      }
    }
  });
  const fragmentShaderId = addToArray_default(shaders, {
    type: WebGLConstants_default.FRAGMENT_SHADER,
    extras: {
      _pipeline: {
        source: fragmentShader,
        extension: ".glsl"
      }
    }
  });
  const programId = addToArray_default(programs, {
    fragmentShader: fragmentShaderId,
    vertexShader: vertexShaderId
  });
  const techniqueId = addToArray_default(techniques, {
    attributes: techniqueAttributes,
    program: programId,
    uniforms: techniqueUniforms
  });
  return techniqueId;
}
function getPBRValueType(paramName) {
  if (paramName.indexOf("Offset") !== -1) {
    return WebGLConstants_default.FLOAT_VEC2;
  } else if (paramName.indexOf("Rotation") !== -1) {
    return WebGLConstants_default.FLOAT;
  } else if (paramName.indexOf("Scale") !== -1) {
    return WebGLConstants_default.FLOAT_VEC2;
  } else if (paramName.indexOf("Texture") !== -1) {
    return WebGLConstants_default.SAMPLER_2D;
  }
  switch (paramName) {
    case "u_baseColorFactor":
      return WebGLConstants_default.FLOAT_VEC4;
    case "u_metallicFactor":
      return WebGLConstants_default.FLOAT;
    case "u_roughnessFactor":
      return WebGLConstants_default.FLOAT;
    case "u_emissiveFactor":
      return WebGLConstants_default.FLOAT_VEC3;
    case "u_diffuseFactor":
      return WebGLConstants_default.FLOAT_VEC4;
    case "u_specularFactor":
      return WebGLConstants_default.FLOAT_VEC3;
    case "u_glossinessFactor":
      return WebGLConstants_default.FLOAT;
  }
}
var processPbrMaterials_default = processPbrMaterials;

// node_modules/cesium/Source/Scene/Vector3DTileBatch.js
function Vector3DTileBatch(options) {
  this.offset = options.offset;
  this.count = options.count;
  this.color = options.color;
  this.batchIds = options.batchIds;
}
var Vector3DTileBatch_default = Vector3DTileBatch;

// node_modules/cesium/Source/Shaders/VectorTileVS.js
var VectorTileVS_default = "attribute vec3 position;\nattribute float a_batchId;\n\nuniform mat4 u_modifiedModelViewProjection;\n\nvoid main()\n{\n    gl_Position = czm_depthClamp(u_modifiedModelViewProjection * vec4(position, 1.0));\n}\n";

// node_modules/cesium/Source/ThirdParty/jsep.js
var jsep = createCommonjsModule(function(module2, exports2) {
  (function(root) {
    var COMPOUND = "Compound", IDENTIFIER = "Identifier", MEMBER_EXP = "MemberExpression", LITERAL = "Literal", THIS_EXP = "ThisExpression", CALL_EXP = "CallExpression", UNARY_EXP = "UnaryExpression", BINARY_EXP = "BinaryExpression", LOGICAL_EXP = "LogicalExpression", CONDITIONAL_EXP = "ConditionalExpression", ARRAY_EXP = "ArrayExpression", PERIOD_CODE = 46, COMMA_CODE = 44, SQUOTE_CODE = 39, DQUOTE_CODE = 34, OPAREN_CODE = 40, CPAREN_CODE = 41, OBRACK_CODE = 91, CBRACK_CODE = 93, QUMARK_CODE = 63, SEMCOL_CODE = 59, COLON_CODE = 58, throwError = function(message, index2) {
      var error = new Error(message + " at character " + index2);
      error.index = index2;
      error.description = message;
      throw error;
    }, t = true, unary_ops = { "-": t, "!": t, "~": t, "+": t }, binary_ops = {
      "||": 1,
      "&&": 2,
      "|": 3,
      "^": 4,
      "&": 5,
      "==": 6,
      "!=": 6,
      "===": 6,
      "!==": 6,
      "<": 7,
      ">": 7,
      "<=": 7,
      ">=": 7,
      "<<": 8,
      ">>": 8,
      ">>>": 8,
      "+": 9,
      "-": 9,
      "*": 10,
      "/": 10,
      "%": 10
    }, getMaxKeyLen = function(obj) {
      var max_len = 0, len;
      for (var key in obj) {
        if ((len = key.length) > max_len && obj.hasOwnProperty(key)) {
          max_len = len;
        }
      }
      return max_len;
    }, max_unop_len = getMaxKeyLen(unary_ops), max_binop_len = getMaxKeyLen(binary_ops), literals = {
      "true": true,
      "false": false,
      "null": null
    }, this_str = "this", binaryPrecedence = function(op_val) {
      return binary_ops[op_val] || 0;
    }, createBinaryExpression = function(operator, left, right) {
      var type = operator === "||" || operator === "&&" ? LOGICAL_EXP : BINARY_EXP;
      return {
        type,
        operator,
        left,
        right
      };
    }, isDecimalDigit = function(ch) {
      return ch >= 48 && ch <= 57;
    }, isIdentifierStart = function(ch) {
      return ch === 36 || ch === 95 || ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch >= 128 && !binary_ops[String.fromCharCode(ch)];
    }, isIdentifierPart = function(ch) {
      return ch === 36 || ch === 95 || ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch >= 48 && ch <= 57 || ch >= 128 && !binary_ops[String.fromCharCode(ch)];
    }, jsep2 = function(expr) {
      var index2 = 0, charAtFunc = expr.charAt, charCodeAtFunc = expr.charCodeAt, exprI = function(i2) {
        return charAtFunc.call(expr, i2);
      }, exprICode = function(i2) {
        return charCodeAtFunc.call(expr, i2);
      }, length3 = expr.length, gobbleSpaces = function() {
        var ch = exprICode(index2);
        while (ch === 32 || ch === 9 || ch === 10 || ch === 13) {
          ch = exprICode(++index2);
        }
      }, gobbleExpression = function() {
        var test = gobbleBinaryExpression(), consequent, alternate;
        gobbleSpaces();
        if (exprICode(index2) === QUMARK_CODE) {
          index2++;
          consequent = gobbleExpression();
          if (!consequent) {
            throwError("Expected expression", index2);
          }
          gobbleSpaces();
          if (exprICode(index2) === COLON_CODE) {
            index2++;
            alternate = gobbleExpression();
            if (!alternate) {
              throwError("Expected expression", index2);
            }
            return {
              type: CONDITIONAL_EXP,
              test,
              consequent,
              alternate
            };
          } else {
            throwError("Expected :", index2);
          }
        } else {
          return test;
        }
      }, gobbleBinaryOp = function() {
        gobbleSpaces();
        var to_check = expr.substr(index2, max_binop_len), tc_len = to_check.length;
        while (tc_len > 0) {
          if (binary_ops.hasOwnProperty(to_check) && (!isIdentifierStart(exprICode(index2)) || index2 + to_check.length < expr.length && !isIdentifierPart(exprICode(index2 + to_check.length)))) {
            index2 += tc_len;
            return to_check;
          }
          to_check = to_check.substr(0, --tc_len);
        }
        return false;
      }, gobbleBinaryExpression = function() {
        var node2, biop, prec, stack, biop_info, left, right, i2, cur_biop;
        left = gobbleToken();
        biop = gobbleBinaryOp();
        if (!biop) {
          return left;
        }
        biop_info = { value: biop, prec: binaryPrecedence(biop) };
        right = gobbleToken();
        if (!right) {
          throwError("Expected expression after " + biop, index2);
        }
        stack = [left, biop_info, right];
        while (biop = gobbleBinaryOp()) {
          prec = binaryPrecedence(biop);
          if (prec === 0) {
            break;
          }
          biop_info = { value: biop, prec };
          cur_biop = biop;
          while (stack.length > 2 && prec <= stack[stack.length - 2].prec) {
            right = stack.pop();
            biop = stack.pop().value;
            left = stack.pop();
            node2 = createBinaryExpression(biop, left, right);
            stack.push(node2);
          }
          node2 = gobbleToken();
          if (!node2) {
            throwError("Expected expression after " + cur_biop, index2);
          }
          stack.push(biop_info, node2);
        }
        i2 = stack.length - 1;
        node2 = stack[i2];
        while (i2 > 1) {
          node2 = createBinaryExpression(stack[i2 - 1].value, stack[i2 - 2], node2);
          i2 -= 2;
        }
        return node2;
      }, gobbleToken = function() {
        var ch, to_check, tc_len;
        gobbleSpaces();
        ch = exprICode(index2);
        if (isDecimalDigit(ch) || ch === PERIOD_CODE) {
          return gobbleNumericLiteral();
        } else if (ch === SQUOTE_CODE || ch === DQUOTE_CODE) {
          return gobbleStringLiteral();
        } else if (ch === OBRACK_CODE) {
          return gobbleArray();
        } else {
          to_check = expr.substr(index2, max_unop_len);
          tc_len = to_check.length;
          while (tc_len > 0) {
            if (unary_ops.hasOwnProperty(to_check) && (!isIdentifierStart(exprICode(index2)) || index2 + to_check.length < expr.length && !isIdentifierPart(exprICode(index2 + to_check.length)))) {
              index2 += tc_len;
              return {
                type: UNARY_EXP,
                operator: to_check,
                argument: gobbleToken(),
                prefix: true
              };
            }
            to_check = to_check.substr(0, --tc_len);
          }
          if (isIdentifierStart(ch) || ch === OPAREN_CODE) {
            return gobbleVariable();
          }
        }
        return false;
      }, gobbleNumericLiteral = function() {
        var number = "", ch, chCode;
        while (isDecimalDigit(exprICode(index2))) {
          number += exprI(index2++);
        }
        if (exprICode(index2) === PERIOD_CODE) {
          number += exprI(index2++);
          while (isDecimalDigit(exprICode(index2))) {
            number += exprI(index2++);
          }
        }
        ch = exprI(index2);
        if (ch === "e" || ch === "E") {
          number += exprI(index2++);
          ch = exprI(index2);
          if (ch === "+" || ch === "-") {
            number += exprI(index2++);
          }
          while (isDecimalDigit(exprICode(index2))) {
            number += exprI(index2++);
          }
          if (!isDecimalDigit(exprICode(index2 - 1))) {
            throwError("Expected exponent (" + number + exprI(index2) + ")", index2);
          }
        }
        chCode = exprICode(index2);
        if (isIdentifierStart(chCode)) {
          throwError("Variable names cannot start with a number (" + number + exprI(index2) + ")", index2);
        } else if (chCode === PERIOD_CODE) {
          throwError("Unexpected period", index2);
        }
        return {
          type: LITERAL,
          value: parseFloat(number),
          raw: number
        };
      }, gobbleStringLiteral = function() {
        var str = "", quote = exprI(index2++), closed = false, ch;
        while (index2 < length3) {
          ch = exprI(index2++);
          if (ch === quote) {
            closed = true;
            break;
          } else if (ch === "\\") {
            ch = exprI(index2++);
            switch (ch) {
              case "n":
                str += "\n";
                break;
              case "r":
                str += "\r";
                break;
              case "t":
                str += "	";
                break;
              case "b":
                str += "\b";
                break;
              case "f":
                str += "\f";
                break;
              case "v":
                str += "\v";
                break;
              default:
                str += ch;
            }
          } else {
            str += ch;
          }
        }
        if (!closed) {
          throwError('Unclosed quote after "' + str + '"', index2);
        }
        return {
          type: LITERAL,
          value: str,
          raw: quote + str + quote
        };
      }, gobbleIdentifier = function() {
        var ch = exprICode(index2), start = index2, identifier;
        if (isIdentifierStart(ch)) {
          index2++;
        } else {
          throwError("Unexpected " + exprI(index2), index2);
        }
        while (index2 < length3) {
          ch = exprICode(index2);
          if (isIdentifierPart(ch)) {
            index2++;
          } else {
            break;
          }
        }
        identifier = expr.slice(start, index2);
        if (literals.hasOwnProperty(identifier)) {
          return {
            type: LITERAL,
            value: literals[identifier],
            raw: identifier
          };
        } else if (identifier === this_str) {
          return { type: THIS_EXP };
        } else {
          return {
            type: IDENTIFIER,
            name: identifier
          };
        }
      }, gobbleArguments = function(termination) {
        var ch_i2, args = [], node2, closed = false;
        var separator_count = 0;
        while (index2 < length3) {
          gobbleSpaces();
          ch_i2 = exprICode(index2);
          if (ch_i2 === termination) {
            closed = true;
            index2++;
            if (termination === CPAREN_CODE && separator_count && separator_count >= args.length) {
              throwError("Unexpected token " + String.fromCharCode(termination), index2);
            }
            break;
          } else if (ch_i2 === COMMA_CODE) {
            index2++;
            separator_count++;
            if (separator_count !== args.length) {
              if (termination === CPAREN_CODE) {
                throwError("Unexpected token ,", index2);
              } else if (termination === CBRACK_CODE) {
                for (var arg = args.length; arg < separator_count; arg++) {
                  args.push(null);
                }
              }
            }
          } else {
            node2 = gobbleExpression();
            if (!node2 || node2.type === COMPOUND) {
              throwError("Expected comma", index2);
            }
            args.push(node2);
          }
        }
        if (!closed) {
          throwError("Expected " + String.fromCharCode(termination), index2);
        }
        return args;
      }, gobbleVariable = function() {
        var ch_i2, node2;
        ch_i2 = exprICode(index2);
        if (ch_i2 === OPAREN_CODE) {
          node2 = gobbleGroup();
        } else {
          node2 = gobbleIdentifier();
        }
        gobbleSpaces();
        ch_i2 = exprICode(index2);
        while (ch_i2 === PERIOD_CODE || ch_i2 === OBRACK_CODE || ch_i2 === OPAREN_CODE) {
          index2++;
          if (ch_i2 === PERIOD_CODE) {
            gobbleSpaces();
            node2 = {
              type: MEMBER_EXP,
              computed: false,
              object: node2,
              property: gobbleIdentifier()
            };
          } else if (ch_i2 === OBRACK_CODE) {
            node2 = {
              type: MEMBER_EXP,
              computed: true,
              object: node2,
              property: gobbleExpression()
            };
            gobbleSpaces();
            ch_i2 = exprICode(index2);
            if (ch_i2 !== CBRACK_CODE) {
              throwError("Unclosed [", index2);
            }
            index2++;
          } else if (ch_i2 === OPAREN_CODE) {
            node2 = {
              type: CALL_EXP,
              "arguments": gobbleArguments(CPAREN_CODE),
              callee: node2
            };
          }
          gobbleSpaces();
          ch_i2 = exprICode(index2);
        }
        return node2;
      }, gobbleGroup = function() {
        index2++;
        var node2 = gobbleExpression();
        gobbleSpaces();
        if (exprICode(index2) === CPAREN_CODE) {
          index2++;
          return node2;
        } else {
          throwError("Unclosed (", index2);
        }
      }, gobbleArray = function() {
        index2++;
        return {
          type: ARRAY_EXP,
          elements: gobbleArguments(CBRACK_CODE)
        };
      }, nodes = [], ch_i, node;
      while (index2 < length3) {
        ch_i = exprICode(index2);
        if (ch_i === SEMCOL_CODE || ch_i === COMMA_CODE) {
          index2++;
        } else {
          if (node = gobbleExpression()) {
            nodes.push(node);
          } else if (index2 < length3) {
            throwError('Unexpected "' + exprI(index2) + '"', index2);
          }
        }
      }
      if (nodes.length === 1) {
        return nodes[0];
      } else {
        return {
          type: COMPOUND,
          body: nodes
        };
      }
    };
    jsep2.version = "0.3.5";
    jsep2.toString = function() {
      return "JavaScript Expression Parser (JSEP) v" + jsep2.version;
    };
    jsep2.addUnaryOp = function(op_name) {
      max_unop_len = Math.max(op_name.length, max_unop_len);
      unary_ops[op_name] = t;
      return this;
    };
    jsep2.addBinaryOp = function(op_name, precedence) {
      max_binop_len = Math.max(op_name.length, max_binop_len);
      binary_ops[op_name] = precedence;
      return this;
    };
    jsep2.addLiteral = function(literal_name, literal_value) {
      literals[literal_name] = literal_value;
      return this;
    };
    jsep2.removeUnaryOp = function(op_name) {
      delete unary_ops[op_name];
      if (op_name.length === max_unop_len) {
        max_unop_len = getMaxKeyLen(unary_ops);
      }
      return this;
    };
    jsep2.removeAllUnaryOps = function() {
      unary_ops = {};
      max_unop_len = 0;
      return this;
    };
    jsep2.removeBinaryOp = function(op_name) {
      delete binary_ops[op_name];
      if (op_name.length === max_binop_len) {
        max_binop_len = getMaxKeyLen(binary_ops);
      }
      return this;
    };
    jsep2.removeAllBinaryOps = function() {
      binary_ops = {};
      max_binop_len = 0;
      return this;
    };
    jsep2.removeLiteral = function(literal_name) {
      delete literals[literal_name];
      return this;
    };
    jsep2.removeAllLiterals = function() {
      literals = {};
      return this;
    };
    {
      if (module2.exports) {
        exports2 = module2.exports = jsep2;
      } else {
        exports2.parse = jsep2;
      }
    }
  })();
});

// node_modules/cesium/Source/Scene/ExpressionNodeType.js
var ExpressionNodeType = {
  VARIABLE: 0,
  UNARY: 1,
  BINARY: 2,
  TERNARY: 3,
  CONDITIONAL: 4,
  MEMBER: 5,
  FUNCTION_CALL: 6,
  ARRAY: 7,
  REGEX: 8,
  VARIABLE_IN_STRING: 9,
  LITERAL_NULL: 10,
  LITERAL_BOOLEAN: 11,
  LITERAL_NUMBER: 12,
  LITERAL_STRING: 13,
  LITERAL_COLOR: 14,
  LITERAL_VECTOR: 15,
  LITERAL_REGEX: 16,
  LITERAL_UNDEFINED: 17,
  BUILTIN_VARIABLE: 18
};
var ExpressionNodeType_default = Object.freeze(ExpressionNodeType);

// node_modules/cesium/Source/Scene/Expression.js
function Expression(expression, defines) {
  Check_default.typeOf.string("expression", expression);
  this._expression = expression;
  expression = replaceDefines(expression, defines);
  expression = replaceVariables(removeBackslashes(expression));
  jsep.addBinaryOp("=~", 0);
  jsep.addBinaryOp("!~", 0);
  let ast;
  try {
    ast = jsep(expression);
  } catch (e2) {
    throw new RuntimeError_default(e2);
  }
  this._runtimeAst = createRuntimeAst(this, ast);
}
Object.defineProperties(Expression.prototype, {
  expression: {
    get: function() {
      return this._expression;
    }
  }
});
var scratchStorage = {
  arrayIndex: 0,
  arrayArray: [[]],
  cartesian2Index: 0,
  cartesian3Index: 0,
  cartesian4Index: 0,
  cartesian2Array: [new Cartesian2_default()],
  cartesian3Array: [new Cartesian3_default()],
  cartesian4Array: [new Cartesian4_default()],
  reset: function() {
    this.arrayIndex = 0;
    this.cartesian2Index = 0;
    this.cartesian3Index = 0;
    this.cartesian4Index = 0;
  },
  getArray: function() {
    if (this.arrayIndex >= this.arrayArray.length) {
      this.arrayArray.push([]);
    }
    const array = this.arrayArray[this.arrayIndex++];
    array.length = 0;
    return array;
  },
  getCartesian2: function() {
    if (this.cartesian2Index >= this.cartesian2Array.length) {
      this.cartesian2Array.push(new Cartesian2_default());
    }
    return this.cartesian2Array[this.cartesian2Index++];
  },
  getCartesian3: function() {
    if (this.cartesian3Index >= this.cartesian3Array.length) {
      this.cartesian3Array.push(new Cartesian3_default());
    }
    return this.cartesian3Array[this.cartesian3Index++];
  },
  getCartesian4: function() {
    if (this.cartesian4Index >= this.cartesian4Array.length) {
      this.cartesian4Array.push(new Cartesian4_default());
    }
    return this.cartesian4Array[this.cartesian4Index++];
  }
};
Expression.prototype.evaluate = function(feature2, result) {
  scratchStorage.reset();
  const value = this._runtimeAst.evaluate(feature2);
  if (result instanceof Color_default && value instanceof Cartesian4_default) {
    return Color_default.fromCartesian4(value, result);
  }
  if (value instanceof Cartesian2_default || value instanceof Cartesian3_default || value instanceof Cartesian4_default) {
    return value.clone(result);
  }
  return value;
};
Expression.prototype.evaluateColor = function(feature2, result) {
  scratchStorage.reset();
  const color = this._runtimeAst.evaluate(feature2);
  return Color_default.fromCartesian4(color, result);
};
Expression.prototype.getShaderFunction = function(functionSignature, variableSubstitutionMap, shaderState, returnType) {
  let shaderExpression = this.getShaderExpression(
    variableSubstitutionMap,
    shaderState
  );
  shaderExpression = `${returnType} ${functionSignature}
{
    return ${shaderExpression};
}
`;
  return shaderExpression;
};
Expression.prototype.getShaderExpression = function(variableSubstitutionMap, shaderState) {
  return this._runtimeAst.getShaderExpression(
    variableSubstitutionMap,
    shaderState
  );
};
Expression.prototype.getVariables = function() {
  let variables = [];
  this._runtimeAst.getVariables(variables);
  variables = variables.filter(function(variable, index2, variables2) {
    return variables2.indexOf(variable) === index2;
  });
  return variables;
};
var unaryOperators = ["!", "-", "+"];
var binaryOperators = [
  "+",
  "-",
  "*",
  "/",
  "%",
  "===",
  "!==",
  ">",
  ">=",
  "<",
  "<=",
  "&&",
  "||",
  "!~",
  "=~"
];
var variableRegex = /\${(.*?)}/g;
var backslashRegex = /\\/g;
var backslashReplacement = "@#%";
var replacementRegex = /@#%/g;
var scratchColor3 = new Color_default();
var unaryFunctions = {
  abs: getEvaluateUnaryComponentwise(Math.abs),
  sqrt: getEvaluateUnaryComponentwise(Math.sqrt),
  cos: getEvaluateUnaryComponentwise(Math.cos),
  sin: getEvaluateUnaryComponentwise(Math.sin),
  tan: getEvaluateUnaryComponentwise(Math.tan),
  acos: getEvaluateUnaryComponentwise(Math.acos),
  asin: getEvaluateUnaryComponentwise(Math.asin),
  atan: getEvaluateUnaryComponentwise(Math.atan),
  radians: getEvaluateUnaryComponentwise(Math_default.toRadians),
  degrees: getEvaluateUnaryComponentwise(Math_default.toDegrees),
  sign: getEvaluateUnaryComponentwise(Math_default.sign),
  floor: getEvaluateUnaryComponentwise(Math.floor),
  ceil: getEvaluateUnaryComponentwise(Math.ceil),
  round: getEvaluateUnaryComponentwise(Math.round),
  exp: getEvaluateUnaryComponentwise(Math.exp),
  exp2: getEvaluateUnaryComponentwise(exp2),
  log: getEvaluateUnaryComponentwise(Math.log),
  log2: getEvaluateUnaryComponentwise(log22),
  fract: getEvaluateUnaryComponentwise(fract),
  length: length2,
  normalize
};
var binaryFunctions = {
  atan2: getEvaluateBinaryComponentwise(Math.atan2, false),
  pow: getEvaluateBinaryComponentwise(Math.pow, false),
  min: getEvaluateBinaryComponentwise(Math.min, true),
  max: getEvaluateBinaryComponentwise(Math.max, true),
  distance,
  dot,
  cross
};
var ternaryFunctions = {
  clamp: getEvaluateTernaryComponentwise(Math_default.clamp, true),
  mix: getEvaluateTernaryComponentwise(Math_default.lerp, true)
};
function fract(number) {
  return number - Math.floor(number);
}
function exp2(exponent) {
  return Math.pow(2, exponent);
}
function log22(number) {
  return Math_default.log2(number);
}
function getEvaluateUnaryComponentwise(operation) {
  return function(call, left) {
    if (typeof left === "number") {
      return operation(left);
    } else if (left instanceof Cartesian2_default) {
      return Cartesian2_default.fromElements(
        operation(left.x),
        operation(left.y),
        scratchStorage.getCartesian2()
      );
    } else if (left instanceof Cartesian3_default) {
      return Cartesian3_default.fromElements(
        operation(left.x),
        operation(left.y),
        operation(left.z),
        scratchStorage.getCartesian3()
      );
    } else if (left instanceof Cartesian4_default) {
      return Cartesian4_default.fromElements(
        operation(left.x),
        operation(left.y),
        operation(left.z),
        operation(left.w),
        scratchStorage.getCartesian4()
      );
    }
    throw new RuntimeError_default(
      `Function "${call}" requires a vector or number argument. Argument is ${left}.`
    );
  };
}
function getEvaluateBinaryComponentwise(operation, allowScalar) {
  return function(call, left, right) {
    if (allowScalar && typeof right === "number") {
      if (typeof left === "number") {
        return operation(left, right);
      } else if (left instanceof Cartesian2_default) {
        return Cartesian2_default.fromElements(
          operation(left.x, right),
          operation(left.y, right),
          scratchStorage.getCartesian2()
        );
      } else if (left instanceof Cartesian3_default) {
        return Cartesian3_default.fromElements(
          operation(left.x, right),
          operation(left.y, right),
          operation(left.z, right),
          scratchStorage.getCartesian3()
        );
      } else if (left instanceof Cartesian4_default) {
        return Cartesian4_default.fromElements(
          operation(left.x, right),
          operation(left.y, right),
          operation(left.z, right),
          operation(left.w, right),
          scratchStorage.getCartesian4()
        );
      }
    }
    if (typeof left === "number" && typeof right === "number") {
      return operation(left, right);
    } else if (left instanceof Cartesian2_default && right instanceof Cartesian2_default) {
      return Cartesian2_default.fromElements(
        operation(left.x, right.x),
        operation(left.y, right.y),
        scratchStorage.getCartesian2()
      );
    } else if (left instanceof Cartesian3_default && right instanceof Cartesian3_default) {
      return Cartesian3_default.fromElements(
        operation(left.x, right.x),
        operation(left.y, right.y),
        operation(left.z, right.z),
        scratchStorage.getCartesian3()
      );
    } else if (left instanceof Cartesian4_default && right instanceof Cartesian4_default) {
      return Cartesian4_default.fromElements(
        operation(left.x, right.x),
        operation(left.y, right.y),
        operation(left.z, right.z),
        operation(left.w, right.w),
        scratchStorage.getCartesian4()
      );
    }
    throw new RuntimeError_default(
      `Function "${call}" requires vector or number arguments of matching types. Arguments are ${left} and ${right}.`
    );
  };
}
function getEvaluateTernaryComponentwise(operation, allowScalar) {
  return function(call, left, right, test) {
    if (allowScalar && typeof test === "number") {
      if (typeof left === "number" && typeof right === "number") {
        return operation(left, right, test);
      } else if (left instanceof Cartesian2_default && right instanceof Cartesian2_default) {
        return Cartesian2_default.fromElements(
          operation(left.x, right.x, test),
          operation(left.y, right.y, test),
          scratchStorage.getCartesian2()
        );
      } else if (left instanceof Cartesian3_default && right instanceof Cartesian3_default) {
        return Cartesian3_default.fromElements(
          operation(left.x, right.x, test),
          operation(left.y, right.y, test),
          operation(left.z, right.z, test),
          scratchStorage.getCartesian3()
        );
      } else if (left instanceof Cartesian4_default && right instanceof Cartesian4_default) {
        return Cartesian4_default.fromElements(
          operation(left.x, right.x, test),
          operation(left.y, right.y, test),
          operation(left.z, right.z, test),
          operation(left.w, right.w, test),
          scratchStorage.getCartesian4()
        );
      }
    }
    if (typeof left === "number" && typeof right === "number" && typeof test === "number") {
      return operation(left, right, test);
    } else if (left instanceof Cartesian2_default && right instanceof Cartesian2_default && test instanceof Cartesian2_default) {
      return Cartesian2_default.fromElements(
        operation(left.x, right.x, test.x),
        operation(left.y, right.y, test.y),
        scratchStorage.getCartesian2()
      );
    } else if (left instanceof Cartesian3_default && right instanceof Cartesian3_default && test instanceof Cartesian3_default) {
      return Cartesian3_default.fromElements(
        operation(left.x, right.x, test.x),
        operation(left.y, right.y, test.y),
        operation(left.z, right.z, test.z),
        scratchStorage.getCartesian3()
      );
    } else if (left instanceof Cartesian4_default && right instanceof Cartesian4_default && test instanceof Cartesian4_default) {
      return Cartesian4_default.fromElements(
        operation(left.x, right.x, test.x),
        operation(left.y, right.y, test.y),
        operation(left.z, right.z, test.z),
        operation(left.w, right.w, test.w),
        scratchStorage.getCartesian4()
      );
    }
    throw new RuntimeError_default(
      `Function "${call}" requires vector or number arguments of matching types. Arguments are ${left}, ${right}, and ${test}.`
    );
  };
}
function length2(call, left) {
  if (typeof left === "number") {
    return Math.abs(left);
  } else if (left instanceof Cartesian2_default) {
    return Cartesian2_default.magnitude(left);
  } else if (left instanceof Cartesian3_default) {
    return Cartesian3_default.magnitude(left);
  } else if (left instanceof Cartesian4_default) {
    return Cartesian4_default.magnitude(left);
  }
  throw new RuntimeError_default(
    `Function "${call}" requires a vector or number argument. Argument is ${left}.`
  );
}
function normalize(call, left) {
  if (typeof left === "number") {
    return 1;
  } else if (left instanceof Cartesian2_default) {
    return Cartesian2_default.normalize(left, scratchStorage.getCartesian2());
  } else if (left instanceof Cartesian3_default) {
    return Cartesian3_default.normalize(left, scratchStorage.getCartesian3());
  } else if (left instanceof Cartesian4_default) {
    return Cartesian4_default.normalize(left, scratchStorage.getCartesian4());
  }
  throw new RuntimeError_default(
    `Function "${call}" requires a vector or number argument. Argument is ${left}.`
  );
}
function distance(call, left, right) {
  if (typeof left === "number" && typeof right === "number") {
    return Math.abs(left - right);
  } else if (left instanceof Cartesian2_default && right instanceof Cartesian2_default) {
    return Cartesian2_default.distance(left, right);
  } else if (left instanceof Cartesian3_default && right instanceof Cartesian3_default) {
    return Cartesian3_default.distance(left, right);
  } else if (left instanceof Cartesian4_default && right instanceof Cartesian4_default) {
    return Cartesian4_default.distance(left, right);
  }
  throw new RuntimeError_default(
    `Function "${call}" requires vector or number arguments of matching types. Arguments are ${left} and ${right}.`
  );
}
function dot(call, left, right) {
  if (typeof left === "number" && typeof right === "number") {
    return left * right;
  } else if (left instanceof Cartesian2_default && right instanceof Cartesian2_default) {
    return Cartesian2_default.dot(left, right);
  } else if (left instanceof Cartesian3_default && right instanceof Cartesian3_default) {
    return Cartesian3_default.dot(left, right);
  } else if (left instanceof Cartesian4_default && right instanceof Cartesian4_default) {
    return Cartesian4_default.dot(left, right);
  }
  throw new RuntimeError_default(
    `Function "${call}" requires vector or number arguments of matching types. Arguments are ${left} and ${right}.`
  );
}
function cross(call, left, right) {
  if (left instanceof Cartesian3_default && right instanceof Cartesian3_default) {
    return Cartesian3_default.cross(left, right, scratchStorage.getCartesian3());
  }
  throw new RuntimeError_default(
    `Function "${call}" requires vec3 arguments. Arguments are ${left} and ${right}.`
  );
}
function Node3(type, value, left, right, test) {
  this._type = type;
  this._value = value;
  this._left = left;
  this._right = right;
  this._test = test;
  this.evaluate = void 0;
  setEvaluateFunction(this);
}
function replaceDefines(expression, defines) {
  if (!defined_default(defines)) {
    return expression;
  }
  for (const key in defines) {
    if (defines.hasOwnProperty(key)) {
      const definePlaceholder = new RegExp(`\\$\\{${key}\\}`, "g");
      const defineReplace = `(${defines[key]})`;
      if (defined_default(defineReplace)) {
        expression = expression.replace(definePlaceholder, defineReplace);
      }
    }
  }
  return expression;
}
function removeBackslashes(expression) {
  return expression.replace(backslashRegex, backslashReplacement);
}
function replaceBackslashes(expression) {
  return expression.replace(replacementRegex, "\\");
}
function replaceVariables(expression) {
  let exp = expression;
  let result = "";
  let i2 = exp.indexOf("${");
  while (i2 >= 0) {
    const openSingleQuote = exp.indexOf("'");
    const openDoubleQuote = exp.indexOf('"');
    let closeQuote;
    if (openSingleQuote >= 0 && openSingleQuote < i2) {
      closeQuote = exp.indexOf("'", openSingleQuote + 1);
      result += exp.substr(0, closeQuote + 1);
      exp = exp.substr(closeQuote + 1);
      i2 = exp.indexOf("${");
    } else if (openDoubleQuote >= 0 && openDoubleQuote < i2) {
      closeQuote = exp.indexOf('"', openDoubleQuote + 1);
      result += exp.substr(0, closeQuote + 1);
      exp = exp.substr(closeQuote + 1);
      i2 = exp.indexOf("${");
    } else {
      result += exp.substr(0, i2);
      const j = exp.indexOf("}");
      if (j < 0) {
        throw new RuntimeError_default("Unmatched {.");
      }
      result += `czm_${exp.substr(i2 + 2, j - (i2 + 2))}`;
      exp = exp.substr(j + 1);
      i2 = exp.indexOf("${");
    }
  }
  result += exp;
  return result;
}
function parseLiteral(ast) {
  const type = typeof ast.value;
  if (ast.value === null) {
    return new Node3(ExpressionNodeType_default.LITERAL_NULL, null);
  } else if (type === "boolean") {
    return new Node3(ExpressionNodeType_default.LITERAL_BOOLEAN, ast.value);
  } else if (type === "number") {
    return new Node3(ExpressionNodeType_default.LITERAL_NUMBER, ast.value);
  } else if (type === "string") {
    if (ast.value.indexOf("${") >= 0) {
      return new Node3(ExpressionNodeType_default.VARIABLE_IN_STRING, ast.value);
    }
    return new Node3(
      ExpressionNodeType_default.LITERAL_STRING,
      replaceBackslashes(ast.value)
    );
  }
}
function parseCall(expression, ast) {
  const args = ast.arguments;
  const argsLength = args.length;
  let call;
  let val, left, right;
  if (ast.callee.type === "MemberExpression") {
    call = ast.callee.property.name;
    const object2 = ast.callee.object;
    if (call === "test" || call === "exec") {
      if (object2.callee.name !== "regExp") {
        throw new RuntimeError_default(`${call} is not a function.`);
      }
      if (argsLength === 0) {
        if (call === "test") {
          return new Node3(ExpressionNodeType_default.LITERAL_BOOLEAN, false);
        }
        return new Node3(ExpressionNodeType_default.LITERAL_NULL, null);
      }
      left = createRuntimeAst(expression, object2);
      right = createRuntimeAst(expression, args[0]);
      return new Node3(ExpressionNodeType_default.FUNCTION_CALL, call, left, right);
    } else if (call === "toString") {
      val = createRuntimeAst(expression, object2);
      return new Node3(ExpressionNodeType_default.FUNCTION_CALL, call, val);
    }
    throw new RuntimeError_default(`Unexpected function call "${call}".`);
  }
  call = ast.callee.name;
  if (call === "color") {
    if (argsLength === 0) {
      return new Node3(ExpressionNodeType_default.LITERAL_COLOR, call);
    }
    val = createRuntimeAst(expression, args[0]);
    if (defined_default(args[1])) {
      const alpha = createRuntimeAst(expression, args[1]);
      return new Node3(ExpressionNodeType_default.LITERAL_COLOR, call, [val, alpha]);
    }
    return new Node3(ExpressionNodeType_default.LITERAL_COLOR, call, [val]);
  } else if (call === "rgb" || call === "hsl") {
    if (argsLength < 3) {
      throw new RuntimeError_default(`${call} requires three arguments.`);
    }
    val = [
      createRuntimeAst(expression, args[0]),
      createRuntimeAst(expression, args[1]),
      createRuntimeAst(expression, args[2])
    ];
    return new Node3(ExpressionNodeType_default.LITERAL_COLOR, call, val);
  } else if (call === "rgba" || call === "hsla") {
    if (argsLength < 4) {
      throw new RuntimeError_default(`${call} requires four arguments.`);
    }
    val = [
      createRuntimeAst(expression, args[0]),
      createRuntimeAst(expression, args[1]),
      createRuntimeAst(expression, args[2]),
      createRuntimeAst(expression, args[3])
    ];
    return new Node3(ExpressionNodeType_default.LITERAL_COLOR, call, val);
  } else if (call === "vec2" || call === "vec3" || call === "vec4") {
    val = new Array(argsLength);
    for (let i2 = 0; i2 < argsLength; ++i2) {
      val[i2] = createRuntimeAst(expression, args[i2]);
    }
    return new Node3(ExpressionNodeType_default.LITERAL_VECTOR, call, val);
  } else if (call === "isNaN" || call === "isFinite") {
    if (argsLength === 0) {
      if (call === "isNaN") {
        return new Node3(ExpressionNodeType_default.LITERAL_BOOLEAN, true);
      }
      return new Node3(ExpressionNodeType_default.LITERAL_BOOLEAN, false);
    }
    val = createRuntimeAst(expression, args[0]);
    return new Node3(ExpressionNodeType_default.UNARY, call, val);
  } else if (call === "isExactClass" || call === "isClass") {
    if (argsLength < 1 || argsLength > 1) {
      throw new RuntimeError_default(`${call} requires exactly one argument.`);
    }
    val = createRuntimeAst(expression, args[0]);
    return new Node3(ExpressionNodeType_default.UNARY, call, val);
  } else if (call === "getExactClassName") {
    if (argsLength > 0) {
      throw new RuntimeError_default(`${call} does not take any argument.`);
    }
    return new Node3(ExpressionNodeType_default.UNARY, call);
  } else if (defined_default(unaryFunctions[call])) {
    if (argsLength !== 1) {
      throw new RuntimeError_default(`${call} requires exactly one argument.`);
    }
    val = createRuntimeAst(expression, args[0]);
    return new Node3(ExpressionNodeType_default.UNARY, call, val);
  } else if (defined_default(binaryFunctions[call])) {
    if (argsLength !== 2) {
      throw new RuntimeError_default(`${call} requires exactly two arguments.`);
    }
    left = createRuntimeAst(expression, args[0]);
    right = createRuntimeAst(expression, args[1]);
    return new Node3(ExpressionNodeType_default.BINARY, call, left, right);
  } else if (defined_default(ternaryFunctions[call])) {
    if (argsLength !== 3) {
      throw new RuntimeError_default(`${call} requires exactly three arguments.`);
    }
    left = createRuntimeAst(expression, args[0]);
    right = createRuntimeAst(expression, args[1]);
    const test = createRuntimeAst(expression, args[2]);
    return new Node3(ExpressionNodeType_default.TERNARY, call, left, right, test);
  } else if (call === "Boolean") {
    if (argsLength === 0) {
      return new Node3(ExpressionNodeType_default.LITERAL_BOOLEAN, false);
    }
    val = createRuntimeAst(expression, args[0]);
    return new Node3(ExpressionNodeType_default.UNARY, call, val);
  } else if (call === "Number") {
    if (argsLength === 0) {
      return new Node3(ExpressionNodeType_default.LITERAL_NUMBER, 0);
    }
    val = createRuntimeAst(expression, args[0]);
    return new Node3(ExpressionNodeType_default.UNARY, call, val);
  } else if (call === "String") {
    if (argsLength === 0) {
      return new Node3(ExpressionNodeType_default.LITERAL_STRING, "");
    }
    val = createRuntimeAst(expression, args[0]);
    return new Node3(ExpressionNodeType_default.UNARY, call, val);
  } else if (call === "regExp") {
    return parseRegex(expression, ast);
  }
  throw new RuntimeError_default(`Unexpected function call "${call}".`);
}
function parseRegex(expression, ast) {
  const args = ast.arguments;
  if (args.length === 0) {
    return new Node3(ExpressionNodeType_default.LITERAL_REGEX, new RegExp());
  }
  const pattern = createRuntimeAst(expression, args[0]);
  let exp;
  if (args.length > 1) {
    const flags = createRuntimeAst(expression, args[1]);
    if (isLiteralType(pattern) && isLiteralType(flags)) {
      try {
        exp = new RegExp(
          replaceBackslashes(String(pattern._value)),
          flags._value
        );
      } catch (e2) {
        throw new RuntimeError_default(e2);
      }
      return new Node3(ExpressionNodeType_default.LITERAL_REGEX, exp);
    }
    return new Node3(ExpressionNodeType_default.REGEX, pattern, flags);
  }
  if (isLiteralType(pattern)) {
    try {
      exp = new RegExp(replaceBackslashes(String(pattern._value)));
    } catch (e2) {
      throw new RuntimeError_default(e2);
    }
    return new Node3(ExpressionNodeType_default.LITERAL_REGEX, exp);
  }
  return new Node3(ExpressionNodeType_default.REGEX, pattern);
}
function parseKeywordsAndVariables(ast) {
  if (isVariable(ast.name)) {
    const name = getPropertyName(ast.name);
    if (name.substr(0, 8) === "tiles3d_") {
      return new Node3(ExpressionNodeType_default.BUILTIN_VARIABLE, name);
    }
    return new Node3(ExpressionNodeType_default.VARIABLE, name);
  } else if (ast.name === "NaN") {
    return new Node3(ExpressionNodeType_default.LITERAL_NUMBER, NaN);
  } else if (ast.name === "Infinity") {
    return new Node3(ExpressionNodeType_default.LITERAL_NUMBER, Infinity);
  } else if (ast.name === "undefined") {
    return new Node3(ExpressionNodeType_default.LITERAL_UNDEFINED, void 0);
  }
  throw new RuntimeError_default(`${ast.name} is not defined.`);
}
function parseMathConstant(ast) {
  const name = ast.property.name;
  if (name === "PI") {
    return new Node3(ExpressionNodeType_default.LITERAL_NUMBER, Math.PI);
  } else if (name === "E") {
    return new Node3(ExpressionNodeType_default.LITERAL_NUMBER, Math.E);
  }
}
function parseNumberConstant(ast) {
  const name = ast.property.name;
  if (name === "POSITIVE_INFINITY") {
    return new Node3(
      ExpressionNodeType_default.LITERAL_NUMBER,
      Number.POSITIVE_INFINITY
    );
  }
}
function parseMemberExpression(expression, ast) {
  if (ast.object.name === "Math") {
    return parseMathConstant(ast);
  } else if (ast.object.name === "Number") {
    return parseNumberConstant(ast);
  }
  let val;
  const obj = createRuntimeAst(expression, ast.object);
  if (ast.computed) {
    val = createRuntimeAst(expression, ast.property);
    return new Node3(ExpressionNodeType_default.MEMBER, "brackets", obj, val);
  }
  val = new Node3(ExpressionNodeType_default.LITERAL_STRING, ast.property.name);
  return new Node3(ExpressionNodeType_default.MEMBER, "dot", obj, val);
}
function isLiteralType(node) {
  return node._type >= ExpressionNodeType_default.LITERAL_NULL;
}
function isVariable(name) {
  return name.substr(0, 4) === "czm_";
}
function getPropertyName(variable) {
  return variable.substr(4);
}
function createRuntimeAst(expression, ast) {
  let node;
  let op;
  let left;
  let right;
  if (ast.type === "Literal") {
    node = parseLiteral(ast);
  } else if (ast.type === "CallExpression") {
    node = parseCall(expression, ast);
  } else if (ast.type === "Identifier") {
    node = parseKeywordsAndVariables(ast);
  } else if (ast.type === "UnaryExpression") {
    op = ast.operator;
    const child = createRuntimeAst(expression, ast.argument);
    if (unaryOperators.indexOf(op) > -1) {
      node = new Node3(ExpressionNodeType_default.UNARY, op, child);
    } else {
      throw new RuntimeError_default(`Unexpected operator "${op}".`);
    }
  } else if (ast.type === "BinaryExpression") {
    op = ast.operator;
    left = createRuntimeAst(expression, ast.left);
    right = createRuntimeAst(expression, ast.right);
    if (binaryOperators.indexOf(op) > -1) {
      node = new Node3(ExpressionNodeType_default.BINARY, op, left, right);
    } else {
      throw new RuntimeError_default(`Unexpected operator "${op}".`);
    }
  } else if (ast.type === "LogicalExpression") {
    op = ast.operator;
    left = createRuntimeAst(expression, ast.left);
    right = createRuntimeAst(expression, ast.right);
    if (binaryOperators.indexOf(op) > -1) {
      node = new Node3(ExpressionNodeType_default.BINARY, op, left, right);
    }
  } else if (ast.type === "ConditionalExpression") {
    const test = createRuntimeAst(expression, ast.test);
    left = createRuntimeAst(expression, ast.consequent);
    right = createRuntimeAst(expression, ast.alternate);
    node = new Node3(ExpressionNodeType_default.CONDITIONAL, "?", left, right, test);
  } else if (ast.type === "MemberExpression") {
    node = parseMemberExpression(expression, ast);
  } else if (ast.type === "ArrayExpression") {
    const val = [];
    for (let i2 = 0; i2 < ast.elements.length; i2++) {
      val[i2] = createRuntimeAst(expression, ast.elements[i2]);
    }
    node = new Node3(ExpressionNodeType_default.ARRAY, val);
  } else if (ast.type === "Compound") {
    throw new RuntimeError_default("Provide exactly one expression.");
  } else {
    throw new RuntimeError_default("Cannot parse expression.");
  }
  return node;
}
function setEvaluateFunction(node) {
  if (node._type === ExpressionNodeType_default.CONDITIONAL) {
    node.evaluate = node._evaluateConditional;
  } else if (node._type === ExpressionNodeType_default.FUNCTION_CALL) {
    if (node._value === "test") {
      node.evaluate = node._evaluateRegExpTest;
    } else if (node._value === "exec") {
      node.evaluate = node._evaluateRegExpExec;
    } else if (node._value === "toString") {
      node.evaluate = node._evaluateToString;
    }
  } else if (node._type === ExpressionNodeType_default.UNARY) {
    if (node._value === "!") {
      node.evaluate = node._evaluateNot;
    } else if (node._value === "-") {
      node.evaluate = node._evaluateNegative;
    } else if (node._value === "+") {
      node.evaluate = node._evaluatePositive;
    } else if (node._value === "isNaN") {
      node.evaluate = node._evaluateNaN;
    } else if (node._value === "isFinite") {
      node.evaluate = node._evaluateIsFinite;
    } else if (node._value === "isExactClass") {
      node.evaluate = node._evaluateIsExactClass;
    } else if (node._value === "isClass") {
      node.evaluate = node._evaluateIsClass;
    } else if (node._value === "getExactClassName") {
      node.evaluate = node._evaluateGetExactClassName;
    } else if (node._value === "Boolean") {
      node.evaluate = node._evaluateBooleanConversion;
    } else if (node._value === "Number") {
      node.evaluate = node._evaluateNumberConversion;
    } else if (node._value === "String") {
      node.evaluate = node._evaluateStringConversion;
    } else if (defined_default(unaryFunctions[node._value])) {
      node.evaluate = getEvaluateUnaryFunction(node._value);
    }
  } else if (node._type === ExpressionNodeType_default.BINARY) {
    if (node._value === "+") {
      node.evaluate = node._evaluatePlus;
    } else if (node._value === "-") {
      node.evaluate = node._evaluateMinus;
    } else if (node._value === "*") {
      node.evaluate = node._evaluateTimes;
    } else if (node._value === "/") {
      node.evaluate = node._evaluateDivide;
    } else if (node._value === "%") {
      node.evaluate = node._evaluateMod;
    } else if (node._value === "===") {
      node.evaluate = node._evaluateEqualsStrict;
    } else if (node._value === "!==") {
      node.evaluate = node._evaluateNotEqualsStrict;
    } else if (node._value === "<") {
      node.evaluate = node._evaluateLessThan;
    } else if (node._value === "<=") {
      node.evaluate = node._evaluateLessThanOrEquals;
    } else if (node._value === ">") {
      node.evaluate = node._evaluateGreaterThan;
    } else if (node._value === ">=") {
      node.evaluate = node._evaluateGreaterThanOrEquals;
    } else if (node._value === "&&") {
      node.evaluate = node._evaluateAnd;
    } else if (node._value === "||") {
      node.evaluate = node._evaluateOr;
    } else if (node._value === "=~") {
      node.evaluate = node._evaluateRegExpMatch;
    } else if (node._value === "!~") {
      node.evaluate = node._evaluateRegExpNotMatch;
    } else if (defined_default(binaryFunctions[node._value])) {
      node.evaluate = getEvaluateBinaryFunction(node._value);
    }
  } else if (node._type === ExpressionNodeType_default.TERNARY) {
    node.evaluate = getEvaluateTernaryFunction(node._value);
  } else if (node._type === ExpressionNodeType_default.MEMBER) {
    if (node._value === "brackets") {
      node.evaluate = node._evaluateMemberBrackets;
    } else {
      node.evaluate = node._evaluateMemberDot;
    }
  } else if (node._type === ExpressionNodeType_default.ARRAY) {
    node.evaluate = node._evaluateArray;
  } else if (node._type === ExpressionNodeType_default.VARIABLE) {
    node.evaluate = node._evaluateVariable;
  } else if (node._type === ExpressionNodeType_default.VARIABLE_IN_STRING) {
    node.evaluate = node._evaluateVariableString;
  } else if (node._type === ExpressionNodeType_default.LITERAL_COLOR) {
    node.evaluate = node._evaluateLiteralColor;
  } else if (node._type === ExpressionNodeType_default.LITERAL_VECTOR) {
    node.evaluate = node._evaluateLiteralVector;
  } else if (node._type === ExpressionNodeType_default.LITERAL_STRING) {
    node.evaluate = node._evaluateLiteralString;
  } else if (node._type === ExpressionNodeType_default.REGEX) {
    node.evaluate = node._evaluateRegExp;
  } else if (node._type === ExpressionNodeType_default.BUILTIN_VARIABLE) {
    if (node._value === "tiles3d_tileset_time") {
      node.evaluate = evaluateTilesetTime;
    }
  } else {
    node.evaluate = node._evaluateLiteral;
  }
}
function evaluateTilesetTime(feature2) {
  if (!defined_default(feature2)) {
    return 0;
  }
  return feature2.content.tileset.timeSinceLoad;
}
function getEvaluateUnaryFunction(call) {
  const evaluate = unaryFunctions[call];
  return function(feature2) {
    const left = this._left.evaluate(feature2);
    return evaluate(call, left);
  };
}
function getEvaluateBinaryFunction(call) {
  const evaluate = binaryFunctions[call];
  return function(feature2) {
    const left = this._left.evaluate(feature2);
    const right = this._right.evaluate(feature2);
    return evaluate(call, left, right);
  };
}
function getEvaluateTernaryFunction(call) {
  const evaluate = ternaryFunctions[call];
  return function(feature2) {
    const left = this._left.evaluate(feature2);
    const right = this._right.evaluate(feature2);
    const test = this._test.evaluate(feature2);
    return evaluate(call, left, right, test);
  };
}
function getFeatureProperty(feature2, name) {
  if (defined_default(feature2)) {
    return feature2.getPropertyInherited(name);
  }
}
Node3.prototype._evaluateLiteral = function() {
  return this._value;
};
Node3.prototype._evaluateLiteralColor = function(feature2) {
  const color = scratchColor3;
  const args = this._left;
  if (this._value === "color") {
    if (!defined_default(args)) {
      Color_default.fromBytes(255, 255, 255, 255, color);
    } else if (args.length > 1) {
      Color_default.fromCssColorString(args[0].evaluate(feature2), color);
      color.alpha = args[1].evaluate(feature2);
    } else {
      Color_default.fromCssColorString(args[0].evaluate(feature2), color);
    }
  } else if (this._value === "rgb") {
    Color_default.fromBytes(
      args[0].evaluate(feature2),
      args[1].evaluate(feature2),
      args[2].evaluate(feature2),
      255,
      color
    );
  } else if (this._value === "rgba") {
    const a4 = args[3].evaluate(feature2) * 255;
    Color_default.fromBytes(
      args[0].evaluate(feature2),
      args[1].evaluate(feature2),
      args[2].evaluate(feature2),
      a4,
      color
    );
  } else if (this._value === "hsl") {
    Color_default.fromHsl(
      args[0].evaluate(feature2),
      args[1].evaluate(feature2),
      args[2].evaluate(feature2),
      1,
      color
    );
  } else if (this._value === "hsla") {
    Color_default.fromHsl(
      args[0].evaluate(feature2),
      args[1].evaluate(feature2),
      args[2].evaluate(feature2),
      args[3].evaluate(feature2),
      color
    );
  }
  return Cartesian4_default.fromColor(color, scratchStorage.getCartesian4());
};
Node3.prototype._evaluateLiteralVector = function(feature2) {
  const components = scratchStorage.getArray();
  const call = this._value;
  const args = this._left;
  const argsLength = args.length;
  for (let i2 = 0; i2 < argsLength; ++i2) {
    const value = args[i2].evaluate(feature2);
    if (typeof value === "number") {
      components.push(value);
    } else if (value instanceof Cartesian2_default) {
      components.push(value.x, value.y);
    } else if (value instanceof Cartesian3_default) {
      components.push(value.x, value.y, value.z);
    } else if (value instanceof Cartesian4_default) {
      components.push(value.x, value.y, value.z, value.w);
    } else {
      throw new RuntimeError_default(
        `${call} argument must be a vector or number. Argument is ${value}.`
      );
    }
  }
  const componentsLength = components.length;
  const vectorLength = parseInt(call.charAt(3));
  if (componentsLength === 0) {
    throw new RuntimeError_default(`Invalid ${call} constructor. No valid arguments.`);
  } else if (componentsLength < vectorLength && componentsLength > 1) {
    throw new RuntimeError_default(
      `Invalid ${call} constructor. Not enough arguments.`
    );
  } else if (componentsLength > vectorLength && argsLength > 1) {
    throw new RuntimeError_default(`Invalid ${call} constructor. Too many arguments.`);
  }
  if (componentsLength === 1) {
    const component = components[0];
    components.push(component, component, component);
  }
  if (call === "vec2") {
    return Cartesian2_default.fromArray(components, 0, scratchStorage.getCartesian2());
  } else if (call === "vec3") {
    return Cartesian3_default.fromArray(components, 0, scratchStorage.getCartesian3());
  } else if (call === "vec4") {
    return Cartesian4_default.fromArray(components, 0, scratchStorage.getCartesian4());
  }
};
Node3.prototype._evaluateLiteralString = function() {
  return this._value;
};
Node3.prototype._evaluateVariableString = function(feature2) {
  let result = this._value;
  let match = variableRegex.exec(result);
  while (match !== null) {
    const placeholder = match[0];
    const variableName = match[1];
    let property = getFeatureProperty(feature2, variableName);
    if (!defined_default(property)) {
      property = "";
    }
    result = result.replace(placeholder, property);
    match = variableRegex.exec(result);
  }
  return result;
};
Node3.prototype._evaluateVariable = function(feature2) {
  return getFeatureProperty(feature2, this._value);
};
function checkFeature(ast) {
  return ast._value === "feature";
}
Node3.prototype._evaluateMemberDot = function(feature2) {
  if (checkFeature(this._left)) {
    return getFeatureProperty(feature2, this._right.evaluate(feature2));
  }
  const property = this._left.evaluate(feature2);
  if (!defined_default(property)) {
    return void 0;
  }
  const member = this._right.evaluate(feature2);
  if (property instanceof Cartesian2_default || property instanceof Cartesian3_default || property instanceof Cartesian4_default) {
    if (member === "r") {
      return property.x;
    } else if (member === "g") {
      return property.y;
    } else if (member === "b") {
      return property.z;
    } else if (member === "a") {
      return property.w;
    }
  }
  return property[member];
};
Node3.prototype._evaluateMemberBrackets = function(feature2) {
  if (checkFeature(this._left)) {
    return getFeatureProperty(feature2, this._right.evaluate(feature2));
  }
  const property = this._left.evaluate(feature2);
  if (!defined_default(property)) {
    return void 0;
  }
  const member = this._right.evaluate(feature2);
  if (property instanceof Cartesian2_default || property instanceof Cartesian3_default || property instanceof Cartesian4_default) {
    if (member === 0 || member === "r") {
      return property.x;
    } else if (member === 1 || member === "g") {
      return property.y;
    } else if (member === 2 || member === "b") {
      return property.z;
    } else if (member === 3 || member === "a") {
      return property.w;
    }
  }
  return property[member];
};
Node3.prototype._evaluateArray = function(feature2) {
  const array = [];
  for (let i2 = 0; i2 < this._value.length; i2++) {
    array[i2] = this._value[i2].evaluate(feature2);
  }
  return array;
};
Node3.prototype._evaluateNot = function(feature2) {
  const left = this._left.evaluate(feature2);
  if (typeof left !== "boolean") {
    throw new RuntimeError_default(
      `Operator "!" requires a boolean argument. Argument is ${left}.`
    );
  }
  return !left;
};
Node3.prototype._evaluateNegative = function(feature2) {
  const left = this._left.evaluate(feature2);
  if (left instanceof Cartesian2_default) {
    return Cartesian2_default.negate(left, scratchStorage.getCartesian2());
  } else if (left instanceof Cartesian3_default) {
    return Cartesian3_default.negate(left, scratchStorage.getCartesian3());
  } else if (left instanceof Cartesian4_default) {
    return Cartesian4_default.negate(left, scratchStorage.getCartesian4());
  } else if (typeof left === "number") {
    return -left;
  }
  throw new RuntimeError_default(
    `Operator "-" requires a vector or number argument. Argument is ${left}.`
  );
};
Node3.prototype._evaluatePositive = function(feature2) {
  const left = this._left.evaluate(feature2);
  if (!(left instanceof Cartesian2_default || left instanceof Cartesian3_default || left instanceof Cartesian4_default || typeof left === "number")) {
    throw new RuntimeError_default(
      `Operator "+" requires a vector or number argument. Argument is ${left}.`
    );
  }
  return left;
};
Node3.prototype._evaluateLessThan = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (typeof left !== "number" || typeof right !== "number") {
    throw new RuntimeError_default(
      `Operator "<" requires number arguments. Arguments are ${left} and ${right}.`
    );
  }
  return left < right;
};
Node3.prototype._evaluateLessThanOrEquals = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (typeof left !== "number" || typeof right !== "number") {
    throw new RuntimeError_default(
      `Operator "<=" requires number arguments. Arguments are ${left} and ${right}.`
    );
  }
  return left <= right;
};
Node3.prototype._evaluateGreaterThan = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (typeof left !== "number" || typeof right !== "number") {
    throw new RuntimeError_default(
      `Operator ">" requires number arguments. Arguments are ${left} and ${right}.`
    );
  }
  return left > right;
};
Node3.prototype._evaluateGreaterThanOrEquals = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (typeof left !== "number" || typeof right !== "number") {
    throw new RuntimeError_default(
      `Operator ">=" requires number arguments. Arguments are ${left} and ${right}.`
    );
  }
  return left >= right;
};
Node3.prototype._evaluateOr = function(feature2) {
  const left = this._left.evaluate(feature2);
  if (typeof left !== "boolean") {
    throw new RuntimeError_default(
      `Operator "||" requires boolean arguments. First argument is ${left}.`
    );
  }
  if (left) {
    return true;
  }
  const right = this._right.evaluate(feature2);
  if (typeof right !== "boolean") {
    throw new RuntimeError_default(
      `Operator "||" requires boolean arguments. Second argument is ${right}.`
    );
  }
  return left || right;
};
Node3.prototype._evaluateAnd = function(feature2) {
  const left = this._left.evaluate(feature2);
  if (typeof left !== "boolean") {
    throw new RuntimeError_default(
      `Operator "&&" requires boolean arguments. First argument is ${left}.`
    );
  }
  if (!left) {
    return false;
  }
  const right = this._right.evaluate(feature2);
  if (typeof right !== "boolean") {
    throw new RuntimeError_default(
      `Operator "&&" requires boolean arguments. Second argument is ${right}.`
    );
  }
  return left && right;
};
Node3.prototype._evaluatePlus = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (right instanceof Cartesian2_default && left instanceof Cartesian2_default) {
    return Cartesian2_default.add(left, right, scratchStorage.getCartesian2());
  } else if (right instanceof Cartesian3_default && left instanceof Cartesian3_default) {
    return Cartesian3_default.add(left, right, scratchStorage.getCartesian3());
  } else if (right instanceof Cartesian4_default && left instanceof Cartesian4_default) {
    return Cartesian4_default.add(left, right, scratchStorage.getCartesian4());
  } else if (typeof left === "string" || typeof right === "string") {
    return left + right;
  } else if (typeof left === "number" && typeof right === "number") {
    return left + right;
  }
  throw new RuntimeError_default(
    `Operator "+" requires vector or number arguments of matching types, or at least one string argument. Arguments are ${left} and ${right}.`
  );
};
Node3.prototype._evaluateMinus = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (right instanceof Cartesian2_default && left instanceof Cartesian2_default) {
    return Cartesian2_default.subtract(left, right, scratchStorage.getCartesian2());
  } else if (right instanceof Cartesian3_default && left instanceof Cartesian3_default) {
    return Cartesian3_default.subtract(left, right, scratchStorage.getCartesian3());
  } else if (right instanceof Cartesian4_default && left instanceof Cartesian4_default) {
    return Cartesian4_default.subtract(left, right, scratchStorage.getCartesian4());
  } else if (typeof left === "number" && typeof right === "number") {
    return left - right;
  }
  throw new RuntimeError_default(
    `Operator "-" requires vector or number arguments of matching types. Arguments are ${left} and ${right}.`
  );
};
Node3.prototype._evaluateTimes = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (right instanceof Cartesian2_default && left instanceof Cartesian2_default) {
    return Cartesian2_default.multiplyComponents(
      left,
      right,
      scratchStorage.getCartesian2()
    );
  } else if (right instanceof Cartesian2_default && typeof left === "number") {
    return Cartesian2_default.multiplyByScalar(
      right,
      left,
      scratchStorage.getCartesian2()
    );
  } else if (left instanceof Cartesian2_default && typeof right === "number") {
    return Cartesian2_default.multiplyByScalar(
      left,
      right,
      scratchStorage.getCartesian2()
    );
  } else if (right instanceof Cartesian3_default && left instanceof Cartesian3_default) {
    return Cartesian3_default.multiplyComponents(
      left,
      right,
      scratchStorage.getCartesian3()
    );
  } else if (right instanceof Cartesian3_default && typeof left === "number") {
    return Cartesian3_default.multiplyByScalar(
      right,
      left,
      scratchStorage.getCartesian3()
    );
  } else if (left instanceof Cartesian3_default && typeof right === "number") {
    return Cartesian3_default.multiplyByScalar(
      left,
      right,
      scratchStorage.getCartesian3()
    );
  } else if (right instanceof Cartesian4_default && left instanceof Cartesian4_default) {
    return Cartesian4_default.multiplyComponents(
      left,
      right,
      scratchStorage.getCartesian4()
    );
  } else if (right instanceof Cartesian4_default && typeof left === "number") {
    return Cartesian4_default.multiplyByScalar(
      right,
      left,
      scratchStorage.getCartesian4()
    );
  } else if (left instanceof Cartesian4_default && typeof right === "number") {
    return Cartesian4_default.multiplyByScalar(
      left,
      right,
      scratchStorage.getCartesian4()
    );
  } else if (typeof left === "number" && typeof right === "number") {
    return left * right;
  }
  throw new RuntimeError_default(
    `Operator "*" requires vector or number arguments. If both arguments are vectors they must be matching types. Arguments are ${left} and ${right}.`
  );
};
Node3.prototype._evaluateDivide = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (right instanceof Cartesian2_default && left instanceof Cartesian2_default) {
    return Cartesian2_default.divideComponents(
      left,
      right,
      scratchStorage.getCartesian2()
    );
  } else if (left instanceof Cartesian2_default && typeof right === "number") {
    return Cartesian2_default.divideByScalar(
      left,
      right,
      scratchStorage.getCartesian2()
    );
  } else if (right instanceof Cartesian3_default && left instanceof Cartesian3_default) {
    return Cartesian3_default.divideComponents(
      left,
      right,
      scratchStorage.getCartesian3()
    );
  } else if (left instanceof Cartesian3_default && typeof right === "number") {
    return Cartesian3_default.divideByScalar(
      left,
      right,
      scratchStorage.getCartesian3()
    );
  } else if (right instanceof Cartesian4_default && left instanceof Cartesian4_default) {
    return Cartesian4_default.divideComponents(
      left,
      right,
      scratchStorage.getCartesian4()
    );
  } else if (left instanceof Cartesian4_default && typeof right === "number") {
    return Cartesian4_default.divideByScalar(
      left,
      right,
      scratchStorage.getCartesian4()
    );
  } else if (typeof left === "number" && typeof right === "number") {
    return left / right;
  }
  throw new RuntimeError_default(
    `Operator "/" requires vector or number arguments of matching types, or a number as the second argument. Arguments are ${left} and ${right}.`
  );
};
Node3.prototype._evaluateMod = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (right instanceof Cartesian2_default && left instanceof Cartesian2_default) {
    return Cartesian2_default.fromElements(
      left.x % right.x,
      left.y % right.y,
      scratchStorage.getCartesian2()
    );
  } else if (right instanceof Cartesian3_default && left instanceof Cartesian3_default) {
    return Cartesian3_default.fromElements(
      left.x % right.x,
      left.y % right.y,
      left.z % right.z,
      scratchStorage.getCartesian3()
    );
  } else if (right instanceof Cartesian4_default && left instanceof Cartesian4_default) {
    return Cartesian4_default.fromElements(
      left.x % right.x,
      left.y % right.y,
      left.z % right.z,
      left.w % right.w,
      scratchStorage.getCartesian4()
    );
  } else if (typeof left === "number" && typeof right === "number") {
    return left % right;
  }
  throw new RuntimeError_default(
    `Operator "%" requires vector or number arguments of matching types. Arguments are ${left} and ${right}.`
  );
};
Node3.prototype._evaluateEqualsStrict = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (right instanceof Cartesian2_default && left instanceof Cartesian2_default || right instanceof Cartesian3_default && left instanceof Cartesian3_default || right instanceof Cartesian4_default && left instanceof Cartesian4_default) {
    return left.equals(right);
  }
  return left === right;
};
Node3.prototype._evaluateNotEqualsStrict = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (right instanceof Cartesian2_default && left instanceof Cartesian2_default || right instanceof Cartesian3_default && left instanceof Cartesian3_default || right instanceof Cartesian4_default && left instanceof Cartesian4_default) {
    return !left.equals(right);
  }
  return left !== right;
};
Node3.prototype._evaluateConditional = function(feature2) {
  const test = this._test.evaluate(feature2);
  if (typeof test !== "boolean") {
    throw new RuntimeError_default(
      `Conditional argument of conditional expression must be a boolean. Argument is ${test}.`
    );
  }
  if (test) {
    return this._left.evaluate(feature2);
  }
  return this._right.evaluate(feature2);
};
Node3.prototype._evaluateNaN = function(feature2) {
  return isNaN(this._left.evaluate(feature2));
};
Node3.prototype._evaluateIsFinite = function(feature2) {
  return isFinite(this._left.evaluate(feature2));
};
Node3.prototype._evaluateIsExactClass = function(feature2) {
  if (defined_default(feature2)) {
    return feature2.isExactClass(this._left.evaluate(feature2));
  }
  return false;
};
Node3.prototype._evaluateIsClass = function(feature2) {
  if (defined_default(feature2)) {
    return feature2.isClass(this._left.evaluate(feature2));
  }
  return false;
};
Node3.prototype._evaluateGetExactClassName = function(feature2) {
  if (defined_default(feature2)) {
    return feature2.getExactClassName();
  }
};
Node3.prototype._evaluateBooleanConversion = function(feature2) {
  return Boolean(this._left.evaluate(feature2));
};
Node3.prototype._evaluateNumberConversion = function(feature2) {
  return Number(this._left.evaluate(feature2));
};
Node3.prototype._evaluateStringConversion = function(feature2) {
  return String(this._left.evaluate(feature2));
};
Node3.prototype._evaluateRegExp = function(feature2) {
  const pattern = this._value.evaluate(feature2);
  let flags = "";
  if (defined_default(this._left)) {
    flags = this._left.evaluate(feature2);
  }
  let exp;
  try {
    exp = new RegExp(pattern, flags);
  } catch (e2) {
    throw new RuntimeError_default(e2);
  }
  return exp;
};
Node3.prototype._evaluateRegExpTest = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (!(left instanceof RegExp && typeof right === "string")) {
    throw new RuntimeError_default(
      `RegExp.test requires the first argument to be a RegExp and the second argument to be a string. Arguments are ${left} and ${right}.`
    );
  }
  return left.test(right);
};
Node3.prototype._evaluateRegExpMatch = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (left instanceof RegExp && typeof right === "string") {
    return left.test(right);
  } else if (right instanceof RegExp && typeof left === "string") {
    return right.test(left);
  }
  throw new RuntimeError_default(
    `Operator "=~" requires one RegExp argument and one string argument. Arguments are ${left} and ${right}.`
  );
};
Node3.prototype._evaluateRegExpNotMatch = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (left instanceof RegExp && typeof right === "string") {
    return !left.test(right);
  } else if (right instanceof RegExp && typeof left === "string") {
    return !right.test(left);
  }
  throw new RuntimeError_default(
    `Operator "!~" requires one RegExp argument and one string argument. Arguments are ${left} and ${right}.`
  );
};
Node3.prototype._evaluateRegExpExec = function(feature2) {
  const left = this._left.evaluate(feature2);
  const right = this._right.evaluate(feature2);
  if (!(left instanceof RegExp && typeof right === "string")) {
    throw new RuntimeError_default(
      `RegExp.exec requires the first argument to be a RegExp and the second argument to be a string. Arguments are ${left} and ${right}.`
    );
  }
  const exec = left.exec(right);
  if (!defined_default(exec)) {
    return null;
  }
  return exec[1];
};
Node3.prototype._evaluateToString = function(feature2) {
  const left = this._left.evaluate(feature2);
  if (left instanceof RegExp || left instanceof Cartesian2_default || left instanceof Cartesian3_default || left instanceof Cartesian4_default) {
    return String(left);
  }
  throw new RuntimeError_default(`Unexpected function call "${this._value}".`);
};
function convertHSLToRGB(ast) {
  const channels = ast._left;
  const length3 = channels.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (channels[i2]._type !== ExpressionNodeType_default.LITERAL_NUMBER) {
      return void 0;
    }
  }
  const h = channels[0]._value;
  const s2 = channels[1]._value;
  const l2 = channels[2]._value;
  const a4 = length3 === 4 ? channels[3]._value : 1;
  return Color_default.fromHsl(h, s2, l2, a4, scratchColor3);
}
function convertRGBToColor(ast) {
  const channels = ast._left;
  const length3 = channels.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (channels[i2]._type !== ExpressionNodeType_default.LITERAL_NUMBER) {
      return void 0;
    }
  }
  const color = scratchColor3;
  color.red = channels[0]._value / 255;
  color.green = channels[1]._value / 255;
  color.blue = channels[2]._value / 255;
  color.alpha = length3 === 4 ? channels[3]._value : 1;
  return color;
}
function numberToString(number) {
  if (number % 1 === 0) {
    return number.toFixed(1);
  }
  return number.toString();
}
function colorToVec3(color) {
  const r2 = numberToString(color.red);
  const g = numberToString(color.green);
  const b = numberToString(color.blue);
  return `vec3(${r2}, ${g}, ${b})`;
}
function colorToVec4(color) {
  const r2 = numberToString(color.red);
  const g = numberToString(color.green);
  const b = numberToString(color.blue);
  const a4 = numberToString(color.alpha);
  return `vec4(${r2}, ${g}, ${b}, ${a4})`;
}
function getExpressionArray(array, variableSubstitutionMap, shaderState, parent) {
  const length3 = array.length;
  const expressions = new Array(length3);
  for (let i2 = 0; i2 < length3; ++i2) {
    expressions[i2] = array[i2].getShaderExpression(
      variableSubstitutionMap,
      shaderState,
      parent
    );
  }
  return expressions;
}
function getVariableName(variableName, variableSubstitutionMap) {
  if (!defined_default(variableSubstitutionMap[variableName])) {
    return Expression.NULL_SENTINEL;
  }
  return variableSubstitutionMap[variableName];
}
Expression.NULL_SENTINEL = "czm_infinity";
Node3.prototype.getShaderExpression = function(variableSubstitutionMap, shaderState, parent) {
  let color;
  let left;
  let right;
  let test;
  const type = this._type;
  let value = this._value;
  if (defined_default(this._left)) {
    if (Array.isArray(this._left)) {
      left = getExpressionArray(
        this._left,
        variableSubstitutionMap,
        shaderState,
        this
      );
    } else {
      left = this._left.getShaderExpression(
        variableSubstitutionMap,
        shaderState,
        this
      );
    }
  }
  if (defined_default(this._right)) {
    right = this._right.getShaderExpression(
      variableSubstitutionMap,
      shaderState,
      this
    );
  }
  if (defined_default(this._test)) {
    test = this._test.getShaderExpression(
      variableSubstitutionMap,
      shaderState,
      this
    );
  }
  if (Array.isArray(this._value)) {
    value = getExpressionArray(
      this._value,
      variableSubstitutionMap,
      shaderState,
      this
    );
  }
  let args;
  let length3;
  let vectorExpression;
  switch (type) {
    case ExpressionNodeType_default.VARIABLE:
      if (checkFeature(this)) {
        return void 0;
      }
      return getVariableName(value, variableSubstitutionMap);
    case ExpressionNodeType_default.UNARY:
      if (value === "Boolean") {
        return `bool(${left})`;
      } else if (value === "Number") {
        return `float(${left})`;
      } else if (value === "round") {
        return `floor(${left} + 0.5)`;
      } else if (defined_default(unaryFunctions[value])) {
        return `${value}(${left})`;
      } else if (value === "isNaN") {
        return `(${left} != ${left})`;
      } else if (value === "isFinite") {
        return `(abs(${left}) < czm_infinity)`;
      } else if (value === "String" || value === "isExactClass" || value === "isClass" || value === "getExactClassName") {
        throw new RuntimeError_default(
          `Error generating style shader: "${value}" is not supported.`
        );
      }
      return value + left;
    case ExpressionNodeType_default.BINARY:
      if (value === "%") {
        return `mod(${left}, ${right})`;
      } else if (value === "===") {
        return `(${left} == ${right})`;
      } else if (value === "!==") {
        return `(${left} != ${right})`;
      } else if (value === "atan2") {
        return `atan(${left}, ${right})`;
      } else if (defined_default(binaryFunctions[value])) {
        return `${value}(${left}, ${right})`;
      }
      return `(${left} ${value} ${right})`;
    case ExpressionNodeType_default.TERNARY:
      if (defined_default(ternaryFunctions[value])) {
        return `${value}(${left}, ${right}, ${test})`;
      }
      break;
    case ExpressionNodeType_default.CONDITIONAL:
      return `(${test} ? ${left} : ${right})`;
    case ExpressionNodeType_default.MEMBER:
      if (checkFeature(this._left)) {
        return getVariableName(right, variableSubstitutionMap);
      }
      if (right === "r" || right === "x" || right === "0.0") {
        return `${left}[0]`;
      } else if (right === "g" || right === "y" || right === "1.0") {
        return `${left}[1]`;
      } else if (right === "b" || right === "z" || right === "2.0") {
        return `${left}[2]`;
      } else if (right === "a" || right === "w" || right === "3.0") {
        return `${left}[3]`;
      }
      return `${left}[int(${right})]`;
    case ExpressionNodeType_default.FUNCTION_CALL:
      throw new RuntimeError_default(
        `Error generating style shader: "${value}" is not supported.`
      );
    case ExpressionNodeType_default.ARRAY:
      if (value.length === 4) {
        return `vec4(${value[0]}, ${value[1]}, ${value[2]}, ${value[3]})`;
      } else if (value.length === 3) {
        return `vec3(${value[0]}, ${value[1]}, ${value[2]})`;
      } else if (value.length === 2) {
        return `vec2(${value[0]}, ${value[1]})`;
      }
      throw new RuntimeError_default(
        "Error generating style shader: Invalid array length. Array length should be 2, 3, or 4."
      );
    case ExpressionNodeType_default.REGEX:
      throw new RuntimeError_default(
        "Error generating style shader: Regular expressions are not supported."
      );
    case ExpressionNodeType_default.VARIABLE_IN_STRING:
      throw new RuntimeError_default(
        "Error generating style shader: Converting a variable to a string is not supported."
      );
    case ExpressionNodeType_default.LITERAL_NULL:
      return Expression.NULL_SENTINEL;
    case ExpressionNodeType_default.LITERAL_BOOLEAN:
      return value ? "true" : "false";
    case ExpressionNodeType_default.LITERAL_NUMBER:
      return numberToString(value);
    case ExpressionNodeType_default.LITERAL_STRING:
      if (defined_default(parent) && parent._type === ExpressionNodeType_default.MEMBER) {
        if (value === "r" || value === "g" || value === "b" || value === "a" || value === "x" || value === "y" || value === "z" || value === "w" || checkFeature(parent._left)) {
          return value;
        }
      }
      color = Color_default.fromCssColorString(value, scratchColor3);
      if (defined_default(color)) {
        return colorToVec3(color);
      }
      throw new RuntimeError_default(
        "Error generating style shader: String literals are not supported."
      );
    case ExpressionNodeType_default.LITERAL_COLOR:
      args = left;
      if (value === "color") {
        if (!defined_default(args)) {
          return "vec4(1.0)";
        } else if (args.length > 1) {
          const rgb = args[0];
          const alpha = args[1];
          if (alpha !== "1.0") {
            shaderState.translucent = true;
          }
          return `vec4(${rgb}, ${alpha})`;
        }
        return `vec4(${args[0]}, 1.0)`;
      } else if (value === "rgb") {
        color = convertRGBToColor(this);
        if (defined_default(color)) {
          return colorToVec4(color);
        }
        return `vec4(${args[0]} / 255.0, ${args[1]} / 255.0, ${args[2]} / 255.0, 1.0)`;
      } else if (value === "rgba") {
        if (args[3] !== "1.0") {
          shaderState.translucent = true;
        }
        color = convertRGBToColor(this);
        if (defined_default(color)) {
          return colorToVec4(color);
        }
        return `vec4(${args[0]} / 255.0, ${args[1]} / 255.0, ${args[2]} / 255.0, ${args[3]})`;
      } else if (value === "hsl") {
        color = convertHSLToRGB(this);
        if (defined_default(color)) {
          return colorToVec4(color);
        }
        return `vec4(czm_HSLToRGB(vec3(${args[0]}, ${args[1]}, ${args[2]})), 1.0)`;
      } else if (value === "hsla") {
        color = convertHSLToRGB(this);
        if (defined_default(color)) {
          if (color.alpha !== 1) {
            shaderState.translucent = true;
          }
          return colorToVec4(color);
        }
        if (args[3] !== "1.0") {
          shaderState.translucent = true;
        }
        return `vec4(czm_HSLToRGB(vec3(${args[0]}, ${args[1]}, ${args[2]})), ${args[3]})`;
      }
      break;
    case ExpressionNodeType_default.LITERAL_VECTOR:
      if (!defined_default(left)) {
        throw new DeveloperError_default(
          "left should always be defined for type ExpressionNodeType.LITERAL_VECTOR"
        );
      }
      length3 = left.length;
      vectorExpression = `${value}(`;
      for (let i2 = 0; i2 < length3; ++i2) {
        vectorExpression += left[i2];
        if (i2 < length3 - 1) {
          vectorExpression += ", ";
        }
      }
      vectorExpression += ")";
      return vectorExpression;
    case ExpressionNodeType_default.LITERAL_REGEX:
      throw new RuntimeError_default(
        "Error generating style shader: Regular expressions are not supported."
      );
    case ExpressionNodeType_default.LITERAL_UNDEFINED:
      return Expression.NULL_SENTINEL;
    case ExpressionNodeType_default.BUILTIN_VARIABLE:
      if (value === "tiles3d_tileset_time") {
        return "u_time";
      }
  }
};
Node3.prototype.getVariables = function(variables, parent) {
  let array;
  let length3;
  let i2;
  const type = this._type;
  const value = this._value;
  if (defined_default(this._left)) {
    if (Array.isArray(this._left)) {
      array = this._left;
      length3 = array.length;
      for (i2 = 0; i2 < length3; ++i2) {
        array[i2].getVariables(variables, this);
      }
    } else {
      this._left.getVariables(variables, this);
    }
  }
  if (defined_default(this._right)) {
    this._right.getVariables(variables, this);
  }
  if (defined_default(this._test)) {
    this._test.getVariables(variables, this);
  }
  if (Array.isArray(this._value)) {
    array = this._value;
    length3 = array.length;
    for (i2 = 0; i2 < length3; ++i2) {
      array[i2].getVariables(variables, this);
    }
  }
  let match;
  switch (type) {
    case ExpressionNodeType_default.VARIABLE:
      if (!checkFeature(this)) {
        variables.push(value);
      }
      break;
    case ExpressionNodeType_default.VARIABLE_IN_STRING:
      match = variableRegex.exec(value);
      while (match !== null) {
        variables.push(match[1]);
        match = variableRegex.exec(value);
      }
      break;
    case ExpressionNodeType_default.LITERAL_STRING:
      if (defined_default(parent) && parent._type === ExpressionNodeType_default.MEMBER && checkFeature(parent._left)) {
        variables.push(value);
      }
      break;
  }
};
var Expression_default = Expression;

// node_modules/cesium/Source/Scene/Vector3DTilePrimitive.js
function Vector3DTilePrimitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._batchTable = options.batchTable;
  this._batchIds = options.batchIds;
  this._positions = options.positions;
  this._vertexBatchIds = options.vertexBatchIds;
  this._indices = options.indices;
  this._indexCounts = options.indexCounts;
  this._indexOffsets = options.indexOffsets;
  this._batchedIndices = options.batchedIndices;
  this._boundingVolume = options.boundingVolume;
  this._boundingVolumes = options.boundingVolumes;
  this._center = defaultValue_default(options.center, Cartesian3_default.ZERO);
  this._va = void 0;
  this._sp = void 0;
  this._spStencil = void 0;
  this._spPick = void 0;
  this._uniformMap = void 0;
  this._vaSwap = void 0;
  this._rsStencilDepthPass = void 0;
  this._rsStencilDepthPass3DTiles = void 0;
  this._rsColorPass = void 0;
  this._rsPickPass = void 0;
  this._rsWireframe = void 0;
  this._commands = [];
  this._commandsIgnoreShow = [];
  this._pickCommands = [];
  this._constantColor = Color_default.clone(Color_default.WHITE);
  this._highlightColor = this._constantColor;
  this._batchDirty = true;
  this._pickCommandsDirty = true;
  this._framesSinceLastRebatch = 0;
  this._updatingAllCommands = false;
  this._trianglesLength = this._indices.length / 3;
  this._geometryByteLength = this._indices.byteLength + this._positions.byteLength + this._vertexBatchIds.byteLength;
  this.debugWireframe = false;
  this._debugWireframe = this.debugWireframe;
  this._wireframeDirty = false;
  this.forceRebatch = false;
  this.classificationType = defaultValue_default(
    options.classificationType,
    ClassificationType_default.BOTH
  );
  this._vertexShaderSource = options._vertexShaderSource;
  this._fragmentShaderSource = options._fragmentShaderSource;
  this._attributeLocations = options._attributeLocations;
  this._uniformMap = options._uniformMap;
  this._pickId = options._pickId;
  this._modelMatrix = options._modelMatrix;
  this._boundingSphere = options._boundingSphere;
  this._batchIdLookUp = {};
  const length3 = this._batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = this._batchIds[i2];
    this._batchIdLookUp[batchId] = i2;
  }
}
Object.defineProperties(Vector3DTilePrimitive.prototype, {
  trianglesLength: {
    get: function() {
      return this._trianglesLength;
    }
  },
  geometryByteLength: {
    get: function() {
      return this._geometryByteLength;
    }
  }
});
var defaultAttributeLocations = {
  position: 0,
  a_batchId: 1
};
function createVertexArray3(primitive, context) {
  if (defined_default(primitive._va)) {
    return;
  }
  const positionBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: primitive._positions,
    usage: BufferUsage_default.STATIC_DRAW
  });
  const idBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: primitive._vertexBatchIds,
    usage: BufferUsage_default.STATIC_DRAW
  });
  const indexBuffer = Buffer_default.createIndexBuffer({
    context,
    typedArray: primitive._indices,
    usage: BufferUsage_default.DYNAMIC_DRAW,
    indexDatatype: primitive._indices.BYTES_PER_ELEMENT === 2 ? IndexDatatype_default.UNSIGNED_SHORT : IndexDatatype_default.UNSIGNED_INT
  });
  const vertexAttributes = [
    {
      index: 0,
      vertexBuffer: positionBuffer,
      componentDatatype: ComponentDatatype_default.fromTypedArray(primitive._positions),
      componentsPerAttribute: 3
    },
    {
      index: 1,
      vertexBuffer: idBuffer,
      componentDatatype: ComponentDatatype_default.fromTypedArray(
        primitive._vertexBatchIds
      ),
      componentsPerAttribute: 1
    }
  ];
  primitive._va = new VertexArray_default({
    context,
    attributes: vertexAttributes,
    indexBuffer
  });
  if (context.webgl2) {
    primitive._vaSwap = new VertexArray_default({
      context,
      attributes: vertexAttributes,
      indexBuffer: Buffer_default.createIndexBuffer({
        context,
        sizeInBytes: indexBuffer.sizeInBytes,
        usage: BufferUsage_default.DYNAMIC_DRAW,
        indexDatatype: indexBuffer.indexDatatype
      })
    });
  }
  primitive._batchedPositions = void 0;
  primitive._transferrableBatchIds = void 0;
  primitive._vertexBatchIds = void 0;
  primitive._verticesPromise = void 0;
}
function createShaders(primitive, context) {
  if (defined_default(primitive._sp)) {
    return;
  }
  const batchTable = primitive._batchTable;
  const attributeLocations8 = defaultValue_default(
    primitive._attributeLocations,
    defaultAttributeLocations
  );
  let pickId = primitive._pickId;
  const vertexShaderSource = primitive._vertexShaderSource;
  let fragmentShaderSource = primitive._fragmentShaderSource;
  if (defined_default(vertexShaderSource)) {
    primitive._sp = ShaderProgram_default.fromCache({
      context,
      vertexShaderSource,
      fragmentShaderSource,
      attributeLocations: attributeLocations8
    });
    primitive._spStencil = primitive._sp;
    fragmentShaderSource = ShaderSource_default.replaceMain(
      fragmentShaderSource,
      "czm_non_pick_main"
    );
    fragmentShaderSource = `${fragmentShaderSource}void main() 
{ 
    czm_non_pick_main(); 
    gl_FragColor = ${pickId}; 
} 
`;
    primitive._spPick = ShaderProgram_default.fromCache({
      context,
      vertexShaderSource,
      fragmentShaderSource,
      attributeLocations: attributeLocations8
    });
    return;
  }
  const vsSource = batchTable.getVertexShaderCallback(
    false,
    "a_batchId",
    void 0
  )(VectorTileVS_default);
  let fsSource = batchTable.getFragmentShaderCallback(
    false,
    void 0,
    true
  )(ShadowVolumeFS_default);
  pickId = batchTable.getPickId();
  let vs = new ShaderSource_default({
    sources: [vsSource]
  });
  let fs = new ShaderSource_default({
    defines: ["VECTOR_TILE"],
    sources: [fsSource]
  });
  primitive._sp = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: vs,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations8
  });
  vs = new ShaderSource_default({
    sources: [VectorTileVS_default]
  });
  fs = new ShaderSource_default({
    defines: ["VECTOR_TILE"],
    sources: [ShadowVolumeFS_default]
  });
  primitive._spStencil = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: vs,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations8
  });
  fsSource = ShaderSource_default.replaceMain(fsSource, "czm_non_pick_main");
  fsSource = `${fsSource}
void main() 
{ 
    czm_non_pick_main(); 
    gl_FragColor = ${pickId}; 
} 
`;
  const pickVS = new ShaderSource_default({
    sources: [vsSource]
  });
  const pickFS = new ShaderSource_default({
    defines: ["VECTOR_TILE"],
    sources: [fsSource]
  });
  primitive._spPick = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: pickVS,
    fragmentShaderSource: pickFS,
    attributeLocations: attributeLocations8
  });
}
function getStencilDepthRenderState2(mask3DTiles) {
  const stencilFunction = mask3DTiles ? StencilFunction_default.EQUAL : StencilFunction_default.ALWAYS;
  return {
    colorMask: {
      red: false,
      green: false,
      blue: false,
      alpha: false
    },
    stencilTest: {
      enabled: true,
      frontFunction: stencilFunction,
      frontOperation: {
        fail: StencilOperation_default.KEEP,
        zFail: StencilOperation_default.DECREMENT_WRAP,
        zPass: StencilOperation_default.KEEP
      },
      backFunction: stencilFunction,
      backOperation: {
        fail: StencilOperation_default.KEEP,
        zFail: StencilOperation_default.INCREMENT_WRAP,
        zPass: StencilOperation_default.KEEP
      },
      reference: StencilConstants_default.CESIUM_3D_TILE_MASK,
      mask: StencilConstants_default.CESIUM_3D_TILE_MASK
    },
    stencilMask: StencilConstants_default.CLASSIFICATION_MASK,
    depthTest: {
      enabled: true,
      func: DepthFunction_default.LESS_OR_EQUAL
    },
    depthMask: false
  };
}
var colorRenderState = {
  stencilTest: {
    enabled: true,
    frontFunction: StencilFunction_default.NOT_EQUAL,
    frontOperation: {
      fail: StencilOperation_default.ZERO,
      zFail: StencilOperation_default.ZERO,
      zPass: StencilOperation_default.ZERO
    },
    backFunction: StencilFunction_default.NOT_EQUAL,
    backOperation: {
      fail: StencilOperation_default.ZERO,
      zFail: StencilOperation_default.ZERO,
      zPass: StencilOperation_default.ZERO
    },
    reference: 0,
    mask: StencilConstants_default.CLASSIFICATION_MASK
  },
  stencilMask: StencilConstants_default.CLASSIFICATION_MASK,
  depthTest: {
    enabled: false
  },
  depthMask: false,
  blending: BlendingState_default.PRE_MULTIPLIED_ALPHA_BLEND
};
var pickRenderState2 = {
  stencilTest: {
    enabled: true,
    frontFunction: StencilFunction_default.NOT_EQUAL,
    frontOperation: {
      fail: StencilOperation_default.ZERO,
      zFail: StencilOperation_default.ZERO,
      zPass: StencilOperation_default.ZERO
    },
    backFunction: StencilFunction_default.NOT_EQUAL,
    backOperation: {
      fail: StencilOperation_default.ZERO,
      zFail: StencilOperation_default.ZERO,
      zPass: StencilOperation_default.ZERO
    },
    reference: 0,
    mask: StencilConstants_default.CLASSIFICATION_MASK
  },
  stencilMask: StencilConstants_default.CLASSIFICATION_MASK,
  depthTest: {
    enabled: false
  },
  depthMask: false
};
function createRenderStates3(primitive) {
  if (defined_default(primitive._rsStencilDepthPass)) {
    return;
  }
  primitive._rsStencilDepthPass = RenderState_default.fromCache(
    getStencilDepthRenderState2(false)
  );
  primitive._rsStencilDepthPass3DTiles = RenderState_default.fromCache(
    getStencilDepthRenderState2(true)
  );
  primitive._rsColorPass = RenderState_default.fromCache(colorRenderState);
  primitive._rsPickPass = RenderState_default.fromCache(pickRenderState2);
}
var modifiedModelViewScratch2 = new Matrix4_default();
var rtcScratch2 = new Cartesian3_default();
function createUniformMap(primitive, context) {
  if (defined_default(primitive._uniformMap)) {
    return;
  }
  const uniformMap2 = {
    u_modifiedModelViewProjection: function() {
      const viewMatrix = context.uniformState.view;
      const projectionMatrix = context.uniformState.projection;
      Matrix4_default.clone(viewMatrix, modifiedModelViewScratch2);
      Matrix4_default.multiplyByPoint(
        modifiedModelViewScratch2,
        primitive._center,
        rtcScratch2
      );
      Matrix4_default.setTranslation(
        modifiedModelViewScratch2,
        rtcScratch2,
        modifiedModelViewScratch2
      );
      Matrix4_default.multiply(
        projectionMatrix,
        modifiedModelViewScratch2,
        modifiedModelViewScratch2
      );
      return modifiedModelViewScratch2;
    },
    u_highlightColor: function() {
      return primitive._highlightColor;
    }
  };
  primitive._uniformMap = primitive._batchTable.getUniformMapCallback()(
    uniformMap2
  );
}
function copyIndicesCPU(indices2, newIndices, currentOffset, offsets, counts, batchIds, batchIdLookUp) {
  const sizeInBytes = indices2.constructor.BYTES_PER_ELEMENT;
  const batchedIdsLength = batchIds.length;
  for (let j = 0; j < batchedIdsLength; ++j) {
    const batchedId = batchIds[j];
    const index2 = batchIdLookUp[batchedId];
    const offset2 = offsets[index2];
    const count = counts[index2];
    const subarray2 = new indices2.constructor(
      indices2.buffer,
      sizeInBytes * offset2,
      count
    );
    newIndices.set(subarray2, currentOffset);
    offsets[index2] = currentOffset;
    currentOffset += count;
  }
  return currentOffset;
}
function rebatchCPU(primitive, batchedIndices) {
  const indices2 = primitive._indices;
  const indexOffsets = primitive._indexOffsets;
  const indexCounts = primitive._indexCounts;
  const batchIdLookUp = primitive._batchIdLookUp;
  const newIndices = new indices2.constructor(indices2.length);
  let current = batchedIndices.pop();
  const newBatchedIndices = [current];
  let currentOffset = copyIndicesCPU(
    indices2,
    newIndices,
    0,
    indexOffsets,
    indexCounts,
    current.batchIds,
    batchIdLookUp
  );
  current.offset = 0;
  current.count = currentOffset;
  while (batchedIndices.length > 0) {
    const next = batchedIndices.pop();
    if (Color_default.equals(next.color, current.color)) {
      currentOffset = copyIndicesCPU(
        indices2,
        newIndices,
        currentOffset,
        indexOffsets,
        indexCounts,
        next.batchIds,
        batchIdLookUp
      );
      current.batchIds = current.batchIds.concat(next.batchIds);
      current.count = currentOffset - current.offset;
    } else {
      const offset2 = currentOffset;
      currentOffset = copyIndicesCPU(
        indices2,
        newIndices,
        currentOffset,
        indexOffsets,
        indexCounts,
        next.batchIds,
        batchIdLookUp
      );
      next.offset = offset2;
      next.count = currentOffset - offset2;
      newBatchedIndices.push(next);
      current = next;
    }
  }
  primitive._va.indexBuffer.copyFromArrayView(newIndices);
  primitive._indices = newIndices;
  primitive._batchedIndices = newBatchedIndices;
}
function copyIndicesGPU(readBuffer, writeBuffer, currentOffset, offsets, counts, batchIds, batchIdLookUp) {
  const sizeInBytes = readBuffer.bytesPerIndex;
  const batchedIdsLength = batchIds.length;
  for (let j = 0; j < batchedIdsLength; ++j) {
    const batchedId = batchIds[j];
    const index2 = batchIdLookUp[batchedId];
    const offset2 = offsets[index2];
    const count = counts[index2];
    writeBuffer.copyFromBuffer(
      readBuffer,
      offset2 * sizeInBytes,
      currentOffset * sizeInBytes,
      count * sizeInBytes
    );
    offsets[index2] = currentOffset;
    currentOffset += count;
  }
  return currentOffset;
}
function rebatchGPU(primitive, batchedIndices) {
  const indexOffsets = primitive._indexOffsets;
  const indexCounts = primitive._indexCounts;
  const batchIdLookUp = primitive._batchIdLookUp;
  let current = batchedIndices.pop();
  const newBatchedIndices = [current];
  const readBuffer = primitive._va.indexBuffer;
  const writeBuffer = primitive._vaSwap.indexBuffer;
  let currentOffset = copyIndicesGPU(
    readBuffer,
    writeBuffer,
    0,
    indexOffsets,
    indexCounts,
    current.batchIds,
    batchIdLookUp
  );
  current.offset = 0;
  current.count = currentOffset;
  while (batchedIndices.length > 0) {
    const next = batchedIndices.pop();
    if (Color_default.equals(next.color, current.color)) {
      currentOffset = copyIndicesGPU(
        readBuffer,
        writeBuffer,
        currentOffset,
        indexOffsets,
        indexCounts,
        next.batchIds,
        batchIdLookUp
      );
      current.batchIds = current.batchIds.concat(next.batchIds);
      current.count = currentOffset - current.offset;
    } else {
      const offset2 = currentOffset;
      currentOffset = copyIndicesGPU(
        readBuffer,
        writeBuffer,
        currentOffset,
        indexOffsets,
        indexCounts,
        next.batchIds,
        batchIdLookUp
      );
      next.offset = offset2;
      next.count = currentOffset - offset2;
      newBatchedIndices.push(next);
      current = next;
    }
  }
  const temp = primitive._va;
  primitive._va = primitive._vaSwap;
  primitive._vaSwap = temp;
  primitive._batchedIndices = newBatchedIndices;
}
function compareColors(a4, b) {
  return b.color.toRgba() - a4.color.toRgba();
}
function rebatchCommands(primitive, context) {
  if (!primitive._batchDirty) {
    return false;
  }
  const batchedIndices = primitive._batchedIndices;
  const length3 = batchedIndices.length;
  let needToRebatch = false;
  const colorCounts = {};
  for (let i2 = 0; i2 < length3; ++i2) {
    const color = batchedIndices[i2].color;
    const rgba = color.toRgba();
    if (defined_default(colorCounts[rgba])) {
      needToRebatch = true;
      break;
    } else {
      colorCounts[rgba] = true;
    }
  }
  if (!needToRebatch) {
    primitive._batchDirty = false;
    return false;
  }
  if (needToRebatch && !primitive.forceRebatch && primitive._framesSinceLastRebatch < 120) {
    ++primitive._framesSinceLastRebatch;
    return;
  }
  batchedIndices.sort(compareColors);
  if (context.webgl2) {
    rebatchGPU(primitive, batchedIndices);
  } else {
    rebatchCPU(primitive, batchedIndices);
  }
  primitive._framesSinceLastRebatch = 0;
  primitive._batchDirty = false;
  primitive._pickCommandsDirty = true;
  primitive._wireframeDirty = true;
  return true;
}
function createColorCommands2(primitive, context) {
  const needsRebatch = rebatchCommands(primitive, context);
  const commands = primitive._commands;
  const batchedIndices = primitive._batchedIndices;
  const length3 = batchedIndices.length;
  const commandsLength = length3 * 2;
  if (defined_default(commands) && !needsRebatch && commands.length === commandsLength) {
    return;
  }
  commands.length = commandsLength;
  const vertexArray = primitive._va;
  const sp = primitive._sp;
  const modelMatrix = defaultValue_default(primitive._modelMatrix, Matrix4_default.IDENTITY);
  const uniformMap2 = primitive._uniformMap;
  const bv = primitive._boundingVolume;
  for (let j = 0; j < length3; ++j) {
    const offset2 = batchedIndices[j].offset;
    const count = batchedIndices[j].count;
    let stencilDepthCommand = commands[j * 2];
    if (!defined_default(stencilDepthCommand)) {
      stencilDepthCommand = commands[j * 2] = new DrawCommand_default({
        owner: primitive
      });
    }
    stencilDepthCommand.vertexArray = vertexArray;
    stencilDepthCommand.modelMatrix = modelMatrix;
    stencilDepthCommand.offset = offset2;
    stencilDepthCommand.count = count;
    stencilDepthCommand.renderState = primitive._rsStencilDepthPass;
    stencilDepthCommand.shaderProgram = sp;
    stencilDepthCommand.uniformMap = uniformMap2;
    stencilDepthCommand.boundingVolume = bv;
    stencilDepthCommand.cull = false;
    stencilDepthCommand.pass = Pass_default.TERRAIN_CLASSIFICATION;
    const stencilDepthDerivedCommand = DrawCommand_default.shallowClone(
      stencilDepthCommand,
      stencilDepthCommand.derivedCommands.tileset
    );
    stencilDepthDerivedCommand.renderState = primitive._rsStencilDepthPass3DTiles;
    stencilDepthDerivedCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    stencilDepthCommand.derivedCommands.tileset = stencilDepthDerivedCommand;
    let colorCommand = commands[j * 2 + 1];
    if (!defined_default(colorCommand)) {
      colorCommand = commands[j * 2 + 1] = new DrawCommand_default({
        owner: primitive
      });
    }
    colorCommand.vertexArray = vertexArray;
    colorCommand.modelMatrix = modelMatrix;
    colorCommand.offset = offset2;
    colorCommand.count = count;
    colorCommand.renderState = primitive._rsColorPass;
    colorCommand.shaderProgram = sp;
    colorCommand.uniformMap = uniformMap2;
    colorCommand.boundingVolume = bv;
    colorCommand.cull = false;
    colorCommand.pass = Pass_default.TERRAIN_CLASSIFICATION;
    const colorDerivedCommand = DrawCommand_default.shallowClone(
      colorCommand,
      colorCommand.derivedCommands.tileset
    );
    colorDerivedCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    colorCommand.derivedCommands.tileset = colorDerivedCommand;
  }
  primitive._commandsDirty = true;
}
function createColorCommandsIgnoreShow(primitive, frameState) {
  if (primitive.classificationType === ClassificationType_default.TERRAIN || !frameState.invertClassification || defined_default(primitive._commandsIgnoreShow) && !primitive._commandsDirty) {
    return;
  }
  const commands = primitive._commands;
  const commandsIgnoreShow = primitive._commandsIgnoreShow;
  const spStencil = primitive._spStencil;
  const commandsLength = commands.length;
  const length3 = commandsIgnoreShow.length = commandsLength / 2;
  let commandIndex = 0;
  for (let j = 0; j < length3; ++j) {
    const commandIgnoreShow = commandsIgnoreShow[j] = DrawCommand_default.shallowClone(
      commands[commandIndex],
      commandsIgnoreShow[j]
    );
    commandIgnoreShow.shaderProgram = spStencil;
    commandIgnoreShow.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW;
    commandIndex += 2;
  }
  primitive._commandsDirty = false;
}
function createPickCommands2(primitive) {
  if (!primitive._pickCommandsDirty) {
    return;
  }
  const length3 = primitive._indexOffsets.length;
  const pickCommands = primitive._pickCommands;
  pickCommands.length = length3 * 2;
  const vertexArray = primitive._va;
  const spStencil = primitive._spStencil;
  const spPick = primitive._spPick;
  const modelMatrix = defaultValue_default(primitive._modelMatrix, Matrix4_default.IDENTITY);
  const uniformMap2 = primitive._uniformMap;
  for (let j = 0; j < length3; ++j) {
    const offset2 = primitive._indexOffsets[j];
    const count = primitive._indexCounts[j];
    const bv = defined_default(primitive._boundingVolumes) ? primitive._boundingVolumes[j] : primitive.boundingVolume;
    let stencilDepthCommand = pickCommands[j * 2];
    if (!defined_default(stencilDepthCommand)) {
      stencilDepthCommand = pickCommands[j * 2] = new DrawCommand_default({
        owner: primitive,
        pickOnly: true
      });
    }
    stencilDepthCommand.vertexArray = vertexArray;
    stencilDepthCommand.modelMatrix = modelMatrix;
    stencilDepthCommand.offset = offset2;
    stencilDepthCommand.count = count;
    stencilDepthCommand.renderState = primitive._rsStencilDepthPass;
    stencilDepthCommand.shaderProgram = spStencil;
    stencilDepthCommand.uniformMap = uniformMap2;
    stencilDepthCommand.boundingVolume = bv;
    stencilDepthCommand.pass = Pass_default.TERRAIN_CLASSIFICATION;
    const stencilDepthDerivedCommand = DrawCommand_default.shallowClone(
      stencilDepthCommand,
      stencilDepthCommand.derivedCommands.tileset
    );
    stencilDepthDerivedCommand.renderState = primitive._rsStencilDepthPass3DTiles;
    stencilDepthDerivedCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    stencilDepthCommand.derivedCommands.tileset = stencilDepthDerivedCommand;
    let colorCommand = pickCommands[j * 2 + 1];
    if (!defined_default(colorCommand)) {
      colorCommand = pickCommands[j * 2 + 1] = new DrawCommand_default({
        owner: primitive,
        pickOnly: true
      });
    }
    colorCommand.vertexArray = vertexArray;
    colorCommand.modelMatrix = modelMatrix;
    colorCommand.offset = offset2;
    colorCommand.count = count;
    colorCommand.renderState = primitive._rsPickPass;
    colorCommand.shaderProgram = spPick;
    colorCommand.uniformMap = uniformMap2;
    colorCommand.boundingVolume = bv;
    colorCommand.pass = Pass_default.TERRAIN_CLASSIFICATION;
    const colorDerivedCommand = DrawCommand_default.shallowClone(
      colorCommand,
      colorCommand.derivedCommands.tileset
    );
    colorDerivedCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    colorCommand.derivedCommands.tileset = colorDerivedCommand;
  }
  primitive._pickCommandsDirty = false;
}
Vector3DTilePrimitive.prototype.createFeatures = function(content, features) {
  const batchIds = this._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    features[batchId] = new Cesium3DTileFeature_default(content, batchId);
  }
};
Vector3DTilePrimitive.prototype.applyDebugSettings = function(enabled, color) {
  this._highlightColor = enabled ? color : this._constantColor;
};
function clearStyle(polygons, features) {
  polygons._updatingAllCommands = true;
  const batchIds = polygons._batchIds;
  let length3 = batchIds.length;
  let i2;
  for (i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    const feature2 = features[batchId];
    feature2.show = true;
    feature2.color = Color_default.WHITE;
  }
  const batchedIndices = polygons._batchedIndices;
  length3 = batchedIndices.length;
  for (i2 = 0; i2 < length3; ++i2) {
    batchedIndices[i2].color = Color_default.clone(Color_default.WHITE);
  }
  polygons._updatingAllCommands = false;
  polygons._batchDirty = true;
}
var scratchColor4 = new Color_default();
var DEFAULT_COLOR_VALUE2 = Color_default.WHITE;
var DEFAULT_SHOW_VALUE2 = true;
var complexExpressionReg = /\$/;
Vector3DTilePrimitive.prototype.applyStyle = function(style, features) {
  if (!defined_default(style)) {
    clearStyle(this, features);
    return;
  }
  const colorExpression = style.color;
  const isSimpleStyle = colorExpression instanceof Expression_default && !complexExpressionReg.test(colorExpression.expression);
  this._updatingAllCommands = isSimpleStyle;
  const batchIds = this._batchIds;
  let length3 = batchIds.length;
  let i2;
  for (i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    const feature2 = features[batchId];
    feature2.color = defined_default(style.color) ? style.color.evaluateColor(feature2, scratchColor4) : DEFAULT_COLOR_VALUE2;
    feature2.show = defined_default(style.show) ? style.show.evaluate(feature2) : DEFAULT_SHOW_VALUE2;
  }
  if (isSimpleStyle) {
    const batchedIndices = this._batchedIndices;
    length3 = batchedIndices.length;
    for (i2 = 0; i2 < length3; ++i2) {
      batchedIndices[i2].color = Color_default.clone(Color_default.WHITE);
    }
    this._updatingAllCommands = false;
    this._batchDirty = true;
  }
};
Vector3DTilePrimitive.prototype.updateCommands = function(batchId, color) {
  if (this._updatingAllCommands) {
    return;
  }
  const batchIdLookUp = this._batchIdLookUp;
  const index2 = batchIdLookUp[batchId];
  if (!defined_default(index2)) {
    return;
  }
  const indexOffsets = this._indexOffsets;
  const indexCounts = this._indexCounts;
  const offset2 = indexOffsets[index2];
  const count = indexCounts[index2];
  const batchedIndices = this._batchedIndices;
  const length3 = batchedIndices.length;
  let i2;
  for (i2 = 0; i2 < length3; ++i2) {
    const batchedOffset = batchedIndices[i2].offset;
    const batchedCount = batchedIndices[i2].count;
    if (offset2 >= batchedOffset && offset2 < batchedOffset + batchedCount) {
      break;
    }
  }
  batchedIndices.push(
    new Vector3DTileBatch_default({
      color: Color_default.clone(color),
      offset: offset2,
      count,
      batchIds: [batchId]
    })
  );
  const startIds = [];
  const endIds = [];
  const batchIds = batchedIndices[i2].batchIds;
  const batchIdsLength = batchIds.length;
  for (let j = 0; j < batchIdsLength; ++j) {
    const id = batchIds[j];
    if (id === batchId) {
      continue;
    }
    const offsetIndex = batchIdLookUp[id];
    if (indexOffsets[offsetIndex] < offset2) {
      startIds.push(id);
    } else {
      endIds.push(id);
    }
  }
  if (endIds.length !== 0) {
    batchedIndices.push(
      new Vector3DTileBatch_default({
        color: Color_default.clone(batchedIndices[i2].color),
        offset: offset2 + count,
        count: batchedIndices[i2].offset + batchedIndices[i2].count - (offset2 + count),
        batchIds: endIds
      })
    );
  }
  if (startIds.length !== 0) {
    batchedIndices[i2].count = offset2 - batchedIndices[i2].offset;
    batchedIndices[i2].batchIds = startIds;
  } else {
    batchedIndices.splice(i2, 1);
  }
  this._batchDirty = true;
};
function queueCommands(primitive, frameState, commands, commandsIgnoreShow) {
  const classificationType = primitive.classificationType;
  const queueTerrainCommands = classificationType !== ClassificationType_default.CESIUM_3D_TILE;
  const queue3DTilesCommands = classificationType !== ClassificationType_default.TERRAIN;
  const commandList = frameState.commandList;
  let commandLength = commands.length;
  let command;
  let i2;
  for (i2 = 0; i2 < commandLength; ++i2) {
    if (queueTerrainCommands) {
      command = commands[i2];
      command.pass = Pass_default.TERRAIN_CLASSIFICATION;
      commandList.push(command);
    }
    if (queue3DTilesCommands) {
      command = commands[i2].derivedCommands.tileset;
      command.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
      commandList.push(command);
    }
  }
  if (!frameState.invertClassification || !defined_default(commandsIgnoreShow)) {
    return;
  }
  commandLength = commandsIgnoreShow.length;
  for (i2 = 0; i2 < commandLength; ++i2) {
    commandList.push(commandsIgnoreShow[i2]);
  }
}
function queueWireframeCommands(frameState, commands) {
  const commandList = frameState.commandList;
  const commandLength = commands.length;
  for (let i2 = 0; i2 < commandLength; i2 += 2) {
    const command = commands[i2 + 1];
    command.pass = Pass_default.OPAQUE;
    commandList.push(command);
  }
}
function updateWireframe(primitive) {
  let earlyExit = primitive.debugWireframe === primitive._debugWireframe;
  earlyExit = earlyExit && !(primitive.debugWireframe && primitive._wireframeDirty);
  if (earlyExit) {
    return;
  }
  if (!defined_default(primitive._rsWireframe)) {
    primitive._rsWireframe = RenderState_default.fromCache({});
  }
  let rs;
  let type;
  if (primitive.debugWireframe) {
    rs = primitive._rsWireframe;
    type = PrimitiveType_default.LINES;
  } else {
    rs = primitive._rsColorPass;
    type = PrimitiveType_default.TRIANGLES;
  }
  const commands = primitive._commands;
  const commandLength = commands.length;
  for (let i2 = 0; i2 < commandLength; i2 += 2) {
    const command = commands[i2 + 1];
    command.renderState = rs;
    command.primitiveType = type;
  }
  primitive._debugWireframe = primitive.debugWireframe;
  primitive._wireframeDirty = false;
}
Vector3DTilePrimitive.prototype.update = function(frameState) {
  const context = frameState.context;
  createVertexArray3(this, context);
  createShaders(this, context);
  createRenderStates3(this);
  createUniformMap(this, context);
  const passes = frameState.passes;
  if (passes.render) {
    createColorCommands2(this, context);
    createColorCommandsIgnoreShow(this, frameState);
    updateWireframe(this);
    if (this._debugWireframe) {
      queueWireframeCommands(frameState, this._commands);
    } else {
      queueCommands(this, frameState, this._commands, this._commandsIgnoreShow);
    }
  }
  if (passes.pick) {
    createPickCommands2(this);
    queueCommands(this, frameState, this._pickCommands);
  }
};
Vector3DTilePrimitive.prototype.isDestroyed = function() {
  return false;
};
Vector3DTilePrimitive.prototype.destroy = function() {
  this._va = this._va && this._va.destroy();
  this._sp = this._sp && this._sp.destroy();
  this._spPick = this._spPick && this._spPick.destroy();
  this._vaSwap = this._vaSwap && this._vaSwap.destroy();
  return destroyObject_default(this);
};
var Vector3DTilePrimitive_default = Vector3DTilePrimitive;

// node_modules/cesium/Source/Scene/ClassificationModel.js
var boundingSphereCartesian3Scratch = new Cartesian3_default();
var ModelState = ModelUtility_default.ModelState;
function ClassificationModel(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let gltf = options.gltf;
  if (gltf instanceof ArrayBuffer) {
    gltf = new Uint8Array(gltf);
  }
  if (gltf instanceof Uint8Array) {
    gltf = parseGlb_default(gltf);
    updateVersion_default(gltf);
    addDefaults_default(gltf);
    processModelMaterialsCommon_default(gltf);
    processPbrMaterials_default(gltf);
  } else {
    throw new RuntimeError_default("Only binary glTF is supported as a classifier.");
  }
  ForEach_default.buffer(gltf, function(buffer) {
    if (!defined_default(buffer.extras._pipeline.source)) {
      throw new RuntimeError_default(
        "Buffer data must be embedded in the binary gltf."
      );
    }
  });
  const gltfNodes = gltf.nodes;
  const gltfMeshes = gltf.meshes;
  const gltfNode = gltfNodes[0];
  const meshId = gltfNode.mesh;
  if (gltfNodes.length !== 1 || !defined_default(meshId)) {
    throw new RuntimeError_default(
      "Only one node is supported for classification and it must have a mesh."
    );
  }
  if (gltfMeshes.length !== 1) {
    throw new RuntimeError_default(
      "Only one mesh is supported when using b3dm for classification."
    );
  }
  const gltfPrimitives = gltfMeshes[0].primitives;
  if (gltfPrimitives.length !== 1) {
    throw new RuntimeError_default(
      "Only one primitive per mesh is supported when using b3dm for classification."
    );
  }
  const gltfPositionAttribute = gltfPrimitives[0].attributes.POSITION;
  if (!defined_default(gltfPositionAttribute)) {
    throw new RuntimeError_default("The mesh must have a position attribute.");
  }
  const gltfBatchIdAttribute = gltfPrimitives[0].attributes._BATCHID;
  if (!defined_default(gltfBatchIdAttribute)) {
    throw new RuntimeError_default("The mesh must have a batch id attribute.");
  }
  this._gltf = gltf;
  this.show = defaultValue_default(options.show, true);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._modelMatrix = Matrix4_default.clone(this.modelMatrix);
  this._ready = false;
  this._readyPromise = defer_default();
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this._debugShowBoundingVolume = false;
  this.debugWireframe = defaultValue_default(options.debugWireframe, false);
  this._debugWireframe = false;
  this._classificationType = options.classificationType;
  this._vertexShaderLoaded = options.vertexShaderLoaded;
  this._classificationShaderLoaded = options.classificationShaderLoaded;
  this._uniformMapLoaded = options.uniformMapLoaded;
  this._pickIdLoaded = options.pickIdLoaded;
  this._ignoreCommands = defaultValue_default(options.ignoreCommands, false);
  this._upAxis = defaultValue_default(options.upAxis, Axis_default.Y);
  this._batchTable = options.batchTable;
  this._computedModelMatrix = new Matrix4_default();
  this._initialRadius = void 0;
  this._boundingSphere = void 0;
  this._scaledBoundingSphere = new BoundingSphere_default();
  this._state = ModelState.NEEDS_LOAD;
  this._loadResources = void 0;
  this._mode = void 0;
  this._dirty = false;
  this._nodeMatrix = new Matrix4_default();
  this._primitive = void 0;
  this._extensionsUsed = void 0;
  this._extensionsRequired = void 0;
  this._quantizedUniforms = void 0;
  this._buffers = {};
  this._vertexArray = void 0;
  this._shaderProgram = void 0;
  this._uniformMap = void 0;
  this._geometryByteLength = 0;
  this._trianglesLength = 0;
  this._rtcCenter = void 0;
  this._rtcCenterEye = void 0;
  this._rtcCenter3D = void 0;
  this._rtcCenter2D = void 0;
}
Object.defineProperties(ClassificationModel.prototype, {
  gltf: {
    get: function() {
      return this._gltf;
    }
  },
  boundingSphere: {
    get: function() {
      if (this._state !== ModelState.LOADED) {
        throw new DeveloperError_default(
          "The model is not loaded.  Use ClassificationModel.readyPromise or wait for ClassificationModel.ready to be true."
        );
      }
      const modelMatrix = this.modelMatrix;
      const nonUniformScale = Matrix4_default.getScale(
        modelMatrix,
        boundingSphereCartesian3Scratch
      );
      const scaledBoundingSphere = this._scaledBoundingSphere;
      scaledBoundingSphere.center = Cartesian3_default.multiplyComponents(
        this._boundingSphere.center,
        nonUniformScale,
        scaledBoundingSphere.center
      );
      scaledBoundingSphere.radius = Cartesian3_default.maximumComponent(nonUniformScale) * this._initialRadius;
      if (defined_default(this._rtcCenter)) {
        Cartesian3_default.add(
          this._rtcCenter,
          scaledBoundingSphere.center,
          scaledBoundingSphere.center
        );
      }
      return scaledBoundingSphere;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  dirty: {
    get: function() {
      return this._dirty;
    }
  },
  extensionsUsed: {
    get: function() {
      if (!defined_default(this._extensionsUsed)) {
        this._extensionsUsed = ModelUtility_default.getUsedExtensions(this.gltf);
      }
      return this._extensionsUsed;
    }
  },
  extensionsRequired: {
    get: function() {
      if (!defined_default(this._extensionsRequired)) {
        this._extensionsRequired = ModelUtility_default.getRequiredExtensions(
          this.gltf
        );
      }
      return this._extensionsRequired;
    }
  },
  upAxis: {
    get: function() {
      return this._upAxis;
    }
  },
  trianglesLength: {
    get: function() {
      return this._trianglesLength;
    }
  },
  geometryByteLength: {
    get: function() {
      return this._geometryByteLength;
    }
  },
  texturesByteLength: {
    get: function() {
      return 0;
    }
  },
  classificationType: {
    get: function() {
      return this._classificationType;
    }
  }
});
function addBuffersToLoadResources(model) {
  const gltf = model.gltf;
  const loadResources = model._loadResources;
  ForEach_default.buffer(gltf, function(buffer, id) {
    loadResources.buffers[id] = buffer.extras._pipeline.source;
  });
}
function parseBufferViews(model) {
  const bufferViews = model.gltf.bufferViews;
  const vertexBuffersToCreate = model._loadResources.vertexBuffersToCreate;
  ForEach_default.bufferView(model.gltf, function(bufferView, id) {
    if (bufferView.target === WebGLConstants_default.ARRAY_BUFFER) {
      vertexBuffersToCreate.enqueue(id);
    }
  });
  const indexBuffersToCreate = model._loadResources.indexBuffersToCreate;
  const indexBufferIds = {};
  ForEach_default.accessor(model.gltf, function(accessor) {
    const bufferViewId = accessor.bufferView;
    const bufferView = bufferViews[bufferViewId];
    if (bufferView.target === WebGLConstants_default.ELEMENT_ARRAY_BUFFER && !defined_default(indexBufferIds[bufferViewId])) {
      indexBufferIds[bufferViewId] = true;
      indexBuffersToCreate.enqueue({
        id: bufferViewId,
        componentType: accessor.componentType
      });
    }
  });
}
function createVertexBuffer(bufferViewId, model) {
  const loadResources = model._loadResources;
  const bufferViews = model.gltf.bufferViews;
  const bufferView = bufferViews[bufferViewId];
  const vertexBuffer = loadResources.getBuffer(bufferView);
  model._buffers[bufferViewId] = vertexBuffer;
  model._geometryByteLength += vertexBuffer.byteLength;
}
function createIndexBuffer(bufferViewId, componentType, model) {
  const loadResources = model._loadResources;
  const bufferViews = model.gltf.bufferViews;
  const bufferView = bufferViews[bufferViewId];
  const indexBuffer = {
    typedArray: loadResources.getBuffer(bufferView),
    indexDatatype: componentType
  };
  model._buffers[bufferViewId] = indexBuffer;
  model._geometryByteLength += indexBuffer.typedArray.byteLength;
}
function createBuffers(model) {
  const loadResources = model._loadResources;
  if (loadResources.pendingBufferLoads !== 0) {
    return;
  }
  const vertexBuffersToCreate = loadResources.vertexBuffersToCreate;
  const indexBuffersToCreate = loadResources.indexBuffersToCreate;
  while (vertexBuffersToCreate.length > 0) {
    createVertexBuffer(vertexBuffersToCreate.dequeue(), model);
  }
  while (indexBuffersToCreate.length > 0) {
    const i2 = indexBuffersToCreate.dequeue();
    createIndexBuffer(i2.id, i2.componentType, model);
  }
}
function modifyShaderForQuantizedAttributes(shader, model) {
  const primitive = model.gltf.meshes[0].primitives[0];
  const result = ModelUtility_default.modifyShaderForQuantizedAttributes(
    model.gltf,
    primitive,
    shader
  );
  model._quantizedUniforms = result.uniforms;
  return result.shader;
}
function modifyShader(shader, callback) {
  if (defined_default(callback)) {
    shader = callback(shader);
  }
  return shader;
}
function createProgram(model) {
  const gltf = model.gltf;
  const positionName = ModelUtility_default.getAttributeOrUniformBySemantic(
    gltf,
    "POSITION"
  );
  const batchIdName = ModelUtility_default.getAttributeOrUniformBySemantic(
    gltf,
    "_BATCHID"
  );
  const attributeLocations8 = {};
  attributeLocations8[positionName] = 0;
  attributeLocations8[batchIdName] = 1;
  const modelViewProjectionName = ModelUtility_default.getAttributeOrUniformBySemantic(
    gltf,
    "MODELVIEWPROJECTION"
  );
  let uniformDecl;
  let toClip;
  if (!defined_default(modelViewProjectionName)) {
    const projectionName = ModelUtility_default.getAttributeOrUniformBySemantic(
      gltf,
      "PROJECTION"
    );
    let modelViewName = ModelUtility_default.getAttributeOrUniformBySemantic(
      gltf,
      "MODELVIEW"
    );
    if (!defined_default(modelViewName)) {
      modelViewName = ModelUtility_default.getAttributeOrUniformBySemantic(
        gltf,
        "CESIUM_RTC_MODELVIEW"
      );
    }
    uniformDecl = `uniform mat4 ${modelViewName};
uniform mat4 ${projectionName};
`;
    toClip = `${projectionName} * ${modelViewName} * vec4(${positionName}, 1.0)`;
  } else {
    uniformDecl = `uniform mat4 ${modelViewProjectionName};
`;
    toClip = `${modelViewProjectionName} * vec4(${positionName}, 1.0)`;
  }
  const computePosition = `    vec4 positionInClipCoords = ${toClip};
`;
  let vs = `attribute vec3 ${positionName};
attribute float ${batchIdName};
${uniformDecl}void main() {
${computePosition}    gl_Position = czm_depthClamp(positionInClipCoords);
}
`;
  const fs = "#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n#endif\nvoid main() \n{ \n    gl_FragColor = vec4(1.0); \n    czm_writeDepthClamp();\n}\n";
  if (model.extensionsUsed.WEB3D_quantized_attributes) {
    vs = modifyShaderForQuantizedAttributes(vs, model);
  }
  const drawVS = modifyShader(vs, model._vertexShaderLoaded);
  const drawFS = modifyShader(fs, model._classificationShaderLoaded);
  model._shaderProgram = {
    vertexShaderSource: drawVS,
    fragmentShaderSource: drawFS,
    attributeLocations: attributeLocations8
  };
}
function getAttributeLocations() {
  return {
    POSITION: 0,
    _BATCHID: 1
  };
}
function createVertexArray4(model) {
  const loadResources = model._loadResources;
  if (!loadResources.finishedBuffersCreation() || defined_default(model._vertexArray)) {
    return;
  }
  const rendererBuffers = model._buffers;
  const gltf = model.gltf;
  const accessors = gltf.accessors;
  const meshes = gltf.meshes;
  const primitives = meshes[0].primitives;
  const primitive = primitives[0];
  const attributeLocations8 = getAttributeLocations();
  const attributes = {};
  ForEach_default.meshPrimitiveAttribute(primitive, function(accessorId, attributeName) {
    const attributeLocation = attributeLocations8[attributeName];
    if (defined_default(attributeLocation)) {
      const a4 = accessors[accessorId];
      attributes[attributeName] = {
        index: attributeLocation,
        vertexBuffer: rendererBuffers[a4.bufferView],
        componentsPerAttribute: numberOfComponentsForType_default(a4.type),
        componentDatatype: a4.componentType,
        offsetInBytes: a4.byteOffset,
        strideInBytes: getAccessorByteStride_default(gltf, a4)
      };
    }
  });
  let indexBuffer;
  if (defined_default(primitive.indices)) {
    const accessor = accessors[primitive.indices];
    indexBuffer = rendererBuffers[accessor.bufferView];
  }
  model._vertexArray = {
    attributes,
    indexBuffer
  };
}
var gltfSemanticUniforms2 = {
  PROJECTION: function(uniformState, model) {
    return ModelUtility_default.getGltfSemanticUniforms().PROJECTION(
      uniformState,
      model
    );
  },
  MODELVIEW: function(uniformState, model) {
    return ModelUtility_default.getGltfSemanticUniforms().MODELVIEW(
      uniformState,
      model
    );
  },
  CESIUM_RTC_MODELVIEW: function(uniformState, model) {
    return ModelUtility_default.getGltfSemanticUniforms().CESIUM_RTC_MODELVIEW(
      uniformState,
      model
    );
  },
  MODELVIEWPROJECTION: function(uniformState, model) {
    return ModelUtility_default.getGltfSemanticUniforms().MODELVIEWPROJECTION(
      uniformState,
      model
    );
  }
};
function createUniformMap2(model, context) {
  if (defined_default(model._uniformMap)) {
    return;
  }
  const uniformMap2 = {};
  ForEach_default.technique(model.gltf, function(technique) {
    ForEach_default.techniqueUniform(technique, function(uniform, uniformName) {
      if (!defined_default(uniform.semantic) || !defined_default(gltfSemanticUniforms2[uniform.semantic])) {
        return;
      }
      uniformMap2[uniformName] = gltfSemanticUniforms2[uniform.semantic](
        context.uniformState,
        model
      );
    });
  });
  model._uniformMap = uniformMap2;
}
function createUniformsForQuantizedAttributes(model, primitive) {
  return ModelUtility_default.createUniformsForQuantizedAttributes(
    model.gltf,
    primitive,
    model._quantizedUniforms
  );
}
function triangleCountFromPrimitiveIndices(primitive, indicesCount) {
  switch (primitive.mode) {
    case PrimitiveType_default.TRIANGLES:
      return indicesCount / 3;
    case PrimitiveType_default.TRIANGLE_STRIP:
    case PrimitiveType_default.TRIANGLE_FAN:
      return Math.max(indicesCount - 2, 0);
    default:
      return 0;
  }
}
function createPrimitive(model) {
  const batchTable = model._batchTable;
  let uniformMap2 = model._uniformMap;
  const vertexArray = model._vertexArray;
  const gltf = model.gltf;
  const accessors = gltf.accessors;
  const gltfMeshes = gltf.meshes;
  const primitive = gltfMeshes[0].primitives[0];
  const ix = accessors[primitive.indices];
  const positionAccessor = primitive.attributes.POSITION;
  const minMax = ModelUtility_default.getAccessorMinMax(gltf, positionAccessor);
  const boundingSphere = BoundingSphere_default.fromCornerPoints(
    Cartesian3_default.fromArray(minMax.min),
    Cartesian3_default.fromArray(minMax.max)
  );
  let offset2;
  let count;
  if (defined_default(ix)) {
    count = ix.count;
    offset2 = ix.byteOffset / IndexDatatype_default.getSizeInBytes(ix.componentType);
  } else {
    const positions = accessors[primitive.attributes.POSITION];
    count = positions.count;
    offset2 = 0;
  }
  model._trianglesLength += triangleCountFromPrimitiveIndices(primitive, count);
  if (defined_default(model._uniformMapLoaded)) {
    uniformMap2 = model._uniformMapLoaded(uniformMap2);
  }
  if (model.extensionsUsed.WEB3D_quantized_attributes) {
    const quantizedUniformMap = createUniformsForQuantizedAttributes(
      model,
      primitive
    );
    uniformMap2 = combine_default(uniformMap2, quantizedUniformMap);
  }
  let attribute = vertexArray.attributes.POSITION;
  let componentDatatype = attribute.componentDatatype;
  let typedArray = attribute.vertexBuffer;
  let byteOffset = typedArray.byteOffset;
  let bufferLength = typedArray.byteLength / ComponentDatatype_default.getSizeInBytes(componentDatatype);
  let positionsBuffer = ComponentDatatype_default.createArrayBufferView(
    componentDatatype,
    typedArray.buffer,
    byteOffset,
    bufferLength
  );
  attribute = vertexArray.attributes._BATCHID;
  componentDatatype = attribute.componentDatatype;
  typedArray = attribute.vertexBuffer;
  byteOffset = typedArray.byteOffset;
  bufferLength = typedArray.byteLength / ComponentDatatype_default.getSizeInBytes(componentDatatype);
  let vertexBatchIds = ComponentDatatype_default.createArrayBufferView(
    componentDatatype,
    typedArray.buffer,
    byteOffset,
    bufferLength
  );
  const buffer = vertexArray.indexBuffer.typedArray;
  let indices2;
  if (vertexArray.indexBuffer.indexDatatype === IndexDatatype_default.UNSIGNED_SHORT) {
    indices2 = new Uint16Array(
      buffer.buffer,
      buffer.byteOffset,
      buffer.byteLength / Uint16Array.BYTES_PER_ELEMENT
    );
  } else {
    indices2 = new Uint32Array(
      buffer.buffer,
      buffer.byteOffset,
      buffer.byteLength / Uint32Array.BYTES_PER_ELEMENT
    );
  }
  positionsBuffer = arraySlice_default(positionsBuffer);
  vertexBatchIds = arraySlice_default(vertexBatchIds);
  indices2 = arraySlice_default(indices2, offset2, offset2 + count);
  const batchIds = [];
  const indexCounts = [];
  const indexOffsets = [];
  const batchedIndices = [];
  let currentId2 = vertexBatchIds[indices2[0]];
  batchIds.push(currentId2);
  indexOffsets.push(0);
  let batchId;
  let indexOffset;
  let indexCount;
  const indicesLength = indices2.length;
  for (let j = 1; j < indicesLength; ++j) {
    batchId = vertexBatchIds[indices2[j]];
    if (batchId !== currentId2) {
      indexOffset = indexOffsets[indexOffsets.length - 1];
      indexCount = j - indexOffset;
      batchIds.push(batchId);
      indexCounts.push(indexCount);
      indexOffsets.push(j);
      batchedIndices.push(
        new Vector3DTileBatch_default({
          offset: indexOffset,
          count: indexCount,
          batchIds: [currentId2],
          color: Color_default.WHITE
        })
      );
      currentId2 = batchId;
    }
  }
  indexOffset = indexOffsets[indexOffsets.length - 1];
  indexCount = indicesLength - indexOffset;
  indexCounts.push(indexCount);
  batchedIndices.push(
    new Vector3DTileBatch_default({
      offset: indexOffset,
      count: indexCount,
      batchIds: [currentId2],
      color: Color_default.WHITE
    })
  );
  const shader = model._shaderProgram;
  const vertexShaderSource = shader.vertexShaderSource;
  const fragmentShaderSource = shader.fragmentShaderSource;
  const attributeLocations8 = shader.attributeLocations;
  const pickId = defined_default(model._pickIdLoaded) ? model._pickIdLoaded() : void 0;
  model._primitive = new Vector3DTilePrimitive_default({
    classificationType: model._classificationType,
    positions: positionsBuffer,
    indices: indices2,
    indexOffsets,
    indexCounts,
    batchIds,
    vertexBatchIds,
    batchedIndices,
    batchTable,
    boundingVolume: new BoundingSphere_default(),
    _vertexShaderSource: vertexShaderSource,
    _fragmentShaderSource: fragmentShaderSource,
    _attributeLocations: attributeLocations8,
    _uniformMap: uniformMap2,
    _pickId: pickId,
    _modelMatrix: new Matrix4_default(),
    _boundingSphere: boundingSphere
  });
  model._buffers = void 0;
  model._vertexArray = void 0;
  model._shaderProgram = void 0;
  model._uniformMap = void 0;
}
function createRuntimeNodes(model) {
  const loadResources = model._loadResources;
  if (!loadResources.finished()) {
    return;
  }
  if (defined_default(model._primitive)) {
    return;
  }
  const gltf = model.gltf;
  const nodes = gltf.nodes;
  const gltfNode = nodes[0];
  model._nodeMatrix = ModelUtility_default.getTransform(gltfNode, model._nodeMatrix);
  createPrimitive(model);
}
function createResources(model, frameState) {
  const context = frameState.context;
  ModelUtility_default.checkSupportedGlExtensions(model.gltf.glExtensionsUsed, context);
  createBuffers(model);
  createProgram(model);
  createVertexArray4(model);
  createUniformMap2(model, context);
  createRuntimeNodes(model);
}
var scratchComputedTranslation = new Cartesian4_default();
var scratchComputedMatrixIn2D = new Matrix4_default();
function updateNodeModelMatrix(model, modelTransformChanged, justLoaded, projection) {
  let computedModelMatrix = model._computedModelMatrix;
  if (model._mode !== SceneMode_default.SCENE3D && !model._ignoreCommands) {
    const translation3 = Matrix4_default.getColumn(
      computedModelMatrix,
      3,
      scratchComputedTranslation
    );
    if (!Cartesian4_default.equals(translation3, Cartesian4_default.UNIT_W)) {
      computedModelMatrix = Transforms_default.basisTo2D(
        projection,
        computedModelMatrix,
        scratchComputedMatrixIn2D
      );
      model._rtcCenter = model._rtcCenter3D;
    } else {
      const center = model.boundingSphere.center;
      const to2D = Transforms_default.wgs84To2DModelMatrix(
        projection,
        center,
        scratchComputedMatrixIn2D
      );
      computedModelMatrix = Matrix4_default.multiply(
        to2D,
        computedModelMatrix,
        scratchComputedMatrixIn2D
      );
      if (defined_default(model._rtcCenter)) {
        Matrix4_default.setTranslation(
          computedModelMatrix,
          Cartesian4_default.UNIT_W,
          computedModelMatrix
        );
        model._rtcCenter = model._rtcCenter2D;
      }
    }
  }
  const primitive = model._primitive;
  if (modelTransformChanged || justLoaded) {
    Matrix4_default.multiplyTransformation(
      computedModelMatrix,
      model._nodeMatrix,
      primitive._modelMatrix
    );
    BoundingSphere_default.transform(
      primitive._boundingSphere,
      primitive._modelMatrix,
      primitive._boundingVolume
    );
    if (defined_default(model._rtcCenter)) {
      Cartesian3_default.add(
        model._rtcCenter,
        primitive._boundingVolume.center,
        primitive._boundingVolume.center
      );
    }
  }
}
ClassificationModel.prototype.updateCommands = function(batchId, color) {
  this._primitive.updateCommands(batchId, color);
};
ClassificationModel.prototype.update = function(frameState) {
  if (frameState.mode === SceneMode_default.MORPHING) {
    return;
  }
  if (!FeatureDetection_default.supportsWebP.initialized) {
    FeatureDetection_default.supportsWebP.initialize();
    return;
  }
  const supportsWebP2 = FeatureDetection_default.supportsWebP();
  if (this._state === ModelState.NEEDS_LOAD && defined_default(this.gltf)) {
    this._state = ModelState.LOADING;
    if (this._state !== ModelState.FAILED) {
      const extensions = this.gltf.extensions;
      if (defined_default(extensions) && defined_default(extensions.CESIUM_RTC)) {
        const center = Cartesian3_default.fromArray(extensions.CESIUM_RTC.center);
        if (!Cartesian3_default.equals(center, Cartesian3_default.ZERO)) {
          this._rtcCenter3D = center;
          const projection = frameState.mapProjection;
          const ellipsoid = projection.ellipsoid;
          const cartographic2 = ellipsoid.cartesianToCartographic(
            this._rtcCenter3D
          );
          const projectedCart = projection.project(cartographic2);
          Cartesian3_default.fromElements(
            projectedCart.z,
            projectedCart.x,
            projectedCart.y,
            projectedCart
          );
          this._rtcCenter2D = projectedCart;
          this._rtcCenterEye = new Cartesian3_default();
          this._rtcCenter = this._rtcCenter3D;
        }
      }
      this._loadResources = new ModelLoadResources_default();
      ModelUtility_default.parseBuffers(this);
    }
  }
  const loadResources = this._loadResources;
  let justLoaded = false;
  if (this._state === ModelState.LOADING) {
    if (loadResources.pendingBufferLoads === 0) {
      ModelUtility_default.checkSupportedExtensions(
        this.extensionsRequired,
        supportsWebP2
      );
      addBuffersToLoadResources(this);
      parseBufferViews(this);
      this._boundingSphere = ModelUtility_default.computeBoundingSphere(this);
      this._initialRadius = this._boundingSphere.radius;
      createResources(this, frameState);
    }
    if (loadResources.finished()) {
      this._state = ModelState.LOADED;
      justLoaded = true;
    }
  }
  if (defined_default(loadResources) && this._state === ModelState.LOADED) {
    if (!justLoaded) {
      createResources(this, frameState);
    }
    if (loadResources.finished()) {
      this._loadResources = void 0;
    }
  }
  const show = this.show;
  if (show && this._state === ModelState.LOADED || justLoaded) {
    this._dirty = false;
    const modelMatrix = this.modelMatrix;
    const modeChanged = frameState.mode !== this._mode;
    this._mode = frameState.mode;
    const modelTransformChanged = !Matrix4_default.equals(this._modelMatrix, modelMatrix) || modeChanged;
    if (modelTransformChanged || justLoaded) {
      Matrix4_default.clone(modelMatrix, this._modelMatrix);
      const computedModelMatrix = this._computedModelMatrix;
      Matrix4_default.clone(modelMatrix, computedModelMatrix);
      if (this._upAxis === Axis_default.Y) {
        Matrix4_default.multiplyTransformation(
          computedModelMatrix,
          Axis_default.Y_UP_TO_Z_UP,
          computedModelMatrix
        );
      } else if (this._upAxis === Axis_default.X) {
        Matrix4_default.multiplyTransformation(
          computedModelMatrix,
          Axis_default.X_UP_TO_Z_UP,
          computedModelMatrix
        );
      }
    }
    if (modelTransformChanged || justLoaded) {
      updateNodeModelMatrix(
        this,
        modelTransformChanged,
        justLoaded,
        frameState.mapProjection
      );
      this._dirty = true;
    }
  }
  if (justLoaded) {
    const model = this;
    frameState.afterRender.push(function() {
      model._ready = true;
      model._readyPromise.resolve(model);
    });
    return;
  }
  if (show && !this._ignoreCommands) {
    this._primitive.debugShowBoundingVolume = this.debugShowBoundingVolume;
    this._primitive.debugWireframe = this.debugWireframe;
    this._primitive.update(frameState);
  }
};
ClassificationModel.prototype.isDestroyed = function() {
  return false;
};
ClassificationModel.prototype.destroy = function() {
  this._primitive = this._primitive && this._primitive.destroy();
  return destroyObject_default(this);
};
var ClassificationModel_default = ClassificationModel;

// node_modules/cesium/Source/Scene/ClippingPlane.js
function ClippingPlane(normal2, distance2) {
  Check_default.typeOf.object("normal", normal2);
  Check_default.typeOf.number("distance", distance2);
  this._distance = distance2;
  this._normal = new UpdateChangedCartesian3(normal2, this);
  this.onChangeCallback = void 0;
  this.index = -1;
}
Object.defineProperties(ClippingPlane.prototype, {
  distance: {
    get: function() {
      return this._distance;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      if (defined_default(this.onChangeCallback) && value !== this._distance) {
        this.onChangeCallback(this.index);
      }
      this._distance = value;
    }
  },
  normal: {
    get: function() {
      return this._normal;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      if (defined_default(this.onChangeCallback) && !Cartesian3_default.equals(this._normal._cartesian3, value)) {
        this.onChangeCallback(this.index);
      }
      Cartesian3_default.clone(value, this._normal._cartesian3);
    }
  }
});
ClippingPlane.fromPlane = function(plane, result) {
  Check_default.typeOf.object("plane", plane);
  if (!defined_default(result)) {
    result = new ClippingPlane(plane.normal, plane.distance);
  } else {
    result.normal = plane.normal;
    result.distance = plane.distance;
  }
  return result;
};
ClippingPlane.clone = function(clippingPlane, result) {
  if (!defined_default(result)) {
    return new ClippingPlane(clippingPlane.normal, clippingPlane.distance);
  }
  result.normal = clippingPlane.normal;
  result.distance = clippingPlane.distance;
  return result;
};
function UpdateChangedCartesian3(normal2, clippingPlane) {
  this._clippingPlane = clippingPlane;
  this._cartesian3 = Cartesian3_default.clone(normal2);
}
Object.defineProperties(UpdateChangedCartesian3.prototype, {
  x: {
    get: function() {
      return this._cartesian3.x;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      if (defined_default(this._clippingPlane.onChangeCallback) && value !== this._cartesian3.x) {
        this._clippingPlane.onChangeCallback(this._clippingPlane.index);
      }
      this._cartesian3.x = value;
    }
  },
  y: {
    get: function() {
      return this._cartesian3.y;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      if (defined_default(this._clippingPlane.onChangeCallback) && value !== this._cartesian3.y) {
        this._clippingPlane.onChangeCallback(this._clippingPlane.index);
      }
      this._cartesian3.y = value;
    }
  },
  z: {
    get: function() {
      return this._cartesian3.z;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      if (defined_default(this._clippingPlane.onChangeCallback) && value !== this._cartesian3.z) {
        this._clippingPlane.onChangeCallback(this._clippingPlane.index);
      }
      this._cartesian3.z = value;
    }
  }
});
var ClippingPlane_default = ClippingPlane;

// node_modules/cesium/Source/Scene/ClippingPlaneCollection.js
function ClippingPlaneCollection(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._planes = [];
  this._dirtyIndex = -1;
  this._multipleDirtyPlanes = false;
  this._enabled = defaultValue_default(options.enabled, true);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this.edgeColor = Color_default.clone(defaultValue_default(options.edgeColor, Color_default.WHITE));
  this.edgeWidth = defaultValue_default(options.edgeWidth, 0);
  this.planeAdded = new Event_default();
  this.planeRemoved = new Event_default();
  this._owner = void 0;
  const unionClippingRegions = defaultValue_default(
    options.unionClippingRegions,
    false
  );
  this._unionClippingRegions = unionClippingRegions;
  this._testIntersection = unionClippingRegions ? unionIntersectFunction : defaultIntersectFunction;
  this._uint8View = void 0;
  this._float32View = void 0;
  this._clippingPlanesTexture = void 0;
  const planes = options.planes;
  if (defined_default(planes)) {
    const planesLength = planes.length;
    for (let i2 = 0; i2 < planesLength; ++i2) {
      this.add(planes[i2]);
    }
  }
}
function unionIntersectFunction(value) {
  return value === Intersect_default.OUTSIDE;
}
function defaultIntersectFunction(value) {
  return value === Intersect_default.INSIDE;
}
Object.defineProperties(ClippingPlaneCollection.prototype, {
  length: {
    get: function() {
      return this._planes.length;
    }
  },
  unionClippingRegions: {
    get: function() {
      return this._unionClippingRegions;
    },
    set: function(value) {
      if (this._unionClippingRegions === value) {
        return;
      }
      this._unionClippingRegions = value;
      this._testIntersection = value ? unionIntersectFunction : defaultIntersectFunction;
    }
  },
  enabled: {
    get: function() {
      return this._enabled;
    },
    set: function(value) {
      if (this._enabled === value) {
        return;
      }
      this._enabled = value;
    }
  },
  texture: {
    get: function() {
      return this._clippingPlanesTexture;
    }
  },
  owner: {
    get: function() {
      return this._owner;
    }
  },
  clippingPlanesState: {
    get: function() {
      return this._unionClippingRegions ? this._planes.length : -this._planes.length;
    }
  }
});
function setIndexDirty(collection, index2) {
  collection._multipleDirtyPlanes = collection._multipleDirtyPlanes || collection._dirtyIndex !== -1 && collection._dirtyIndex !== index2;
  collection._dirtyIndex = index2;
}
ClippingPlaneCollection.prototype.add = function(plane) {
  const newPlaneIndex = this._planes.length;
  const that = this;
  plane.onChangeCallback = function(index2) {
    setIndexDirty(that, index2);
  };
  plane.index = newPlaneIndex;
  setIndexDirty(this, newPlaneIndex);
  this._planes.push(plane);
  this.planeAdded.raiseEvent(plane, newPlaneIndex);
};
ClippingPlaneCollection.prototype.get = function(index2) {
  Check_default.typeOf.number("index", index2);
  return this._planes[index2];
};
function indexOf(planes, plane) {
  const length3 = planes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (Plane_default.equals(planes[i2], plane)) {
      return i2;
    }
  }
  return -1;
}
ClippingPlaneCollection.prototype.contains = function(clippingPlane) {
  return indexOf(this._planes, clippingPlane) !== -1;
};
ClippingPlaneCollection.prototype.remove = function(clippingPlane) {
  const planes = this._planes;
  const index2 = indexOf(planes, clippingPlane);
  if (index2 === -1) {
    return false;
  }
  if (clippingPlane instanceof ClippingPlane_default) {
    clippingPlane.onChangeCallback = void 0;
    clippingPlane.index = -1;
  }
  const length3 = planes.length - 1;
  for (let i2 = index2; i2 < length3; ++i2) {
    const planeToKeep = planes[i2 + 1];
    planes[i2] = planeToKeep;
    if (planeToKeep instanceof ClippingPlane_default) {
      planeToKeep.index = i2;
    }
  }
  this._multipleDirtyPlanes = true;
  planes.length = length3;
  this.planeRemoved.raiseEvent(clippingPlane, index2);
  return true;
};
ClippingPlaneCollection.prototype.removeAll = function() {
  const planes = this._planes;
  const planesCount = planes.length;
  for (let i2 = 0; i2 < planesCount; ++i2) {
    const plane = planes[i2];
    if (plane instanceof ClippingPlane_default) {
      plane.onChangeCallback = void 0;
      plane.index = -1;
    }
    this.planeRemoved.raiseEvent(plane, i2);
  }
  this._multipleDirtyPlanes = true;
  this._planes = [];
};
var distanceEncodeScratch = new Cartesian4_default();
var oct32EncodeScratch = new Cartesian4_default();
function packPlanesAsUint8(clippingPlaneCollection, startIndex, endIndex) {
  const uint8View = clippingPlaneCollection._uint8View;
  const planes = clippingPlaneCollection._planes;
  let byteIndex = 0;
  for (let i2 = startIndex; i2 < endIndex; ++i2) {
    const plane = planes[i2];
    const oct32Normal = AttributeCompression_default.octEncodeToCartesian4(
      plane.normal,
      oct32EncodeScratch
    );
    uint8View[byteIndex] = oct32Normal.x;
    uint8View[byteIndex + 1] = oct32Normal.y;
    uint8View[byteIndex + 2] = oct32Normal.z;
    uint8View[byteIndex + 3] = oct32Normal.w;
    const encodedDistance = Cartesian4_default.packFloat(
      plane.distance,
      distanceEncodeScratch
    );
    uint8View[byteIndex + 4] = encodedDistance.x;
    uint8View[byteIndex + 5] = encodedDistance.y;
    uint8View[byteIndex + 6] = encodedDistance.z;
    uint8View[byteIndex + 7] = encodedDistance.w;
    byteIndex += 8;
  }
}
function packPlanesAsFloats(clippingPlaneCollection, startIndex, endIndex) {
  const float32View = clippingPlaneCollection._float32View;
  const planes = clippingPlaneCollection._planes;
  let floatIndex = 0;
  for (let i2 = startIndex; i2 < endIndex; ++i2) {
    const plane = planes[i2];
    const normal2 = plane.normal;
    float32View[floatIndex] = normal2.x;
    float32View[floatIndex + 1] = normal2.y;
    float32View[floatIndex + 2] = normal2.z;
    float32View[floatIndex + 3] = plane.distance;
    floatIndex += 4;
  }
}
function computeTextureResolution(pixelsNeeded, result) {
  const maxSize = ContextLimits_default.maximumTextureSize;
  result.x = Math.min(pixelsNeeded, maxSize);
  result.y = Math.ceil(pixelsNeeded / result.x);
  return result;
}
var textureResolutionScratch = new Cartesian2_default();
ClippingPlaneCollection.prototype.update = function(frameState) {
  let clippingPlanesTexture = this._clippingPlanesTexture;
  const context = frameState.context;
  const useFloatTexture = ClippingPlaneCollection.useFloatTexture(context);
  const pixelsNeeded = useFloatTexture ? this.length : this.length * 2;
  if (defined_default(clippingPlanesTexture)) {
    const currentPixelCount = clippingPlanesTexture.width * clippingPlanesTexture.height;
    if (currentPixelCount < pixelsNeeded || pixelsNeeded < 0.25 * currentPixelCount) {
      clippingPlanesTexture.destroy();
      clippingPlanesTexture = void 0;
      this._clippingPlanesTexture = void 0;
    }
  }
  if (this.length === 0) {
    return;
  }
  if (!defined_default(clippingPlanesTexture)) {
    const requiredResolution = computeTextureResolution(
      pixelsNeeded,
      textureResolutionScratch
    );
    requiredResolution.y *= 2;
    if (useFloatTexture) {
      clippingPlanesTexture = new Texture_default({
        context,
        width: requiredResolution.x,
        height: requiredResolution.y,
        pixelFormat: PixelFormat_default.RGBA,
        pixelDatatype: PixelDatatype_default.FLOAT,
        sampler: Sampler_default.NEAREST,
        flipY: false
      });
      this._float32View = new Float32Array(
        requiredResolution.x * requiredResolution.y * 4
      );
    } else {
      clippingPlanesTexture = new Texture_default({
        context,
        width: requiredResolution.x,
        height: requiredResolution.y,
        pixelFormat: PixelFormat_default.RGBA,
        pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
        sampler: Sampler_default.NEAREST,
        flipY: false
      });
      this._uint8View = new Uint8Array(
        requiredResolution.x * requiredResolution.y * 4
      );
    }
    this._clippingPlanesTexture = clippingPlanesTexture;
    this._multipleDirtyPlanes = true;
  }
  const dirtyIndex = this._dirtyIndex;
  if (!this._multipleDirtyPlanes && dirtyIndex === -1) {
    return;
  }
  if (!this._multipleDirtyPlanes) {
    let offsetX = 0;
    let offsetY = 0;
    if (useFloatTexture) {
      offsetY = Math.floor(dirtyIndex / clippingPlanesTexture.width);
      offsetX = Math.floor(dirtyIndex - offsetY * clippingPlanesTexture.width);
      packPlanesAsFloats(this, dirtyIndex, dirtyIndex + 1);
      clippingPlanesTexture.copyFrom({
        source: {
          width: 1,
          height: 1,
          arrayBufferView: this._float32View
        },
        xOffset: offsetX,
        yOffset: offsetY
      });
    } else {
      offsetY = Math.floor(dirtyIndex * 2 / clippingPlanesTexture.width);
      offsetX = Math.floor(
        dirtyIndex * 2 - offsetY * clippingPlanesTexture.width
      );
      packPlanesAsUint8(this, dirtyIndex, dirtyIndex + 1);
      clippingPlanesTexture.copyFrom({
        source: {
          width: 2,
          height: 1,
          arrayBufferView: this._uint8View
        },
        xOffset: offsetX,
        yOffset: offsetY
      });
    }
  } else if (useFloatTexture) {
    packPlanesAsFloats(this, 0, this._planes.length);
    clippingPlanesTexture.copyFrom({
      source: {
        width: clippingPlanesTexture.width,
        height: clippingPlanesTexture.height,
        arrayBufferView: this._float32View
      }
    });
  } else {
    packPlanesAsUint8(this, 0, this._planes.length);
    clippingPlanesTexture.copyFrom({
      source: {
        width: clippingPlanesTexture.width,
        height: clippingPlanesTexture.height,
        arrayBufferView: this._uint8View
      }
    });
  }
  this._multipleDirtyPlanes = false;
  this._dirtyIndex = -1;
};
var scratchMatrix = new Matrix4_default();
var scratchPlane3 = new Plane_default(Cartesian3_default.UNIT_X, 0);
ClippingPlaneCollection.prototype.computeIntersectionWithBoundingVolume = function(tileBoundingVolume, transform4) {
  const planes = this._planes;
  const length3 = planes.length;
  let modelMatrix = this.modelMatrix;
  if (defined_default(transform4)) {
    modelMatrix = Matrix4_default.multiply(transform4, modelMatrix, scratchMatrix);
  }
  let intersection = Intersect_default.INSIDE;
  if (!this.unionClippingRegions && length3 > 0) {
    intersection = Intersect_default.OUTSIDE;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    const plane = planes[i2];
    Plane_default.transform(plane, modelMatrix, scratchPlane3);
    const value = tileBoundingVolume.intersectPlane(scratchPlane3);
    if (value === Intersect_default.INTERSECTING) {
      intersection = value;
    } else if (this._testIntersection(value)) {
      return value;
    }
  }
  return intersection;
};
ClippingPlaneCollection.setOwner = function(clippingPlaneCollection, owner, key) {
  if (clippingPlaneCollection === owner[key]) {
    return;
  }
  owner[key] = owner[key] && owner[key].destroy();
  if (defined_default(clippingPlaneCollection)) {
    if (defined_default(clippingPlaneCollection._owner)) {
      throw new DeveloperError_default(
        "ClippingPlaneCollection should only be assigned to one object"
      );
    }
    clippingPlaneCollection._owner = owner;
    owner[key] = clippingPlaneCollection;
  }
};
ClippingPlaneCollection.useFloatTexture = function(context) {
  return context.floatingPointTexture;
};
ClippingPlaneCollection.getTextureResolution = function(clippingPlaneCollection, context, result) {
  const texture = clippingPlaneCollection.texture;
  if (defined_default(texture)) {
    result.x = texture.width;
    result.y = texture.height;
    return result;
  }
  const pixelsNeeded = ClippingPlaneCollection.useFloatTexture(context) ? clippingPlaneCollection.length : clippingPlaneCollection.length * 2;
  const requiredResolution = computeTextureResolution(pixelsNeeded, result);
  requiredResolution.y *= 2;
  return requiredResolution;
};
ClippingPlaneCollection.prototype.isDestroyed = function() {
  return false;
};
ClippingPlaneCollection.prototype.destroy = function() {
  this._clippingPlanesTexture = this._clippingPlanesTexture && this._clippingPlanesTexture.destroy();
  return destroyObject_default(this);
};
var ClippingPlaneCollection_default = ClippingPlaneCollection;

// node_modules/cesium/Source/Scene/ColorBlendMode.js
var ColorBlendMode = {
  HIGHLIGHT: 0,
  REPLACE: 1,
  MIX: 2
};
ColorBlendMode.getColorBlend = function(colorBlendMode, colorBlendAmount) {
  if (colorBlendMode === ColorBlendMode.HIGHLIGHT) {
    return 0;
  } else if (colorBlendMode === ColorBlendMode.REPLACE) {
    return 1;
  } else if (colorBlendMode === ColorBlendMode.MIX) {
    return Math_default.clamp(colorBlendAmount, Math_default.EPSILON4, 1);
  }
};
var ColorBlendMode_default = Object.freeze(ColorBlendMode);

// node_modules/cesium/Source/Scene/DracoLoader.js
function DracoLoader() {
}
DracoLoader._maxDecodingConcurrency = Math.max(
  FeatureDetection_default.hardwareConcurrency - 1,
  1
);
DracoLoader._decoderTaskProcessor = void 0;
DracoLoader._taskProcessorReady = false;
DracoLoader._getDecoderTaskProcessor = function() {
  if (!defined_default(DracoLoader._decoderTaskProcessor)) {
    const processor = new TaskProcessor_default(
      "decodeDraco",
      DracoLoader._maxDecodingConcurrency
    );
    processor.initWebAssemblyModule({
      modulePath: "ThirdParty/Workers/draco_decoder_nodejs.js",
      wasmBinaryFile: "ThirdParty/draco_decoder.wasm"
    }).then(function() {
      DracoLoader._taskProcessorReady = true;
    });
    DracoLoader._decoderTaskProcessor = processor;
  }
  return DracoLoader._decoderTaskProcessor;
};
DracoLoader.hasExtension = function(model) {
  return defined_default(model.extensionsRequired.KHR_draco_mesh_compression) || defined_default(model.extensionsUsed.KHR_draco_mesh_compression);
};
function addBufferToLoadResources(loadResources, typedArray) {
  const bufferViewId = `runtime.${Object.keys(loadResources.createdBufferViews).length}`;
  const loadResourceBuffers = loadResources.buffers;
  const id = Object.keys(loadResourceBuffers).length;
  loadResourceBuffers[id] = typedArray;
  loadResources.createdBufferViews[bufferViewId] = {
    buffer: id,
    byteOffset: 0,
    byteLength: typedArray.byteLength
  };
  return bufferViewId;
}
function addNewVertexBuffer(typedArray, model, context) {
  const loadResources = model._loadResources;
  const id = addBufferToLoadResources(loadResources, typedArray);
  loadResources.vertexBuffersToCreate.enqueue(id);
  return id;
}
function addNewIndexBuffer(indexArray, model, context) {
  const typedArray = indexArray.typedArray;
  const loadResources = model._loadResources;
  const id = addBufferToLoadResources(loadResources, typedArray);
  loadResources.indexBuffersToCreate.enqueue({
    id,
    componentType: ComponentDatatype_default.fromTypedArray(typedArray)
  });
  return {
    bufferViewId: id,
    numberOfIndices: indexArray.numberOfIndices
  };
}
function scheduleDecodingTask(decoderTaskProcessor, model, loadResources, context) {
  if (!DracoLoader._taskProcessorReady) {
    return;
  }
  const taskData = loadResources.primitivesToDecode.peek();
  if (!defined_default(taskData)) {
    return;
  }
  const promise = decoderTaskProcessor.scheduleTask(taskData, [
    taskData.array.buffer
  ]);
  if (!defined_default(promise)) {
    return;
  }
  loadResources.activeDecodingTasks++;
  loadResources.primitivesToDecode.dequeue();
  return promise.then(function(result) {
    loadResources.activeDecodingTasks--;
    const decodedIndexBuffer = addNewIndexBuffer(
      result.indexArray,
      model,
      context
    );
    const attributes = {};
    const decodedAttributeData = result.attributeData;
    for (const attributeName in decodedAttributeData) {
      if (decodedAttributeData.hasOwnProperty(attributeName)) {
        const attribute = decodedAttributeData[attributeName];
        const vertexArray = attribute.array;
        const vertexBufferView = addNewVertexBuffer(
          vertexArray,
          model,
          context
        );
        const data = attribute.data;
        data.bufferView = vertexBufferView;
        attributes[attributeName] = data;
      }
    }
    model._decodedData[`${taskData.mesh}.primitive.${taskData.primitive}`] = {
      bufferView: decodedIndexBuffer.bufferViewId,
      numberOfIndices: decodedIndexBuffer.numberOfIndices,
      attributes
    };
  });
}
DracoLoader._decodedModelResourceCache = void 0;
DracoLoader.parse = function(model, context) {
  if (!DracoLoader.hasExtension(model)) {
    return;
  }
  const loadResources = model._loadResources;
  const cacheKey = model.cacheKey;
  if (defined_default(cacheKey)) {
    if (!defined_default(DracoLoader._decodedModelResourceCache)) {
      if (!defined_default(context.cache.modelDecodingCache)) {
        context.cache.modelDecodingCache = {};
      }
      DracoLoader._decodedModelResourceCache = context.cache.modelDecodingCache;
    }
    const cachedData = DracoLoader._decodedModelResourceCache[cacheKey];
    if (defined_default(cachedData)) {
      cachedData.count++;
      loadResources.pendingDecodingCache = true;
      return;
    }
  }
  const dequantizeInShader = model._dequantizeInShader;
  const gltf = model.gltf;
  ForEach_default.mesh(gltf, function(mesh2, meshId) {
    ForEach_default.meshPrimitive(mesh2, function(primitive, primitiveId) {
      if (!defined_default(primitive.extensions)) {
        return;
      }
      const compressionData = primitive.extensions.KHR_draco_mesh_compression;
      if (!defined_default(compressionData)) {
        return;
      }
      const bufferView = gltf.bufferViews[compressionData.bufferView];
      const typedArray = arraySlice_default(
        gltf.buffers[bufferView.buffer].extras._pipeline.source,
        bufferView.byteOffset,
        bufferView.byteOffset + bufferView.byteLength
      );
      loadResources.primitivesToDecode.enqueue({
        mesh: meshId,
        primitive: primitiveId,
        array: typedArray,
        bufferView,
        compressedAttributes: compressionData.attributes,
        dequantizeInShader
      });
    });
  });
};
DracoLoader.decodeModel = function(model, context) {
  if (!DracoLoader.hasExtension(model)) {
    return Promise.resolve();
  }
  const loadResources = model._loadResources;
  const cacheKey = model.cacheKey;
  if (defined_default(cacheKey) && defined_default(DracoLoader._decodedModelResourceCache)) {
    const cachedData = DracoLoader._decodedModelResourceCache[cacheKey];
    if (defined_default(cachedData) && loadResources.pendingDecodingCache) {
      return Promise.resolve(cachedData.ready).then(function() {
        model._decodedData = cachedData.data;
        loadResources.pendingDecodingCache = false;
      });
    }
    DracoLoader._decodedModelResourceCache[cacheKey] = {
      ready: false,
      count: 1,
      data: void 0
    };
  }
  if (loadResources.primitivesToDecode.length === 0) {
    return Promise.resolve();
  }
  const decoderTaskProcessor = DracoLoader._getDecoderTaskProcessor();
  const decodingPromises = [];
  let promise = scheduleDecodingTask(
    decoderTaskProcessor,
    model,
    loadResources,
    context
  );
  while (defined_default(promise)) {
    decodingPromises.push(promise);
    promise = scheduleDecodingTask(
      decoderTaskProcessor,
      model,
      loadResources,
      context
    );
  }
  return Promise.all(decodingPromises);
};
DracoLoader.decodePointCloud = function(parameters) {
  const decoderTaskProcessor = DracoLoader._getDecoderTaskProcessor();
  if (!DracoLoader._taskProcessorReady) {
    return;
  }
  return decoderTaskProcessor.scheduleTask(parameters, [
    parameters.buffer.buffer
  ]);
};
DracoLoader.decodeBufferView = function(options) {
  const decoderTaskProcessor = DracoLoader._getDecoderTaskProcessor();
  if (!DracoLoader._taskProcessorReady) {
    return;
  }
  return decoderTaskProcessor.scheduleTask(options, [options.array.buffer]);
};
DracoLoader.cacheDataForModel = function(model) {
  const cacheKey = model.cacheKey;
  if (defined_default(cacheKey) && defined_default(DracoLoader._decodedModelResourceCache)) {
    const cachedData = DracoLoader._decodedModelResourceCache[cacheKey];
    if (defined_default(cachedData)) {
      cachedData.ready = true;
      cachedData.data = model._decodedData;
    }
  }
};
DracoLoader.destroyCachedDataForModel = function(model) {
  const cacheKey = model.cacheKey;
  if (defined_default(cacheKey) && defined_default(DracoLoader._decodedModelResourceCache)) {
    const cachedData = DracoLoader._decodedModelResourceCache[cacheKey];
    if (defined_default(cachedData) && --cachedData.count === 0) {
      delete DracoLoader._decodedModelResourceCache[cacheKey];
    }
  }
};
var DracoLoader_default = DracoLoader;

// node_modules/cesium/Source/Scene/getClipAndStyleCode.js
function getClipAndStyleCode(samplerUniformName, matrixUniformName, styleUniformName) {
  Check_default.typeOf.string("samplerUniformName", samplerUniformName);
  Check_default.typeOf.string("matrixUniformName", matrixUniformName);
  Check_default.typeOf.string("styleUniformName", styleUniformName);
  const shaderCode = `    float clipDistance = clip(gl_FragCoord, ${samplerUniformName}, ${matrixUniformName}); 
    vec4 clippingPlanesEdgeColor = vec4(1.0); 
    clippingPlanesEdgeColor.rgb = ${styleUniformName}.rgb; 
    float clippingPlanesEdgeWidth = ${styleUniformName}.a; 
    if (clipDistance > 0.0 && clipDistance < clippingPlanesEdgeWidth) 
    { 
        gl_FragColor = clippingPlanesEdgeColor;
    } 
`;
  return shaderCode;
}
var getClipAndStyleCode_default = getClipAndStyleCode;

// node_modules/cesium/Source/Scene/getClippingFunction.js
var textureResolutionScratch2 = new Cartesian2_default();
function getClippingFunction(clippingPlaneCollection, context) {
  Check_default.typeOf.object("clippingPlaneCollection", clippingPlaneCollection);
  Check_default.typeOf.object("context", context);
  const unionClippingRegions = clippingPlaneCollection.unionClippingRegions;
  const clippingPlanesLength = clippingPlaneCollection.length;
  const usingFloatTexture = ClippingPlaneCollection_default.useFloatTexture(context);
  const textureResolution = ClippingPlaneCollection_default.getTextureResolution(
    clippingPlaneCollection,
    context,
    textureResolutionScratch2
  );
  const width = textureResolution.x;
  const height = textureResolution.y;
  let functions = usingFloatTexture ? getClippingPlaneFloat(width, height) : getClippingPlaneUint8(width, height);
  functions += "\n";
  functions += unionClippingRegions ? clippingFunctionUnion(clippingPlanesLength) : clippingFunctionIntersect(clippingPlanesLength);
  return functions;
}
function clippingFunctionUnion(clippingPlanesLength) {
  const functionString = `${"float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)\n{\n    vec4 position = czm_windowToEyeCoordinates(fragCoord);\n    vec3 clipNormal = vec3(0.0);\n    vec3 clipPosition = vec3(0.0);\n    float clipAmount;\n    float pixelWidth = czm_metersPerPixel(position);\n    bool breakAndDiscard = false;\n    for (int i = 0; i < "}${clippingPlanesLength}; ++i)
    {
        vec4 clippingPlane = getClippingPlane(clippingPlanes, i, clippingPlanesMatrix);
        clipNormal = clippingPlane.xyz;
        clipPosition = -clippingPlane.w * clipNormal;
        float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;
        clipAmount = czm_branchFreeTernary(i == 0, amount, min(amount, clipAmount));
        if (amount <= 0.0)
        {
           breakAndDiscard = true;
           break;
        }
    }
    if (breakAndDiscard) {
        discard;
    }
    return clipAmount;
}
`;
  return functionString;
}
function clippingFunctionIntersect(clippingPlanesLength) {
  const functionString = `${"float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)\n{\n    bool clipped = true;\n    vec4 position = czm_windowToEyeCoordinates(fragCoord);\n    vec3 clipNormal = vec3(0.0);\n    vec3 clipPosition = vec3(0.0);\n    float clipAmount = 0.0;\n    float pixelWidth = czm_metersPerPixel(position);\n    for (int i = 0; i < "}${clippingPlanesLength}; ++i)
    {
        vec4 clippingPlane = getClippingPlane(clippingPlanes, i, clippingPlanesMatrix);
        clipNormal = clippingPlane.xyz;
        clipPosition = -clippingPlane.w * clipNormal;
        float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;
        clipAmount = max(amount, clipAmount);
        clipped = clipped && (amount <= 0.0);
    }
    if (clipped)
    {
        discard;
    }
    return clipAmount;
}
`;
  return functionString;
}
function getClippingPlaneFloat(width, height) {
  const pixelWidth = 1 / width;
  const pixelHeight = 1 / height;
  let pixelWidthString = `${pixelWidth}`;
  if (pixelWidthString.indexOf(".") === -1) {
    pixelWidthString += ".0";
  }
  let pixelHeightString = `${pixelHeight}`;
  if (pixelHeightString.indexOf(".") === -1) {
    pixelHeightString += ".0";
  }
  const functionString = `${"vec4 getClippingPlane(highp sampler2D packedClippingPlanes, int clippingPlaneNumber, mat4 transform)\n{\n    int pixY = clippingPlaneNumber / "}${width};
    int pixX = clippingPlaneNumber - (pixY * ${width});
    float u = (float(pixX) + 0.5) * ${pixelWidthString};
    float v = (float(pixY) + 0.5) * ${pixelHeightString};
    vec4 plane = texture2D(packedClippingPlanes, vec2(u, v));
    return czm_transformPlane(plane, transform);
}
`;
  return functionString;
}
function getClippingPlaneUint8(width, height) {
  const pixelWidth = 1 / width;
  const pixelHeight = 1 / height;
  let pixelWidthString = `${pixelWidth}`;
  if (pixelWidthString.indexOf(".") === -1) {
    pixelWidthString += ".0";
  }
  let pixelHeightString = `${pixelHeight}`;
  if (pixelHeightString.indexOf(".") === -1) {
    pixelHeightString += ".0";
  }
  const functionString = `${"vec4 getClippingPlane(highp sampler2D packedClippingPlanes, int clippingPlaneNumber, mat4 transform)\n{\n    int clippingPlaneStartIndex = clippingPlaneNumber * 2;\n    int pixY = clippingPlaneStartIndex / "}${width};
    int pixX = clippingPlaneStartIndex - (pixY * ${width});
    float u = (float(pixX) + 0.5) * ${pixelWidthString};
    float v = (float(pixY) + 0.5) * ${pixelHeightString};
    vec4 oct32 = texture2D(packedClippingPlanes, vec2(u, v)) * 255.0;
    vec2 oct = vec2(oct32.x * 256.0 + oct32.y, oct32.z * 256.0 + oct32.w);
    vec4 plane;
    plane.xyz = czm_octDecode(oct, 65535.0);
    plane.w = czm_unpackFloat(texture2D(packedClippingPlanes, vec2(u + ${pixelWidthString}, v)));
    return czm_transformPlane(plane, transform);
}
`;
  return functionString;
}
var getClippingFunction_default = getClippingFunction;

// node_modules/cesium/Source/Scene/JobType.js
var JobType = {
  TEXTURE: 0,
  PROGRAM: 1,
  BUFFER: 2,
  NUMBER_OF_JOB_TYPES: 3
};
var JobType_default = Object.freeze(JobType);

// node_modules/cesium/Source/Scene/ModelAnimationCache.js
function ModelAnimationCache() {
}
var dataUriRegex3 = /^data\:/i;
function getAccessorKey(model, accessor) {
  const gltf = model.gltf;
  const buffers = gltf.buffers;
  const bufferViews = gltf.bufferViews;
  const bufferView = bufferViews[accessor.bufferView];
  const buffer = buffers[bufferView.buffer];
  const byteOffset = bufferView.byteOffset + accessor.byteOffset;
  const byteLength = accessor.count * numberOfComponentsForType_default(accessor.type);
  const uriKey = dataUriRegex3.test(buffer.uri) ? "" : buffer.uri;
  return `${model.cacheKey}//${uriKey}/${byteOffset}/${byteLength}`;
}
var cachedAnimationParameters = {};
ModelAnimationCache.getAnimationParameterValues = function(model, accessor) {
  const key = getAccessorKey(model, accessor);
  let values = cachedAnimationParameters[key];
  if (!defined_default(values)) {
    const gltf = model.gltf;
    const buffers = gltf.buffers;
    const bufferViews = gltf.bufferViews;
    const bufferView = bufferViews[accessor.bufferView];
    const bufferId = bufferView.buffer;
    const buffer = buffers[bufferId];
    const source = buffer.extras._pipeline.source;
    const componentType = accessor.componentType;
    const type = accessor.type;
    const numberOfComponents = numberOfComponentsForType_default(type);
    const count = accessor.count;
    const byteStride = getAccessorByteStride_default(gltf, accessor);
    values = new Array(count);
    const accessorByteOffset = defaultValue_default(accessor.byteOffset, 0);
    let byteOffset = bufferView.byteOffset + accessorByteOffset;
    for (let i2 = 0; i2 < count; i2++) {
      const typedArrayView = ComponentDatatype_default.createArrayBufferView(
        componentType,
        source.buffer,
        source.byteOffset + byteOffset,
        numberOfComponents
      );
      if (type === "SCALAR") {
        values[i2] = typedArrayView[0];
      } else if (type === "VEC3") {
        values[i2] = Cartesian3_default.fromArray(typedArrayView);
      } else if (type === "VEC4") {
        values[i2] = Quaternion_default.unpack(typedArrayView);
      }
      byteOffset += byteStride;
    }
    if (defined_default(model.cacheKey)) {
      cachedAnimationParameters[key] = values;
    }
  }
  return values;
};
var cachedAnimationSplines = {};
function getAnimationSplineKey(model, animationName, samplerName) {
  return `${model.cacheKey}//${animationName}/${samplerName}`;
}
function SteppedSpline2(backingSpline) {
  this._spline = backingSpline;
  this._lastTimeIndex = 0;
}
SteppedSpline2.prototype.findTimeInterval = Spline_default.prototype.findTimeInterval;
SteppedSpline2.prototype.evaluate = function(time, result) {
  const i2 = this._lastTimeIndex = this.findTimeInterval(
    time,
    this._lastTimeIndex
  );
  const times = this._spline.times;
  const steppedTime = time >= times[i2 + 1] ? times[i2 + 1] : times[i2];
  return this._spline.evaluate(steppedTime, result);
};
Object.defineProperties(SteppedSpline2.prototype, {
  times: {
    get: function() {
      return this._spline.times;
    }
  }
});
SteppedSpline2.prototype.wrapTime = function(time) {
  return this._spline.wrapTime(time);
};
SteppedSpline2.prototype.clampTime = function(time) {
  return this._spline.clampTime(time);
};
ModelAnimationCache.getAnimationSpline = function(model, animationName, animation, samplerName, sampler, input, path, output) {
  const key = getAnimationSplineKey(model, animationName, samplerName);
  let spline = cachedAnimationSplines[key];
  if (!defined_default(spline)) {
    const times = input;
    const controlPoints = output;
    if (times.length === 1 && controlPoints.length === 1) {
      spline = new ConstantSpline_default(controlPoints[0]);
    } else if (sampler.interpolation === "LINEAR" || sampler.interpolation === "STEP") {
      if (path === "translation" || path === "scale") {
        spline = new LinearSpline_default({
          times,
          points: controlPoints
        });
      } else if (path === "rotation") {
        spline = new QuaternionSpline_default({
          times,
          points: controlPoints
        });
      } else if (path === "weights") {
        spline = new MorphWeightSpline_default({
          times,
          weights: controlPoints
        });
      }
      if (defined_default(spline) && sampler.interpolation === "STEP") {
        spline = new SteppedSpline2(spline);
      }
    }
    if (defined_default(model.cacheKey)) {
      cachedAnimationSplines[key] = spline;
    }
  }
  return spline;
};
var cachedSkinInverseBindMatrices = {};
ModelAnimationCache.getSkinInverseBindMatrices = function(model, accessor) {
  const key = getAccessorKey(model, accessor);
  let matrices = cachedSkinInverseBindMatrices[key];
  if (!defined_default(matrices)) {
    const gltf = model.gltf;
    const buffers = gltf.buffers;
    const bufferViews = gltf.bufferViews;
    const bufferViewId = accessor.bufferView;
    const bufferView = bufferViews[bufferViewId];
    const bufferId = bufferView.buffer;
    const buffer = buffers[bufferId];
    const source = buffer.extras._pipeline.source;
    const componentType = accessor.componentType;
    const type = accessor.type;
    const count = accessor.count;
    const byteStride = getAccessorByteStride_default(gltf, accessor);
    let byteOffset = bufferView.byteOffset + accessor.byteOffset;
    const numberOfComponents = numberOfComponentsForType_default(type);
    matrices = new Array(count);
    if (componentType === WebGLConstants_default.FLOAT && type === AttributeType_default.MAT4) {
      for (let i2 = 0; i2 < count; ++i2) {
        const typedArrayView = ComponentDatatype_default.createArrayBufferView(
          componentType,
          source.buffer,
          source.byteOffset + byteOffset,
          numberOfComponents
        );
        matrices[i2] = Matrix4_default.fromArray(typedArrayView);
        byteOffset += byteStride;
      }
    }
    cachedSkinInverseBindMatrices[key] = matrices;
  }
  return matrices;
};
var ModelAnimationCache_default = ModelAnimationCache;

// node_modules/cesium/Source/Scene/ModelAnimationLoop.js
var ModelAnimationLoop = {
  NONE: 0,
  REPEAT: 1,
  MIRRORED_REPEAT: 2
};
var ModelAnimationLoop_default = Object.freeze(ModelAnimationLoop);

// node_modules/cesium/Source/Scene/ModelAnimationState.js
var ModelAnimationState_default = Object.freeze({
  STOPPED: 0,
  ANIMATING: 1
});

// node_modules/cesium/Source/Scene/ModelAnimation.js
function ModelAnimation(options, model, runtimeAnimation) {
  this._name = runtimeAnimation.name;
  this._startTime = JulianDate_default.clone(options.startTime);
  this._delay = defaultValue_default(options.delay, 0);
  this._stopTime = options.stopTime;
  this.removeOnStop = defaultValue_default(options.removeOnStop, false);
  this._multiplier = defaultValue_default(options.multiplier, 1);
  this._reverse = defaultValue_default(options.reverse, false);
  this._loop = defaultValue_default(options.loop, ModelAnimationLoop_default.NONE);
  this.start = new Event_default();
  this.update = new Event_default();
  this.stop = new Event_default();
  this._state = ModelAnimationState_default.STOPPED;
  this._runtimeAnimation = runtimeAnimation;
  this._computedStartTime = void 0;
  this._duration = void 0;
  const that = this;
  this._raiseStartEvent = function() {
    that.start.raiseEvent(model, that);
  };
  this._updateEventTime = 0;
  this._raiseUpdateEvent = function() {
    that.update.raiseEvent(model, that, that._updateEventTime);
  };
  this._raiseStopEvent = function() {
    that.stop.raiseEvent(model, that);
  };
}
Object.defineProperties(ModelAnimation.prototype, {
  name: {
    get: function() {
      return this._name;
    }
  },
  startTime: {
    get: function() {
      return this._startTime;
    }
  },
  delay: {
    get: function() {
      return this._delay;
    }
  },
  stopTime: {
    get: function() {
      return this._stopTime;
    }
  },
  multiplier: {
    get: function() {
      return this._multiplier;
    }
  },
  reverse: {
    get: function() {
      return this._reverse;
    }
  },
  loop: {
    get: function() {
      return this._loop;
    }
  }
});
var ModelAnimation_default = ModelAnimation;

// node_modules/cesium/Source/Scene/ModelAnimationCollection.js
function ModelAnimationCollection(model) {
  this.animationAdded = new Event_default();
  this.animationRemoved = new Event_default();
  this._model = model;
  this._scheduledAnimations = [];
  this._previousTime = void 0;
}
Object.defineProperties(ModelAnimationCollection.prototype, {
  length: {
    get: function() {
      return this._scheduledAnimations.length;
    }
  }
});
function add(collection, index2, options) {
  const model = collection._model;
  const animations = model._runtime.animations;
  const animation = animations[index2];
  const scheduledAnimation = new ModelAnimation_default(options, model, animation);
  collection._scheduledAnimations.push(scheduledAnimation);
  collection.animationAdded.raiseEvent(model, scheduledAnimation);
  return scheduledAnimation;
}
ModelAnimationCollection.prototype.add = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const model = this._model;
  const animations = model._runtime.animations;
  if (!defined_default(animations)) {
    throw new DeveloperError_default(
      "Animations are not loaded.  Wait for Model.readyPromise to resolve."
    );
  }
  if (!defined_default(options.name) && !defined_default(options.index)) {
    throw new DeveloperError_default(
      "Either options.name or options.index must be defined."
    );
  }
  if (defined_default(options.multiplier) && options.multiplier <= 0) {
    throw new DeveloperError_default("options.multiplier must be greater than zero.");
  }
  if (defined_default(options.index) && (options.index >= animations.length || options.index < 0)) {
    throw new DeveloperError_default("options.index must be a valid animation index.");
  }
  if (defined_default(options.index)) {
    return add(this, options.index, options);
  }
  let index2;
  const length3 = animations.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (animations[i2].name === options.name) {
      index2 = i2;
      break;
    }
  }
  if (!defined_default(index2)) {
    throw new DeveloperError_default("options.name must be a valid animation name.");
  }
  return add(this, index2, options);
};
ModelAnimationCollection.prototype.addAll = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(this._model._runtime.animations)) {
    throw new DeveloperError_default(
      "Animations are not loaded.  Wait for Model.readyPromise to resolve."
    );
  }
  if (defined_default(options.multiplier) && options.multiplier <= 0) {
    throw new DeveloperError_default("options.multiplier must be greater than zero.");
  }
  const scheduledAnimations = [];
  const model = this._model;
  const animations = model._runtime.animations;
  const length3 = animations.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    scheduledAnimations.push(add(this, i2, options));
  }
  return scheduledAnimations;
};
ModelAnimationCollection.prototype.remove = function(animation) {
  if (defined_default(animation)) {
    const animations = this._scheduledAnimations;
    const i2 = animations.indexOf(animation);
    if (i2 !== -1) {
      animations.splice(i2, 1);
      this.animationRemoved.raiseEvent(this._model, animation);
      return true;
    }
  }
  return false;
};
ModelAnimationCollection.prototype.removeAll = function() {
  const model = this._model;
  const animations = this._scheduledAnimations;
  const length3 = animations.length;
  this._scheduledAnimations = [];
  for (let i2 = 0; i2 < length3; ++i2) {
    this.animationRemoved.raiseEvent(model, animations[i2]);
  }
};
ModelAnimationCollection.prototype.contains = function(animation) {
  if (defined_default(animation)) {
    return this._scheduledAnimations.indexOf(animation) !== -1;
  }
  return false;
};
ModelAnimationCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.");
  }
  return this._scheduledAnimations[index2];
};
function animateChannels(runtimeAnimation, localAnimationTime) {
  const channelEvaluators = runtimeAnimation.channelEvaluators;
  const length3 = channelEvaluators.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    channelEvaluators[i2](localAnimationTime);
  }
}
var animationsToRemove = [];
function createAnimationRemovedFunction(modelAnimationCollection, model, animation) {
  return function() {
    modelAnimationCollection.animationRemoved.raiseEvent(model, animation);
  };
}
ModelAnimationCollection.prototype.update = function(frameState) {
  const scheduledAnimations = this._scheduledAnimations;
  let length3 = scheduledAnimations.length;
  if (length3 === 0) {
    this._previousTime = void 0;
    return false;
  }
  if (JulianDate_default.equals(frameState.time, this._previousTime)) {
    return false;
  }
  this._previousTime = JulianDate_default.clone(frameState.time, this._previousTime);
  let animationOccured = false;
  const sceneTime = frameState.time;
  const model = this._model;
  for (let i2 = 0; i2 < length3; ++i2) {
    const scheduledAnimation = scheduledAnimations[i2];
    const runtimeAnimation = scheduledAnimation._runtimeAnimation;
    if (!defined_default(scheduledAnimation._computedStartTime)) {
      scheduledAnimation._computedStartTime = JulianDate_default.addSeconds(
        defaultValue_default(scheduledAnimation.startTime, sceneTime),
        scheduledAnimation.delay,
        new JulianDate_default()
      );
    }
    if (!defined_default(scheduledAnimation._duration)) {
      scheduledAnimation._duration = runtimeAnimation.stopTime * (1 / scheduledAnimation.multiplier);
    }
    const startTime = scheduledAnimation._computedStartTime;
    const duration = scheduledAnimation._duration;
    const stopTime = scheduledAnimation.stopTime;
    let delta = duration !== 0 ? JulianDate_default.secondsDifference(sceneTime, startTime) / duration : 0;
    if (duration !== 0 && defined_default(stopTime) && JulianDate_default.greaterThan(sceneTime, stopTime)) {
      delta = JulianDate_default.secondsDifference(stopTime, startTime) / duration;
    }
    const pastStartTime = delta >= 0;
    const repeat = scheduledAnimation.loop === ModelAnimationLoop_default.REPEAT || scheduledAnimation.loop === ModelAnimationLoop_default.MIRRORED_REPEAT;
    const play = (pastStartTime || repeat && !defined_default(scheduledAnimation.startTime)) && (delta <= 1 || repeat) && (!defined_default(stopTime) || JulianDate_default.lessThanOrEquals(sceneTime, stopTime));
    if (play || scheduledAnimation._state === ModelAnimationState_default.ANIMATING) {
      if (play && scheduledAnimation._state === ModelAnimationState_default.STOPPED) {
        scheduledAnimation._state = ModelAnimationState_default.ANIMATING;
        if (scheduledAnimation.start.numberOfListeners > 0) {
          frameState.afterRender.push(scheduledAnimation._raiseStartEvent);
        }
      }
      if (scheduledAnimation.loop === ModelAnimationLoop_default.REPEAT) {
        delta = delta - Math.floor(delta);
      } else if (scheduledAnimation.loop === ModelAnimationLoop_default.MIRRORED_REPEAT) {
        const floor = Math.floor(delta);
        const fract2 = delta - floor;
        delta = floor % 2 === 1 ? 1 - fract2 : fract2;
      }
      if (scheduledAnimation.reverse) {
        delta = 1 - delta;
      }
      let localAnimationTime = delta * duration * scheduledAnimation.multiplier;
      localAnimationTime = Math_default.clamp(
        localAnimationTime,
        runtimeAnimation.startTime,
        runtimeAnimation.stopTime
      );
      animateChannels(runtimeAnimation, localAnimationTime);
      if (scheduledAnimation.update.numberOfListeners > 0) {
        scheduledAnimation._updateEventTime = localAnimationTime;
        frameState.afterRender.push(scheduledAnimation._raiseUpdateEvent);
      }
      animationOccured = true;
      if (!play) {
        scheduledAnimation._state = ModelAnimationState_default.STOPPED;
        if (scheduledAnimation.stop.numberOfListeners > 0) {
          frameState.afterRender.push(scheduledAnimation._raiseStopEvent);
        }
        if (scheduledAnimation.removeOnStop) {
          animationsToRemove.push(scheduledAnimation);
        }
      }
    }
  }
  length3 = animationsToRemove.length;
  for (let j = 0; j < length3; ++j) {
    const animationToRemove = animationsToRemove[j];
    scheduledAnimations.splice(
      scheduledAnimations.indexOf(animationToRemove),
      1
    );
    frameState.afterRender.push(
      createAnimationRemovedFunction(this, model, animationToRemove)
    );
  }
  animationsToRemove.length = 0;
  return animationOccured;
};
var ModelAnimationCollection_default = ModelAnimationCollection;

// node_modules/cesium/Source/Scene/ModelMaterial.js
function ModelMaterial(model, material, id) {
  this._name = material.name;
  this._id = id;
  this._uniformMap = model._uniformMaps[id];
  this._technique = void 0;
  this._program = void 0;
  this._values = void 0;
}
Object.defineProperties(ModelMaterial.prototype, {
  name: {
    get: function() {
      return this._name;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  }
});
ModelMaterial.prototype.setValue = function(name, value) {
  if (!defined_default(name)) {
    throw new DeveloperError_default("name is required.");
  }
  const uniformName = `u_${name}`;
  const v7 = this._uniformMap.values[uniformName];
  if (!defined_default(v7)) {
    throw new DeveloperError_default(
      "name must match a parameter name in the material's technique that is targetable and not optimized out."
    );
  }
  v7.value = v7.clone(value, v7.value);
};
ModelMaterial.prototype.getValue = function(name) {
  if (!defined_default(name)) {
    throw new DeveloperError_default("name is required.");
  }
  const uniformName = `u_${name}`;
  const v7 = this._uniformMap.values[uniformName];
  if (!defined_default(v7)) {
    return void 0;
  }
  return v7.value;
};
var ModelMaterial_default = ModelMaterial;

// node_modules/cesium/Source/Scene/ModelMesh.js
function ModelMesh(mesh2, runtimeMaterialsById, id) {
  const materials = [];
  const primitives = mesh2.primitives;
  const length3 = primitives.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const p2 = primitives[i2];
    materials[i2] = runtimeMaterialsById[p2.material];
  }
  this._name = mesh2.name;
  this._materials = materials;
  this._id = id;
}
Object.defineProperties(ModelMesh.prototype, {
  name: {
    get: function() {
      return this._name;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  materials: {
    get: function() {
      return this._materials;
    }
  }
});
var ModelMesh_default = ModelMesh;

// node_modules/cesium/Source/Scene/ModelNode.js
function ModelNode(model, node, runtimeNode, id, matrix) {
  this._model = model;
  this._runtimeNode = runtimeNode;
  this._name = node.name;
  this._id = id;
  this.useMatrix = false;
  this._show = true;
  this._matrix = Matrix4_default.clone(matrix);
  this._originalMatrix = Matrix4_default.clone(matrix);
}
Object.defineProperties(ModelNode.prototype, {
  name: {
    get: function() {
      return this._name;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  show: {
    get: function() {
      return this._show;
    },
    set: function(value) {
      if (this._show !== value) {
        this._show = value;
        this._model._perNodeShowDirty = true;
      }
    }
  },
  matrix: {
    get: function() {
      return this._matrix;
    },
    set: function(value) {
      this._matrix = Matrix4_default.clone(value, this._matrix);
      this.useMatrix = true;
      const model = this._model;
      model._cesiumAnimationsDirty = true;
      this._runtimeNode.dirtyNumber = model._maxDirtyNumber;
    }
  },
  originalMatrix: {
    get: function() {
      return this._originalMatrix;
    }
  }
});
ModelNode.prototype.setMatrix = function(matrix) {
  Matrix4_default.clone(matrix, this._matrix);
};
var ModelNode_default = ModelNode;

// node_modules/cesium/Source/Scene/ModelOutlineLoader.js
var MAX_GLTF_UINT16_INDEX = 65534;
function ModelOutlineLoader() {
}
ModelOutlineLoader.hasExtension = function(model) {
  return defined_default(model.extensionsRequired.CESIUM_primitive_outline) || defined_default(model.extensionsUsed.CESIUM_primitive_outline);
};
ModelOutlineLoader.outlinePrimitives = function(model) {
  if (!ModelOutlineLoader.hasExtension(model)) {
    return;
  }
  const gltf = model.gltf;
  const vertexNumberingScopes = [];
  ForEach_default.mesh(gltf, function(mesh2, meshId) {
    ForEach_default.meshPrimitive(mesh2, function(primitive, primitiveId) {
      if (!defined_default(primitive.extensions)) {
        return;
      }
      const outlineData = primitive.extensions.CESIUM_primitive_outline;
      if (!defined_default(outlineData)) {
        return;
      }
      const vertexNumberingScope = getVertexNumberingScope(model, primitive);
      if (vertexNumberingScope === void 0) {
        return;
      }
      if (vertexNumberingScopes.indexOf(vertexNumberingScope) < 0) {
        vertexNumberingScopes.push(vertexNumberingScope);
      }
      addOutline(
        model,
        meshId,
        primitiveId,
        outlineData.indices,
        vertexNumberingScope
      );
    });
  });
  for (let i2 = 0; i2 < vertexNumberingScopes.length; ++i2) {
    updateBufferViewsWithNewVertices(
      model,
      vertexNumberingScopes[i2].bufferViews
    );
  }
  compactBuffers(model);
};
ModelOutlineLoader.createTexture = function(model, context) {
  let cache = context.cache.modelOutliningCache;
  if (!defined_default(cache)) {
    cache = context.cache.modelOutliningCache = {};
  }
  if (defined_default(cache.outlineTexture)) {
    return cache.outlineTexture;
  }
  const maxSize = Math.min(4096, ContextLimits_default.maximumTextureSize);
  let size = maxSize;
  const levelZero = createTexture3(size);
  const mipLevels = [];
  while (size > 1) {
    size >>= 1;
    mipLevels.push(createTexture3(size));
  }
  const texture = new Texture_default({
    context,
    source: {
      arrayBufferView: levelZero,
      mipLevels
    },
    width: maxSize,
    height: 1,
    pixelFormat: PixelFormat_default.LUMINANCE,
    sampler: new Sampler_default({
      wrapS: TextureWrap_default.CLAMP_TO_EDGE,
      wrapT: TextureWrap_default.CLAMP_TO_EDGE,
      minificationFilter: TextureMinificationFilter_default.LINEAR_MIPMAP_LINEAR,
      magnificationFilter: TextureMagnificationFilter_default.LINEAR
    })
  });
  cache.outlineTexture = texture;
  return texture;
};
function addOutline(model, meshId, primitiveId, edgeIndicesAccessorId, vertexNumberingScope) {
  const vertexCopies = vertexNumberingScope.vertexCopies;
  const extraVertices = vertexNumberingScope.extraVertices;
  const outlineCoordinates = vertexNumberingScope.outlineCoordinates;
  const gltf = model.gltf;
  const mesh2 = gltf.meshes[meshId];
  const primitive = mesh2.primitives[primitiveId];
  const accessors = gltf.accessors;
  const bufferViews = gltf.bufferViews;
  let numVertices;
  for (const semantic in primitive.attributes) {
    if (primitive.attributes.hasOwnProperty(semantic)) {
      const attributeId = primitive.attributes[semantic];
      const accessor = accessors[attributeId];
      if (defined_default(accessor)) {
        numVertices = accessor.count;
        break;
      }
    }
  }
  if (!defined_default(numVertices)) {
    return void 0;
  }
  const triangleIndexAccessorGltf = accessors[primitive.indices];
  const triangleIndexBufferViewGltf = bufferViews[triangleIndexAccessorGltf.bufferView];
  const edgeIndexAccessorGltf = accessors[edgeIndicesAccessorId];
  const edgeIndexBufferViewGltf = bufferViews[edgeIndexAccessorGltf.bufferView];
  const loadResources = model._loadResources;
  const triangleIndexBufferView = loadResources.getBuffer(
    triangleIndexBufferViewGltf
  );
  const edgeIndexBufferView = loadResources.getBuffer(edgeIndexBufferViewGltf);
  let triangleIndices = triangleIndexAccessorGltf.componentType === 5123 ? new Uint16Array(
    triangleIndexBufferView.buffer,
    triangleIndexBufferView.byteOffset + triangleIndexAccessorGltf.byteOffset,
    triangleIndexAccessorGltf.count
  ) : new Uint32Array(
    triangleIndexBufferView.buffer,
    triangleIndexBufferView.byteOffset + triangleIndexAccessorGltf.byteOffset,
    triangleIndexAccessorGltf.count
  );
  const edgeIndices = edgeIndexAccessorGltf.componentType === 5123 ? new Uint16Array(
    edgeIndexBufferView.buffer,
    edgeIndexBufferView.byteOffset + edgeIndexAccessorGltf.byteOffset,
    edgeIndexAccessorGltf.count
  ) : new Uint32Array(
    edgeIndexBufferView.buffer,
    edgeIndexBufferView.byteOffset + edgeIndexAccessorGltf.byteOffset,
    edgeIndexAccessorGltf.count
  );
  const edgeSmallMultiplier = numVertices;
  const edges = [edgeSmallMultiplier];
  let i2;
  for (i2 = 0; i2 < edgeIndices.length; i2 += 2) {
    const a4 = edgeIndices[i2];
    const b = edgeIndices[i2 + 1];
    const small = Math.min(a4, b);
    const big = Math.max(a4, b);
    edges[small * edgeSmallMultiplier + big] = 1;
  }
  for (i2 = 0; i2 < triangleIndices.length; i2 += 3) {
    let i0 = triangleIndices[i2];
    let i1 = triangleIndices[i2 + 1];
    let i22 = triangleIndices[i2 + 2];
    const all = false;
    const has01 = all || isHighlighted(edges, i0, i1);
    const has12 = all || isHighlighted(edges, i1, i22);
    const has20 = all || isHighlighted(edges, i22, i0);
    let unmatchableVertexIndex = matchAndStoreCoordinates(
      outlineCoordinates,
      i0,
      i1,
      i22,
      has01,
      has12,
      has20
    );
    while (unmatchableVertexIndex >= 0) {
      let copy;
      if (unmatchableVertexIndex === i0) {
        copy = vertexCopies[i0];
      } else if (unmatchableVertexIndex === i1) {
        copy = vertexCopies[i1];
      } else {
        copy = vertexCopies[i22];
      }
      if (copy === void 0) {
        copy = numVertices + extraVertices.length;
        let original2 = unmatchableVertexIndex;
        while (original2 >= numVertices) {
          original2 = extraVertices[original2 - numVertices];
        }
        extraVertices.push(original2);
        vertexCopies[unmatchableVertexIndex] = copy;
      }
      if (copy > MAX_GLTF_UINT16_INDEX && triangleIndices instanceof Uint16Array) {
        triangleIndices = new Uint32Array(triangleIndices);
        triangleIndexAccessorGltf.componentType = 5125;
        triangleIndexBufferViewGltf.buffer = gltf.buffers.push({
          byteLength: triangleIndices.byteLength,
          extras: {
            _pipeline: {
              source: triangleIndices.buffer
            }
          }
        }) - 1;
        triangleIndexBufferViewGltf.byteLength = triangleIndices.byteLength;
        triangleIndexBufferViewGltf.byteOffset = 0;
        model._loadResources.buffers[triangleIndexBufferViewGltf.buffer] = new Uint8Array(
          triangleIndices.buffer,
          0,
          triangleIndices.byteLength
        );
        loadResources.indexBuffersToCreate._array.forEach(function(toCreate) {
          if (toCreate.id === triangleIndexAccessorGltf.bufferView) {
            toCreate.componentType = triangleIndexAccessorGltf.componentType;
          }
        });
      }
      if (unmatchableVertexIndex === i0) {
        i0 = copy;
        triangleIndices[i2] = copy;
      } else if (unmatchableVertexIndex === i1) {
        i1 = copy;
        triangleIndices[i2 + 1] = copy;
      } else {
        i22 = copy;
        triangleIndices[i2 + 2] = copy;
      }
      if (defined_default(triangleIndexAccessorGltf.max)) {
        triangleIndexAccessorGltf.max[0] = Math.max(
          triangleIndexAccessorGltf.max[0],
          copy
        );
      }
      unmatchableVertexIndex = matchAndStoreCoordinates(
        outlineCoordinates,
        i0,
        i1,
        i22,
        has01,
        has12,
        has20
      );
    }
  }
}
function computeOrderMask(outlineCoordinates, vertexIndex, a4, b, c14) {
  const startIndex = vertexIndex * 3;
  const first = outlineCoordinates[startIndex];
  const second = outlineCoordinates[startIndex + 1];
  const third = outlineCoordinates[startIndex + 2];
  if (first === void 0) {
    return 63;
  }
  return ((first === a4 && second === b && third === c14) << 0) + ((first === a4 && second === c14 && third === b) << 1) + ((first === b && second === a4 && third === c14) << 2) + ((first === b && second === c14 && third === a4) << 3) + ((first === c14 && second === a4 && third === b) << 4) + ((first === c14 && second === b && third === a4) << 5);
}
function popcount0to63(value) {
  return (value & 1) + (value >> 1 & 1) + (value >> 2 & 1) + (value >> 3 & 1) + (value >> 4 & 1) + (value >> 5 & 1);
}
function matchAndStoreCoordinates(outlineCoordinates, i0, i1, i2, has01, has12, has20) {
  const a0 = has20 ? 1 : 0;
  const b0 = has01 ? 1 : 0;
  const c0 = 0;
  const i0Mask = computeOrderMask(outlineCoordinates, i0, a0, b0, c0);
  if (i0Mask === 0) {
    return i0;
  }
  const a1 = 0;
  const b1 = has01 ? 1 : 0;
  const c14 = has12 ? 1 : 0;
  const i1Mask = computeOrderMask(outlineCoordinates, i1, a1, b1, c14);
  if (i1Mask === 0) {
    return i1;
  }
  const a22 = has20 ? 1 : 0;
  const b2 = 0;
  const c22 = has12 ? 1 : 0;
  const i2Mask = computeOrderMask(outlineCoordinates, i2, a22, b2, c22);
  if (i2Mask === 0) {
    return i2;
  }
  const workingOrders = i0Mask & i1Mask & i2Mask;
  let a4, b, c15;
  if (workingOrders & 1 << 0) {
    a4 = 0;
    b = 1;
    c15 = 2;
  } else if (workingOrders & 1 << 1) {
    a4 = 0;
    c15 = 1;
    b = 2;
  } else if (workingOrders & 1 << 2) {
    b = 0;
    a4 = 1;
    c15 = 2;
  } else if (workingOrders & 1 << 3) {
    b = 0;
    c15 = 1;
    a4 = 2;
  } else if (workingOrders & 1 << 4) {
    c15 = 0;
    a4 = 1;
    b = 2;
  } else if (workingOrders & 1 << 5) {
    c15 = 0;
    b = 1;
    a4 = 2;
  } else {
    const i0Popcount = popcount0to63(i0Mask);
    const i1Popcount = popcount0to63(i1Mask);
    const i2Popcount = popcount0to63(i2Mask);
    if (i0Popcount < i1Popcount && i0Popcount < i2Popcount) {
      return i0;
    } else if (i1Popcount < i2Popcount) {
      return i1;
    }
    return i2;
  }
  const i0Start = i0 * 3;
  outlineCoordinates[i0Start + a4] = a0;
  outlineCoordinates[i0Start + b] = b0;
  outlineCoordinates[i0Start + c15] = c0;
  const i1Start = i1 * 3;
  outlineCoordinates[i1Start + a4] = a1;
  outlineCoordinates[i1Start + b] = b1;
  outlineCoordinates[i1Start + c15] = c14;
  const i2Start = i2 * 3;
  outlineCoordinates[i2Start + a4] = a22;
  outlineCoordinates[i2Start + b] = b2;
  outlineCoordinates[i2Start + c15] = c22;
  return -1;
}
function isHighlighted(edges, i0, i1) {
  const edgeSmallMultiplier = edges[0];
  const index2 = Math.min(i0, i1) * edgeSmallMultiplier + Math.max(i0, i1);
  return edges[index2] === 1;
}
function createTexture3(size) {
  const texture = new Uint8Array(size);
  texture[size - 1] = 192;
  if (size === 8) {
    texture[size - 1] = 96;
  } else if (size === 4) {
    texture[size - 1] = 48;
  } else if (size === 2) {
    texture[size - 1] = 24;
  } else if (size === 1) {
    texture[size - 1] = 12;
  }
  return texture;
}
function updateBufferViewsWithNewVertices(model, bufferViews) {
  const gltf = model.gltf;
  const loadResources = model._loadResources;
  let i2, j;
  for (i2 = 0; i2 < bufferViews.length; ++i2) {
    const bufferView = bufferViews[i2];
    const vertexNumberingScope = bufferView.extras._pipeline.vertexNumberingScope;
    bufferView.extras._pipeline.vertexNumberingScope = void 0;
    const newVertices = vertexNumberingScope.extraVertices;
    const sourceData = loadResources.getBuffer(bufferView);
    const byteStride = bufferView.byteStride || 4;
    const newVerticesLength = newVertices.length;
    const destData = new Uint8Array(
      sourceData.byteLength + newVerticesLength * byteStride
    );
    destData.set(sourceData);
    for (j = 0; j < newVerticesLength; ++j) {
      const sourceIndex = newVertices[j] * byteStride;
      const destIndex = sourceData.length + j * byteStride;
      for (let k = 0; k < byteStride; ++k) {
        destData[destIndex + k] = destData[sourceIndex + k];
      }
    }
    bufferView.byteOffset = 0;
    bufferView.byteLength = destData.byteLength;
    const bufferId = gltf.buffers.push({
      byteLength: destData.byteLength,
      extras: {
        _pipeline: {
          source: destData.buffer
        }
      }
    }) - 1;
    bufferView.buffer = bufferId;
    loadResources.buffers[bufferId] = destData;
    const accessors = vertexNumberingScope.accessors;
    for (j = 0; j < accessors.length; ++j) {
      const accessorId = accessors[j];
      gltf.accessors[accessorId].count += newVerticesLength;
    }
    if (!vertexNumberingScope.createdOutlines) {
      const outlineCoordinates = vertexNumberingScope.outlineCoordinates;
      const outlineCoordinateBuffer = new Float32Array(outlineCoordinates);
      const bufferIndex = model.gltf.buffers.push({
        byteLength: outlineCoordinateBuffer.byteLength,
        extras: {
          _pipeline: {
            source: outlineCoordinateBuffer.buffer
          }
        }
      }) - 1;
      loadResources.buffers[bufferIndex] = new Uint8Array(
        outlineCoordinateBuffer.buffer,
        0,
        outlineCoordinateBuffer.byteLength
      );
      const bufferViewIndex = model.gltf.bufferViews.push({
        buffer: bufferIndex,
        byteLength: outlineCoordinateBuffer.byteLength,
        byteOffset: 0,
        byteStride: 3 * Float32Array.BYTES_PER_ELEMENT,
        target: 34962
      }) - 1;
      const accessorIndex = model.gltf.accessors.push({
        bufferView: bufferViewIndex,
        byteOffset: 0,
        componentType: 5126,
        count: outlineCoordinateBuffer.length / 3,
        type: "VEC3",
        min: [0, 0, 0],
        max: [1, 1, 1]
      }) - 1;
      const primitives = vertexNumberingScope.primitives;
      for (j = 0; j < primitives.length; ++j) {
        primitives[j].attributes._OUTLINE_COORDINATES = accessorIndex;
      }
      loadResources.vertexBuffersToCreate.enqueue(bufferViewIndex);
      vertexNumberingScope.createdOutlines = true;
    }
  }
}
function compactBuffers(model) {
  const gltf = model.gltf;
  const loadResources = model._loadResources;
  let i2;
  for (i2 = 0; i2 < gltf.buffers.length; ++i2) {
    const buffer = gltf.buffers[i2];
    const bufferViewsUsingThisBuffer = gltf.bufferViews.filter(
      usesBuffer.bind(void 0, i2)
    );
    const newLength = bufferViewsUsingThisBuffer.reduce(
      function(previous, current) {
        return previous + current.byteLength;
      },
      0
    );
    if (newLength === buffer.byteLength) {
      continue;
    }
    const newBuffer = new Uint8Array(newLength);
    let offset2 = 0;
    for (let j = 0; j < bufferViewsUsingThisBuffer.length; ++j) {
      const bufferView = bufferViewsUsingThisBuffer[j];
      const sourceData = loadResources.getBuffer(bufferView);
      newBuffer.set(sourceData, offset2);
      bufferView.byteOffset = offset2;
      offset2 += sourceData.byteLength;
    }
    loadResources.buffers[i2] = newBuffer;
    buffer.extras._pipeline.source = newBuffer.buffer;
    buffer.byteLength = newLength;
  }
}
function usesBuffer(bufferId, bufferView) {
  return bufferView.buffer === bufferId;
}
function getVertexNumberingScope(model, primitive) {
  const attributes = primitive.attributes;
  if (attributes === void 0) {
    return void 0;
  }
  const gltf = model.gltf;
  let vertexNumberingScope;
  for (const semantic in attributes) {
    if (!attributes.hasOwnProperty(semantic)) {
      continue;
    }
    const accessorId = attributes[semantic];
    const accessor = gltf.accessors[accessorId];
    const bufferViewId = accessor.bufferView;
    const bufferView = gltf.bufferViews[bufferViewId];
    if (!defined_default(bufferView.extras)) {
      bufferView.extras = {};
    }
    if (!defined_default(bufferView.extras._pipeline)) {
      bufferView.extras._pipeline = {};
    }
    if (!defined_default(bufferView.extras._pipeline.vertexNumberingScope)) {
      bufferView.extras._pipeline.vertexNumberingScope = vertexNumberingScope || {
        vertexCopies: [],
        extraVertices: [],
        outlineCoordinates: [],
        accessors: [],
        bufferViews: [],
        primitives: [],
        createdOutlines: false
      };
    } else if (vertexNumberingScope !== void 0 && bufferView.extras._pipeline.vertexNumberingScope !== vertexNumberingScope) {
      return void 0;
    }
    vertexNumberingScope = bufferView.extras._pipeline.vertexNumberingScope;
    if (vertexNumberingScope.bufferViews.indexOf(bufferView) < 0) {
      vertexNumberingScope.bufferViews.push(bufferView);
    }
    if (vertexNumberingScope.accessors.indexOf(accessorId) < 0) {
      vertexNumberingScope.accessors.push(accessorId);
    }
  }
  vertexNumberingScope.primitives.push(primitive);
  return vertexNumberingScope;
}
var ModelOutlineLoader_default = ModelOutlineLoader;

// node_modules/cesium/Source/Scene/SplitDirection.js
var SplitDirection = {
  LEFT: -1,
  NONE: 0,
  RIGHT: 1
};
var SplitDirection_default = Object.freeze(SplitDirection);

// node_modules/cesium/Source/Scene/Splitter.js
var Splitter = {
  modifyFragmentShader: function modifyFragmentShader(shader) {
    shader = ShaderSource_default.replaceMain(shader, "czm_splitter_main");
    shader += "uniform float czm_splitDirection; \nvoid main() \n{ \n#ifndef SHADOW_MAP\n    if (czm_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard; \n    if (czm_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard; \n#endif\n    czm_splitter_main(); \n} \n";
    return shader;
  },
  addUniforms: function addUniforms(object2, uniformMap2) {
    uniformMap2.czm_splitDirection = function() {
      return object2.splitDirection;
    };
  }
};
var Splitter_default = Splitter;

// node_modules/cesium/Source/Scene/Model.js
var boundingSphereCartesian3Scratch2 = new Cartesian3_default();
var ModelState2 = ModelUtility_default.ModelState;
var defaultModelAccept = "model/gltf-binary,model/gltf+json;q=0.8,application/json;q=0.2,*/*;q=0.01";
var articulationEpsilon = Math_default.EPSILON16;
function setCachedGltf(model, cachedGltf) {
  model._cachedGltf = cachedGltf;
}
function CachedGltf(options) {
  this._gltf = options.gltf;
  this.ready = options.ready;
  this.modelsToLoad = [];
  this.count = 0;
}
Object.defineProperties(CachedGltf.prototype, {
  gltf: {
    set: function(value) {
      this._gltf = value;
    },
    get: function() {
      return this._gltf;
    }
  }
});
CachedGltf.prototype.makeReady = function(gltfJson) {
  this.gltf = gltfJson;
  const models = this.modelsToLoad;
  const length3 = models.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const m = models[i2];
    if (!m.isDestroyed()) {
      setCachedGltf(m, this);
    }
  }
  this.modelsToLoad = void 0;
  this.ready = true;
};
var gltfCache = {};
var uriToGuid = {};
function Model(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const cacheKey = options.cacheKey;
  this._cacheKey = cacheKey;
  this._cachedGltf = void 0;
  this._releaseGltfJson = defaultValue_default(options.releaseGltfJson, false);
  let cachedGltf;
  if (defined_default(cacheKey) && defined_default(gltfCache[cacheKey]) && gltfCache[cacheKey].ready) {
    cachedGltf = gltfCache[cacheKey];
    ++cachedGltf.count;
  } else {
    let gltf = options.gltf;
    if (defined_default(gltf)) {
      if (gltf instanceof ArrayBuffer) {
        gltf = new Uint8Array(gltf);
      }
      if (gltf instanceof Uint8Array) {
        const parsedGltf = parseGlb_default(gltf);
        cachedGltf = new CachedGltf({
          gltf: parsedGltf,
          ready: true
        });
      } else {
        cachedGltf = new CachedGltf({
          gltf: options.gltf,
          ready: true
        });
      }
      cachedGltf.count = 1;
      if (defined_default(cacheKey)) {
        gltfCache[cacheKey] = cachedGltf;
      }
    }
  }
  setCachedGltf(this, cachedGltf);
  const basePath = defaultValue_default(options.basePath, "");
  this._resource = Resource_default.createIfNeeded(basePath);
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  this._credit = credit;
  this._resourceCredits = [];
  this._gltfCredits = [];
  this._showCreditsOnScreen = defaultValue_default(options.showCreditsOnScreen, false);
  this.show = defaultValue_default(options.show, true);
  this.silhouetteColor = defaultValue_default(options.silhouetteColor, Color_default.RED);
  this._silhouetteColor = new Color_default();
  this._silhouetteColorPreviousAlpha = 1;
  this._normalAttributeName = void 0;
  this.silhouetteSize = defaultValue_default(options.silhouetteSize, 0);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._modelMatrix = Matrix4_default.clone(this.modelMatrix);
  this._clampedModelMatrix = void 0;
  this.scale = defaultValue_default(options.scale, 1);
  this._scale = this.scale;
  this.minimumPixelSize = defaultValue_default(options.minimumPixelSize, 0);
  this._minimumPixelSize = this.minimumPixelSize;
  this.maximumScale = options.maximumScale;
  this._maximumScale = this.maximumScale;
  this.id = options.id;
  this._id = options.id;
  this.heightReference = defaultValue_default(
    options.heightReference,
    HeightReference_default.NONE
  );
  this._heightReference = this.heightReference;
  this._heightChanged = false;
  this._removeUpdateHeightCallback = void 0;
  const scene = options.scene;
  this._scene = scene;
  if (defined_default(scene) && defined_default(scene.terrainProviderChanged)) {
    this._terrainProviderChangedCallback = scene.terrainProviderChanged.addEventListener(
      function() {
        this._heightChanged = true;
      },
      this
    );
  }
  this._pickObject = options.pickObject;
  this._allowPicking = defaultValue_default(options.allowPicking, true);
  this._ready = false;
  this._readyPromise = defer_default();
  this.activeAnimations = new ModelAnimationCollection_default(this);
  this.clampAnimations = defaultValue_default(options.clampAnimations, true);
  this._defaultTexture = void 0;
  this._incrementallyLoadTextures = defaultValue_default(
    options.incrementallyLoadTextures,
    true
  );
  this._asynchronous = defaultValue_default(options.asynchronous, true);
  this.shadows = defaultValue_default(options.shadows, ShadowMode_default.ENABLED);
  this._shadows = this.shadows;
  this.color = Color_default.clone(defaultValue_default(options.color, Color_default.WHITE));
  this._colorPreviousAlpha = 1;
  this.colorBlendMode = defaultValue_default(
    options.colorBlendMode,
    ColorBlendMode_default.HIGHLIGHT
  );
  this.colorBlendAmount = defaultValue_default(options.colorBlendAmount, 0.5);
  this._colorShadingEnabled = false;
  this._clippingPlanes = void 0;
  this.clippingPlanes = options.clippingPlanes;
  this._clippingPlanesState = 0;
  this.referenceMatrix = void 0;
  this.backFaceCulling = defaultValue_default(options.backFaceCulling, true);
  this.showOutline = defaultValue_default(options.showOutline, true);
  this.splitDirection = defaultValue_default(
    options.splitDirection,
    SplitDirection_default.NONE
  );
  this._splittingEnabled = false;
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this._debugShowBoundingVolume = false;
  this.debugWireframe = defaultValue_default(options.debugWireframe, false);
  this._debugWireframe = false;
  this._distanceDisplayCondition = options.distanceDisplayCondition;
  this._addBatchIdToGeneratedShaders = options.addBatchIdToGeneratedShaders;
  this._precreatedAttributes = options.precreatedAttributes;
  this._vertexShaderLoaded = options.vertexShaderLoaded;
  this._fragmentShaderLoaded = options.fragmentShaderLoaded;
  this._uniformMapLoaded = options.uniformMapLoaded;
  this._pickIdLoaded = options.pickIdLoaded;
  this._ignoreCommands = defaultValue_default(options.ignoreCommands, false);
  this._requestType = options.requestType;
  this._upAxis = defaultValue_default(options.upAxis, Axis_default.Y);
  this._gltfForwardAxis = Axis_default.Z;
  this._forwardAxis = options.forwardAxis;
  this.cull = defaultValue_default(options.cull, true);
  this.opaquePass = defaultValue_default(options.opaquePass, Pass_default.OPAQUE);
  this._computedModelMatrix = new Matrix4_default();
  this._clippingPlanesMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._iblReferenceFrameMatrix = Matrix3_default.clone(Matrix3_default.IDENTITY);
  this._initialRadius = void 0;
  this._boundingSphere = void 0;
  this._scaledBoundingSphere = new BoundingSphere_default();
  this._state = ModelState2.NEEDS_LOAD;
  this._loadResources = void 0;
  this._mode = void 0;
  this._perNodeShowDirty = false;
  this._cesiumAnimationsDirty = false;
  this._dirty = false;
  this._maxDirtyNumber = 0;
  this._runtime = {
    animations: void 0,
    articulationsByName: void 0,
    articulationsByStageKey: void 0,
    stagesByKey: void 0,
    rootNodes: void 0,
    nodes: void 0,
    nodesByName: void 0,
    skinnedNodes: void 0,
    meshesByName: void 0,
    materialsByName: void 0,
    materialsById: void 0
  };
  this._uniformMaps = {};
  this._extensionsUsed = void 0;
  this._extensionsRequired = void 0;
  this._quantizedUniforms = {};
  this._programPrimitives = {};
  this._rendererResources = {
    buffers: {},
    vertexArrays: {},
    programs: {},
    sourceShaders: {},
    silhouettePrograms: {},
    textures: {},
    samplers: {},
    renderStates: {}
  };
  this._cachedRendererResources = void 0;
  this._loadRendererResourcesFromCache = false;
  this._dequantizeInShader = defaultValue_default(options.dequantizeInShader, true);
  this._decodedData = {};
  this._cachedGeometryByteLength = 0;
  this._cachedTexturesByteLength = 0;
  this._geometryByteLength = 0;
  this._texturesByteLength = 0;
  this._trianglesLength = 0;
  this._pointsLength = 0;
  this._sourceTechniques = {};
  this._sourcePrograms = {};
  this._quantizedVertexShaders = {};
  this._nodeCommands = [];
  this._pickIds = [];
  this._rtcCenter = void 0;
  this._rtcCenterEye = void 0;
  this._rtcCenter3D = void 0;
  this._rtcCenter2D = void 0;
  this._sourceVersion = void 0;
  this._sourceKHRTechniquesWebGL = void 0;
  this._lightColor = Cartesian3_default.clone(options.lightColor);
  const hasIndividualIBLParameters = defined_default(options.imageBasedLightingFactor) || defined_default(options.luminanceAtZenith) || defined_default(options.sphericalHarmonicCoefficients) || defined_default(options.specularEnvironmentMaps);
  if (defined_default(options.imageBasedLighting)) {
    this._imageBasedLighting = options.imageBasedLighting;
    this._shouldDestroyImageBasedLighting = false;
  } else if (hasIndividualIBLParameters) {
    deprecationWarning_default(
      "ImageBasedLightingConstructor",
      "Individual image-based lighting parameters were deprecated in Cesium 1.92. They will be removed in version 1.94. Use options.imageBasedLighting instead."
    );
    this._imageBasedLighting = new ImageBasedLighting({
      imageBasedLightingFactor: options.imageBasedLightingFactor,
      luminanceAtZenith: options.luminanceAtZenith,
      sphericalHarmonicCoefficients: options.sphericalHarmonicCoefficients,
      specularEnvironmentMaps: options.specularEnvironmentMaps
    });
    this._shouldDestroyImageBasedLighting = true;
  } else {
    this._imageBasedLighting = new ImageBasedLighting();
    this._shouldDestroyImageBasedLighting = true;
  }
  this._shouldRegenerateShaders = false;
}
Object.defineProperties(Model.prototype, {
  gltf: {
    get: function() {
      return defined_default(this._cachedGltf) ? this._cachedGltf.gltf : void 0;
    }
  },
  releaseGltfJson: {
    get: function() {
      return this._releaseGltfJson;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  basePath: {
    get: function() {
      return this._resource.url;
    }
  },
  boundingSphere: {
    get: function() {
      if (this._state !== ModelState2.LOADED) {
        throw new DeveloperError_default(
          "The model is not loaded.  Use Model.readyPromise or wait for Model.ready to be true."
        );
      }
      let modelMatrix = this.modelMatrix;
      if (this.heightReference !== HeightReference_default.NONE && this._clampedModelMatrix) {
        modelMatrix = this._clampedModelMatrix;
      }
      const nonUniformScale = Matrix4_default.getScale(
        modelMatrix,
        boundingSphereCartesian3Scratch2
      );
      const scale = defined_default(this.maximumScale) ? Math.min(this.maximumScale, this.scale) : this.scale;
      Cartesian3_default.multiplyByScalar(nonUniformScale, scale, nonUniformScale);
      const scaledBoundingSphere = this._scaledBoundingSphere;
      scaledBoundingSphere.center = Cartesian3_default.multiplyComponents(
        this._boundingSphere.center,
        nonUniformScale,
        scaledBoundingSphere.center
      );
      scaledBoundingSphere.radius = Cartesian3_default.maximumComponent(nonUniformScale) * this._initialRadius;
      if (defined_default(this._rtcCenter)) {
        Cartesian3_default.add(
          this._rtcCenter,
          scaledBoundingSphere.center,
          scaledBoundingSphere.center
        );
      }
      return scaledBoundingSphere;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  asynchronous: {
    get: function() {
      return this._asynchronous;
    }
  },
  allowPicking: {
    get: function() {
      return this._allowPicking;
    }
  },
  incrementallyLoadTextures: {
    get: function() {
      return this._incrementallyLoadTextures;
    }
  },
  pendingTextureLoads: {
    get: function() {
      return defined_default(this._loadResources) ? this._loadResources.pendingTextureLoads : 0;
    }
  },
  dirty: {
    get: function() {
      return this._dirty;
    }
  },
  distanceDisplayCondition: {
    get: function() {
      return this._distanceDisplayCondition;
    },
    set: function(value) {
      if (defined_default(value) && value.far <= value.near) {
        throw new DeveloperError_default("far must be greater than near");
      }
      this._distanceDisplayCondition = DistanceDisplayCondition_default.clone(
        value,
        this._distanceDisplayCondition
      );
    }
  },
  extensionsUsed: {
    get: function() {
      if (!defined_default(this._extensionsUsed)) {
        this._extensionsUsed = ModelUtility_default.getUsedExtensions(this.gltf);
      }
      return this._extensionsUsed;
    }
  },
  extensionsRequired: {
    get: function() {
      if (!defined_default(this._extensionsRequired)) {
        this._extensionsRequired = ModelUtility_default.getRequiredExtensions(
          this.gltf
        );
      }
      return this._extensionsRequired;
    }
  },
  upAxis: {
    get: function() {
      return this._upAxis;
    }
  },
  forwardAxis: {
    get: function() {
      if (defined_default(this._forwardAxis)) {
        return this._forwardAxis;
      }
      return this._gltfForwardAxis;
    }
  },
  trianglesLength: {
    get: function() {
      return this._trianglesLength;
    }
  },
  pointsLength: {
    get: function() {
      return this._pointsLength;
    }
  },
  geometryByteLength: {
    get: function() {
      return this._geometryByteLength;
    }
  },
  texturesByteLength: {
    get: function() {
      return this._texturesByteLength;
    }
  },
  cachedGeometryByteLength: {
    get: function() {
      return this._cachedGeometryByteLength;
    }
  },
  cachedTexturesByteLength: {
    get: function() {
      return this._cachedTexturesByteLength;
    }
  },
  clippingPlanes: {
    get: function() {
      return this._clippingPlanes;
    },
    set: function(value) {
      if (value === this._clippingPlanes) {
        return;
      }
      ClippingPlaneCollection_default.setOwner(value, this, "_clippingPlanes");
    }
  },
  pickIds: {
    get: function() {
      return this._pickIds;
    }
  },
  lightColor: {
    get: function() {
      return this._lightColor;
    },
    set: function(value) {
      const lightColor = this._lightColor;
      if (value === lightColor || Cartesian3_default.equals(value, lightColor)) {
        return;
      }
      this._shouldRegenerateShaders = this._shouldRegenerateShaders || defined_default(lightColor) && !defined_default(value) || defined_default(value) && !defined_default(lightColor);
      this._lightColor = Cartesian3_default.clone(value, lightColor);
    }
  },
  imageBasedLighting: {
    get: function() {
      return this._imageBasedLighting;
    },
    set: function(value) {
      Check_default.typeOf.object("imageBasedLighting", this._imageBasedLighting);
      if (value !== this._imageBasedLighting) {
        if (this._shouldDestroyImageBasedLighting && !this._imageBasedLighting.isDestroyed()) {
          this._imageBasedLighting.destroy();
        }
        this._imageBasedLighting = value;
        this._shouldDestroyImageBasedLighting = false;
        this._shouldRegenerateShaders = true;
      }
    }
  },
  imageBasedLightingFactor: {
    get: function() {
      return this._imageBasedLighting.imageBasedLightingFactor;
    },
    set: function(value) {
      this._imageBasedLighting.imageBasedLightingFactor = value;
    }
  },
  luminanceAtZenith: {
    get: function() {
      return this._imageBasedLighting.luminanceAtZenith;
    },
    set: function(value) {
      this._imageBasedLighting.luminanceAtZenith = value;
    }
  },
  sphericalHarmonicCoefficients: {
    get: function() {
      return this._imageBasedLighting.sphericalHarmonicCoefficients;
    },
    set: function(value) {
      this._imageBasedLighting.sphericalHarmonicCoefficients = value;
    }
  },
  specularEnvironmentMaps: {
    get: function() {
      return this._imageBasedLighting.specularEnvironmentMaps;
    },
    set: function(value) {
      this._imageBasedLighting.specularEnvironmentMaps = value;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  showCreditsOnScreen: {
    get: function() {
      return this._showCreditsOnScreen;
    },
    set: function(value) {
      if (this._showCreditsOnScreen !== value) {
        if (defined_default(this._credit)) {
          this._credit.showOnScreen = value;
        }
        const resourceCreditsLength = this._resourceCredits.length;
        for (let i2 = 0; i2 < resourceCreditsLength; i2++) {
          this._resourceCredits[i2].showOnScreen = value;
        }
        const gltfCreditsLength = this._gltfCredits.length;
        for (let i2 = 0; i2 < gltfCreditsLength; i2++) {
          this._gltfCredits[i2].showOnScreen = value;
        }
      }
      this._showCreditsOnScreen = value;
    }
  }
});
function silhouetteSupported(context) {
  return context.stencilBuffer;
}
function isColorShadingEnabled(model) {
  return !Color_default.equals(model.color, Color_default.WHITE) || model.colorBlendMode !== ColorBlendMode_default.HIGHLIGHT;
}
function isClippingEnabled(model) {
  const clippingPlanes = model._clippingPlanes;
  return defined_default(clippingPlanes) && clippingPlanes.enabled && clippingPlanes.length !== 0;
}
Model.silhouetteSupported = function(scene) {
  return silhouetteSupported(scene.context);
};
function containsGltfMagic(uint8Array) {
  const magic = getMagic_default(uint8Array);
  return magic === "glTF";
}
Model.fromGltf = function(options) {
  if (!defined_default(options) || !defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required");
  }
  const url2 = options.url;
  options = clone_default(options);
  const modelResource = Resource_default.createIfNeeded(url2);
  const basePath = defaultValue_default(options.basePath, modelResource.clone());
  const resource = Resource_default.createIfNeeded(basePath);
  let cacheKey = defaultValue_default(
    options.cacheKey,
    uriToGuid[getAbsoluteUri_default(modelResource.url)]
  );
  if (!defined_default(cacheKey)) {
    cacheKey = createGuid_default();
    uriToGuid[getAbsoluteUri_default(modelResource.url)] = cacheKey;
  }
  if (defined_default(options.basePath) && !defined_default(options.cacheKey)) {
    cacheKey += resource.url;
  }
  options.cacheKey = cacheKey;
  options.basePath = resource;
  const model = new Model(options);
  let cachedGltf = gltfCache[cacheKey];
  if (!defined_default(cachedGltf)) {
    cachedGltf = new CachedGltf({
      ready: false
    });
    cachedGltf.count = 1;
    cachedGltf.modelsToLoad.push(model);
    setCachedGltf(model, cachedGltf);
    gltfCache[cacheKey] = cachedGltf;
    if (!defined_default(modelResource.headers.Accept)) {
      modelResource.headers.Accept = defaultModelAccept;
    }
    modelResource.fetchArrayBuffer().then(function(arrayBuffer) {
      const array = new Uint8Array(arrayBuffer);
      if (containsGltfMagic(array)) {
        const parsedGltf = parseGlb_default(array);
        cachedGltf.makeReady(parsedGltf);
      } else {
        const json = getJsonFromTypedArray_default(array);
        cachedGltf.makeReady(json);
      }
      const resourceCredits = model._resourceCredits;
      const credits = modelResource.credits;
      if (defined_default(credits)) {
        const length3 = credits.length;
        for (let i2 = 0; i2 < length3; i2++) {
          resourceCredits.push(credits[i2]);
        }
      }
    }).catch(
      ModelUtility_default.getFailedLoadFunction(model, "model", modelResource.url)
    );
  } else if (!cachedGltf.ready) {
    ++cachedGltf.count;
    cachedGltf.modelsToLoad.push(model);
  }
  return model;
};
Model._gltfCache = gltfCache;
function getRuntime(model, runtimeName, name) {
  if (model._state !== ModelState2.LOADED) {
    throw new DeveloperError_default(
      "The model is not loaded.  Use Model.readyPromise or wait for Model.ready to be true."
    );
  }
  if (!defined_default(name)) {
    throw new DeveloperError_default("name is required.");
  }
  return model._runtime[runtimeName][name];
}
Model.prototype.getNode = function(name) {
  const node = getRuntime(this, "nodesByName", name);
  return defined_default(node) ? node.publicNode : void 0;
};
Model.prototype.getMesh = function(name) {
  return getRuntime(this, "meshesByName", name);
};
Model.prototype.getMaterial = function(name) {
  return getRuntime(this, "materialsByName", name);
};
Model.prototype.setArticulationStage = function(articulationStageKey, value) {
  Check_default.typeOf.number("value", value);
  const stage = getRuntime(this, "stagesByKey", articulationStageKey);
  const articulation = getRuntime(
    this,
    "articulationsByStageKey",
    articulationStageKey
  );
  if (defined_default(stage) && defined_default(articulation)) {
    value = Math_default.clamp(value, stage.minimumValue, stage.maximumValue);
    if (!Math_default.equalsEpsilon(stage.currentValue, value, articulationEpsilon)) {
      stage.currentValue = value;
      articulation.isDirty = true;
    }
  }
};
var scratchArticulationCartesian = new Cartesian3_default();
var scratchArticulationRotation = new Matrix3_default();
function applyArticulationStageMatrix(stage, result) {
  Check_default.typeOf.object("stage", stage);
  Check_default.typeOf.object("result", result);
  const value = stage.currentValue;
  const cartesian11 = scratchArticulationCartesian;
  let rotation;
  switch (stage.type) {
    case "xRotate":
      rotation = Matrix3_default.fromRotationX(
        Math_default.toRadians(value),
        scratchArticulationRotation
      );
      Matrix4_default.multiplyByMatrix3(result, rotation, result);
      break;
    case "yRotate":
      rotation = Matrix3_default.fromRotationY(
        Math_default.toRadians(value),
        scratchArticulationRotation
      );
      Matrix4_default.multiplyByMatrix3(result, rotation, result);
      break;
    case "zRotate":
      rotation = Matrix3_default.fromRotationZ(
        Math_default.toRadians(value),
        scratchArticulationRotation
      );
      Matrix4_default.multiplyByMatrix3(result, rotation, result);
      break;
    case "xTranslate":
      cartesian11.x = value;
      cartesian11.y = 0;
      cartesian11.z = 0;
      Matrix4_default.multiplyByTranslation(result, cartesian11, result);
      break;
    case "yTranslate":
      cartesian11.x = 0;
      cartesian11.y = value;
      cartesian11.z = 0;
      Matrix4_default.multiplyByTranslation(result, cartesian11, result);
      break;
    case "zTranslate":
      cartesian11.x = 0;
      cartesian11.y = 0;
      cartesian11.z = value;
      Matrix4_default.multiplyByTranslation(result, cartesian11, result);
      break;
    case "xScale":
      cartesian11.x = value;
      cartesian11.y = 1;
      cartesian11.z = 1;
      Matrix4_default.multiplyByScale(result, cartesian11, result);
      break;
    case "yScale":
      cartesian11.x = 1;
      cartesian11.y = value;
      cartesian11.z = 1;
      Matrix4_default.multiplyByScale(result, cartesian11, result);
      break;
    case "zScale":
      cartesian11.x = 1;
      cartesian11.y = 1;
      cartesian11.z = value;
      Matrix4_default.multiplyByScale(result, cartesian11, result);
      break;
    case "uniformScale":
      Matrix4_default.multiplyByUniformScale(result, value, result);
      break;
    default:
      break;
  }
  return result;
}
var scratchApplyArticulationTransform = new Matrix4_default();
Model.prototype.applyArticulations = function() {
  const articulationsByName = this._runtime.articulationsByName;
  for (const articulationName in articulationsByName) {
    if (articulationsByName.hasOwnProperty(articulationName)) {
      const articulation = articulationsByName[articulationName];
      if (articulation.isDirty) {
        articulation.isDirty = false;
        const numNodes = articulation.nodes.length;
        for (let n2 = 0; n2 < numNodes; ++n2) {
          const node = articulation.nodes[n2];
          let transform4 = Matrix4_default.clone(
            node.originalMatrix,
            scratchApplyArticulationTransform
          );
          const numStages = articulation.stages.length;
          for (let s2 = 0; s2 < numStages; ++s2) {
            const stage = articulation.stages[s2];
            transform4 = applyArticulationStageMatrix(stage, transform4);
          }
          node.matrix = transform4;
        }
      }
    }
  }
};
function addBuffersToLoadResources2(model) {
  const gltf = model.gltf;
  const loadResources = model._loadResources;
  ForEach_default.buffer(gltf, function(buffer, id) {
    loadResources.buffers[id] = buffer.extras._pipeline.source;
  });
}
function bufferLoad(model, id) {
  return function(arrayBuffer) {
    const loadResources = model._loadResources;
    const buffer = new Uint8Array(arrayBuffer);
    --loadResources.pendingBufferLoads;
    model.gltf.buffers[id].extras._pipeline.source = buffer;
  };
}
function parseBufferViews2(model) {
  const bufferViews = model.gltf.bufferViews;
  const vertexBuffersToCreate = model._loadResources.vertexBuffersToCreate;
  ForEach_default.bufferView(model.gltf, function(bufferView, id) {
    if (bufferView.target === WebGLConstants_default.ARRAY_BUFFER) {
      vertexBuffersToCreate.enqueue(id);
    }
  });
  const indexBuffersToCreate = model._loadResources.indexBuffersToCreate;
  const indexBufferIds = {};
  ForEach_default.accessor(model.gltf, function(accessor) {
    const bufferViewId = accessor.bufferView;
    if (!defined_default(bufferViewId)) {
      return;
    }
    const bufferView = bufferViews[bufferViewId];
    if (bufferView.target === WebGLConstants_default.ELEMENT_ARRAY_BUFFER && !defined_default(indexBufferIds[bufferViewId])) {
      indexBufferIds[bufferViewId] = true;
      indexBuffersToCreate.enqueue({
        id: bufferViewId,
        componentType: accessor.componentType
      });
    }
  });
}
function parseTechniques(model) {
  const gltf = model.gltf;
  if (!usesExtension_default(gltf, "KHR_techniques_webgl")) {
    return;
  }
  const sourcePrograms = model._sourcePrograms;
  const sourceTechniques = model._sourceTechniques;
  const programs = gltf.extensions.KHR_techniques_webgl.programs;
  ForEach_default.technique(gltf, function(technique, techniqueId) {
    sourceTechniques[techniqueId] = clone_default(technique);
    const programId = technique.program;
    if (!defined_default(sourcePrograms[programId])) {
      sourcePrograms[programId] = clone_default(programs[programId]);
    }
  });
}
function shaderLoad(model, type, id) {
  return function(source) {
    const loadResources = model._loadResources;
    loadResources.shaders[id] = {
      source,
      type,
      bufferView: void 0
    };
    --loadResources.pendingShaderLoads;
    model._rendererResources.sourceShaders[id] = source;
  };
}
function parseShaders(model) {
  const gltf = model.gltf;
  const buffers = gltf.buffers;
  const bufferViews = gltf.bufferViews;
  const sourceShaders = model._rendererResources.sourceShaders;
  ForEach_default.shader(gltf, function(shader, id) {
    if (defined_default(shader.bufferView)) {
      const bufferViewId = shader.bufferView;
      const bufferView = bufferViews[bufferViewId];
      const bufferId = bufferView.buffer;
      const buffer = buffers[bufferId];
      const source = getStringFromTypedArray_default(
        buffer.extras._pipeline.source,
        bufferView.byteOffset,
        bufferView.byteLength
      );
      sourceShaders[id] = source;
    } else if (defined_default(shader.extras._pipeline.source)) {
      sourceShaders[id] = shader.extras._pipeline.source;
    } else {
      ++model._loadResources.pendingShaderLoads;
      const shaderResource = model._resource.getDerivedResource({
        url: shader.uri
      });
      shaderResource.fetchText().then(shaderLoad(model, shader.type, id)).catch(
        ModelUtility_default.getFailedLoadFunction(
          model,
          "shader",
          shaderResource.url
        )
      );
    }
  });
}
function parsePrograms(model) {
  const sourceTechniques = model._sourceTechniques;
  for (const techniqueId in sourceTechniques) {
    if (sourceTechniques.hasOwnProperty(techniqueId)) {
      const technique = sourceTechniques[techniqueId];
      model._loadResources.programsToCreate.enqueue({
        programId: technique.program,
        techniqueId
      });
    }
  }
}
function parseArticulations(model) {
  const articulationsByName = {};
  const articulationsByStageKey = {};
  const runtimeStagesByKey = {};
  model._runtime.articulationsByName = articulationsByName;
  model._runtime.articulationsByStageKey = articulationsByStageKey;
  model._runtime.stagesByKey = runtimeStagesByKey;
  const gltf = model.gltf;
  if (!usesExtension_default(gltf, "AGI_articulations") || !defined_default(gltf.extensions) || !defined_default(gltf.extensions.AGI_articulations)) {
    return;
  }
  const gltfArticulations = gltf.extensions.AGI_articulations.articulations;
  if (!defined_default(gltfArticulations)) {
    return;
  }
  const numArticulations = gltfArticulations.length;
  for (let i2 = 0; i2 < numArticulations; ++i2) {
    const articulation = clone_default(gltfArticulations[i2]);
    articulation.nodes = [];
    articulation.isDirty = true;
    articulationsByName[articulation.name] = articulation;
    const numStages = articulation.stages.length;
    for (let s2 = 0; s2 < numStages; ++s2) {
      const stage = articulation.stages[s2];
      stage.currentValue = stage.initialValue;
      const stageKey = `${articulation.name} ${stage.name}`;
      articulationsByStageKey[stageKey] = articulation;
      runtimeStagesByKey[stageKey] = stage;
    }
  }
}
function imageLoad(model, textureId) {
  return function(image) {
    const loadResources = model._loadResources;
    --loadResources.pendingTextureLoads;
    let mipLevels;
    if (Array.isArray(image)) {
      mipLevels = image.slice(1, image.length).map(function(mipLevel) {
        return mipLevel.bufferView;
      });
      image = image[0];
    }
    loadResources.texturesToCreate.enqueue({
      id: textureId,
      image,
      bufferView: image.bufferView,
      width: image.width,
      height: image.height,
      internalFormat: image.internalFormat,
      mipLevels
    });
  };
}
var ktx2Regex2 = /(^data:image\/ktx2)|(\.ktx2$)/i;
function parseTextures(model, context, supportsWebP2) {
  const gltf = model.gltf;
  const images = gltf.images;
  let uri;
  ForEach_default.texture(gltf, function(texture, id) {
    let imageId = texture.source;
    if (defined_default(texture.extensions) && defined_default(texture.extensions.EXT_texture_webp) && supportsWebP2) {
      imageId = texture.extensions.EXT_texture_webp.source;
    } else if (defined_default(texture.extensions) && defined_default(texture.extensions.KHR_texture_basisu) && context.supportsBasis) {
      imageId = texture.extensions.KHR_texture_basisu.source;
    }
    const gltfImage = images[imageId];
    const bufferViewId = gltfImage.bufferView;
    const mimeType = gltfImage.mimeType;
    uri = gltfImage.uri;
    if (defined_default(bufferViewId)) {
      model._loadResources.texturesToCreateFromBufferView.enqueue({
        id,
        image: void 0,
        bufferView: bufferViewId,
        mimeType
      });
    } else {
      ++model._loadResources.pendingTextureLoads;
      const imageResource = model._resource.getDerivedResource({
        url: uri
      });
      let promise;
      if (ktx2Regex2.test(uri)) {
        promise = loadKTX2_default(imageResource);
      } else {
        promise = imageResource.fetchImage({
          skipColorSpaceConversion: true,
          preferImageBitmap: true
        });
      }
      promise.then(imageLoad(model, id, imageId)).catch(
        ModelUtility_default.getFailedLoadFunction(model, "image", imageResource.url)
      );
    }
  });
}
var scratchArticulationStageInitialTransform = new Matrix4_default();
function parseNodes(model) {
  const runtimeNodes = {};
  const runtimeNodesByName = {};
  const skinnedNodes = [];
  const skinnedNodesIds = model._loadResources.skinnedNodesIds;
  const articulationsByName = model._runtime.articulationsByName;
  ForEach_default.node(model.gltf, function(node, id) {
    const runtimeNode = {
      matrix: void 0,
      translation: void 0,
      rotation: void 0,
      scale: void 0,
      computedShow: true,
      transformToRoot: new Matrix4_default(),
      computedMatrix: new Matrix4_default(),
      dirtyNumber: 0,
      commands: [],
      inverseBindMatrices: void 0,
      bindShapeMatrix: void 0,
      joints: [],
      computedJointMatrices: [],
      jointName: node.jointName,
      weights: [],
      children: [],
      parents: [],
      publicNode: void 0
    };
    runtimeNode.publicNode = new ModelNode_default(
      model,
      node,
      runtimeNode,
      id,
      ModelUtility_default.getTransform(node)
    );
    runtimeNodes[id] = runtimeNode;
    runtimeNodesByName[node.name] = runtimeNode;
    if (defined_default(node.skin)) {
      skinnedNodesIds.push(id);
      skinnedNodes.push(runtimeNode);
    }
    if (defined_default(node.extensions) && defined_default(node.extensions.AGI_articulations)) {
      const articulationName = node.extensions.AGI_articulations.articulationName;
      if (defined_default(articulationName)) {
        let transform4 = Matrix4_default.clone(
          runtimeNode.publicNode.originalMatrix,
          scratchArticulationStageInitialTransform
        );
        const articulation = articulationsByName[articulationName];
        articulation.nodes.push(runtimeNode.publicNode);
        const numStages = articulation.stages.length;
        for (let s2 = 0; s2 < numStages; ++s2) {
          const stage = articulation.stages[s2];
          transform4 = applyArticulationStageMatrix(stage, transform4);
        }
        runtimeNode.publicNode.matrix = transform4;
      }
    }
  });
  model._runtime.nodes = runtimeNodes;
  model._runtime.nodesByName = runtimeNodesByName;
  model._runtime.skinnedNodes = skinnedNodes;
}
function parseMaterials(model) {
  const gltf = model.gltf;
  const techniques = model._sourceTechniques;
  const runtimeMaterialsByName = {};
  const runtimeMaterialsById = {};
  const uniformMaps = model._uniformMaps;
  ForEach_default.material(gltf, function(material, materialId) {
    uniformMaps[materialId] = {
      uniformMap: void 0,
      values: void 0,
      jointMatrixUniformName: void 0,
      morphWeightsUniformName: void 0
    };
    const modelMaterial = new ModelMaterial_default(model, material, materialId);
    if (defined_default(material.extensions) && defined_default(material.extensions.KHR_techniques_webgl)) {
      const techniqueId = material.extensions.KHR_techniques_webgl.technique;
      modelMaterial._technique = techniqueId;
      modelMaterial._program = techniques[techniqueId].program;
      ForEach_default.materialValue(material, function(value, uniformName) {
        if (!defined_default(modelMaterial._values)) {
          modelMaterial._values = {};
        }
        modelMaterial._values[uniformName] = clone_default(value);
      });
    }
    runtimeMaterialsByName[material.name] = modelMaterial;
    runtimeMaterialsById[materialId] = modelMaterial;
  });
  model._runtime.materialsByName = runtimeMaterialsByName;
  model._runtime.materialsById = runtimeMaterialsById;
}
function parseMeshes(model) {
  const runtimeMeshesByName = {};
  const runtimeMaterialsById = model._runtime.materialsById;
  ForEach_default.mesh(model.gltf, function(mesh2, meshId) {
    runtimeMeshesByName[mesh2.name] = new ModelMesh_default(
      mesh2,
      runtimeMaterialsById,
      meshId
    );
    if (defined_default(model.extensionsUsed.WEB3D_quantized_attributes) || model._dequantizeInShader) {
      ForEach_default.meshPrimitive(mesh2, function(primitive, primitiveId) {
        const programId = getProgramForPrimitive(model, primitive);
        let programPrimitives = model._programPrimitives[programId];
        if (!defined_default(programPrimitives)) {
          programPrimitives = {};
          model._programPrimitives[programId] = programPrimitives;
        }
        programPrimitives[`${meshId}.primitive.${primitiveId}`] = primitive;
      });
    }
  });
  model._runtime.meshesByName = runtimeMeshesByName;
}
function parseCredits(model) {
  const asset = model.gltf.asset;
  const copyright = asset.copyright;
  if (!defined_default(copyright)) {
    return;
  }
  const showOnScreen = model._showCreditsOnScreen;
  const credits = copyright.split(";").map(function(string) {
    return new Credit_default(string.trim(), showOnScreen);
  });
  model._gltfCredits = credits;
}
var CreateVertexBufferJob = function() {
  this.id = void 0;
  this.model = void 0;
  this.context = void 0;
};
CreateVertexBufferJob.prototype.set = function(id, model, context) {
  this.id = id;
  this.model = model;
  this.context = context;
};
CreateVertexBufferJob.prototype.execute = function() {
  createVertexBuffer2(this.id, this.model, this.context);
};
function createVertexBuffer2(bufferViewId, model, context) {
  const loadResources = model._loadResources;
  const bufferViews = model.gltf.bufferViews;
  let bufferView = bufferViews[bufferViewId];
  if (!defined_default(bufferView)) {
    bufferView = loadResources.createdBufferViews[bufferViewId];
  }
  const vertexBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: loadResources.getBuffer(bufferView),
    usage: BufferUsage_default.STATIC_DRAW
  });
  vertexBuffer.vertexArrayDestroyable = false;
  model._rendererResources.buffers[bufferViewId] = vertexBuffer;
  model._geometryByteLength += vertexBuffer.sizeInBytes;
}
var CreateIndexBufferJob = function() {
  this.id = void 0;
  this.componentType = void 0;
  this.model = void 0;
  this.context = void 0;
};
CreateIndexBufferJob.prototype.set = function(id, componentType, model, context) {
  this.id = id;
  this.componentType = componentType;
  this.model = model;
  this.context = context;
};
CreateIndexBufferJob.prototype.execute = function() {
  createIndexBuffer2(this.id, this.componentType, this.model, this.context);
};
function createIndexBuffer2(bufferViewId, componentType, model, context) {
  const loadResources = model._loadResources;
  const bufferViews = model.gltf.bufferViews;
  let bufferView = bufferViews[bufferViewId];
  if (!defined_default(bufferView)) {
    bufferView = loadResources.createdBufferViews[bufferViewId];
  }
  const indexBuffer = Buffer_default.createIndexBuffer({
    context,
    typedArray: loadResources.getBuffer(bufferView),
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype: componentType
  });
  indexBuffer.vertexArrayDestroyable = false;
  model._rendererResources.buffers[bufferViewId] = indexBuffer;
  model._geometryByteLength += indexBuffer.sizeInBytes;
}
var scratchVertexBufferJob = new CreateVertexBufferJob();
var scratchIndexBufferJob = new CreateIndexBufferJob();
function createBuffers2(model, frameState) {
  const loadResources = model._loadResources;
  if (loadResources.pendingBufferLoads !== 0) {
    return;
  }
  const context = frameState.context;
  const vertexBuffersToCreate = loadResources.vertexBuffersToCreate;
  const indexBuffersToCreate = loadResources.indexBuffersToCreate;
  let i2;
  if (model.asynchronous) {
    while (vertexBuffersToCreate.length > 0) {
      scratchVertexBufferJob.set(vertexBuffersToCreate.peek(), model, context);
      if (!frameState.jobScheduler.execute(scratchVertexBufferJob, JobType_default.BUFFER)) {
        break;
      }
      vertexBuffersToCreate.dequeue();
    }
    while (indexBuffersToCreate.length > 0) {
      i2 = indexBuffersToCreate.peek();
      scratchIndexBufferJob.set(i2.id, i2.componentType, model, context);
      if (!frameState.jobScheduler.execute(scratchIndexBufferJob, JobType_default.BUFFER)) {
        break;
      }
      indexBuffersToCreate.dequeue();
    }
  } else {
    while (vertexBuffersToCreate.length > 0) {
      createVertexBuffer2(vertexBuffersToCreate.dequeue(), model, context);
    }
    while (indexBuffersToCreate.length > 0) {
      i2 = indexBuffersToCreate.dequeue();
      createIndexBuffer2(i2.id, i2.componentType, model, context);
    }
  }
}
function getProgramForPrimitive(model, primitive) {
  const material = model._runtime.materialsById[primitive.material];
  if (!defined_default(material)) {
    return;
  }
  return material._program;
}
function modifyShaderForQuantizedAttributes2(shader, programName, model) {
  let primitive;
  const primitives = model._programPrimitives[programName];
  if (!defined_default(primitives)) {
    return shader;
  }
  let primitiveId;
  for (primitiveId in primitives) {
    if (primitives.hasOwnProperty(primitiveId)) {
      primitive = primitives[primitiveId];
      if (getProgramForPrimitive(model, primitive) === programName) {
        break;
      }
    }
  }
  model._programPrimitives[programName] = void 0;
  let result;
  if (model.extensionsUsed.WEB3D_quantized_attributes) {
    result = ModelUtility_default.modifyShaderForQuantizedAttributes(
      model.gltf,
      primitive,
      shader
    );
    model._quantizedUniforms[programName] = result.uniforms;
  } else {
    const decodedData = model._decodedData[primitiveId];
    if (defined_default(decodedData)) {
      result = ModelUtility_default.modifyShaderForDracoQuantizedAttributes(
        model.gltf,
        primitive,
        shader,
        decodedData.attributes
      );
    } else {
      return shader;
    }
  }
  return result.shader;
}
function modifyShaderForColor(shader) {
  shader = ShaderSource_default.replaceMain(shader, "gltf_blend_main");
  shader += "uniform vec4 gltf_color; \nuniform float gltf_colorBlend; \nvoid main() \n{ \n    gltf_blend_main(); \n    gl_FragColor.rgb = mix(gl_FragColor.rgb, gltf_color.rgb, gltf_colorBlend); \n    float highlight = ceil(gltf_colorBlend); \n    gl_FragColor.rgb *= mix(gltf_color.rgb, vec3(1.0), highlight); \n    gl_FragColor.a *= gltf_color.a; \n} \n";
  return shader;
}
function modifyShader2(shader, programName, callback) {
  if (defined_default(callback)) {
    shader = callback(shader, programName);
  }
  return shader;
}
var CreateProgramJob = function() {
  this.programToCreate = void 0;
  this.model = void 0;
  this.context = void 0;
};
CreateProgramJob.prototype.set = function(programToCreate, model, context) {
  this.programToCreate = programToCreate;
  this.model = model;
  this.context = context;
};
CreateProgramJob.prototype.execute = function() {
  createProgram2(this.programToCreate, this.model, this.context);
};
function createProgram2(programToCreate, model, context) {
  const programId = programToCreate.programId;
  const techniqueId = programToCreate.techniqueId;
  const program = model._sourcePrograms[programId];
  const shaders = model._rendererResources.sourceShaders;
  let vs = shaders[program.vertexShader];
  const fs = shaders[program.fragmentShader];
  const quantizedVertexShaders = model._quantizedVertexShaders;
  if (model.extensionsUsed.WEB3D_quantized_attributes || model._dequantizeInShader) {
    let quantizedVS = quantizedVertexShaders[programId];
    if (!defined_default(quantizedVS)) {
      quantizedVS = modifyShaderForQuantizedAttributes2(vs, programId, model);
      quantizedVertexShaders[programId] = quantizedVS;
    }
    vs = quantizedVS;
  }
  const drawVS = modifyShader2(vs, programId, model._vertexShaderLoaded);
  let drawFS = modifyShader2(fs, programId, model._fragmentShaderLoaded);
  if (!defined_default(model._uniformMapLoaded)) {
    drawFS = `uniform vec4 czm_pickColor;
${drawFS}`;
  }
  const imageBasedLighting = model._imageBasedLighting;
  const useIBL = imageBasedLighting.enabled;
  if (useIBL) {
    drawFS = `#define USE_IBL_LIGHTING 

${drawFS}`;
  }
  if (defined_default(model._lightColor)) {
    drawFS = `#define USE_CUSTOM_LIGHT_COLOR 

${drawFS}`;
  }
  if (model._sourceVersion !== "2.0" || model._sourceKHRTechniquesWebGL) {
    drawFS = ShaderSource_default.replaceMain(drawFS, "non_gamma_corrected_main");
    drawFS = `${drawFS}
void main() { 
    non_gamma_corrected_main(); 
    gl_FragColor = czm_gammaCorrect(gl_FragColor); 
} 
`;
  }
  if (OctahedralProjectedCubeMap_default.isSupported(context)) {
    const useSHC = imageBasedLighting.useSphericalHarmonicCoefficients;
    const useSEM = imageBasedLighting.useSpecularEnvironmentMaps;
    const addMatrix = useSHC || useSEM || useIBL;
    if (addMatrix) {
      drawFS = `uniform mat3 gltf_iblReferenceFrameMatrix; 
${drawFS}`;
    }
    if (defined_default(imageBasedLighting.sphericalHarmonicCoefficients)) {
      drawFS = `${"#define DIFFUSE_IBL \n#define CUSTOM_SPHERICAL_HARMONICS \nuniform vec3 gltf_sphericalHarmonicCoefficients[9]; \n"}${drawFS}`;
    } else if (imageBasedLighting.useDefaultSphericalHarmonics) {
      drawFS = `#define DIFFUSE_IBL 
${drawFS}`;
    }
    if (defined_default(imageBasedLighting.specularEnvironmentMapAtlas) && imageBasedLighting.specularEnvironmentMapAtlas.ready) {
      drawFS = `${"#define SPECULAR_IBL \n#define CUSTOM_SPECULAR_IBL \nuniform sampler2D gltf_specularMap; \nuniform vec2 gltf_specularMapSize; \nuniform float gltf_maxSpecularLOD; \n"}${drawFS}`;
    } else if (imageBasedLighting.useDefaultSpecularMaps) {
      drawFS = `#define SPECULAR_IBL 
${drawFS}`;
    }
  }
  if (defined_default(imageBasedLighting.luminanceAtZenith)) {
    drawFS = `${"#define USE_SUN_LUMINANCE \nuniform float gltf_luminanceAtZenith;\n"}${drawFS}`;
  }
  createAttributesAndProgram(
    programId,
    techniqueId,
    drawFS,
    drawVS,
    model,
    context
  );
}
function recreateProgram(programToCreate, model, context) {
  const programId = programToCreate.programId;
  const techniqueId = programToCreate.techniqueId;
  const program = model._sourcePrograms[programId];
  const shaders = model._rendererResources.sourceShaders;
  const quantizedVertexShaders = model._quantizedVertexShaders;
  const clippingPlaneCollection = model.clippingPlanes;
  const addClippingPlaneCode = isClippingEnabled(model);
  let vs = shaders[program.vertexShader];
  const fs = shaders[program.fragmentShader];
  if (model.extensionsUsed.WEB3D_quantized_attributes || model._dequantizeInShader) {
    vs = quantizedVertexShaders[programId];
  }
  let finalFS = fs;
  if (isColorShadingEnabled(model)) {
    finalFS = Model._modifyShaderForColor(finalFS);
  }
  if (addClippingPlaneCode) {
    finalFS = modifyShaderForClippingPlanes(
      finalFS,
      clippingPlaneCollection,
      context
    );
  }
  if (model.splitDirection !== SplitDirection_default.NONE) {
    finalFS = Splitter_default.modifyFragmentShader(finalFS);
  }
  const drawVS = modifyShader2(vs, programId, model._vertexShaderLoaded);
  let drawFS = modifyShader2(finalFS, programId, model._fragmentShaderLoaded);
  if (!defined_default(model._uniformMapLoaded)) {
    drawFS = `uniform vec4 czm_pickColor;
${drawFS}`;
  }
  const imageBasedLighting = model._imageBasedLighting;
  const useIBL = imageBasedLighting.enabled;
  if (useIBL) {
    drawFS = `#define USE_IBL_LIGHTING 

${drawFS}`;
  }
  if (defined_default(model._lightColor)) {
    drawFS = `#define USE_CUSTOM_LIGHT_COLOR 

${drawFS}`;
  }
  if (model._sourceVersion !== "2.0" || model._sourceKHRTechniquesWebGL) {
    drawFS = ShaderSource_default.replaceMain(drawFS, "non_gamma_corrected_main");
    drawFS = `${drawFS}
void main() { 
    non_gamma_corrected_main(); 
    gl_FragColor = czm_gammaCorrect(gl_FragColor); 
} 
`;
  }
  if (OctahedralProjectedCubeMap_default.isSupported(context)) {
    const useSHC = imageBasedLighting.useSphericalHarmonicCoefficients;
    const useSEM = imageBasedLighting.useSpecularEnvironmentMaps;
    const addMatrix = useSHC || useSEM || useIBL;
    if (addMatrix) {
      drawFS = `uniform mat3 gltf_iblReferenceFrameMatrix; 
${drawFS}`;
    }
    if (defined_default(imageBasedLighting.sphericalHarmonicCoefficients)) {
      drawFS = `${"#define DIFFUSE_IBL \n#define CUSTOM_SPHERICAL_HARMONICS \nuniform vec3 gltf_sphericalHarmonicCoefficients[9]; \n"}${drawFS}`;
    } else if (imageBasedLighting.useDefaultSphericalHarmonics) {
      drawFS = `#define DIFFUSE_IBL 
${drawFS}`;
    }
    if (defined_default(imageBasedLighting.specularEnvironmentMapAtlas) && imageBasedLighting.specularEnvironmentMapAtlas.ready) {
      drawFS = `${"#define SPECULAR_IBL \n#define CUSTOM_SPECULAR_IBL \nuniform sampler2D gltf_specularMap; \nuniform vec2 gltf_specularMapSize; \nuniform float gltf_maxSpecularLOD; \n"}${drawFS}`;
    } else if (imageBasedLighting.useDefaultSpecularMaps) {
      drawFS = `#define SPECULAR_IBL 
${drawFS}`;
    }
  }
  if (defined_default(imageBasedLighting.luminanceAtZenith)) {
    drawFS = `${"#define USE_SUN_LUMINANCE \nuniform float gltf_luminanceAtZenith;\n"}${drawFS}`;
  }
  createAttributesAndProgram(
    programId,
    techniqueId,
    drawFS,
    drawVS,
    model,
    context
  );
}
function createAttributesAndProgram(programId, techniqueId, drawFS, drawVS, model, context) {
  const technique = model._sourceTechniques[techniqueId];
  const attributeLocations8 = ModelUtility_default.createAttributeLocations(
    technique,
    model._precreatedAttributes
  );
  model._rendererResources.programs[programId] = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: drawVS,
    fragmentShaderSource: drawFS,
    attributeLocations: attributeLocations8
  });
}
var scratchCreateProgramJob = new CreateProgramJob();
function createPrograms(model, frameState) {
  const loadResources = model._loadResources;
  const programsToCreate = loadResources.programsToCreate;
  if (loadResources.pendingShaderLoads !== 0) {
    return;
  }
  if (loadResources.pendingBufferLoads !== 0) {
    return;
  }
  const context = frameState.context;
  if (model.asynchronous) {
    while (programsToCreate.length > 0) {
      scratchCreateProgramJob.set(programsToCreate.peek(), model, context);
      if (!frameState.jobScheduler.execute(
        scratchCreateProgramJob,
        JobType_default.PROGRAM
      )) {
        break;
      }
      programsToCreate.dequeue();
    }
  } else {
    while (programsToCreate.length > 0) {
      createProgram2(programsToCreate.dequeue(), model, context);
    }
  }
}
function getOnImageCreatedFromTypedArray(loadResources, gltfTexture) {
  return function(image) {
    loadResources.texturesToCreate.enqueue({
      id: gltfTexture.id,
      image,
      bufferView: void 0
    });
    --loadResources.pendingBufferViewToImage;
  };
}
function loadTexturesFromBufferViews(model) {
  const loadResources = model._loadResources;
  if (loadResources.pendingBufferLoads !== 0) {
    return;
  }
  while (loadResources.texturesToCreateFromBufferView.length > 0) {
    const gltfTexture = loadResources.texturesToCreateFromBufferView.dequeue();
    const gltf = model.gltf;
    const bufferView = gltf.bufferViews[gltfTexture.bufferView];
    const imageId = gltf.textures[gltfTexture.id].source;
    const onerror = ModelUtility_default.getFailedLoadFunction(
      model,
      "image",
      `id: ${gltfTexture.id}, bufferView: ${gltfTexture.bufferView}`
    );
    if (gltfTexture.mimeType === "image/ktx2") {
      const ktxBuffer = new Uint8Array(loadResources.getBuffer(bufferView));
      loadKTX2_default(ktxBuffer).then(imageLoad(model, gltfTexture.id, imageId)).catch(onerror);
      ++model._loadResources.pendingTextureLoads;
    } else {
      const onload = getOnImageCreatedFromTypedArray(
        loadResources,
        gltfTexture
      );
      loadImageFromTypedArray_default({
        uint8Array: loadResources.getBuffer(bufferView),
        format: gltfTexture.mimeType,
        flipY: false,
        skipColorSpaceConversion: true
      }).then(onload).catch(onerror);
      ++loadResources.pendingBufferViewToImage;
    }
  }
}
function createSamplers(model) {
  const loadResources = model._loadResources;
  if (loadResources.createSamplers) {
    loadResources.createSamplers = false;
    const rendererSamplers = model._rendererResources.samplers;
    ForEach_default.sampler(model.gltf, function(sampler, samplerId) {
      rendererSamplers[samplerId] = new Sampler_default({
        wrapS: sampler.wrapS,
        wrapT: sampler.wrapT,
        minificationFilter: sampler.minFilter,
        magnificationFilter: sampler.magFilter
      });
    });
  }
}
var CreateTextureJob = function() {
  this.gltfTexture = void 0;
  this.model = void 0;
  this.context = void 0;
};
CreateTextureJob.prototype.set = function(gltfTexture, model, context) {
  this.gltfTexture = gltfTexture;
  this.model = model;
  this.context = context;
};
CreateTextureJob.prototype.execute = function() {
  createTexture4(this.gltfTexture, this.model, this.context);
};
function createTexture4(gltfTexture, model, context) {
  const textures = model.gltf.textures;
  const texture = textures[gltfTexture.id];
  const rendererSamplers = model._rendererResources.samplers;
  let sampler = rendererSamplers[texture.sampler];
  if (!defined_default(sampler)) {
    sampler = new Sampler_default({
      wrapS: TextureWrap_default.REPEAT,
      wrapT: TextureWrap_default.REPEAT
    });
  }
  let usesTextureTransform = false;
  const materials = model.gltf.materials;
  const materialsLength = materials.length;
  for (let i2 = 0; i2 < materialsLength; ++i2) {
    const material = materials[i2];
    if (defined_default(material.extensions) && defined_default(material.extensions.KHR_techniques_webgl)) {
      const values = material.extensions.KHR_techniques_webgl.values;
      for (const valueName in values) {
        if (values.hasOwnProperty(valueName) && valueName.indexOf("Texture") !== -1) {
          const value = values[valueName];
          if (value.index === gltfTexture.id && defined_default(value.extensions) && defined_default(value.extensions.KHR_texture_transform)) {
            usesTextureTransform = true;
            break;
          }
        }
      }
    }
    if (usesTextureTransform) {
      break;
    }
  }
  const wrapS = sampler.wrapS;
  const wrapT = sampler.wrapT;
  let minFilter = sampler.minificationFilter;
  if (usesTextureTransform && minFilter !== TextureMinificationFilter_default.LINEAR && minFilter !== TextureMinificationFilter_default.NEAREST) {
    if (minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_NEAREST || minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_LINEAR) {
      minFilter = TextureMinificationFilter_default.NEAREST;
    } else {
      minFilter = TextureMinificationFilter_default.LINEAR;
    }
    sampler = new Sampler_default({
      wrapS: sampler.wrapS,
      wrapT: sampler.wrapT,
      minificationFilter: minFilter,
      magnificationFilter: sampler.magnificationFilter
    });
  }
  const internalFormat = gltfTexture.internalFormat;
  const mipmap = !(defined_default(internalFormat) && PixelFormat_default.isCompressedFormat(internalFormat)) && (minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_NEAREST || minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_LINEAR || minFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_NEAREST || minFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_LINEAR);
  const requiresNpot = mipmap || wrapS === TextureWrap_default.REPEAT || wrapS === TextureWrap_default.MIRRORED_REPEAT || wrapT === TextureWrap_default.REPEAT || wrapT === TextureWrap_default.MIRRORED_REPEAT;
  let npot;
  let tx;
  let source = gltfTexture.image;
  if (defined_default(internalFormat)) {
    npot = !Math_default.isPowerOfTwo(gltfTexture.width) || !Math_default.isPowerOfTwo(gltfTexture.height);
    if (!context.webgl2 && PixelFormat_default.isCompressedFormat(internalFormat) && npot && requiresNpot) {
      console.warn(
        "Compressed texture uses REPEAT or MIRRORED_REPEAT texture wrap mode and dimensions are not powers of two. The texture may be rendered incorrectly. See the Model.js constructor documentation for more information."
      );
    }
    let minificationFilter = sampler.minificationFilter;
    if (!defined_default(gltfTexture.mipLevels) && (minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_NEAREST || minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_LINEAR)) {
      minificationFilter = TextureMinificationFilter_default.NEAREST;
    } else if (!defined_default(gltfTexture.mipLevels) && (minFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_NEAREST || minFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_LINEAR)) {
      minificationFilter = TextureMinificationFilter_default.LINEAR;
    }
    sampler = new Sampler_default({
      wrapS: sampler.wrapS,
      wrapT: sampler.wrapT,
      minificationFilter,
      magnificationFilter: sampler.magnificationFilter
    });
    tx = new Texture_default({
      context,
      source: {
        arrayBufferView: gltfTexture.bufferView,
        mipLevels: gltfTexture.mipLevels
      },
      width: gltfTexture.width,
      height: gltfTexture.height,
      pixelFormat: internalFormat,
      sampler
    });
  } else if (defined_default(source)) {
    npot = !Math_default.isPowerOfTwo(source.width) || !Math_default.isPowerOfTwo(source.height);
    if (requiresNpot && npot) {
      const canvas = document.createElement("canvas");
      canvas.width = Math_default.nextPowerOfTwo(source.width);
      canvas.height = Math_default.nextPowerOfTwo(source.height);
      const canvasContext = canvas.getContext("2d");
      canvasContext.drawImage(
        source,
        0,
        0,
        source.width,
        source.height,
        0,
        0,
        canvas.width,
        canvas.height
      );
      source = canvas;
    }
    tx = new Texture_default({
      context,
      source,
      pixelFormat: texture.internalFormat,
      pixelDatatype: texture.type,
      sampler,
      flipY: false,
      skipColorSpaceConversion: true
    });
    if (mipmap) {
      tx.generateMipmap();
    }
  }
  if (defined_default(tx)) {
    model._rendererResources.textures[gltfTexture.id] = tx;
    model._texturesByteLength += tx.sizeInBytes;
  }
}
var scratchCreateTextureJob = new CreateTextureJob();
function createTextures(model, frameState) {
  const context = frameState.context;
  const texturesToCreate = model._loadResources.texturesToCreate;
  if (model.asynchronous) {
    while (texturesToCreate.length > 0) {
      scratchCreateTextureJob.set(texturesToCreate.peek(), model, context);
      if (!frameState.jobScheduler.execute(
        scratchCreateTextureJob,
        JobType_default.TEXTURE
      )) {
        break;
      }
      texturesToCreate.dequeue();
    }
  } else {
    while (texturesToCreate.length > 0) {
      createTexture4(texturesToCreate.dequeue(), model, context);
    }
  }
}
function getAttributeLocations2(model, primitive) {
  const techniques = model._sourceTechniques;
  const attributeLocations8 = {};
  let location2;
  let index2;
  const material = model._runtime.materialsById[primitive.material];
  if (!defined_default(material)) {
    return attributeLocations8;
  }
  const technique = techniques[material._technique];
  if (!defined_default(technique)) {
    return attributeLocations8;
  }
  const attributes = technique.attributes;
  const program = model._rendererResources.programs[technique.program];
  const programAttributeLocations = program._attributeLocations;
  for (location2 in programAttributeLocations) {
    if (programAttributeLocations.hasOwnProperty(location2)) {
      const attribute = attributes[location2];
      if (defined_default(attribute)) {
        index2 = programAttributeLocations[location2];
        attributeLocations8[attribute.semantic] = index2;
      }
    }
  }
  const precreatedAttributes = model._precreatedAttributes;
  if (defined_default(precreatedAttributes)) {
    for (location2 in precreatedAttributes) {
      if (precreatedAttributes.hasOwnProperty(location2)) {
        index2 = programAttributeLocations[location2];
        attributeLocations8[location2] = index2;
      }
    }
  }
  return attributeLocations8;
}
function createJoints(model, runtimeSkins) {
  const gltf = model.gltf;
  const skins = gltf.skins;
  const nodes = gltf.nodes;
  const runtimeNodes = model._runtime.nodes;
  const skinnedNodesIds = model._loadResources.skinnedNodesIds;
  const length3 = skinnedNodesIds.length;
  for (let j = 0; j < length3; ++j) {
    const id = skinnedNodesIds[j];
    const skinnedNode = runtimeNodes[id];
    const node = nodes[id];
    const runtimeSkin = runtimeSkins[node.skin];
    skinnedNode.inverseBindMatrices = runtimeSkin.inverseBindMatrices;
    skinnedNode.bindShapeMatrix = runtimeSkin.bindShapeMatrix;
    const gltfJoints = skins[node.skin].joints;
    const jointsLength = gltfJoints.length;
    for (let i2 = 0; i2 < jointsLength; ++i2) {
      const nodeId = gltfJoints[i2];
      const jointNode = runtimeNodes[nodeId];
      skinnedNode.joints.push(jointNode);
    }
  }
}
function createSkins(model) {
  const loadResources = model._loadResources;
  if (loadResources.pendingBufferLoads !== 0) {
    return;
  }
  if (!loadResources.createSkins) {
    return;
  }
  loadResources.createSkins = false;
  const gltf = model.gltf;
  const accessors = gltf.accessors;
  const runtimeSkins = {};
  ForEach_default.skin(gltf, function(skin, id) {
    const accessor = accessors[skin.inverseBindMatrices];
    let bindShapeMatrix;
    if (!Matrix4_default.equals(skin.bindShapeMatrix, Matrix4_default.IDENTITY)) {
      bindShapeMatrix = Matrix4_default.clone(skin.bindShapeMatrix);
    }
    runtimeSkins[id] = {
      inverseBindMatrices: ModelAnimationCache_default.getSkinInverseBindMatrices(
        model,
        accessor
      ),
      bindShapeMatrix
    };
  });
  createJoints(model, runtimeSkins);
}
function getChannelEvaluator(model, runtimeNode, targetPath, spline) {
  return function(localAnimationTime) {
    if (defined_default(spline)) {
      localAnimationTime = model.clampAnimations ? spline.clampTime(localAnimationTime) : spline.wrapTime(localAnimationTime);
      runtimeNode[targetPath] = spline.evaluate(
        localAnimationTime,
        runtimeNode[targetPath]
      );
      runtimeNode.dirtyNumber = model._maxDirtyNumber;
    }
  };
}
function createRuntimeAnimations(model) {
  const loadResources = model._loadResources;
  if (!loadResources.finishedPendingBufferLoads()) {
    return;
  }
  if (!loadResources.createRuntimeAnimations) {
    return;
  }
  loadResources.createRuntimeAnimations = false;
  model._runtime.animations = [];
  const runtimeNodes = model._runtime.nodes;
  const accessors = model.gltf.accessors;
  ForEach_default.animation(model.gltf, function(animation, i2) {
    const channels = animation.channels;
    const samplers = animation.samplers;
    let startTime = Number.MAX_VALUE;
    let stopTime = -Number.MAX_VALUE;
    const channelsLength = channels.length;
    const channelEvaluators = new Array(channelsLength);
    for (let j = 0; j < channelsLength; ++j) {
      const channel = channels[j];
      const target = channel.target;
      const path = target.path;
      const sampler = samplers[channel.sampler];
      const input = ModelAnimationCache_default.getAnimationParameterValues(
        model,
        accessors[sampler.input]
      );
      const output = ModelAnimationCache_default.getAnimationParameterValues(
        model,
        accessors[sampler.output]
      );
      startTime = Math.min(startTime, input[0]);
      stopTime = Math.max(stopTime, input[input.length - 1]);
      const spline = ModelAnimationCache_default.getAnimationSpline(
        model,
        i2,
        animation,
        channel.sampler,
        sampler,
        input,
        path,
        output
      );
      channelEvaluators[j] = getChannelEvaluator(
        model,
        runtimeNodes[target.node],
        target.path,
        spline
      );
    }
    model._runtime.animations[i2] = {
      name: animation.name,
      startTime,
      stopTime,
      channelEvaluators
    };
  });
}
function createVertexArrays(model, context) {
  const loadResources = model._loadResources;
  if (!loadResources.finishedBuffersCreation() || !loadResources.finishedProgramCreation() || !loadResources.createVertexArrays) {
    return;
  }
  loadResources.createVertexArrays = false;
  const rendererBuffers = model._rendererResources.buffers;
  const rendererVertexArrays = model._rendererResources.vertexArrays;
  const gltf = model.gltf;
  const accessors = gltf.accessors;
  ForEach_default.mesh(gltf, function(mesh2, meshId) {
    ForEach_default.meshPrimitive(mesh2, function(primitive, primitiveId) {
      const attributes = [];
      let attributeLocation;
      const attributeLocations8 = getAttributeLocations2(model, primitive);
      const decodedData = model._decodedData[`${meshId}.primitive.${primitiveId}`];
      ForEach_default.meshPrimitiveAttribute(primitive, function(accessorId, attributeName2) {
        attributeLocation = attributeLocations8[attributeName2];
        if (defined_default(attributeLocation)) {
          if (defined_default(decodedData)) {
            const decodedAttributes = decodedData.attributes;
            if (decodedAttributes.hasOwnProperty(attributeName2)) {
              const decodedAttribute = decodedAttributes[attributeName2];
              attributes.push({
                index: attributeLocation,
                vertexBuffer: rendererBuffers[decodedAttribute.bufferView],
                componentsPerAttribute: decodedAttribute.componentsPerAttribute,
                componentDatatype: decodedAttribute.componentDatatype,
                normalize: decodedAttribute.normalized,
                offsetInBytes: decodedAttribute.byteOffset,
                strideInBytes: decodedAttribute.byteStride
              });
              return;
            }
          }
          const a4 = accessors[accessorId];
          const normalize2 = defined_default(a4.normalized) && a4.normalized;
          attributes.push({
            index: attributeLocation,
            vertexBuffer: rendererBuffers[a4.bufferView],
            componentsPerAttribute: numberOfComponentsForType_default(a4.type),
            componentDatatype: a4.componentType,
            normalize: normalize2,
            offsetInBytes: a4.byteOffset,
            strideInBytes: getAccessorByteStride_default(gltf, a4)
          });
        }
      });
      let attribute;
      let attributeName;
      const precreatedAttributes = model._precreatedAttributes;
      if (defined_default(precreatedAttributes)) {
        for (attributeName in precreatedAttributes) {
          if (precreatedAttributes.hasOwnProperty(attributeName)) {
            attributeLocation = attributeLocations8[attributeName];
            if (defined_default(attributeLocation)) {
              attribute = precreatedAttributes[attributeName];
              attribute.index = attributeLocation;
              attributes.push(attribute);
            }
          }
        }
      }
      let indexBuffer;
      if (defined_default(primitive.indices)) {
        const accessor = accessors[primitive.indices];
        let bufferView = accessor.bufferView;
        if (defined_default(decodedData)) {
          bufferView = decodedData.bufferView;
        }
        indexBuffer = rendererBuffers[bufferView];
      }
      rendererVertexArrays[`${meshId}.primitive.${primitiveId}`] = new VertexArray_default({
        context,
        attributes,
        indexBuffer
      });
    });
  });
}
function createRenderStates4(model) {
  const loadResources = model._loadResources;
  if (loadResources.createRenderStates) {
    loadResources.createRenderStates = false;
    ForEach_default.material(model.gltf, function(material, materialId) {
      createRenderStateForMaterial(model, material, materialId);
    });
  }
}
function createRenderStateForMaterial(model, material, materialId) {
  const rendererRenderStates = model._rendererResources.renderStates;
  let blendEquationSeparate = [
    WebGLConstants_default.FUNC_ADD,
    WebGLConstants_default.FUNC_ADD
  ];
  let blendFuncSeparate = [
    WebGLConstants_default.ONE,
    WebGLConstants_default.ONE_MINUS_SRC_ALPHA,
    WebGLConstants_default.ONE,
    WebGLConstants_default.ONE_MINUS_SRC_ALPHA
  ];
  if (defined_default(material.extensions) && defined_default(material.extensions.KHR_blend)) {
    blendEquationSeparate = material.extensions.KHR_blend.blendEquation;
    blendFuncSeparate = material.extensions.KHR_blend.blendFactors;
  }
  const enableCulling = !material.doubleSided;
  const blendingEnabled = material.alphaMode === "BLEND";
  rendererRenderStates[materialId] = RenderState_default.fromCache({
    cull: {
      enabled: enableCulling
    },
    depthTest: {
      enabled: true,
      func: DepthFunction_default.LESS_OR_EQUAL
    },
    depthMask: !blendingEnabled,
    blending: {
      enabled: blendingEnabled,
      equationRgb: blendEquationSeparate[0],
      equationAlpha: blendEquationSeparate[1],
      functionSourceRgb: blendFuncSeparate[0],
      functionDestinationRgb: blendFuncSeparate[1],
      functionSourceAlpha: blendFuncSeparate[2],
      functionDestinationAlpha: blendFuncSeparate[3]
    }
  });
}
var gltfUniformsFromNode = {
  MODEL: function(uniformState, model, runtimeNode) {
    return function() {
      return runtimeNode.computedMatrix;
    };
  },
  VIEW: function(uniformState, model, runtimeNode) {
    return function() {
      return uniformState.view;
    };
  },
  PROJECTION: function(uniformState, model, runtimeNode) {
    return function() {
      return uniformState.projection;
    };
  },
  MODELVIEW: function(uniformState, model, runtimeNode) {
    const mv = new Matrix4_default();
    return function() {
      return Matrix4_default.multiplyTransformation(
        uniformState.view,
        runtimeNode.computedMatrix,
        mv
      );
    };
  },
  CESIUM_RTC_MODELVIEW: function(uniformState, model, runtimeNode) {
    const mvRtc = new Matrix4_default();
    return function() {
      Matrix4_default.multiplyTransformation(
        uniformState.view,
        runtimeNode.computedMatrix,
        mvRtc
      );
      return Matrix4_default.setTranslation(mvRtc, model._rtcCenterEye, mvRtc);
    };
  },
  MODELVIEWPROJECTION: function(uniformState, model, runtimeNode) {
    const mvp = new Matrix4_default();
    return function() {
      Matrix4_default.multiplyTransformation(
        uniformState.view,
        runtimeNode.computedMatrix,
        mvp
      );
      return Matrix4_default.multiply(uniformState._projection, mvp, mvp);
    };
  },
  MODELINVERSE: function(uniformState, model, runtimeNode) {
    const mInverse = new Matrix4_default();
    return function() {
      return Matrix4_default.inverse(runtimeNode.computedMatrix, mInverse);
    };
  },
  VIEWINVERSE: function(uniformState, model) {
    return function() {
      return uniformState.inverseView;
    };
  },
  PROJECTIONINVERSE: function(uniformState, model, runtimeNode) {
    return function() {
      return uniformState.inverseProjection;
    };
  },
  MODELVIEWINVERSE: function(uniformState, model, runtimeNode) {
    const mv = new Matrix4_default();
    const mvInverse = new Matrix4_default();
    return function() {
      Matrix4_default.multiplyTransformation(
        uniformState.view,
        runtimeNode.computedMatrix,
        mv
      );
      return Matrix4_default.inverse(mv, mvInverse);
    };
  },
  MODELVIEWPROJECTIONINVERSE: function(uniformState, model, runtimeNode) {
    const mvp = new Matrix4_default();
    const mvpInverse = new Matrix4_default();
    return function() {
      Matrix4_default.multiplyTransformation(
        uniformState.view,
        runtimeNode.computedMatrix,
        mvp
      );
      Matrix4_default.multiply(uniformState._projection, mvp, mvp);
      return Matrix4_default.inverse(mvp, mvpInverse);
    };
  },
  MODELINVERSETRANSPOSE: function(uniformState, model, runtimeNode) {
    const mInverse = new Matrix4_default();
    const mInverseTranspose = new Matrix3_default();
    return function() {
      Matrix4_default.inverse(runtimeNode.computedMatrix, mInverse);
      Matrix4_default.getMatrix3(mInverse, mInverseTranspose);
      return Matrix3_default.transpose(mInverseTranspose, mInverseTranspose);
    };
  },
  MODELVIEWINVERSETRANSPOSE: function(uniformState, model, runtimeNode) {
    const mv = new Matrix4_default();
    const mvInverse = new Matrix4_default();
    const mvInverseTranspose = new Matrix3_default();
    return function() {
      Matrix4_default.multiplyTransformation(
        uniformState.view,
        runtimeNode.computedMatrix,
        mv
      );
      Matrix4_default.inverse(mv, mvInverse);
      Matrix4_default.getMatrix3(mvInverse, mvInverseTranspose);
      return Matrix3_default.transpose(mvInverseTranspose, mvInverseTranspose);
    };
  },
  VIEWPORT: function(uniformState, model, runtimeNode) {
    return function() {
      return uniformState.viewportCartesian4;
    };
  }
};
function getUniformFunctionFromSource(source, model, semantic, uniformState) {
  const runtimeNode = model._runtime.nodes[source];
  return gltfUniformsFromNode[semantic](uniformState, model, runtimeNode);
}
function createUniformsForMaterial(model, material, technique, instanceValues, context, textures, defaultTexture) {
  const uniformMap2 = {};
  const uniformValues = {};
  let jointMatrixUniformName;
  let morphWeightsUniformName;
  ForEach_default.techniqueUniform(technique, function(uniform, uniformName) {
    let uv;
    if (defined_default(instanceValues) && defined_default(instanceValues[uniformName])) {
      uv = ModelUtility_default.createUniformFunction(
        uniform.type,
        instanceValues[uniformName],
        textures,
        defaultTexture
      );
      uniformMap2[uniformName] = uv.func;
      uniformValues[uniformName] = uv;
    } else if (defined_default(uniform.node)) {
      uniformMap2[uniformName] = getUniformFunctionFromSource(
        uniform.node,
        model,
        uniform.semantic,
        context.uniformState
      );
    } else if (defined_default(uniform.semantic)) {
      if (uniform.semantic === "JOINTMATRIX") {
        jointMatrixUniformName = uniformName;
      } else if (uniform.semantic === "MORPHWEIGHTS") {
        morphWeightsUniformName = uniformName;
      } else if (uniform.semantic === "ALPHACUTOFF") {
        const alphaMode = material.alphaMode;
        if (defined_default(alphaMode) && alphaMode === "MASK") {
          const alphaCutoffValue = defaultValue_default(material.alphaCutoff, 0.5);
          uv = ModelUtility_default.createUniformFunction(
            uniform.type,
            alphaCutoffValue,
            textures,
            defaultTexture
          );
          uniformMap2[uniformName] = uv.func;
          uniformValues[uniformName] = uv;
        }
      } else {
        uniformMap2[uniformName] = ModelUtility_default.getGltfSemanticUniforms()[uniform.semantic](context.uniformState, model);
      }
    } else if (defined_default(uniform.value)) {
      const uv2 = ModelUtility_default.createUniformFunction(
        uniform.type,
        uniform.value,
        textures,
        defaultTexture
      );
      uniformMap2[uniformName] = uv2.func;
      uniformValues[uniformName] = uv2;
    }
  });
  return {
    map: uniformMap2,
    values: uniformValues,
    jointMatrixUniformName,
    morphWeightsUniformName
  };
}
function createUniformMaps(model, context) {
  const loadResources = model._loadResources;
  if (!loadResources.finishedProgramCreation()) {
    return;
  }
  if (!loadResources.createUniformMaps) {
    return;
  }
  loadResources.createUniformMaps = false;
  const gltf = model.gltf;
  const techniques = model._sourceTechniques;
  const uniformMaps = model._uniformMaps;
  const textures = model._rendererResources.textures;
  const defaultTexture = model._defaultTexture;
  ForEach_default.material(gltf, function(material, materialId) {
    const modelMaterial = model._runtime.materialsById[materialId];
    const technique = techniques[modelMaterial._technique];
    const instanceValues = modelMaterial._values;
    const uniforms = createUniformsForMaterial(
      model,
      material,
      technique,
      instanceValues,
      context,
      textures,
      defaultTexture
    );
    const u3 = uniformMaps[materialId];
    u3.uniformMap = uniforms.map;
    u3.values = uniforms.values;
    u3.jointMatrixUniformName = uniforms.jointMatrixUniformName;
    u3.morphWeightsUniformName = uniforms.morphWeightsUniformName;
    if (defined_default(technique.attributes.a_outlineCoordinates)) {
      const outlineTexture = ModelOutlineLoader_default.createTexture(model, context);
      u3.uniformMap.u_outlineTexture = function() {
        return outlineTexture;
      };
    }
  });
}
function createUniformsForDracoQuantizedAttributes(decodedData) {
  return ModelUtility_default.createUniformsForDracoQuantizedAttributes(
    decodedData.attributes
  );
}
function createUniformsForQuantizedAttributes2(model, primitive) {
  const programId = getProgramForPrimitive(model, primitive);
  const quantizedUniforms = model._quantizedUniforms[programId];
  return ModelUtility_default.createUniformsForQuantizedAttributes(
    model.gltf,
    primitive,
    quantizedUniforms
  );
}
function createPickColorFunction(color) {
  return function() {
    return color;
  };
}
function createJointMatricesFunction(runtimeNode) {
  return function() {
    return runtimeNode.computedJointMatrices;
  };
}
function createMorphWeightsFunction(runtimeNode) {
  return function() {
    return runtimeNode.weights;
  };
}
function createSilhouetteColorFunction(model) {
  return function() {
    return model.silhouetteColor;
  };
}
function createSilhouetteSizeFunction(model) {
  return function() {
    return model.silhouetteSize;
  };
}
function createColorFunction(model) {
  return function() {
    return model.color;
  };
}
function createClippingPlanesMatrixFunction(model) {
  return function() {
    return model._clippingPlanesMatrix;
  };
}
function createIBLReferenceFrameMatrixFunction(model) {
  return function() {
    return model._iblReferenceFrameMatrix;
  };
}
function createClippingPlanesFunction(model) {
  return function() {
    const clippingPlanes = model.clippingPlanes;
    return !defined_default(clippingPlanes) || !clippingPlanes.enabled ? model._defaultTexture : clippingPlanes.texture;
  };
}
function createClippingPlanesEdgeStyleFunction(model) {
  return function() {
    const clippingPlanes = model.clippingPlanes;
    if (!defined_default(clippingPlanes)) {
      return Color_default.WHITE.withAlpha(0);
    }
    const style = Color_default.clone(clippingPlanes.edgeColor);
    style.alpha = clippingPlanes.edgeWidth;
    return style;
  };
}
function createColorBlendFunction(model) {
  return function() {
    return ColorBlendMode_default.getColorBlend(
      model.colorBlendMode,
      model.colorBlendAmount
    );
  };
}
function createIBLFactorFunction(model) {
  return function() {
    return model._imageBasedLighting.imageBasedLightingFactor;
  };
}
function createLightColorFunction(model) {
  return function() {
    return model._lightColor;
  };
}
function createLuminanceAtZenithFunction(model) {
  return function() {
    return model._imageBasedLighting.luminanceAtZenith;
  };
}
function createSphericalHarmonicCoefficientsFunction(model) {
  return function() {
    return model._imageBasedLighting.sphericalHarmonicCoefficients;
  };
}
function createSpecularEnvironmentMapFunction(model) {
  return function() {
    return model._imageBasedLighting.specularEnvironmentMapAtlas.texture;
  };
}
function createSpecularEnvironmentMapSizeFunction(model) {
  return function() {
    return model._imageBasedLighting.specularEnvironmentMapAtlas.texture.dimensions;
  };
}
function createSpecularEnvironmentMapLOD(model) {
  return function() {
    return model._imageBasedLighting.specularEnvironmentMapAtlas.maximumMipmapLevel;
  };
}
function triangleCountFromPrimitiveIndices2(primitive, indicesCount) {
  switch (primitive.mode) {
    case PrimitiveType_default.TRIANGLES:
      return indicesCount / 3;
    case PrimitiveType_default.TRIANGLE_STRIP:
    case PrimitiveType_default.TRIANGLE_FAN:
      return Math.max(indicesCount - 2, 0);
    default:
      return 0;
  }
}
function createCommand(model, gltfNode, runtimeNode, context, scene3DOnly) {
  const nodeCommands = model._nodeCommands;
  const pickIds = model._pickIds;
  const allowPicking = model.allowPicking;
  const runtimeMeshesByName = model._runtime.meshesByName;
  const resources = model._rendererResources;
  const rendererVertexArrays = resources.vertexArrays;
  const rendererPrograms = resources.programs;
  const rendererRenderStates = resources.renderStates;
  const uniformMaps = model._uniformMaps;
  const gltf = model.gltf;
  const accessors = gltf.accessors;
  const gltfMeshes = gltf.meshes;
  const id = gltfNode.mesh;
  const mesh2 = gltfMeshes[id];
  const primitives = mesh2.primitives;
  const length3 = primitives.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const primitive = primitives[i2];
    const ix = accessors[primitive.indices];
    const material = model._runtime.materialsById[primitive.material];
    const programId = material._program;
    const decodedData = model._decodedData[`${id}.primitive.${i2}`];
    let boundingSphere;
    const positionAccessor = primitive.attributes.POSITION;
    if (defined_default(positionAccessor)) {
      const minMax = ModelUtility_default.getAccessorMinMax(gltf, positionAccessor);
      boundingSphere = BoundingSphere_default.fromCornerPoints(
        Cartesian3_default.fromArray(minMax.min),
        Cartesian3_default.fromArray(minMax.max)
      );
    }
    const vertexArray = rendererVertexArrays[`${id}.primitive.${i2}`];
    let offset2;
    let count;
    if (defined_default(decodedData)) {
      count = decodedData.numberOfIndices;
      offset2 = 0;
    } else if (defined_default(ix)) {
      count = ix.count;
      offset2 = ix.byteOffset / IndexDatatype_default.getSizeInBytes(ix.componentType);
    } else {
      const positions = accessors[primitive.attributes.POSITION];
      count = positions.count;
      offset2 = 0;
    }
    model._trianglesLength += triangleCountFromPrimitiveIndices2(
      primitive,
      count
    );
    if (primitive.mode === PrimitiveType_default.POINTS) {
      model._pointsLength += count;
    }
    const um = uniformMaps[primitive.material];
    let uniformMap2 = um.uniformMap;
    if (defined_default(um.jointMatrixUniformName)) {
      const jointUniformMap = {};
      jointUniformMap[um.jointMatrixUniformName] = createJointMatricesFunction(
        runtimeNode
      );
      uniformMap2 = combine_default(uniformMap2, jointUniformMap);
    }
    if (defined_default(um.morphWeightsUniformName)) {
      const morphWeightsUniformMap = {};
      morphWeightsUniformMap[um.morphWeightsUniformName] = createMorphWeightsFunction(runtimeNode);
      uniformMap2 = combine_default(uniformMap2, morphWeightsUniformMap);
    }
    uniformMap2 = combine_default(uniformMap2, {
      gltf_color: createColorFunction(model),
      gltf_colorBlend: createColorBlendFunction(model),
      gltf_clippingPlanes: createClippingPlanesFunction(model),
      gltf_clippingPlanesEdgeStyle: createClippingPlanesEdgeStyleFunction(
        model
      ),
      gltf_clippingPlanesMatrix: createClippingPlanesMatrixFunction(model),
      gltf_iblReferenceFrameMatrix: createIBLReferenceFrameMatrixFunction(
        model
      ),
      gltf_iblFactor: createIBLFactorFunction(model),
      gltf_lightColor: createLightColorFunction(model),
      gltf_sphericalHarmonicCoefficients: createSphericalHarmonicCoefficientsFunction(
        model
      ),
      gltf_specularMap: createSpecularEnvironmentMapFunction(model),
      gltf_specularMapSize: createSpecularEnvironmentMapSizeFunction(model),
      gltf_maxSpecularLOD: createSpecularEnvironmentMapLOD(model),
      gltf_luminanceAtZenith: createLuminanceAtZenithFunction(model)
    });
    Splitter_default.addUniforms(model, uniformMap2);
    if (defined_default(model._uniformMapLoaded)) {
      uniformMap2 = model._uniformMapLoaded(uniformMap2, programId, runtimeNode);
    }
    let quantizedUniformMap = {};
    if (model.extensionsUsed.WEB3D_quantized_attributes) {
      quantizedUniformMap = createUniformsForQuantizedAttributes2(
        model,
        primitive
      );
    } else if (model._dequantizeInShader && defined_default(decodedData)) {
      quantizedUniformMap = createUniformsForDracoQuantizedAttributes(
        decodedData
      );
    }
    uniformMap2 = combine_default(uniformMap2, quantizedUniformMap);
    const rs = rendererRenderStates[primitive.material];
    const isTranslucent2 = rs.blending.enabled;
    let owner = model._pickObject;
    if (!defined_default(owner)) {
      owner = {
        primitive: model,
        id: model.id,
        node: runtimeNode.publicNode,
        mesh: runtimeMeshesByName[mesh2.name]
      };
    }
    const castShadows = ShadowMode_default.castShadows(model._shadows);
    const receiveShadows = ShadowMode_default.receiveShadows(model._shadows);
    let pickId;
    if (allowPicking && !defined_default(model._uniformMapLoaded)) {
      pickId = context.createPickId(owner);
      pickIds.push(pickId);
      const pickUniforms = {
        czm_pickColor: createPickColorFunction(pickId.color)
      };
      uniformMap2 = combine_default(uniformMap2, pickUniforms);
    }
    if (allowPicking) {
      if (defined_default(model._pickIdLoaded) && defined_default(model._uniformMapLoaded)) {
        pickId = model._pickIdLoaded();
      } else {
        pickId = "czm_pickColor";
      }
    }
    const command = new DrawCommand_default({
      boundingVolume: new BoundingSphere_default(),
      cull: model.cull,
      modelMatrix: new Matrix4_default(),
      primitiveType: primitive.mode,
      vertexArray,
      count,
      offset: offset2,
      shaderProgram: rendererPrograms[programId],
      castShadows,
      receiveShadows,
      uniformMap: uniformMap2,
      renderState: rs,
      owner,
      pass: isTranslucent2 ? Pass_default.TRANSLUCENT : model.opaquePass,
      pickId
    });
    let command2D;
    if (!scene3DOnly) {
      command2D = DrawCommand_default.shallowClone(command);
      command2D.boundingVolume = new BoundingSphere_default();
      command2D.modelMatrix = new Matrix4_default();
    }
    const nodeCommand = {
      show: true,
      boundingSphere,
      command,
      command2D,
      silhouetteModelCommand: void 0,
      silhouetteModelCommand2D: void 0,
      silhouetteColorCommand: void 0,
      silhouetteColorCommand2D: void 0,
      translucentCommand: void 0,
      translucentCommand2D: void 0,
      disableCullingCommand: void 0,
      disableCullingCommand2D: void 0,
      programId
    };
    runtimeNode.commands.push(nodeCommand);
    nodeCommands.push(nodeCommand);
  }
}
function createRuntimeNodes2(model, context, scene3DOnly) {
  const loadResources = model._loadResources;
  if (!loadResources.finishedEverythingButTextureCreation()) {
    return;
  }
  if (!loadResources.createRuntimeNodes) {
    return;
  }
  loadResources.createRuntimeNodes = false;
  const rootNodes = [];
  const runtimeNodes = model._runtime.nodes;
  const gltf = model.gltf;
  const nodes = gltf.nodes;
  const scene = gltf.scenes[gltf.scene];
  const sceneNodes = scene.nodes;
  const length3 = sceneNodes.length;
  const stack = [];
  const seen = {};
  for (let i2 = 0; i2 < length3; ++i2) {
    stack.push({
      parentRuntimeNode: void 0,
      gltfNode: nodes[sceneNodes[i2]],
      id: sceneNodes[i2]
    });
    while (stack.length > 0) {
      const n2 = stack.pop();
      seen[n2.id] = true;
      const parentRuntimeNode = n2.parentRuntimeNode;
      const gltfNode = n2.gltfNode;
      const runtimeNode = runtimeNodes[n2.id];
      if (runtimeNode.parents.length === 0) {
        if (defined_default(gltfNode.matrix)) {
          runtimeNode.matrix = Matrix4_default.fromColumnMajorArray(gltfNode.matrix);
        } else {
          const rotation = gltfNode.rotation;
          runtimeNode.translation = Cartesian3_default.fromArray(gltfNode.translation);
          runtimeNode.rotation = Quaternion_default.unpack(rotation);
          runtimeNode.scale = Cartesian3_default.fromArray(gltfNode.scale);
        }
      }
      if (defined_default(parentRuntimeNode)) {
        parentRuntimeNode.children.push(runtimeNode);
        runtimeNode.parents.push(parentRuntimeNode);
      } else {
        rootNodes.push(runtimeNode);
      }
      if (defined_default(gltfNode.mesh)) {
        createCommand(model, gltfNode, runtimeNode, context, scene3DOnly);
      }
      const children = gltfNode.children;
      if (defined_default(children)) {
        const childrenLength = children.length;
        for (let j = 0; j < childrenLength; j++) {
          const childId = children[j];
          if (!seen[childId]) {
            stack.push({
              parentRuntimeNode: runtimeNode,
              gltfNode: nodes[childId],
              id: children[j]
            });
          }
        }
      }
    }
  }
  model._runtime.rootNodes = rootNodes;
  model._runtime.nodes = runtimeNodes;
}
function getGeometryByteLength(buffers) {
  let memory = 0;
  for (const id in buffers) {
    if (buffers.hasOwnProperty(id)) {
      memory += buffers[id].sizeInBytes;
    }
  }
  return memory;
}
function getTexturesByteLength(textures) {
  let memory = 0;
  for (const id in textures) {
    if (textures.hasOwnProperty(id)) {
      memory += textures[id].sizeInBytes;
    }
  }
  return memory;
}
function createResources2(model, frameState) {
  const context = frameState.context;
  const scene3DOnly = frameState.scene3DOnly;
  const quantizedVertexShaders = model._quantizedVertexShaders;
  const techniques = model._sourceTechniques;
  const programs = model._sourcePrograms;
  const resources = model._rendererResources;
  let shaders = resources.sourceShaders;
  if (model._loadRendererResourcesFromCache) {
    shaders = resources.sourceShaders = model._cachedRendererResources.sourceShaders;
  }
  for (const techniqueId in techniques) {
    if (techniques.hasOwnProperty(techniqueId)) {
      const programId = techniques[techniqueId].program;
      const program = programs[programId];
      let shader = shaders[program.vertexShader];
      ModelUtility_default.checkSupportedGlExtensions(program.glExtensions, context);
      if (model.extensionsUsed.WEB3D_quantized_attributes || model._dequantizeInShader) {
        let quantizedVS = quantizedVertexShaders[programId];
        if (!defined_default(quantizedVS)) {
          quantizedVS = modifyShaderForQuantizedAttributes2(
            shader,
            programId,
            model
          );
          quantizedVertexShaders[programId] = quantizedVS;
        }
        shader = quantizedVS;
      }
      shader = modifyShader2(shader, programId, model._vertexShaderLoaded);
    }
  }
  if (model._loadRendererResourcesFromCache) {
    const cachedResources = model._cachedRendererResources;
    resources.buffers = cachedResources.buffers;
    resources.vertexArrays = cachedResources.vertexArrays;
    resources.programs = cachedResources.programs;
    resources.silhouettePrograms = cachedResources.silhouettePrograms;
    resources.textures = cachedResources.textures;
    resources.samplers = cachedResources.samplers;
    resources.renderStates = cachedResources.renderStates;
    if (defined_default(model._precreatedAttributes)) {
      createVertexArrays(model, context);
    }
    model._cachedGeometryByteLength += getGeometryByteLength(
      cachedResources.buffers
    );
    model._cachedTexturesByteLength += getTexturesByteLength(
      cachedResources.textures
    );
  } else {
    createBuffers2(model, frameState);
    createPrograms(model, frameState);
    createSamplers(model, context);
    loadTexturesFromBufferViews(model);
    createTextures(model, frameState);
  }
  createSkins(model);
  createRuntimeAnimations(model);
  if (!model._loadRendererResourcesFromCache) {
    createVertexArrays(model, context);
    createRenderStates4(model);
  }
  createUniformMaps(model, context);
  createRuntimeNodes2(model, context, scene3DOnly);
}
function getNodeMatrix(node, result) {
  const publicNode = node.publicNode;
  const publicMatrix = publicNode.matrix;
  if (publicNode.useMatrix && defined_default(publicMatrix)) {
    Matrix4_default.clone(publicMatrix, result);
  } else if (defined_default(node.matrix)) {
    Matrix4_default.clone(node.matrix, result);
  } else {
    Matrix4_default.fromTranslationQuaternionRotationScale(
      node.translation,
      node.rotation,
      node.scale,
      result
    );
    publicNode.setMatrix(result);
  }
}
var scratchNodeStack = [];
var scratchComputedTranslation2 = new Cartesian4_default();
var scratchComputedMatrixIn2D2 = new Matrix4_default();
function updateNodeHierarchyModelMatrix(model, modelTransformChanged, justLoaded, projection) {
  const maxDirtyNumber = model._maxDirtyNumber;
  const rootNodes = model._runtime.rootNodes;
  const length3 = rootNodes.length;
  const nodeStack = scratchNodeStack;
  let computedModelMatrix = model._computedModelMatrix;
  if (model._mode !== SceneMode_default.SCENE3D && !model._ignoreCommands) {
    const translation3 = Matrix4_default.getColumn(
      computedModelMatrix,
      3,
      scratchComputedTranslation2
    );
    if (!Cartesian4_default.equals(translation3, Cartesian4_default.UNIT_W)) {
      computedModelMatrix = Transforms_default.basisTo2D(
        projection,
        computedModelMatrix,
        scratchComputedMatrixIn2D2
      );
      model._rtcCenter = model._rtcCenter3D;
    } else {
      const center = model.boundingSphere.center;
      const to2D = Transforms_default.wgs84To2DModelMatrix(
        projection,
        center,
        scratchComputedMatrixIn2D2
      );
      computedModelMatrix = Matrix4_default.multiply(
        to2D,
        computedModelMatrix,
        scratchComputedMatrixIn2D2
      );
      if (defined_default(model._rtcCenter)) {
        Matrix4_default.setTranslation(
          computedModelMatrix,
          Cartesian4_default.UNIT_W,
          computedModelMatrix
        );
        model._rtcCenter = model._rtcCenter2D;
      }
    }
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    let n2 = rootNodes[i2];
    getNodeMatrix(n2, n2.transformToRoot);
    nodeStack.push(n2);
    while (nodeStack.length > 0) {
      n2 = nodeStack.pop();
      const transformToRoot = n2.transformToRoot;
      const commands = n2.commands;
      if (n2.dirtyNumber === maxDirtyNumber || modelTransformChanged || justLoaded) {
        const nodeMatrix = Matrix4_default.multiplyTransformation(
          computedModelMatrix,
          transformToRoot,
          n2.computedMatrix
        );
        const commandsLength = commands.length;
        if (commandsLength > 0) {
          for (let j = 0; j < commandsLength; ++j) {
            const primitiveCommand = commands[j];
            let command = primitiveCommand.command;
            Matrix4_default.clone(nodeMatrix, command.modelMatrix);
            BoundingSphere_default.transform(
              primitiveCommand.boundingSphere,
              command.modelMatrix,
              command.boundingVolume
            );
            if (defined_default(model._rtcCenter)) {
              Cartesian3_default.add(
                model._rtcCenter,
                command.boundingVolume.center,
                command.boundingVolume.center
              );
            }
            command = primitiveCommand.command2D;
            if (defined_default(command) && model._mode === SceneMode_default.SCENE2D) {
              Matrix4_default.clone(nodeMatrix, command.modelMatrix);
              command.modelMatrix[13] -= Math_default.sign(command.modelMatrix[13]) * 2 * Math_default.PI * projection.ellipsoid.maximumRadius;
              BoundingSphere_default.transform(
                primitiveCommand.boundingSphere,
                command.modelMatrix,
                command.boundingVolume
              );
            }
          }
        }
      }
      const children = n2.children;
      if (defined_default(children)) {
        const childrenLength = children.length;
        for (let k = 0; k < childrenLength; ++k) {
          const child = children[k];
          child.dirtyNumber = Math.max(child.dirtyNumber, n2.dirtyNumber);
          if (child.dirtyNumber === maxDirtyNumber || justLoaded) {
            getNodeMatrix(child, child.transformToRoot);
            Matrix4_default.multiplyTransformation(
              transformToRoot,
              child.transformToRoot,
              child.transformToRoot
            );
          }
          nodeStack.push(child);
        }
      }
    }
  }
  ++model._maxDirtyNumber;
}
var scratchObjectSpace = new Matrix4_default();
function applySkins(model) {
  const skinnedNodes = model._runtime.skinnedNodes;
  const length3 = skinnedNodes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const node = skinnedNodes[i2];
    scratchObjectSpace = Matrix4_default.inverseTransformation(
      node.transformToRoot,
      scratchObjectSpace
    );
    const computedJointMatrices = node.computedJointMatrices;
    const joints = node.joints;
    const bindShapeMatrix = node.bindShapeMatrix;
    const inverseBindMatrices = node.inverseBindMatrices;
    const inverseBindMatricesLength = inverseBindMatrices.length;
    for (let m = 0; m < inverseBindMatricesLength; ++m) {
      if (!defined_default(computedJointMatrices[m])) {
        computedJointMatrices[m] = new Matrix4_default();
      }
      computedJointMatrices[m] = Matrix4_default.multiplyTransformation(
        scratchObjectSpace,
        joints[m].transformToRoot,
        computedJointMatrices[m]
      );
      computedJointMatrices[m] = Matrix4_default.multiplyTransformation(
        computedJointMatrices[m],
        inverseBindMatrices[m],
        computedJointMatrices[m]
      );
      if (defined_default(bindShapeMatrix)) {
        computedJointMatrices[m] = Matrix4_default.multiplyTransformation(
          computedJointMatrices[m],
          bindShapeMatrix,
          computedJointMatrices[m]
        );
      }
    }
  }
}
function updatePerNodeShow(model) {
  const rootNodes = model._runtime.rootNodes;
  const length3 = rootNodes.length;
  const nodeStack = scratchNodeStack;
  for (let i2 = 0; i2 < length3; ++i2) {
    let n2 = rootNodes[i2];
    n2.computedShow = n2.publicNode.show;
    nodeStack.push(n2);
    while (nodeStack.length > 0) {
      n2 = nodeStack.pop();
      const show = n2.computedShow;
      const nodeCommands = n2.commands;
      const nodeCommandsLength = nodeCommands.length;
      for (let j = 0; j < nodeCommandsLength; ++j) {
        nodeCommands[j].show = show;
      }
      const children = n2.children;
      if (defined_default(children)) {
        const childrenLength = children.length;
        for (let k = 0; k < childrenLength; ++k) {
          const child = children[k];
          child.computedShow = show && child.publicNode.show;
          nodeStack.push(child);
        }
      }
    }
  }
}
function updatePickIds(model, context) {
  const id = model.id;
  if (model._id !== id) {
    model._id = id;
    const pickIds = model._pickIds;
    const length3 = pickIds.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      pickIds[i2].object.id = id;
    }
  }
}
function updateWireframe2(model) {
  if (model._debugWireframe !== model.debugWireframe) {
    model._debugWireframe = model.debugWireframe;
    const primitiveType = model.debugWireframe ? PrimitiveType_default.LINES : PrimitiveType_default.TRIANGLES;
    const nodeCommands = model._nodeCommands;
    const length3 = nodeCommands.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      nodeCommands[i2].command.primitiveType = primitiveType;
    }
  }
}
function updateShowBoundingVolume(model) {
  if (model.debugShowBoundingVolume !== model._debugShowBoundingVolume) {
    model._debugShowBoundingVolume = model.debugShowBoundingVolume;
    const debugShowBoundingVolume2 = model.debugShowBoundingVolume;
    const nodeCommands = model._nodeCommands;
    const length3 = nodeCommands.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      nodeCommands[i2].command.debugShowBoundingVolume = debugShowBoundingVolume2;
    }
  }
}
function updateShadows(model) {
  if (model.shadows !== model._shadows) {
    model._shadows = model.shadows;
    const castShadows = ShadowMode_default.castShadows(model.shadows);
    const receiveShadows = ShadowMode_default.receiveShadows(model.shadows);
    const nodeCommands = model._nodeCommands;
    const length3 = nodeCommands.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const nodeCommand = nodeCommands[i2];
      nodeCommand.command.castShadows = castShadows;
      nodeCommand.command.receiveShadows = receiveShadows;
    }
  }
}
function getTranslucentRenderState2(model, renderState) {
  const rs = clone_default(renderState, true);
  rs.cull.enabled = false;
  rs.depthTest.enabled = true;
  rs.depthMask = false;
  rs.blending = BlendingState_default.ALPHA_BLEND;
  if (model.opaquePass === Pass_default.CESIUM_3D_TILE) {
    rs.stencilTest = StencilConstants_default.setCesium3DTileBit();
    rs.stencilMask = StencilConstants_default.CESIUM_3D_TILE_MASK;
  }
  return RenderState_default.fromCache(rs);
}
function deriveTranslucentCommand2(model, command) {
  const translucentCommand = DrawCommand_default.shallowClone(command);
  translucentCommand.pass = Pass_default.TRANSLUCENT;
  translucentCommand.renderState = getTranslucentRenderState2(
    model,
    command.renderState
  );
  return translucentCommand;
}
function updateColor(model, frameState, forceDerive) {
  const scene3DOnly = frameState.scene3DOnly;
  const alpha = model.color.alpha;
  if (alpha > 0 && alpha < 1) {
    const nodeCommands = model._nodeCommands;
    const length3 = nodeCommands.length;
    if (length3 > 0 && (!defined_default(nodeCommands[0].translucentCommand) || forceDerive)) {
      for (let i2 = 0; i2 < length3; ++i2) {
        const nodeCommand = nodeCommands[i2];
        const command = nodeCommand.command;
        nodeCommand.translucentCommand = deriveTranslucentCommand2(
          model,
          command
        );
        if (!scene3DOnly) {
          const command2D = nodeCommand.command2D;
          nodeCommand.translucentCommand2D = deriveTranslucentCommand2(
            model,
            command2D
          );
        }
      }
    }
  }
}
function getDisableCullingRenderState(renderState) {
  const rs = clone_default(renderState, true);
  rs.cull.enabled = false;
  return RenderState_default.fromCache(rs);
}
function deriveDisableCullingCommand(command) {
  const disableCullingCommand = DrawCommand_default.shallowClone(command);
  disableCullingCommand.renderState = getDisableCullingRenderState(
    command.renderState
  );
  return disableCullingCommand;
}
function updateBackFaceCulling(model, frameState, forceDerive) {
  const scene3DOnly = frameState.scene3DOnly;
  const backFaceCulling = model.backFaceCulling;
  if (!backFaceCulling) {
    const nodeCommands = model._nodeCommands;
    const length3 = nodeCommands.length;
    if (length3 > 0 && (!defined_default(nodeCommands[0].disableCullingCommand) || forceDerive)) {
      for (let i2 = 0; i2 < length3; ++i2) {
        const nodeCommand = nodeCommands[i2];
        const command = nodeCommand.command;
        nodeCommand.disableCullingCommand = deriveDisableCullingCommand(
          command
        );
        if (!scene3DOnly) {
          const command2D = nodeCommand.command2D;
          nodeCommand.disableCullingCommand2D = deriveDisableCullingCommand(
            command2D
          );
        }
      }
    }
  }
}
function getProgramId(model, program) {
  const programs = model._rendererResources.programs;
  for (const id in programs) {
    if (programs.hasOwnProperty(id)) {
      if (programs[id] === program) {
        return id;
      }
    }
  }
}
function createSilhouetteProgram(model, program, frameState) {
  let vs = program.vertexShaderSource.sources[0];
  const attributeLocations8 = program._attributeLocations;
  const normalAttributeName = model._normalAttributeName;
  vs = ShaderSource_default.replaceMain(vs, "gltf_silhouette_main");
  vs += `${"uniform float gltf_silhouetteSize; \nvoid main() \n{ \n    gltf_silhouette_main(); \n    vec3 n = normalize(czm_normal3D * "}${normalAttributeName}); 
    n.x *= czm_projection[0][0]; 
    n.y *= czm_projection[1][1]; 
    vec4 clip = gl_Position; 
    clip.xy += n.xy * clip.w * gltf_silhouetteSize * czm_pixelRatio / czm_viewport.z; 
    gl_Position = clip; 
}`;
  const fs = "uniform vec4 gltf_silhouetteColor; \nvoid main() \n{ \n    gl_FragColor = czm_gammaCorrect(gltf_silhouetteColor); \n}";
  return ShaderProgram_default.fromCache({
    context: frameState.context,
    vertexShaderSource: vs,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations8
  });
}
function hasSilhouette(model, frameState) {
  return silhouetteSupported(frameState.context) && model.silhouetteSize > 0 && model.silhouetteColor.alpha > 0 && defined_default(model._normalAttributeName);
}
function hasTranslucentCommands(model) {
  const nodeCommands = model._nodeCommands;
  const length3 = nodeCommands.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const nodeCommand = nodeCommands[i2];
    const command = nodeCommand.command;
    if (command.pass === Pass_default.TRANSLUCENT) {
      return true;
    }
  }
  return false;
}
function isTranslucent(model) {
  return model.color.alpha > 0 && model.color.alpha < 1;
}
function isInvisible(model) {
  return model.color.alpha === 0;
}
function alphaDirty(currAlpha, prevAlpha) {
  return Math.floor(currAlpha) !== Math.floor(prevAlpha) || Math.ceil(currAlpha) !== Math.ceil(prevAlpha);
}
var silhouettesLength = 0;
function createSilhouetteCommands(model, frameState) {
  const stencilReference = ++silhouettesLength % 255;
  const silhouetteTranslucent = hasTranslucentCommands(model) || isTranslucent(model) || model.silhouetteColor.alpha < 1;
  const silhouettePrograms = model._rendererResources.silhouettePrograms;
  const scene3DOnly = frameState.scene3DOnly;
  const nodeCommands = model._nodeCommands;
  const length3 = nodeCommands.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const nodeCommand = nodeCommands[i2];
    const command = nodeCommand.command;
    const modelCommand = isTranslucent(model) ? nodeCommand.translucentCommand : command;
    const silhouetteModelCommand = DrawCommand_default.shallowClone(modelCommand);
    let renderState = clone_default(modelCommand.renderState);
    renderState.stencilTest = {
      enabled: true,
      frontFunction: WebGLConstants_default.ALWAYS,
      backFunction: WebGLConstants_default.ALWAYS,
      reference: stencilReference,
      mask: ~0,
      frontOperation: {
        fail: WebGLConstants_default.KEEP,
        zFail: WebGLConstants_default.KEEP,
        zPass: WebGLConstants_default.REPLACE
      },
      backOperation: {
        fail: WebGLConstants_default.KEEP,
        zFail: WebGLConstants_default.KEEP,
        zPass: WebGLConstants_default.REPLACE
      }
    };
    if (isInvisible(model)) {
      renderState.colorMask = {
        red: false,
        green: false,
        blue: false,
        alpha: false
      };
      renderState.depthMask = false;
    }
    renderState = RenderState_default.fromCache(renderState);
    silhouetteModelCommand.renderState = renderState;
    nodeCommand.silhouetteModelCommand = silhouetteModelCommand;
    const silhouetteColorCommand = DrawCommand_default.shallowClone(command);
    renderState = clone_default(command.renderState, true);
    renderState.depthTest.enabled = true;
    renderState.cull.enabled = false;
    if (silhouetteTranslucent) {
      silhouetteColorCommand.pass = Pass_default.TRANSLUCENT;
      renderState.depthMask = false;
      renderState.blending = BlendingState_default.ALPHA_BLEND;
    }
    renderState.stencilTest = {
      enabled: true,
      frontFunction: WebGLConstants_default.NOTEQUAL,
      backFunction: WebGLConstants_default.NOTEQUAL,
      reference: stencilReference,
      mask: ~0,
      frontOperation: {
        fail: WebGLConstants_default.KEEP,
        zFail: WebGLConstants_default.KEEP,
        zPass: WebGLConstants_default.KEEP
      },
      backOperation: {
        fail: WebGLConstants_default.KEEP,
        zFail: WebGLConstants_default.KEEP,
        zPass: WebGLConstants_default.KEEP
      }
    };
    renderState = RenderState_default.fromCache(renderState);
    const program = command.shaderProgram;
    const id = getProgramId(model, program);
    let silhouetteProgram = silhouettePrograms[id];
    if (!defined_default(silhouetteProgram)) {
      silhouetteProgram = createSilhouetteProgram(model, program, frameState);
      silhouettePrograms[id] = silhouetteProgram;
    }
    const silhouetteUniformMap = combine_default(command.uniformMap, {
      gltf_silhouetteColor: createSilhouetteColorFunction(model),
      gltf_silhouetteSize: createSilhouetteSizeFunction(model)
    });
    silhouetteColorCommand.renderState = renderState;
    silhouetteColorCommand.shaderProgram = silhouetteProgram;
    silhouetteColorCommand.uniformMap = silhouetteUniformMap;
    silhouetteColorCommand.castShadows = false;
    silhouetteColorCommand.receiveShadows = false;
    nodeCommand.silhouetteColorCommand = silhouetteColorCommand;
    if (!scene3DOnly) {
      const command2D = nodeCommand.command2D;
      const silhouetteModelCommand2D = DrawCommand_default.shallowClone(
        silhouetteModelCommand
      );
      silhouetteModelCommand2D.boundingVolume = command2D.boundingVolume;
      silhouetteModelCommand2D.modelMatrix = command2D.modelMatrix;
      nodeCommand.silhouetteModelCommand2D = silhouetteModelCommand2D;
      const silhouetteColorCommand2D = DrawCommand_default.shallowClone(
        silhouetteColorCommand
      );
      silhouetteModelCommand2D.boundingVolume = command2D.boundingVolume;
      silhouetteModelCommand2D.modelMatrix = command2D.modelMatrix;
      nodeCommand.silhouetteColorCommand2D = silhouetteColorCommand2D;
    }
  }
}
function modifyShaderForClippingPlanes(shader, clippingPlaneCollection, context) {
  shader = ShaderSource_default.replaceMain(shader, "gltf_clip_main");
  shader += `${Model._getClippingFunction(clippingPlaneCollection, context)}
`;
  shader += `${"uniform highp sampler2D gltf_clippingPlanes; \nuniform mat4 gltf_clippingPlanesMatrix; \nuniform vec4 gltf_clippingPlanesEdgeStyle; \nvoid main() \n{ \n    gltf_clip_main(); \n"}${getClipAndStyleCode_default(
    "gltf_clippingPlanes",
    "gltf_clippingPlanesMatrix",
    "gltf_clippingPlanesEdgeStyle"
  )}} 
`;
  return shader;
}
function updateSilhouette(model, frameState, force) {
  if (!hasSilhouette(model, frameState)) {
    return;
  }
  const nodeCommands = model._nodeCommands;
  const dirty = nodeCommands.length > 0 && (alphaDirty(model.color.alpha, model._colorPreviousAlpha) || alphaDirty(
    model.silhouetteColor.alpha,
    model._silhouetteColorPreviousAlpha
  ) || !defined_default(nodeCommands[0].silhouetteModelCommand));
  model._colorPreviousAlpha = model.color.alpha;
  model._silhouetteColorPreviousAlpha = model.silhouetteColor.alpha;
  if (dirty || force) {
    createSilhouetteCommands(model, frameState);
  }
}
function updateClippingPlanes(model, frameState) {
  const clippingPlanes = model._clippingPlanes;
  if (defined_default(clippingPlanes) && clippingPlanes.owner === model) {
    if (clippingPlanes.enabled) {
      clippingPlanes.update(frameState);
    }
  }
}
var scratchBoundingSphere4 = new BoundingSphere_default();
function scaleInPixels(positionWC2, radius, frameState) {
  scratchBoundingSphere4.center = positionWC2;
  scratchBoundingSphere4.radius = radius;
  return frameState.camera.getPixelSize(
    scratchBoundingSphere4,
    frameState.context.drawingBufferWidth,
    frameState.context.drawingBufferHeight
  );
}
var scratchPosition7 = new Cartesian3_default();
var scratchCartographic5 = new Cartographic_default();
function getScale(model, frameState) {
  let scale = model.scale;
  if (model.minimumPixelSize !== 0) {
    const context = frameState.context;
    const maxPixelSize = Math.max(
      context.drawingBufferWidth,
      context.drawingBufferHeight
    );
    const m = defined_default(model._clampedModelMatrix) ? model._clampedModelMatrix : model.modelMatrix;
    scratchPosition7.x = m[12];
    scratchPosition7.y = m[13];
    scratchPosition7.z = m[14];
    if (defined_default(model._rtcCenter)) {
      Cartesian3_default.add(model._rtcCenter, scratchPosition7, scratchPosition7);
    }
    if (model._mode !== SceneMode_default.SCENE3D) {
      const projection = frameState.mapProjection;
      const cartographic2 = projection.ellipsoid.cartesianToCartographic(
        scratchPosition7,
        scratchCartographic5
      );
      projection.project(cartographic2, scratchPosition7);
      Cartesian3_default.fromElements(
        scratchPosition7.z,
        scratchPosition7.x,
        scratchPosition7.y,
        scratchPosition7
      );
    }
    const radius = model.boundingSphere.radius;
    const metersPerPixel = scaleInPixels(scratchPosition7, radius, frameState);
    const pixelsPerMeter = 1 / metersPerPixel;
    const diameterInPixels = Math.min(
      pixelsPerMeter * (2 * radius),
      maxPixelSize
    );
    if (diameterInPixels < model.minimumPixelSize) {
      scale = model.minimumPixelSize * metersPerPixel / (2 * model._initialRadius);
    }
  }
  return defined_default(model.maximumScale) ? Math.min(model.maximumScale, scale) : scale;
}
function releaseCachedGltf(model) {
  if (defined_default(model._cacheKey) && defined_default(model._cachedGltf) && --model._cachedGltf.count === 0) {
    delete gltfCache[model._cacheKey];
  }
  model._cachedGltf = void 0;
}
function CachedRendererResources(context, cacheKey) {
  this.buffers = void 0;
  this.vertexArrays = void 0;
  this.programs = void 0;
  this.sourceShaders = void 0;
  this.silhouettePrograms = void 0;
  this.textures = void 0;
  this.samplers = void 0;
  this.renderStates = void 0;
  this.ready = false;
  this.context = context;
  this.cacheKey = cacheKey;
  this.count = 0;
}
function destroy(property) {
  for (const name in property) {
    if (property.hasOwnProperty(name)) {
      property[name].destroy();
    }
  }
}
function destroyCachedRendererResources(resources) {
  destroy(resources.buffers);
  destroy(resources.vertexArrays);
  destroy(resources.programs);
  destroy(resources.silhouettePrograms);
  destroy(resources.textures);
}
CachedRendererResources.prototype.release = function() {
  if (--this.count === 0) {
    if (defined_default(this.cacheKey)) {
      delete this.context.cache.modelRendererResourceCache[this.cacheKey];
    }
    destroyCachedRendererResources(this);
    return destroyObject_default(this);
  }
  return void 0;
};
function getUpdateHeightCallback(model, ellipsoid, cartoPosition) {
  return function(clampedPosition) {
    if (model.heightReference === HeightReference_default.RELATIVE_TO_GROUND) {
      const clampedCart = ellipsoid.cartesianToCartographic(
        clampedPosition,
        scratchCartographic5
      );
      clampedCart.height += cartoPosition.height;
      ellipsoid.cartographicToCartesian(clampedCart, clampedPosition);
    }
    const clampedModelMatrix = model._clampedModelMatrix;
    Matrix4_default.clone(model.modelMatrix, clampedModelMatrix);
    clampedModelMatrix[12] = clampedPosition.x;
    clampedModelMatrix[13] = clampedPosition.y;
    clampedModelMatrix[14] = clampedPosition.z;
    model._heightChanged = true;
  };
}
function updateClamping(model) {
  if (defined_default(model._removeUpdateHeightCallback)) {
    model._removeUpdateHeightCallback();
    model._removeUpdateHeightCallback = void 0;
  }
  const scene = model._scene;
  if (!defined_default(scene) || !defined_default(scene.globe) || model.heightReference === HeightReference_default.NONE) {
    if (model.heightReference !== HeightReference_default.NONE) {
      throw new DeveloperError_default(
        "Height reference is not supported without a scene and globe."
      );
    }
    model._clampedModelMatrix = void 0;
    return;
  }
  const globe = scene.globe;
  const ellipsoid = globe.ellipsoid;
  const modelMatrix = model.modelMatrix;
  scratchPosition7.x = modelMatrix[12];
  scratchPosition7.y = modelMatrix[13];
  scratchPosition7.z = modelMatrix[14];
  const cartoPosition = ellipsoid.cartesianToCartographic(scratchPosition7);
  if (!defined_default(model._clampedModelMatrix)) {
    model._clampedModelMatrix = Matrix4_default.clone(modelMatrix, new Matrix4_default());
  }
  const surface = globe._surface;
  model._removeUpdateHeightCallback = surface.updateHeight(
    cartoPosition,
    getUpdateHeightCallback(model, ellipsoid, cartoPosition)
  );
  const height = globe.getHeight(cartoPosition);
  if (defined_default(height)) {
    const cb = getUpdateHeightCallback(model, ellipsoid, cartoPosition);
    Cartographic_default.clone(cartoPosition, scratchCartographic5);
    scratchCartographic5.height = height;
    ellipsoid.cartographicToCartesian(scratchCartographic5, scratchPosition7);
    cb(scratchPosition7);
  }
}
var scratchDisplayConditionCartesian = new Cartesian3_default();
var scratchDistanceDisplayConditionCartographic = new Cartographic_default();
function distanceDisplayConditionVisible(model, frameState) {
  let distance2;
  const ddc = model.distanceDisplayCondition;
  const nearSquared = ddc.near * ddc.near;
  const farSquared = ddc.far * ddc.far;
  if (frameState.mode === SceneMode_default.SCENE2D) {
    const frustum2DWidth = frameState.camera.frustum.right - frameState.camera.frustum.left;
    distance2 = frustum2DWidth * 0.5;
    distance2 = distance2 * distance2;
  } else {
    let position = Matrix4_default.getTranslation(
      model.modelMatrix,
      scratchDisplayConditionCartesian
    );
    if (frameState.mode === SceneMode_default.COLUMBUS_VIEW) {
      const projection = frameState.mapProjection;
      const ellipsoid = projection.ellipsoid;
      const cartographic2 = ellipsoid.cartesianToCartographic(
        position,
        scratchDistanceDisplayConditionCartographic
      );
      position = projection.project(cartographic2, position);
      Cartesian3_default.fromElements(position.z, position.x, position.y, position);
    }
    distance2 = Cartesian3_default.distanceSquared(
      position,
      frameState.camera.positionWC
    );
  }
  return distance2 >= nearSquared && distance2 <= farSquared;
}
var scratchIBLReferenceFrameMatrix4 = new Matrix4_default();
var scratchIBLReferenceFrameMatrix3 = new Matrix3_default();
var scratchClippingPlanesMatrix = new Matrix4_default();
Model.prototype.update = function(frameState) {
  if (frameState.mode === SceneMode_default.MORPHING) {
    return;
  }
  if (!FeatureDetection_default.supportsWebP.initialized) {
    FeatureDetection_default.supportsWebP.initialize();
    return;
  }
  const context = frameState.context;
  this._defaultTexture = context.defaultTexture;
  const supportsWebP2 = FeatureDetection_default.supportsWebP();
  if (this._state === ModelState2.NEEDS_LOAD && defined_default(this.gltf)) {
    let cachedRendererResources;
    const cacheKey = this.cacheKey;
    if (defined_default(cacheKey)) {
      context.cache.modelRendererResourceCache = defaultValue_default(
        context.cache.modelRendererResourceCache,
        {}
      );
      const modelCaches = context.cache.modelRendererResourceCache;
      cachedRendererResources = modelCaches[this.cacheKey];
      if (defined_default(cachedRendererResources)) {
        if (!cachedRendererResources.ready) {
          return;
        }
        ++cachedRendererResources.count;
        this._loadRendererResourcesFromCache = true;
      } else {
        cachedRendererResources = new CachedRendererResources(
          context,
          cacheKey
        );
        cachedRendererResources.count = 1;
        modelCaches[this.cacheKey] = cachedRendererResources;
      }
      this._cachedRendererResources = cachedRendererResources;
    } else {
      cachedRendererResources = new CachedRendererResources(context);
      cachedRendererResources.count = 1;
      this._cachedRendererResources = cachedRendererResources;
    }
    this._state = ModelState2.LOADING;
    if (this._state !== ModelState2.FAILED) {
      const extensions = this.gltf.extensions;
      if (defined_default(extensions) && defined_default(extensions.CESIUM_RTC)) {
        const center = Cartesian3_default.fromArray(extensions.CESIUM_RTC.center);
        if (!Cartesian3_default.equals(center, Cartesian3_default.ZERO)) {
          this._rtcCenter3D = center;
          const projection = frameState.mapProjection;
          const ellipsoid = projection.ellipsoid;
          const cartographic2 = ellipsoid.cartesianToCartographic(
            this._rtcCenter3D
          );
          const projectedCart = projection.project(cartographic2);
          Cartesian3_default.fromElements(
            projectedCart.z,
            projectedCart.x,
            projectedCart.y,
            projectedCart
          );
          this._rtcCenter2D = projectedCart;
          this._rtcCenterEye = new Cartesian3_default();
          this._rtcCenter = this._rtcCenter3D;
        }
      }
      addPipelineExtras_default(this.gltf);
      this._loadResources = new ModelLoadResources_default();
      if (!this._loadRendererResourcesFromCache) {
        ModelUtility_default.parseBuffers(this, bufferLoad);
      }
    }
  }
  const loadResources = this._loadResources;
  const incrementallyLoadTextures = this._incrementallyLoadTextures;
  let justLoaded = false;
  if (this._state === ModelState2.LOADING) {
    if (loadResources.pendingBufferLoads === 0) {
      if (!loadResources.initialized) {
        frameState.brdfLutGenerator.update(frameState);
        ModelUtility_default.checkSupportedExtensions(
          this.extensionsRequired,
          supportsWebP2
        );
        ModelUtility_default.updateForwardAxis(this);
        if (!defined_default(this.gltf.extras.sourceVersion)) {
          const gltf = this.gltf;
          gltf.extras.sourceVersion = ModelUtility_default.getAssetVersion(gltf);
          gltf.extras.sourceKHRTechniquesWebGL = defined_default(
            ModelUtility_default.getUsedExtensions(gltf).KHR_techniques_webgl
          );
          this._sourceVersion = gltf.extras.sourceVersion;
          this._sourceKHRTechniquesWebGL = gltf.extras.sourceKHRTechniquesWebGL;
          updateVersion_default(gltf);
          addDefaults_default(gltf);
          const options = {
            addBatchIdToGeneratedShaders: this._addBatchIdToGeneratedShaders
          };
          processModelMaterialsCommon_default(gltf, options);
          processPbrMaterials_default(gltf, options);
        }
        this._sourceVersion = this.gltf.extras.sourceVersion;
        this._sourceKHRTechniquesWebGL = this.gltf.extras.sourceKHRTechniquesWebGL;
        this._dequantizeInShader = this._dequantizeInShader && DracoLoader_default.hasExtension(this);
        addBuffersToLoadResources2(this);
        parseArticulations(this);
        parseTechniques(this);
        if (!this._loadRendererResourcesFromCache) {
          parseBufferViews2(this);
          parseShaders(this);
          parsePrograms(this);
          parseTextures(this, context, supportsWebP2);
        }
        parseMaterials(this);
        parseMeshes(this);
        parseNodes(this);
        parseCredits(this);
        DracoLoader_default.parse(this, context);
        loadResources.initialized = true;
      }
      if (!loadResources.finishedDecoding()) {
        DracoLoader_default.decodeModel(this, context).catch(
          ModelUtility_default.getFailedLoadFunction(this, "model", this.basePath)
        );
      }
      if (loadResources.finishedDecoding() && !loadResources.resourcesParsed) {
        this._boundingSphere = ModelUtility_default.computeBoundingSphere(this);
        this._initialRadius = this._boundingSphere.radius;
        DracoLoader_default.cacheDataForModel(this);
        loadResources.resourcesParsed = true;
      }
      if (loadResources.resourcesParsed && loadResources.pendingShaderLoads === 0) {
        if (this.showOutline) {
          ModelOutlineLoader_default.outlinePrimitives(this);
        }
        createResources2(this, frameState);
      }
    }
    if (loadResources.finished() || incrementallyLoadTextures && loadResources.finishedEverythingButTextureCreation()) {
      this._state = ModelState2.LOADED;
      justLoaded = true;
    }
  }
  if (defined_default(loadResources) && this._state === ModelState2.LOADED) {
    if (incrementallyLoadTextures && !justLoaded) {
      createResources2(this, frameState);
    }
    if (loadResources.finished()) {
      this._loadResources = void 0;
      const resources = this._rendererResources;
      const cachedResources = this._cachedRendererResources;
      cachedResources.buffers = resources.buffers;
      cachedResources.vertexArrays = resources.vertexArrays;
      cachedResources.programs = resources.programs;
      cachedResources.sourceShaders = resources.sourceShaders;
      cachedResources.silhouettePrograms = resources.silhouettePrograms;
      cachedResources.textures = resources.textures;
      cachedResources.samplers = resources.samplers;
      cachedResources.renderStates = resources.renderStates;
      cachedResources.ready = true;
      this._normalAttributeName = ModelUtility_default.getAttributeOrUniformBySemantic(
        this.gltf,
        "NORMAL"
      );
      if (defined_default(this._precreatedAttributes)) {
        cachedResources.vertexArrays = {};
      }
      if (this.releaseGltfJson) {
        releaseCachedGltf(this);
      }
    }
  }
  const silhouette = hasSilhouette(this, frameState);
  const translucent = isTranslucent(this);
  const invisible = isInvisible(this);
  const backFaceCulling = this.backFaceCulling;
  const displayConditionPassed = defined_default(this.distanceDisplayCondition) ? distanceDisplayConditionVisible(this, frameState) : true;
  const show = this.show && displayConditionPassed && this.scale !== 0 && (!invisible || silhouette);
  this._imageBasedLighting.update(frameState);
  if (show && this._state === ModelState2.LOADED || justLoaded) {
    const animated = this.activeAnimations.update(frameState) || this._cesiumAnimationsDirty;
    this._cesiumAnimationsDirty = false;
    this._dirty = false;
    let modelMatrix = this.modelMatrix;
    const modeChanged = frameState.mode !== this._mode;
    this._mode = frameState.mode;
    const modelTransformChanged = !Matrix4_default.equals(this._modelMatrix, modelMatrix) || this._scale !== this.scale || this._minimumPixelSize !== this.minimumPixelSize || this.minimumPixelSize !== 0 || this._maximumScale !== this.maximumScale || this._heightReference !== this.heightReference || this._heightChanged || modeChanged;
    if (modelTransformChanged || justLoaded) {
      Matrix4_default.clone(modelMatrix, this._modelMatrix);
      updateClamping(this);
      if (defined_default(this._clampedModelMatrix)) {
        modelMatrix = this._clampedModelMatrix;
      }
      this._scale = this.scale;
      this._minimumPixelSize = this.minimumPixelSize;
      this._maximumScale = this.maximumScale;
      this._heightReference = this.heightReference;
      this._heightChanged = false;
      const scale = getScale(this, frameState);
      const computedModelMatrix = this._computedModelMatrix;
      Matrix4_default.multiplyByUniformScale(modelMatrix, scale, computedModelMatrix);
      if (this._upAxis === Axis_default.Y) {
        Matrix4_default.multiplyTransformation(
          computedModelMatrix,
          Axis_default.Y_UP_TO_Z_UP,
          computedModelMatrix
        );
      } else if (this._upAxis === Axis_default.X) {
        Matrix4_default.multiplyTransformation(
          computedModelMatrix,
          Axis_default.X_UP_TO_Z_UP,
          computedModelMatrix
        );
      }
      if (this.forwardAxis === Axis_default.Z) {
        Matrix4_default.multiplyTransformation(
          computedModelMatrix,
          Axis_default.Z_UP_TO_X_UP,
          computedModelMatrix
        );
      }
    }
    if (animated || modelTransformChanged || justLoaded) {
      updateNodeHierarchyModelMatrix(
        this,
        modelTransformChanged,
        justLoaded,
        frameState.mapProjection
      );
      this._dirty = true;
      if (animated || justLoaded) {
        applySkins(this);
      }
    }
    if (this._perNodeShowDirty) {
      this._perNodeShowDirty = false;
      updatePerNodeShow(this);
    }
    updatePickIds(this, context);
    updateWireframe2(this);
    updateShowBoundingVolume(this);
    updateShadows(this);
    updateClippingPlanes(this, frameState);
    const clippingPlanes = this._clippingPlanes;
    let currentClippingPlanesState = 0;
    const referenceMatrix = defaultValue_default(this.referenceMatrix, modelMatrix);
    if (this._imageBasedLighting.useSphericalHarmonicCoefficients || this._imageBasedLighting.useSpecularEnvironmentMaps) {
      let iblReferenceFrameMatrix3 = scratchIBLReferenceFrameMatrix3;
      let iblReferenceFrameMatrix4 = scratchIBLReferenceFrameMatrix4;
      iblReferenceFrameMatrix4 = Matrix4_default.multiply(
        context.uniformState.view3D,
        referenceMatrix,
        iblReferenceFrameMatrix4
      );
      iblReferenceFrameMatrix3 = Matrix4_default.getMatrix3(
        iblReferenceFrameMatrix4,
        iblReferenceFrameMatrix3
      );
      iblReferenceFrameMatrix3 = Matrix3_default.getRotation(
        iblReferenceFrameMatrix3,
        iblReferenceFrameMatrix3
      );
      this._iblReferenceFrameMatrix = Matrix3_default.transpose(
        iblReferenceFrameMatrix3,
        this._iblReferenceFrameMatrix
      );
    }
    this._shouldRegenerateShaders = this._shouldRegenerateShaders || this._imageBasedLighting.shouldRegenerateShaders;
    if (isClippingEnabled(this)) {
      let clippingPlanesMatrix = scratchClippingPlanesMatrix;
      clippingPlanesMatrix = Matrix4_default.multiply(
        context.uniformState.view3D,
        referenceMatrix,
        clippingPlanesMatrix
      );
      clippingPlanesMatrix = Matrix4_default.multiply(
        clippingPlanesMatrix,
        clippingPlanes.modelMatrix,
        clippingPlanesMatrix
      );
      this._clippingPlanesMatrix = Matrix4_default.inverseTranspose(
        clippingPlanesMatrix,
        this._clippingPlanesMatrix
      );
      currentClippingPlanesState = clippingPlanes.clippingPlanesState;
    }
    this._shouldRegenerateShaders = this._shouldRegenerateShaders || this._clippingPlanesState !== currentClippingPlanesState;
    this._clippingPlanesState = currentClippingPlanesState;
    const currentlyColorShadingEnabled = isColorShadingEnabled(this);
    if (currentlyColorShadingEnabled !== this._colorShadingEnabled) {
      this._colorShadingEnabled = currentlyColorShadingEnabled;
      this._shouldRegenerateShaders = true;
    }
    const splittingEnabled = this.splitDirection !== SplitDirection_default.NONE;
    if (this._splittingEnabled !== splittingEnabled) {
      this._splittingEnabled = splittingEnabled;
      this._shouldRegenerateShaders = true;
    }
    if (this._shouldRegenerateShaders) {
      regenerateShaders(this, frameState);
    } else {
      updateColor(this, frameState, false);
      updateBackFaceCulling(this, frameState, false);
      updateSilhouette(this, frameState, false);
    }
  }
  if (justLoaded) {
    const model = this;
    frameState.afterRender.push(function() {
      model._ready = true;
      model._readyPromise.resolve(model);
    });
    return;
  }
  if (show && !this._ignoreCommands) {
    const commandList = frameState.commandList;
    const passes = frameState.passes;
    const nodeCommands = this._nodeCommands;
    const length3 = nodeCommands.length;
    let i2;
    let nc;
    const idl2D = frameState.mapProjection.ellipsoid.maximumRadius * Math_default.PI;
    let boundingVolume;
    if (passes.render || passes.pick && this.allowPicking) {
      for (i2 = 0; i2 < length3; ++i2) {
        nc = nodeCommands[i2];
        if (nc.show) {
          let command = nc.command;
          if (silhouette) {
            command = nc.silhouetteModelCommand;
          } else if (translucent) {
            command = nc.translucentCommand;
          } else if (!backFaceCulling) {
            command = nc.disableCullingCommand;
          }
          commandList.push(command);
          boundingVolume = nc.command.boundingVolume;
          if (frameState.mode === SceneMode_default.SCENE2D && (boundingVolume.center.y + boundingVolume.radius > idl2D || boundingVolume.center.y - boundingVolume.radius < idl2D)) {
            let command2D = nc.command2D;
            if (silhouette) {
              command2D = nc.silhouetteModelCommand2D;
            } else if (translucent) {
              command2D = nc.translucentCommand2D;
            } else if (!backFaceCulling) {
              command2D = nc.disableCullingCommand2D;
            }
            commandList.push(command2D);
          }
        }
      }
      if (silhouette && !passes.pick) {
        for (i2 = 0; i2 < length3; ++i2) {
          nc = nodeCommands[i2];
          if (nc.show) {
            commandList.push(nc.silhouetteColorCommand);
            boundingVolume = nc.command.boundingVolume;
            if (frameState.mode === SceneMode_default.SCENE2D && (boundingVolume.center.y + boundingVolume.radius > idl2D || boundingVolume.center.y - boundingVolume.radius < idl2D)) {
              commandList.push(nc.silhouetteColorCommand2D);
            }
          }
        }
      }
    }
  }
  const credit = this._credit;
  if (defined_default(credit)) {
    frameState.creditDisplay.addCredit(credit);
  }
  const resourceCredits = this._resourceCredits;
  const resourceCreditsLength = resourceCredits.length;
  for (let c14 = 0; c14 < resourceCreditsLength; c14++) {
    frameState.creditDisplay.addCredit(resourceCredits[c14]);
  }
  const gltfCredits = this._gltfCredits;
  const gltfCreditsLength = gltfCredits.length;
  for (let c14 = 0; c14 < gltfCreditsLength; c14++) {
    frameState.creditDisplay.addCredit(gltfCredits[c14]);
  }
};
function destroyIfNotCached(rendererResources, cachedRendererResources) {
  if (rendererResources.programs !== cachedRendererResources.programs) {
    destroy(rendererResources.programs);
  }
  if (rendererResources.silhouettePrograms !== cachedRendererResources.silhouettePrograms) {
    destroy(rendererResources.silhouettePrograms);
  }
}
function regenerateShaders(model, frameState) {
  const rendererResources = model._rendererResources;
  const cachedRendererResources = model._cachedRendererResources;
  destroyIfNotCached(rendererResources, cachedRendererResources);
  let programId;
  if (isClippingEnabled(model) || isColorShadingEnabled(model) || model.splitDirection !== SplitDirection_default.NONE || model._shouldRegenerateShaders) {
    model._shouldRegenerateShaders = false;
    rendererResources.programs = {};
    rendererResources.silhouettePrograms = {};
    const visitedPrograms = {};
    const techniques = model._sourceTechniques;
    let technique;
    for (const techniqueId in techniques) {
      if (techniques.hasOwnProperty(techniqueId)) {
        technique = techniques[techniqueId];
        programId = technique.program;
        if (!visitedPrograms[programId]) {
          visitedPrograms[programId] = true;
          recreateProgram(
            {
              programId,
              techniqueId
            },
            model,
            frameState.context
          );
        }
      }
    }
  } else {
    rendererResources.programs = cachedRendererResources.programs;
    rendererResources.silhouettePrograms = cachedRendererResources.silhouettePrograms;
  }
  const rendererPrograms = rendererResources.programs;
  const nodeCommands = model._nodeCommands;
  const commandCount = nodeCommands.length;
  for (let i2 = 0; i2 < commandCount; ++i2) {
    const nodeCommand = nodeCommands[i2];
    programId = nodeCommand.programId;
    const renderProgram = rendererPrograms[programId];
    nodeCommand.command.shaderProgram = renderProgram;
    if (defined_default(nodeCommand.command2D)) {
      nodeCommand.command2D.shaderProgram = renderProgram;
    }
  }
  updateColor(model, frameState, true);
  updateBackFaceCulling(model, frameState, true);
  updateSilhouette(model, frameState, true);
}
Model.prototype.isDestroyed = function() {
  return false;
};
Model.prototype.destroy = function() {
  if (defined_default(this._precreatedAttributes)) {
    destroy(this._rendererResources.vertexArrays);
  }
  if (defined_default(this._removeUpdateHeightCallback)) {
    this._removeUpdateHeightCallback();
    this._removeUpdateHeightCallback = void 0;
  }
  if (defined_default(this._terrainProviderChangedCallback)) {
    this._terrainProviderChangedCallback();
    this._terrainProviderChangedCallback = void 0;
  }
  if (defined_default(this._cachedRendererResources)) {
    destroyIfNotCached(this._rendererResources, this._cachedRendererResources);
  }
  this._rendererResources = void 0;
  this._cachedRendererResources = this._cachedRendererResources && this._cachedRendererResources.release();
  DracoLoader_default.destroyCachedDataForModel(this);
  const pickIds = this._pickIds;
  const length3 = pickIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    pickIds[i2].destroy();
  }
  releaseCachedGltf(this);
  this._quantizedVertexShaders = void 0;
  const clippingPlaneCollection = this._clippingPlanes;
  if (defined_default(clippingPlaneCollection) && !clippingPlaneCollection.isDestroyed() && clippingPlaneCollection.owner === this) {
    clippingPlaneCollection.destroy();
  }
  this._clippingPlanes = void 0;
  if (this._shouldDestroyImageBasedLighting && !this._imageBasedLighting.isDestroyed()) {
    this._imageBasedLighting.destroy();
  }
  this._imageBasedLighting = void 0;
  return destroyObject_default(this);
};
Model._getClippingFunction = getClippingFunction_default;
Model._modifyShaderForColor = modifyShaderForColor;
var Model_default = Model;

// node_modules/cesium/Source/Scene/Batched3DModel3DTileContent.js
function Batched3DModel3DTileContent(tileset, tile, resource, arrayBuffer, byteOffset) {
  this._tileset = tileset;
  this._tile = tile;
  this._resource = resource;
  this._model = void 0;
  this._batchTable = void 0;
  this._features = void 0;
  this._classificationType = tileset.vectorClassificationOnly ? void 0 : tileset.classificationType;
  this._metadata = void 0;
  this._batchIdAttributeName = void 0;
  this._diffuseAttributeOrUniformName = {};
  this._rtcCenterTransform = void 0;
  this._contentModelMatrix = void 0;
  this.featurePropertiesDirty = false;
  this._group = void 0;
  initialize4(this, arrayBuffer, byteOffset);
}
Batched3DModel3DTileContent._deprecationWarning = deprecationWarning_default;
Object.defineProperties(Batched3DModel3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      return this.batchTable.featuresLength;
    }
  },
  pointsLength: {
    get: function() {
      return this._model.pointsLength;
    }
  },
  trianglesLength: {
    get: function() {
      return this._model.trianglesLength;
    }
  },
  geometryByteLength: {
    get: function() {
      return this._model.geometryByteLength;
    }
  },
  texturesByteLength: {
    get: function() {
      return this._model.texturesByteLength;
    }
  },
  batchTableByteLength: {
    get: function() {
      return this.batchTable.memorySizeInBytes;
    }
  },
  innerContents: {
    get: function() {
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._model.readyPromise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return this._resource.getUrlComponent(true);
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    },
    set: function(value) {
      this._metadata = value;
    }
  },
  batchTable: {
    get: function() {
      return this._batchTable;
    }
  },
  group: {
    get: function() {
      return this._group;
    },
    set: function(value) {
      this._group = value;
    }
  }
});
function getBatchIdAttributeName(gltf) {
  let batchIdAttributeName = ModelUtility_default.getAttributeOrUniformBySemantic(
    gltf,
    "_BATCHID"
  );
  if (!defined_default(batchIdAttributeName)) {
    batchIdAttributeName = ModelUtility_default.getAttributeOrUniformBySemantic(
      gltf,
      "BATCHID"
    );
    if (defined_default(batchIdAttributeName)) {
      Batched3DModel3DTileContent._deprecationWarning(
        "b3dm-legacy-batchid",
        "The glTF in this b3dm uses the semantic `BATCHID`. Application-specific semantics should be prefixed with an underscore: `_BATCHID`."
      );
    }
  }
  return batchIdAttributeName;
}
function getVertexShaderCallback(content) {
  return function(vs, programId) {
    const batchTable = content._batchTable;
    const handleTranslucent = !defined_default(content._classificationType);
    const gltf = content._model.gltf;
    if (defined_default(gltf)) {
      content._batchIdAttributeName = getBatchIdAttributeName(gltf);
      content._diffuseAttributeOrUniformName[programId] = ModelUtility_default.getDiffuseAttributeOrUniform(gltf, programId);
    }
    const callback = batchTable.getVertexShaderCallback(
      handleTranslucent,
      content._batchIdAttributeName,
      content._diffuseAttributeOrUniformName[programId]
    );
    return defined_default(callback) ? callback(vs) : vs;
  };
}
function getFragmentShaderCallback(content) {
  return function(fs, programId) {
    const batchTable = content._batchTable;
    const handleTranslucent = !defined_default(content._classificationType);
    const gltf = content._model.gltf;
    if (defined_default(gltf)) {
      content._diffuseAttributeOrUniformName[programId] = ModelUtility_default.getDiffuseAttributeOrUniform(gltf, programId);
    }
    const callback = batchTable.getFragmentShaderCallback(
      handleTranslucent,
      content._diffuseAttributeOrUniformName[programId],
      false
    );
    return defined_default(callback) ? callback(fs) : fs;
  };
}
function getPickIdCallback(content) {
  return function() {
    return content._batchTable.getPickId();
  };
}
function getClassificationFragmentShaderCallback(content) {
  return function(fs) {
    const batchTable = content._batchTable;
    const callback = batchTable.getClassificationFragmentShaderCallback();
    return defined_default(callback) ? callback(fs) : fs;
  };
}
function createColorChangedCallback(content) {
  return function(batchId, color) {
    content._model.updateCommands(batchId, color);
  };
}
function initialize4(content, arrayBuffer, byteOffset) {
  const tileset = content._tileset;
  const tile = content._tile;
  const resource = content._resource;
  const b3dm = B3dmParser_default.parse(arrayBuffer, byteOffset);
  let batchLength = b3dm.batchLength;
  const featureTableJson = b3dm.featureTableJson;
  const featureTableBinary = b3dm.featureTableBinary;
  const featureTable = new Cesium3DTileFeatureTable_default(
    featureTableJson,
    featureTableBinary
  );
  batchLength = featureTable.getGlobalProperty("BATCH_LENGTH");
  featureTable.featuresLength = batchLength;
  const batchTableJson = b3dm.batchTableJson;
  const batchTableBinary = b3dm.batchTableBinary;
  let colorChangedCallback;
  if (defined_default(content._classificationType)) {
    colorChangedCallback = createColorChangedCallback(content);
  }
  const batchTable = new Cesium3DTileBatchTable_default(
    content,
    batchLength,
    batchTableJson,
    batchTableBinary,
    colorChangedCallback
  );
  content._batchTable = batchTable;
  const gltfView = b3dm.gltf;
  const pickObject = {
    content,
    primitive: tileset
  };
  content._rtcCenterTransform = Matrix4_default.IDENTITY;
  const rtcCenter = featureTable.getGlobalProperty(
    "RTC_CENTER",
    ComponentDatatype_default.FLOAT,
    3
  );
  if (defined_default(rtcCenter)) {
    content._rtcCenterTransform = Matrix4_default.fromTranslation(
      Cartesian3_default.fromArray(rtcCenter)
    );
  }
  content._contentModelMatrix = Matrix4_default.multiply(
    tile.computedTransform,
    content._rtcCenterTransform,
    new Matrix4_default()
  );
  if (!defined_default(content._classificationType)) {
    content._model = new Model_default({
      gltf: gltfView,
      cull: false,
      releaseGltfJson: true,
      opaquePass: Pass_default.CESIUM_3D_TILE,
      basePath: resource,
      requestType: RequestType_default.TILES3D,
      modelMatrix: content._contentModelMatrix,
      upAxis: tileset._gltfUpAxis,
      forwardAxis: Axis_default.X,
      shadows: tileset.shadows,
      debugWireframe: tileset.debugWireframe,
      incrementallyLoadTextures: false,
      vertexShaderLoaded: getVertexShaderCallback(content),
      fragmentShaderLoaded: getFragmentShaderCallback(content),
      uniformMapLoaded: batchTable.getUniformMapCallback(),
      pickIdLoaded: getPickIdCallback(content),
      addBatchIdToGeneratedShaders: batchLength > 0,
      pickObject,
      lightColor: tileset.lightColor,
      imageBasedLighting: tileset.imageBasedLighting,
      backFaceCulling: tileset.backFaceCulling,
      showOutline: tileset.showOutline,
      showCreditsOnScreen: tileset.showCreditsOnScreen
    });
    content._model.readyPromise.then(function(model) {
      model.activeAnimations.addAll({
        loop: ModelAnimationLoop_default.REPEAT
      });
    });
  } else {
    content._model = new ClassificationModel_default({
      gltf: gltfView,
      cull: false,
      basePath: resource,
      requestType: RequestType_default.TILES3D,
      modelMatrix: content._contentModelMatrix,
      upAxis: tileset._gltfUpAxis,
      forwardAxis: Axis_default.X,
      debugWireframe: tileset.debugWireframe,
      vertexShaderLoaded: getVertexShaderCallback(content),
      classificationShaderLoaded: getClassificationFragmentShaderCallback(
        content
      ),
      uniformMapLoaded: batchTable.getUniformMapCallback(),
      pickIdLoaded: getPickIdCallback(content),
      classificationType: content._classificationType,
      batchTable
    });
  }
}
function createFeatures(content) {
  const featuresLength = content.featuresLength;
  if (!defined_default(content._features) && featuresLength > 0) {
    const features = new Array(featuresLength);
    for (let i2 = 0; i2 < featuresLength; ++i2) {
      features[i2] = new Cesium3DTileFeature_default(content, i2);
    }
    content._features = features;
  }
}
Batched3DModel3DTileContent.prototype.hasProperty = function(batchId, name) {
  return this._batchTable.hasProperty(batchId, name);
};
Batched3DModel3DTileContent.prototype.getFeature = function(batchId) {
  const featuresLength = this.featuresLength;
  if (!defined_default(batchId) || batchId < 0 || batchId >= featuresLength) {
    throw new DeveloperError_default(
      `batchId is required and between zero and featuresLength - 1 (${featuresLength - 1}).`
    );
  }
  createFeatures(this);
  return this._features[batchId];
};
Batched3DModel3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
  color = enabled ? color : Color_default.WHITE;
  if (this.featuresLength === 0) {
    this._model.color = color;
  } else {
    this._batchTable.setAllColor(color);
  }
};
Batched3DModel3DTileContent.prototype.applyStyle = function(style) {
  if (this.featuresLength === 0) {
    const hasColorStyle = defined_default(style) && defined_default(style.color);
    const hasShowStyle = defined_default(style) && defined_default(style.show);
    this._model.color = hasColorStyle ? style.color.evaluateColor(void 0, this._model.color) : Color_default.clone(Color_default.WHITE, this._model.color);
    this._model.show = hasShowStyle ? style.show.evaluate(void 0) : true;
  } else {
    this._batchTable.applyStyle(style);
  }
};
Batched3DModel3DTileContent.prototype.update = function(tileset, frameState) {
  const commandStart = frameState.commandList.length;
  const model = this._model;
  const tile = this._tile;
  const batchTable = this._batchTable;
  batchTable.update(tileset, frameState);
  this._contentModelMatrix = Matrix4_default.multiply(
    tile.computedTransform,
    this._rtcCenterTransform,
    this._contentModelMatrix
  );
  model.modelMatrix = this._contentModelMatrix;
  model.shadows = tileset.shadows;
  model.lightColor = tileset.lightColor;
  model.imageBasedLighting = tileset.imageBasedLighting;
  model.backFaceCulling = tileset.backFaceCulling;
  model.debugWireframe = tileset.debugWireframe;
  model.showCreditsOnScreen = tileset.showCreditsOnScreen;
  model.splitDirection = tileset.splitDirection;
  const tilesetClippingPlanes = tileset.clippingPlanes;
  model.referenceMatrix = tileset.clippingPlanesOriginMatrix;
  if (defined_default(tilesetClippingPlanes) && tile.clippingPlanesDirty) {
    model._clippingPlanes = tilesetClippingPlanes.enabled && tile._isClipped ? tilesetClippingPlanes : void 0;
  }
  if (defined_default(tilesetClippingPlanes) && defined_default(model._clippingPlanes) && model._clippingPlanes !== tilesetClippingPlanes) {
    model._clippingPlanes = tilesetClippingPlanes;
  }
  model.update(frameState);
  const commandEnd = frameState.commandList.length;
  if (commandStart < commandEnd && (frameState.passes.render || frameState.passes.pick) && !defined_default(this._classificationType)) {
    batchTable.addDerivedCommands(frameState, commandStart);
  }
};
Batched3DModel3DTileContent.prototype.isDestroyed = function() {
  return false;
};
Batched3DModel3DTileContent.prototype.destroy = function() {
  this._model = this._model && this._model.destroy();
  this._batchTable = this._batchTable && this._batchTable.destroy();
  return destroyObject_default(this);
};
var Batched3DModel3DTileContent_default = Batched3DModel3DTileContent;

// node_modules/cesium/Source/Scene/Composite3DTileContent.js
function Composite3DTileContent(tileset, tile, resource, arrayBuffer, byteOffset, factory) {
  this._tileset = tileset;
  this._tile = tile;
  this._resource = resource;
  this._contents = [];
  this._readyPromise = defer_default();
  this._metadata = void 0;
  this._group = void 0;
  initialize5(this, arrayBuffer, byteOffset, factory);
}
Object.defineProperties(Composite3DTileContent.prototype, {
  featurePropertiesDirty: {
    get: function() {
      const contents = this._contents;
      const length3 = contents.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        if (contents[i2].featurePropertiesDirty) {
          return true;
        }
      }
      return false;
    },
    set: function(value) {
      const contents = this._contents;
      const length3 = contents.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        contents[i2].featurePropertiesDirty = value;
      }
    }
  },
  featuresLength: {
    get: function() {
      return 0;
    }
  },
  pointsLength: {
    get: function() {
      return 0;
    }
  },
  trianglesLength: {
    get: function() {
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      return 0;
    }
  },
  texturesByteLength: {
    get: function() {
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      return 0;
    }
  },
  innerContents: {
    get: function() {
      return this._contents;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return this._resource.getUrlComponent(true);
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    },
    set: function(value) {
      this._metadata = value;
      const contents = this._contents;
      const length3 = contents.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        contents[i2].metadata = value;
      }
    }
  },
  batchTable: {
    get: function() {
      return void 0;
    }
  },
  group: {
    get: function() {
      return this._group;
    },
    set: function(value) {
      this._group = value;
      const contents = this._contents;
      const length3 = contents.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        contents[i2].group = value;
      }
    }
  }
});
var sizeOfUint324 = Uint32Array.BYTES_PER_ELEMENT;
function initialize5(content, arrayBuffer, byteOffset, factory) {
  byteOffset = defaultValue_default(byteOffset, 0);
  const uint8Array = new Uint8Array(arrayBuffer);
  const view = new DataView(arrayBuffer);
  byteOffset += sizeOfUint324;
  const version = view.getUint32(byteOffset, true);
  if (version !== 1) {
    throw new RuntimeError_default(
      `Only Composite Tile version 1 is supported. Version ${version} is not.`
    );
  }
  byteOffset += sizeOfUint324;
  byteOffset += sizeOfUint324;
  const tilesLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint324;
  const contentPromises = [];
  for (let i2 = 0; i2 < tilesLength; ++i2) {
    const tileType = getMagic_default(uint8Array, byteOffset);
    const tileByteLength = view.getUint32(byteOffset + sizeOfUint324 * 2, true);
    const contentFactory = factory[tileType];
    if (defined_default(contentFactory)) {
      const innerContent = contentFactory(
        content._tileset,
        content._tile,
        content._resource,
        arrayBuffer,
        byteOffset
      );
      content._contents.push(innerContent);
      contentPromises.push(innerContent.readyPromise);
    } else {
      throw new RuntimeError_default(
        `Unknown tile content type, ${tileType}, inside Composite tile`
      );
    }
    byteOffset += tileByteLength;
  }
  Promise.all(contentPromises).then(function() {
    content._readyPromise.resolve(content);
  }).catch(function(error) {
    content._readyPromise.reject(error);
  });
}
Composite3DTileContent.prototype.hasProperty = function(batchId, name) {
  return false;
};
Composite3DTileContent.prototype.getFeature = function(batchId) {
  return void 0;
};
Composite3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
  const contents = this._contents;
  const length3 = contents.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    contents[i2].applyDebugSettings(enabled, color);
  }
};
Composite3DTileContent.prototype.applyStyle = function(style) {
  const contents = this._contents;
  const length3 = contents.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    contents[i2].applyStyle(style);
  }
};
Composite3DTileContent.prototype.update = function(tileset, frameState) {
  const contents = this._contents;
  const length3 = contents.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    contents[i2].update(tileset, frameState);
  }
};
Composite3DTileContent.prototype.isDestroyed = function() {
  return false;
};
Composite3DTileContent.prototype.destroy = function() {
  const contents = this._contents;
  const length3 = contents.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    contents[i2].destroy();
  }
  return destroyObject_default(this);
};
var Composite3DTileContent_default = Composite3DTileContent;

// node_modules/cesium/Source/Scene/Vector3DTileGeometry.js
function Vector3DTileGeometry(options) {
  this._boxes = options.boxes;
  this._boxBatchIds = options.boxBatchIds;
  this._cylinders = options.cylinders;
  this._cylinderBatchIds = options.cylinderBatchIds;
  this._ellipsoids = options.ellipsoids;
  this._ellipsoidBatchIds = options.ellipsoidBatchIds;
  this._spheres = options.spheres;
  this._sphereBatchIds = options.sphereBatchIds;
  this._modelMatrix = options.modelMatrix;
  this._batchTable = options.batchTable;
  this._boundingVolume = options.boundingVolume;
  this._center = options.center;
  if (!defined_default(this._center)) {
    if (defined_default(this._boundingVolume)) {
      this._center = Cartesian3_default.clone(this._boundingVolume.center);
    } else {
      this._center = Cartesian3_default.clone(Cartesian3_default.ZERO);
    }
  }
  this._boundingVolumes = void 0;
  this._batchedIndices = void 0;
  this._indices = void 0;
  this._indexOffsets = void 0;
  this._indexCounts = void 0;
  this._positions = void 0;
  this._vertexBatchIds = void 0;
  this._batchIds = void 0;
  this._batchTableColors = void 0;
  this._packedBuffer = void 0;
  this._ready = false;
  this._readyPromise = defer_default();
  this._verticesPromise = void 0;
  this._primitive = void 0;
  this.debugWireframe = false;
  this.forceRebatch = false;
  this.classificationType = ClassificationType_default.BOTH;
}
Object.defineProperties(Vector3DTileGeometry.prototype, {
  trianglesLength: {
    get: function() {
      if (defined_default(this._primitive)) {
        return this._primitive.trianglesLength;
      }
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      if (defined_default(this._primitive)) {
        return this._primitive.geometryByteLength;
      }
      return 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  }
});
Vector3DTileGeometry.packedBoxLength = Matrix4_default.packedLength + Cartesian3_default.packedLength;
Vector3DTileGeometry.packedCylinderLength = Matrix4_default.packedLength + 2;
Vector3DTileGeometry.packedEllipsoidLength = Matrix4_default.packedLength + Cartesian3_default.packedLength;
Vector3DTileGeometry.packedSphereLength = Cartesian3_default.packedLength + 1;
function packBuffer(geometries) {
  const packedBuffer = new Float64Array(
    Matrix4_default.packedLength + Cartesian3_default.packedLength
  );
  let offset2 = 0;
  Cartesian3_default.pack(geometries._center, packedBuffer, offset2);
  offset2 += Cartesian3_default.packedLength;
  Matrix4_default.pack(geometries._modelMatrix, packedBuffer, offset2);
  return packedBuffer;
}
function unpackBuffer(geometries, packedBuffer) {
  let offset2 = 0;
  const indicesBytesPerElement = packedBuffer[offset2++];
  const numBVS = packedBuffer[offset2++];
  const bvs = geometries._boundingVolumes = new Array(numBVS);
  for (let i2 = 0; i2 < numBVS; ++i2) {
    bvs[i2] = BoundingSphere_default.unpack(packedBuffer, offset2);
    offset2 += BoundingSphere_default.packedLength;
  }
  const numBatchedIndices = packedBuffer[offset2++];
  const bis = geometries._batchedIndices = new Array(numBatchedIndices);
  for (let j = 0; j < numBatchedIndices; ++j) {
    const color = Color_default.unpack(packedBuffer, offset2);
    offset2 += Color_default.packedLength;
    const indexOffset = packedBuffer[offset2++];
    const count = packedBuffer[offset2++];
    const length3 = packedBuffer[offset2++];
    const batchIds = new Array(length3);
    for (let k = 0; k < length3; ++k) {
      batchIds[k] = packedBuffer[offset2++];
    }
    bis[j] = new Vector3DTileBatch_default({
      color,
      offset: indexOffset,
      count,
      batchIds
    });
  }
  return indicesBytesPerElement;
}
var createVerticesTaskProcessor = new TaskProcessor_default(
  "createVectorTileGeometries",
  5
);
var scratchColor5 = new Color_default();
function createPrimitive2(geometries) {
  if (defined_default(geometries._primitive)) {
    return;
  }
  if (!defined_default(geometries._verticesPromise)) {
    let boxes = geometries._boxes;
    let boxBatchIds = geometries._boxBatchIds;
    let cylinders = geometries._cylinders;
    let cylinderBatchIds = geometries._cylinderBatchIds;
    let ellipsoids = geometries._ellipsoids;
    let ellipsoidBatchIds = geometries._ellipsoidBatchIds;
    let spheres = geometries._spheres;
    let sphereBatchIds = geometries._sphereBatchIds;
    let batchTableColors = geometries._batchTableColors;
    let packedBuffer = geometries._packedBuffer;
    if (!defined_default(batchTableColors)) {
      let length3 = 0;
      if (defined_default(geometries._boxes)) {
        boxes = geometries._boxes = arraySlice_default(boxes);
        boxBatchIds = geometries._boxBatchIds = arraySlice_default(boxBatchIds);
        length3 += boxBatchIds.length;
      }
      if (defined_default(geometries._cylinders)) {
        cylinders = geometries._cylinders = arraySlice_default(cylinders);
        cylinderBatchIds = geometries._cylinderBatchIds = arraySlice_default(
          cylinderBatchIds
        );
        length3 += cylinderBatchIds.length;
      }
      if (defined_default(geometries._ellipsoids)) {
        ellipsoids = geometries._ellipsoids = arraySlice_default(ellipsoids);
        ellipsoidBatchIds = geometries._ellipsoidBatchIds = arraySlice_default(
          ellipsoidBatchIds
        );
        length3 += ellipsoidBatchIds.length;
      }
      if (defined_default(geometries._spheres)) {
        spheres = geometries._sphere = arraySlice_default(spheres);
        sphereBatchIds = geometries._sphereBatchIds = arraySlice_default(
          sphereBatchIds
        );
        length3 += sphereBatchIds.length;
      }
      batchTableColors = geometries._batchTableColors = new Uint32Array(length3);
      const batchTable = geometries._batchTable;
      for (let i2 = 0; i2 < length3; ++i2) {
        const color = batchTable.getColor(i2, scratchColor5);
        batchTableColors[i2] = color.toRgba();
      }
      packedBuffer = geometries._packedBuffer = packBuffer(geometries);
    }
    const transferrableObjects = [];
    if (defined_default(boxes)) {
      transferrableObjects.push(boxes.buffer, boxBatchIds.buffer);
    }
    if (defined_default(cylinders)) {
      transferrableObjects.push(cylinders.buffer, cylinderBatchIds.buffer);
    }
    if (defined_default(ellipsoids)) {
      transferrableObjects.push(ellipsoids.buffer, ellipsoidBatchIds.buffer);
    }
    if (defined_default(spheres)) {
      transferrableObjects.push(spheres.buffer, sphereBatchIds.buffer);
    }
    transferrableObjects.push(batchTableColors.buffer, packedBuffer.buffer);
    const parameters = {
      boxes: defined_default(boxes) ? boxes.buffer : void 0,
      boxBatchIds: defined_default(boxes) ? boxBatchIds.buffer : void 0,
      cylinders: defined_default(cylinders) ? cylinders.buffer : void 0,
      cylinderBatchIds: defined_default(cylinders) ? cylinderBatchIds.buffer : void 0,
      ellipsoids: defined_default(ellipsoids) ? ellipsoids.buffer : void 0,
      ellipsoidBatchIds: defined_default(ellipsoids) ? ellipsoidBatchIds.buffer : void 0,
      spheres: defined_default(spheres) ? spheres.buffer : void 0,
      sphereBatchIds: defined_default(spheres) ? sphereBatchIds.buffer : void 0,
      batchTableColors: batchTableColors.buffer,
      packedBuffer: packedBuffer.buffer
    };
    const verticesPromise = geometries._verticesPromise = createVerticesTaskProcessor.scheduleTask(
      parameters,
      transferrableObjects
    );
    if (!defined_default(verticesPromise)) {
      return;
    }
    verticesPromise.then(function(result) {
      const packedBuffer2 = new Float64Array(result.packedBuffer);
      const indicesBytesPerElement = unpackBuffer(geometries, packedBuffer2);
      if (indicesBytesPerElement === 2) {
        geometries._indices = new Uint16Array(result.indices);
      } else {
        geometries._indices = new Uint32Array(result.indices);
      }
      geometries._indexOffsets = new Uint32Array(result.indexOffsets);
      geometries._indexCounts = new Uint32Array(result.indexCounts);
      geometries._positions = new Float32Array(result.positions);
      geometries._vertexBatchIds = new Uint16Array(result.vertexBatchIds);
      geometries._batchIds = new Uint16Array(result.batchIds);
      geometries._ready = true;
    });
  }
  if (geometries._ready && !defined_default(geometries._primitive)) {
    geometries._primitive = new Vector3DTilePrimitive_default({
      batchTable: geometries._batchTable,
      positions: geometries._positions,
      batchIds: geometries._batchIds,
      vertexBatchIds: geometries._vertexBatchIds,
      indices: geometries._indices,
      indexOffsets: geometries._indexOffsets,
      indexCounts: geometries._indexCounts,
      batchedIndices: geometries._batchedIndices,
      boundingVolume: geometries._boundingVolume,
      boundingVolumes: geometries._boundingVolumes,
      center: geometries._center,
      pickObject: defaultValue_default(geometries._pickObject, geometries)
    });
    geometries._boxes = void 0;
    geometries._boxBatchIds = void 0;
    geometries._cylinders = void 0;
    geometries._cylinderBatchIds = void 0;
    geometries._ellipsoids = void 0;
    geometries._ellipsoidBatchIds = void 0;
    geometries._spheres = void 0;
    geometries._sphereBatchIds = void 0;
    geometries._center = void 0;
    geometries._modelMatrix = void 0;
    geometries._batchTable = void 0;
    geometries._boundingVolume = void 0;
    geometries._boundingVolumes = void 0;
    geometries._batchedIndices = void 0;
    geometries._indices = void 0;
    geometries._indexOffsets = void 0;
    geometries._indexCounts = void 0;
    geometries._positions = void 0;
    geometries._vertexBatchIds = void 0;
    geometries._batchIds = void 0;
    geometries._batchTableColors = void 0;
    geometries._packedBuffer = void 0;
    geometries._verticesPromise = void 0;
    geometries._readyPromise.resolve();
  }
}
Vector3DTileGeometry.prototype.createFeatures = function(content, features) {
  this._primitive.createFeatures(content, features);
};
Vector3DTileGeometry.prototype.applyDebugSettings = function(enabled, color) {
  this._primitive.applyDebugSettings(enabled, color);
};
Vector3DTileGeometry.prototype.applyStyle = function(style, features) {
  this._primitive.applyStyle(style, features);
};
Vector3DTileGeometry.prototype.updateCommands = function(batchId, color) {
  this._primitive.updateCommands(batchId, color);
};
Vector3DTileGeometry.prototype.update = function(frameState) {
  createPrimitive2(this);
  if (!this._ready) {
    return;
  }
  this._primitive.debugWireframe = this.debugWireframe;
  this._primitive.forceRebatch = this.forceRebatch;
  this._primitive.classificationType = this.classificationType;
  this._primitive.update(frameState);
};
Vector3DTileGeometry.prototype.isDestroyed = function() {
  return false;
};
Vector3DTileGeometry.prototype.destroy = function() {
  this._primitive = this._primitive && this._primitive.destroy();
  return destroyObject_default(this);
};
var Vector3DTileGeometry_default = Vector3DTileGeometry;

// node_modules/cesium/Source/Scene/Geometry3DTileContent.js
function Geometry3DTileContent(tileset, tile, resource, arrayBuffer, byteOffset) {
  this._tileset = tileset;
  this._tile = tile;
  this._resource = resource;
  this._geometries = void 0;
  this._contentReadyPromise = void 0;
  this._readyPromise = defer_default();
  this._metadata = void 0;
  this._batchTable = void 0;
  this._features = void 0;
  this.featurePropertiesDirty = false;
  this._group = void 0;
  initialize6(this, arrayBuffer, byteOffset);
}
Object.defineProperties(Geometry3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      return defined_default(this._batchTable) ? this._batchTable.featuresLength : 0;
    }
  },
  pointsLength: {
    get: function() {
      return 0;
    }
  },
  trianglesLength: {
    get: function() {
      if (defined_default(this._geometries)) {
        return this._geometries.trianglesLength;
      }
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      if (defined_default(this._geometries)) {
        return this._geometries.geometryByteLength;
      }
      return 0;
    }
  },
  texturesByteLength: {
    get: function() {
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      return defined_default(this._batchTable) ? this._batchTable.memorySizeInBytes : 0;
    }
  },
  innerContents: {
    get: function() {
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return this._resource.getUrlComponent(true);
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    },
    set: function(value) {
      this._metadata = value;
    }
  },
  batchTable: {
    get: function() {
      return this._batchTable;
    }
  },
  group: {
    get: function() {
      return this._group;
    },
    set: function(value) {
      this._group = value;
    }
  }
});
function createColorChangedCallback2(content) {
  return function(batchId, color) {
    if (defined_default(content._geometries)) {
      content._geometries.updateCommands(batchId, color);
    }
  };
}
function getBatchIds(featureTableJson, featureTableBinary) {
  let boxBatchIds;
  let cylinderBatchIds;
  let ellipsoidBatchIds;
  let sphereBatchIds;
  let i2;
  const numberOfBoxes = defaultValue_default(featureTableJson.BOXES_LENGTH, 0);
  const numberOfCylinders = defaultValue_default(featureTableJson.CYLINDERS_LENGTH, 0);
  const numberOfEllipsoids = defaultValue_default(
    featureTableJson.ELLIPSOIDS_LENGTH,
    0
  );
  const numberOfSpheres = defaultValue_default(featureTableJson.SPHERES_LENGTH, 0);
  if (numberOfBoxes > 0 && defined_default(featureTableJson.BOX_BATCH_IDS)) {
    const boxBatchIdsByteOffset = featureTableBinary.byteOffset + featureTableJson.BOX_BATCH_IDS.byteOffset;
    boxBatchIds = new Uint16Array(
      featureTableBinary.buffer,
      boxBatchIdsByteOffset,
      numberOfBoxes
    );
  }
  if (numberOfCylinders > 0 && defined_default(featureTableJson.CYLINDER_BATCH_IDS)) {
    const cylinderBatchIdsByteOffset = featureTableBinary.byteOffset + featureTableJson.CYLINDER_BATCH_IDS.byteOffset;
    cylinderBatchIds = new Uint16Array(
      featureTableBinary.buffer,
      cylinderBatchIdsByteOffset,
      numberOfCylinders
    );
  }
  if (numberOfEllipsoids > 0 && defined_default(featureTableJson.ELLIPSOID_BATCH_IDS)) {
    const ellipsoidBatchIdsByteOffset = featureTableBinary.byteOffset + featureTableJson.ELLIPSOID_BATCH_IDS.byteOffset;
    ellipsoidBatchIds = new Uint16Array(
      featureTableBinary.buffer,
      ellipsoidBatchIdsByteOffset,
      numberOfEllipsoids
    );
  }
  if (numberOfSpheres > 0 && defined_default(featureTableJson.SPHERE_BATCH_IDS)) {
    const sphereBatchIdsByteOffset = featureTableBinary.byteOffset + featureTableJson.SPHERE_BATCH_IDS.byteOffset;
    sphereBatchIds = new Uint16Array(
      featureTableBinary.buffer,
      sphereBatchIdsByteOffset,
      numberOfSpheres
    );
  }
  const atLeastOneDefined = defined_default(boxBatchIds) || defined_default(cylinderBatchIds) || defined_default(ellipsoidBatchIds) || defined_default(sphereBatchIds);
  const atLeastOneUndefined = numberOfBoxes > 0 && !defined_default(boxBatchIds) || numberOfCylinders > 0 && !defined_default(cylinderBatchIds) || numberOfEllipsoids > 0 && !defined_default(ellipsoidBatchIds) || numberOfSpheres > 0 && !defined_default(sphereBatchIds);
  if (atLeastOneDefined && atLeastOneUndefined) {
    throw new RuntimeError_default(
      "If one group of batch ids is defined, then all batch ids must be defined."
    );
  }
  const allUndefinedBatchIds = !defined_default(boxBatchIds) && !defined_default(cylinderBatchIds) && !defined_default(ellipsoidBatchIds) && !defined_default(sphereBatchIds);
  if (allUndefinedBatchIds) {
    let id = 0;
    if (!defined_default(boxBatchIds) && numberOfBoxes > 0) {
      boxBatchIds = new Uint16Array(numberOfBoxes);
      for (i2 = 0; i2 < numberOfBoxes; ++i2) {
        boxBatchIds[i2] = id++;
      }
    }
    if (!defined_default(cylinderBatchIds) && numberOfCylinders > 0) {
      cylinderBatchIds = new Uint16Array(numberOfCylinders);
      for (i2 = 0; i2 < numberOfCylinders; ++i2) {
        cylinderBatchIds[i2] = id++;
      }
    }
    if (!defined_default(ellipsoidBatchIds) && numberOfEllipsoids > 0) {
      ellipsoidBatchIds = new Uint16Array(numberOfEllipsoids);
      for (i2 = 0; i2 < numberOfEllipsoids; ++i2) {
        ellipsoidBatchIds[i2] = id++;
      }
    }
    if (!defined_default(sphereBatchIds) && numberOfSpheres > 0) {
      sphereBatchIds = new Uint16Array(numberOfSpheres);
      for (i2 = 0; i2 < numberOfSpheres; ++i2) {
        sphereBatchIds[i2] = id++;
      }
    }
  }
  return {
    boxes: boxBatchIds,
    cylinders: cylinderBatchIds,
    ellipsoids: ellipsoidBatchIds,
    spheres: sphereBatchIds
  };
}
var sizeOfUint325 = Uint32Array.BYTES_PER_ELEMENT;
function initialize6(content, arrayBuffer, byteOffset) {
  byteOffset = defaultValue_default(byteOffset, 0);
  const uint8Array = new Uint8Array(arrayBuffer);
  const view = new DataView(arrayBuffer);
  byteOffset += sizeOfUint325;
  const version = view.getUint32(byteOffset, true);
  if (version !== 1) {
    throw new RuntimeError_default(
      `Only Geometry tile version 1 is supported.  Version ${version} is not.`
    );
  }
  byteOffset += sizeOfUint325;
  const byteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint325;
  if (byteLength === 0) {
    content._readyPromise.resolve(content);
    return;
  }
  const featureTableJSONByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint325;
  if (featureTableJSONByteLength === 0) {
    throw new RuntimeError_default(
      "Feature table must have a byte length greater than zero"
    );
  }
  const featureTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint325;
  const batchTableJSONByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint325;
  const batchTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint325;
  const featureTableJson = getJsonFromTypedArray_default(
    uint8Array,
    byteOffset,
    featureTableJSONByteLength
  );
  byteOffset += featureTableJSONByteLength;
  const featureTableBinary = new Uint8Array(
    arrayBuffer,
    byteOffset,
    featureTableBinaryByteLength
  );
  byteOffset += featureTableBinaryByteLength;
  let batchTableJson;
  let batchTableBinary;
  if (batchTableJSONByteLength > 0) {
    batchTableJson = getJsonFromTypedArray_default(
      uint8Array,
      byteOffset,
      batchTableJSONByteLength
    );
    byteOffset += batchTableJSONByteLength;
    if (batchTableBinaryByteLength > 0) {
      batchTableBinary = new Uint8Array(
        arrayBuffer,
        byteOffset,
        batchTableBinaryByteLength
      );
      batchTableBinary = new Uint8Array(batchTableBinary);
    }
  }
  const numberOfBoxes = defaultValue_default(featureTableJson.BOXES_LENGTH, 0);
  const numberOfCylinders = defaultValue_default(featureTableJson.CYLINDERS_LENGTH, 0);
  const numberOfEllipsoids = defaultValue_default(
    featureTableJson.ELLIPSOIDS_LENGTH,
    0
  );
  const numberOfSpheres = defaultValue_default(featureTableJson.SPHERES_LENGTH, 0);
  const totalPrimitives = numberOfBoxes + numberOfCylinders + numberOfEllipsoids + numberOfSpheres;
  const batchTable = new Cesium3DTileBatchTable_default(
    content,
    totalPrimitives,
    batchTableJson,
    batchTableBinary,
    createColorChangedCallback2(content)
  );
  content._batchTable = batchTable;
  if (totalPrimitives === 0) {
    return;
  }
  const modelMatrix = content.tile.computedTransform;
  let center;
  if (defined_default(featureTableJson.RTC_CENTER)) {
    center = Cartesian3_default.unpack(featureTableJson.RTC_CENTER);
    Matrix4_default.multiplyByPoint(modelMatrix, center, center);
  }
  const batchIds = getBatchIds(featureTableJson, featureTableBinary);
  if (numberOfBoxes > 0 || numberOfCylinders > 0 || numberOfEllipsoids > 0 || numberOfSpheres > 0) {
    let boxes;
    let cylinders;
    let ellipsoids;
    let spheres;
    if (numberOfBoxes > 0) {
      const boxesByteOffset = featureTableBinary.byteOffset + featureTableJson.BOXES.byteOffset;
      boxes = new Float32Array(
        featureTableBinary.buffer,
        boxesByteOffset,
        Vector3DTileGeometry_default.packedBoxLength * numberOfBoxes
      );
    }
    if (numberOfCylinders > 0) {
      const cylindersByteOffset = featureTableBinary.byteOffset + featureTableJson.CYLINDERS.byteOffset;
      cylinders = new Float32Array(
        featureTableBinary.buffer,
        cylindersByteOffset,
        Vector3DTileGeometry_default.packedCylinderLength * numberOfCylinders
      );
    }
    if (numberOfEllipsoids > 0) {
      const ellipsoidsByteOffset = featureTableBinary.byteOffset + featureTableJson.ELLIPSOIDS.byteOffset;
      ellipsoids = new Float32Array(
        featureTableBinary.buffer,
        ellipsoidsByteOffset,
        Vector3DTileGeometry_default.packedEllipsoidLength * numberOfEllipsoids
      );
    }
    if (numberOfSpheres > 0) {
      const spheresByteOffset = featureTableBinary.byteOffset + featureTableJson.SPHERES.byteOffset;
      spheres = new Float32Array(
        featureTableBinary.buffer,
        spheresByteOffset,
        Vector3DTileGeometry_default.packedSphereLength * numberOfSpheres
      );
    }
    content._geometries = new Vector3DTileGeometry_default({
      boxes,
      boxBatchIds: batchIds.boxes,
      cylinders,
      cylinderBatchIds: batchIds.cylinders,
      ellipsoids,
      ellipsoidBatchIds: batchIds.ellipsoids,
      spheres,
      sphereBatchIds: batchIds.spheres,
      center,
      modelMatrix,
      batchTable,
      boundingVolume: content.tile.boundingVolume.boundingVolume
    });
  }
}
function createFeatures2(content) {
  const featuresLength = content.featuresLength;
  if (!defined_default(content._features) && featuresLength > 0) {
    const features = new Array(featuresLength);
    if (defined_default(content._geometries)) {
      content._geometries.createFeatures(content, features);
    }
    content._features = features;
  }
}
Geometry3DTileContent.prototype.hasProperty = function(batchId, name) {
  return this._batchTable.hasProperty(batchId, name);
};
Geometry3DTileContent.prototype.getFeature = function(batchId) {
  const featuresLength = this.featuresLength;
  if (!defined_default(batchId) || batchId < 0 || batchId >= featuresLength) {
    throw new DeveloperError_default(
      `batchId is required and between zero and featuresLength - 1 (${featuresLength - 1}).`
    );
  }
  createFeatures2(this);
  return this._features[batchId];
};
Geometry3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
  if (defined_default(this._geometries)) {
    this._geometries.applyDebugSettings(enabled, color);
  }
};
Geometry3DTileContent.prototype.applyStyle = function(style) {
  createFeatures2(this);
  if (defined_default(this._geometries)) {
    this._geometries.applyStyle(style, this._features);
  }
};
Geometry3DTileContent.prototype.update = function(tileset, frameState) {
  if (defined_default(this._geometries)) {
    this._geometries.classificationType = this._tileset.classificationType;
    this._geometries.debugWireframe = this._tileset.debugWireframe;
    this._geometries.update(frameState);
  }
  if (defined_default(this._batchTable) && this._geometries._ready) {
    this._batchTable.update(tileset, frameState);
  }
  if (!defined_default(this._contentReadyPromise)) {
    const that = this;
    this._contentReadyPromise = this._geometries.readyPromise.then(function() {
      that._readyPromise.resolve(that);
    });
  }
};
Geometry3DTileContent.prototype.isDestroyed = function() {
  return false;
};
Geometry3DTileContent.prototype.destroy = function() {
  this._geometries = this._geometries && this._geometries.destroy();
  this._batchTable = this._batchTable && this._batchTable.destroy();
  return destroyObject_default(this);
};
var Geometry3DTileContent_default = Geometry3DTileContent;

// node_modules/cesium/Source/Scene/hasExtension.js
function hasExtension(json, extensionName) {
  return defined_default(json) && defined_default(json.extensions) && defined_default(json.extensions[extensionName]);
}

// node_modules/cesium/Source/Scene/ImplicitAvailabilityBitstream.js
function ImplicitAvailabilityBitstream(options) {
  const lengthBits = options.lengthBits;
  let availableCount = options.availableCount;
  Check_default.typeOf.number("options.lengthBits", lengthBits);
  const constant = options.constant;
  const bitstream = options.bitstream;
  if (defined_default(constant)) {
    availableCount = lengthBits;
  } else {
    const expectedLength = Math.ceil(lengthBits / 8);
    if (bitstream.length !== expectedLength) {
      throw new RuntimeError_default(
        `Availability bitstream must be exactly ${expectedLength} bytes long to store ${lengthBits} bits. Actual bitstream was ${bitstream.length} bytes long.`
      );
    }
    const computeAvailableCountEnabled = defaultValue_default(
      options.computeAvailableCountEnabled,
      false
    );
    if (!defined_default(availableCount) && computeAvailableCountEnabled) {
      availableCount = count1Bits(bitstream, lengthBits);
    }
  }
  this._lengthBits = lengthBits;
  this._availableCount = availableCount;
  this._constant = constant;
  this._bitstream = bitstream;
}
function count1Bits(bitstream, lengthBits) {
  let count = 0;
  for (let i2 = 0; i2 < lengthBits; i2++) {
    const byteIndex = i2 >> 3;
    const bitIndex = i2 % 8;
    count += bitstream[byteIndex] >> bitIndex & 1;
  }
  return count;
}
Object.defineProperties(ImplicitAvailabilityBitstream.prototype, {
  lengthBits: {
    get: function() {
      return this._lengthBits;
    }
  },
  availableCount: {
    get: function() {
      return this._availableCount;
    }
  }
});
ImplicitAvailabilityBitstream.prototype.getBit = function(index2) {
  if (index2 < 0 || index2 >= this._lengthBits) {
    throw new DeveloperError_default("Bit index out of bounds.");
  }
  if (defined_default(this._constant)) {
    return this._constant;
  }
  const byteIndex = index2 >> 3;
  const bitIndex = index2 % 8;
  return (this._bitstream[byteIndex] >> bitIndex & 1) === 1;
};

// node_modules/cesium/Source/Scene/ImplicitMetadataView.js
function ImplicitMetadataView(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const metadataTable = options.metadataTable;
  const metadataClass = options.class;
  const entityId = options.entityId;
  const propertyTableJson = options.propertyTableJson;
  Check_default.typeOf.object("options.metadataTable", metadataTable);
  Check_default.typeOf.object("options.class", metadataClass);
  Check_default.typeOf.number("options.entityId", entityId);
  Check_default.typeOf.object("options.propertyTableJson", propertyTableJson);
  this._class = metadataClass;
  this._metadataTable = metadataTable;
  this._entityId = entityId;
  this._extensions = propertyTableJson.extensions;
  this._extras = propertyTableJson.extras;
}
Object.defineProperties(ImplicitMetadataView.prototype, {
  class: {
    get: function() {
      return this._class;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
ImplicitMetadataView.prototype.hasProperty = function(propertyId) {
  return this._metadataTable.hasProperty(propertyId);
};
ImplicitMetadataView.prototype.hasPropertyBySemantic = function(semantic) {
  return this._metadataTable.hasPropertyBySemantic(semantic);
};
ImplicitMetadataView.prototype.getPropertyIds = function(results) {
  return this._metadataTable.getPropertyIds(results);
};
ImplicitMetadataView.prototype.getProperty = function(propertyId) {
  return this._metadataTable.getProperty(this._entityId, propertyId);
};
ImplicitMetadataView.prototype.setProperty = function(propertyId, value) {
  return this._metadataTable.setProperty(this._entityId, propertyId, value);
};
ImplicitMetadataView.prototype.getPropertyBySemantic = function(semantic) {
  return this._metadataTable.getPropertyBySemantic(this._entityId, semantic);
};
ImplicitMetadataView.prototype.setPropertyBySemantic = function(semantic, value) {
  return this._metadataTable.setPropertyBySemantic(
    this._entityId,
    semantic,
    value
  );
};

// node_modules/cesium/Source/Scene/ImplicitSubdivisionScheme.js
var ImplicitSubdivisionScheme = {
  QUADTREE: "QUADTREE",
  OCTREE: "OCTREE"
};
ImplicitSubdivisionScheme.getBranchingFactor = function(subdivisionScheme) {
  switch (subdivisionScheme) {
    case ImplicitSubdivisionScheme.OCTREE:
      return 8;
    case ImplicitSubdivisionScheme.QUADTREE:
      return 4;
    default:
      throw new DeveloperError_default("subdivisionScheme is not a valid value.");
  }
};
var ImplicitSubdivisionScheme_default = Object.freeze(ImplicitSubdivisionScheme);

// node_modules/cesium/Source/Scene/MetadataEntity.js
function MetadataEntity() {
}
Object.defineProperties(MetadataEntity.prototype, {
  class: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  }
});
MetadataEntity.prototype.hasProperty = function(propertyId) {
  DeveloperError_default.throwInstantiationError();
};
MetadataEntity.prototype.hasPropertyBySemantic = function(semantic) {
  DeveloperError_default.throwInstantiationError();
};
MetadataEntity.prototype.getPropertyIds = function(results) {
  DeveloperError_default.throwInstantiationError();
};
MetadataEntity.prototype.getProperty = function(propertyId) {
  DeveloperError_default.throwInstantiationError();
};
MetadataEntity.prototype.setProperty = function(propertyId, value) {
  DeveloperError_default.throwInstantiationError();
};
MetadataEntity.prototype.getPropertyBySemantic = function(semantic) {
  DeveloperError_default.throwInstantiationError();
};
MetadataEntity.prototype.setPropertyBySemantic = function(semantic, value) {
  DeveloperError_default.throwInstantiationError();
};
MetadataEntity.hasProperty = function(propertyId, properties, classDefinition) {
  Check_default.typeOf.string("propertyId", propertyId);
  Check_default.typeOf.object("properties", properties);
  Check_default.typeOf.object("classDefinition", classDefinition);
  if (defined_default(properties[propertyId])) {
    return true;
  }
  const classProperties = classDefinition.properties;
  if (!defined_default(classProperties)) {
    return false;
  }
  const classProperty = classProperties[propertyId];
  if (defined_default(classProperty) && defined_default(classProperty.default)) {
    return true;
  }
  return false;
};
MetadataEntity.hasPropertyBySemantic = function(semantic, properties, classDefinition) {
  Check_default.typeOf.string("semantic", semantic);
  Check_default.typeOf.object("properties", properties);
  Check_default.typeOf.object("classDefinition", classDefinition);
  const propertiesBySemantic = classDefinition.propertiesBySemantic;
  if (!defined_default(propertiesBySemantic)) {
    return false;
  }
  const property = propertiesBySemantic[semantic];
  return defined_default(property);
};
MetadataEntity.getPropertyIds = function(properties, classDefinition, results) {
  Check_default.typeOf.object("properties", properties);
  Check_default.typeOf.object("classDefinition", classDefinition);
  results = defined_default(results) ? results : [];
  results.length = 0;
  for (const propertyId in properties) {
    if (properties.hasOwnProperty(propertyId) && defined_default(properties[propertyId])) {
      results.push(propertyId);
    }
  }
  const classProperties = classDefinition.properties;
  if (defined_default(classProperties)) {
    for (const classPropertyId in classProperties) {
      if (classProperties.hasOwnProperty(classPropertyId) && !defined_default(properties[classPropertyId]) && defined_default(classProperties[classPropertyId].default)) {
        results.push(classPropertyId);
      }
    }
  }
  return results;
};
MetadataEntity.getProperty = function(propertyId, properties, classDefinition) {
  Check_default.typeOf.string("propertyId", propertyId);
  Check_default.typeOf.object("properties", properties);
  Check_default.typeOf.object("classDefinition", classDefinition);
  if (!defined_default(classDefinition.properties[propertyId])) {
    throw new DeveloperError_default(`Class definition missing property ${propertyId}`);
  }
  const classProperty = classDefinition.properties[propertyId];
  let value = properties[propertyId];
  if (Array.isArray(value)) {
    value = value.slice();
  }
  const enableNestedArrays = true;
  value = classProperty.handleNoData(value);
  if (!defined_default(value) && defined_default(classProperty.default)) {
    value = clone_default(classProperty.default, true);
    return classProperty.unpackVectorAndMatrixTypes(value, enableNestedArrays);
  }
  if (!defined_default(value)) {
    return void 0;
  }
  value = classProperty.normalize(value);
  value = classProperty.applyValueTransform(value);
  return classProperty.unpackVectorAndMatrixTypes(value, enableNestedArrays);
};
MetadataEntity.setProperty = function(propertyId, value, properties, classDefinition) {
  Check_default.typeOf.string("propertyId", propertyId);
  Check_default.defined("value", value);
  Check_default.typeOf.object("properties", properties);
  Check_default.typeOf.object("classDefinition", classDefinition);
  if (!defined_default(properties[propertyId])) {
    return false;
  }
  if (Array.isArray(value)) {
    value = value.slice();
  }
  let classProperty;
  const classProperties = classDefinition.properties;
  if (defined_default(classProperties)) {
    classProperty = classProperties[propertyId];
  }
  const enableNestedArrays = true;
  if (defined_default(classProperty)) {
    value = classProperty.packVectorAndMatrixTypes(value, enableNestedArrays);
    value = classProperty.unapplyValueTransform(value);
    value = classProperty.unnormalize(value);
  }
  properties[propertyId] = value;
  return true;
};
MetadataEntity.getPropertyBySemantic = function(semantic, properties, classDefinition) {
  Check_default.typeOf.string("semantic", semantic);
  Check_default.typeOf.object("properties", properties);
  Check_default.typeOf.object("classDefinition", classDefinition);
  const propertiesBySemantic = classDefinition.propertiesBySemantic;
  if (!defined_default(propertiesBySemantic)) {
    return void 0;
  }
  const property = propertiesBySemantic[semantic];
  if (defined_default(property)) {
    return MetadataEntity.getProperty(property.id, properties, classDefinition);
  }
  return void 0;
};
MetadataEntity.setPropertyBySemantic = function(semantic, value, properties, classDefinition) {
  Check_default.typeOf.string("semantic", semantic);
  Check_default.defined("value", value);
  Check_default.typeOf.object("properties", properties);
  Check_default.typeOf.object("classDefinition", classDefinition);
  const propertiesBySemantic = classDefinition.propertiesBySemantic;
  if (!defined_default(propertiesBySemantic)) {
    return false;
  }
  const property = classDefinition.propertiesBySemantic[semantic];
  if (defined_default(property)) {
    return MetadataEntity.setProperty(
      property.id,
      value,
      properties,
      classDefinition
    );
  }
  return false;
};
var MetadataEntity_default = MetadataEntity;

// node_modules/cesium/Source/Scene/ImplicitSubtreeMetadata.js
function ImplicitSubtreeMetadata(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const subtreeMetadata = options.subtreeMetadata;
  const metadataClass = options.class;
  Check_default.typeOf.object("options.subtreeMetadata", subtreeMetadata);
  Check_default.typeOf.object("options.class", metadataClass);
  const properties = defined_default(subtreeMetadata.properties) ? subtreeMetadata.properties : {};
  this._class = metadataClass;
  this._properties = properties;
  this._extras = subtreeMetadata.extras;
  this._extensions = subtreeMetadata.extensions;
}
Object.defineProperties(ImplicitSubtreeMetadata.prototype, {
  class: {
    get: function() {
      return this._class;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
ImplicitSubtreeMetadata.prototype.hasProperty = function(propertyId) {
  return MetadataEntity_default.hasProperty(propertyId, this._properties, this._class);
};
ImplicitSubtreeMetadata.prototype.hasPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.hasPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
ImplicitSubtreeMetadata.prototype.getPropertyIds = function(results) {
  return MetadataEntity_default.getPropertyIds(this._properties, this._class, results);
};
ImplicitSubtreeMetadata.prototype.getProperty = function(propertyId) {
  return MetadataEntity_default.getProperty(propertyId, this._properties, this._class);
};
ImplicitSubtreeMetadata.prototype.setProperty = function(propertyId, value) {
  return MetadataEntity_default.setProperty(
    propertyId,
    value,
    this._properties,
    this._class
  );
};
ImplicitSubtreeMetadata.prototype.getPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.getPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
ImplicitSubtreeMetadata.prototype.setPropertyBySemantic = function(semantic, value) {
  return MetadataEntity_default.setPropertyBySemantic(
    semantic,
    value,
    this._properties,
    this._class
  );
};
var ImplicitSubtreeMetadata_default = ImplicitSubtreeMetadata;

// node_modules/cesium/Source/Scene/MetadataComponentType.js
var MetadataComponentType = {
  INT8: "INT8",
  UINT8: "UINT8",
  INT16: "INT16",
  UINT16: "UINT16",
  INT32: "INT32",
  UINT32: "UINT32",
  INT64: "INT64",
  UINT64: "UINT64",
  FLOAT32: "FLOAT32",
  FLOAT64: "FLOAT64"
};
MetadataComponentType.getMinimum = function(type) {
  if (!MetadataComponentType.isNumericType(type)) {
    throw new DeveloperError_default("type must be a numeric type");
  }
  switch (type) {
    case MetadataComponentType.INT8:
      return -128;
    case MetadataComponentType.UINT8:
      return 0;
    case MetadataComponentType.INT16:
      return -32768;
    case MetadataComponentType.UINT16:
      return 0;
    case MetadataComponentType.INT32:
      return -2147483648;
    case MetadataComponentType.UINT32:
      return 0;
    case MetadataComponentType.INT64:
      if (FeatureDetection_default.supportsBigInt()) {
        return BigInt("-9223372036854775808");
      }
      return -Math.pow(2, 63);
    case MetadataComponentType.UINT64:
      if (FeatureDetection_default.supportsBigInt()) {
        return BigInt(0);
      }
      return 0;
    case MetadataComponentType.FLOAT32:
      return -34028234663852886e22;
    case MetadataComponentType.FLOAT64:
      return -Number.MAX_VALUE;
  }
};
MetadataComponentType.getMaximum = function(type) {
  if (!MetadataComponentType.isNumericType(type)) {
    throw new DeveloperError_default("type must be a numeric type");
  }
  switch (type) {
    case MetadataComponentType.INT8:
      return 127;
    case MetadataComponentType.UINT8:
      return 255;
    case MetadataComponentType.INT16:
      return 32767;
    case MetadataComponentType.UINT16:
      return 65535;
    case MetadataComponentType.INT32:
      return 2147483647;
    case MetadataComponentType.UINT32:
      return 4294967295;
    case MetadataComponentType.INT64:
      if (FeatureDetection_default.supportsBigInt()) {
        return BigInt("9223372036854775807");
      }
      return Math.pow(2, 63) - 1;
    case MetadataComponentType.UINT64:
      if (FeatureDetection_default.supportsBigInt()) {
        return BigInt("18446744073709551615");
      }
      return Math.pow(2, 64) - 1;
    case MetadataComponentType.FLOAT32:
      return 34028234663852886e22;
    case MetadataComponentType.FLOAT64:
      return Number.MAX_VALUE;
  }
};
MetadataComponentType.isNumericType = function(type) {
  Check_default.typeOf.string("type", type);
  switch (type) {
    case MetadataComponentType.INT8:
    case MetadataComponentType.UINT8:
    case MetadataComponentType.INT16:
    case MetadataComponentType.UINT16:
    case MetadataComponentType.INT32:
    case MetadataComponentType.UINT32:
    case MetadataComponentType.INT64:
    case MetadataComponentType.UINT64:
    case MetadataComponentType.FLOAT32:
    case MetadataComponentType.FLOAT64:
      return true;
    default:
      return false;
  }
};
MetadataComponentType.isIntegerType = function(type) {
  Check_default.typeOf.string("type", type);
  switch (type) {
    case MetadataComponentType.INT8:
    case MetadataComponentType.UINT8:
    case MetadataComponentType.INT16:
    case MetadataComponentType.UINT16:
    case MetadataComponentType.INT32:
    case MetadataComponentType.UINT32:
    case MetadataComponentType.INT64:
    case MetadataComponentType.UINT64:
      return true;
    default:
      return false;
  }
};
MetadataComponentType.isUnsignedIntegerType = function(type) {
  Check_default.typeOf.string("type", type);
  switch (type) {
    case MetadataComponentType.UINT8:
    case MetadataComponentType.UINT16:
    case MetadataComponentType.UINT32:
    case MetadataComponentType.UINT64:
      return true;
    default:
      return false;
  }
};
MetadataComponentType.isVectorCompatible = function(type) {
  Check_default.typeOf.string("type", type);
  switch (type) {
    case MetadataComponentType.INT8:
    case MetadataComponentType.UINT8:
    case MetadataComponentType.INT16:
    case MetadataComponentType.UINT16:
    case MetadataComponentType.INT32:
    case MetadataComponentType.UINT32:
    case MetadataComponentType.FLOAT32:
    case MetadataComponentType.FLOAT64:
      return true;
    default:
      return false;
  }
};
MetadataComponentType.normalize = function(value, type) {
  if (typeof value !== "number" && typeof value !== "bigint") {
    throw new DeveloperError_default("value must be a number or a BigInt");
  }
  if (!MetadataComponentType.isIntegerType(type)) {
    throw new DeveloperError_default("type must be an integer type");
  }
  return Math.max(
    Number(value) / Number(MetadataComponentType.getMaximum(type)),
    -1
  );
};
MetadataComponentType.unnormalize = function(value, type) {
  Check_default.typeOf.number("value", value);
  if (!MetadataComponentType.isIntegerType(type)) {
    throw new DeveloperError_default("type must be an integer type");
  }
  const max3 = MetadataComponentType.getMaximum(type);
  const min3 = MetadataComponentType.isUnsignedIntegerType(type) ? 0 : -max3;
  value = Math_default.sign(value) * Math.round(Math.abs(value) * Number(max3));
  if ((type === MetadataComponentType.INT64 || type === MetadataComponentType.UINT64) && FeatureDetection_default.supportsBigInt()) {
    value = BigInt(value);
  }
  if (value > max3) {
    return max3;
  }
  if (value < min3) {
    return min3;
  }
  return value;
};
MetadataComponentType.applyValueTransform = function(value, offset2, scale) {
  return scale * value + offset2;
};
MetadataComponentType.unapplyValueTransform = function(value, offset2, scale) {
  if (scale === 0) {
    return 0;
  }
  return (value - offset2) / scale;
};
MetadataComponentType.getSizeInBytes = function(type) {
  if (!MetadataComponentType.isNumericType(type)) {
    throw new DeveloperError_default("type must be a numeric type");
  }
  switch (type) {
    case MetadataComponentType.INT8:
    case MetadataComponentType.UINT8:
      return 1;
    case MetadataComponentType.INT16:
    case MetadataComponentType.UINT16:
      return 2;
    case MetadataComponentType.INT32:
    case MetadataComponentType.UINT32:
      return 4;
    case MetadataComponentType.INT64:
    case MetadataComponentType.UINT64:
      return 8;
    case MetadataComponentType.FLOAT32:
      return 4;
    case MetadataComponentType.FLOAT64:
      return 8;
  }
};
var MetadataComponentType_default = Object.freeze(MetadataComponentType);

// node_modules/cesium/Source/Scene/MetadataType.js
var MetadataType = {
  SCALAR: "SCALAR",
  VEC2: "VEC2",
  VEC3: "VEC3",
  VEC4: "VEC4",
  MAT2: "MAT2",
  MAT3: "MAT3",
  MAT4: "MAT4",
  BOOLEAN: "BOOLEAN",
  STRING: "STRING",
  ENUM: "ENUM"
};
MetadataType.isVectorType = function(type) {
  Check_default.typeOf.string("type", type);
  switch (type) {
    case MetadataType.VEC2:
    case MetadataType.VEC3:
    case MetadataType.VEC4:
      return true;
    default:
      return false;
  }
};
MetadataType.isMatrixType = function(type) {
  Check_default.typeOf.string("type", type);
  switch (type) {
    case MetadataType.MAT2:
    case MetadataType.MAT3:
    case MetadataType.MAT4:
      return true;
    default:
      return false;
  }
};
MetadataType.getComponentCount = function(type) {
  Check_default.typeOf.string("type", type);
  switch (type) {
    case MetadataType.SCALAR:
    case MetadataType.STRING:
    case MetadataType.ENUM:
    case MetadataType.BOOLEAN:
      return 1;
    case MetadataType.VEC2:
      return 2;
    case MetadataType.VEC3:
      return 3;
    case MetadataType.VEC4:
      return 4;
    case MetadataType.MAT2:
      return 4;
    case MetadataType.MAT3:
      return 9;
    case MetadataType.MAT4:
      return 16;
    default:
      throw new DeveloperError_default(`Invalid metadata type ${type}`);
  }
};
MetadataType.getMathType = function(type) {
  switch (type) {
    case MetadataType.VEC2:
      return Cartesian2_default;
    case MetadataType.VEC3:
      return Cartesian3_default;
    case MetadataType.VEC4:
      return Cartesian4_default;
    case MetadataType.MAT2:
      return Matrix2_default;
    case MetadataType.MAT3:
      return Matrix3_default;
    case MetadataType.MAT4:
      return Matrix4_default;
    default:
      return void 0;
  }
};
var MetadataType_default = Object.freeze(MetadataType);

// node_modules/cesium/Source/Scene/MetadataClassProperty.js
function MetadataClassProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const id = options.id;
  const property = options.property;
  Check_default.typeOf.string("options.id", id);
  Check_default.typeOf.object("options.property", property);
  Check_default.typeOf.string("options.property.type", property.type);
  const isLegacyExtension = isLegacy(property);
  const parsedType = parseType(property, options.enums);
  const componentType = parsedType.componentType;
  const normalized = defined_default(componentType) && MetadataComponentType_default.isIntegerType(componentType) && defaultValue_default(property.normalized, false);
  this._id = id;
  this._name = property.name;
  this._description = property.description;
  this._semantic = property.semantic;
  this._isLegacyExtension = isLegacyExtension;
  this._type = parsedType.type;
  this._componentType = componentType;
  this._enumType = parsedType.enumType;
  this._valueType = parsedType.valueType;
  this._isArray = parsedType.isArray;
  this._isVariableLengthArray = parsedType.isVariableLengthArray;
  this._arrayLength = parsedType.arrayLength;
  this._min = property.min;
  this._max = property.max;
  this._normalized = normalized;
  let offset2 = property.offset;
  let scale = property.scale;
  const hasValueTransform = defined_default(offset2) || defined_default(scale);
  const enableNestedArrays = true;
  if (!defined_default(offset2)) {
    offset2 = this.expandConstant(0, enableNestedArrays);
  }
  if (!defined_default(scale)) {
    scale = this.expandConstant(1, enableNestedArrays);
  }
  this._offset = offset2;
  this._scale = scale;
  this._hasValueTransform = hasValueTransform;
  this._noData = property.noData;
  this._default = property.default;
  let required;
  if (!defined_default(isLegacyExtension)) {
    required = false;
  } else if (isLegacyExtension) {
    required = defined_default(property.optional) ? !property.optional : true;
  } else {
    required = defaultValue_default(property.required, false);
  }
  this._required = required;
  this._extras = property.extras;
  this._extensions = property.extensions;
}
Object.defineProperties(MetadataClassProperty.prototype, {
  id: {
    get: function() {
      return this._id;
    }
  },
  name: {
    get: function() {
      return this._name;
    }
  },
  description: {
    get: function() {
      return this._description;
    }
  },
  type: {
    get: function() {
      return this._type;
    }
  },
  enumType: {
    get: function() {
      return this._enumType;
    }
  },
  componentType: {
    get: function() {
      return this._componentType;
    }
  },
  valueType: {
    get: function() {
      return this._valueType;
    }
  },
  isArray: {
    get: function() {
      return this._isArray;
    }
  },
  isVariableLengthArray: {
    get: function() {
      return this._isVariableLengthArray;
    }
  },
  arrayLength: {
    get: function() {
      return this._arrayLength;
    }
  },
  normalized: {
    get: function() {
      return this._normalized;
    }
  },
  max: {
    get: function() {
      return this._max;
    }
  },
  min: {
    get: function() {
      return this._min;
    }
  },
  noData: {
    get: function() {
      return this._noData;
    }
  },
  default: {
    get: function() {
      return this._default;
    }
  },
  required: {
    get: function() {
      return this._required;
    }
  },
  semantic: {
    get: function() {
      return this._semantic;
    }
  },
  hasValueTransform: {
    get: function() {
      return this._hasValueTransform;
    }
  },
  offset: {
    get: function() {
      return this._offset;
    }
  },
  scale: {
    get: function() {
      return this._scale;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
function isLegacy(property) {
  if (property.type === "ARRAY") {
    return true;
  }
  const type = property.type;
  if (type === MetadataType_default.SCALAR || MetadataType_default.isMatrixType(type) || MetadataType_default.isVectorType(type)) {
    return false;
  }
  if (MetadataComponentType_default.isNumericType(type)) {
    return true;
  }
  if (defined_default(property.noData) || defined_default(property.scale) || defined_default(property.offset) || defined_default(property.required) || defined_default(property.count) || defined_default(property.array)) {
    return false;
  }
  if (defined_default(property.optional)) {
    return false;
  }
  return void 0;
}
function parseType(property, enums) {
  const type = property.type;
  const componentType = property.componentType;
  const isLegacyArray = type === "ARRAY";
  let isArray;
  let arrayLength;
  let isVariableLengthArray;
  if (isLegacyArray) {
    isArray = true;
    arrayLength = property.componentCount;
    isVariableLengthArray = !defined_default(arrayLength);
  } else if (property.array) {
    isArray = true;
    arrayLength = property.count;
    isVariableLengthArray = !defined_default(property.count);
  } else {
    isArray = false;
    arrayLength = void 0;
    isVariableLengthArray = false;
  }
  let enumType;
  if (defined_default(property.enumType)) {
    enumType = enums[property.enumType];
  }
  if (type === MetadataType_default.ENUM) {
    return {
      type,
      componentType: void 0,
      enumType,
      valueType: enumType.valueType,
      isArray,
      isVariableLengthArray,
      arrayLength
    };
  }
  if (isLegacyArray && componentType === MetadataType_default.ENUM) {
    return {
      type: componentType,
      componentType: void 0,
      enumType,
      valueType: enumType.valueType,
      isArray,
      isVariableLengthArray,
      arrayLength
    };
  }
  if (type === MetadataType_default.SCALAR || MetadataType_default.isMatrixType(type) || MetadataType_default.isVectorType(type)) {
    return {
      type,
      componentType,
      enumType: void 0,
      valueType: componentType,
      isArray,
      isVariableLengthArray,
      arrayLength
    };
  }
  if (type === MetadataType_default.BOOLEAN || type === MetadataType_default.STRING) {
    return {
      type,
      componentType: void 0,
      enumType: void 0,
      valueType: void 0,
      isArray,
      isVariableLengthArray,
      arrayLength
    };
  }
  if (isLegacyArray && (componentType === MetadataType_default.BOOLEAN || componentType === MetadataType_default.STRING)) {
    return {
      type: componentType,
      componentType: void 0,
      enumType: void 0,
      valueType: void 0,
      isArray,
      isVariableLengthArray,
      arrayLength
    };
  }
  if (defined_default(componentType) && MetadataComponentType_default.isNumericType(componentType)) {
    return {
      type: MetadataType_default.SCALAR,
      componentType,
      enumType: void 0,
      valueType: componentType,
      isArray,
      isVariableLengthArray,
      arrayLength
    };
  }
  if (MetadataComponentType_default.isNumericType(type)) {
    return {
      type: MetadataType_default.SCALAR,
      componentType: type,
      enumType: void 0,
      valueType: type,
      isArray,
      isVariableLengthArray,
      arrayLength
    };
  }
  throw new DeveloperError_default(
    `unknown metadata type {type: ${type}, componentType: ${componentType})`
  );
}
MetadataClassProperty.prototype.normalize = function(value) {
  if (!this._normalized) {
    return value;
  }
  return normalizeInPlace(
    value,
    this._valueType,
    MetadataComponentType_default.normalize
  );
};
MetadataClassProperty.prototype.unnormalize = function(value) {
  if (!this._normalized) {
    return value;
  }
  return normalizeInPlace(
    value,
    this._valueType,
    MetadataComponentType_default.unnormalize
  );
};
MetadataClassProperty.prototype.applyValueTransform = function(value) {
  if (!this._hasValueTransform || this._isVariableLengthArray) {
    return value;
  }
  return MetadataClassProperty.valueTransformInPlace(
    value,
    this._offset,
    this._scale,
    MetadataComponentType_default.applyValueTransform
  );
};
MetadataClassProperty.prototype.unapplyValueTransform = function(value) {
  if (!this._hasValueTransform || this._isVariableLengthArray) {
    return value;
  }
  return MetadataClassProperty.valueTransformInPlace(
    value,
    this._offset,
    this._scale,
    MetadataComponentType_default.unapplyValueTransform
  );
};
MetadataClassProperty.prototype.expandConstant = function(constant, enableNestedArrays) {
  enableNestedArrays = defaultValue_default(enableNestedArrays, false);
  const isArray = this._isArray;
  const arrayLength = this._arrayLength;
  const componentCount = MetadataType_default.getComponentCount(this._type);
  const isNested = isArray && componentCount > 1;
  if (!isArray && componentCount === 1) {
    return constant;
  }
  if (!isArray) {
    return new Array(componentCount).fill(constant);
  }
  if (!isNested) {
    return new Array(arrayLength).fill(constant);
  }
  if (!enableNestedArrays) {
    return new Array(this._arrayLength * componentCount).fill(constant);
  }
  const innerConstant = new Array(componentCount).fill(constant);
  return new Array(this._arrayLength).fill(innerConstant);
};
MetadataClassProperty.prototype.handleNoData = function(value) {
  const sentinel = this._noData;
  if (!defined_default(sentinel)) {
    return value;
  }
  if (arrayEquals(value, sentinel)) {
    return void 0;
  }
  return value;
};
function arrayEquals(left, right) {
  if (!Array.isArray(left)) {
    return left === right;
  }
  if (!Array.isArray(right)) {
    return false;
  }
  if (left.length !== right.length) {
    return false;
  }
  for (let i2 = 0; i2 < left.length; i2++) {
    if (!arrayEquals(left[i2], right[i2])) {
      return false;
    }
  }
  return true;
}
MetadataClassProperty.prototype.unpackVectorAndMatrixTypes = function(value, enableNestedArrays) {
  enableNestedArrays = defaultValue_default(enableNestedArrays, false);
  const MathType = MetadataType_default.getMathType(this._type);
  const isArray = this._isArray;
  const componentCount = MetadataType_default.getComponentCount(this._type);
  const isNested = isArray && componentCount > 1;
  if (!defined_default(MathType)) {
    return value;
  }
  if (enableNestedArrays && isNested) {
    return value.map(function(x) {
      return MathType.unpack(x);
    });
  }
  if (isArray) {
    return MathType.unpackArray(value);
  }
  return MathType.unpack(value);
};
MetadataClassProperty.prototype.packVectorAndMatrixTypes = function(value, enableNestedArrays) {
  enableNestedArrays = defaultValue_default(enableNestedArrays, false);
  const MathType = MetadataType_default.getMathType(this._type);
  const isArray = this._isArray;
  const componentCount = MetadataType_default.getComponentCount(this._type);
  const isNested = isArray && componentCount > 1;
  if (!defined_default(MathType)) {
    return value;
  }
  if (enableNestedArrays && isNested) {
    return value.map(function(x) {
      return MathType.pack(x, []);
    });
  }
  if (isArray) {
    return MathType.packArray(value, []);
  }
  return MathType.pack(value, []);
};
MetadataClassProperty.prototype.validate = function(value) {
  if (!defined_default(value) && defined_default(this._default)) {
    return void 0;
  }
  if (this._required && !defined_default(value)) {
    return `required property must have a value`;
  }
  if (this._isArray) {
    return validateArray(this, value);
  }
  return validateSingleValue(this, value);
};
function validateArray(classProperty, value) {
  if (!Array.isArray(value)) {
    return `value ${value} must be an array`;
  }
  const length3 = value.length;
  if (!classProperty._isVariableLengthArray && length3 !== classProperty._arrayLength) {
    return "Array length does not match property.arrayLength";
  }
  for (let i2 = 0; i2 < length3; i2++) {
    const message = validateSingleValue(classProperty, value[i2]);
    if (defined_default(message)) {
      return message;
    }
  }
}
function validateSingleValue(classProperty, value) {
  const type = classProperty._type;
  const componentType = classProperty._componentType;
  const enumType = classProperty._enumType;
  const normalized = classProperty._normalized;
  if (MetadataType_default.isVectorType(type)) {
    return validateVector(value, type, componentType);
  } else if (MetadataType_default.isMatrixType(type)) {
    return validateMatrix(value, type, componentType);
  } else if (type === MetadataType_default.STRING) {
    return validateString(value);
  } else if (type === MetadataType_default.BOOLEAN) {
    return validateBoolean(value);
  } else if (type === MetadataType_default.ENUM) {
    return validateEnum(value, enumType);
  }
  return validateScalar(value, componentType, normalized);
}
function validateVector(value, type, componentType) {
  if (!MetadataComponentType_default.isVectorCompatible(componentType)) {
    return `componentType ${componentType} is incompatible with vector type ${type}`;
  }
  if (type === MetadataType_default.VEC2 && !(value instanceof Cartesian2_default)) {
    return `vector value ${value} must be a Cartesian2`;
  }
  if (type === MetadataType_default.VEC3 && !(value instanceof Cartesian3_default)) {
    return `vector value ${value} must be a Cartesian3`;
  }
  if (type === MetadataType_default.VEC4 && !(value instanceof Cartesian4_default)) {
    return `vector value ${value} must be a Cartesian4`;
  }
}
function validateMatrix(value, type, componentType) {
  if (!MetadataComponentType_default.isVectorCompatible(componentType)) {
    return `componentType ${componentType} is incompatible with matrix type ${type}`;
  }
  if (type === MetadataType_default.MAT2 && !(value instanceof Matrix2_default)) {
    return `matrix value ${value} must be a Matrix2`;
  }
  if (type === MetadataType_default.MAT3 && !(value instanceof Matrix3_default)) {
    return `matrix value ${value} must be a Matrix3`;
  }
  if (type === MetadataType_default.MAT4 && !(value instanceof Matrix4_default)) {
    return `matrix value ${value} must be a Matrix4`;
  }
}
function validateString(value) {
  if (typeof value !== "string") {
    return getTypeErrorMessage(value, MetadataType_default.STRING);
  }
}
function validateBoolean(value) {
  if (typeof value !== "boolean") {
    return getTypeErrorMessage(value, MetadataType_default.BOOLEAN);
  }
}
function validateEnum(value, enumType) {
  const javascriptType = typeof value;
  if (defined_default(enumType)) {
    if (javascriptType !== "string" || !defined_default(enumType.valuesByName[value])) {
      return `value ${value} is not a valid enum name for ${enumType.id}`;
    }
    return;
  }
}
function validateScalar(value, componentType, normalized) {
  const javascriptType = typeof value;
  switch (componentType) {
    case MetadataComponentType_default.INT8:
    case MetadataComponentType_default.UINT8:
    case MetadataComponentType_default.INT16:
    case MetadataComponentType_default.UINT16:
    case MetadataComponentType_default.INT32:
    case MetadataComponentType_default.UINT32:
    case MetadataComponentType_default.FLOAT32:
    case MetadataComponentType_default.FLOAT64:
      if (javascriptType !== "number") {
        return getTypeErrorMessage(value, componentType);
      }
      if (!isFinite(value)) {
        return getNonFiniteErrorMessage(value, componentType);
      }
      return checkInRange(value, componentType, normalized);
    case MetadataComponentType_default.INT64:
    case MetadataComponentType_default.UINT64:
      if (javascriptType !== "number" && javascriptType !== "bigint") {
        return getTypeErrorMessage(value, componentType);
      }
      if (javascriptType === "number" && !isFinite(value)) {
        return getNonFiniteErrorMessage(value, componentType);
      }
      return checkInRange(value, componentType, normalized);
  }
}
function getTypeErrorMessage(value, type) {
  return `value ${value} does not match type ${type}`;
}
function getOutOfRangeErrorMessage(value, type, normalized) {
  let errorMessage = `value ${value} is out of range for type ${type}`;
  if (normalized) {
    errorMessage += " (normalized)";
  }
  return errorMessage;
}
function checkInRange(value, componentType, normalized) {
  if (normalized) {
    const min3 = MetadataComponentType_default.isUnsignedIntegerType(componentType) ? 0 : -1;
    const max3 = 1;
    if (value < min3 || value > max3) {
      return getOutOfRangeErrorMessage(value, componentType, normalized);
    }
    return;
  }
  if (value < MetadataComponentType_default.getMinimum(componentType) || value > MetadataComponentType_default.getMaximum(componentType)) {
    return getOutOfRangeErrorMessage(value, componentType, normalized);
  }
}
function getNonFiniteErrorMessage(value, type) {
  return `value ${value} of type ${type} must be finite`;
}
function normalizeInPlace(values, valueType, normalizeFunction) {
  if (!Array.isArray(values)) {
    return normalizeFunction(values, valueType);
  }
  for (let i2 = 0; i2 < values.length; i2++) {
    values[i2] = normalizeInPlace(values[i2], valueType, normalizeFunction);
  }
  return values;
}
MetadataClassProperty.valueTransformInPlace = function(values, offsets, scales, transformationFunction) {
  if (!Array.isArray(values)) {
    return transformationFunction(values, offsets, scales);
  }
  for (let i2 = 0; i2 < values.length; i2++) {
    values[i2] = MetadataClassProperty.valueTransformInPlace(
      values[i2],
      offsets[i2],
      scales[i2],
      transformationFunction
    );
  }
  return values;
};
var MetadataClassProperty_default = MetadataClassProperty;

// node_modules/cesium/Source/Scene/MetadataTableProperty.js
function MetadataTableProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const count = options.count;
  const property = options.property;
  const classProperty = options.classProperty;
  const bufferViews = options.bufferViews;
  Check_default.typeOf.number.greaterThan("options.count", count, 0);
  Check_default.typeOf.object("options.property", property);
  Check_default.typeOf.object("options.classProperty", classProperty);
  Check_default.typeOf.object("options.bufferViews", bufferViews);
  const type = classProperty.type;
  const isArray = classProperty.isArray;
  const isVariableLengthArray = classProperty.isVariableLengthArray;
  let valueType = classProperty.valueType;
  const enumType = classProperty.enumType;
  const hasStrings = type === MetadataType_default.STRING;
  const hasBooleans = type === MetadataType_default.BOOLEAN;
  let arrayOffsets;
  if (isVariableLengthArray) {
    let arrayOffsetType = defaultValue_default(
      property.arrayOffsetType,
      property.offsetType
    );
    arrayOffsetType = defaultValue_default(
      MetadataComponentType_default[arrayOffsetType],
      MetadataComponentType_default.UINT32
    );
    const arrayOffsetBufferView = defaultValue_default(
      property.arrayOffsets,
      property.arrayOffsetBufferView
    );
    arrayOffsets = new BufferView(
      bufferViews[arrayOffsetBufferView],
      arrayOffsetType,
      count + 1
    );
  }
  const vectorComponentCount = MetadataType_default.getComponentCount(type);
  let arrayComponentCount;
  if (isVariableLengthArray) {
    arrayComponentCount = arrayOffsets.get(count) - arrayOffsets.get(0);
  } else if (isArray) {
    arrayComponentCount = count * classProperty.arrayLength;
  } else {
    arrayComponentCount = count;
  }
  const componentCount = vectorComponentCount * arrayComponentCount;
  let stringOffsets;
  if (hasStrings) {
    let stringOffsetType = defaultValue_default(
      property.stringOffsetType,
      property.offsetType
    );
    stringOffsetType = defaultValue_default(
      MetadataComponentType_default[stringOffsetType],
      MetadataComponentType_default.UINT32
    );
    const stringOffsetBufferView = defaultValue_default(
      property.stringOffsets,
      property.stringOffsetBufferView
    );
    stringOffsets = new BufferView(
      bufferViews[stringOffsetBufferView],
      stringOffsetType,
      componentCount + 1
    );
  }
  if (hasStrings || hasBooleans) {
    valueType = MetadataComponentType_default.UINT8;
  }
  let valueCount;
  if (hasStrings) {
    valueCount = stringOffsets.get(componentCount) - stringOffsets.get(0);
  } else if (hasBooleans) {
    valueCount = Math.ceil(componentCount / 8);
  } else {
    valueCount = componentCount;
  }
  const valuesBufferView = defaultValue_default(property.values, property.bufferView);
  const values = new BufferView(
    bufferViews[valuesBufferView],
    valueType,
    valueCount
  );
  let offset2 = property.offset;
  let scale = property.scale;
  const hasValueTransform = classProperty.hasValueTransform || defined_default(offset2) || defined_default(scale);
  offset2 = defaultValue_default(offset2, classProperty.offset);
  scale = defaultValue_default(scale, classProperty.scale);
  offset2 = flatten(offset2);
  scale = flatten(scale);
  let getValueFunction;
  let setValueFunction;
  const that = this;
  if (hasStrings) {
    getValueFunction = function(index2) {
      return getString(index2, that._values, that._stringOffsets);
    };
  } else if (hasBooleans) {
    getValueFunction = function(index2) {
      return getBoolean(index2, that._values);
    };
    setValueFunction = function(index2, value) {
      setBoolean(index2, that._values, value);
    };
  } else if (defined_default(enumType)) {
    getValueFunction = function(index2) {
      const integer = that._values.get(index2);
      return enumType.namesByValue[integer];
    };
    setValueFunction = function(index2, value) {
      const integer = enumType.valuesByName[value];
      that._values.set(index2, integer);
    };
  } else {
    getValueFunction = function(index2) {
      return that._values.get(index2);
    };
    setValueFunction = function(index2, value) {
      that._values.set(index2, value);
    };
  }
  this._arrayOffsets = arrayOffsets;
  this._stringOffsets = stringOffsets;
  this._values = values;
  this._classProperty = classProperty;
  this._count = count;
  this._vectorComponentCount = vectorComponentCount;
  this._min = property.min;
  this._max = property.max;
  this._offset = offset2;
  this._scale = scale;
  this._hasValueTransform = hasValueTransform;
  this._getValue = getValueFunction;
  this._setValue = setValueFunction;
  this._unpackedValues = void 0;
  this._extras = property.extras;
  this._extensions = property.extensions;
}
Object.defineProperties(MetadataTableProperty.prototype, {
  hasValueTransform: {
    get: function() {
      return this._hasValueTransform;
    }
  },
  offset: {
    get: function() {
      return this._offset;
    }
  },
  scale: {
    get: function() {
      return this._scale;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
MetadataTableProperty.prototype.get = function(index2) {
  checkIndex(this, index2);
  let value = get(this, index2);
  value = this._classProperty.handleNoData(value);
  if (!defined_default(value)) {
    value = this._classProperty.default;
    return this._classProperty.unpackVectorAndMatrixTypes(value);
  }
  value = this._classProperty.normalize(value);
  value = applyValueTransform(this, value);
  return this._classProperty.unpackVectorAndMatrixTypes(value);
};
MetadataTableProperty.prototype.set = function(index2, value) {
  const classProperty = this._classProperty;
  Check_default.defined("value", value);
  checkIndex(this, index2);
  const errorMessage = classProperty.validate(value);
  if (defined_default(errorMessage)) {
    throw new DeveloperError_default(errorMessage);
  }
  value = classProperty.packVectorAndMatrixTypes(value);
  value = unapplyValueTransform(this, value);
  value = classProperty.unnormalize(value);
  set(this, index2, value);
};
MetadataTableProperty.prototype.getTypedArray = function() {
  if (defined_default(this._values)) {
    return this._values.typedArray;
  }
  return void 0;
};
function flatten(values) {
  if (!Array.isArray(values)) {
    return values;
  }
  const result = [];
  for (let i2 = 0; i2 < values.length; i2++) {
    const value = values[i2];
    if (Array.isArray(value)) {
      result.push.apply(result, value);
    } else {
      result.push(value);
    }
  }
  return result;
}
function checkIndex(table2, index2) {
  const count = table2._count;
  if (!defined_default(index2) || index2 < 0 || index2 >= count) {
    const maximumIndex = count - 1;
    throw new DeveloperError_default(
      `index is required and between zero and count - 1. Actual value: ${maximumIndex}`
    );
  }
}
function get(property, index2) {
  if (requiresUnpackForGet(property)) {
    unpackProperty(property);
  }
  const classProperty = property._classProperty;
  const isArray = classProperty.isArray;
  const type = classProperty.type;
  const componentCount = MetadataType_default.getComponentCount(type);
  if (defined_default(property._unpackedValues)) {
    const value = property._unpackedValues[index2];
    if (isArray) {
      return clone_default(value, true);
    }
    return value;
  }
  if (!isArray && componentCount === 1) {
    return property._getValue(index2);
  }
  return getArrayValues(property, classProperty, index2);
}
function getArrayValues(property, classProperty, index2) {
  let offset2;
  let length3;
  if (classProperty.isVariableLengthArray) {
    offset2 = property._arrayOffsets.get(index2);
    length3 = property._arrayOffsets.get(index2 + 1) - offset2;
    const componentCount = MetadataType_default.getComponentCount(classProperty.type);
    offset2 *= componentCount;
    length3 *= componentCount;
  } else {
    const arrayLength = defaultValue_default(classProperty.arrayLength, 1);
    const componentCount = arrayLength * property._vectorComponentCount;
    offset2 = index2 * componentCount;
    length3 = componentCount;
  }
  const values = new Array(length3);
  for (let i2 = 0; i2 < length3; i2++) {
    values[i2] = property._getValue(offset2 + i2);
  }
  return values;
}
function set(property, index2, value) {
  if (requiresUnpackForSet(property, index2, value)) {
    unpackProperty(property);
  }
  const classProperty = property._classProperty;
  const isArray = classProperty.isArray;
  const type = classProperty.type;
  const componentCount = MetadataType_default.getComponentCount(type);
  if (defined_default(property._unpackedValues)) {
    if (classProperty.isArray) {
      value = clone_default(value, true);
    }
    property._unpackedValues[index2] = value;
    return;
  }
  if (!isArray && componentCount === 1) {
    property._setValue(index2, value);
    return;
  }
  let offset2;
  let length3;
  if (classProperty.isVariableLengthArray) {
    offset2 = property._arrayOffsets.get(index2);
    length3 = property._arrayOffsets.get(index2 + 1) - offset2;
  } else {
    const arrayLength = defaultValue_default(classProperty.arrayLength, 1);
    const componentCount2 = arrayLength * property._vectorComponentCount;
    offset2 = index2 * componentCount2;
    length3 = componentCount2;
  }
  for (let i2 = 0; i2 < length3; ++i2) {
    property._setValue(offset2 + i2, value[i2]);
  }
}
function getString(index2, values, stringOffsets) {
  const stringByteOffset = stringOffsets.get(index2);
  const stringByteLength = stringOffsets.get(index2 + 1) - stringByteOffset;
  return getStringFromTypedArray_default(
    values.typedArray,
    stringByteOffset,
    stringByteLength
  );
}
function getBoolean(index2, values) {
  const byteIndex = index2 >> 3;
  const bitIndex = index2 % 8;
  return (values.typedArray[byteIndex] >> bitIndex & 1) === 1;
}
function setBoolean(index2, values, value) {
  const byteIndex = index2 >> 3;
  const bitIndex = index2 % 8;
  if (value) {
    values.typedArray[byteIndex] |= 1 << bitIndex;
  } else {
    values.typedArray[byteIndex] &= ~(1 << bitIndex);
  }
}
function getInt64NumberFallback(index2, values) {
  const dataView = values.dataView;
  const byteOffset = index2 * 8;
  let value = 0;
  const isNegative = (dataView.getUint8(byteOffset + 7) & 128) > 0;
  let carrying = true;
  for (let i2 = 0; i2 < 8; ++i2) {
    let byte = dataView.getUint8(byteOffset + i2);
    if (isNegative) {
      if (carrying) {
        if (byte !== 0) {
          byte = ~(byte - 1) & 255;
          carrying = false;
        }
      } else {
        byte = ~byte & 255;
      }
    }
    value += byte * Math.pow(256, i2);
  }
  if (isNegative) {
    value = -value;
  }
  return value;
}
function getInt64BigIntFallback(index2, values) {
  const dataView = values.dataView;
  const byteOffset = index2 * 8;
  let value = BigInt(0);
  const isNegative = (dataView.getUint8(byteOffset + 7) & 128) > 0;
  let carrying = true;
  for (let i2 = 0; i2 < 8; ++i2) {
    let byte = dataView.getUint8(byteOffset + i2);
    if (isNegative) {
      if (carrying) {
        if (byte !== 0) {
          byte = ~(byte - 1) & 255;
          carrying = false;
        }
      } else {
        byte = ~byte & 255;
      }
    }
    value += BigInt(byte) * (BigInt(1) << BigInt(i2 * 8));
  }
  if (isNegative) {
    value = -value;
  }
  return value;
}
function getUint64NumberFallback(index2, values) {
  const dataView = values.dataView;
  const byteOffset = index2 * 8;
  const left = dataView.getUint32(byteOffset, true);
  const right = dataView.getUint32(byteOffset + 4, true);
  const value = left + 4294967296 * right;
  return value;
}
function getUint64BigIntFallback(index2, values) {
  const dataView = values.dataView;
  const byteOffset = index2 * 8;
  const left = BigInt(dataView.getUint32(byteOffset, true));
  const right = BigInt(dataView.getUint32(byteOffset + 4, true));
  const value = left + BigInt(4294967296) * right;
  return value;
}
function getComponentDatatype(componentType) {
  switch (componentType) {
    case MetadataComponentType_default.INT8:
      return ComponentDatatype_default.BYTE;
    case MetadataComponentType_default.UINT8:
      return ComponentDatatype_default.UNSIGNED_BYTE;
    case MetadataComponentType_default.INT16:
      return ComponentDatatype_default.SHORT;
    case MetadataComponentType_default.UINT16:
      return ComponentDatatype_default.UNSIGNED_SHORT;
    case MetadataComponentType_default.INT32:
      return ComponentDatatype_default.INT;
    case MetadataComponentType_default.UINT32:
      return ComponentDatatype_default.UNSIGNED_INT;
    case MetadataComponentType_default.FLOAT32:
      return ComponentDatatype_default.FLOAT;
    case MetadataComponentType_default.FLOAT64:
      return ComponentDatatype_default.DOUBLE;
  }
}
function requiresUnpackForGet(property) {
  if (defined_default(property._unpackedValues)) {
    return false;
  }
  const classProperty = property._classProperty;
  const type = classProperty.type;
  const valueType = classProperty.valueType;
  if (type === MetadataType_default.STRING) {
    return true;
  }
  if (valueType === MetadataComponentType_default.INT64 && !FeatureDetection_default.supportsBigInt64Array()) {
    return true;
  }
  if (valueType === MetadataComponentType_default.UINT64 && !FeatureDetection_default.supportsBigUint64Array()) {
    return true;
  }
  return false;
}
function requiresUnpackForSet(property, index2, value) {
  if (requiresUnpackForGet(property)) {
    return true;
  }
  const arrayOffsets = property._arrayOffsets;
  if (defined_default(arrayOffsets)) {
    const oldLength = arrayOffsets.get(index2 + 1) - arrayOffsets.get(index2);
    const newLength = value.length;
    if (oldLength !== newLength) {
      return true;
    }
  }
  return false;
}
function unpackProperty(property) {
  property._unpackedValues = unpackValues(property);
  property._arrayOffsets = void 0;
  property._stringOffsets = void 0;
  property._values = void 0;
}
function unpackValues(property) {
  const count = property._count;
  const unpackedValues = new Array(count);
  const classProperty = property._classProperty;
  const isArray = classProperty.isArray;
  const type = classProperty.type;
  const componentCount = MetadataType_default.getComponentCount(type);
  if (!isArray && componentCount === 1) {
    for (let i2 = 0; i2 < count; ++i2) {
      unpackedValues[i2] = property._getValue(i2);
    }
    return unpackedValues;
  }
  for (let i2 = 0; i2 < count; i2++) {
    unpackedValues[i2] = getArrayValues(property, classProperty, i2);
  }
  return unpackedValues;
}
function applyValueTransform(property, value) {
  const classProperty = property._classProperty;
  const isVariableLengthArray = classProperty.isVariableLengthArray;
  if (!property._hasValueTransform || isVariableLengthArray) {
    return value;
  }
  return MetadataClassProperty_default.valueTransformInPlace(
    value,
    property._offset,
    property._scale,
    MetadataComponentType_default.applyValueTransform
  );
}
function unapplyValueTransform(property, value) {
  const classProperty = property._classProperty;
  const isVariableLengthArray = classProperty.isVariableLengthArray;
  if (!property._hasValueTransform || isVariableLengthArray) {
    return value;
  }
  return MetadataClassProperty_default.valueTransformInPlace(
    value,
    property._offset,
    property._scale,
    MetadataComponentType_default.unapplyValueTransform
  );
}
function BufferView(bufferView, componentType, length3) {
  const that = this;
  let typedArray;
  let getFunction;
  let setFunction;
  if (componentType === MetadataComponentType_default.INT64) {
    if (!FeatureDetection_default.supportsBigInt()) {
      oneTimeWarning_default(
        "INT64 type is not fully supported on this platform. Values greater than 2^53 - 1 or less than -(2^53 - 1) may lose precision when read."
      );
      typedArray = new Uint8Array(
        bufferView.buffer,
        bufferView.byteOffset,
        length3 * 8
      );
      getFunction = function(index2) {
        return getInt64NumberFallback(index2, that);
      };
    } else if (!FeatureDetection_default.supportsBigInt64Array()) {
      typedArray = new Uint8Array(
        bufferView.buffer,
        bufferView.byteOffset,
        length3 * 8
      );
      getFunction = function(index2) {
        return getInt64BigIntFallback(index2, that);
      };
    } else {
      typedArray = new BigInt64Array(
        bufferView.buffer,
        bufferView.byteOffset,
        length3
      );
      setFunction = function(index2, value) {
        that.typedArray[index2] = BigInt(value);
      };
    }
  } else if (componentType === MetadataComponentType_default.UINT64) {
    if (!FeatureDetection_default.supportsBigInt()) {
      oneTimeWarning_default(
        "UINT64 type is not fully supported on this platform. Values greater than 2^53 - 1 may lose precision when read."
      );
      typedArray = new Uint8Array(
        bufferView.buffer,
        bufferView.byteOffset,
        length3 * 8
      );
      getFunction = function(index2) {
        return getUint64NumberFallback(index2, that);
      };
    } else if (!FeatureDetection_default.supportsBigUint64Array()) {
      typedArray = new Uint8Array(
        bufferView.buffer,
        bufferView.byteOffset,
        length3 * 8
      );
      getFunction = function(index2) {
        return getUint64BigIntFallback(index2, that);
      };
    } else {
      typedArray = new BigUint64Array(
        bufferView.buffer,
        bufferView.byteOffset,
        length3
      );
      setFunction = function(index2, value) {
        that.typedArray[index2] = BigInt(value);
      };
    }
  } else {
    const componentDatatype = getComponentDatatype(componentType);
    typedArray = ComponentDatatype_default.createArrayBufferView(
      componentDatatype,
      bufferView.buffer,
      bufferView.byteOffset,
      length3
    );
    setFunction = function(index2, value) {
      that.typedArray[index2] = value;
    };
  }
  if (!defined_default(getFunction)) {
    getFunction = function(index2) {
      return that.typedArray[index2];
    };
  }
  this.typedArray = typedArray;
  this.dataView = new DataView(typedArray.buffer, typedArray.byteOffset);
  this.get = getFunction;
  this.set = setFunction;
  this._componentType = componentType;
}
var MetadataTableProperty_default = MetadataTableProperty;

// node_modules/cesium/Source/Scene/MetadataTable.js
function MetadataTable(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const count = options.count;
  const metadataClass = options.class;
  Check_default.typeOf.number.greaterThan("options.count", count, 0);
  Check_default.typeOf.object("options.class", metadataClass);
  const properties = {};
  if (defined_default(options.properties)) {
    for (const propertyId in options.properties) {
      if (options.properties.hasOwnProperty(propertyId)) {
        properties[propertyId] = new MetadataTableProperty_default({
          count,
          property: options.properties[propertyId],
          classProperty: metadataClass.properties[propertyId],
          bufferViews: options.bufferViews
        });
      }
    }
  }
  this._count = count;
  this._class = metadataClass;
  this._properties = properties;
}
Object.defineProperties(MetadataTable.prototype, {
  count: {
    get: function() {
      return this._count;
    }
  },
  class: {
    get: function() {
      return this._class;
    }
  }
});
MetadataTable.prototype.hasProperty = function(propertyId) {
  return MetadataEntity_default.hasProperty(propertyId, this._properties, this._class);
};
MetadataTable.prototype.hasPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.hasPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
MetadataTable.prototype.getPropertyIds = function(results) {
  return MetadataEntity_default.getPropertyIds(this._properties, this._class, results);
};
MetadataTable.prototype.getProperty = function(index2, propertyId) {
  Check_default.typeOf.string("propertyId", propertyId);
  const property = this._properties[propertyId];
  let value;
  if (defined_default(property)) {
    value = property.get(index2);
  } else {
    value = getDefault(this._class, propertyId);
  }
  return value;
};
MetadataTable.prototype.setProperty = function(index2, propertyId, value) {
  Check_default.typeOf.string("propertyId", propertyId);
  const property = this._properties[propertyId];
  if (defined_default(property)) {
    property.set(index2, value);
    return true;
  }
  return false;
};
MetadataTable.prototype.getPropertyBySemantic = function(index2, semantic) {
  Check_default.typeOf.string("semantic", semantic);
  let property;
  const propertiesBySemantic = this._class.propertiesBySemantic;
  if (defined_default(propertiesBySemantic)) {
    property = propertiesBySemantic[semantic];
  }
  if (defined_default(property)) {
    return this.getProperty(index2, property.id);
  }
  return void 0;
};
MetadataTable.prototype.setPropertyBySemantic = function(index2, semantic, value) {
  Check_default.typeOf.string("semantic", semantic);
  let property;
  const propertiesBySemantic = this._class.propertiesBySemantic;
  if (defined_default(propertiesBySemantic)) {
    property = propertiesBySemantic[semantic];
  }
  if (defined_default(property)) {
    return this.setProperty(index2, property.id, value);
  }
  return false;
};
MetadataTable.prototype.getPropertyTypedArray = function(propertyId) {
  Check_default.typeOf.string("propertyId", propertyId);
  const property = this._properties[propertyId];
  if (defined_default(property)) {
    return property.getTypedArray();
  }
  return void 0;
};
MetadataTable.prototype.getPropertyTypedArrayBySemantic = function(semantic) {
  Check_default.typeOf.string("semantic", semantic);
  let property;
  const propertiesBySemantic = this._class.propertiesBySemantic;
  if (defined_default(propertiesBySemantic)) {
    property = propertiesBySemantic[semantic];
  }
  if (defined_default(property)) {
    return this.getPropertyTypedArray(property.id);
  }
  return void 0;
};
function getDefault(classDefinition, propertyId) {
  const classProperties = classDefinition.properties;
  if (!defined_default(classProperties)) {
    return void 0;
  }
  const classProperty = classProperties[propertyId];
  if (defined_default(classProperty) && defined_default(classProperty.default)) {
    let value = classProperty.default;
    if (classProperty.isArray) {
      value = clone_default(value, true);
    }
    value = classProperty.normalize(value);
    return classProperty.unpackVectorAndMatrixTypes(value);
  }
}
var MetadataTable_default = MetadataTable;

// node_modules/cesium/Source/Scene/ResourceLoader.js
function ResourceLoader() {
}
Object.defineProperties(ResourceLoader.prototype, {
  promise: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  cacheKey: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  }
});
ResourceLoader.prototype.load = function() {
  DeveloperError_default.throwInstantiationError();
};
ResourceLoader.prototype.unload = function() {
};
ResourceLoader.prototype.process = function(frameState) {
};
ResourceLoader.prototype.getError = function(errorMessage, error) {
  Check_default.typeOf.string("errorMessage", errorMessage);
  if (defined_default(error)) {
    errorMessage += `
${error.message}`;
  }
  return new RuntimeError_default(errorMessage);
};
ResourceLoader.prototype.isDestroyed = function() {
  return false;
};
ResourceLoader.prototype.destroy = function() {
  this.unload();
  return destroyObject_default(this);
};

// node_modules/cesium/Source/Scene/ResourceLoaderState.js
var ResourceLoaderState = {
  UNLOADED: 0,
  LOADING: 1,
  PROCESSING: 2,
  READY: 3,
  FAILED: 4
};
var ResourceLoaderState_default = Object.freeze(ResourceLoaderState);

// node_modules/cesium/Source/Scene/BufferLoader.js
function BufferLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const typedArray = options.typedArray;
  const resource = options.resource;
  const cacheKey = options.cacheKey;
  if (defined_default(typedArray) === defined_default(resource)) {
    throw new DeveloperError_default(
      "One of options.typedArray and options.resource must be defined."
    );
  }
  this._typedArray = typedArray;
  this._resource = resource;
  this._cacheKey = cacheKey;
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  BufferLoader.prototype = Object.create(ResourceLoader.prototype);
  BufferLoader.prototype.constructor = BufferLoader;
}
Object.defineProperties(BufferLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  typedArray: {
    get: function() {
      return this._typedArray;
    }
  }
});
BufferLoader.prototype.load = function() {
  if (defined_default(this._typedArray)) {
    this._promise.resolve(this);
    return;
  }
  loadExternalBuffer(this);
};
function loadExternalBuffer(bufferLoader) {
  const resource = bufferLoader._resource;
  bufferLoader._state = ResourceLoaderState_default.LOADING;
  BufferLoader._fetchArrayBuffer(resource).then(function(arrayBuffer) {
    if (bufferLoader.isDestroyed()) {
      return;
    }
    bufferLoader._typedArray = new Uint8Array(arrayBuffer);
    bufferLoader._state = ResourceLoaderState_default.READY;
    bufferLoader._promise.resolve(bufferLoader);
  }).catch(function(error) {
    if (bufferLoader.isDestroyed()) {
      return;
    }
    bufferLoader._state = ResourceLoaderState_default.FAILED;
    const errorMessage = `Failed to load external buffer: ${resource.url}`;
    bufferLoader._promise.reject(bufferLoader.getError(errorMessage, error));
  });
}
BufferLoader._fetchArrayBuffer = function(resource) {
  return resource.fetchArrayBuffer();
};
BufferLoader.prototype.unload = function() {
  this._typedArray = void 0;
};

// node_modules/cesium/Source/ThirdParty/meshoptimizer.js
(function() {
  var wasm = "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";
  var wasmpack = new Uint8Array([32, 0, 65, 2, 1, 106, 34, 33, 3, 128, 11, 4, 13, 64, 6, 253, 10, 7, 15, 116, 127, 5, 8, 12, 40, 16, 19, 54, 20, 9, 27, 255, 113, 17, 42, 67, 24, 23, 146, 148, 18, 14, 22, 45, 70, 69, 56, 114, 101, 21, 25, 63, 75, 136, 108, 28, 118, 29, 73, 115]);
  if (typeof WebAssembly !== "object") {
    return {
      supported: false
    };
  }
  var instance;
  var promise = WebAssembly.instantiate(unpack(wasm), {}).then(function(result) {
    instance = result.instance;
    instance.exports.__wasm_call_ctors();
    instance.exports.meshopt_encodeVertexVersion(0);
    instance.exports.meshopt_encodeIndexVersion(1);
  });
  function unpack(data) {
    var result = new Uint8Array(data.length);
    for (var i2 = 0; i2 < data.length; ++i2) {
      var ch = data.charCodeAt(i2);
      result[i2] = ch > 96 ? ch - 71 : ch > 64 ? ch - 65 : ch > 47 ? ch + 4 : ch > 46 ? 63 : 62;
    }
    var write = 0;
    for (var i2 = 0; i2 < data.length; ++i2) {
      result[write++] = result[i2] < 60 ? wasmpack[result[i2]] : (result[i2] - 60) * 64 + result[++i2];
    }
    return result.buffer.slice(0, write);
  }
  function assert(cond) {
    if (!cond) {
      throw new Error("Assertion failed");
    }
  }
  function reorder(indices2, vertices, optf) {
    var sbrk = instance.exports.sbrk;
    var ip = sbrk(indices2.length * 4);
    var rp = sbrk(vertices * 4);
    var heap = new Uint8Array(instance.exports.memory.buffer);
    var indices8 = new Uint8Array(indices2.buffer, indices2.byteOffset, indices2.byteLength);
    heap.set(indices8, ip);
    if (optf) {
      optf(ip, ip, indices2.length, vertices);
    }
    var unique = instance.exports.meshopt_optimizeVertexFetchRemap(rp, ip, indices2.length, vertices);
    heap = new Uint8Array(instance.exports.memory.buffer);
    var remap = new Uint32Array(vertices);
    new Uint8Array(remap.buffer).set(heap.subarray(rp, rp + vertices * 4));
    indices8.set(heap.subarray(ip, ip + indices2.length * 4));
    sbrk(ip - sbrk(0));
    for (var i2 = 0; i2 < indices2.length; ++i2)
      indices2[i2] = remap[indices2[i2]];
    return [remap, unique];
  }
  function encode(fun, bound, source, count, size) {
    var sbrk = instance.exports.sbrk;
    var tp = sbrk(bound);
    var sp = sbrk(count * size);
    var heap = new Uint8Array(instance.exports.memory.buffer);
    heap.set(new Uint8Array(source.buffer, source.byteOffset, source.byteLength), sp);
    var res = fun(tp, bound, sp, count, size);
    var target = new Uint8Array(res);
    target.set(heap.subarray(tp, tp + res));
    sbrk(tp - sbrk(0));
    return target;
  }
  function maxindex(source) {
    var result = 0;
    for (var i2 = 0; i2 < source.length; ++i2) {
      var index2 = source[i2];
      result = result < index2 ? index2 : result;
    }
    return result;
  }
  function index32(source, size) {
    assert(size == 2 || size == 4);
    if (size == 4) {
      return new Uint32Array(source.buffer, source.byteOffset, source.byteLength / 4);
    } else {
      var view = new Uint16Array(source.buffer, source.byteOffset, source.byteLength / 2);
      return new Uint32Array(view);
    }
  }
  function filter(fun, source, count, stride, bits, insize) {
    var sbrk = instance.exports.sbrk;
    var tp = sbrk(count * stride);
    var sp = sbrk(count * insize);
    var heap = new Uint8Array(instance.exports.memory.buffer);
    heap.set(new Uint8Array(source.buffer, source.byteOffset, source.byteLength), sp);
    fun(tp, count, stride, bits, sp);
    var target = new Uint8Array(count * stride);
    target.set(heap.subarray(tp, tp + count * stride));
    sbrk(tp - sbrk(0));
    return target;
  }
  return {
    ready: promise,
    supported: true,
    reorderMesh: function(indices2, triangles, optsize) {
      var optf = triangles ? optsize ? instance.exports.meshopt_optimizeVertexCacheStrip : instance.exports.meshopt_optimizeVertexCache : void 0;
      return reorder(indices2, maxindex(indices2) + 1, optf);
    },
    encodeVertexBuffer: function(source, count, size) {
      assert(size > 0 && size <= 256);
      assert(size % 4 == 0);
      var bound = instance.exports.meshopt_encodeVertexBufferBound(count, size);
      return encode(instance.exports.meshopt_encodeVertexBuffer, bound, source, count, size);
    },
    encodeIndexBuffer: function(source, count, size) {
      assert(size == 2 || size == 4);
      assert(count % 3 == 0);
      var indices2 = index32(source, size);
      var bound = instance.exports.meshopt_encodeIndexBufferBound(count, maxindex(indices2) + 1);
      return encode(instance.exports.meshopt_encodeIndexBuffer, bound, indices2, count, 4);
    },
    encodeIndexSequence: function(source, count, size) {
      assert(size == 2 || size == 4);
      var indices2 = index32(source, size);
      var bound = instance.exports.meshopt_encodeIndexSequenceBound(count, maxindex(indices2) + 1);
      return encode(instance.exports.meshopt_encodeIndexSequence, bound, indices2, count, 4);
    },
    encodeGltfBuffer: function(source, count, size, mode2) {
      var table2 = {
        ATTRIBUTES: this.encodeVertexBuffer,
        TRIANGLES: this.encodeIndexBuffer,
        INDICES: this.encodeIndexSequence
      };
      assert(table2[mode2]);
      return table2[mode2](source, count, size);
    },
    encodeFilterOct: function(source, count, stride, bits) {
      assert(stride == 4 || stride == 8);
      assert(bits >= 1 && bits <= 16);
      return filter(instance.exports.meshopt_encodeFilterOct, source, count, stride, bits, 4);
    },
    encodeFilterQuat: function(source, count, stride, bits) {
      assert(stride == 8);
      assert(bits >= 4 && bits <= 16);
      return filter(instance.exports.meshopt_encodeFilterQuat, source, count, stride, bits, 4);
    },
    encodeFilterExp: function(source, count, stride, bits) {
      assert(stride > 0 && stride % 4 == 0);
      assert(bits >= 1 && bits <= 24);
      return filter(instance.exports.meshopt_encodeFilterExp, source, count, stride, bits, stride / 4);
    }
  };
})();
var MeshoptDecoder = function() {
  var wasm_base = "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";
  var wasm_simd = "B9h79tEBBBE5V9gBB9gVUUUUUEU9gIUUUB9gDUUB9gEUEUIMXBBEBEEDIDIDLLVE9wEEEVIEBEOWEUEC+Q/aEKR/LEdO9tw9t9vv95DBh9f9f939h79t9f9j9h229f9jT9vv7BB8a9tw79o9v9wT9f9kw9j9v9kw9WwvTw949C919m9mwvBDy9tw79o9v9wT9f9kw9j9v9kw69u9kw949C919m9mwvBLe9tw79o9v9wT9f9kw9j9v9kw69u9kw949Twg91w9u9jwBVl9tw79o9v9wT9f9kw9j9v9kws9p2Twv9P9jTBOk9tw79o9v9wT9f9kw9j9v9kws9p2Twv9R919hTBWl9tw79o9v9wT9f9kw9j9v9kws9p2Twvt949wBQL79iv9rBKQ/j6XLBZIK9+EVU8jJJJJBCZ9rHBCBHEINCBHDCBHIINABCWFADFAICJUAEAD4CEgGLe86BBAIALFHIADCEFGDCW9HMBKAEC+Q+YJJBFAI86BBAECITC+Q1JJBFAB8pIW83IBAECEFGECJD9HMBKK1HLSUD97EUO978jJJJJBCJ/KB9rGV8kJJJJBC9+HODNADCEFAL0MBCUHOAIrBBC+gE9HMBAVAIALFGRAD9rAD/8QBBCJ/ABAD9uC/wfBgGOCJDAOCJD6eHWAICEFHOCBHdDNINAdAE9PMEAWAEAd9rAdAWFAE6eHQDNDNADtMBAQCSFGLC9wgGKCI2HXAKCETHMALCL4CIFCD4HpCBHSINAOHZCBHhDNINDNARAZ9rAp9PMBCBHOXVKAVCJ/CBFAhAK2FHoAZApFHOCBHIDNAKC/AB6MBARAO9rC/gB6MBCBHLINAoALFHIDNDNDNDNDNAZALCO4FrBBGaCIgpLBEDIBKAICBPhPKLBXIKAIAOPBBLAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlGcCDP+MEAcPMBZEhDoIaLcVxOqRlC+D+G+MkPhP9OGxCIPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBAqC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKLBAOCLFAlPqBFAqC+Q+YJJBFrBBFHOXDKAIAOPBBWAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlC+P+e+8/4BPhP9OGxCSPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBAqC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKLBAOCWFAlPqBFAqC+Q+YJJBFrBBFHOXEKAIAOPBBBPKLBAOCZFHOKDNDNDNDNDNAaCD4CIgpLBEDIBKAICBPhPKLZXIKAIAOPBBLAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlGcCDP+MEAcPMBZEhDoIaLcVxOqRlC+D+G+MkPhP9OGxCIPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBAqC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKLZAOCLFAlPqBFAqC+Q+YJJBFrBBFHOXDKAIAOPBBWAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlC+P+e+8/4BPhP9OGxCSPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBAqC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKLZAOCWFAlPqBFAqC+Q+YJJBFrBBFHOXEKAIAOPBBBPKLZAOCZFHOKDNDNDNDNDNAaCL4CIgpLBEDIBKAICBPhPKLAXIKAIAOPBBLAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlGcCDP+MEAcPMBZEhDoIaLcVxOqRlC+D+G+MkPhP9OGxCIPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBAqC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKLAAOCLFAlPqBFAqC+Q+YJJBFrBBFHOXDKAIAOPBBWAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlC+P+e+8/4BPhP9OGxCSPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBAqC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKLAAOCWFAlPqBFAqC+Q+YJJBFrBBFHOXEKAIAOPBBBPKLAAOCZFHOKDNDNDNDNDNAaCO4pLBEDIBKAICBPhPKL8wXIKAIAOPBBLAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlGcCDP+MEAcPMBZEhDoIaLcVxOqRlC+D+G+MkPhP9OGxCIPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGaCITC+Q1JJBFPBIBAaC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGaCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKL8wAOCLFAlPqBFAaC+Q+YJJBFrBBFHOXDKAIAOPBBWAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlC+P+e+8/4BPhP9OGxCSPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGaCITC+Q1JJBFPBIBAaC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGaCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKL8wAOCWFAlPqBFAaC+Q+YJJBFrBBFHOXEKAIAOPBBBPKL8wAOCZFHOKALC/ABFHIALCJEFAK0MEAIHLARAO9rC/fB0MBKKDNAIAK9PMBAICI4HLINDNARAO9rCk9PMBCBHOXRKAoAIFHaDNDNDNDNDNAZAICO4FrBBALCOg4CIgpLBEDIBKAaCBPhPKLBXIKAaAOPBBLAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlGcCDP+MEAcPMBZEhDoIaLcVxOqRlC+D+G+MkPhP9OGxCIPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBAqC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKLBAOCLFAlPqBFAqC+Q+YJJBFrBBFHOXDKAaAOPBBWAOPBBBGcCLP+MEAcPMBZEhDoIaLcVxOqRlC+P+e+8/4BPhP9OGxCSPSP8jGcP5B9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBAqC+Q+YJJBFPBBBGlAlPMBBBBBBBBBBBBBBBBAcP5E9CJf/8/4/w/g/AB9+9Cu1+nGqCITC+Q1JJBFPBIBP9uPMBEDILVORZhoacxqlPpAxAcP9SPKLBAOCWFAlPqBFAqC+Q+YJJBFrBBFHOXEKAaAOPBBBPKLBAOCZFHOKALCDFHLAICZFGIAK6MBKKDNAOtMBAOHZAhCEFGhCLsMDXEKKCBHOXIKDNAKtMBAVCJDFASFHIAVASFPBDBHlCBHaINAIAVCJ/CBFAaFGLPBLBGxCEP9tAxCEPSGcP9OP9hP9RGxALAKFPBLBGkCEP9tAkAcP9OP9hP9RGkPMBZEhDoIaLcVxOqRlGyALAMFPBLBG8aCEP9tA8aAcP9OP9hP9RG8aALAXFPBLBGeCEP9tAeAcP9OP9hP9RGePMBZEhDoIaLcVxOqRlG3PMBEZhDIoaLVcxORqlGcAcPMBEDIBEDIBEDIBEDIAlP9uGlPeBbDBAIADFGLAlAcAcPMLVORLVORLVORLVORP9uGlPeBbDBALADFGLAlAcAcPMWdQKWdQKWdQKWdQKP9uGlPeBbDBALADFGLAlAcAcPMXMpSXMpSXMpSXMpSP9uGlPeBbDBALADFGLAlAyA3PMWdkyQK8aeXM35pS8e8fGcAcPMBEDIBEDIBEDIBEDIP9uGlPeBbDBALADFGLAlAcAcPMLVORLVORLVORLVORP9uGlPeBbDBALADFGLAlAcAcPMWdQKWdQKWdQKWdQKP9uGlPeBbDBALADFGLAlAcAcPMXMpSXMpSXMpSXMpSP9uGlPeBbDBALADFGLAlAxAkPMWkdyQ8aKeX3M5p8eS8fGxA8aAePMWkdyQ8aKeX3M5p8eS8fGkPMBEZhDIoaLVcxORqlGcAcPMBEDIBEDIBEDIBEDIP9uGlPeBbDBALADFGLAlAcAcPMLVORLVORLVORLVORP9uGlPeBbDBALADFGLAlAcAcPMWdQKWdQKWdQKWdQKP9uGlPeBbDBALADFGLAlAcAcPMXMpSXMpSXMpSXMpSP9uGlPeBbDBALADFGLAlAxAkPMWdkyQK8aeXM35pS8e8fGcAcPMBEDIBEDIBEDIBEDIP9uGlPeBbDBALADFGLAlAcAcPMLVORLVORLVORLVORP9uGlPeBbDBALADFGLAlAcAcPMWdQKWdQKWdQKWdQKP9uGlPeBbDBALADFGLAlAcAcPMXMpSXMpSXMpSXMpSP9uGlPeBbDBALADFHIAaCZFGaAK6MBKKASCLFGSAD6MBKKABAdAD2FAVCJDFAQAD2/8QBBAVAVCJDFAQCUFAD2FAD/8QBBKAQCBAOeAdFHdAOMBKC9+HOXEKCBC99ARAO9rADCAADCA0eseHOKAVCJ/KBF8kJJJJBAOKWBZ+BJJJBK+KoEZU8jJJJJBC/AE9rGV8kJJJJBC9+HODNAECI9uGRChFAL0MBCUHOAIrBBGWC/wEgC/gE9HMBAWCSgGdCE0MBAVC/ABFCfECJE/8KBAVCuF9CU83IBAVC8wF9CU83IBAVCYF9CU83IBAVCAF9CU83IBAVCkF9CU83IBAVCZF9CU83IBAV9CU83IWAV9CU83IBAIALFC9wFHQAICEFGWARFHKDNAEtMBCMCSAdCEseHXABHICBHdCBHMCBHpCBHLCBHOINDNAKAQ9NMBC9+HOXIKDNDNAWrBBGRC/vE0MBAVC/ABFARCL4CU7AOFCSgCITFGSYDLHZASYDBHhDNARCSgGSAX9PMBAVARCU7ALFCSgCDTFYDBAdASeHRAStHSDNDNADCD9HMBABAh87EBABCLFAR87EBABCDFAZ87EBXEKAIAhbDBAICWFARbDBAICLFAZbDBKAdASFHdAVC/ABFAOCITFGoARbDBAoAZbDLAVALCDTFARbDBAVC/ABFAOCEFCSgGOCITFGZAhbDBAZARbDLALASFHLAOCEFHOXDKDNDNASCSsMBAMASFASC987FCEFHMXEKAK8sBBGSCfEgHRDNDNASCU9MMBAKCEFHKXEKAK8sBEGSCfBgCRTARCfBgvHRDNASCU9MMBAKCDFHKXEKAK8sBDGSCfBgCpTARvHRDNASCU9MMBAKCIFHKXEKAK8sBIGSCfBgCxTARvHRDNASCU9MMBAKCLFHKXEKAKrBLC3TARvHRAKCVFHKKARCE4CBARCEg9r7AMFHMKDNDNADCD9HMBABAh87EBABCLFAM87EBABCDFAZ87EBXEKAIAhbDBAICWFAMbDBAICLFAZbDBKAVC/ABFAOCITFGRAMbDBARAZbDLAVALCDTFAMbDBAVC/ABFAOCEFCSgGOCITFGRAhbDBARAMbDLALCEFHLAOCEFHOXEKDNARCPE0MBAVALAQARCSgFrBBGSCL4GZ9rCSgCDTFYDBAdCEFGhAZeHRAVALAS9rCSgCDTFYDBAhAZtGoFGhASCSgGZeHSAZtHZDNDNADCD9HMBABAd87EBABCLFAS87EBABCDFAR87EBXEKAIAdbDBAICWFASbDBAICLFARbDBKAVALCDTFAdbDBAVC/ABFAOCITFGaARbDBAaAdbDLAVALCEFGLCSgCDTFARbDBAVC/ABFAOCEFCSgCITFGaASbDBAaARbDLAVALAoFCSgGLCDTFASbDBAVC/ABFAOCDFCSgGOCITFGRAdbDBARASbDLAOCEFHOALAZFHLAhAZFHdXEKAdCBAKrBBGaeGZARC/+EsGcFHRAaCSgHhDNDNAaCL4GoMBARCEFHSXEKARHSAVALAo9rCSgCDTFYDBHRKDNDNAhMBASCEFHdXEKASHdAVALAa9rCSgCDTFYDBHSKDNDNActMBAKCEFHaXEKAK8sBEGaCfEgHZDNDNAaCU9MMBAKCDFHaXEKAK8sBDGaCfBgCRTAZCfBgvHZDNAaCU9MMBAKCIFHaXEKAK8sBIGaCfBgCpTAZvHZDNAaCU9MMBAKCLFHaXEKAK8sBLGaCfBgCxTAZvHZDNAaCU9MMBAKCVFHaXEKAKCOFHaAKrBVC3TAZvHZKAZCE4CBAZCEg9r7AMFGMHZKDNDNAoCSsMBAaHcXEKAa8sBBGKCfEgHRDNDNAKCU9MMBAaCEFHcXEKAa8sBEGKCfBgCRTARCfBgvHRDNAKCU9MMBAaCDFHcXEKAa8sBDGKCfBgCpTARvHRDNAKCU9MMBAaCIFHcXEKAa8sBIGKCfBgCxTARvHRDNAKCU9MMBAaCLFHcXEKAaCVFHcAarBLC3TARvHRKARCE4CBARCEg9r7AMFGMHRKDNDNAhCSsMBAcHKXEKAc8sBBGKCfEgHSDNDNAKCU9MMBAcCEFHKXEKAc8sBEGKCfBgCRTASCfBgvHSDNAKCU9MMBAcCDFHKXEKAc8sBDGKCfBgCpTASvHSDNAKCU9MMBAcCIFHKXEKAc8sBIGKCfBgCxTASvHSDNAKCU9MMBAcCLFHKXEKAcCVFHKAcrBLC3TASvHSKASCE4CBASCEg9r7AMFGMHSKDNDNADCD9HMBABAZ87EBABCLFAS87EBABCDFAR87EBXEKAIAZbDBAICWFASbDBAICLFARbDBKAVC/ABFAOCITFGaARbDBAaAZbDLAVALCDTFAZbDBAVC/ABFAOCEFCSgCITFGaASbDBAaARbDLAVALCEFGLCSgCDTFARbDBAVC/ABFAOCDFCSgCITFGRAZbDBARASbDLAVALAotAoCSsvFGLCSgCDTFASbDBALAhtAhCSsvFHLAOCIFHOKAWCEFHWABCOFHBAICXFHIAOCSgHOALCSgHLApCIFGpAE6MBKKCBC99AKAQseHOKAVC/AEF8kJJJJBAOK/tLEDU8jJJJJBCZ9rHVC9+HODNAECVFAL0MBCUHOAIrBBC/+EgC/QE9HMBAV9CB83IWAICEFHOAIALFC98FHIDNAEtMBDNADCDsMBINDNAOAI6MBC9+SKAO8sBBGDCfEgHLDNDNADCU9MMBAOCEFHOXEKAO8sBEGDCfBgCRTALCfBgvHLDNADCU9MMBAOCDFHOXEKAO8sBDGDCfBgCpTALvHLDNADCU9MMBAOCIFHOXEKAO8sBIGDCfBgCxTALvHLDNADCU9MMBAOCLFHOXEKAOrBLC3TALvHLAOCVFHOKAVCWFALCEgCDTvGDALCD4CBALCE4CEg9r7ADYDBFGLbDBABALbDBABCLFHBAECUFGEMBXDKKINDNAOAI6MBC9+SKAO8sBBGDCfEgHLDNDNADCU9MMBAOCEFHOXEKAO8sBEGDCfBgCRTALCfBgvHLDNADCU9MMBAOCDFHOXEKAO8sBDGDCfBgCpTALvHLDNADCU9MMBAOCIFHOXEKAO8sBIGDCfBgCxTALvHLDNADCU9MMBAOCLFHOXEKAOrBLC3TALvHLAOCVFHOKABALCD4CBALCE4CEg9r7AVCWFALCEgCDTvGLYDBFGD87EBALADbDBABCDFHBAECUFGEMBKKCBC99AOAIseHOKAOK/xVDIUO978jJJJJBCA9rGI8kJJJJBDNDNADCL9HMBDNAEC98gGLtMBABHDCBHVINADADPBBBGOCkP+rECkP+sEP/6EGRAOCWP+rECkP+sEP/6EARP/gEAOCZP+rECkP+sEP/6EGWP/gEP/kEP/lEGdCBPhP+2EGQARCJJJJ94PhGKP9OP9RP/kEGRjBB/+9CPaARARP/mEAdAdP/mEAWAQAWAKP9OP9RP/kEGRARP/mEP/kEP/kEP/jEP/nEGWP/mEjBBN0PaGQP/kECfEPhP9OAOCJJJ94PhP9OP9QARAWP/mEAQP/kECWP+rECJ/+IPhP9OP9QAdAWP/mEAQP/kECZP+rECJJ/8RPhP9OP9QPKBBADCZFHDAVCLFGVAL6MBKKALAE9PMEAIAECIgGVCDTGDvCBCZAD9r/8KBAIABALCDTFGLAD/8QBBDNAVtMBAIAIPBLBGOCkP+rECkP+sEP/6EGRAOCWP+rECkP+sEP/6EARP/gEAOCZP+rECkP+sEP/6EGWP/gEP/kEP/lEGdCBPhP+2EGQARCJJJJ94PhGKP9OP9RP/kEGRjBB/+9CPaARARP/mEAdAdP/mEAWAQAWAKP9OP9RP/kEGRARP/mEP/kEP/kEP/jEP/nEGWP/mEjBBN0PaGQP/kECfEPhP9OAOCJJJ94PhP9OP9QARAWP/mEAQP/kECWP+rECJ/+IPhP9OP9QAdAWP/mEAQP/kECZP+rECJJ/8RPhP9OP9QPKLBKALAIAD/8QBBXEKABAEC98gGDZ+HJJJBADAE9PMBAIAECIgGLCITGVFCBCAAV9r/8KBAIABADCITFGDAV/8QBBAIALZ+HJJJBADAIAV/8QBBKAICAF8kJJJJBK+yIDDUR97DNAEtMBCBHDINABCZFGIAIPBBBGLCBPhGVCJJ98P3ECJJ98P3IGOP9OABPBBBGRALPMLVORXMpScxql358e8fCffEPhP9OP/6EARALPMBEDIWdQKZhoaky8aeGLCZP+sEP/6EGWP/gEALCZP+rECZP+sEP/6EGdP/gEP/kEP/lEGLjB/+fsPaAdALAVP+2EGVAdCJJJJ94PhGQP9OP9RP/kEGdAdP/mEALALP/mEAWAVAWAQP9OP9RP/kEGLALP/mEP/kEP/kEP/jEP/nEGWP/mEjBBN0PaGVP/kECZP+rEAdAWP/mEAVP/kECffIPhP9OP9QGdALAWP/mEAVP/kECUPSCBPlDCBPlICBPlOCBPlRCBPlQCBPlKCBPlpCBPlSP9OGLPMWdkyQK8aeXM35pS8e8fP9QPKBBABARAOP9OAdALPMBEZhDIoaLVcxORqlP9QPKBBABCAFHBADCLFGDAE6MBKKK94EIU8jJJJJBCA9rGI8kJJJJBABAEC98gGLZ+JJJJBDNALAE9PMBAIAECIgGVCITGEFCBCAAE9r/8KBAIABALCITFGBAE/8QBBAIAVZ+JJJJBABAIAE/8QBBKAICAF8kJJJJBK/hILDUE97EUV978jJJJJBCZ9rHDDNAEtMBCBHIINADABPBBBGLABCZFGVPBBBGOPMLVORXMpScxql358e8fGRCZP+sEGWCLP+rEPKLBABjBBJzPaj/zL81zPaAWCIPhP9QP/6EP/nEGWALAOPMBEDIWdQKZhoaky8aeGLCZP+rECZP+sEP/6EP/mEGOAOP/mEAWALCZP+sEP/6EP/mEGdAdP/mEAWARCZP+rECZP+sEP/6EP/mEGRARP/mEP/kEP/kEP/lECBPhP+4EP/jEjB/+fsPaGWP/mEjBBN0PaGLP/kECffIPhGQP9OAdAWP/mEALP/kECZP+rEP9QGdARAWP/mEALP/kECZP+rEAOAWP/mEALP/kEAQP9OP9QGWPMBEZhDIoaLVcxORqlGLP5BADPBLBPeB+t+J83IBABCWFALP5EADPBLBPeE+t+J83IBAVAdAWPMWdkyQK8aeXM35pS8e8fGWP5BADPBLBPeD+t+J83IBABCkFAWP5EADPBLBPeI+t+J83IBABCAFHBAICLFGIAE6MBKKK/3EDIUE978jJJJJBC/AB9rHIDNADCD4AE2GLC98gGVtMBCBHDABHEINAEAEPBBBGOCWP+rECWP+sEP/6EAOCkP+sEClP+rECJJJ/8IPhP+uEP/mEPKBBAECZFHEADCLFGDAV6MBKKDNAVAL9PMBAIALCIgGDCDTGEvCBC/ABAE9r/8KBAIABAVCDTFGVAE/8QBBDNADtMBAIAIPBLBGOCWP+rECWP+sEP/6EAOCkP+sEClP+rECJJJ/8IPhP+uEP/mEPKLBKAVAIAE/8QBBKK9TEIUCBCBYDJ1JJBGEABCIFC98gFGBbDJ1JJBDNDNABzBCZTGD9NMBCUHIABAD9rCffIFCZ4NBCUsMEKAEHIKAIKKKEBCJWKLZ9tBB";
  var detector = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 5, 3, 1, 0, 1, 12, 1, 0, 10, 22, 2, 12, 0, 65, 0, 65, 0, 65, 0, 252, 10, 0, 0, 11, 7, 0, 65, 0, 253, 15, 26, 11]);
  var wasmpack = new Uint8Array([32, 0, 65, 2, 1, 106, 34, 33, 3, 128, 11, 4, 13, 64, 6, 253, 10, 7, 15, 116, 127, 5, 8, 12, 40, 16, 19, 54, 20, 9, 27, 255, 113, 17, 42, 67, 24, 23, 146, 148, 18, 14, 22, 45, 70, 69, 56, 114, 101, 21, 25, 63, 75, 136, 108, 28, 118, 29, 73, 115]);
  if (typeof WebAssembly !== "object") {
    return {
      supported: false
    };
  }
  var wasm = wasm_base;
  if (WebAssembly.validate(detector)) {
    wasm = wasm_simd;
  }
  var instance;
  var promise = WebAssembly.instantiate(unpack(wasm), {}).then(function(result) {
    instance = result.instance;
    instance.exports.__wasm_call_ctors();
  });
  function unpack(data) {
    var result = new Uint8Array(data.length);
    for (var i2 = 0; i2 < data.length; ++i2) {
      var ch = data.charCodeAt(i2);
      result[i2] = ch > 96 ? ch - 71 : ch > 64 ? ch - 65 : ch > 47 ? ch + 4 : ch > 46 ? 63 : 62;
    }
    var write = 0;
    for (var i2 = 0; i2 < data.length; ++i2) {
      result[write++] = result[i2] < 60 ? wasmpack[result[i2]] : (result[i2] - 60) * 64 + result[++i2];
    }
    return result.buffer.slice(0, write);
  }
  function decode(fun, target, count, size, source, filter) {
    var sbrk = instance.exports.sbrk;
    var count4 = count + 3 & ~3;
    var tp = sbrk(count4 * size);
    var sp = sbrk(source.length);
    var heap = new Uint8Array(instance.exports.memory.buffer);
    heap.set(source, sp);
    var res = fun(tp, count, size, sp, source.length);
    if (res == 0 && filter) {
      filter(tp, count4, size);
    }
    target.set(heap.subarray(tp, tp + count * size));
    sbrk(tp - sbrk(0));
    if (res != 0) {
      throw new Error("Malformed buffer data: " + res);
    }
  }
  var filters = {
    0: "",
    1: "meshopt_decodeFilterOct",
    2: "meshopt_decodeFilterQuat",
    3: "meshopt_decodeFilterExp",
    NONE: "",
    OCTAHEDRAL: "meshopt_decodeFilterOct",
    QUATERNION: "meshopt_decodeFilterQuat",
    EXPONENTIAL: "meshopt_decodeFilterExp"
  };
  var decoders = {
    0: "meshopt_decodeVertexBuffer",
    1: "meshopt_decodeIndexBuffer",
    2: "meshopt_decodeIndexSequence",
    ATTRIBUTES: "meshopt_decodeVertexBuffer",
    TRIANGLES: "meshopt_decodeIndexBuffer",
    INDICES: "meshopt_decodeIndexSequence"
  };
  return {
    ready: promise,
    supported: true,
    decodeVertexBuffer: function(target, count, size, source, filter) {
      decode(instance.exports.meshopt_decodeVertexBuffer, target, count, size, source, instance.exports[filters[filter]]);
    },
    decodeIndexBuffer: function(target, count, size, source) {
      decode(instance.exports.meshopt_decodeIndexBuffer, target, count, size, source);
    },
    decodeIndexSequence: function(target, count, size, source) {
      decode(instance.exports.meshopt_decodeIndexSequence, target, count, size, source);
    },
    decodeGltfBuffer: function(target, count, size, source, mode2, filter) {
      decode(instance.exports[decoders[mode2]], target, count, size, source, instance.exports[filters[filter]]);
    }
  };
}();

// node_modules/cesium/Source/Scene/GltfBufferViewLoader.js
function GltfBufferViewLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resourceCache = options.resourceCache;
  const gltf = options.gltf;
  const bufferViewId = options.bufferViewId;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const cacheKey = options.cacheKey;
  Check_default.typeOf.func("options.resourceCache", resourceCache);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.bufferViewId", bufferViewId);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const bufferView = gltf.bufferViews[bufferViewId];
  let bufferId = bufferView.buffer;
  let byteOffset = bufferView.byteOffset;
  let byteLength = bufferView.byteLength;
  let hasMeshopt = false;
  let meshoptByteStride;
  let meshoptCount;
  let meshoptMode;
  let meshoptFilter;
  if (hasExtension(bufferView, "EXT_meshopt_compression")) {
    const meshopt = bufferView.extensions.EXT_meshopt_compression;
    bufferId = meshopt.buffer;
    byteOffset = defaultValue_default(meshopt.byteOffset, 0);
    byteLength = meshopt.byteLength;
    hasMeshopt = true;
    meshoptByteStride = meshopt.byteStride;
    meshoptCount = meshopt.count;
    meshoptMode = meshopt.mode;
    meshoptFilter = defaultValue_default(meshopt.filter, "NONE");
  }
  const buffer = gltf.buffers[bufferId];
  this._hasMeshopt = hasMeshopt;
  this._meshoptByteStride = meshoptByteStride;
  this._meshoptCount = meshoptCount;
  this._meshoptMode = meshoptMode;
  this._meshoptFilter = meshoptFilter;
  this._resourceCache = resourceCache;
  this._gltfResource = gltfResource;
  this._baseResource = baseResource2;
  this._buffer = buffer;
  this._bufferId = bufferId;
  this._byteOffset = byteOffset;
  this._byteLength = byteLength;
  this._cacheKey = cacheKey;
  this._bufferLoader = void 0;
  this._typedArray = void 0;
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  GltfBufferViewLoader.prototype = Object.create(ResourceLoader.prototype);
  GltfBufferViewLoader.prototype.constructor = GltfBufferViewLoader;
}
Object.defineProperties(GltfBufferViewLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  typedArray: {
    get: function() {
      return this._typedArray;
    }
  }
});
GltfBufferViewLoader.prototype.load = function() {
  const bufferLoader = getBufferLoader(this);
  this._bufferLoader = bufferLoader;
  this._state = ResourceLoaderState_default.LOADING;
  const that = this;
  bufferLoader.promise.then(function() {
    if (that.isDestroyed()) {
      return;
    }
    const bufferTypedArray = bufferLoader.typedArray;
    const bufferViewTypedArray = new Uint8Array(
      bufferTypedArray.buffer,
      bufferTypedArray.byteOffset + that._byteOffset,
      that._byteLength
    );
    that.unload();
    that._typedArray = bufferViewTypedArray;
    if (that._hasMeshopt) {
      that._state = ResourceLoaderState_default.PROCESSING;
    } else {
      that._state = ResourceLoaderState_default.READY;
      that._promise.resolve(that);
    }
  }).catch(function(error) {
    if (that.isDestroyed()) {
      return;
    }
    that.unload();
    that._state = ResourceLoaderState_default.FAILED;
    const errorMessage = "Failed to load buffer view";
    that._promise.reject(that.getError(errorMessage, error));
  });
};
function getBufferLoader(bufferViewLoader) {
  const resourceCache = bufferViewLoader._resourceCache;
  const buffer = bufferViewLoader._buffer;
  if (defined_default(buffer.uri)) {
    const baseResource2 = bufferViewLoader._baseResource;
    const resource = baseResource2.getDerivedResource({
      url: buffer.uri
    });
    return resourceCache.loadExternalBuffer({
      resource
    });
  }
  return resourceCache.loadEmbeddedBuffer({
    parentResource: bufferViewLoader._gltfResource,
    bufferId: bufferViewLoader._bufferId
  });
}
GltfBufferViewLoader.prototype.process = function(frameState) {
  Check_default.typeOf.object("frameState", frameState);
  if (!this._hasMeshopt) {
    return;
  }
  if (!defined_default(this._typedArray)) {
    return;
  }
  if (this._state !== ResourceLoaderState_default.PROCESSING) {
    return;
  }
  const count = this._meshoptCount;
  const byteStride = this._meshoptByteStride;
  const result = new Uint8Array(count * byteStride);
  MeshoptDecoder.decodeGltfBuffer(
    result,
    count,
    byteStride,
    this._typedArray,
    this._meshoptMode,
    this._meshoptFilter
  );
  this._typedArray = result;
  this._state = ResourceLoaderState_default.READY;
  this._promise.resolve(this);
};
GltfBufferViewLoader.prototype.unload = function() {
  if (defined_default(this._bufferLoader)) {
    this._resourceCache.unload(this._bufferLoader);
  }
  this._bufferLoader = void 0;
  this._typedArray = void 0;
};

// node_modules/cesium/Source/Scene/GltfDracoLoader.js
function GltfDracoLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resourceCache = options.resourceCache;
  const gltf = options.gltf;
  const draco = options.draco;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const cacheKey = options.cacheKey;
  Check_default.typeOf.func("options.resourceCache", resourceCache);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.draco", draco);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  this._resourceCache = resourceCache;
  this._gltfResource = gltfResource;
  this._baseResource = baseResource2;
  this._gltf = gltf;
  this._draco = draco;
  this._cacheKey = cacheKey;
  this._bufferViewLoader = void 0;
  this._bufferViewTypedArray = void 0;
  this._decodePromise = void 0;
  this._decodedData = void 0;
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  GltfDracoLoader.prototype = Object.create(ResourceLoader.prototype);
  GltfDracoLoader.prototype.constructor = GltfDracoLoader;
}
Object.defineProperties(GltfDracoLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  decodedData: {
    get: function() {
      return this._decodedData;
    }
  }
});
GltfDracoLoader.prototype.load = function() {
  const resourceCache = this._resourceCache;
  const bufferViewLoader = resourceCache.loadBufferView({
    gltf: this._gltf,
    bufferViewId: this._draco.bufferView,
    gltfResource: this._gltfResource,
    baseResource: this._baseResource
  });
  this._bufferViewLoader = bufferViewLoader;
  this._state = ResourceLoaderState_default.LOADING;
  const that = this;
  bufferViewLoader.promise.then(function() {
    if (that.isDestroyed()) {
      return;
    }
    that._bufferViewTypedArray = bufferViewLoader.typedArray;
    that._state = ResourceLoaderState_default.PROCESSING;
  }).catch(function(error) {
    if (that.isDestroyed()) {
      return;
    }
    handleError(that, error);
  });
};
function handleError(dracoLoader, error) {
  dracoLoader.unload();
  dracoLoader._state = ResourceLoaderState_default.FAILED;
  const errorMessage = "Failed to load Draco";
  dracoLoader._promise.reject(dracoLoader.getError(errorMessage, error));
}
GltfDracoLoader.prototype.process = function(frameState) {
  Check_default.typeOf.object("frameState", frameState);
  if (!defined_default(this._bufferViewTypedArray)) {
    return;
  }
  if (defined_default(this._decodePromise)) {
    return;
  }
  const draco = this._draco;
  const gltf = this._gltf;
  const bufferViews = gltf.bufferViews;
  const bufferViewId = draco.bufferView;
  const bufferView = bufferViews[bufferViewId];
  const compressedAttributes = draco.attributes;
  const decodeOptions = {
    array: new Uint8Array(this._bufferViewTypedArray),
    bufferView,
    compressedAttributes,
    dequantizeInShader: true
  };
  const decodePromise = DracoLoader_default.decodeBufferView(decodeOptions);
  if (!defined_default(decodePromise)) {
    return;
  }
  const that = this;
  this._decodePromise = decodePromise.then(function(results) {
    if (that.isDestroyed()) {
      return;
    }
    that.unload();
    that._decodedData = {
      indices: results.indexArray,
      vertexAttributes: results.attributeData
    };
    that._state = ResourceLoaderState_default.READY;
    that._promise.resolve(that);
  }).catch(function(error) {
    if (that.isDestroyed()) {
      return;
    }
    handleError(that, error);
  });
};
GltfDracoLoader.prototype.unload = function() {
  if (defined_default(this._bufferViewLoader)) {
    this._resourceCache.unload(this._bufferViewLoader);
  }
  this._bufferViewLoader = void 0;
  this._bufferViewTypedArray = void 0;
  this._decodedData = void 0;
  this._gltf = void 0;
};

// node_modules/cesium/Source/Scene/GltfImageLoader.js
function GltfImageLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resourceCache = options.resourceCache;
  const gltf = options.gltf;
  const imageId = options.imageId;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const cacheKey = options.cacheKey;
  Check_default.typeOf.func("options.resourceCache", resourceCache);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.imageId", imageId);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const image = gltf.images[imageId];
  const bufferViewId = image.bufferView;
  const uri = image.uri;
  this._resourceCache = resourceCache;
  this._gltfResource = gltfResource;
  this._baseResource = baseResource2;
  this._gltf = gltf;
  this._bufferViewId = bufferViewId;
  this._uri = uri;
  this._cacheKey = cacheKey;
  this._bufferViewLoader = void 0;
  this._image = void 0;
  this._mipLevels = void 0;
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  GltfImageLoader.prototype = Object.create(ResourceLoader.prototype);
  GltfImageLoader.prototype.constructor = GltfImageLoader;
}
Object.defineProperties(GltfImageLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  image: {
    get: function() {
      return this._image;
    }
  },
  mipLevels: {
    get: function() {
      return this._mipLevels;
    }
  }
});
GltfImageLoader.prototype.load = function() {
  if (defined_default(this._bufferViewId)) {
    loadFromBufferView(this);
  } else {
    loadFromUri(this);
  }
};
function getImageAndMipLevels(image) {
  let mipLevels;
  if (Array.isArray(image)) {
    mipLevels = image.slice(1, image.length).map(function(mipLevel) {
      return mipLevel.bufferView;
    });
    image = image[0];
  }
  return {
    image,
    mipLevels
  };
}
function loadFromBufferView(imageLoader) {
  const resourceCache = imageLoader._resourceCache;
  const bufferViewLoader = resourceCache.loadBufferView({
    gltf: imageLoader._gltf,
    bufferViewId: imageLoader._bufferViewId,
    gltfResource: imageLoader._gltfResource,
    baseResource: imageLoader._baseResource
  });
  imageLoader._bufferViewLoader = bufferViewLoader;
  imageLoader._state = ResourceLoaderState_default.LOADING;
  bufferViewLoader.promise.then(function() {
    if (imageLoader.isDestroyed()) {
      return;
    }
    const typedArray = bufferViewLoader.typedArray;
    return loadImageFromBufferTypedArray(typedArray).then(function(image) {
      if (imageLoader.isDestroyed()) {
        return;
      }
      const imageAndMipLevels = getImageAndMipLevels(image);
      imageLoader.unload();
      imageLoader._image = imageAndMipLevels.image;
      imageLoader._mipLevels = imageAndMipLevels.mipLevels;
      imageLoader._state = ResourceLoaderState_default.READY;
      imageLoader._promise.resolve(imageLoader);
    });
  }).catch(function(error) {
    if (imageLoader.isDestroyed()) {
      return;
    }
    handleError2(imageLoader, error, "Failed to load embedded image");
  });
}
function loadFromUri(imageLoader) {
  const baseResource2 = imageLoader._baseResource;
  const uri = imageLoader._uri;
  const resource = baseResource2.getDerivedResource({
    url: uri
  });
  imageLoader._state = ResourceLoaderState_default.LOADING;
  loadImageFromUri(resource).then(function(image) {
    if (imageLoader.isDestroyed()) {
      return;
    }
    const imageAndMipLevels = getImageAndMipLevels(image);
    imageLoader.unload();
    imageLoader._image = imageAndMipLevels.image;
    imageLoader._mipLevels = imageAndMipLevels.mipLevels;
    imageLoader._state = ResourceLoaderState_default.READY;
    imageLoader._promise.resolve(imageLoader);
  }).catch(function(error) {
    if (imageLoader.isDestroyed()) {
      return;
    }
    handleError2(imageLoader, error, `Failed to load image: ${uri}`);
  });
}
function handleError2(imageLoader, error, errorMessage) {
  imageLoader.unload();
  imageLoader._state = ResourceLoaderState_default.FAILED;
  imageLoader._promise.reject(imageLoader.getError(errorMessage, error));
}
function getMimeTypeFromTypedArray(typedArray) {
  const header = typedArray.subarray(0, 2);
  const webpHeaderRIFFChars = typedArray.subarray(0, 4);
  const webpHeaderWEBPChars = typedArray.subarray(8, 12);
  if (header[0] === 255 && header[1] === 216) {
    return "image/jpeg";
  } else if (header[0] === 137 && header[1] === 80) {
    return "image/png";
  } else if (header[0] === 171 && header[1] === 75) {
    return "image/ktx2";
  } else if (webpHeaderRIFFChars[0] === 82 && webpHeaderRIFFChars[1] === 73 && webpHeaderRIFFChars[2] === 70 && webpHeaderRIFFChars[3] === 70 && webpHeaderWEBPChars[0] === 87 && webpHeaderWEBPChars[1] === 69 && webpHeaderWEBPChars[2] === 66 && webpHeaderWEBPChars[3] === 80) {
    return "image/webp";
  }
  throw new RuntimeError_default("Image format is not recognized");
}
function loadImageFromBufferTypedArray(typedArray) {
  const mimeType = getMimeTypeFromTypedArray(typedArray);
  if (mimeType === "image/ktx2") {
    const ktxBuffer = new Uint8Array(typedArray);
    return loadKTX2_default(ktxBuffer);
  }
  return GltfImageLoader._loadImageFromTypedArray({
    uint8Array: typedArray,
    format: mimeType,
    flipY: false,
    skipColorSpaceConversion: true
  });
}
var ktx2Regex3 = /(^data:image\/ktx2)|(\.ktx2$)/i;
function loadImageFromUri(resource) {
  const uri = resource.url;
  if (ktx2Regex3.test(uri)) {
    return loadKTX2_default(resource);
  }
  return resource.fetchImage({
    skipColorSpaceConversion: true,
    preferImageBitmap: true
  });
}
GltfImageLoader.prototype.unload = function() {
  if (defined_default(this._bufferViewLoader)) {
    this._resourceCache.unload(this._bufferViewLoader);
  }
  this._bufferViewLoader = void 0;
  this._uri = void 0;
  this._image = void 0;
  this._mipLevels = void 0;
  this._gltf = void 0;
};
GltfImageLoader._loadImageFromTypedArray = loadImageFromTypedArray_default;

// node_modules/cesium/Source/Scene/GltfIndexBufferLoader.js
function GltfIndexBufferLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resourceCache = options.resourceCache;
  const gltf = options.gltf;
  const accessorId = options.accessorId;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const draco = options.draco;
  const cacheKey = options.cacheKey;
  const asynchronous = defaultValue_default(options.asynchronous, true);
  const loadAsTypedArray = defaultValue_default(options.loadAsTypedArray, false);
  Check_default.typeOf.func("options.resourceCache", resourceCache);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.accessorId", accessorId);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const indexDatatype = gltf.accessors[accessorId].componentType;
  this._resourceCache = resourceCache;
  this._gltfResource = gltfResource;
  this._baseResource = baseResource2;
  this._gltf = gltf;
  this._accessorId = accessorId;
  this._indexDatatype = indexDatatype;
  this._draco = draco;
  this._cacheKey = cacheKey;
  this._asynchronous = asynchronous;
  this._loadAsTypedArray = loadAsTypedArray;
  this._bufferViewLoader = void 0;
  this._dracoLoader = void 0;
  this._typedArray = void 0;
  this._buffer = void 0;
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  GltfIndexBufferLoader.prototype = Object.create(ResourceLoader.prototype);
  GltfIndexBufferLoader.prototype.constructor = GltfIndexBufferLoader;
}
Object.defineProperties(GltfIndexBufferLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  buffer: {
    get: function() {
      return this._buffer;
    }
  },
  typedArray: {
    get: function() {
      return this._typedArray;
    }
  },
  indexDatatype: {
    get: function() {
      return this._indexDatatype;
    }
  }
});
GltfIndexBufferLoader.prototype.load = function() {
  if (defined_default(this._draco)) {
    loadFromDraco(this);
  } else {
    loadFromBufferView2(this);
  }
};
function loadFromDraco(indexBufferLoader) {
  const resourceCache = indexBufferLoader._resourceCache;
  const dracoLoader = resourceCache.loadDraco({
    gltf: indexBufferLoader._gltf,
    draco: indexBufferLoader._draco,
    gltfResource: indexBufferLoader._gltfResource,
    baseResource: indexBufferLoader._baseResource
  });
  indexBufferLoader._dracoLoader = dracoLoader;
  indexBufferLoader._state = ResourceLoaderState_default.LOADING;
  dracoLoader.promise.then(function() {
    if (indexBufferLoader.isDestroyed()) {
      return;
    }
    const typedArray = dracoLoader.decodedData.indices.typedArray;
    indexBufferLoader._typedArray = typedArray;
    indexBufferLoader._indexDatatype = ComponentDatatype_default.fromTypedArray(
      typedArray
    );
    indexBufferLoader._state = ResourceLoaderState_default.PROCESSING;
  }).catch(function(error) {
    if (indexBufferLoader.isDestroyed()) {
      return;
    }
    handleError3(indexBufferLoader, error);
  });
}
function loadFromBufferView2(indexBufferLoader) {
  const gltf = indexBufferLoader._gltf;
  const accessorId = indexBufferLoader._accessorId;
  const accessor = gltf.accessors[accessorId];
  const bufferViewId = accessor.bufferView;
  const resourceCache = indexBufferLoader._resourceCache;
  const bufferViewLoader = resourceCache.loadBufferView({
    gltf,
    bufferViewId,
    gltfResource: indexBufferLoader._gltfResource,
    baseResource: indexBufferLoader._baseResource
  });
  indexBufferLoader._state = ResourceLoaderState_default.LOADING;
  indexBufferLoader._bufferViewLoader = bufferViewLoader;
  bufferViewLoader.promise.then(function() {
    if (indexBufferLoader.isDestroyed()) {
      return;
    }
    const bufferViewTypedArray = bufferViewLoader.typedArray;
    indexBufferLoader._typedArray = createIndicesTypedArray(
      indexBufferLoader,
      bufferViewTypedArray
    );
    indexBufferLoader._state = ResourceLoaderState_default.PROCESSING;
  }).catch(function(error) {
    if (indexBufferLoader.isDestroyed()) {
      return;
    }
    handleError3(indexBufferLoader, error);
  });
}
function createIndicesTypedArray(indexBufferLoader, bufferViewTypedArray) {
  const gltf = indexBufferLoader._gltf;
  const accessorId = indexBufferLoader._accessorId;
  const accessor = gltf.accessors[accessorId];
  const count = accessor.count;
  const indexDatatype = accessor.componentType;
  const arrayBuffer = bufferViewTypedArray.buffer;
  const byteOffset = bufferViewTypedArray.byteOffset + accessor.byteOffset;
  let typedArray;
  if (indexDatatype === IndexDatatype_default.UNSIGNED_BYTE) {
    typedArray = new Uint8Array(arrayBuffer, byteOffset, count);
  } else if (indexDatatype === IndexDatatype_default.UNSIGNED_SHORT) {
    typedArray = new Uint16Array(arrayBuffer, byteOffset, count);
  } else if (indexDatatype === IndexDatatype_default.UNSIGNED_INT) {
    typedArray = new Uint32Array(arrayBuffer, byteOffset, count);
  }
  return typedArray;
}
function handleError3(indexBufferLoader, error) {
  indexBufferLoader.unload();
  indexBufferLoader._state = ResourceLoaderState_default.FAILED;
  const errorMessage = "Failed to load index buffer";
  error = indexBufferLoader.getError(errorMessage, error);
  indexBufferLoader._promise.reject(error);
}
function CreateIndexBufferJob2() {
  this.typedArray = void 0;
  this.indexDatatype = void 0;
  this.context = void 0;
  this.buffer = void 0;
}
CreateIndexBufferJob2.prototype.set = function(typedArray, indexDatatype, context) {
  this.typedArray = typedArray;
  this.indexDatatype = indexDatatype;
  this.context = context;
};
CreateIndexBufferJob2.prototype.execute = function() {
  this.buffer = createIndexBuffer3(
    this.typedArray,
    this.indexDatatype,
    this.context
  );
};
function createIndexBuffer3(typedArray, indexDatatype, context) {
  const buffer = Buffer_default.createIndexBuffer({
    typedArray,
    context,
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype
  });
  buffer.vertexArrayDestroyable = false;
  return buffer;
}
var scratchIndexBufferJob2 = new CreateIndexBufferJob2();
GltfIndexBufferLoader.prototype.process = function(frameState) {
  Check_default.typeOf.object("frameState", frameState);
  if (this._state === ResourceLoaderState_default.READY) {
    return;
  }
  const typedArray = this._typedArray;
  const indexDatatype = this._indexDatatype;
  if (defined_default(this._dracoLoader)) {
    this._dracoLoader.process(frameState);
  }
  if (defined_default(this._bufferViewLoader)) {
    this._bufferViewLoader.process(frameState);
  }
  if (!defined_default(typedArray)) {
    return;
  }
  const useWebgl2 = frameState.context.webgl2;
  if (this._loadAsTypedArray || !useWebgl2) {
    this.unload();
    this._typedArray = typedArray;
    this._state = ResourceLoaderState_default.READY;
    this._promise.resolve(this);
    return;
  }
  let buffer;
  if (this._asynchronous) {
    const indexBufferJob = scratchIndexBufferJob2;
    indexBufferJob.set(typedArray, indexDatatype, frameState.context);
    const jobScheduler = frameState.jobScheduler;
    if (!jobScheduler.execute(indexBufferJob, JobType_default.BUFFER)) {
      return;
    }
    buffer = indexBufferJob.buffer;
  } else {
    buffer = createIndexBuffer3(typedArray, indexDatatype, frameState.context);
  }
  this.unload();
  this._buffer = buffer;
  this._state = ResourceLoaderState_default.READY;
  this._promise.resolve(this);
};
GltfIndexBufferLoader.prototype.unload = function() {
  if (defined_default(this._buffer)) {
    this._buffer.destroy();
  }
  const resourceCache = this._resourceCache;
  if (defined_default(this._bufferViewLoader)) {
    resourceCache.unload(this._bufferViewLoader);
  }
  if (defined_default(this._dracoLoader)) {
    resourceCache.unload(this._dracoLoader);
  }
  this._bufferViewLoader = void 0;
  this._dracoLoader = void 0;
  this._typedArray = void 0;
  this._buffer = void 0;
  this._gltf = void 0;
};

// node_modules/cesium/Source/Scene/GltfPipeline/removePipelineExtras.js
function removePipelineExtras(gltf) {
  ForEach_default.shader(gltf, function(shader) {
    removeExtras(shader);
  });
  ForEach_default.buffer(gltf, function(buffer) {
    removeExtras(buffer);
  });
  ForEach_default.image(gltf, function(image) {
    removeExtras(image);
  });
  removeExtras(gltf);
  return gltf;
}
function removeExtras(object2) {
  if (!defined_default(object2.extras)) {
    return;
  }
  if (defined_default(object2.extras._pipeline)) {
    delete object2.extras._pipeline;
  }
  if (Object.keys(object2.extras).length === 0) {
    delete object2.extras;
  }
}
var removePipelineExtras_default = removePipelineExtras;

// node_modules/cesium/Source/Scene/GltfJsonLoader.js
function GltfJsonLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resourceCache = options.resourceCache;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const typedArray = options.typedArray;
  const gltfJson = options.gltfJson;
  const cacheKey = options.cacheKey;
  Check_default.typeOf.func("options.resourceCache", resourceCache);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  this._resourceCache = resourceCache;
  this._gltfResource = gltfResource;
  this._baseResource = baseResource2;
  this._typedArray = typedArray;
  this._gltfJson = gltfJson;
  this._cacheKey = cacheKey;
  this._gltf = void 0;
  this._bufferLoaders = [];
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  GltfJsonLoader.prototype = Object.create(ResourceLoader.prototype);
  GltfJsonLoader.prototype.constructor = GltfJsonLoader;
}
Object.defineProperties(GltfJsonLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  gltf: {
    get: function() {
      return this._gltf;
    }
  }
});
GltfJsonLoader.prototype.load = function() {
  this._state = ResourceLoaderState_default.LOADING;
  let processPromise;
  if (defined_default(this._gltfJson)) {
    processPromise = processGltfJson(this, this._gltfJson);
  } else if (defined_default(this._typedArray)) {
    processPromise = processGltfTypedArray(this, this._typedArray);
  } else {
    processPromise = loadFromUri2(this);
  }
  const that = this;
  return processPromise.then(function(gltf) {
    if (that.isDestroyed()) {
      return;
    }
    that._gltf = gltf;
    that._state = ResourceLoaderState_default.READY;
    that._promise.resolve(that);
  }).catch(function(error) {
    if (that.isDestroyed()) {
      return;
    }
    handleError4(that, error);
  });
};
function loadFromUri2(gltfJsonLoader) {
  return gltfJsonLoader._fetchGltf().then(function(arrayBuffer) {
    if (gltfJsonLoader.isDestroyed()) {
      return;
    }
    const typedArray = new Uint8Array(arrayBuffer);
    return processGltfTypedArray(gltfJsonLoader, typedArray);
  });
}
function handleError4(gltfJsonLoader, error) {
  gltfJsonLoader.unload();
  gltfJsonLoader._state = ResourceLoaderState_default.FAILED;
  const errorMessage = `Failed to load glTF: ${gltfJsonLoader._gltfResource.url}`;
  gltfJsonLoader._promise.reject(gltfJsonLoader.getError(errorMessage, error));
}
function upgradeVersion(gltfJsonLoader, gltf) {
  if (gltf.asset.version === "2.0") {
    return Promise.resolve();
  }
  const promises = [];
  ForEach_default.buffer(gltf, function(buffer) {
    if (!defined_default(buffer.extras._pipeline.source) && defined_default(buffer.uri)) {
      const resource = gltfJsonLoader._baseResource.getDerivedResource({
        url: buffer.uri
      });
      const resourceCache = gltfJsonLoader._resourceCache;
      const bufferLoader = resourceCache.loadExternalBuffer({
        resource
      });
      gltfJsonLoader._bufferLoaders.push(bufferLoader);
      promises.push(
        bufferLoader.promise.then(function(bufferLoader2) {
          buffer.extras._pipeline.source = bufferLoader2.typedArray;
        })
      );
    }
  });
  return Promise.all(promises).then(function() {
    updateVersion_default(gltf);
  });
}
function decodeDataUris(gltf) {
  const promises = [];
  ForEach_default.buffer(gltf, function(buffer) {
    const bufferUri = buffer.uri;
    if (!defined_default(buffer.extras._pipeline.source) && defined_default(bufferUri) && isDataUri_default(bufferUri)) {
      delete buffer.uri;
      promises.push(
        Resource_default.fetchArrayBuffer(bufferUri).then(function(arrayBuffer) {
          buffer.extras._pipeline.source = new Uint8Array(arrayBuffer);
        })
      );
    }
  });
  return Promise.all(promises);
}
function loadEmbeddedBuffers(gltfJsonLoader, gltf) {
  const promises = [];
  ForEach_default.buffer(gltf, function(buffer, bufferId) {
    const source = buffer.extras._pipeline.source;
    if (defined_default(source) && !defined_default(buffer.uri)) {
      const resourceCache = gltfJsonLoader._resourceCache;
      const bufferLoader = resourceCache.loadEmbeddedBuffer({
        parentResource: gltfJsonLoader._gltfResource,
        bufferId,
        typedArray: source
      });
      gltfJsonLoader._bufferLoaders.push(bufferLoader);
      promises.push(bufferLoader.promise);
    }
  });
  return Promise.all(promises);
}
function processGltfJson(gltfJsonLoader, gltf) {
  addPipelineExtras_default(gltf);
  return decodeDataUris(gltf).then(function() {
    return upgradeVersion(gltfJsonLoader, gltf).then(function() {
      addDefaults_default(gltf);
      return loadEmbeddedBuffers(gltfJsonLoader, gltf).then(function() {
        removePipelineExtras_default(gltf);
        return gltf;
      });
    });
  });
}
function processGltfTypedArray(gltfJsonLoader, typedArray) {
  let gltf;
  if (getMagic_default(typedArray) === "glTF") {
    gltf = parseGlb_default(typedArray);
  } else {
    gltf = getJsonFromTypedArray_default(typedArray);
  }
  return processGltfJson(gltfJsonLoader, gltf);
}
GltfJsonLoader.prototype.unload = function() {
  const bufferLoaders = this._bufferLoaders;
  const bufferLoadersLength = bufferLoaders.length;
  for (let i2 = 0; i2 < bufferLoadersLength; ++i2) {
    this._resourceCache.unload(bufferLoaders[i2]);
  }
  this._bufferLoaders.length = 0;
  this._gltf = void 0;
};
GltfJsonLoader.prototype._fetchGltf = function() {
  return this._gltfResource.fetchArrayBuffer();
};

// node_modules/cesium/Source/Scene/AlphaMode.js
var AlphaMode = {
  OPAQUE: "OPAQUE",
  MASK: "MASK",
  BLEND: "BLEND"
};
var AlphaMode_default = Object.freeze(AlphaMode);

// node_modules/cesium/Source/Scene/ModelComponents.js
var ModelComponents = {};
function Quantization() {
  this.octEncoded = false;
  this.octEncodedZXY = false;
  this.normalizationRange = void 0;
  this.quantizedVolumeOffset = void 0;
  this.quantizedVolumeDimensions = void 0;
  this.quantizedVolumeStepSize = void 0;
  this.componentDatatype = void 0;
  this.type = void 0;
}
function Attribute() {
  this.name = void 0;
  this.semantic = void 0;
  this.setIndex = void 0;
  this.componentDatatype = void 0;
  this.type = void 0;
  this.normalized = false;
  this.count = void 0;
  this.min = void 0;
  this.max = void 0;
  this.constant = void 0;
  this.quantization = void 0;
  this.packedTypedArray = void 0;
  this.buffer = void 0;
  this.typedArray = void 0;
  this.byteOffset = 0;
  this.byteStride = void 0;
}
function Indices() {
  this.indexDatatype = void 0;
  this.count = void 0;
  this.buffer = void 0;
  this.typedArray = void 0;
}
function FeatureIdAttribute() {
  this.featureCount = void 0;
  this.nullFeatureId = void 0;
  this.propertyTableId = void 0;
  this.setIndex = void 0;
  this.label = void 0;
  this.positionalLabel = void 0;
}
function FeatureIdImplicitRange() {
  this.featureCount = void 0;
  this.nullFeatureId = void 0;
  this.propertyTableId = void 0;
  this.offset = 0;
  this.repeat = void 0;
  this.label = void 0;
  this.positionalLabel = void 0;
}
function FeatureIdTexture() {
  this.featureCount = void 0;
  this.nullFeatureId = void 0;
  this.propertyTableId = void 0;
  this.textureReader = void 0;
  this.label = void 0;
  this.positionalLabel = void 0;
}
function MorphTarget() {
  this.attributes = [];
}
function Primitive2() {
  this.attributes = [];
  this.morphTargets = [];
  this.indices = void 0;
  this.material = void 0;
  this.primitiveType = void 0;
  this.featureIds = [];
  this.propertyTextureIds = [];
  this.propertyAttributeIds = [];
}
function Instances() {
  this.attributes = [];
  this.featureIds = [];
  this.transformInWorldSpace = false;
}
function Skin() {
  this.index = void 0;
  this.joints = [];
  this.inverseBindMatrices = [];
}
function Node4() {
  this.name = void 0;
  this.index = void 0;
  this.children = [];
  this.primitives = [];
  this.instances = void 0;
  this.skin = void 0;
  this.matrix = void 0;
  this.translation = void 0;
  this.rotation = void 0;
  this.scale = void 0;
  this.morphWeights = [];
}
function Scene() {
  this.nodes = [];
}
var AnimatedPropertyType = {
  TRANSLATION: "translation",
  ROTATION: "rotation",
  SCALE: "scale",
  WEIGHTS: "weights"
};
function AnimationSampler() {
  this.input = [];
  this.interpolation = void 0;
  this.output = [];
}
function AnimationTarget() {
  this.node = void 0;
  this.path = void 0;
}
function AnimationChannel() {
  this.sampler = void 0;
  this.target = void 0;
}
function Animation() {
  this.name = void 0;
  this.samplers = [];
  this.channels = [];
}
function Asset() {
  this.credits = [];
}
function Components() {
  this.asset = new Asset();
  this.scene = void 0;
  this.nodes = [];
  this.skins = [];
  this.animations = [];
  this.structuralMetadata = void 0;
  this.upAxis = void 0;
  this.forwardAxis = void 0;
  this.transform = Matrix4_default.clone(Matrix4_default.IDENTITY);
}
function TextureReader() {
  this.texture = void 0;
  this.index = void 0;
  this.texCoord = 0;
  this.transform = Matrix3_default.clone(Matrix3_default.IDENTITY);
  this.channels = void 0;
}
function MetallicRoughness() {
  this.baseColorTexture = void 0;
  this.metallicRoughnessTexture = void 0;
  this.baseColorFactor = Cartesian4_default.clone(
    MetallicRoughness.DEFAULT_BASE_COLOR_FACTOR
  );
  this.metallicFactor = MetallicRoughness.DEFAULT_METALLIC_FACTOR;
  this.roughnessFactor = MetallicRoughness.DEFAULT_ROUGHNESS_FACTOR;
}
MetallicRoughness.DEFAULT_BASE_COLOR_FACTOR = Cartesian4_default.ONE;
MetallicRoughness.DEFAULT_METALLIC_FACTOR = 1;
MetallicRoughness.DEFAULT_ROUGHNESS_FACTOR = 1;
function SpecularGlossiness() {
  this.diffuseTexture = void 0;
  this.specularGlossinessTexture = void 0;
  this.diffuseFactor = Cartesian4_default.clone(
    SpecularGlossiness.DEFAULT_DIFFUSE_FACTOR
  );
  this.specularFactor = Cartesian3_default.clone(
    SpecularGlossiness.DEFAULT_SPECULAR_FACTOR
  );
  this.glossinessFactor = SpecularGlossiness.DEFAULT_GLOSSINESS_FACTOR;
}
SpecularGlossiness.DEFAULT_DIFFUSE_FACTOR = Cartesian4_default.ONE;
SpecularGlossiness.DEFAULT_SPECULAR_FACTOR = Cartesian3_default.ONE;
SpecularGlossiness.DEFAULT_GLOSSINESS_FACTOR = 1;
function Material2() {
  this.metallicRoughness = new MetallicRoughness();
  this.specularGlossiness = void 0;
  this.emissiveTexture = void 0;
  this.normalTexture = void 0;
  this.occlusionTexture = void 0;
  this.emissiveFactor = Cartesian3_default.clone(Material2.DEFAULT_EMISSIVE_FACTOR);
  this.alphaMode = AlphaMode_default.OPAQUE;
  this.alphaCutoff = 0.5;
  this.doubleSided = false;
  this.unlit = false;
}
Material2.DEFAULT_EMISSIVE_FACTOR = Cartesian3_default.ZERO;
ModelComponents.Quantization = Quantization;
ModelComponents.Attribute = Attribute;
ModelComponents.Indices = Indices;
ModelComponents.FeatureIdAttribute = FeatureIdAttribute;
ModelComponents.FeatureIdTexture = FeatureIdTexture;
ModelComponents.FeatureIdImplicitRange = FeatureIdImplicitRange;
ModelComponents.MorphTarget = MorphTarget;
ModelComponents.Primitive = Primitive2;
ModelComponents.Instances = Instances;
ModelComponents.Skin = Skin;
ModelComponents.Node = Node4;
ModelComponents.Scene = Scene;
ModelComponents.AnimatedPropertyType = Object.freeze(AnimatedPropertyType);
ModelComponents.AnimationSampler = AnimationSampler;
ModelComponents.AnimationTarget = AnimationTarget;
ModelComponents.AnimationChannel = AnimationChannel;
ModelComponents.Animation = Animation;
ModelComponents.Asset = Asset;
ModelComponents.Components = Components;
ModelComponents.TextureReader = TextureReader;
ModelComponents.MetallicRoughness = MetallicRoughness;
ModelComponents.SpecularGlossiness = SpecularGlossiness;
ModelComponents.Material = Material2;
var ModelComponents_default = ModelComponents;

// node_modules/cesium/Source/Scene/GltfLoaderUtil.js
var GltfLoaderUtil = {};
GltfLoaderUtil.getImageIdFromTexture = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const textureId = options.textureId;
  const supportedImageFormats = options.supportedImageFormats;
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.textureId", textureId);
  Check_default.typeOf.object("options.supportedImageFormats", supportedImageFormats);
  const texture = gltf.textures[textureId];
  const extensions = texture.extensions;
  if (defined_default(extensions)) {
    if (supportedImageFormats.webp && defined_default(extensions.EXT_texture_webp)) {
      return extensions.EXT_texture_webp.source;
    } else if (supportedImageFormats.basis && defined_default(extensions.KHR_texture_basisu)) {
      return extensions.KHR_texture_basisu.source;
    }
  }
  return texture.source;
};
GltfLoaderUtil.createSampler = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const textureInfo = options.textureInfo;
  const compressedTextureNoMipmap = defaultValue_default(
    options.compressedTextureNoMipmap,
    false
  );
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.textureInfo", textureInfo);
  let wrapS = TextureWrap_default.REPEAT;
  let wrapT = TextureWrap_default.REPEAT;
  let minFilter = TextureMinificationFilter_default.LINEAR;
  let magFilter = TextureMagnificationFilter_default.LINEAR;
  const textureId = textureInfo.index;
  const texture = gltf.textures[textureId];
  const samplerId = texture.sampler;
  if (defined_default(samplerId)) {
    const sampler = gltf.samplers[samplerId];
    wrapS = defaultValue_default(sampler.wrapS, wrapS);
    wrapT = defaultValue_default(sampler.wrapT, wrapT);
    minFilter = defaultValue_default(sampler.minFilter, minFilter);
    magFilter = defaultValue_default(sampler.magFilter, magFilter);
  }
  let usesTextureTransform = false;
  const extensions = textureInfo.extensions;
  if (defined_default(extensions) && defined_default(extensions.KHR_texture_transform)) {
    usesTextureTransform = true;
  }
  if ((compressedTextureNoMipmap || usesTextureTransform) && minFilter !== TextureMinificationFilter_default.LINEAR && minFilter !== TextureMinificationFilter_default.NEAREST) {
    if (minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_NEAREST || minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_LINEAR) {
      minFilter = TextureMinificationFilter_default.NEAREST;
    } else {
      minFilter = TextureMinificationFilter_default.LINEAR;
    }
  }
  return new Sampler_default({
    wrapS,
    wrapT,
    minificationFilter: minFilter,
    magnificationFilter: magFilter
  });
};
var defaultScale3 = new Cartesian2_default(1, 1);
GltfLoaderUtil.createModelTextureReader = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const textureInfo = options.textureInfo;
  const channels = options.channels;
  const texture = options.texture;
  Check_default.typeOf.object("options.textureInfo", textureInfo);
  let texCoord = defaultValue_default(textureInfo.texCoord, 0);
  let transform4;
  const textureTransform = defaultValue_default(
    textureInfo.extensions,
    defaultValue_default.EMPTY_OBJECT
  ).KHR_texture_transform;
  if (defined_default(textureTransform)) {
    texCoord = defaultValue_default(textureTransform.texCoord, texCoord);
    const offset2 = defined_default(textureTransform.offset) ? Cartesian2_default.unpack(textureTransform.offset) : Cartesian2_default.ZERO;
    let rotation = defaultValue_default(textureTransform.rotation, 0);
    const scale = defined_default(textureTransform.scale) ? Cartesian2_default.unpack(textureTransform.scale) : defaultScale3;
    rotation = -rotation;
    transform4 = new Matrix3_default(
      Math.cos(rotation) * scale.x,
      -Math.sin(rotation) * scale.y,
      offset2.x,
      Math.sin(rotation) * scale.x,
      Math.cos(rotation) * scale.y,
      offset2.y,
      0,
      0,
      1
    );
  }
  const modelTextureReader = new ModelComponents_default.TextureReader();
  modelTextureReader.index = textureInfo.index;
  modelTextureReader.texture = texture;
  modelTextureReader.texCoord = texCoord;
  modelTextureReader.transform = transform4;
  modelTextureReader.channels = channels;
  return modelTextureReader;
};
var GltfLoaderUtil_default = GltfLoaderUtil;

// node_modules/cesium/Source/Scene/GltfTextureLoader.js
function GltfTextureLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resourceCache = options.resourceCache;
  const gltf = options.gltf;
  const textureInfo = options.textureInfo;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const supportedImageFormats = options.supportedImageFormats;
  const cacheKey = options.cacheKey;
  const asynchronous = defaultValue_default(options.asynchronous, true);
  Check_default.typeOf.func("options.resourceCache", resourceCache);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.textureInfo", textureInfo);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  Check_default.typeOf.object("options.supportedImageFormats", supportedImageFormats);
  const textureId = textureInfo.index;
  const imageId = GltfLoaderUtil_default.getImageIdFromTexture({
    gltf,
    textureId,
    supportedImageFormats
  });
  this._resourceCache = resourceCache;
  this._gltf = gltf;
  this._textureInfo = textureInfo;
  this._imageId = imageId;
  this._gltfResource = gltfResource;
  this._baseResource = baseResource2;
  this._cacheKey = cacheKey;
  this._asynchronous = asynchronous;
  this._imageLoader = void 0;
  this._image = void 0;
  this._mipLevels = void 0;
  this._texture = void 0;
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  GltfTextureLoader.prototype = Object.create(ResourceLoader.prototype);
  GltfTextureLoader.prototype.constructor = GltfTextureLoader;
}
Object.defineProperties(GltfTextureLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  texture: {
    get: function() {
      return this._texture;
    }
  }
});
GltfTextureLoader.prototype.load = function() {
  const resourceCache = this._resourceCache;
  const imageLoader = resourceCache.loadImage({
    gltf: this._gltf,
    imageId: this._imageId,
    gltfResource: this._gltfResource,
    baseResource: this._baseResource
  });
  this._imageLoader = imageLoader;
  this._state = ResourceLoaderState_default.LOADING;
  const that = this;
  imageLoader.promise.then(function() {
    if (that.isDestroyed()) {
      return;
    }
    that._image = imageLoader.image;
    that._mipLevels = imageLoader.mipLevels;
    that._state = ResourceLoaderState_default.PROCESSING;
  }).catch(function(error) {
    if (that.isDestroyed()) {
      return;
    }
    that.unload();
    that._state = ResourceLoaderState_default.FAILED;
    const errorMessage = "Failed to load texture";
    that._promise.reject(that.getError(errorMessage, error));
  });
};
function CreateTextureJob2() {
  this.gltf = void 0;
  this.textureInfo = void 0;
  this.image = void 0;
  this.context = void 0;
  this.texture = void 0;
}
CreateTextureJob2.prototype.set = function(gltf, textureInfo, image, mipLevels, context) {
  this.gltf = gltf;
  this.textureInfo = textureInfo;
  this.image = image;
  this.mipLevels = mipLevels;
  this.context = context;
};
CreateTextureJob2.prototype.execute = function() {
  this.texture = createTexture5(
    this.gltf,
    this.textureInfo,
    this.image,
    this.mipLevels,
    this.context
  );
};
function resizeImageToNextPowerOfTwo(image) {
  const canvas = document.createElement("canvas");
  canvas.width = Math_default.nextPowerOfTwo(image.width);
  canvas.height = Math_default.nextPowerOfTwo(image.height);
  const canvasContext = canvas.getContext("2d");
  canvasContext.drawImage(
    image,
    0,
    0,
    image.width,
    image.height,
    0,
    0,
    canvas.width,
    canvas.height
  );
  return canvas;
}
function createTexture5(gltf, textureInfo, image, mipLevels, context) {
  const internalFormat = image.internalFormat;
  let compressedTextureNoMipmap = false;
  if (PixelFormat_default.isCompressedFormat(internalFormat) && !defined_default(mipLevels)) {
    compressedTextureNoMipmap = true;
  }
  const sampler = GltfLoaderUtil_default.createSampler({
    gltf,
    textureInfo,
    compressedTextureNoMipmap
  });
  const minFilter = sampler.minificationFilter;
  const wrapS = sampler.wrapS;
  const wrapT = sampler.wrapT;
  const samplerRequiresMipmap = minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_NEAREST || minFilter === TextureMinificationFilter_default.NEAREST_MIPMAP_LINEAR || minFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_NEAREST || minFilter === TextureMinificationFilter_default.LINEAR_MIPMAP_LINEAR;
  const generateMipmap = !defined_default(internalFormat) && samplerRequiresMipmap;
  const requiresPowerOfTwo = generateMipmap || wrapS === TextureWrap_default.REPEAT || wrapS === TextureWrap_default.MIRRORED_REPEAT || wrapT === TextureWrap_default.REPEAT || wrapT === TextureWrap_default.MIRRORED_REPEAT;
  const nonPowerOfTwo = !Math_default.isPowerOfTwo(image.width) || !Math_default.isPowerOfTwo(image.height);
  const requiresResize = requiresPowerOfTwo && nonPowerOfTwo;
  let texture;
  if (defined_default(internalFormat)) {
    if (!context.webgl2 && PixelFormat_default.isCompressedFormat(internalFormat) && nonPowerOfTwo && requiresPowerOfTwo) {
      console.warn(
        "Compressed texture uses REPEAT or MIRRORED_REPEAT texture wrap mode and dimensions are not powers of two. The texture may be rendered incorrectly."
      );
    }
    texture = Texture_default.create({
      context,
      source: {
        arrayBufferView: image.bufferView,
        mipLevels
      },
      width: image.width,
      height: image.height,
      pixelFormat: image.internalFormat,
      sampler
    });
  } else {
    if (requiresResize) {
      image = resizeImageToNextPowerOfTwo(image);
    }
    texture = Texture_default.create({
      context,
      source: image,
      sampler,
      flipY: false,
      skipColorSpaceConversion: true
    });
  }
  if (generateMipmap) {
    texture.generateMipmap();
  }
  return texture;
}
var scratchTextureJob = new CreateTextureJob2();
GltfTextureLoader.prototype.process = function(frameState) {
  Check_default.typeOf.object("frameState", frameState);
  if (defined_default(this._texture)) {
    return;
  }
  if (!defined_default(this._image)) {
    return;
  }
  let texture;
  if (this._asynchronous) {
    const textureJob = scratchTextureJob;
    textureJob.set(
      this._gltf,
      this._textureInfo,
      this._image,
      this._mipLevels,
      frameState.context
    );
    const jobScheduler = frameState.jobScheduler;
    if (!jobScheduler.execute(textureJob, JobType_default.TEXTURE)) {
      return;
    }
    texture = textureJob.texture;
  } else {
    texture = createTexture5(
      this._gltf,
      this._textureInfo,
      this._image,
      this._mipLevels,
      frameState.context
    );
  }
  this.unload();
  this._texture = texture;
  this._state = ResourceLoaderState_default.READY;
  this._promise.resolve(this);
};
GltfTextureLoader.prototype.unload = function() {
  if (defined_default(this._texture)) {
    this._texture.destroy();
  }
  if (defined_default(this._imageLoader)) {
    this._resourceCache.unload(this._imageLoader);
  }
  this._imageLoader = void 0;
  this._image = void 0;
  this._mipLevels = void 0;
  this._texture = void 0;
  this._gltf = void 0;
};

// node_modules/cesium/Source/Scene/GltfVertexBufferLoader.js
function GltfVertexBufferLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resourceCache = options.resourceCache;
  const gltf = options.gltf;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const bufferViewId = options.bufferViewId;
  const draco = options.draco;
  const attributeSemantic = options.attributeSemantic;
  const accessorId = options.accessorId;
  const cacheKey = options.cacheKey;
  const asynchronous = defaultValue_default(options.asynchronous, true);
  const dequantize = defaultValue_default(options.dequantize, false);
  const loadAsTypedArray = defaultValue_default(options.loadAsTypedArray, false);
  Check_default.typeOf.func("options.resourceCache", resourceCache);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const hasBufferViewId = defined_default(bufferViewId);
  const hasDraco = defined_default(draco);
  const hasAttributeSemantic = defined_default(attributeSemantic);
  const hasAccessorId = defined_default(accessorId);
  if (hasBufferViewId === hasDraco) {
    throw new DeveloperError_default(
      "One of options.bufferViewId and options.draco must be defined."
    );
  }
  if (hasDraco && !hasAttributeSemantic) {
    throw new DeveloperError_default(
      "When options.draco is defined options.attributeSemantic must also be defined."
    );
  }
  if (hasDraco && !hasAccessorId) {
    throw new DeveloperError_default(
      "When options.draco is defined options.accessorId must also be defined."
    );
  }
  if (hasDraco) {
    Check_default.typeOf.object("options.draco", draco);
    Check_default.typeOf.string("options.attributeSemantic", attributeSemantic);
    Check_default.typeOf.number("options.accessorId", accessorId);
  }
  this._resourceCache = resourceCache;
  this._gltfResource = gltfResource;
  this._baseResource = baseResource2;
  this._gltf = gltf;
  this._bufferViewId = bufferViewId;
  this._draco = draco;
  this._attributeSemantic = attributeSemantic;
  this._accessorId = accessorId;
  this._cacheKey = cacheKey;
  this._asynchronous = asynchronous;
  this._dequantize = dequantize;
  this._loadAsTypedArray = loadAsTypedArray;
  this._bufferViewLoader = void 0;
  this._dracoLoader = void 0;
  this._quantization = void 0;
  this._typedArray = void 0;
  this._buffer = void 0;
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  GltfVertexBufferLoader.prototype = Object.create(ResourceLoader.prototype);
  GltfVertexBufferLoader.prototype.constructor = GltfVertexBufferLoader;
}
Object.defineProperties(GltfVertexBufferLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  buffer: {
    get: function() {
      return this._buffer;
    }
  },
  typedArray: {
    get: function() {
      return this._typedArray;
    }
  },
  quantization: {
    get: function() {
      return this._quantization;
    }
  }
});
GltfVertexBufferLoader.prototype.load = function() {
  if (defined_default(this._draco)) {
    loadFromDraco2(this);
  } else {
    loadFromBufferView3(this);
  }
};
function getQuantizationInformation(dracoQuantization, componentDatatype, componentCount, type) {
  const quantizationBits = dracoQuantization.quantizationBits;
  const normalizationRange = (1 << quantizationBits) - 1;
  const normalizationDivisor = 1 / normalizationRange;
  const quantization = new ModelComponents_default.Quantization();
  quantization.componentDatatype = componentDatatype;
  quantization.octEncoded = dracoQuantization.octEncoded;
  quantization.octEncodedZXY = true;
  quantization.type = type;
  if (quantization.octEncoded) {
    quantization.type = AttributeType_default.VEC2;
    quantization.normalizationRange = normalizationRange;
  } else {
    const MathType = AttributeType_default.getMathType(type);
    if (MathType === Number) {
      const dimensions = dracoQuantization.range;
      quantization.quantizedVolumeOffset = dracoQuantization.minValues[0];
      quantization.quantizedVolumeDimensions = dimensions;
      quantization.normalizationRange = normalizationRange;
      quantization.quantizedVolumeStepSize = dimensions * normalizationDivisor;
    } else {
      quantization.quantizedVolumeOffset = MathType.unpack(
        dracoQuantization.minValues
      );
      quantization.normalizationRange = MathType.unpack(
        arrayFill_default(new Array(componentCount), normalizationRange)
      );
      const packedDimensions = arrayFill_default(
        new Array(componentCount),
        dracoQuantization.range
      );
      quantization.quantizedVolumeDimensions = MathType.unpack(
        packedDimensions
      );
      const packedSteps = packedDimensions.map(function(dimension) {
        return dimension * normalizationDivisor;
      });
      quantization.quantizedVolumeStepSize = MathType.unpack(packedSteps);
    }
  }
  return quantization;
}
function loadFromDraco2(vertexBufferLoader) {
  const resourceCache = vertexBufferLoader._resourceCache;
  const dracoLoader = resourceCache.loadDraco({
    gltf: vertexBufferLoader._gltf,
    draco: vertexBufferLoader._draco,
    gltfResource: vertexBufferLoader._gltfResource,
    baseResource: vertexBufferLoader._baseResource
  });
  vertexBufferLoader._dracoLoader = dracoLoader;
  vertexBufferLoader._state = ResourceLoaderState_default.LOADING;
  dracoLoader.promise.then(function() {
    if (vertexBufferLoader.isDestroyed()) {
      return;
    }
    const decodedVertexAttributes = dracoLoader.decodedData.vertexAttributes;
    const attributeSemantic = vertexBufferLoader._attributeSemantic;
    const dracoAttribute = decodedVertexAttributes[attributeSemantic];
    const accessorId = vertexBufferLoader._accessorId;
    const accessor = vertexBufferLoader._gltf.accessors[accessorId];
    const type = accessor.type;
    const typedArray = dracoAttribute.array;
    const dracoQuantization = dracoAttribute.data.quantization;
    if (defined_default(dracoQuantization)) {
      vertexBufferLoader._quantization = getQuantizationInformation(
        dracoQuantization,
        dracoAttribute.data.componentDatatype,
        dracoAttribute.data.componentsPerAttribute,
        type
      );
    }
    vertexBufferLoader._typedArray = typedArray;
    vertexBufferLoader._state = ResourceLoaderState_default.PROCESSING;
  }).catch(function(error) {
    if (vertexBufferLoader.isDestroyed()) {
      return;
    }
    handleError5(vertexBufferLoader, error);
  });
}
function loadFromBufferView3(vertexBufferLoader) {
  const resourceCache = vertexBufferLoader._resourceCache;
  const bufferViewLoader = resourceCache.loadBufferView({
    gltf: vertexBufferLoader._gltf,
    bufferViewId: vertexBufferLoader._bufferViewId,
    gltfResource: vertexBufferLoader._gltfResource,
    baseResource: vertexBufferLoader._baseResource
  });
  vertexBufferLoader._state = ResourceLoaderState_default.LOADING;
  vertexBufferLoader._bufferViewLoader = bufferViewLoader;
  bufferViewLoader.promise.then(function() {
    if (vertexBufferLoader.isDestroyed()) {
      return;
    }
    vertexBufferLoader._typedArray = bufferViewLoader.typedArray;
    vertexBufferLoader._state = ResourceLoaderState_default.PROCESSING;
  }).catch(function(error) {
    if (vertexBufferLoader.isDestroyed()) {
      return;
    }
    handleError5(vertexBufferLoader, error);
  });
}
function handleError5(vertexBufferLoader, error) {
  vertexBufferLoader.unload();
  vertexBufferLoader._state = ResourceLoaderState_default.FAILED;
  const errorMessage = "Failed to load vertex buffer";
  error = vertexBufferLoader.getError(errorMessage, error);
  vertexBufferLoader._promise.reject(error);
}
function CreateVertexBufferJob2() {
  this.typedArray = void 0;
  this.dequantize = void 0;
  this.componentType = void 0;
  this.type = void 0;
  this.count = void 0;
  this.context = void 0;
  this.buffer = void 0;
}
CreateVertexBufferJob2.prototype.set = function(typedArray, dequantize, componentType, type, count, context) {
  this.typedArray = typedArray;
  this.dequantize = dequantize;
  this.componentType = componentType;
  this.type = type;
  this.count = count;
  this.context = context;
};
CreateVertexBufferJob2.prototype.execute = function() {
  this.buffer = createVertexBuffer3(
    this.typedArray,
    this.dequantize,
    this.componentType,
    this.type,
    this.count,
    this.context
  );
};
function createVertexBuffer3(typedArray, dequantize, componentType, type, count, context) {
  if (dequantize && componentType !== ComponentDatatype_default.FLOAT) {
    typedArray = AttributeCompression_default.dequantize(
      typedArray,
      componentType,
      type,
      count
    );
  }
  const buffer = Buffer_default.createVertexBuffer({
    typedArray,
    context,
    usage: BufferUsage_default.STATIC_DRAW
  });
  buffer.vertexArrayDestroyable = false;
  return buffer;
}
var scratchVertexBufferJob2 = new CreateVertexBufferJob2();
GltfVertexBufferLoader.prototype.process = function(frameState) {
  Check_default.typeOf.object("frameState", frameState);
  if (this._state === ResourceLoaderState_default.READY) {
    return;
  }
  const typedArray = this._typedArray;
  const dequantize = this._dequantize;
  if (defined_default(this._dracoLoader)) {
    this._dracoLoader.process(frameState);
  }
  if (defined_default(this._bufferViewLoader)) {
    this._bufferViewLoader.process(frameState);
  }
  if (!defined_default(typedArray)) {
    return;
  }
  if (this._loadAsTypedArray) {
    this.unload();
    this._typedArray = typedArray;
    this._state = ResourceLoaderState_default.READY;
    this._promise.resolve(this);
    return;
  }
  const accessor = this._gltf.accessors[this._accessorId];
  let buffer;
  if (this._asynchronous) {
    const vertexBufferJob = scratchVertexBufferJob2;
    vertexBufferJob.set(
      typedArray,
      dequantize,
      accessor.componentType,
      accessor.type,
      accessor.count,
      frameState.context
    );
    const jobScheduler = frameState.jobScheduler;
    if (!jobScheduler.execute(vertexBufferJob, JobType_default.BUFFER)) {
      return;
    }
    buffer = vertexBufferJob.buffer;
  } else {
    buffer = createVertexBuffer3(
      typedArray,
      dequantize,
      accessor.componentType,
      accessor.type,
      accessor.count,
      frameState.context
    );
  }
  this.unload();
  this._buffer = buffer;
  this._state = ResourceLoaderState_default.READY;
  this._promise.resolve(this);
};
GltfVertexBufferLoader.prototype.unload = function() {
  if (defined_default(this._buffer)) {
    this._buffer.destroy();
  }
  const resourceCache = this._resourceCache;
  if (defined_default(this._bufferViewLoader)) {
    resourceCache.unload(this._bufferViewLoader);
  }
  if (defined_default(this._dracoLoader)) {
    resourceCache.unload(this._dracoLoader);
  }
  this._bufferViewLoader = void 0;
  this._dracoLoader = void 0;
  this._typedArray = void 0;
  this._buffer = void 0;
  this._gltf = void 0;
};

// node_modules/cesium/Source/Scene/MetadataClass.js
function MetadataClass(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const id = options.id;
  const classDefinition = options.class;
  Check_default.typeOf.string("options.id", id);
  Check_default.typeOf.object("options.class", classDefinition);
  const properties = {};
  const propertiesBySemantic = {};
  for (const propertyId in classDefinition.properties) {
    if (classDefinition.properties.hasOwnProperty(propertyId)) {
      const property = new MetadataClassProperty_default({
        id: propertyId,
        property: classDefinition.properties[propertyId],
        enums: options.enums
      });
      properties[propertyId] = property;
      if (defined_default(property.semantic)) {
        propertiesBySemantic[property.semantic] = property;
      }
    }
  }
  this._properties = properties;
  this._propertiesBySemantic = propertiesBySemantic;
  this._id = id;
  this._name = classDefinition.name;
  this._description = classDefinition.description;
  this._extras = classDefinition.extras;
  this._extensions = classDefinition.extensions;
}
Object.defineProperties(MetadataClass.prototype, {
  properties: {
    get: function() {
      return this._properties;
    }
  },
  propertiesBySemantic: {
    get: function() {
      return this._propertiesBySemantic;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  name: {
    get: function() {
      return this._name;
    }
  },
  description: {
    get: function() {
      return this._description;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
MetadataClass.BATCH_TABLE_CLASS_NAME = "_batchTable";
var MetadataClass_default = MetadataClass;

// node_modules/cesium/Source/Scene/MetadataEnumValue.js
function MetadataEnumValue(value) {
  Check_default.typeOf.object("value", value);
  this._value = value.value;
  this._name = value.name;
  this._description = value.description;
  this._extras = value.extras;
  this._extensions = value.extensions;
}
Object.defineProperties(MetadataEnumValue.prototype, {
  value: {
    get: function() {
      return this._value;
    }
  },
  name: {
    get: function() {
      return this._name;
    }
  },
  description: {
    get: function() {
      return this._description;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
var MetadataEnumValue_default = MetadataEnumValue;

// node_modules/cesium/Source/Scene/MetadataEnum.js
function MetadataEnum(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const id = options.id;
  const enumDefinition = options.enum;
  Check_default.typeOf.string("options.id", id);
  Check_default.typeOf.object("options.enum", enumDefinition);
  const namesByValue = {};
  const valuesByName = {};
  const values = enumDefinition.values.map(function(value) {
    namesByValue[value.value] = value.name;
    valuesByName[value.name] = value.value;
    return new MetadataEnumValue_default(value);
  });
  const valueType = defaultValue_default(
    MetadataComponentType_default[enumDefinition.valueType],
    MetadataComponentType_default.UINT16
  );
  this._values = values;
  this._namesByValue = namesByValue;
  this._valuesByName = valuesByName;
  this._valueType = valueType;
  this._id = id;
  this._name = enumDefinition.name;
  this._description = enumDefinition.description;
  this._extras = enumDefinition.extras;
  this._extensions = enumDefinition.extensions;
}
Object.defineProperties(MetadataEnum.prototype, {
  values: {
    get: function() {
      return this._values;
    }
  },
  namesByValue: {
    get: function() {
      return this._namesByValue;
    }
  },
  valuesByName: {
    get: function() {
      return this._valuesByName;
    }
  },
  valueType: {
    get: function() {
      return this._valueType;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  name: {
    get: function() {
      return this._name;
    }
  },
  description: {
    get: function() {
      return this._description;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
var MetadataEnum_default = MetadataEnum;

// node_modules/cesium/Source/Scene/MetadataSchema.js
function MetadataSchema(schema) {
  Check_default.typeOf.object("schema", schema);
  const enums = {};
  if (defined_default(schema.enums)) {
    for (const enumId in schema.enums) {
      if (schema.enums.hasOwnProperty(enumId)) {
        enums[enumId] = new MetadataEnum_default({
          id: enumId,
          enum: schema.enums[enumId]
        });
      }
    }
  }
  const classes = {};
  if (defined_default(schema.classes)) {
    for (const classId in schema.classes) {
      if (schema.classes.hasOwnProperty(classId)) {
        classes[classId] = new MetadataClass_default({
          id: classId,
          class: schema.classes[classId],
          enums
        });
      }
    }
  }
  this._classes = classes;
  this._enums = enums;
  this._id = schema.id;
  this._name = schema.name;
  this._description = schema.description;
  this._version = schema.version;
  this._extras = schema.extras;
  this._extensions = schema.extensions;
}
Object.defineProperties(MetadataSchema.prototype, {
  classes: {
    get: function() {
      return this._classes;
    }
  },
  enums: {
    get: function() {
      return this._enums;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  name: {
    get: function() {
      return this._name;
    }
  },
  description: {
    get: function() {
      return this._description;
    }
  },
  version: {
    get: function() {
      return this._version;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
var MetadataSchema_default = MetadataSchema;

// node_modules/cesium/Source/Scene/MetadataSchemaLoader.js
function MetadataSchemaLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const schema = options.schema;
  const resource = options.resource;
  const cacheKey = options.cacheKey;
  if (defined_default(schema) === defined_default(resource)) {
    throw new DeveloperError_default(
      "One of options.schema and options.resource must be defined."
    );
  }
  this._schema = defined_default(schema) ? new MetadataSchema_default(schema) : void 0;
  this._resource = resource;
  this._cacheKey = cacheKey;
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  MetadataSchemaLoader.prototype = Object.create(ResourceLoader.prototype);
  MetadataSchemaLoader.prototype.constructor = MetadataSchemaLoader;
}
Object.defineProperties(MetadataSchemaLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  schema: {
    get: function() {
      return this._schema;
    }
  }
});
MetadataSchemaLoader.prototype.load = function() {
  if (defined_default(this._schema)) {
    this._promise.resolve(this);
    return;
  }
  loadExternalSchema(this);
};
function loadExternalSchema(schemaLoader) {
  const resource = schemaLoader._resource;
  schemaLoader._state = ResourceLoaderState_default.LOADING;
  resource.fetchJson().then(function(json) {
    if (schemaLoader.isDestroyed()) {
      return;
    }
    schemaLoader._schema = new MetadataSchema_default(json);
    schemaLoader._state = ResourceLoaderState_default.READY;
    schemaLoader._promise.resolve(schemaLoader);
  }).catch(function(error) {
    if (schemaLoader.isDestroyed()) {
      return;
    }
    schemaLoader._state = ResourceLoaderState_default.FAILED;
    const errorMessage = `Failed to load schema: ${resource.url}`;
    schemaLoader._promise.reject(schemaLoader.getError(errorMessage, error));
  });
}
MetadataSchemaLoader.prototype.unload = function() {
  this._schema = void 0;
};

// node_modules/cesium/Source/Scene/ResourceCacheKey.js
var ResourceCacheKey = {};
function getExternalResourceCacheKey(resource) {
  return getAbsoluteUri_default(resource.url);
}
function getBufferViewCacheKey(bufferView) {
  let byteOffset = bufferView.byteOffset;
  let byteLength = bufferView.byteLength;
  if (hasExtension(bufferView, "EXT_meshopt_compression")) {
    const meshopt = bufferView.extensions.EXT_meshopt_compression;
    byteOffset = defaultValue_default(meshopt.byteOffset, 0);
    byteLength = meshopt.byteLength;
  }
  return `${byteOffset}-${byteOffset + byteLength}`;
}
function getAccessorCacheKey(accessor, bufferView) {
  const byteOffset = bufferView.byteOffset + accessor.byteOffset;
  const componentType = accessor.componentType;
  const type = accessor.type;
  const count = accessor.count;
  return `${byteOffset}-${componentType}-${type}-${count}`;
}
function getExternalBufferCacheKey(resource) {
  return getExternalResourceCacheKey(resource);
}
function getEmbeddedBufferCacheKey(parentResource, bufferId) {
  const parentCacheKey = getExternalResourceCacheKey(parentResource);
  return `${parentCacheKey}-buffer-id-${bufferId}`;
}
function getBufferCacheKey(buffer, bufferId, gltfResource, baseResource2) {
  if (defined_default(buffer.uri)) {
    const resource = baseResource2.getDerivedResource({
      url: buffer.uri
    });
    return getExternalBufferCacheKey(resource);
  }
  return getEmbeddedBufferCacheKey(gltfResource, bufferId);
}
function getDracoCacheKey(gltf, draco, gltfResource, baseResource2) {
  const bufferViewId = draco.bufferView;
  const bufferView = gltf.bufferViews[bufferViewId];
  const bufferId = bufferView.buffer;
  const buffer = gltf.buffers[bufferId];
  const bufferCacheKey = getBufferCacheKey(
    buffer,
    bufferId,
    gltfResource,
    baseResource2
  );
  const bufferViewCacheKey = getBufferViewCacheKey(bufferView);
  return `${bufferCacheKey}-range-${bufferViewCacheKey}`;
}
function getImageCacheKey(gltf, imageId, gltfResource, baseResource2) {
  const image = gltf.images[imageId];
  const bufferViewId = image.bufferView;
  const uri = image.uri;
  if (defined_default(uri)) {
    const resource = baseResource2.getDerivedResource({
      url: uri
    });
    return getExternalResourceCacheKey(resource);
  }
  const bufferView = gltf.bufferViews[bufferViewId];
  const bufferId = bufferView.buffer;
  const buffer = gltf.buffers[bufferId];
  const bufferCacheKey = getBufferCacheKey(
    buffer,
    bufferId,
    gltfResource,
    baseResource2
  );
  const bufferViewCacheKey = getBufferViewCacheKey(bufferView);
  return `${bufferCacheKey}-range-${bufferViewCacheKey}`;
}
function getSamplerCacheKey(gltf, textureInfo) {
  const sampler = GltfLoaderUtil_default.createSampler({
    gltf,
    textureInfo
  });
  return `${sampler.wrapS}-${sampler.wrapT}-${sampler.minificationFilter}-${sampler.magnificationFilter}`;
}
ResourceCacheKey.getSchemaCacheKey = function(options) {
  const schema = options.schema;
  const resource = options.resource;
  if (defined_default(schema) === defined_default(resource)) {
    throw new DeveloperError_default(
      "One of options.schema and options.resource must be defined."
    );
  }
  if (defined_default(schema)) {
    return `embedded-schema:${JSON.stringify(schema)}`;
  }
  return `external-schema:${getExternalResourceCacheKey(resource)}`;
};
ResourceCacheKey.getExternalBufferCacheKey = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resource = options.resource;
  Check_default.typeOf.object("options.resource", resource);
  return `external-buffer:${getExternalBufferCacheKey(resource)}`;
};
ResourceCacheKey.getEmbeddedBufferCacheKey = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const parentResource = options.parentResource;
  const bufferId = options.bufferId;
  Check_default.typeOf.object("options.parentResource", parentResource);
  Check_default.typeOf.number("options.bufferId", bufferId);
  return `embedded-buffer:${getEmbeddedBufferCacheKey(
    parentResource,
    bufferId
  )}`;
};
ResourceCacheKey.getGltfCacheKey = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltfResource = options.gltfResource;
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  return `gltf:${getExternalResourceCacheKey(gltfResource)}`;
};
ResourceCacheKey.getBufferViewCacheKey = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const bufferViewId = options.bufferViewId;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.bufferViewId", bufferViewId);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const bufferView = gltf.bufferViews[bufferViewId];
  let bufferId = bufferView.buffer;
  const buffer = gltf.buffers[bufferId];
  if (hasExtension(bufferView, "EXT_meshopt_compression")) {
    const meshopt = bufferView.extensions.EXT_meshopt_compression;
    bufferId = meshopt.buffer;
  }
  const bufferCacheKey = getBufferCacheKey(
    buffer,
    bufferId,
    gltfResource,
    baseResource2
  );
  const bufferViewCacheKey = getBufferViewCacheKey(bufferView);
  return `buffer-view:${bufferCacheKey}-range-${bufferViewCacheKey}`;
};
ResourceCacheKey.getDracoCacheKey = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const draco = options.draco;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.draco", draco);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  return `draco:${getDracoCacheKey(gltf, draco, gltfResource, baseResource2)}`;
};
ResourceCacheKey.getVertexBufferCacheKey = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const bufferViewId = options.bufferViewId;
  const draco = options.draco;
  const attributeSemantic = options.attributeSemantic;
  const dequantize = defaultValue_default(options.dequantize, false);
  const loadAsTypedArray = defaultValue_default(options.loadAsTypedArray, false);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const hasBufferViewId = defined_default(bufferViewId);
  const hasDraco = defined_default(draco);
  const hasAttributeSemantic = defined_default(attributeSemantic);
  if (hasBufferViewId === hasDraco) {
    throw new DeveloperError_default(
      "One of options.bufferViewId and options.draco must be defined."
    );
  }
  if (hasDraco && !hasAttributeSemantic) {
    throw new DeveloperError_default(
      "When options.draco is defined options.attributeSemantic must also be defined."
    );
  }
  if (hasDraco) {
    Check_default.typeOf.object("options.draco", draco);
    Check_default.typeOf.string("options.attributeSemantic", attributeSemantic);
  }
  let cacheKeySuffix = "";
  if (dequantize) {
    cacheKeySuffix += "-dequantize";
  }
  if (loadAsTypedArray) {
    cacheKeySuffix += "-typed-array";
  }
  if (defined_default(draco)) {
    const dracoCacheKey = getDracoCacheKey(
      gltf,
      draco,
      gltfResource,
      baseResource2
    );
    return `vertex-buffer:${dracoCacheKey}-draco-${attributeSemantic}${cacheKeySuffix}`;
  }
  const bufferView = gltf.bufferViews[bufferViewId];
  const bufferId = bufferView.buffer;
  const buffer = gltf.buffers[bufferId];
  const bufferCacheKey = getBufferCacheKey(
    buffer,
    bufferId,
    gltfResource,
    baseResource2
  );
  const bufferViewCacheKey = getBufferViewCacheKey(bufferView);
  return `vertex-buffer:${bufferCacheKey}-range-${bufferViewCacheKey}${cacheKeySuffix}`;
};
ResourceCacheKey.getIndexBufferCacheKey = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const accessorId = options.accessorId;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const draco = options.draco;
  const loadAsTypedArray = defaultValue_default(options.loadAsTypedArray, false);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.accessorId", accessorId);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  let cacheKeySuffix = "";
  if (loadAsTypedArray) {
    cacheKeySuffix += "-typed-array";
  }
  if (defined_default(draco)) {
    const dracoCacheKey = getDracoCacheKey(
      gltf,
      draco,
      gltfResource,
      baseResource2
    );
    return `index-buffer:${dracoCacheKey}-draco${cacheKeySuffix}`;
  }
  const accessor = gltf.accessors[accessorId];
  const bufferViewId = accessor.bufferView;
  const bufferView = gltf.bufferViews[bufferViewId];
  const bufferId = bufferView.buffer;
  const buffer = gltf.buffers[bufferId];
  const bufferCacheKey = getBufferCacheKey(
    buffer,
    bufferId,
    gltfResource,
    baseResource2
  );
  const accessorCacheKey = getAccessorCacheKey(accessor, bufferView);
  return `index-buffer:${bufferCacheKey}-accessor-${accessorCacheKey}${cacheKeySuffix}`;
};
ResourceCacheKey.getImageCacheKey = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const imageId = options.imageId;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.imageId", imageId);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const imageCacheKey = getImageCacheKey(
    gltf,
    imageId,
    gltfResource,
    baseResource2
  );
  return `image:${imageCacheKey}`;
};
ResourceCacheKey.getTextureCacheKey = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const textureInfo = options.textureInfo;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const supportedImageFormats = options.supportedImageFormats;
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.textureInfo", textureInfo);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  Check_default.typeOf.object("options.supportedImageFormats", supportedImageFormats);
  const textureId = textureInfo.index;
  const imageId = GltfLoaderUtil_default.getImageIdFromTexture({
    gltf,
    textureId,
    supportedImageFormats
  });
  const imageCacheKey = getImageCacheKey(
    gltf,
    imageId,
    gltfResource,
    baseResource2
  );
  const samplerCacheKey = getSamplerCacheKey(gltf, textureInfo);
  return `texture:${imageCacheKey}-sampler-${samplerCacheKey}`;
};
var ResourceCacheKey_default = ResourceCacheKey;

// node_modules/cesium/Source/Scene/ResourceCache.js
function ResourceCache() {
}
ResourceCache.cacheEntries = {};
function CacheEntry(resourceLoader) {
  this.referenceCount = 1;
  this.resourceLoader = resourceLoader;
}
ResourceCache.get = function(cacheKey) {
  Check_default.typeOf.string("cacheKey", cacheKey);
  const cacheEntry = ResourceCache.cacheEntries[cacheKey];
  if (defined_default(cacheEntry)) {
    ++cacheEntry.referenceCount;
    return cacheEntry.resourceLoader;
  }
  return void 0;
};
ResourceCache.load = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resourceLoader = options.resourceLoader;
  Check_default.typeOf.object("options.resourceLoader", resourceLoader);
  const cacheKey = resourceLoader.cacheKey;
  Check_default.typeOf.string("options.resourceLoader.cacheKey", cacheKey);
  if (defined_default(ResourceCache.cacheEntries[cacheKey])) {
    throw new DeveloperError_default(
      `Resource with this cacheKey is already in the cache: ${cacheKey}`
    );
  }
  ResourceCache.cacheEntries[cacheKey] = new CacheEntry(resourceLoader);
  resourceLoader.load();
};
ResourceCache.unload = function(resourceLoader) {
  Check_default.typeOf.object("resourceLoader", resourceLoader);
  const cacheKey = resourceLoader.cacheKey;
  const cacheEntry = ResourceCache.cacheEntries[cacheKey];
  if (!defined_default(cacheEntry)) {
    throw new DeveloperError_default(`Resource is not in the cache: ${cacheKey}`);
  }
  --cacheEntry.referenceCount;
  if (cacheEntry.referenceCount === 0) {
    resourceLoader.destroy();
    delete ResourceCache.cacheEntries[cacheKey];
  }
};
ResourceCache.loadSchema = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const schema = options.schema;
  const resource = options.resource;
  if (defined_default(schema) === defined_default(resource)) {
    throw new DeveloperError_default(
      "One of options.schema and options.resource must be defined."
    );
  }
  const cacheKey = ResourceCacheKey_default.getSchemaCacheKey({
    schema,
    resource
  });
  let schemaLoader = ResourceCache.get(cacheKey);
  if (defined_default(schemaLoader)) {
    return schemaLoader;
  }
  schemaLoader = new MetadataSchemaLoader({
    schema,
    resource,
    cacheKey
  });
  ResourceCache.load({
    resourceLoader: schemaLoader
  });
  return schemaLoader;
};
ResourceCache.loadEmbeddedBuffer = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const parentResource = options.parentResource;
  const bufferId = options.bufferId;
  const typedArray = options.typedArray;
  Check_default.typeOf.object("options.parentResource", parentResource);
  Check_default.typeOf.number("options.bufferId", bufferId);
  const cacheKey = ResourceCacheKey_default.getEmbeddedBufferCacheKey({
    parentResource,
    bufferId
  });
  let bufferLoader = ResourceCache.get(cacheKey);
  if (defined_default(bufferLoader)) {
    return bufferLoader;
  }
  Check_default.typeOf.object("options.typedArray", typedArray);
  bufferLoader = new BufferLoader({
    typedArray,
    cacheKey
  });
  ResourceCache.load({
    resourceLoader: bufferLoader
  });
  return bufferLoader;
};
ResourceCache.loadExternalBuffer = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resource = options.resource;
  Check_default.typeOf.object("options.resource", resource);
  const cacheKey = ResourceCacheKey_default.getExternalBufferCacheKey({
    resource
  });
  let bufferLoader = ResourceCache.get(cacheKey);
  if (defined_default(bufferLoader)) {
    return bufferLoader;
  }
  bufferLoader = new BufferLoader({
    resource,
    cacheKey
  });
  ResourceCache.load({
    resourceLoader: bufferLoader
  });
  return bufferLoader;
};
ResourceCache.loadGltfJson = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const typedArray = options.typedArray;
  const gltfJson = options.gltfJson;
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const cacheKey = ResourceCacheKey_default.getGltfCacheKey({
    gltfResource
  });
  let gltfJsonLoader = ResourceCache.get(cacheKey);
  if (defined_default(gltfJsonLoader)) {
    return gltfJsonLoader;
  }
  gltfJsonLoader = new GltfJsonLoader({
    resourceCache: ResourceCache,
    gltfResource,
    baseResource: baseResource2,
    typedArray,
    gltfJson,
    cacheKey
  });
  ResourceCache.load({
    resourceLoader: gltfJsonLoader
  });
  return gltfJsonLoader;
};
ResourceCache.loadBufferView = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const bufferViewId = options.bufferViewId;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.bufferViewId", bufferViewId);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const cacheKey = ResourceCacheKey_default.getBufferViewCacheKey({
    gltf,
    bufferViewId,
    gltfResource,
    baseResource: baseResource2
  });
  let bufferViewLoader = ResourceCache.get(cacheKey);
  if (defined_default(bufferViewLoader)) {
    return bufferViewLoader;
  }
  bufferViewLoader = new GltfBufferViewLoader({
    resourceCache: ResourceCache,
    gltf,
    bufferViewId,
    gltfResource,
    baseResource: baseResource2,
    cacheKey
  });
  ResourceCache.load({
    resourceLoader: bufferViewLoader
  });
  return bufferViewLoader;
};
ResourceCache.loadDraco = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const draco = options.draco;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.draco", draco);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const cacheKey = ResourceCacheKey_default.getDracoCacheKey({
    gltf,
    draco,
    gltfResource,
    baseResource: baseResource2
  });
  let dracoLoader = ResourceCache.get(cacheKey);
  if (defined_default(dracoLoader)) {
    return dracoLoader;
  }
  dracoLoader = new GltfDracoLoader({
    resourceCache: ResourceCache,
    gltf,
    draco,
    gltfResource,
    baseResource: baseResource2,
    cacheKey
  });
  ResourceCache.load({
    resourceLoader: dracoLoader
  });
  return dracoLoader;
};
ResourceCache.loadVertexBuffer = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const bufferViewId = options.bufferViewId;
  const draco = options.draco;
  const attributeSemantic = options.attributeSemantic;
  const accessorId = options.accessorId;
  const asynchronous = defaultValue_default(options.asynchronous, true);
  const dequantize = defaultValue_default(options.dequantize, false);
  const loadAsTypedArray = defaultValue_default(options.loadAsTypedArray, false);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const hasBufferViewId = defined_default(bufferViewId);
  const hasDraco = defined_default(draco);
  const hasAttributeSemantic = defined_default(attributeSemantic);
  const hasAccessorId = defined_default(accessorId);
  if (hasBufferViewId === hasDraco) {
    throw new DeveloperError_default(
      "One of options.bufferViewId and options.draco must be defined."
    );
  }
  if (hasDraco && !hasAttributeSemantic) {
    throw new DeveloperError_default(
      "When options.draco is defined options.attributeSemantic must also be defined."
    );
  }
  if (hasDraco && !hasAccessorId) {
    throw new DeveloperError_default(
      "When options.draco is defined options.haAccessorId must also be defined."
    );
  }
  if (hasDraco) {
    Check_default.typeOf.object("options.draco", draco);
    Check_default.typeOf.string("options.attributeSemantic", attributeSemantic);
    Check_default.typeOf.number("options.accessorId", accessorId);
  }
  const cacheKey = ResourceCacheKey_default.getVertexBufferCacheKey({
    gltf,
    gltfResource,
    baseResource: baseResource2,
    bufferViewId,
    draco,
    attributeSemantic,
    dequantize,
    loadAsTypedArray
  });
  let vertexBufferLoader = ResourceCache.get(cacheKey);
  if (defined_default(vertexBufferLoader)) {
    return vertexBufferLoader;
  }
  vertexBufferLoader = new GltfVertexBufferLoader({
    resourceCache: ResourceCache,
    gltf,
    gltfResource,
    baseResource: baseResource2,
    bufferViewId,
    draco,
    attributeSemantic,
    accessorId,
    cacheKey,
    asynchronous,
    dequantize,
    loadAsTypedArray
  });
  ResourceCache.load({
    resourceLoader: vertexBufferLoader
  });
  return vertexBufferLoader;
};
ResourceCache.loadIndexBuffer = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const accessorId = options.accessorId;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const draco = options.draco;
  const asynchronous = defaultValue_default(options.asynchronous, true);
  const loadAsTypedArray = defaultValue_default(options.loadAsTypedArray, false);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.accessorId", accessorId);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const cacheKey = ResourceCacheKey_default.getIndexBufferCacheKey({
    gltf,
    accessorId,
    gltfResource,
    baseResource: baseResource2,
    draco,
    loadAsTypedArray
  });
  let indexBufferLoader = ResourceCache.get(cacheKey);
  if (defined_default(indexBufferLoader)) {
    return indexBufferLoader;
  }
  indexBufferLoader = new GltfIndexBufferLoader({
    resourceCache: ResourceCache,
    gltf,
    accessorId,
    gltfResource,
    baseResource: baseResource2,
    draco,
    cacheKey,
    asynchronous,
    loadAsTypedArray
  });
  ResourceCache.load({
    resourceLoader: indexBufferLoader
  });
  return indexBufferLoader;
};
ResourceCache.loadImage = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const imageId = options.imageId;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.number("options.imageId", imageId);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const cacheKey = ResourceCacheKey_default.getImageCacheKey({
    gltf,
    imageId,
    gltfResource,
    baseResource: baseResource2
  });
  let imageLoader = ResourceCache.get(cacheKey);
  if (defined_default(imageLoader)) {
    return imageLoader;
  }
  imageLoader = new GltfImageLoader({
    resourceCache: ResourceCache,
    gltf,
    imageId,
    gltfResource,
    baseResource: baseResource2,
    cacheKey
  });
  ResourceCache.load({
    resourceLoader: imageLoader
  });
  return imageLoader;
};
ResourceCache.loadTexture = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const textureInfo = options.textureInfo;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const supportedImageFormats = options.supportedImageFormats;
  const asynchronous = defaultValue_default(options.asynchronous, true);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.textureInfo", textureInfo);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  const cacheKey = ResourceCacheKey_default.getTextureCacheKey({
    gltf,
    textureInfo,
    gltfResource,
    baseResource: baseResource2,
    supportedImageFormats
  });
  let textureLoader = ResourceCache.get(cacheKey);
  if (defined_default(textureLoader)) {
    return textureLoader;
  }
  textureLoader = new GltfTextureLoader({
    resourceCache: ResourceCache,
    gltf,
    textureInfo,
    gltfResource,
    baseResource: baseResource2,
    supportedImageFormats,
    cacheKey,
    asynchronous
  });
  ResourceCache.load({
    resourceLoader: textureLoader
  });
  return textureLoader;
};
ResourceCache.clearForSpecs = function() {
  const precedence = [
    GltfVertexBufferLoader,
    GltfIndexBufferLoader,
    GltfDracoLoader,
    GltfTextureLoader,
    GltfImageLoader,
    GltfBufferViewLoader,
    BufferLoader,
    MetadataSchemaLoader,
    GltfJsonLoader
  ];
  let cacheKey;
  const cacheEntries = ResourceCache.cacheEntries;
  const cacheEntriesSorted = [];
  for (cacheKey in cacheEntries) {
    if (cacheEntries.hasOwnProperty(cacheKey)) {
      cacheEntriesSorted.push(cacheEntries[cacheKey]);
    }
  }
  cacheEntriesSorted.sort(function(a4, b) {
    const indexA = precedence.indexOf(a4.resourceLoader.constructor);
    const indexB = precedence.indexOf(b.resourceLoader.constructor);
    return indexA - indexB;
  });
  const cacheEntriesLength = cacheEntriesSorted.length;
  for (let i2 = 0; i2 < cacheEntriesLength; ++i2) {
    const cacheEntry = cacheEntriesSorted[i2];
    cacheKey = cacheEntry.resourceLoader.cacheKey;
    if (defined_default(cacheEntries[cacheKey])) {
      cacheEntry.resourceLoader.destroy();
      delete cacheEntries[cacheKey];
    }
  }
};
var ResourceCache_default = ResourceCache;

// node_modules/cesium/Source/Scene/ImplicitSubtree.js
function ImplicitSubtree(resource, json, subtreeView, implicitTileset, implicitCoordinates) {
  Check_default.typeOf.object("resource", resource);
  if (defined_default(json) === defined_default(subtreeView)) {
    throw new DeveloperError_default("One of json and subtreeView must be defined.");
  }
  Check_default.typeOf.object("implicitTileset", implicitTileset);
  Check_default.typeOf.object("implicitCoordinates", implicitCoordinates);
  this._resource = resource;
  this._subtreeJson = void 0;
  this._bufferLoader = void 0;
  this._tileAvailability = void 0;
  this._contentAvailabilityBitstreams = [];
  this._childSubtreeAvailability = void 0;
  this._implicitCoordinates = implicitCoordinates;
  this._subtreeLevels = implicitTileset.subtreeLevels;
  this._subdivisionScheme = implicitTileset.subdivisionScheme;
  this._branchingFactor = implicitTileset.branchingFactor;
  this._readyPromise = defer_default();
  this._metadata = void 0;
  this._tileMetadataTable = void 0;
  this._tilePropertyTableJson = void 0;
  this._contentMetadataTables = [];
  this._contentPropertyTableJsons = [];
  this._tileJumpBuffer = void 0;
  this._contentJumpBuffers = [];
  initialize7(this, json, subtreeView, implicitTileset);
}
Object.defineProperties(ImplicitSubtree.prototype, {
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    }
  },
  tileMetadataTable: {
    get: function() {
      return this._tileMetadataTable;
    }
  },
  tilePropertyTableJson: {
    get: function() {
      return this._tilePropertyTableJson;
    }
  },
  contentMetadataTables: {
    get: function() {
      return this._contentMetadataTables;
    }
  },
  contentPropertyTableJsons: {
    get: function() {
      return this._contentPropertyTableJsons;
    }
  },
  implicitCoordinates: {
    get: function() {
      return this._implicitCoordinates;
    }
  }
});
ImplicitSubtree.prototype.tileIsAvailableAtIndex = function(index2) {
  return this._tileAvailability.getBit(index2);
};
ImplicitSubtree.prototype.tileIsAvailableAtCoordinates = function(implicitCoordinates) {
  const index2 = this.getTileIndex(implicitCoordinates);
  return this.tileIsAvailableAtIndex(index2);
};
ImplicitSubtree.prototype.contentIsAvailableAtIndex = function(index2, contentIndex) {
  contentIndex = defaultValue_default(contentIndex, 0);
  if (contentIndex < 0 || contentIndex >= this._contentAvailabilityBitstreams.length) {
    throw new DeveloperError_default("contentIndex out of bounds.");
  }
  return this._contentAvailabilityBitstreams[contentIndex].getBit(index2);
};
ImplicitSubtree.prototype.contentIsAvailableAtCoordinates = function(implicitCoordinates, contentIndex) {
  const index2 = this.getTileIndex(implicitCoordinates);
  return this.contentIsAvailableAtIndex(index2, contentIndex);
};
ImplicitSubtree.prototype.childSubtreeIsAvailableAtIndex = function(index2) {
  return this._childSubtreeAvailability.getBit(index2);
};
ImplicitSubtree.prototype.childSubtreeIsAvailableAtCoordinates = function(implicitCoordinates) {
  const index2 = this.getChildSubtreeIndex(implicitCoordinates);
  return this.childSubtreeIsAvailableAtIndex(index2);
};
ImplicitSubtree.prototype.getLevelOffset = function(level) {
  const branchingFactor = this._branchingFactor;
  return (Math.pow(branchingFactor, level) - 1) / (branchingFactor - 1);
};
ImplicitSubtree.prototype.getParentMortonIndex = function(mortonIndex) {
  let bitsPerLevel = 2;
  if (this._subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    bitsPerLevel = 3;
  }
  return mortonIndex >> bitsPerLevel;
};
function initialize7(subtree, json, subtreeView, implicitTileset) {
  let chunks;
  if (defined_default(json)) {
    chunks = {
      json,
      binary: void 0
    };
  } else {
    chunks = parseSubtreeChunks(subtreeView);
  }
  const subtreeJson = chunks.json;
  subtree._subtreeJson = subtreeJson;
  let tilePropertyTableJson;
  if (hasExtension(subtreeJson, "3DTILES_metadata")) {
    tilePropertyTableJson = subtreeJson.extensions["3DTILES_metadata"];
  } else if (defined_default(subtreeJson.tileMetadata)) {
    const propertyTableIndex = subtreeJson.tileMetadata;
    tilePropertyTableJson = subtreeJson.propertyTables[propertyTableIndex];
  }
  const contentPropertyTableJsons = [];
  if (defined_default(subtreeJson.contentMetadata)) {
    const length3 = subtreeJson.contentMetadata.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const propertyTableIndex = subtreeJson.contentMetadata[i2];
      contentPropertyTableJsons.push(
        subtreeJson.propertyTables[propertyTableIndex]
      );
    }
  }
  let metadata;
  const schema = implicitTileset.metadataSchema;
  const subtreeMetadata = subtreeJson.subtreeMetadata;
  if (defined_default(subtreeMetadata)) {
    const metadataClass = subtreeMetadata.class;
    const subtreeMetadataClass = schema.classes[metadataClass];
    metadata = new ImplicitSubtreeMetadata_default({
      subtreeMetadata,
      class: subtreeMetadataClass
    });
  }
  subtree._metadata = metadata;
  subtree._tilePropertyTableJson = tilePropertyTableJson;
  subtree._contentPropertyTableJsons = contentPropertyTableJsons;
  const defaultContentAvailability = {
    constant: 0
  };
  subtreeJson.contentAvailabilityHeaders = [];
  if (hasExtension(subtreeJson, "3DTILES_multiple_contents")) {
    subtreeJson.contentAvailabilityHeaders = subtreeJson.extensions["3DTILES_multiple_contents"].contentAvailability;
  } else if (Array.isArray(subtreeJson.contentAvailability)) {
    subtreeJson.contentAvailabilityHeaders = subtreeJson.contentAvailability;
  } else {
    subtreeJson.contentAvailabilityHeaders.push(
      defaultValue_default(subtreeJson.contentAvailability, defaultContentAvailability)
    );
  }
  const bufferHeaders = preprocessBuffers(subtreeJson.buffers);
  const bufferViewHeaders = preprocessBufferViews(
    subtreeJson.bufferViews,
    bufferHeaders
  );
  markActiveBufferViews(subtreeJson, bufferViewHeaders);
  if (defined_default(tilePropertyTableJson)) {
    markActiveMetadataBufferViews(tilePropertyTableJson, bufferViewHeaders);
  }
  for (let i2 = 0; i2 < contentPropertyTableJsons.length; i2++) {
    const contentPropertyTableJson = contentPropertyTableJsons[i2];
    markActiveMetadataBufferViews(contentPropertyTableJson, bufferViewHeaders);
  }
  requestActiveBuffers(subtree, bufferHeaders, chunks.binary).then(function(buffersU8) {
    const bufferViewsU8 = parseActiveBufferViews(
      bufferViewHeaders,
      buffersU8
    );
    parseAvailability(subtree, subtreeJson, implicitTileset, bufferViewsU8);
    if (defined_default(tilePropertyTableJson)) {
      parseTileMetadataTable(subtree, implicitTileset, bufferViewsU8);
      makeTileJumpBuffer(subtree);
    }
    parseContentMetadataTables(subtree, implicitTileset, bufferViewsU8);
    makeContentJumpBuffers(subtree);
    subtree._readyPromise.resolve(subtree);
  }).catch(function(error) {
    subtree._readyPromise.reject(error);
  });
}
function parseSubtreeChunks(subtreeView) {
  const littleEndian2 = true;
  const subtreeReader = new DataView(
    subtreeView.buffer,
    subtreeView.byteOffset
  );
  let byteOffset = 8;
  const jsonByteLength = subtreeReader.getUint32(byteOffset, littleEndian2);
  byteOffset += 8;
  const binaryByteLength = subtreeReader.getUint32(byteOffset, littleEndian2);
  byteOffset += 8;
  const subtreeJson = getJsonFromTypedArray_default(
    subtreeView,
    byteOffset,
    jsonByteLength
  );
  byteOffset += jsonByteLength;
  const subtreeBinary = subtreeView.subarray(
    byteOffset,
    byteOffset + binaryByteLength
  );
  return {
    json: subtreeJson,
    binary: subtreeBinary
  };
}
function preprocessBuffers(bufferHeaders) {
  bufferHeaders = defined_default(bufferHeaders) ? bufferHeaders : [];
  for (let i2 = 0; i2 < bufferHeaders.length; i2++) {
    const bufferHeader = bufferHeaders[i2];
    bufferHeader.isExternal = defined_default(bufferHeader.uri);
    bufferHeader.isActive = false;
  }
  return bufferHeaders;
}
function preprocessBufferViews(bufferViewHeaders, bufferHeaders) {
  bufferViewHeaders = defined_default(bufferViewHeaders) ? bufferViewHeaders : [];
  for (let i2 = 0; i2 < bufferViewHeaders.length; i2++) {
    const bufferViewHeader = bufferViewHeaders[i2];
    const bufferHeader = bufferHeaders[bufferViewHeader.buffer];
    bufferViewHeader.bufferHeader = bufferHeader;
    bufferViewHeader.isActive = false;
  }
  return bufferViewHeaders;
}
function markActiveBufferViews(subtreeJson, bufferViewHeaders) {
  let header;
  const tileAvailabilityHeader = subtreeJson.tileAvailability;
  if (defined_default(tileAvailabilityHeader.bitstream)) {
    header = bufferViewHeaders[tileAvailabilityHeader.bitstream];
  } else if (defined_default(tileAvailabilityHeader.bufferView)) {
    header = bufferViewHeaders[tileAvailabilityHeader.bufferView];
  }
  if (defined_default(header)) {
    header.isActive = true;
    header.bufferHeader.isActive = true;
  }
  const contentAvailabilityHeaders = subtreeJson.contentAvailabilityHeaders;
  for (let i2 = 0; i2 < contentAvailabilityHeaders.length; i2++) {
    header = void 0;
    if (defined_default(contentAvailabilityHeaders[i2].bitstream)) {
      header = bufferViewHeaders[contentAvailabilityHeaders[i2].bitstream];
    } else if (defined_default(contentAvailabilityHeaders[i2].bufferView)) {
      header = bufferViewHeaders[contentAvailabilityHeaders[i2].bufferView];
    }
    if (defined_default(header)) {
      header.isActive = true;
      header.bufferHeader.isActive = true;
    }
  }
  header = void 0;
  const childSubtreeAvailabilityHeader = subtreeJson.childSubtreeAvailability;
  if (defined_default(childSubtreeAvailabilityHeader.bitstream)) {
    header = bufferViewHeaders[childSubtreeAvailabilityHeader.bitstream];
  } else if (defined_default(childSubtreeAvailabilityHeader.bufferView)) {
    header = bufferViewHeaders[childSubtreeAvailabilityHeader.bufferView];
  }
  if (defined_default(header)) {
    header.isActive = true;
    header.bufferHeader.isActive = true;
  }
}
function markActiveMetadataBufferViews(propertyTableJson, bufferViewHeaders) {
  const properties = propertyTableJson.properties;
  let header;
  for (const key in properties) {
    if (properties.hasOwnProperty(key)) {
      const metadataHeader = properties[key];
      const valuesBufferView = defaultValue_default(
        metadataHeader.values,
        metadataHeader.bufferView
      );
      header = bufferViewHeaders[valuesBufferView];
      header.isActive = true;
      header.bufferHeader.isActive = true;
      const stringOffsetBufferView = defaultValue_default(
        metadataHeader.stringOffsets,
        metadataHeader.stringOffsetBufferView
      );
      if (defined_default(stringOffsetBufferView)) {
        header = bufferViewHeaders[stringOffsetBufferView];
        header.isActive = true;
        header.bufferHeader.isActive = true;
      }
      const arrayOffsetBufferView = defaultValue_default(
        metadataHeader.arrayOffsets,
        metadataHeader.arrayOffsetBufferView
      );
      if (defined_default(arrayOffsetBufferView)) {
        header = bufferViewHeaders[arrayOffsetBufferView];
        header.isActive = true;
        header.bufferHeader.isActive = true;
      }
    }
  }
}
function requestActiveBuffers(subtree, bufferHeaders, internalBuffer) {
  const promises = [];
  for (let i2 = 0; i2 < bufferHeaders.length; i2++) {
    const bufferHeader = bufferHeaders[i2];
    if (!bufferHeader.isActive) {
      promises.push(Promise.resolve(void 0));
    } else if (bufferHeader.isExternal) {
      const promise = requestExternalBuffer(subtree, bufferHeader);
      promises.push(promise);
    } else {
      promises.push(Promise.resolve(internalBuffer));
    }
  }
  return Promise.all(promises).then(function(bufferResults) {
    const buffersU8 = {};
    for (let i2 = 0; i2 < bufferResults.length; i2++) {
      const result = bufferResults[i2];
      if (defined_default(result)) {
        buffersU8[i2] = result;
      }
    }
    return buffersU8;
  });
}
function requestExternalBuffer(subtree, bufferHeader) {
  const baseResource2 = subtree._resource;
  const bufferResource = baseResource2.getDerivedResource({
    url: bufferHeader.uri
  });
  const bufferLoader = ResourceCache_default.loadExternalBuffer({
    resource: bufferResource
  });
  subtree._bufferLoader = bufferLoader;
  return bufferLoader.promise.then(function(bufferLoader2) {
    return bufferLoader2.typedArray;
  });
}
function parseActiveBufferViews(bufferViewHeaders, buffersU8) {
  const bufferViewsU8 = {};
  for (let i2 = 0; i2 < bufferViewHeaders.length; i2++) {
    const bufferViewHeader = bufferViewHeaders[i2];
    if (!bufferViewHeader.isActive) {
      continue;
    }
    const start = bufferViewHeader.byteOffset;
    const end = start + bufferViewHeader.byteLength;
    const buffer = buffersU8[bufferViewHeader.buffer];
    const bufferView = buffer.subarray(start, end);
    bufferViewsU8[i2] = bufferView;
  }
  return bufferViewsU8;
}
function parseAvailability(subtree, subtreeJson, implicitTileset, bufferViewsU8) {
  const branchingFactor = implicitTileset.branchingFactor;
  const subtreeLevels = implicitTileset.subtreeLevels;
  const tileAvailabilityBits = (Math.pow(branchingFactor, subtreeLevels) - 1) / (branchingFactor - 1);
  const childSubtreeBits = Math.pow(branchingFactor, subtreeLevels);
  const hasMetadataExtension = hasExtension(subtreeJson, "3DTILES_metadata");
  const hasTileMetadata = defined_default(subtree._tilePropertyTableJson);
  let computeAvailableCountEnabled = hasMetadataExtension || hasTileMetadata;
  subtree._tileAvailability = parseAvailabilityBitstream(
    subtreeJson.tileAvailability,
    bufferViewsU8,
    tileAvailabilityBits,
    computeAvailableCountEnabled
  );
  const hasContentMetadata = subtree._contentPropertyTableJsons.length > 0;
  computeAvailableCountEnabled = computeAvailableCountEnabled || hasContentMetadata;
  for (let i2 = 0; i2 < subtreeJson.contentAvailabilityHeaders.length; i2++) {
    const bitstream = parseAvailabilityBitstream(
      subtreeJson.contentAvailabilityHeaders[i2],
      bufferViewsU8,
      tileAvailabilityBits,
      computeAvailableCountEnabled
    );
    subtree._contentAvailabilityBitstreams.push(bitstream);
  }
  subtree._childSubtreeAvailability = parseAvailabilityBitstream(
    subtreeJson.childSubtreeAvailability,
    bufferViewsU8,
    childSubtreeBits
  );
}
function parseAvailabilityBitstream(availabilityJson, bufferViewsU8, lengthBits, computeAvailableCountEnabled) {
  if (defined_default(availabilityJson.constant)) {
    return new ImplicitAvailabilityBitstream({
      constant: Boolean(availabilityJson.constant),
      lengthBits,
      availableCount: availabilityJson.availableCount
    });
  }
  let bufferView;
  if (defined_default(availabilityJson.bitstream)) {
    bufferView = bufferViewsU8[availabilityJson.bitstream];
  } else if (defined_default(availabilityJson.bufferView)) {
    bufferView = bufferViewsU8[availabilityJson.bufferView];
  }
  return new ImplicitAvailabilityBitstream({
    bitstream: bufferView,
    lengthBits,
    availableCount: availabilityJson.availableCount,
    computeAvailableCountEnabled
  });
}
function parseTileMetadataTable(subtree, implicitTileset, bufferViewsU8) {
  const tilePropertyTableJson = subtree._tilePropertyTableJson;
  const tileCount = subtree._tileAvailability.availableCount;
  const metadataSchema = implicitTileset.metadataSchema;
  const tileMetadataClassName = tilePropertyTableJson.class;
  const tileMetadataClass = metadataSchema.classes[tileMetadataClassName];
  subtree._tileMetadataTable = new MetadataTable_default({
    class: tileMetadataClass,
    count: tileCount,
    properties: tilePropertyTableJson.properties,
    bufferViews: bufferViewsU8
  });
}
function parseContentMetadataTables(subtree, implicitTileset, bufferViewsU8) {
  const contentPropertyTableJsons = subtree._contentPropertyTableJsons;
  const contentAvailabilityBitstreams = subtree._contentAvailabilityBitstreams;
  const metadataSchema = implicitTileset.metadataSchema;
  const contentMetadataTables = subtree._contentMetadataTables;
  for (let i2 = 0; i2 < contentPropertyTableJsons.length; i2++) {
    const contentPropertyTableJson = contentPropertyTableJsons[i2];
    const contentAvailabilityBitsteam = contentAvailabilityBitstreams[i2];
    const contentCount = contentAvailabilityBitsteam.availableCount;
    const contentMetadataClassName = contentPropertyTableJson.class;
    const contentMetadataClass = metadataSchema.classes[contentMetadataClassName];
    const metadataTable = new MetadataTable_default({
      class: contentMetadataClass,
      count: contentCount,
      properties: contentPropertyTableJson.properties,
      bufferViews: bufferViewsU8
    });
    contentMetadataTables.push(metadataTable);
  }
}
function makeJumpBuffer(availability) {
  let entityId = 0;
  const bufferLength = availability.lengthBits;
  const availableCount = availability.availableCount;
  let jumpBuffer;
  if (availableCount < 256) {
    jumpBuffer = new Uint8Array(bufferLength);
  } else if (availableCount < 65536) {
    jumpBuffer = new Uint16Array(bufferLength);
  } else {
    jumpBuffer = new Uint32Array(bufferLength);
  }
  for (let i2 = 0; i2 < availability.lengthBits; i2++) {
    if (availability.getBit(i2)) {
      jumpBuffer[i2] = entityId;
      entityId++;
    }
  }
  return jumpBuffer;
}
function makeTileJumpBuffer(subtree) {
  const tileJumpBuffer = makeJumpBuffer(subtree._tileAvailability);
  subtree._tileJumpBuffer = tileJumpBuffer;
}
function makeContentJumpBuffers(subtree) {
  const contentJumpBuffers = subtree._contentJumpBuffers;
  const contentAvailabilityBitstreams = subtree._contentAvailabilityBitstreams;
  for (let i2 = 0; i2 < contentAvailabilityBitstreams.length; i2++) {
    const contentAvailability = contentAvailabilityBitstreams[i2];
    const contentJumpBuffer = makeJumpBuffer(contentAvailability);
    contentJumpBuffers.push(contentJumpBuffer);
  }
}
ImplicitSubtree.prototype.getTileIndex = function(implicitCoordinates) {
  const localLevel = implicitCoordinates.level - this._implicitCoordinates.level;
  if (localLevel < 0 || this._subtreeLevels <= localLevel) {
    throw new RuntimeError_default("level is out of bounds for this subtree");
  }
  const subtreeCoordinates = implicitCoordinates.getSubtreeCoordinates();
  const offsetCoordinates = subtreeCoordinates.getOffsetCoordinates(
    implicitCoordinates
  );
  const index2 = offsetCoordinates.tileIndex;
  return index2;
};
ImplicitSubtree.prototype.getChildSubtreeIndex = function(implicitCoordinates) {
  const localLevel = implicitCoordinates.level - this._implicitCoordinates.level;
  if (localLevel !== this._implicitCoordinates.subtreeLevels) {
    throw new RuntimeError_default("level is out of bounds for this subtree");
  }
  const parentSubtreeCoordinates = implicitCoordinates.getParentSubtreeCoordinates();
  const offsetCoordinates = parentSubtreeCoordinates.getOffsetCoordinates(
    implicitCoordinates
  );
  const index2 = offsetCoordinates.mortonIndex;
  return index2;
};
function getTileEntityId(subtree, implicitCoordinates) {
  if (!defined_default(subtree._tileMetadataTable)) {
    return void 0;
  }
  const tileIndex = subtree.getTileIndex(implicitCoordinates);
  if (subtree._tileAvailability.getBit(tileIndex)) {
    return subtree._tileJumpBuffer[tileIndex];
  }
  return void 0;
}
function getContentEntityId(subtree, implicitCoordinates, contentIndex) {
  const metadataTables = subtree._contentMetadataTables;
  if (!defined_default(metadataTables)) {
    return void 0;
  }
  const metadataTable = metadataTables[contentIndex];
  if (!defined_default(metadataTable)) {
    return void 0;
  }
  const availability = subtree._contentAvailabilityBitstreams[contentIndex];
  const tileIndex = subtree.getTileIndex(implicitCoordinates);
  if (availability.getBit(tileIndex)) {
    const contentJumpBuffer = subtree._contentJumpBuffers[contentIndex];
    return contentJumpBuffer[tileIndex];
  }
  return void 0;
}
ImplicitSubtree.prototype.getTileMetadataView = function(implicitCoordinates) {
  const entityId = getTileEntityId(this, implicitCoordinates);
  if (!defined_default(entityId)) {
    return void 0;
  }
  const metadataTable = this._tileMetadataTable;
  return new ImplicitMetadataView({
    class: metadataTable.class,
    metadataTable,
    entityId,
    propertyTableJson: this._tilePropertyTableJson
  });
};
ImplicitSubtree.prototype.getContentMetadataView = function(implicitCoordinates, contentIndex) {
  const entityId = getContentEntityId(this, implicitCoordinates, contentIndex);
  if (!defined_default(entityId)) {
    return void 0;
  }
  const metadataTable = this._contentMetadataTables[contentIndex];
  const propertyTableJson = this._contentPropertyTableJsons[contentIndex];
  return new ImplicitMetadataView({
    class: metadataTable.class,
    metadataTable,
    entityId,
    contentIndex,
    propertyTableJson
  });
};
ImplicitSubtree.prototype.isDestroyed = function() {
  return false;
};
ImplicitSubtree.prototype.destroy = function() {
  if (defined_default(this._bufferLoader)) {
    ResourceCache_default.unload(this._bufferLoader);
  }
  return destroyObject_default(this);
};

// node_modules/cesium/Source/Scene/MetadataSemantic.js
var MetadataSemantic = {
  ID: "ID",
  NAME: "NAME",
  DESCRIPTION: "DESCRIPTION",
  TILE_BOUNDING_BOX: "TILE_BOUNDING_BOX",
  TILE_BOUNDING_REGION: "TILE_BOUNDING_REGION",
  TILE_BOUNDING_SPHERE: "TILE_BOUNDING_SPHERE",
  TILE_MINIMUM_HEIGHT: "TILE_MINIMUM_HEIGHT",
  TILE_MAXIMUM_HEIGHT: "TILE_MAXIMUM_HEIGHT",
  TILE_HORIZON_OCCLUSION_POINT: "TILE_HORIZON_OCCLUSION_POINT",
  TILE_GEOMETRIC_ERROR: "TILE_GEOMETRIC_ERROR",
  CONTENT_BOUNDING_BOX: "CONTENT_BOUNDING_BOX",
  CONTENT_BOUNDING_REGION: "CONTENT_BOUNDING_REGION",
  CONTENT_BOUNDING_SPHERE: "CONTENT_BOUNDING_SPHERE",
  CONTENT_MINIMUM_HEIGHT: "CONTENT_MINIMUM_HEIGHT",
  CONTENT_MAXIMUM_HEIGHT: "CONTENT_MAXIMUM_HEIGHT",
  CONTENT_HORIZON_OCCLUSION_POINT: "CONTENT_HORIZON_OCCLUSION_POINT"
};
var MetadataSemantic_default = Object.freeze(MetadataSemantic);

// node_modules/cesium/Source/Scene/parseBoundingVolumeSemantics.js
function parseBoundingVolumeSemantics(tileMetadata) {
  Check_default.typeOf.object("tileMetadata", tileMetadata);
  return {
    tile: {
      boundingVolume: parseBoundingVolume("TILE", tileMetadata),
      minimumHeight: parseMinimumHeight("TILE", tileMetadata),
      maximumHeight: parseMaximumHeight("TILE", tileMetadata)
    },
    content: {
      boundingVolume: parseBoundingVolume("CONTENT", tileMetadata),
      minimumHeight: parseMinimumHeight("CONTENT", tileMetadata),
      maximumHeight: parseMaximumHeight("CONTENT", tileMetadata)
    }
  };
}
function parseBoundingVolume(prefix, tileMetadata) {
  const boundingBoxSemantic = `${prefix}_BOUNDING_BOX`;
  const boundingBox = tileMetadata.getPropertyBySemantic(boundingBoxSemantic);
  if (defined_default(boundingBox)) {
    return {
      box: boundingBox
    };
  }
  const boundingRegionSemantic = `${prefix}_BOUNDING_REGION`;
  const boundingRegion = tileMetadata.getPropertyBySemantic(
    boundingRegionSemantic
  );
  if (defined_default(boundingRegion)) {
    return {
      region: boundingRegion
    };
  }
  const boundingSphereSemantic = `${prefix}_BOUNDING_SPHERE`;
  const boundingSphere = tileMetadata.getPropertyBySemantic(
    boundingSphereSemantic
  );
  if (defined_default(boundingSphere)) {
    return {
      sphere: boundingSphere
    };
  }
  return void 0;
}
function parseMinimumHeight(prefix, tileMetadata) {
  const minimumHeightSemantic = `${prefix}_MINIMUM_HEIGHT`;
  return tileMetadata.getPropertyBySemantic(minimumHeightSemantic);
}
function parseMaximumHeight(prefix, tileMetadata) {
  const maximumHeightSemantic = `${prefix}_MAXIMUM_HEIGHT`;
  return tileMetadata.getPropertyBySemantic(maximumHeightSemantic);
}

// node_modules/cesium/Source/Scene/Implicit3DTileContent.js
function Implicit3DTileContent(tileset, tile, resource, json, arrayBuffer, byteOffset) {
  Check_default.defined("tile.implicitTileset", tile.implicitTileset);
  Check_default.defined("tile.implicitCoordinates", tile.implicitCoordinates);
  if (defined_default(json) === defined_default(arrayBuffer)) {
    throw new DeveloperError_default("One of json and arrayBuffer must be defined.");
  }
  const implicitTileset = tile.implicitTileset;
  const implicitCoordinates = tile.implicitCoordinates;
  this._implicitTileset = implicitTileset;
  this._implicitCoordinates = implicitCoordinates;
  this._implicitSubtree = void 0;
  this._tileset = tileset;
  this._tile = tile;
  this._resource = resource;
  this._readyPromise = defer_default();
  this._metadata = void 0;
  this.featurePropertiesDirty = false;
  this._group = void 0;
  const templateValues = implicitCoordinates.getTemplateValues();
  const subtreeResource = implicitTileset.subtreeUriTemplate.getDerivedResource(
    {
      templateValues
    }
  );
  this._url = subtreeResource.getUrlComponent(true);
  initialize8(this, json, arrayBuffer, byteOffset);
}
Object.defineProperties(Implicit3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      return 0;
    }
  },
  pointsLength: {
    get: function() {
      return 0;
    }
  },
  trianglesLength: {
    get: function() {
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      return 0;
    }
  },
  texturesByteLength: {
    get: function() {
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      return 0;
    }
  },
  innerContents: {
    get: function() {
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return this._url;
    }
  },
  metadata: {
    get: function() {
      return void 0;
    },
    set: function() {
      throw new DeveloperError_default("Implicit3DTileContent cannot have metadata");
    }
  },
  batchTable: {
    get: function() {
      return void 0;
    }
  },
  group: {
    get: function() {
      return this._group;
    },
    set: function(value) {
      this._group = value;
    }
  }
});
function initialize8(content, json, arrayBuffer, byteOffset) {
  byteOffset = defaultValue_default(byteOffset, 0);
  let uint8Array;
  if (defined_default(arrayBuffer)) {
    uint8Array = new Uint8Array(arrayBuffer, byteOffset);
  }
  const subtree = new ImplicitSubtree(
    content._resource,
    json,
    uint8Array,
    content._implicitTileset,
    content._implicitCoordinates
  );
  content._implicitSubtree = subtree;
  subtree.readyPromise.then(function() {
    expandSubtree(content, subtree);
    content._readyPromise.resolve();
  }).catch(function(error) {
    content._readyPromise.reject(error);
  });
}
function expandSubtree(content, subtree) {
  const placeholderTile = content._tile;
  const childIndex = content._implicitCoordinates.childIndex;
  const results = transcodeSubtreeTiles(
    content,
    subtree,
    placeholderTile,
    childIndex
  );
  placeholderTile.children.push(results.rootTile);
  const childSubtrees = listChildSubtrees(content, subtree, results.bottomRow);
  for (let i2 = 0; i2 < childSubtrees.length; i2++) {
    const subtreeLocator = childSubtrees[i2];
    const leafTile = subtreeLocator.tile;
    const implicitChildTile = makePlaceholderChildSubtree(
      content,
      leafTile,
      subtreeLocator.childIndex
    );
    leafTile.children.push(implicitChildTile);
  }
}
function listChildSubtrees(content, subtree, bottomRow) {
  const results = [];
  const branchingFactor = content._implicitTileset.branchingFactor;
  for (let i2 = 0; i2 < bottomRow.length; i2++) {
    const leafTile = bottomRow[i2];
    if (!defined_default(leafTile)) {
      continue;
    }
    for (let j = 0; j < branchingFactor; j++) {
      const index2 = i2 * branchingFactor + j;
      if (subtree.childSubtreeIsAvailableAtIndex(index2)) {
        results.push({
          tile: leafTile,
          childIndex: j
        });
      }
    }
  }
  return results;
}
function transcodeSubtreeTiles(content, subtree, placeholderTile, childIndex) {
  const rootBitIndex = 0;
  const rootParentIsPlaceholder = true;
  const rootTile = deriveChildTile(
    content,
    subtree,
    placeholderTile,
    childIndex,
    rootBitIndex,
    rootParentIsPlaceholder
  );
  let parentRow = [rootTile];
  let currentRow = [];
  const implicitTileset = content._implicitTileset;
  for (let level = 1; level < implicitTileset.subtreeLevels; level++) {
    const levelOffset = subtree.getLevelOffset(level);
    const numberOfChildren = implicitTileset.branchingFactor * parentRow.length;
    for (let childMortonIndex = 0; childMortonIndex < numberOfChildren; childMortonIndex++) {
      const childBitIndex = levelOffset + childMortonIndex;
      if (!subtree.tileIsAvailableAtIndex(childBitIndex)) {
        currentRow.push(void 0);
        continue;
      }
      const parentMortonIndex = subtree.getParentMortonIndex(childMortonIndex);
      const parentTile = parentRow[parentMortonIndex];
      const childChildIndex = childMortonIndex % implicitTileset.branchingFactor;
      const childTile = deriveChildTile(
        content,
        subtree,
        parentTile,
        childChildIndex,
        childBitIndex
      );
      parentTile.children.push(childTile);
      currentRow.push(childTile);
    }
    parentRow = currentRow;
    currentRow = [];
  }
  return {
    rootTile,
    bottomRow: parentRow
  };
}
function getGeometricError(tileMetadata, implicitTileset, implicitCoordinates) {
  const semantic = MetadataSemantic_default.TILE_GEOMETRIC_ERROR;
  if (defined_default(tileMetadata) && tileMetadata.hasPropertyBySemantic(semantic)) {
    return tileMetadata.getPropertyBySemantic(semantic);
  }
  return implicitTileset.geometricError / Math.pow(2, implicitCoordinates.level);
}
function deriveChildTile(implicitContent, subtree, parentTile, childIndex, childBitIndex, parentIsPlaceholderTile) {
  const implicitTileset = implicitContent._implicitTileset;
  let implicitCoordinates;
  if (defaultValue_default(parentIsPlaceholderTile, false)) {
    implicitCoordinates = parentTile.implicitCoordinates;
  } else {
    implicitCoordinates = parentTile.implicitCoordinates.getChildCoordinates(
      childIndex
    );
  }
  let tileMetadata;
  let tileBounds;
  let contentBounds;
  if (defined_default(subtree.tilePropertyTableJson)) {
    tileMetadata = subtree.getTileMetadataView(implicitCoordinates);
    const boundingVolumeSemantics = parseBoundingVolumeSemantics(tileMetadata);
    tileBounds = boundingVolumeSemantics.tile;
    contentBounds = boundingVolumeSemantics.content;
  }
  const contentPropertyTableJsons = subtree.contentPropertyTableJsons;
  const length3 = contentPropertyTableJsons.length;
  let hasImplicitContentMetadata = false;
  for (let i2 = 0; i2 < length3; i2++) {
    if (subtree.contentIsAvailableAtCoordinates(implicitCoordinates, i2)) {
      hasImplicitContentMetadata = true;
      break;
    }
  }
  const boundingVolume = getTileBoundingVolume(
    implicitTileset,
    implicitCoordinates,
    childIndex,
    parentIsPlaceholderTile,
    parentTile,
    tileBounds
  );
  const contentJsons = [];
  for (let i2 = 0; i2 < implicitTileset.contentCount; i2++) {
    if (!subtree.contentIsAvailableAtIndex(childBitIndex, i2)) {
      continue;
    }
    const childContentTemplate = implicitTileset.contentUriTemplates[i2];
    const childContentUri = childContentTemplate.getDerivedResource({
      templateValues: implicitCoordinates.getTemplateValues()
    }).url;
    const contentJson = {
      uri: childContentUri
    };
    const contentBoundingVolume = getContentBoundingVolume(
      boundingVolume,
      contentBounds
    );
    if (defined_default(contentBoundingVolume)) {
      contentJson.boundingVolume = contentBoundingVolume;
    }
    contentJsons.push(combine_default(contentJson, implicitTileset.contentHeaders[i2]));
  }
  const childGeometricError = getGeometricError(
    tileMetadata,
    implicitTileset,
    implicitCoordinates
  );
  const tileJson = {
    boundingVolume,
    geometricError: childGeometricError,
    refine: implicitTileset.refine,
    contents: contentJsons
  };
  const deep = true;
  const rootHeader = clone_default(implicitTileset.tileHeader, deep);
  delete rootHeader.boundingVolume;
  delete rootHeader.transform;
  const combinedTileJson = combine_default(tileJson, rootHeader, deep);
  const childTile = makeTile(
    implicitContent,
    implicitTileset.baseResource,
    combinedTileJson,
    parentTile
  );
  childTile.implicitCoordinates = implicitCoordinates;
  childTile.implicitSubtree = subtree;
  childTile.metadata = tileMetadata;
  childTile.hasImplicitContentMetadata = hasImplicitContentMetadata;
  return childTile;
}
function canUpdateHeights(boundingVolume, tileBounds) {
  return defined_default(boundingVolume) && defined_default(tileBounds) && (defined_default(tileBounds.minimumHeight) || defined_default(tileBounds.maximumHeight)) && (hasExtension(boundingVolume, "3DTILES_bounding_volume_S2") || defined_default(boundingVolume.region));
}
function updateHeights(boundingVolume, tileBounds) {
  if (!defined_default(tileBounds)) {
    return;
  }
  if (hasExtension(boundingVolume, "3DTILES_bounding_volume_S2")) {
    updateS2CellHeights(
      boundingVolume.extensions["3DTILES_bounding_volume_S2"],
      tileBounds.minimumHeight,
      tileBounds.maximumHeight
    );
  } else if (defined_default(boundingVolume.region)) {
    updateRegionHeights(
      boundingVolume.region,
      tileBounds.minimumHeight,
      tileBounds.maximumHeight
    );
  }
}
function updateRegionHeights(region, minimumHeight, maximumHeight) {
  if (defined_default(minimumHeight)) {
    region[4] = minimumHeight;
  }
  if (defined_default(maximumHeight)) {
    region[5] = maximumHeight;
  }
}
function updateS2CellHeights(s2CellVolume, minimumHeight, maximumHeight) {
  if (defined_default(minimumHeight)) {
    s2CellVolume.minimumHeight = minimumHeight;
  }
  if (defined_default(maximumHeight)) {
    s2CellVolume.maximumHeight = maximumHeight;
  }
}
function getTileBoundingVolume(implicitTileset, implicitCoordinates, childIndex, parentIsPlaceholderTile, parentTile, tileBounds) {
  let boundingVolume;
  if (!defined_default(tileBounds) || !defined_default(tileBounds.boundingVolume) || !canUpdateHeights(tileBounds.boundingVolume, tileBounds) && canUpdateHeights(implicitTileset.boundingVolume, tileBounds)) {
    boundingVolume = deriveBoundingVolume(
      implicitTileset,
      implicitCoordinates,
      childIndex,
      defaultValue_default(parentIsPlaceholderTile, false),
      parentTile
    );
  } else {
    boundingVolume = tileBounds.boundingVolume;
  }
  updateHeights(boundingVolume, tileBounds);
  return boundingVolume;
}
function getContentBoundingVolume(tileBoundingVolume, contentBounds) {
  let contentBoundingVolume;
  if (defined_default(contentBounds)) {
    contentBoundingVolume = contentBounds.boundingVolume;
  }
  if (canUpdateHeights(contentBoundingVolume, contentBounds)) {
    updateHeights(contentBoundingVolume, contentBounds);
  } else if (canUpdateHeights(tileBoundingVolume, contentBounds)) {
    contentBoundingVolume = clone_default(tileBoundingVolume, true);
    updateHeights(contentBoundingVolume, contentBounds);
  }
  return contentBoundingVolume;
}
function deriveBoundingVolume(implicitTileset, implicitCoordinates, childIndex, parentIsPlaceholderTile, parentTile) {
  const rootBoundingVolume = implicitTileset.boundingVolume;
  if (hasExtension(rootBoundingVolume, "3DTILES_bounding_volume_S2")) {
    return deriveBoundingVolumeS2(
      parentIsPlaceholderTile,
      parentTile,
      childIndex,
      implicitCoordinates.level,
      implicitCoordinates.x,
      implicitCoordinates.y,
      implicitCoordinates.z
    );
  }
  if (defined_default(rootBoundingVolume.region)) {
    const childRegion = deriveBoundingRegion(
      rootBoundingVolume.region,
      implicitCoordinates.level,
      implicitCoordinates.x,
      implicitCoordinates.y,
      implicitCoordinates.z
    );
    return {
      region: childRegion
    };
  }
  const childBox = deriveBoundingBox(
    rootBoundingVolume.box,
    implicitCoordinates.level,
    implicitCoordinates.x,
    implicitCoordinates.y,
    implicitCoordinates.z
  );
  return {
    box: childBox
  };
}
function deriveBoundingVolumeS2(parentIsPlaceholderTile, parentTile, childIndex, level, x, y, z) {
  Check_default.typeOf.bool("parentIsPlaceholderTile", parentIsPlaceholderTile);
  Check_default.typeOf.object("parentTile", parentTile);
  Check_default.typeOf.number("childIndex", childIndex);
  Check_default.typeOf.number("level", level);
  Check_default.typeOf.number("x", x);
  Check_default.typeOf.number("y", y);
  if (defined_default(z)) {
    Check_default.typeOf.number("z", z);
  }
  const boundingVolumeS2 = parentTile._boundingVolume;
  if (parentIsPlaceholderTile) {
    return {
      extensions: {
        "3DTILES_bounding_volume_S2": {
          token: S2Cell_default.getTokenFromId(boundingVolumeS2.s2Cell._cellId),
          minimumHeight: boundingVolumeS2.minimumHeight,
          maximumHeight: boundingVolumeS2.maximumHeight
        }
      }
    };
  }
  const face = Number(parentTile._boundingVolume.s2Cell._cellId >> BigInt(61));
  const position = face % 2 === 0 ? HilbertOrder_default.encode2D(level, x, y) : HilbertOrder_default.encode2D(level, y, x);
  const cell = S2Cell_default.fromFacePositionLevel(face, BigInt(position), level);
  let minHeight, maxHeight;
  if (defined_default(z)) {
    const midpointHeight = (boundingVolumeS2.maximumHeight + boundingVolumeS2.minimumHeight) / 2;
    minHeight = childIndex < 4 ? boundingVolumeS2.minimumHeight : midpointHeight;
    maxHeight = childIndex < 4 ? midpointHeight : boundingVolumeS2.maximumHeight;
  } else {
    minHeight = boundingVolumeS2.minimumHeight;
    maxHeight = boundingVolumeS2.maximumHeight;
  }
  return {
    extensions: {
      "3DTILES_bounding_volume_S2": {
        token: S2Cell_default.getTokenFromId(cell._cellId),
        minimumHeight: minHeight,
        maximumHeight: maxHeight
      }
    }
  };
}
var scratchScaleFactors = new Cartesian3_default();
var scratchRootCenter = new Cartesian3_default();
var scratchCenter4 = new Cartesian3_default();
var scratchHalfAxes = new Matrix3_default();
function deriveBoundingBox(rootBox, level, x, y, z) {
  Check_default.typeOf.object("rootBox", rootBox);
  Check_default.typeOf.number("level", level);
  Check_default.typeOf.number("x", x);
  Check_default.typeOf.number("y", y);
  if (defined_default(z)) {
    Check_default.typeOf.number("z", z);
  }
  if (level === 0) {
    return rootBox;
  }
  const rootCenter = Cartesian3_default.unpack(rootBox, 0, scratchRootCenter);
  const rootHalfAxes = Matrix3_default.unpack(rootBox, 3, scratchHalfAxes);
  const tileScale = Math.pow(2, -level);
  const modelSpaceX = -1 + (2 * x + 1) * tileScale;
  const modelSpaceY = -1 + (2 * y + 1) * tileScale;
  let modelSpaceZ = 0;
  const scaleFactors = Cartesian3_default.fromElements(
    tileScale,
    tileScale,
    1,
    scratchScaleFactors
  );
  if (defined_default(z)) {
    modelSpaceZ = -1 + (2 * z + 1) * tileScale;
    scaleFactors.z = tileScale;
  }
  let center = Cartesian3_default.fromElements(
    modelSpaceX,
    modelSpaceY,
    modelSpaceZ,
    scratchCenter4
  );
  center = Matrix3_default.multiplyByVector(rootHalfAxes, center, scratchCenter4);
  center = Cartesian3_default.add(center, rootCenter, scratchCenter4);
  let halfAxes = Matrix3_default.clone(rootHalfAxes);
  halfAxes = Matrix3_default.multiplyByScale(halfAxes, scaleFactors, halfAxes);
  const childBox = new Array(12);
  Cartesian3_default.pack(center, childBox);
  Matrix3_default.pack(halfAxes, childBox, 3);
  return childBox;
}
var scratchRectangle3 = new Rectangle_default();
function deriveBoundingRegion(rootRegion, level, x, y, z) {
  Check_default.typeOf.object("rootRegion", rootRegion);
  Check_default.typeOf.number("level", level);
  Check_default.typeOf.number("x", x);
  Check_default.typeOf.number("y", y);
  if (defined_default(z)) {
    Check_default.typeOf.number("z", z);
  }
  if (level === 0) {
    return rootRegion.slice();
  }
  const rectangle = Rectangle_default.unpack(rootRegion, 0, scratchRectangle3);
  const rootMinimumHeight = rootRegion[4];
  const rootMaximumHeight = rootRegion[5];
  const tileScale = Math.pow(2, -level);
  const childWidth = tileScale * rectangle.width;
  const west = Math_default.negativePiToPi(rectangle.west + x * childWidth);
  const east = Math_default.negativePiToPi(west + childWidth);
  const childHeight = tileScale * rectangle.height;
  const south = Math_default.negativePiToPi(rectangle.south + y * childHeight);
  const north = Math_default.negativePiToPi(south + childHeight);
  let minimumHeight = rootMinimumHeight;
  let maximumHeight = rootMaximumHeight;
  if (defined_default(z)) {
    const childThickness = tileScale * (rootMaximumHeight - rootMinimumHeight);
    minimumHeight += z * childThickness;
    maximumHeight = minimumHeight + childThickness;
  }
  return [west, south, east, north, minimumHeight, maximumHeight];
}
function makePlaceholderChildSubtree(content, parentTile, childIndex) {
  const implicitTileset = content._implicitTileset;
  const implicitCoordinates = parentTile.implicitCoordinates.getChildCoordinates(
    childIndex
  );
  const childBoundingVolume = deriveBoundingVolume(
    implicitTileset,
    implicitCoordinates,
    childIndex,
    false,
    parentTile
  );
  const childGeometricError = getGeometricError(
    void 0,
    implicitTileset,
    implicitCoordinates
  );
  const childContentUri = implicitTileset.subtreeUriTemplate.getDerivedResource(
    {
      templateValues: implicitCoordinates.getTemplateValues()
    }
  ).url;
  const tileJson = {
    boundingVolume: childBoundingVolume,
    geometricError: childGeometricError,
    refine: implicitTileset.refine,
    contents: [
      {
        uri: childContentUri
      }
    ]
  };
  const tile = makeTile(
    content,
    implicitTileset.baseResource,
    tileJson,
    parentTile
  );
  tile.implicitTileset = implicitTileset;
  tile.implicitCoordinates = implicitCoordinates;
  return tile;
}
function makeTile(content, baseResource2, tileJson, parentTile) {
  const Cesium3DTile2 = content._tile.constructor;
  return new Cesium3DTile2(content._tileset, baseResource2, tileJson, parentTile);
}
Implicit3DTileContent.prototype.hasProperty = function(batchId, name) {
  return false;
};
Implicit3DTileContent.prototype.getFeature = function(batchId) {
  return void 0;
};
Implicit3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
};
Implicit3DTileContent.prototype.applyStyle = function(style) {
};
Implicit3DTileContent.prototype.update = function(tileset, frameState) {
};
Implicit3DTileContent.prototype.isDestroyed = function() {
  return false;
};
Implicit3DTileContent.prototype.destroy = function() {
  this._implicitSubtree = this._implicitSubtree && this._implicitSubtree.destroy();
  return destroyObject_default(this);
};
Implicit3DTileContent._deriveBoundingBox = deriveBoundingBox;
Implicit3DTileContent._deriveBoundingRegion = deriveBoundingRegion;
Implicit3DTileContent._deriveBoundingVolumeS2 = deriveBoundingVolumeS2;

// node_modules/cesium/Source/Scene/I3dmParser.js
var I3dmParser = {};
I3dmParser._deprecationWarning = deprecationWarning_default;
var sizeOfUint326 = Uint32Array.BYTES_PER_ELEMENT;
I3dmParser.parse = function(arrayBuffer, byteOffset) {
  Check_default.defined("arrayBuffer", arrayBuffer);
  const byteStart = defaultValue_default(byteOffset, 0);
  byteOffset = byteStart;
  const uint8Array = new Uint8Array(arrayBuffer);
  const view = new DataView(arrayBuffer);
  byteOffset += sizeOfUint326;
  const version = view.getUint32(byteOffset, true);
  if (version !== 1) {
    throw new RuntimeError_default(
      `Only Instanced 3D Model version 1 is supported. Version ${version} is not.`
    );
  }
  byteOffset += sizeOfUint326;
  const byteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint326;
  const featureTableJsonByteLength = view.getUint32(byteOffset, true);
  if (featureTableJsonByteLength === 0) {
    throw new RuntimeError_default(
      "featureTableJsonByteLength is zero, the feature table must be defined."
    );
  }
  byteOffset += sizeOfUint326;
  const featureTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint326;
  const batchTableJsonByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint326;
  const batchTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint326;
  const gltfFormat = view.getUint32(byteOffset, true);
  if (gltfFormat !== 1 && gltfFormat !== 0) {
    throw new RuntimeError_default(
      `Only glTF format 0 (uri) or 1 (embedded) are supported. Format ${gltfFormat} is not.`
    );
  }
  byteOffset += sizeOfUint326;
  const featureTableJson = getJsonFromTypedArray_default(
    uint8Array,
    byteOffset,
    featureTableJsonByteLength
  );
  byteOffset += featureTableJsonByteLength;
  const featureTableBinary = new Uint8Array(
    arrayBuffer,
    byteOffset,
    featureTableBinaryByteLength
  );
  byteOffset += featureTableBinaryByteLength;
  let batchTableJson;
  let batchTableBinary;
  if (batchTableJsonByteLength > 0) {
    batchTableJson = getJsonFromTypedArray_default(
      uint8Array,
      byteOffset,
      batchTableJsonByteLength
    );
    byteOffset += batchTableJsonByteLength;
    if (batchTableBinaryByteLength > 0) {
      batchTableBinary = new Uint8Array(
        arrayBuffer,
        byteOffset,
        batchTableBinaryByteLength
      );
      batchTableBinary = new Uint8Array(batchTableBinary);
      byteOffset += batchTableBinaryByteLength;
    }
  }
  const gltfByteLength = byteStart + byteLength - byteOffset;
  if (gltfByteLength === 0) {
    throw new RuntimeError_default("glTF byte length must be greater than 0.");
  }
  let gltfView;
  if (byteOffset % 4 === 0) {
    gltfView = new Uint8Array(arrayBuffer, byteOffset, gltfByteLength);
  } else {
    I3dmParser._deprecationWarning(
      "i3dm-glb-unaligned",
      "The embedded glb is not aligned to a 4-byte boundary."
    );
    gltfView = new Uint8Array(
      uint8Array.subarray(byteOffset, byteOffset + gltfByteLength)
    );
  }
  return {
    gltfFormat,
    featureTableJson,
    featureTableBinary,
    batchTableJson,
    batchTableBinary,
    gltf: gltfView
  };
};
var I3dmParser_default = I3dmParser;

// node_modules/cesium/Source/Scene/ModelInstance.js
function ModelInstance(collection, modelMatrix, instanceId) {
  this.primitive = collection;
  this._modelMatrix = Matrix4_default.clone(modelMatrix);
  this._instanceId = instanceId;
}
Object.defineProperties(ModelInstance.prototype, {
  instanceId: {
    get: function() {
      return this._instanceId;
    }
  },
  model: {
    get: function() {
      return this.primitive._model;
    }
  },
  modelMatrix: {
    get: function() {
      return Matrix4_default.clone(this._modelMatrix);
    },
    set: function(value) {
      Matrix4_default.clone(value, this._modelMatrix);
      this.primitive.expandBoundingSphere(this._modelMatrix);
      this.primitive._dirty = true;
    }
  }
});
var ModelInstance_default = ModelInstance;

// node_modules/cesium/Source/Scene/ModelInstanceCollection.js
var LoadState = {
  NEEDS_LOAD: 0,
  LOADING: 1,
  LOADED: 2,
  FAILED: 3
};
function ModelInstanceCollection(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.gltf) && !defined_default(options.url)) {
    throw new DeveloperError_default("Either options.gltf or options.url is required.");
  }
  if (defined_default(options.gltf) && defined_default(options.url)) {
    throw new DeveloperError_default(
      "Cannot pass in both options.gltf and options.url."
    );
  }
  this.show = defaultValue_default(options.show, true);
  this._instancingSupported = false;
  this._dynamic = defaultValue_default(options.dynamic, false);
  this._allowPicking = defaultValue_default(options.allowPicking, true);
  this._ready = false;
  this._readyPromise = defer_default();
  this._state = LoadState.NEEDS_LOAD;
  this._dirty = false;
  this._cull = defaultValue_default(options.cull, true);
  this._opaquePass = defaultValue_default(options.opaquePass, Pass_default.OPAQUE);
  this._instances = createInstances(this, options.instances);
  this._batchTable = options.batchTable;
  this._model = void 0;
  this._vertexBufferTypedArray = void 0;
  this._vertexBuffer = void 0;
  this._batchIdBuffer = void 0;
  this._instancedUniformsByProgram = void 0;
  this._drawCommands = [];
  this._modelCommands = void 0;
  this._renderStates = void 0;
  this._disableCullingRenderStates = void 0;
  this._boundingSphere = createBoundingSphere(this);
  this._center = Cartesian3_default.clone(this._boundingSphere.center);
  this._rtcTransform = new Matrix4_default();
  this._rtcModelView = new Matrix4_default();
  this._mode = void 0;
  this.modelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._modelMatrix = Matrix4_default.clone(this.modelMatrix);
  this._url = Resource_default.createIfNeeded(options.url);
  this._requestType = options.requestType;
  this._gltf = options.gltf;
  this._basePath = Resource_default.createIfNeeded(options.basePath);
  this._asynchronous = options.asynchronous;
  this._incrementallyLoadTextures = options.incrementallyLoadTextures;
  this._upAxis = options.upAxis;
  this._forwardAxis = options.forwardAxis;
  this.shadows = defaultValue_default(options.shadows, ShadowMode_default.ENABLED);
  this._shadows = this.shadows;
  this._pickIdLoaded = options.pickIdLoaded;
  this.splitDirection = defaultValue_default(
    options.splitDirection,
    SplitDirection_default.NONE
  );
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this._debugShowBoundingVolume = false;
  this.debugWireframe = defaultValue_default(options.debugWireframe, false);
  this._debugWireframe = false;
  if (defined_default(options.imageBasedLighting)) {
    this._imageBasedLighting = options.imageBasedLighting;
    this._shouldDestroyImageBasedLighting = false;
  } else {
    this._imageBasedLighting = new ImageBasedLighting({
      imageBasedLightingFactor: options.imageBasedLightingFactor,
      luminanceAtZenith: options.luminanceAtZenith,
      sphericalHarmonicCoefficients: options.sphericalHarmonicCoefficients,
      specularEnvironmentMaps: options.specularEnvironmentMaps
    });
    this._shouldDestroyImageBasedLighting = true;
  }
  this.backFaceCulling = defaultValue_default(options.backFaceCulling, true);
  this._backFaceCulling = this.backFaceCulling;
  this.showCreditsOnScreen = defaultValue_default(options.showCreditsOnScreen, false);
}
Object.defineProperties(ModelInstanceCollection.prototype, {
  allowPicking: {
    get: function() {
      return this._allowPicking;
    }
  },
  length: {
    get: function() {
      return this._instances.length;
    }
  },
  activeAnimations: {
    get: function() {
      return this._model.activeAnimations;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  imageBasedLighting: {
    get: function() {
      return this._imageBasedLighting;
    },
    set: function(value) {
      if (value !== this._imageBasedLighting) {
        if (this._shouldDestroyImageBasedLighting && !this._imageBasedLighting.isDestroyed()) {
          this._imageBasedLighting.destroy();
        }
        this._imageBasedLighting = value;
        this._shouldDestroyImageBasedLighting = false;
      }
    }
  },
  imageBasedLightingFactor: {
    get: function() {
      return this._imageBasedLighting.imageBasedLightingFactor;
    },
    set: function(value) {
      this._imageBasedLighting.imageBasedLightingFactor = value;
    }
  },
  luminanceAtZenith: {
    get: function() {
      return this._imageBasedLighting.luminanceAtZenith;
    },
    set: function(value) {
      this._imageBasedLighting.luminanceAtZenith = value;
    }
  },
  sphericalHarmonicCoefficients: {
    get: function() {
      return this._imageBasedLighting.sphericalHarmonicCoefficients;
    },
    set: function(value) {
      this._imageBasedLighting.sphericalHarmonicCoefficients = value;
    }
  },
  specularEnvironmentMaps: {
    get: function() {
      return this._imageBasedLighting.specularEnvironmentMaps;
    },
    set: function(value) {
      this._imageBasedLighting.specularEnvironmentMaps = value;
    }
  }
});
function createInstances(collection, instancesOptions) {
  instancesOptions = defaultValue_default(instancesOptions, []);
  const length3 = instancesOptions.length;
  const instances = new Array(length3);
  for (let i2 = 0; i2 < length3; ++i2) {
    const instanceOptions = instancesOptions[i2];
    const modelMatrix = instanceOptions.modelMatrix;
    const instanceId = defaultValue_default(instanceOptions.batchId, i2);
    instances[i2] = new ModelInstance_default(collection, modelMatrix, instanceId);
  }
  return instances;
}
function createBoundingSphere(collection) {
  const instancesLength = collection.length;
  const points = new Array(instancesLength);
  for (let i2 = 0; i2 < instancesLength; ++i2) {
    points[i2] = Matrix4_default.getTranslation(
      collection._instances[i2]._modelMatrix,
      new Cartesian3_default()
    );
  }
  return BoundingSphere_default.fromPoints(points);
}
var scratchCartesian10 = new Cartesian3_default();
var scratchMatrix2 = new Matrix4_default();
ModelInstanceCollection.prototype.expandBoundingSphere = function(instanceModelMatrix) {
  const translation3 = Matrix4_default.getTranslation(
    instanceModelMatrix,
    scratchCartesian10
  );
  BoundingSphere_default.expand(
    this._boundingSphere,
    translation3,
    this._boundingSphere
  );
};
function getCheckUniformSemanticFunction(modelSemantics, supportedSemantics, programId, uniformMap2) {
  return function(uniform, uniformName) {
    const semantic = uniform.semantic;
    if (defined_default(semantic) && modelSemantics.indexOf(semantic) > -1) {
      if (supportedSemantics.indexOf(semantic) > -1) {
        uniformMap2[uniformName] = semantic;
      } else {
        throw new RuntimeError_default(
          `${'Shader program cannot be optimized for instancing. Uniform "'}${uniformName}" in program "${programId}" uses unsupported semantic "${semantic}"`
        );
      }
    }
  };
}
function getInstancedUniforms(collection, programId) {
  if (defined_default(collection._instancedUniformsByProgram)) {
    return collection._instancedUniformsByProgram[programId];
  }
  const instancedUniformsByProgram = {};
  collection._instancedUniformsByProgram = instancedUniformsByProgram;
  const modelSemantics = [
    "MODEL",
    "MODELVIEW",
    "CESIUM_RTC_MODELVIEW",
    "MODELVIEWPROJECTION",
    "MODELINVERSE",
    "MODELVIEWINVERSE",
    "MODELVIEWPROJECTIONINVERSE",
    "MODELINVERSETRANSPOSE",
    "MODELVIEWINVERSETRANSPOSE"
  ];
  const supportedSemantics = [
    "MODELVIEW",
    "CESIUM_RTC_MODELVIEW",
    "MODELVIEWPROJECTION",
    "MODELVIEWINVERSETRANSPOSE"
  ];
  const techniques = collection._model._sourceTechniques;
  for (const techniqueId in techniques) {
    if (techniques.hasOwnProperty(techniqueId)) {
      const technique = techniques[techniqueId];
      const program = technique.program;
      if (!defined_default(instancedUniformsByProgram[program])) {
        const uniformMap2 = {};
        instancedUniformsByProgram[program] = uniformMap2;
        ForEach_default.techniqueUniform(
          technique,
          getCheckUniformSemanticFunction(
            modelSemantics,
            supportedSemantics,
            programId,
            uniformMap2
          )
        );
      }
    }
  }
  return instancedUniformsByProgram[programId];
}
function getVertexShaderCallback2(collection) {
  return function(vs, programId) {
    const instancedUniforms = getInstancedUniforms(collection, programId);
    const usesBatchTable = defined_default(collection._batchTable);
    let renamedSource = ShaderSource_default.replaceMain(vs, "czm_instancing_main");
    let globalVarsHeader = "";
    let globalVarsMain = "";
    for (const uniform in instancedUniforms) {
      if (instancedUniforms.hasOwnProperty(uniform)) {
        const semantic = instancedUniforms[uniform];
        let varName;
        if (semantic === "MODELVIEW" || semantic === "CESIUM_RTC_MODELVIEW") {
          varName = "czm_instanced_modelView";
        } else if (semantic === "MODELVIEWPROJECTION") {
          varName = "czm_instanced_modelViewProjection";
          globalVarsHeader += "mat4 czm_instanced_modelViewProjection;\n";
          globalVarsMain += "czm_instanced_modelViewProjection = czm_projection * czm_instanced_modelView;\n";
        } else if (semantic === "MODELVIEWINVERSETRANSPOSE") {
          varName = "czm_instanced_modelViewInverseTranspose";
          globalVarsHeader += "mat3 czm_instanced_modelViewInverseTranspose;\n";
          globalVarsMain += "czm_instanced_modelViewInverseTranspose = mat3(czm_instanced_modelView);\n";
        }
        let regex = new RegExp(`uniform.*${uniform}.*`);
        renamedSource = renamedSource.replace(regex, "");
        regex = new RegExp(`${uniform}\\b`, "g");
        renamedSource = renamedSource.replace(regex, varName);
      }
    }
    const uniforms = "uniform mat4 czm_instanced_modifiedModelView;\nuniform mat4 czm_instanced_nodeTransform;\n";
    let batchIdAttribute;
    let pickAttribute;
    let pickVarying;
    if (usesBatchTable) {
      batchIdAttribute = "attribute float a_batchId;\n";
      pickAttribute = "";
      pickVarying = "";
    } else {
      batchIdAttribute = "";
      pickAttribute = "attribute vec4 pickColor;\nvarying vec4 v_pickColor;\n";
      pickVarying = "    v_pickColor = pickColor;\n";
    }
    let instancedSource = `${uniforms + globalVarsHeader}mat4 czm_instanced_modelView;
attribute vec4 czm_modelMatrixRow0;
attribute vec4 czm_modelMatrixRow1;
attribute vec4 czm_modelMatrixRow2;
${batchIdAttribute}${pickAttribute}${renamedSource}void main()
{
    mat4 czm_instanced_model = mat4(czm_modelMatrixRow0.x, czm_modelMatrixRow1.x, czm_modelMatrixRow2.x, 0.0, czm_modelMatrixRow0.y, czm_modelMatrixRow1.y, czm_modelMatrixRow2.y, 0.0, czm_modelMatrixRow0.z, czm_modelMatrixRow1.z, czm_modelMatrixRow2.z, 0.0, czm_modelMatrixRow0.w, czm_modelMatrixRow1.w, czm_modelMatrixRow2.w, 1.0);
    czm_instanced_modelView = czm_instanced_modifiedModelView * czm_instanced_model * czm_instanced_nodeTransform;
${globalVarsMain}    czm_instancing_main();
${pickVarying}}
`;
    if (usesBatchTable) {
      const gltf = collection._model.gltf;
      const diffuseAttributeOrUniformName = ModelUtility_default.getDiffuseAttributeOrUniform(
        gltf,
        programId
      );
      instancedSource = collection._batchTable.getVertexShaderCallback(
        true,
        "a_batchId",
        diffuseAttributeOrUniformName
      )(instancedSource);
    }
    return instancedSource;
  };
}
function getFragmentShaderCallback2(collection) {
  return function(fs, programId) {
    const batchTable = collection._batchTable;
    if (defined_default(batchTable)) {
      const gltf = collection._model.gltf;
      const diffuseAttributeOrUniformName = ModelUtility_default.getDiffuseAttributeOrUniform(
        gltf,
        programId
      );
      fs = batchTable.getFragmentShaderCallback(
        true,
        diffuseAttributeOrUniformName,
        false
      )(fs);
    } else {
      fs = `varying vec4 v_pickColor;
${fs}`;
    }
    return fs;
  };
}
function createModifiedModelView(collection, context) {
  return function() {
    return Matrix4_default.multiply(
      context.uniformState.view,
      collection._rtcTransform,
      collection._rtcModelView
    );
  };
}
function createNodeTransformFunction(node) {
  return function() {
    return node.computedMatrix;
  };
}
function getUniformMapCallback(collection, context) {
  return function(uniformMap2, programId, node) {
    uniformMap2 = clone_default(uniformMap2);
    uniformMap2.czm_instanced_modifiedModelView = createModifiedModelView(
      collection,
      context
    );
    uniformMap2.czm_instanced_nodeTransform = createNodeTransformFunction(node);
    const instancedUniforms = getInstancedUniforms(collection, programId);
    for (const uniform in instancedUniforms) {
      if (instancedUniforms.hasOwnProperty(uniform)) {
        delete uniformMap2[uniform];
      }
    }
    if (defined_default(collection._batchTable)) {
      uniformMap2 = collection._batchTable.getUniformMapCallback()(uniformMap2);
    }
    return uniformMap2;
  };
}
function getVertexShaderNonInstancedCallback(collection) {
  return function(vs, programId) {
    if (defined_default(collection._batchTable)) {
      const gltf = collection._model.gltf;
      const diffuseAttributeOrUniformName = ModelUtility_default.getDiffuseAttributeOrUniform(
        gltf,
        programId
      );
      vs = collection._batchTable.getVertexShaderCallback(
        true,
        "a_batchId",
        diffuseAttributeOrUniformName
      )(vs);
      vs = `uniform float a_batchId
;${vs}`;
    }
    return vs;
  };
}
function getFragmentShaderNonInstancedCallback(collection) {
  return function(fs, programId) {
    const batchTable = collection._batchTable;
    if (defined_default(batchTable)) {
      const gltf = collection._model.gltf;
      const diffuseAttributeOrUniformName = ModelUtility_default.getDiffuseAttributeOrUniform(
        gltf,
        programId
      );
      fs = batchTable.getFragmentShaderCallback(
        true,
        diffuseAttributeOrUniformName,
        false
      )(fs);
    } else {
      fs = `uniform vec4 czm_pickColor;
${fs}`;
    }
    return fs;
  };
}
function getUniformMapNonInstancedCallback(collection) {
  return function(uniformMap2) {
    if (defined_default(collection._batchTable)) {
      uniformMap2 = collection._batchTable.getUniformMapCallback()(uniformMap2);
    }
    return uniformMap2;
  };
}
function getVertexBufferTypedArray(collection) {
  const instances = collection._instances;
  const instancesLength = collection.length;
  const collectionCenter = collection._center;
  const vertexSizeInFloats = 12;
  let bufferData = collection._vertexBufferTypedArray;
  if (!defined_default(bufferData)) {
    bufferData = new Float32Array(instancesLength * vertexSizeInFloats);
  }
  if (collection._dynamic) {
    collection._vertexBufferTypedArray = bufferData;
  }
  for (let i2 = 0; i2 < instancesLength; ++i2) {
    const modelMatrix = instances[i2]._modelMatrix;
    const instanceMatrix = Matrix4_default.clone(modelMatrix, scratchMatrix2);
    instanceMatrix[12] -= collectionCenter.x;
    instanceMatrix[13] -= collectionCenter.y;
    instanceMatrix[14] -= collectionCenter.z;
    const offset2 = i2 * vertexSizeInFloats;
    bufferData[offset2 + 0] = instanceMatrix[0];
    bufferData[offset2 + 1] = instanceMatrix[4];
    bufferData[offset2 + 2] = instanceMatrix[8];
    bufferData[offset2 + 3] = instanceMatrix[12];
    bufferData[offset2 + 4] = instanceMatrix[1];
    bufferData[offset2 + 5] = instanceMatrix[5];
    bufferData[offset2 + 6] = instanceMatrix[9];
    bufferData[offset2 + 7] = instanceMatrix[13];
    bufferData[offset2 + 8] = instanceMatrix[2];
    bufferData[offset2 + 9] = instanceMatrix[6];
    bufferData[offset2 + 10] = instanceMatrix[10];
    bufferData[offset2 + 11] = instanceMatrix[14];
  }
  return bufferData;
}
function createVertexBuffer4(collection, context) {
  let i2;
  const instances = collection._instances;
  const instancesLength = collection.length;
  const dynamic = collection._dynamic;
  const usesBatchTable = defined_default(collection._batchTable);
  if (usesBatchTable) {
    const batchIdBufferData = new Uint16Array(instancesLength);
    for (i2 = 0; i2 < instancesLength; ++i2) {
      batchIdBufferData[i2] = instances[i2]._instanceId;
    }
    collection._batchIdBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: batchIdBufferData,
      usage: BufferUsage_default.STATIC_DRAW
    });
  }
  if (!usesBatchTable) {
    const pickIdBuffer = new Uint8Array(instancesLength * 4);
    for (i2 = 0; i2 < instancesLength; ++i2) {
      const pickId = collection._pickIds[i2];
      const pickColor = pickId.color;
      const offset2 = i2 * 4;
      pickIdBuffer[offset2] = Color_default.floatToByte(pickColor.red);
      pickIdBuffer[offset2 + 1] = Color_default.floatToByte(pickColor.green);
      pickIdBuffer[offset2 + 2] = Color_default.floatToByte(pickColor.blue);
      pickIdBuffer[offset2 + 3] = Color_default.floatToByte(pickColor.alpha);
    }
    collection._pickIdBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: pickIdBuffer,
      usage: BufferUsage_default.STATIC_DRAW
    });
  }
  const vertexBufferTypedArray = getVertexBufferTypedArray(collection);
  collection._vertexBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: vertexBufferTypedArray,
    usage: dynamic ? BufferUsage_default.STREAM_DRAW : BufferUsage_default.STATIC_DRAW
  });
}
function updateVertexBuffer(collection) {
  const vertexBufferTypedArray = getVertexBufferTypedArray(collection);
  collection._vertexBuffer.copyFromArrayView(vertexBufferTypedArray);
}
function createPickIds(collection, context) {
  const instances = collection._instances;
  const instancesLength = instances.length;
  const pickIds = new Array(instancesLength);
  for (let i2 = 0; i2 < instancesLength; ++i2) {
    pickIds[i2] = context.createPickId(instances[i2]);
  }
  return pickIds;
}
function createModel(collection, context) {
  const instancingSupported = collection._instancingSupported;
  const usesBatchTable = defined_default(collection._batchTable);
  const allowPicking = collection._allowPicking;
  const modelOptions = {
    url: collection._url,
    requestType: collection._requestType,
    gltf: collection._gltf,
    basePath: collection._basePath,
    shadows: collection._shadows,
    cacheKey: void 0,
    asynchronous: collection._asynchronous,
    allowPicking,
    incrementallyLoadTextures: collection._incrementallyLoadTextures,
    upAxis: collection._upAxis,
    forwardAxis: collection._forwardAxis,
    precreatedAttributes: void 0,
    vertexShaderLoaded: void 0,
    fragmentShaderLoaded: void 0,
    uniformMapLoaded: void 0,
    pickIdLoaded: collection._pickIdLoaded,
    ignoreCommands: true,
    opaquePass: collection._opaquePass,
    imageBasedLighting: collection._imageBasedLighting,
    showOutline: collection.showOutline,
    showCreditsOnScreen: collection.showCreditsOnScreen
  };
  if (!usesBatchTable) {
    collection._pickIds = createPickIds(collection, context);
  }
  if (instancingSupported) {
    createVertexBuffer4(collection, context);
    const vertexSizeInFloats = 12;
    const componentSizeInBytes = ComponentDatatype_default.getSizeInBytes(
      ComponentDatatype_default.FLOAT
    );
    const instancedAttributes = {
      czm_modelMatrixRow0: {
        index: 0,
        vertexBuffer: collection._vertexBuffer,
        componentsPerAttribute: 4,
        componentDatatype: ComponentDatatype_default.FLOAT,
        normalize: false,
        offsetInBytes: 0,
        strideInBytes: componentSizeInBytes * vertexSizeInFloats,
        instanceDivisor: 1
      },
      czm_modelMatrixRow1: {
        index: 0,
        vertexBuffer: collection._vertexBuffer,
        componentsPerAttribute: 4,
        componentDatatype: ComponentDatatype_default.FLOAT,
        normalize: false,
        offsetInBytes: componentSizeInBytes * 4,
        strideInBytes: componentSizeInBytes * vertexSizeInFloats,
        instanceDivisor: 1
      },
      czm_modelMatrixRow2: {
        index: 0,
        vertexBuffer: collection._vertexBuffer,
        componentsPerAttribute: 4,
        componentDatatype: ComponentDatatype_default.FLOAT,
        normalize: false,
        offsetInBytes: componentSizeInBytes * 8,
        strideInBytes: componentSizeInBytes * vertexSizeInFloats,
        instanceDivisor: 1
      }
    };
    if (usesBatchTable) {
      instancedAttributes.a_batchId = {
        index: 0,
        vertexBuffer: collection._batchIdBuffer,
        componentsPerAttribute: 1,
        componentDatatype: ComponentDatatype_default.UNSIGNED_SHORT,
        normalize: false,
        offsetInBytes: 0,
        strideInBytes: 0,
        instanceDivisor: 1
      };
    }
    if (!usesBatchTable) {
      instancedAttributes.pickColor = {
        index: 0,
        vertexBuffer: collection._pickIdBuffer,
        componentsPerAttribute: 4,
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
        normalize: true,
        offsetInBytes: 0,
        strideInBytes: 0,
        instanceDivisor: 1
      };
    }
    modelOptions.precreatedAttributes = instancedAttributes;
    modelOptions.vertexShaderLoaded = getVertexShaderCallback2(collection);
    modelOptions.fragmentShaderLoaded = getFragmentShaderCallback2(collection);
    modelOptions.uniformMapLoaded = getUniformMapCallback(collection, context);
    if (defined_default(collection._url)) {
      modelOptions.cacheKey = `${collection._url.getUrlComponent()}#instanced`;
    }
  } else {
    modelOptions.vertexShaderLoaded = getVertexShaderNonInstancedCallback(
      collection
    );
    modelOptions.fragmentShaderLoaded = getFragmentShaderNonInstancedCallback(
      collection
    );
    modelOptions.uniformMapLoaded = getUniformMapNonInstancedCallback(
      collection,
      context
    );
  }
  if (defined_default(collection._url)) {
    collection._model = Model_default.fromGltf(modelOptions);
  } else {
    collection._model = new Model_default(modelOptions);
  }
}
function updateWireframe3(collection, force) {
  if (collection._debugWireframe !== collection.debugWireframe || force) {
    collection._debugWireframe = collection.debugWireframe;
    const primitiveType = collection.debugWireframe ? PrimitiveType_default.LINES : PrimitiveType_default.TRIANGLES;
    const commands = collection._drawCommands;
    const length3 = commands.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      commands[i2].primitiveType = primitiveType;
    }
  }
}
function getDisableCullingRenderState2(renderState) {
  const rs = clone_default(renderState, true);
  rs.cull.enabled = false;
  return RenderState_default.fromCache(rs);
}
function updateBackFaceCulling2(collection, force) {
  if (collection._backFaceCulling !== collection.backFaceCulling || force) {
    collection._backFaceCulling = collection.backFaceCulling;
    const commands = collection._drawCommands;
    const length3 = commands.length;
    let i2;
    if (!defined_default(collection._disableCullingRenderStates)) {
      collection._disableCullingRenderStates = new Array(length3);
      collection._renderStates = new Array(length3);
      for (i2 = 0; i2 < length3; ++i2) {
        const renderState = commands[i2].renderState;
        const derivedRenderState = getDisableCullingRenderState2(renderState);
        collection._disableCullingRenderStates[i2] = derivedRenderState;
        collection._renderStates[i2] = renderState;
      }
    }
    for (i2 = 0; i2 < length3; ++i2) {
      commands[i2].renderState = collection._backFaceCulling ? collection._renderStates[i2] : collection._disableCullingRenderStates[i2];
    }
  }
}
function updateShowBoundingVolume2(collection, force) {
  if (collection.debugShowBoundingVolume !== collection._debugShowBoundingVolume || force) {
    collection._debugShowBoundingVolume = collection.debugShowBoundingVolume;
    const commands = collection._drawCommands;
    const length3 = commands.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      commands[i2].debugShowBoundingVolume = collection.debugShowBoundingVolume;
    }
  }
}
function createCommands4(collection, drawCommands) {
  const commandsLength = drawCommands.length;
  const instancesLength = collection.length;
  const boundingSphere = collection._boundingSphere;
  const cull = collection._cull;
  for (let i2 = 0; i2 < commandsLength; ++i2) {
    const drawCommand = DrawCommand_default.shallowClone(drawCommands[i2]);
    drawCommand.instanceCount = instancesLength;
    drawCommand.boundingVolume = boundingSphere;
    drawCommand.cull = cull;
    if (defined_default(collection._batchTable)) {
      drawCommand.pickId = collection._batchTable.getPickId();
    } else {
      drawCommand.pickId = "v_pickColor";
    }
    collection._drawCommands.push(drawCommand);
  }
}
function createBatchIdFunction(batchId) {
  return function() {
    return batchId;
  };
}
function createPickColorFunction2(color) {
  return function() {
    return color;
  };
}
function createCommandsNonInstanced(collection, drawCommands) {
  const instances = collection._instances;
  const commandsLength = drawCommands.length;
  const instancesLength = collection.length;
  const batchTable = collection._batchTable;
  const usesBatchTable = defined_default(batchTable);
  const cull = collection._cull;
  for (let i2 = 0; i2 < commandsLength; ++i2) {
    for (let j = 0; j < instancesLength; ++j) {
      const drawCommand = DrawCommand_default.shallowClone(drawCommands[i2]);
      drawCommand.modelMatrix = new Matrix4_default();
      drawCommand.boundingVolume = new BoundingSphere_default();
      drawCommand.cull = cull;
      drawCommand.uniformMap = clone_default(drawCommand.uniformMap);
      if (usesBatchTable) {
        drawCommand.uniformMap.a_batchId = createBatchIdFunction(
          instances[j]._instanceId
        );
      } else {
        const pickId = collection._pickIds[j];
        drawCommand.uniformMap.czm_pickColor = createPickColorFunction2(
          pickId.color
        );
      }
      collection._drawCommands.push(drawCommand);
    }
  }
}
function updateCommandsNonInstanced(collection) {
  const modelCommands = collection._modelCommands;
  const commandsLength = modelCommands.length;
  const instancesLength = collection.length;
  const collectionTransform = collection._rtcTransform;
  const collectionCenter = collection._center;
  for (let i2 = 0; i2 < commandsLength; ++i2) {
    const modelCommand = modelCommands[i2];
    for (let j = 0; j < instancesLength; ++j) {
      const commandIndex = i2 * instancesLength + j;
      const drawCommand = collection._drawCommands[commandIndex];
      let instanceMatrix = Matrix4_default.clone(
        collection._instances[j]._modelMatrix,
        scratchMatrix2
      );
      instanceMatrix[12] -= collectionCenter.x;
      instanceMatrix[13] -= collectionCenter.y;
      instanceMatrix[14] -= collectionCenter.z;
      instanceMatrix = Matrix4_default.multiply(
        collectionTransform,
        instanceMatrix,
        scratchMatrix2
      );
      const nodeMatrix = modelCommand.modelMatrix;
      const modelMatrix = drawCommand.modelMatrix;
      Matrix4_default.multiply(instanceMatrix, nodeMatrix, modelMatrix);
      const nodeBoundingSphere = modelCommand.boundingVolume;
      const boundingSphere = drawCommand.boundingVolume;
      BoundingSphere_default.transform(
        nodeBoundingSphere,
        instanceMatrix,
        boundingSphere
      );
    }
  }
}
function getModelCommands(model) {
  const nodeCommands = model._nodeCommands;
  const length3 = nodeCommands.length;
  const drawCommands = [];
  for (let i2 = 0; i2 < length3; ++i2) {
    const nc = nodeCommands[i2];
    if (nc.show) {
      drawCommands.push(nc.command);
    }
  }
  return drawCommands;
}
function commandsDirty(model) {
  const nodeCommands = model._nodeCommands;
  const length3 = nodeCommands.length;
  let commandsDirty2 = false;
  for (let i2 = 0; i2 < length3; i2++) {
    const nc = nodeCommands[i2];
    if (nc.command.dirty) {
      nc.command.dirty = false;
      commandsDirty2 = true;
    }
  }
  return commandsDirty2;
}
function generateModelCommands(modelInstanceCollection, instancingSupported) {
  modelInstanceCollection._drawCommands = [];
  const modelCommands = getModelCommands(modelInstanceCollection._model);
  if (instancingSupported) {
    createCommands4(modelInstanceCollection, modelCommands);
  } else {
    createCommandsNonInstanced(modelInstanceCollection, modelCommands);
    updateCommandsNonInstanced(modelInstanceCollection);
  }
}
function updateShadows2(collection, force) {
  if (collection.shadows !== collection._shadows || force) {
    collection._shadows = collection.shadows;
    const castShadows = ShadowMode_default.castShadows(collection.shadows);
    const receiveShadows = ShadowMode_default.receiveShadows(collection.shadows);
    const drawCommands = collection._drawCommands;
    const length3 = drawCommands.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      const drawCommand = drawCommands[i2];
      drawCommand.castShadows = castShadows;
      drawCommand.receiveShadows = receiveShadows;
    }
  }
}
ModelInstanceCollection.prototype.update = function(frameState) {
  if (frameState.mode === SceneMode_default.MORPHING) {
    return;
  }
  if (!this.show) {
    return;
  }
  if (this.length === 0) {
    return;
  }
  const context = frameState.context;
  if (this._state === LoadState.NEEDS_LOAD) {
    this._state = LoadState.LOADING;
    this._instancingSupported = context.instancedArrays;
    createModel(this, context);
    const that = this;
    this._model.readyPromise.catch(function(error) {
      that._state = LoadState.FAILED;
      that._readyPromise.reject(error);
    });
  }
  const instancingSupported = this._instancingSupported;
  const model = this._model;
  model.imageBasedLighting = this._imageBasedLighting;
  model.showCreditsOnScreen = this.showCreditsOnScreen;
  model.splitDirection = this.splitDirection;
  model.update(frameState);
  if (model.ready && this._state === LoadState.LOADING) {
    this._state = LoadState.LOADED;
    this._ready = true;
    const modelRadius = model.boundingSphere.radius + Cartesian3_default.magnitude(model.boundingSphere.center);
    this._boundingSphere.radius += modelRadius;
    this._modelCommands = getModelCommands(model);
    generateModelCommands(this, instancingSupported);
    this._readyPromise.resolve(this);
    return;
  }
  if (this._state !== LoadState.LOADED) {
    return;
  }
  const modeChanged = frameState.mode !== this._mode;
  const modelMatrix = this.modelMatrix;
  const modelMatrixChanged = !Matrix4_default.equals(this._modelMatrix, modelMatrix);
  if (modeChanged || modelMatrixChanged) {
    this._mode = frameState.mode;
    Matrix4_default.clone(modelMatrix, this._modelMatrix);
    let rtcTransform = Matrix4_default.multiplyByTranslation(
      this._modelMatrix,
      this._center,
      this._rtcTransform
    );
    if (this._mode !== SceneMode_default.SCENE3D) {
      rtcTransform = Transforms_default.basisTo2D(
        frameState.mapProjection,
        rtcTransform,
        rtcTransform
      );
    }
    Matrix4_default.getTranslation(rtcTransform, this._boundingSphere.center);
  }
  if (instancingSupported && this._dirty) {
    this._dynamic = true;
    this._dirty = false;
    updateVertexBuffer(this);
  }
  const modelCommandsDirty = commandsDirty(model);
  if (modelCommandsDirty) {
    generateModelCommands(this, instancingSupported);
  }
  if (!instancingSupported && (model.dirty || this._dirty || modeChanged || modelMatrixChanged)) {
    updateCommandsNonInstanced(this);
  }
  updateShadows2(this, modelCommandsDirty);
  updateWireframe3(this, modelCommandsDirty);
  updateBackFaceCulling2(this, modelCommandsDirty);
  updateShowBoundingVolume2(this, modelCommandsDirty);
  const passes = frameState.passes;
  if (!passes.render && !passes.pick) {
    return;
  }
  const commandList = frameState.commandList;
  const commands = this._drawCommands;
  const commandsLength = commands.length;
  for (let i2 = 0; i2 < commandsLength; ++i2) {
    commandList.push(commands[i2]);
  }
};
ModelInstanceCollection.prototype.isDestroyed = function() {
  return false;
};
ModelInstanceCollection.prototype.destroy = function() {
  this._model = this._model && this._model.destroy();
  const pickIds = this._pickIds;
  if (defined_default(pickIds)) {
    const length3 = pickIds.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      pickIds[i2].destroy();
    }
  }
  if (this._shouldDestroyImageBasedLighting && !this._imageBasedLighting.isDestroyed()) {
    this._imageBasedLighting.destroy();
  }
  this._imageBasedLighting = void 0;
  return destroyObject_default(this);
};
var ModelInstanceCollection_default = ModelInstanceCollection;

// node_modules/cesium/Source/Scene/Instanced3DModel3DTileContent.js
function Instanced3DModel3DTileContent(tileset, tile, resource, arrayBuffer, byteOffset) {
  this._tileset = tileset;
  this._tile = tile;
  this._resource = resource;
  this._modelInstanceCollection = void 0;
  this._metadata = void 0;
  this._batchTable = void 0;
  this._features = void 0;
  this.featurePropertiesDirty = false;
  this._group = void 0;
  initialize9(this, arrayBuffer, byteOffset);
}
Instanced3DModel3DTileContent._deprecationWarning = deprecationWarning_default;
Object.defineProperties(Instanced3DModel3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      return this._batchTable.featuresLength;
    }
  },
  pointsLength: {
    get: function() {
      return 0;
    }
  },
  trianglesLength: {
    get: function() {
      const model = this._modelInstanceCollection._model;
      if (defined_default(model)) {
        return model.trianglesLength;
      }
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      const model = this._modelInstanceCollection._model;
      if (defined_default(model)) {
        return model.geometryByteLength;
      }
      return 0;
    }
  },
  texturesByteLength: {
    get: function() {
      const model = this._modelInstanceCollection._model;
      if (defined_default(model)) {
        return model.texturesByteLength;
      }
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      return this._batchTable.memorySizeInBytes;
    }
  },
  innerContents: {
    get: function() {
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._modelInstanceCollection.readyPromise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return this._resource.getUrlComponent(true);
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    },
    set: function(value) {
      this._metadata = value;
    }
  },
  batchTable: {
    get: function() {
      return this._batchTable;
    }
  },
  group: {
    get: function() {
      return this._group;
    },
    set: function(value) {
      this._group = value;
    }
  }
});
function getPickIdCallback2(content) {
  return function() {
    return content._batchTable.getPickId();
  };
}
var propertyScratch1 = new Array(4);
var propertyScratch2 = new Array(4);
function initialize9(content, arrayBuffer, byteOffset) {
  const i3dm = I3dmParser_default.parse(arrayBuffer, byteOffset);
  const gltfFormat = i3dm.gltfFormat;
  const gltfView = i3dm.gltf;
  const featureTableJson = i3dm.featureTableJson;
  const featureTableBinary = i3dm.featureTableBinary;
  const batchTableJson = i3dm.batchTableJson;
  const batchTableBinary = i3dm.batchTableBinary;
  const featureTable = new Cesium3DTileFeatureTable_default(
    featureTableJson,
    featureTableBinary
  );
  const instancesLength = featureTable.getGlobalProperty("INSTANCES_LENGTH");
  featureTable.featuresLength = instancesLength;
  if (!defined_default(instancesLength)) {
    throw new RuntimeError_default(
      "Feature table global property: INSTANCES_LENGTH must be defined"
    );
  }
  content._batchTable = new Cesium3DTileBatchTable_default(
    content,
    instancesLength,
    batchTableJson,
    batchTableBinary
  );
  const tileset = content._tileset;
  const collectionOptions = {
    instances: new Array(instancesLength),
    batchTable: content._batchTable,
    cull: false,
    url: void 0,
    requestType: RequestType_default.TILES3D,
    gltf: void 0,
    basePath: void 0,
    incrementallyLoadTextures: false,
    upAxis: tileset._gltfUpAxis,
    forwardAxis: Axis_default.X,
    opaquePass: Pass_default.CESIUM_3D_TILE,
    pickIdLoaded: getPickIdCallback2(content),
    imageBasedLighting: tileset.imageBasedLighting,
    specularEnvironmentMaps: tileset.specularEnvironmentMaps,
    backFaceCulling: tileset.backFaceCulling,
    showOutline: tileset.showOutline,
    showCreditsOnScreen: tileset.showCreditsOnScreen
  };
  if (gltfFormat === 0) {
    let gltfUrl = getStringFromTypedArray_default(gltfView);
    gltfUrl = gltfUrl.replace(/[\s\0]+$/, "");
    collectionOptions.url = content._resource.getDerivedResource({
      url: gltfUrl
    });
  } else {
    collectionOptions.gltf = gltfView;
    collectionOptions.basePath = content._resource.clone();
  }
  const eastNorthUp = featureTable.getGlobalProperty("EAST_NORTH_UP");
  let rtcCenter;
  const rtcCenterArray = featureTable.getGlobalProperty(
    "RTC_CENTER",
    ComponentDatatype_default.FLOAT,
    3
  );
  if (defined_default(rtcCenterArray)) {
    rtcCenter = Cartesian3_default.unpack(rtcCenterArray);
  }
  const instances = collectionOptions.instances;
  const instancePosition = new Cartesian3_default();
  const instancePositionArray = new Array(3);
  const instanceNormalRight = new Cartesian3_default();
  const instanceNormalUp = new Cartesian3_default();
  const instanceNormalForward = new Cartesian3_default();
  const instanceRotation = new Matrix3_default();
  const instanceQuaternion = new Quaternion_default();
  let instanceScale = new Cartesian3_default();
  const instanceTranslationRotationScale = new TranslationRotationScale_default();
  const instanceTransform = new Matrix4_default();
  for (let i2 = 0; i2 < instancesLength; i2++) {
    let position = featureTable.getProperty(
      "POSITION",
      ComponentDatatype_default.FLOAT,
      3,
      i2,
      propertyScratch1
    );
    if (!defined_default(position)) {
      position = instancePositionArray;
      const positionQuantized = featureTable.getProperty(
        "POSITION_QUANTIZED",
        ComponentDatatype_default.UNSIGNED_SHORT,
        3,
        i2,
        propertyScratch1
      );
      if (!defined_default(positionQuantized)) {
        throw new RuntimeError_default(
          "Either POSITION or POSITION_QUANTIZED must be defined for each instance."
        );
      }
      const quantizedVolumeOffset = featureTable.getGlobalProperty(
        "QUANTIZED_VOLUME_OFFSET",
        ComponentDatatype_default.FLOAT,
        3
      );
      if (!defined_default(quantizedVolumeOffset)) {
        throw new RuntimeError_default(
          "Global property: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions."
        );
      }
      const quantizedVolumeScale = featureTable.getGlobalProperty(
        "QUANTIZED_VOLUME_SCALE",
        ComponentDatatype_default.FLOAT,
        3
      );
      if (!defined_default(quantizedVolumeScale)) {
        throw new RuntimeError_default(
          "Global property: QUANTIZED_VOLUME_SCALE must be defined for quantized positions."
        );
      }
      for (let j = 0; j < 3; j++) {
        position[j] = positionQuantized[j] / 65535 * quantizedVolumeScale[j] + quantizedVolumeOffset[j];
      }
    }
    Cartesian3_default.unpack(position, 0, instancePosition);
    if (defined_default(rtcCenter)) {
      Cartesian3_default.add(instancePosition, rtcCenter, instancePosition);
    }
    instanceTranslationRotationScale.translation = instancePosition;
    const normalUp = featureTable.getProperty(
      "NORMAL_UP",
      ComponentDatatype_default.FLOAT,
      3,
      i2,
      propertyScratch1
    );
    const normalRight = featureTable.getProperty(
      "NORMAL_RIGHT",
      ComponentDatatype_default.FLOAT,
      3,
      i2,
      propertyScratch2
    );
    let hasCustomOrientation = false;
    if (defined_default(normalUp)) {
      if (!defined_default(normalRight)) {
        throw new RuntimeError_default(
          "To define a custom orientation, both NORMAL_UP and NORMAL_RIGHT must be defined."
        );
      }
      Cartesian3_default.unpack(normalUp, 0, instanceNormalUp);
      Cartesian3_default.unpack(normalRight, 0, instanceNormalRight);
      hasCustomOrientation = true;
    } else {
      const octNormalUp = featureTable.getProperty(
        "NORMAL_UP_OCT32P",
        ComponentDatatype_default.UNSIGNED_SHORT,
        2,
        i2,
        propertyScratch1
      );
      const octNormalRight = featureTable.getProperty(
        "NORMAL_RIGHT_OCT32P",
        ComponentDatatype_default.UNSIGNED_SHORT,
        2,
        i2,
        propertyScratch2
      );
      if (defined_default(octNormalUp)) {
        if (!defined_default(octNormalRight)) {
          throw new RuntimeError_default(
            "To define a custom orientation with oct-encoded vectors, both NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P must be defined."
          );
        }
        AttributeCompression_default.octDecodeInRange(
          octNormalUp[0],
          octNormalUp[1],
          65535,
          instanceNormalUp
        );
        AttributeCompression_default.octDecodeInRange(
          octNormalRight[0],
          octNormalRight[1],
          65535,
          instanceNormalRight
        );
        hasCustomOrientation = true;
      } else if (eastNorthUp) {
        Transforms_default.eastNorthUpToFixedFrame(
          instancePosition,
          Ellipsoid_default.WGS84,
          instanceTransform
        );
        Matrix4_default.getMatrix3(instanceTransform, instanceRotation);
      } else {
        Matrix3_default.clone(Matrix3_default.IDENTITY, instanceRotation);
      }
    }
    if (hasCustomOrientation) {
      Cartesian3_default.cross(
        instanceNormalRight,
        instanceNormalUp,
        instanceNormalForward
      );
      Cartesian3_default.normalize(instanceNormalForward, instanceNormalForward);
      Matrix3_default.setColumn(
        instanceRotation,
        0,
        instanceNormalRight,
        instanceRotation
      );
      Matrix3_default.setColumn(
        instanceRotation,
        1,
        instanceNormalUp,
        instanceRotation
      );
      Matrix3_default.setColumn(
        instanceRotation,
        2,
        instanceNormalForward,
        instanceRotation
      );
    }
    Quaternion_default.fromRotationMatrix(instanceRotation, instanceQuaternion);
    instanceTranslationRotationScale.rotation = instanceQuaternion;
    instanceScale = Cartesian3_default.fromElements(1, 1, 1, instanceScale);
    const scale = featureTable.getProperty(
      "SCALE",
      ComponentDatatype_default.FLOAT,
      1,
      i2
    );
    if (defined_default(scale)) {
      Cartesian3_default.multiplyByScalar(instanceScale, scale, instanceScale);
    }
    const nonUniformScale = featureTable.getProperty(
      "SCALE_NON_UNIFORM",
      ComponentDatatype_default.FLOAT,
      3,
      i2,
      propertyScratch1
    );
    if (defined_default(nonUniformScale)) {
      instanceScale.x *= nonUniformScale[0];
      instanceScale.y *= nonUniformScale[1];
      instanceScale.z *= nonUniformScale[2];
    }
    instanceTranslationRotationScale.scale = instanceScale;
    let batchId = featureTable.getProperty(
      "BATCH_ID",
      ComponentDatatype_default.UNSIGNED_SHORT,
      1,
      i2
    );
    if (!defined_default(batchId)) {
      batchId = i2;
    }
    Matrix4_default.fromTranslationRotationScale(
      instanceTranslationRotationScale,
      instanceTransform
    );
    const modelMatrix = instanceTransform.clone();
    instances[i2] = {
      modelMatrix,
      batchId
    };
  }
  content._modelInstanceCollection = new ModelInstanceCollection_default(
    collectionOptions
  );
  content._modelInstanceCollection.readyPromise.catch(function() {
  }).then(function(collection) {
    if (content._modelInstanceCollection.ready) {
      collection.activeAnimations.addAll({
        loop: ModelAnimationLoop_default.REPEAT
      });
    }
  });
}
function createFeatures3(content) {
  const featuresLength = content.featuresLength;
  if (!defined_default(content._features) && featuresLength > 0) {
    const features = new Array(featuresLength);
    for (let i2 = 0; i2 < featuresLength; ++i2) {
      features[i2] = new Cesium3DTileFeature_default(content, i2);
    }
    content._features = features;
  }
}
Instanced3DModel3DTileContent.prototype.hasProperty = function(batchId, name) {
  return this._batchTable.hasProperty(batchId, name);
};
Instanced3DModel3DTileContent.prototype.getFeature = function(batchId) {
  const featuresLength = this.featuresLength;
  if (!defined_default(batchId) || batchId < 0 || batchId >= featuresLength) {
    throw new DeveloperError_default(
      `batchId is required and between zero and featuresLength - 1 (${featuresLength - 1}).`
    );
  }
  createFeatures3(this);
  return this._features[batchId];
};
Instanced3DModel3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
  color = enabled ? color : Color_default.WHITE;
  this._batchTable.setAllColor(color);
};
Instanced3DModel3DTileContent.prototype.applyStyle = function(style) {
  this._batchTable.applyStyle(style);
};
Instanced3DModel3DTileContent.prototype.update = function(tileset, frameState) {
  const commandStart = frameState.commandList.length;
  this._batchTable.update(tileset, frameState);
  this._modelInstanceCollection.modelMatrix = this._tile.computedTransform;
  this._modelInstanceCollection.shadows = this._tileset.shadows;
  this._modelInstanceCollection.lightColor = this._tileset.lightColor;
  this._modelInstanceCollection.imageBasedLighting = this._tileset.imageBasedLighting;
  this._modelInstanceCollection.backFaceCulling = this._tileset.backFaceCulling;
  this._modelInstanceCollection.debugWireframe = this._tileset.debugWireframe;
  this._modelInstanceCollection.showCreditsOnScreen = this._tileset.showCreditsOnScreen;
  this._modelInstanceCollection.splitDirection = this._tileset.splitDirection;
  const model = this._modelInstanceCollection._model;
  if (defined_default(model)) {
    const tilesetClippingPlanes = this._tileset.clippingPlanes;
    model.referenceMatrix = this._tileset.clippingPlanesOriginMatrix;
    if (defined_default(tilesetClippingPlanes) && this._tile.clippingPlanesDirty) {
      model._clippingPlanes = tilesetClippingPlanes.enabled && this._tile._isClipped ? tilesetClippingPlanes : void 0;
    }
    if (defined_default(tilesetClippingPlanes) && defined_default(model._clippingPlanes) && model._clippingPlanes !== tilesetClippingPlanes) {
      model._clippingPlanes = tilesetClippingPlanes;
    }
  }
  this._modelInstanceCollection.update(frameState);
  const commandEnd = frameState.commandList.length;
  if (commandStart < commandEnd && (frameState.passes.render || frameState.passes.pick)) {
    this._batchTable.addDerivedCommands(frameState, commandStart, false);
  }
};
Instanced3DModel3DTileContent.prototype.isDestroyed = function() {
  return false;
};
Instanced3DModel3DTileContent.prototype.destroy = function() {
  this._modelInstanceCollection = this._modelInstanceCollection && this._modelInstanceCollection.destroy();
  this._batchTable = this._batchTable && this._batchTable.destroy();
  return destroyObject_default(this);
};
var Instanced3DModel3DTileContent_default = Instanced3DModel3DTileContent;

// node_modules/cesium/Source/Scene/Cesium3DTileRefine.js
var Cesium3DTileRefine = {
  ADD: 0,
  REPLACE: 1
};
var Cesium3DTileRefine_default = Object.freeze(Cesium3DTileRefine);

// node_modules/cesium/Source/Scene/VertexAttributeSemantic.js
var VertexAttributeSemantic = {
  POSITION: "POSITION",
  NORMAL: "NORMAL",
  TANGENT: "TANGENT",
  TEXCOORD: "TEXCOORD",
  COLOR: "COLOR",
  JOINTS: "JOINTS",
  WEIGHTS: "WEIGHTS",
  FEATURE_ID: "_FEATURE_ID"
};
function semanticToVariableName(semantic) {
  switch (semantic) {
    case VertexAttributeSemantic.POSITION:
      return "positionMC";
    case VertexAttributeSemantic.NORMAL:
      return "normalMC";
    case VertexAttributeSemantic.TANGENT:
      return "tangentMC";
    case VertexAttributeSemantic.TEXCOORD:
      return "texCoord";
    case VertexAttributeSemantic.COLOR:
      return "color";
    case VertexAttributeSemantic.JOINTS:
      return "joints";
    case VertexAttributeSemantic.WEIGHTS:
      return "weights";
    case VertexAttributeSemantic.FEATURE_ID:
      return "featureId";
    default:
      throw new DeveloperError_default("semantic is not a valid value.");
  }
}
VertexAttributeSemantic.hasSetIndex = function(semantic) {
  Check_default.typeOf.string("semantic", semantic);
  switch (semantic) {
    case VertexAttributeSemantic.POSITION:
    case VertexAttributeSemantic.NORMAL:
    case VertexAttributeSemantic.TANGENT:
      return false;
    case VertexAttributeSemantic.TEXCOORD:
    case VertexAttributeSemantic.COLOR:
    case VertexAttributeSemantic.JOINTS:
    case VertexAttributeSemantic.WEIGHTS:
    case VertexAttributeSemantic.FEATURE_ID:
      return true;
    default:
      throw new DeveloperError_default("semantic is not a valid value.");
  }
};
VertexAttributeSemantic.fromGltfSemantic = function(gltfSemantic) {
  Check_default.typeOf.string("gltfSemantic", gltfSemantic);
  let semantic = gltfSemantic;
  const setIndexRegex = /^(\w+)_\d+$/;
  const setIndexMatch = setIndexRegex.exec(gltfSemantic);
  if (setIndexMatch !== null) {
    semantic = setIndexMatch[1];
  }
  switch (semantic) {
    case "POSITION":
      return VertexAttributeSemantic.POSITION;
    case "NORMAL":
      return VertexAttributeSemantic.NORMAL;
    case "TANGENT":
      return VertexAttributeSemantic.TANGENT;
    case "TEXCOORD":
      return VertexAttributeSemantic.TEXCOORD;
    case "COLOR":
      return VertexAttributeSemantic.COLOR;
    case "JOINTS":
      return VertexAttributeSemantic.JOINTS;
    case "WEIGHTS":
      return VertexAttributeSemantic.WEIGHTS;
    case "_FEATURE_ID":
      return VertexAttributeSemantic.FEATURE_ID;
  }
  return void 0;
};
VertexAttributeSemantic.fromPntsSemantic = function(pntsSemantic) {
  Check_default.typeOf.string("pntsSemantic", pntsSemantic);
  switch (pntsSemantic) {
    case "POSITION":
    case "POSITION_QUANTIZED":
      return VertexAttributeSemantic.POSITION;
    case "RGBA":
    case "RGB":
    case "RGB565":
      return VertexAttributeSemantic.COLOR;
    case "NORMAL":
    case "NORMAL_OCT16P":
      return VertexAttributeSemantic.NORMAL;
    case "BATCH_ID":
      return VertexAttributeSemantic.FEATURE_ID;
    default:
      throw new DeveloperError_default("pntsSemantic is not a valid value.");
  }
};
VertexAttributeSemantic.getGlslType = function(semantic) {
  Check_default.typeOf.string("semantic", semantic);
  switch (semantic) {
    case VertexAttributeSemantic.POSITION:
    case VertexAttributeSemantic.NORMAL:
    case VertexAttributeSemantic.TANGENT:
      return "vec3";
    case VertexAttributeSemantic.TEXCOORD:
      return "vec2";
    case VertexAttributeSemantic.COLOR:
      return "vec4";
    case VertexAttributeSemantic.JOINTS:
      return "ivec4";
    case VertexAttributeSemantic.WEIGHTS:
      return "vec4";
    case VertexAttributeSemantic.FEATURE_ID:
      return "int";
    default:
      throw new DeveloperError_default("semantic is not a valid value.");
  }
};
VertexAttributeSemantic.getVariableName = function(semantic, setIndex) {
  Check_default.typeOf.string("semantic", semantic);
  let variableName = semanticToVariableName(semantic);
  if (defined_default(setIndex)) {
    variableName += `_${setIndex}`;
  }
  return variableName;
};
var VertexAttributeSemantic_default = Object.freeze(VertexAttributeSemantic);

// node_modules/cesium/Source/Scene/PntsParser.js
var PntsParser = {};
var sizeOfUint327 = Uint32Array.BYTES_PER_ELEMENT;
PntsParser.parse = function(arrayBuffer, byteOffset) {
  byteOffset = defaultValue_default(byteOffset, 0);
  Check_default.defined("arrayBuffer", arrayBuffer);
  const uint8Array = new Uint8Array(arrayBuffer);
  const view = new DataView(arrayBuffer);
  byteOffset += sizeOfUint327;
  const version = view.getUint32(byteOffset, true);
  if (version !== 1) {
    throw new RuntimeError_default(
      `Only Point Cloud tile version 1 is supported.  Version ${version} is not.`
    );
  }
  byteOffset += sizeOfUint327;
  byteOffset += sizeOfUint327;
  const featureTableJsonByteLength = view.getUint32(byteOffset, true);
  if (featureTableJsonByteLength === 0) {
    throw new RuntimeError_default(
      "Feature table must have a byte length greater than zero"
    );
  }
  byteOffset += sizeOfUint327;
  const featureTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint327;
  const batchTableJsonByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint327;
  const batchTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint327;
  const featureTableJson = getJsonFromTypedArray_default(
    uint8Array,
    byteOffset,
    featureTableJsonByteLength
  );
  byteOffset += featureTableJsonByteLength;
  const featureTableBinary = new Uint8Array(
    arrayBuffer,
    byteOffset,
    featureTableBinaryByteLength
  );
  byteOffset += featureTableBinaryByteLength;
  let batchTableJson;
  let batchTableBinary;
  if (batchTableJsonByteLength > 0) {
    batchTableJson = getJsonFromTypedArray_default(
      uint8Array,
      byteOffset,
      batchTableJsonByteLength
    );
    byteOffset += batchTableJsonByteLength;
    if (batchTableBinaryByteLength > 0) {
      batchTableBinary = new Uint8Array(
        arrayBuffer,
        byteOffset,
        batchTableBinaryByteLength
      );
      byteOffset += batchTableBinaryByteLength;
    }
  }
  const featureTable = new Cesium3DTileFeatureTable_default(
    featureTableJson,
    featureTableBinary
  );
  const pointsLength = featureTable.getGlobalProperty("POINTS_LENGTH");
  featureTable.featuresLength = pointsLength;
  if (!defined_default(pointsLength)) {
    throw new RuntimeError_default(
      "Feature table global property: POINTS_LENGTH must be defined"
    );
  }
  let rtcCenter = featureTable.getGlobalProperty(
    "RTC_CENTER",
    ComponentDatatype_default.FLOAT,
    3
  );
  if (defined_default(rtcCenter)) {
    rtcCenter = Cartesian3_default.unpack(rtcCenter);
  }
  const parsedContent = parseDracoProperties(featureTable, batchTableJson);
  parsedContent.rtcCenter = rtcCenter;
  parsedContent.pointsLength = pointsLength;
  if (!parsedContent.hasPositions) {
    const positions = parsePositions(featureTable);
    parsedContent.positions = positions;
    parsedContent.hasPositions = parsedContent.hasPositions || defined_default(positions);
  }
  if (!parsedContent.hasPositions) {
    throw new RuntimeError_default(
      "Either POSITION or POSITION_QUANTIZED must be defined."
    );
  }
  if (!parsedContent.hasNormals) {
    const normals = parseNormals(featureTable);
    parsedContent.normals = normals;
    parsedContent.hasNormals = parsedContent.hasNormals || defined_default(normals);
  }
  if (!parsedContent.hasColors) {
    const colors = parseColors(featureTable);
    parsedContent.colors = colors;
    parsedContent.hasColors = parsedContent.hasColors || defined_default(colors);
    parsedContent.hasConstantColor = defined_default(parsedContent.constantColor);
    parsedContent.isTranslucent = defined_default(colors) && colors.isTranslucent;
  }
  if (!parsedContent.hasBatchIds) {
    const batchIds = parseBatchIds(featureTable);
    parsedContent.batchIds = batchIds;
    parsedContent.hasBatchIds = parsedContent.hasBatchIds || defined_default(batchIds);
  }
  if (parsedContent.hasBatchIds) {
    const batchLength = featureTable.getGlobalProperty("BATCH_LENGTH");
    if (!defined_default(batchLength)) {
      throw new RuntimeError_default(
        "Global property: BATCH_LENGTH must be defined when BATCH_ID is defined."
      );
    }
    parsedContent.batchLength = batchLength;
  }
  if (defined_default(batchTableBinary)) {
    batchTableBinary = new Uint8Array(batchTableBinary);
    parsedContent.batchTableJson = batchTableJson;
    parsedContent.batchTableBinary = batchTableBinary;
  }
  return parsedContent;
};
function parseDracoProperties(featureTable, batchTableJson) {
  const featureTableJson = featureTable.json;
  let dracoBuffer;
  let dracoFeatureTableProperties;
  let dracoBatchTableProperties;
  const featureTableDraco = defined_default(featureTableJson.extensions) ? featureTableJson.extensions["3DTILES_draco_point_compression"] : void 0;
  const batchTableDraco = defined_default(batchTableJson) && defined_default(batchTableJson.extensions) ? batchTableJson.extensions["3DTILES_draco_point_compression"] : void 0;
  if (defined_default(batchTableDraco)) {
    dracoBatchTableProperties = batchTableDraco.properties;
  }
  let hasPositions;
  let hasColors;
  let hasNormals;
  let hasBatchIds;
  let isTranslucent2;
  if (defined_default(featureTableDraco)) {
    dracoFeatureTableProperties = featureTableDraco.properties;
    const dracoByteOffset = featureTableDraco.byteOffset;
    const dracoByteLength = featureTableDraco.byteLength;
    if (!defined_default(dracoFeatureTableProperties) || !defined_default(dracoByteOffset) || !defined_default(dracoByteLength)) {
      throw new RuntimeError_default(
        "Draco properties, byteOffset, and byteLength must be defined"
      );
    }
    dracoBuffer = arraySlice_default(
      featureTable.buffer,
      dracoByteOffset,
      dracoByteOffset + dracoByteLength
    );
    hasPositions = defined_default(dracoFeatureTableProperties.POSITION);
    hasColors = defined_default(dracoFeatureTableProperties.RGB) || defined_default(dracoFeatureTableProperties.RGBA);
    hasNormals = defined_default(dracoFeatureTableProperties.NORMAL);
    hasBatchIds = defined_default(dracoFeatureTableProperties.BATCH_ID);
    isTranslucent2 = defined_default(dracoFeatureTableProperties.RGBA);
  }
  let draco;
  if (defined_default(dracoBuffer)) {
    draco = {
      buffer: dracoBuffer,
      featureTableProperties: dracoFeatureTableProperties,
      batchTableProperties: dracoBatchTableProperties,
      properties: combine_default(
        dracoFeatureTableProperties,
        dracoBatchTableProperties
      ),
      dequantizeInShader: true
    };
  }
  return {
    draco,
    hasPositions,
    hasColors,
    isTranslucent: isTranslucent2,
    hasNormals,
    hasBatchIds
  };
}
function parsePositions(featureTable) {
  const featureTableJson = featureTable.json;
  let positions;
  if (defined_default(featureTableJson.POSITION)) {
    positions = featureTable.getPropertyArray(
      "POSITION",
      ComponentDatatype_default.FLOAT,
      3
    );
    return {
      name: VertexAttributeSemantic_default.POSITION,
      semantic: VertexAttributeSemantic_default.POSITION,
      typedArray: positions,
      isQuantized: false,
      componentDatatype: ComponentDatatype_default.FLOAT,
      type: AttributeType_default.VEC3
    };
  } else if (defined_default(featureTableJson.POSITION_QUANTIZED)) {
    positions = featureTable.getPropertyArray(
      "POSITION_QUANTIZED",
      ComponentDatatype_default.UNSIGNED_SHORT,
      3
    );
    const quantizedVolumeScale = featureTable.getGlobalProperty(
      "QUANTIZED_VOLUME_SCALE",
      ComponentDatatype_default.FLOAT,
      3
    );
    if (!defined_default(quantizedVolumeScale)) {
      throw new RuntimeError_default(
        "Global property: QUANTIZED_VOLUME_SCALE must be defined for quantized positions."
      );
    }
    const quantizedRange = (1 << 16) - 1;
    const quantizedVolumeOffset = featureTable.getGlobalProperty(
      "QUANTIZED_VOLUME_OFFSET",
      ComponentDatatype_default.FLOAT,
      3
    );
    if (!defined_default(quantizedVolumeOffset)) {
      throw new RuntimeError_default(
        "Global property: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions."
      );
    }
    return {
      name: VertexAttributeSemantic_default.POSITION,
      semantic: VertexAttributeSemantic_default.POSITION,
      typedArray: positions,
      isQuantized: true,
      componentDatatype: ComponentDatatype_default.FLOAT,
      type: AttributeType_default.VEC3,
      quantizedRange,
      quantizedVolumeOffset: Cartesian3_default.unpack(quantizedVolumeOffset),
      quantizedVolumeScale: Cartesian3_default.unpack(quantizedVolumeScale),
      quantizedComponentDatatype: ComponentDatatype_default.UNSIGNED_SHORT,
      quantizedType: AttributeType_default.VEC3
    };
  }
}
function parseColors(featureTable) {
  const featureTableJson = featureTable.json;
  let colors;
  if (defined_default(featureTableJson.RGBA)) {
    colors = featureTable.getPropertyArray(
      "RGBA",
      ComponentDatatype_default.UNSIGNED_BYTE,
      4
    );
    return {
      name: VertexAttributeSemantic_default.COLOR,
      semantic: VertexAttributeSemantic_default.COLOR,
      setIndex: 0,
      typedArray: colors,
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      type: AttributeType_default.VEC4,
      normalized: true,
      isRGB565: false,
      isTranslucent: true
    };
  } else if (defined_default(featureTableJson.RGB)) {
    colors = featureTable.getPropertyArray(
      "RGB",
      ComponentDatatype_default.UNSIGNED_BYTE,
      3
    );
    return {
      name: "COLOR",
      semantic: VertexAttributeSemantic_default.COLOR,
      setIndex: 0,
      typedArray: colors,
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      type: AttributeType_default.VEC3,
      normalized: true,
      isRGB565: false,
      isTranslucent: false
    };
  } else if (defined_default(featureTableJson.RGB565)) {
    colors = featureTable.getPropertyArray(
      "RGB565",
      ComponentDatatype_default.UNSIGNED_SHORT,
      1
    );
    return {
      name: "COLOR",
      semantic: VertexAttributeSemantic_default.COLOR,
      setIndex: 0,
      typedArray: colors,
      componentDatatype: ComponentDatatype_default.FLOAT,
      type: AttributeType_default.VEC3,
      normalized: false,
      isRGB565: true,
      isTranslucent: false
    };
  } else if (defined_default(featureTableJson.CONSTANT_RGBA)) {
    const constantRGBA = featureTable.getGlobalProperty(
      "CONSTANT_RGBA",
      ComponentDatatype_default.UNSIGNED_BYTE,
      4
    );
    const alpha = constantRGBA[3];
    const constantColor = Color_default.fromBytes(
      constantRGBA[0],
      constantRGBA[1],
      constantRGBA[2],
      alpha
    );
    const isTranslucent2 = alpha < 255;
    return {
      name: VertexAttributeSemantic_default.COLOR,
      semantic: VertexAttributeSemantic_default.COLOR,
      setIndex: 0,
      constantColor,
      componentDatatype: ComponentDatatype_default.FLOAT,
      type: AttributeType_default.VEC4,
      isQuantized: false,
      isTranslucent: isTranslucent2
    };
  }
  return void 0;
}
function parseNormals(featureTable) {
  const featureTableJson = featureTable.json;
  let normals;
  if (defined_default(featureTableJson.NORMAL)) {
    normals = featureTable.getPropertyArray(
      "NORMAL",
      ComponentDatatype_default.FLOAT,
      3
    );
    return {
      name: VertexAttributeSemantic_default.NORMAL,
      semantic: VertexAttributeSemantic_default.NORMAL,
      typedArray: normals,
      octEncoded: false,
      octEncodedZXY: false,
      componentDatatype: ComponentDatatype_default.FLOAT,
      type: AttributeType_default.VEC3
    };
  } else if (defined_default(featureTableJson.NORMAL_OCT16P)) {
    normals = featureTable.getPropertyArray(
      "NORMAL_OCT16P",
      ComponentDatatype_default.UNSIGNED_BYTE,
      2
    );
    const quantizationBits = 8;
    return {
      name: VertexAttributeSemantic_default.NORMAL,
      semantic: VertexAttributeSemantic_default.NORMAL,
      typedArray: normals,
      octEncoded: true,
      octEncodedZXY: false,
      quantizedRange: (1 << quantizationBits) - 1,
      quantizedType: AttributeType_default.VEC2,
      quantizedComponentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentDatatype: ComponentDatatype_default.FLOAT,
      type: AttributeType_default.VEC3
    };
  }
  return void 0;
}
function parseBatchIds(featureTable) {
  const featureTableJson = featureTable.json;
  if (defined_default(featureTableJson.BATCH_ID)) {
    const batchIds = featureTable.getPropertyArray(
      "BATCH_ID",
      ComponentDatatype_default.UNSIGNED_SHORT,
      1
    );
    return {
      name: VertexAttributeSemantic_default.FEATURE_ID,
      semantic: VertexAttributeSemantic_default.FEATURE_ID,
      setIndex: 0,
      typedArray: batchIds,
      componentDatatype: ComponentDatatype_default.fromTypedArray(batchIds),
      type: AttributeType_default.SCALAR
    };
  }
  return void 0;
}
var PntsParser_default = PntsParser;

// node_modules/cesium/Source/Scene/PointCloud.js
var DecodingState = {
  NEEDS_DECODE: 0,
  DECODING: 1,
  READY: 2,
  FAILED: 3
};
function PointCloud(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.object("options.arrayBuffer", options.arrayBuffer);
  this._parsedContent = void 0;
  this._drawCommand = void 0;
  this._isTranslucent = false;
  this._styleTranslucent = false;
  this._constantColor = Color_default.clone(Color_default.DARKGRAY);
  this._highlightColor = Color_default.clone(Color_default.WHITE);
  this._pointSize = 1;
  this._rtcCenter = void 0;
  this._quantizedVolumeScale = void 0;
  this._quantizedVolumeOffset = void 0;
  this._styleableShaderAttributes = void 0;
  this._isQuantized = false;
  this._isOctEncoded16P = false;
  this._isRGB565 = false;
  this._hasColors = false;
  this._hasNormals = false;
  this._hasBatchIds = false;
  this._decodingState = DecodingState.READY;
  this._dequantizeInShader = true;
  this._isQuantizedDraco = false;
  this._isOctEncodedDraco = false;
  this._quantizedRange = 0;
  this._octEncodedRange = 0;
  this.backFaceCulling = false;
  this._backFaceCulling = false;
  this.normalShading = true;
  this._normalShading = true;
  this._opaqueRenderState = void 0;
  this._translucentRenderState = void 0;
  this._mode = void 0;
  this._ready = false;
  this._readyPromise = defer_default();
  this._pointsLength = 0;
  this._geometryByteLength = 0;
  this._vertexShaderLoaded = options.vertexShaderLoaded;
  this._fragmentShaderLoaded = options.fragmentShaderLoaded;
  this._uniformMapLoaded = options.uniformMapLoaded;
  this._batchTableLoaded = options.batchTableLoaded;
  this._pickIdLoaded = options.pickIdLoaded;
  this._opaquePass = defaultValue_default(options.opaquePass, Pass_default.OPAQUE);
  this._cull = defaultValue_default(options.cull, true);
  this.style = void 0;
  this._style = void 0;
  this.styleDirty = false;
  this.modelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._modelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this.time = 0;
  this.shadows = ShadowMode_default.ENABLED;
  this._boundingSphere = void 0;
  this.clippingPlanes = void 0;
  this.isClipped = false;
  this.clippingPlanesDirty = false;
  this.clippingPlanesOriginMatrix = void 0;
  this.attenuation = false;
  this._attenuation = false;
  this.geometricError = 0;
  this.geometricErrorScale = 1;
  this.maximumAttenuation = this._pointSize;
  this.splitDirection = defaultValue_default(
    options.splitDirection,
    SplitDirection_default.NONE
  );
  this._splittingEnabled = false;
  initialize10(this, options);
}
Object.defineProperties(PointCloud.prototype, {
  pointsLength: {
    get: function() {
      return this._pointsLength;
    }
  },
  geometryByteLength: {
    get: function() {
      return this._geometryByteLength;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  color: {
    get: function() {
      return Color_default.clone(this._highlightColor);
    },
    set: function(value) {
      this._highlightColor = Color_default.clone(value, this._highlightColor);
    }
  },
  boundingSphere: {
    get: function() {
      if (defined_default(this._drawCommand)) {
        return this._drawCommand.boundingVolume;
      }
      return void 0;
    },
    set: function(value) {
      this._boundingSphere = BoundingSphere_default.clone(value, this._boundingSphere);
    }
  }
});
function initialize10(pointCloud, options) {
  const parsedContent = PntsParser_default.parse(
    options.arrayBuffer,
    options.byteOffset
  );
  pointCloud._parsedContent = parsedContent;
  pointCloud._rtcCenter = parsedContent.rtcCenter;
  pointCloud._hasNormals = parsedContent.hasNormals;
  pointCloud._hasColors = parsedContent.hasColors;
  pointCloud._hasBatchIds = parsedContent.hasBatchIds;
  pointCloud._isTranslucent = parsedContent.isTranslucent;
  if (!parsedContent.hasBatchIds && defined_default(parsedContent.batchTableBinary)) {
    parsedContent.styleableProperties = Cesium3DTileBatchTable_default.getBinaryProperties(
      parsedContent.pointsLength,
      parsedContent.batchTableJson,
      parsedContent.batchTableBinary
    );
  }
  if (defined_default(parsedContent.draco)) {
    const draco = parsedContent.draco;
    pointCloud._decodingState = DecodingState.NEEDS_DECODE;
    draco.dequantizeInShader = pointCloud._dequantizeInShader;
  }
  const positions = parsedContent.positions;
  if (defined_default(positions)) {
    pointCloud._isQuantized = positions.isQuantized;
    pointCloud._quantizedVolumeScale = positions.quantizedVolumeScale;
    pointCloud._quantizedVolumeOffset = positions.quantizedVolumeOffset;
    pointCloud._quantizedRange = positions.quantizedRange;
  }
  const normals = parsedContent.normals;
  if (defined_default(normals)) {
    pointCloud._isOctEncoded16P = normals.octEncoded;
  }
  const colors = parsedContent.colors;
  if (defined_default(colors)) {
    if (defined_default(colors.constantColor)) {
      pointCloud._constantColor = Color_default.clone(
        colors.constantColor,
        pointCloud._constantColor
      );
      pointCloud._hasColors = false;
    }
    pointCloud._isRGB565 = colors.isRGB565;
  }
  const batchIds = parsedContent.batchIds;
  if (defined_default(parsedContent.batchIds)) {
    batchIds.name = "BATCH_ID";
    batchIds.semantic = "BATCH_ID";
    batchIds.setIndex = void 0;
  }
  if (parsedContent.hasBatchIds) {
    pointCloud._batchTableLoaded(
      parsedContent.batchLength,
      parsedContent.batchTableJson,
      parsedContent.batchTableBinary
    );
  }
  pointCloud._pointsLength = parsedContent.pointsLength;
}
var scratchMin3 = new Cartesian3_default();
var scratchMax3 = new Cartesian3_default();
var scratchPosition8 = new Cartesian3_default();
var randomNumberGenerator2;
var randomValues;
function getRandomValues(samplesLength) {
  if (!defined_default(randomValues)) {
    randomNumberGenerator2 = new mersenneTwister(0);
    randomValues = new Array(samplesLength);
    for (let i2 = 0; i2 < samplesLength; ++i2) {
      randomValues[i2] = randomNumberGenerator2.random();
    }
  }
  return randomValues;
}
function computeApproximateBoundingSphereFromPositions(positions) {
  const maximumSamplesLength = 20;
  const pointsLength = positions.length / 3;
  const samplesLength = Math.min(pointsLength, maximumSamplesLength);
  const randomValues3 = getRandomValues(maximumSamplesLength);
  const maxValue = Number.MAX_VALUE;
  const minValue = -Number.MAX_VALUE;
  const min3 = Cartesian3_default.fromElements(maxValue, maxValue, maxValue, scratchMin3);
  const max3 = Cartesian3_default.fromElements(minValue, minValue, minValue, scratchMax3);
  for (let i2 = 0; i2 < samplesLength; ++i2) {
    const index2 = Math.floor(randomValues3[i2] * pointsLength);
    const position = Cartesian3_default.unpack(positions, index2 * 3, scratchPosition8);
    Cartesian3_default.minimumByComponent(min3, position, min3);
    Cartesian3_default.maximumByComponent(max3, position, max3);
  }
  const boundingSphere = BoundingSphere_default.fromCornerPoints(min3, max3);
  boundingSphere.radius += Math_default.EPSILON2;
  return boundingSphere;
}
function prepareVertexAttribute(typedArray, name) {
  const componentDatatype = ComponentDatatype_default.fromTypedArray(typedArray);
  if (componentDatatype === ComponentDatatype_default.INT || componentDatatype === ComponentDatatype_default.UNSIGNED_INT || componentDatatype === ComponentDatatype_default.DOUBLE) {
    oneTimeWarning_default(
      "Cast pnts property to floats",
      `Point cloud property "${name}" will be casted to a float array because INT, UNSIGNED_INT, and DOUBLE are not valid WebGL vertex attribute types. Some precision may be lost.`
    );
    return new Float32Array(typedArray);
  }
  return typedArray;
}
var scratchPointSizeAndTimeAndGeometricErrorAndDepthMultiplier = new Cartesian4_default();
var scratchQuantizedVolumeScaleAndOctEncodedRange = new Cartesian4_default();
var scratchColor6 = new Color_default();
var positionLocation = 0;
var colorLocation = 1;
var normalLocation = 2;
var batchIdLocation = 3;
var numberOfAttributes = 4;
var scratchClippingPlanesMatrix2 = new Matrix4_default();
var scratchInverseTransposeClippingPlanesMatrix = new Matrix4_default();
function createResources3(pointCloud, frameState) {
  const context = frameState.context;
  const parsedContent = pointCloud._parsedContent;
  const pointsLength = pointCloud._pointsLength;
  const positions = parsedContent.positions;
  const colors = parsedContent.colors;
  const normals = parsedContent.normals;
  let batchIds = parsedContent.batchIds;
  const styleableProperties = parsedContent.styleableProperties;
  const hasStyleableProperties = defined_default(styleableProperties);
  const isQuantized = pointCloud._isQuantized;
  const isQuantizedDraco = pointCloud._isQuantizedDraco;
  const isOctEncoded16P = pointCloud._isOctEncoded16P;
  const isOctEncodedDraco = pointCloud._isOctEncodedDraco;
  const quantizedRange = pointCloud._quantizedRange;
  const octEncodedRange = pointCloud._octEncodedRange;
  const isRGB565 = pointCloud._isRGB565;
  const isTranslucent2 = pointCloud._isTranslucent;
  const hasColors = pointCloud._hasColors;
  const hasNormals = pointCloud._hasNormals;
  const hasBatchIds = pointCloud._hasBatchIds;
  let componentsPerAttribute;
  let componentDatatype;
  const styleableVertexAttributes = [];
  const styleableShaderAttributes = {};
  pointCloud._styleableShaderAttributes = styleableShaderAttributes;
  if (hasStyleableProperties) {
    let attributeLocation = numberOfAttributes;
    for (const name in styleableProperties) {
      if (styleableProperties.hasOwnProperty(name)) {
        const property = styleableProperties[name];
        const typedArray = prepareVertexAttribute(property.typedArray, name);
        componentsPerAttribute = property.componentCount;
        componentDatatype = ComponentDatatype_default.fromTypedArray(typedArray);
        const vertexBuffer = Buffer_default.createVertexBuffer({
          context,
          typedArray,
          usage: BufferUsage_default.STATIC_DRAW
        });
        pointCloud._geometryByteLength += vertexBuffer.sizeInBytes;
        const vertexAttribute = {
          index: attributeLocation,
          vertexBuffer,
          componentsPerAttribute,
          componentDatatype,
          normalize: false,
          offsetInBytes: 0,
          strideInBytes: 0
        };
        styleableVertexAttributes.push(vertexAttribute);
        styleableShaderAttributes[name] = {
          location: attributeLocation,
          componentCount: componentsPerAttribute
        };
        ++attributeLocation;
      }
    }
  }
  const positionsVertexBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: positions.typedArray,
    usage: BufferUsage_default.STATIC_DRAW
  });
  pointCloud._geometryByteLength += positionsVertexBuffer.sizeInBytes;
  let colorsVertexBuffer;
  if (hasColors) {
    colorsVertexBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: colors.typedArray,
      usage: BufferUsage_default.STATIC_DRAW
    });
    pointCloud._geometryByteLength += colorsVertexBuffer.sizeInBytes;
  }
  let normalsVertexBuffer;
  if (hasNormals) {
    normalsVertexBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: normals.typedArray,
      usage: BufferUsage_default.STATIC_DRAW
    });
    pointCloud._geometryByteLength += normalsVertexBuffer.sizeInBytes;
  }
  let batchIdsVertexBuffer;
  if (hasBatchIds) {
    batchIds = prepareVertexAttribute(batchIds, "batchIds");
    batchIdsVertexBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: batchIds.typedArray,
      usage: BufferUsage_default.STATIC_DRAW
    });
    pointCloud._geometryByteLength += batchIdsVertexBuffer.sizeInBytes;
  }
  let attributes = [];
  if (isQuantized) {
    componentDatatype = ComponentDatatype_default.UNSIGNED_SHORT;
  } else if (isQuantizedDraco) {
    componentDatatype = quantizedRange <= 255 ? ComponentDatatype_default.UNSIGNED_BYTE : ComponentDatatype_default.UNSIGNED_SHORT;
  } else {
    componentDatatype = ComponentDatatype_default.FLOAT;
  }
  attributes.push({
    index: positionLocation,
    vertexBuffer: positionsVertexBuffer,
    componentsPerAttribute: 3,
    componentDatatype,
    normalize: false,
    offsetInBytes: 0,
    strideInBytes: 0
  });
  if (pointCloud._cull) {
    if (isQuantized || isQuantizedDraco) {
      pointCloud._boundingSphere = BoundingSphere_default.fromCornerPoints(
        Cartesian3_default.ZERO,
        pointCloud._quantizedVolumeScale
      );
    } else {
      pointCloud._boundingSphere = computeApproximateBoundingSphereFromPositions(
        positions.typedArray
      );
    }
  }
  if (hasColors) {
    if (isRGB565) {
      attributes.push({
        index: colorLocation,
        vertexBuffer: colorsVertexBuffer,
        componentsPerAttribute: 1,
        componentDatatype: ComponentDatatype_default.UNSIGNED_SHORT,
        normalize: false,
        offsetInBytes: 0,
        strideInBytes: 0
      });
    } else {
      const colorComponentsPerAttribute = isTranslucent2 ? 4 : 3;
      attributes.push({
        index: colorLocation,
        vertexBuffer: colorsVertexBuffer,
        componentsPerAttribute: colorComponentsPerAttribute,
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
        normalize: true,
        offsetInBytes: 0,
        strideInBytes: 0
      });
    }
  }
  if (hasNormals) {
    if (isOctEncoded16P) {
      componentsPerAttribute = 2;
      componentDatatype = ComponentDatatype_default.UNSIGNED_BYTE;
    } else if (isOctEncodedDraco) {
      componentsPerAttribute = 2;
      componentDatatype = octEncodedRange <= 255 ? ComponentDatatype_default.UNSIGNED_BYTE : ComponentDatatype_default.UNSIGNED_SHORT;
    } else {
      componentsPerAttribute = 3;
      componentDatatype = ComponentDatatype_default.FLOAT;
    }
    attributes.push({
      index: normalLocation,
      vertexBuffer: normalsVertexBuffer,
      componentsPerAttribute,
      componentDatatype,
      normalize: false,
      offsetInBytes: 0,
      strideInBytes: 0
    });
  }
  if (hasBatchIds) {
    attributes.push({
      index: batchIdLocation,
      vertexBuffer: batchIdsVertexBuffer,
      componentsPerAttribute: 1,
      componentDatatype: ComponentDatatype_default.fromTypedArray(batchIds.typedArray),
      normalize: false,
      offsetInBytes: 0,
      strideInBytes: 0
    });
  }
  if (hasStyleableProperties) {
    attributes = attributes.concat(styleableVertexAttributes);
  }
  const vertexArray = new VertexArray_default({
    context,
    attributes
  });
  const opaqueRenderState = {
    depthTest: {
      enabled: true
    }
  };
  const translucentRenderState = {
    depthTest: {
      enabled: true
    },
    depthMask: false,
    blending: BlendingState_default.ALPHA_BLEND
  };
  if (pointCloud._opaquePass === Pass_default.CESIUM_3D_TILE) {
    opaqueRenderState.stencilTest = StencilConstants_default.setCesium3DTileBit();
    opaqueRenderState.stencilMask = StencilConstants_default.CESIUM_3D_TILE_MASK;
    translucentRenderState.stencilTest = StencilConstants_default.setCesium3DTileBit();
    translucentRenderState.stencilMask = StencilConstants_default.CESIUM_3D_TILE_MASK;
  }
  pointCloud._opaqueRenderState = RenderState_default.fromCache(opaqueRenderState);
  pointCloud._translucentRenderState = RenderState_default.fromCache(
    translucentRenderState
  );
  pointCloud._drawCommand = new DrawCommand_default({
    boundingVolume: new BoundingSphere_default(),
    cull: pointCloud._cull,
    modelMatrix: new Matrix4_default(),
    primitiveType: PrimitiveType_default.POINTS,
    vertexArray,
    count: pointsLength,
    shaderProgram: void 0,
    uniformMap: void 0,
    renderState: isTranslucent2 ? pointCloud._translucentRenderState : pointCloud._opaqueRenderState,
    pass: isTranslucent2 ? Pass_default.TRANSLUCENT : pointCloud._opaquePass,
    owner: pointCloud,
    castShadows: false,
    receiveShadows: false,
    pickId: pointCloud._pickIdLoaded()
  });
}
function createUniformMap3(pointCloud, frameState) {
  const context = frameState.context;
  const isQuantized = pointCloud._isQuantized;
  const isQuantizedDraco = pointCloud._isQuantizedDraco;
  const isOctEncodedDraco = pointCloud._isOctEncodedDraco;
  let uniformMap2 = {
    u_pointSizeAndTimeAndGeometricErrorAndDepthMultiplier: function() {
      const scratch = scratchPointSizeAndTimeAndGeometricErrorAndDepthMultiplier;
      scratch.x = pointCloud._attenuation ? pointCloud.maximumAttenuation : pointCloud._pointSize;
      scratch.x *= frameState.pixelRatio;
      scratch.y = pointCloud.time;
      if (pointCloud._attenuation) {
        const frustum = frameState.camera.frustum;
        let depthMultiplier;
        if (frameState.mode === SceneMode_default.SCENE2D || frustum instanceof OrthographicFrustum_default) {
          depthMultiplier = Number.POSITIVE_INFINITY;
        } else {
          depthMultiplier = context.drawingBufferHeight / frameState.camera.frustum.sseDenominator;
        }
        scratch.z = pointCloud.geometricError * pointCloud.geometricErrorScale;
        scratch.w = depthMultiplier;
      }
      return scratch;
    },
    u_highlightColor: function() {
      return pointCloud._highlightColor;
    },
    u_constantColor: function() {
      return pointCloud._constantColor;
    },
    u_clippingPlanes: function() {
      const clippingPlanes = pointCloud.clippingPlanes;
      const isClipped = pointCloud.isClipped;
      return isClipped ? clippingPlanes.texture : context.defaultTexture;
    },
    u_clippingPlanesEdgeStyle: function() {
      const clippingPlanes = pointCloud.clippingPlanes;
      if (!defined_default(clippingPlanes)) {
        return Color_default.TRANSPARENT;
      }
      const style = Color_default.clone(clippingPlanes.edgeColor, scratchColor6);
      style.alpha = clippingPlanes.edgeWidth;
      return style;
    },
    u_clippingPlanesMatrix: function() {
      const clippingPlanes = pointCloud.clippingPlanes;
      if (!defined_default(clippingPlanes)) {
        return Matrix4_default.IDENTITY;
      }
      const clippingPlanesOriginMatrix = defaultValue_default(
        pointCloud.clippingPlanesOriginMatrix,
        pointCloud._modelMatrix
      );
      Matrix4_default.multiply(
        context.uniformState.view3D,
        clippingPlanesOriginMatrix,
        scratchClippingPlanesMatrix2
      );
      const transform4 = Matrix4_default.multiply(
        scratchClippingPlanesMatrix2,
        clippingPlanes.modelMatrix,
        scratchClippingPlanesMatrix2
      );
      return Matrix4_default.inverseTranspose(
        transform4,
        scratchInverseTransposeClippingPlanesMatrix
      );
    }
  };
  Splitter_default.addUniforms(pointCloud, uniformMap2);
  if (isQuantized || isQuantizedDraco || isOctEncodedDraco) {
    uniformMap2 = combine_default(uniformMap2, {
      u_quantizedVolumeScaleAndOctEncodedRange: function() {
        const scratch = scratchQuantizedVolumeScaleAndOctEncodedRange;
        if (defined_default(pointCloud._quantizedVolumeScale)) {
          const scale = Cartesian3_default.clone(
            pointCloud._quantizedVolumeScale,
            scratch
          );
          Cartesian3_default.divideByScalar(scale, pointCloud._quantizedRange, scratch);
        }
        scratch.w = pointCloud._octEncodedRange;
        return scratch;
      }
    });
  }
  if (defined_default(pointCloud._uniformMapLoaded)) {
    uniformMap2 = pointCloud._uniformMapLoaded(uniformMap2);
  }
  pointCloud._drawCommand.uniformMap = uniformMap2;
}
function getStyleablePropertyIds(source, propertyIds) {
  const regex = /czm_3dtiles_property_(\d+)/g;
  let matches = regex.exec(source);
  while (matches !== null) {
    const id = parseInt(matches[1]);
    if (propertyIds.indexOf(id) === -1) {
      propertyIds.push(id);
    }
    matches = regex.exec(source);
  }
}
function getBuiltinPropertyNames(source, propertyNames) {
  source = source.slice(source.indexOf("\n"));
  const regex = /czm_3dtiles_builtin_property_(\w+)/g;
  let matches = regex.exec(source);
  while (matches !== null) {
    const name = matches[1];
    if (propertyNames.indexOf(name) === -1) {
      propertyNames.push(name);
    }
    matches = regex.exec(source);
  }
}
function getVertexAttribute(vertexArray, index2) {
  const numberOfAttributes2 = vertexArray.numberOfAttributes;
  for (let i2 = 0; i2 < numberOfAttributes2; ++i2) {
    const attribute = vertexArray.getAttribute(i2);
    if (attribute.index === index2) {
      return attribute;
    }
  }
}
var builtinVariableSubstitutionMap = {
  POSITION: "czm_3dtiles_builtin_property_POSITION",
  POSITION_ABSOLUTE: "czm_3dtiles_builtin_property_POSITION_ABSOLUTE",
  COLOR: "czm_3dtiles_builtin_property_COLOR",
  NORMAL: "czm_3dtiles_builtin_property_NORMAL"
};
function createShaders2(pointCloud, frameState, style) {
  let i2;
  let name;
  let attribute;
  const context = frameState.context;
  const hasStyle = defined_default(style);
  const isQuantized = pointCloud._isQuantized;
  const isQuantizedDraco = pointCloud._isQuantizedDraco;
  const isOctEncoded16P = pointCloud._isOctEncoded16P;
  const isOctEncodedDraco = pointCloud._isOctEncodedDraco;
  const isRGB565 = pointCloud._isRGB565;
  const isTranslucent2 = pointCloud._isTranslucent;
  const hasColors = pointCloud._hasColors;
  const hasNormals = pointCloud._hasNormals;
  const hasBatchIds = pointCloud._hasBatchIds;
  const backFaceCulling = pointCloud._backFaceCulling;
  const normalShading = pointCloud._normalShading;
  const vertexArray = pointCloud._drawCommand.vertexArray;
  const clippingPlanes = pointCloud.clippingPlanes;
  const attenuation = pointCloud._attenuation;
  let colorStyleFunction;
  let showStyleFunction;
  let pointSizeStyleFunction;
  let styleTranslucent = isTranslucent2;
  const variableSubstitutionMap = clone_default(builtinVariableSubstitutionMap);
  const propertyIdToAttributeMap = {};
  const styleableShaderAttributes = pointCloud._styleableShaderAttributes;
  for (name in styleableShaderAttributes) {
    if (styleableShaderAttributes.hasOwnProperty(name)) {
      attribute = styleableShaderAttributes[name];
      variableSubstitutionMap[name] = `czm_3dtiles_property_${attribute.location}`;
      propertyIdToAttributeMap[attribute.location] = attribute;
    }
  }
  if (hasStyle) {
    const shaderState = {
      translucent: false
    };
    const parameterList = "(vec3 czm_3dtiles_builtin_property_POSITION, vec3 czm_3dtiles_builtin_property_POSITION_ABSOLUTE, vec4 czm_3dtiles_builtin_property_COLOR, vec3 czm_3dtiles_builtin_property_NORMAL)";
    colorStyleFunction = style.getColorShaderFunction(
      `getColorFromStyle${parameterList}`,
      variableSubstitutionMap,
      shaderState
    );
    showStyleFunction = style.getShowShaderFunction(
      `getShowFromStyle${parameterList}`,
      variableSubstitutionMap,
      shaderState
    );
    pointSizeStyleFunction = style.getPointSizeShaderFunction(
      `getPointSizeFromStyle${parameterList}`,
      variableSubstitutionMap,
      shaderState
    );
    if (defined_default(colorStyleFunction) && shaderState.translucent) {
      styleTranslucent = true;
    }
  }
  pointCloud._styleTranslucent = styleTranslucent;
  const hasColorStyle = defined_default(colorStyleFunction);
  const hasShowStyle = defined_default(showStyleFunction);
  const hasPointSizeStyle = defined_default(pointSizeStyleFunction);
  const hasClippedContent = pointCloud.isClipped;
  const styleablePropertyIds = [];
  const builtinPropertyNames = [];
  if (hasColorStyle) {
    getStyleablePropertyIds(colorStyleFunction, styleablePropertyIds);
    getBuiltinPropertyNames(colorStyleFunction, builtinPropertyNames);
  }
  if (hasShowStyle) {
    getStyleablePropertyIds(showStyleFunction, styleablePropertyIds);
    getBuiltinPropertyNames(showStyleFunction, builtinPropertyNames);
  }
  if (hasPointSizeStyle) {
    getStyleablePropertyIds(pointSizeStyleFunction, styleablePropertyIds);
    getBuiltinPropertyNames(pointSizeStyleFunction, builtinPropertyNames);
  }
  const usesColorSemantic = builtinPropertyNames.indexOf("COLOR") >= 0;
  const usesNormalSemantic = builtinPropertyNames.indexOf("NORMAL") >= 0;
  if (usesNormalSemantic && !hasNormals) {
    throw new RuntimeError_default(
      "Style references the NORMAL semantic but the point cloud does not have normals"
    );
  }
  for (name in styleableShaderAttributes) {
    if (styleableShaderAttributes.hasOwnProperty(name)) {
      attribute = styleableShaderAttributes[name];
      const enabled = styleablePropertyIds.indexOf(attribute.location) >= 0;
      const vertexAttribute = getVertexAttribute(
        vertexArray,
        attribute.location
      );
      vertexAttribute.enabled = enabled;
    }
  }
  const usesColors = hasColors && (!hasColorStyle || usesColorSemantic);
  if (hasColors) {
    const colorVertexAttribute = getVertexAttribute(vertexArray, colorLocation);
    colorVertexAttribute.enabled = usesColors;
  }
  const usesNormals = hasNormals && (normalShading || backFaceCulling || usesNormalSemantic);
  if (hasNormals) {
    const normalVertexAttribute = getVertexAttribute(
      vertexArray,
      normalLocation
    );
    normalVertexAttribute.enabled = usesNormals;
  }
  const attributeLocations8 = {
    a_position: positionLocation
  };
  if (usesColors) {
    attributeLocations8.a_color = colorLocation;
  }
  if (usesNormals) {
    attributeLocations8.a_normal = normalLocation;
  }
  if (hasBatchIds) {
    attributeLocations8.a_batchId = batchIdLocation;
  }
  let attributeDeclarations = "";
  const length3 = styleablePropertyIds.length;
  for (i2 = 0; i2 < length3; ++i2) {
    const propertyId = styleablePropertyIds[i2];
    attribute = propertyIdToAttributeMap[propertyId];
    const componentCount = attribute.componentCount;
    const attributeName = `czm_3dtiles_property_${propertyId}`;
    let attributeType;
    if (componentCount === 1) {
      attributeType = "float";
    } else {
      attributeType = `vec${componentCount}`;
    }
    attributeDeclarations += `attribute ${attributeType} ${attributeName}; 
`;
    attributeLocations8[attributeName] = attribute.location;
  }
  createUniformMap3(pointCloud, frameState);
  let vs = "attribute vec3 a_position; \nvarying vec4 v_color; \nuniform vec4 u_pointSizeAndTimeAndGeometricErrorAndDepthMultiplier; \nuniform vec4 u_constantColor; \nuniform vec4 u_highlightColor; \n";
  vs += "float u_pointSize; \nfloat u_time; \n";
  if (attenuation) {
    vs += "float u_geometricError; \nfloat u_depthMultiplier; \n";
  }
  vs += attributeDeclarations;
  if (usesColors) {
    if (isTranslucent2) {
      vs += "attribute vec4 a_color; \n";
    } else if (isRGB565) {
      vs += "attribute float a_color; \nconst float SHIFT_RIGHT_11 = 1.0 / 2048.0; \nconst float SHIFT_RIGHT_5 = 1.0 / 32.0; \nconst float SHIFT_LEFT_11 = 2048.0; \nconst float SHIFT_LEFT_5 = 32.0; \nconst float NORMALIZE_6 = 1.0 / 64.0; \nconst float NORMALIZE_5 = 1.0 / 32.0; \n";
    } else {
      vs += "attribute vec3 a_color; \n";
    }
  }
  if (usesNormals) {
    if (isOctEncoded16P || isOctEncodedDraco) {
      vs += "attribute vec2 a_normal; \n";
    } else {
      vs += "attribute vec3 a_normal; \n";
    }
  }
  if (hasBatchIds) {
    vs += "attribute float a_batchId; \n";
  }
  if (isQuantized || isQuantizedDraco || isOctEncodedDraco) {
    vs += "uniform vec4 u_quantizedVolumeScaleAndOctEncodedRange; \n";
  }
  if (hasColorStyle) {
    vs += colorStyleFunction;
  }
  if (hasShowStyle) {
    vs += showStyleFunction;
  }
  if (hasPointSizeStyle) {
    vs += pointSizeStyleFunction;
  }
  vs += "void main() \n{ \n    u_pointSize = u_pointSizeAndTimeAndGeometricErrorAndDepthMultiplier.x; \n    u_time = u_pointSizeAndTimeAndGeometricErrorAndDepthMultiplier.y; \n";
  if (attenuation) {
    vs += "    u_geometricError = u_pointSizeAndTimeAndGeometricErrorAndDepthMultiplier.z; \n    u_depthMultiplier = u_pointSizeAndTimeAndGeometricErrorAndDepthMultiplier.w; \n";
  }
  if (usesColors) {
    if (isTranslucent2) {
      vs += "    vec4 color = a_color; \n";
    } else if (isRGB565) {
      vs += "    float compressed = a_color; \n    float r = floor(compressed * SHIFT_RIGHT_11); \n    compressed -= r * SHIFT_LEFT_11; \n    float g = floor(compressed * SHIFT_RIGHT_5); \n    compressed -= g * SHIFT_LEFT_5; \n    float b = compressed; \n    vec3 rgb = vec3(r * NORMALIZE_5, g * NORMALIZE_6, b * NORMALIZE_5); \n    vec4 color = vec4(rgb, 1.0); \n";
    } else {
      vs += "    vec4 color = vec4(a_color, 1.0); \n";
    }
  } else {
    vs += "    vec4 color = u_constantColor; \n";
  }
  if (isQuantized || isQuantizedDraco) {
    vs += "    vec3 position = a_position * u_quantizedVolumeScaleAndOctEncodedRange.xyz; \n";
  } else {
    vs += "    vec3 position = a_position; \n";
  }
  vs += "    vec3 position_absolute = vec3(czm_model * vec4(position, 1.0)); \n";
  if (usesNormals) {
    if (isOctEncoded16P) {
      vs += "    vec3 normal = czm_octDecode(a_normal); \n";
    } else if (isOctEncodedDraco) {
      vs += "    vec3 normal = czm_octDecode(a_normal, u_quantizedVolumeScaleAndOctEncodedRange.w).zxy; \n";
    } else {
      vs += "    vec3 normal = a_normal; \n";
    }
    vs += "    vec3 normalEC = czm_normal * normal; \n";
  } else {
    vs += "    vec3 normal = vec3(1.0); \n";
  }
  if (hasColorStyle) {
    vs += "    color = getColorFromStyle(position, position_absolute, color, normal); \n";
  }
  if (hasShowStyle) {
    vs += "    float show = float(getShowFromStyle(position, position_absolute, color, normal)); \n";
  }
  if (hasPointSizeStyle) {
    vs += "    gl_PointSize = getPointSizeFromStyle(position, position_absolute, color, normal) * czm_pixelRatio; \n";
  } else if (attenuation) {
    vs += "    vec4 positionEC = czm_modelView * vec4(position, 1.0); \n    float depth = -positionEC.z; \n    gl_PointSize = min((u_geometricError / depth) * u_depthMultiplier, u_pointSize); \n";
  } else {
    vs += "    gl_PointSize = u_pointSize; \n";
  }
  vs += "    color = color * u_highlightColor; \n";
  if (usesNormals && normalShading) {
    vs += "    float diffuseStrength = czm_getLambertDiffuse(czm_lightDirectionEC, normalEC); \n    diffuseStrength = max(diffuseStrength, 0.4); \n    color.xyz *= diffuseStrength * czm_lightColor; \n";
  }
  vs += "    v_color = color; \n    gl_Position = czm_modelViewProjection * vec4(position, 1.0); \n";
  if (usesNormals && backFaceCulling) {
    vs += "    float visible = step(-normalEC.z, 0.0); \n    gl_Position *= visible; \n    gl_PointSize *= visible; \n";
  }
  if (hasShowStyle) {
    vs += "    gl_Position.w *= float(show); \n    gl_PointSize *= float(show); \n";
  }
  vs += "} \n";
  let fs = "varying vec4 v_color; \n";
  if (hasClippedContent) {
    fs += "uniform highp sampler2D u_clippingPlanes; \nuniform mat4 u_clippingPlanesMatrix; \nuniform vec4 u_clippingPlanesEdgeStyle; \n";
    fs += "\n";
    fs += getClippingFunction_default(clippingPlanes, context);
    fs += "\n";
  }
  fs += "void main() \n{ \n    gl_FragColor = czm_gammaCorrect(v_color); \n";
  if (hasClippedContent) {
    fs += getClipAndStyleCode_default(
      "u_clippingPlanes",
      "u_clippingPlanesMatrix",
      "u_clippingPlanesEdgeStyle"
    );
  }
  fs += "} \n";
  if (pointCloud.splitDirection !== SplitDirection_default.NONE) {
    fs = Splitter_default.modifyFragmentShader(fs);
  }
  if (defined_default(pointCloud._vertexShaderLoaded)) {
    vs = pointCloud._vertexShaderLoaded(vs);
  }
  if (defined_default(pointCloud._fragmentShaderLoaded)) {
    fs = pointCloud._fragmentShaderLoaded(fs);
  }
  const drawCommand = pointCloud._drawCommand;
  if (defined_default(drawCommand.shaderProgram)) {
    drawCommand.shaderProgram.destroy();
  }
  drawCommand.shaderProgram = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: vs,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations8
  });
  try {
    drawCommand.shaderProgram._bind();
  } catch (error) {
    throw new RuntimeError_default(
      "Error generating style shader: this may be caused by a type mismatch, index out-of-bounds, or other syntax error."
    );
  }
}
function decodeDraco(pointCloud, context) {
  if (pointCloud._decodingState === DecodingState.READY) {
    return false;
  }
  if (pointCloud._decodingState === DecodingState.NEEDS_DECODE) {
    const parsedContent = pointCloud._parsedContent;
    const draco = parsedContent.draco;
    const decodePromise = DracoLoader_default.decodePointCloud(draco, context);
    if (defined_default(decodePromise)) {
      pointCloud._decodingState = DecodingState.DECODING;
      decodePromise.then(function(result) {
        pointCloud._decodingState = DecodingState.READY;
        const decodedPositions = defined_default(result.POSITION) ? result.POSITION.array : void 0;
        const decodedRgb = defined_default(result.RGB) ? result.RGB.array : void 0;
        const decodedRgba = defined_default(result.RGBA) ? result.RGBA.array : void 0;
        const decodedNormals = defined_default(result.NORMAL) ? result.NORMAL.array : void 0;
        const decodedBatchIds = defined_default(result.BATCH_ID) ? result.BATCH_ID.array : void 0;
        const isQuantizedDraco = defined_default(decodedPositions) && defined_default(result.POSITION.data.quantization);
        const isOctEncodedDraco = defined_default(decodedNormals) && defined_default(result.NORMAL.data.quantization);
        if (isQuantizedDraco) {
          const quantization = result.POSITION.data.quantization;
          const range2 = quantization.range;
          pointCloud._quantizedVolumeScale = Cartesian3_default.fromElements(
            range2,
            range2,
            range2
          );
          pointCloud._quantizedVolumeOffset = Cartesian3_default.unpack(
            quantization.minValues
          );
          pointCloud._quantizedRange = (1 << quantization.quantizationBits) - 1;
          pointCloud._isQuantizedDraco = true;
        }
        if (isOctEncodedDraco) {
          pointCloud._octEncodedRange = (1 << result.NORMAL.data.quantization.quantizationBits) - 1;
          pointCloud._isOctEncodedDraco = true;
        }
        let styleableProperties = parsedContent.styleableProperties;
        const batchTableProperties = draco.batchTableProperties;
        for (const name in batchTableProperties) {
          if (batchTableProperties.hasOwnProperty(name)) {
            const property = result[name];
            if (!defined_default(styleableProperties)) {
              styleableProperties = {};
            }
            styleableProperties[name] = {
              typedArray: property.array,
              componentCount: property.data.componentsPerAttribute
            };
          }
        }
        if (defined_default(decodedPositions)) {
          parsedContent.positions = {
            typedArray: decodedPositions
          };
        }
        const decodedColors = defaultValue_default(decodedRgba, decodedRgb);
        if (defined_default(decodedColors)) {
          parsedContent.colors = {
            typedArray: decodedColors
          };
        }
        if (defined_default(decodedNormals)) {
          parsedContent.normals = {
            typedArray: decodedNormals
          };
        }
        if (defined_default(decodedBatchIds)) {
          parsedContent.batchIds = {
            typedArray: decodedBatchIds
          };
        }
        parsedContent.styleableProperties = styleableProperties;
      }).catch(function(error) {
        pointCloud._decodingState = DecodingState.FAILED;
        pointCloud._readyPromise.reject(error);
      });
    }
  }
  return true;
}
var scratchComputedTranslation3 = new Cartesian4_default();
var scratchScale3 = new Cartesian3_default();
PointCloud.prototype.update = function(frameState) {
  const context = frameState.context;
  const decoding = decodeDraco(this, context);
  if (decoding) {
    return;
  }
  let shadersDirty = false;
  let modelMatrixDirty = !Matrix4_default.equals(this._modelMatrix, this.modelMatrix);
  if (this._mode !== frameState.mode) {
    this._mode = frameState.mode;
    modelMatrixDirty = true;
  }
  if (!defined_default(this._drawCommand)) {
    createResources3(this, frameState);
    modelMatrixDirty = true;
    shadersDirty = true;
    this._ready = true;
    this._readyPromise.resolve(this);
    this._parsedContent = void 0;
  }
  if (modelMatrixDirty) {
    Matrix4_default.clone(this.modelMatrix, this._modelMatrix);
    const modelMatrix = this._drawCommand.modelMatrix;
    Matrix4_default.clone(this._modelMatrix, modelMatrix);
    if (defined_default(this._rtcCenter)) {
      Matrix4_default.multiplyByTranslation(modelMatrix, this._rtcCenter, modelMatrix);
    }
    if (defined_default(this._quantizedVolumeOffset)) {
      Matrix4_default.multiplyByTranslation(
        modelMatrix,
        this._quantizedVolumeOffset,
        modelMatrix
      );
    }
    if (frameState.mode !== SceneMode_default.SCENE3D) {
      const projection = frameState.mapProjection;
      const translation3 = Matrix4_default.getColumn(
        modelMatrix,
        3,
        scratchComputedTranslation3
      );
      if (!Cartesian4_default.equals(translation3, Cartesian4_default.UNIT_W)) {
        Transforms_default.basisTo2D(projection, modelMatrix, modelMatrix);
      }
    }
    const boundingSphere = this._drawCommand.boundingVolume;
    BoundingSphere_default.clone(this._boundingSphere, boundingSphere);
    if (this._cull) {
      const center = boundingSphere.center;
      Matrix4_default.multiplyByPoint(modelMatrix, center, center);
      const scale = Matrix4_default.getScale(modelMatrix, scratchScale3);
      boundingSphere.radius *= Cartesian3_default.maximumComponent(scale);
    }
  }
  if (this.clippingPlanesDirty) {
    this.clippingPlanesDirty = false;
    shadersDirty = true;
  }
  if (this._attenuation !== this.attenuation) {
    this._attenuation = this.attenuation;
    shadersDirty = true;
  }
  if (this.backFaceCulling !== this._backFaceCulling) {
    this._backFaceCulling = this.backFaceCulling;
    shadersDirty = true;
  }
  if (this.normalShading !== this._normalShading) {
    this._normalShading = this.normalShading;
    shadersDirty = true;
  }
  if (this._style !== this.style || this.styleDirty) {
    this._style = this.style;
    this.styleDirty = false;
    shadersDirty = true;
  }
  const splittingEnabled = this.splitDirection !== SplitDirection_default.NONE;
  if (this._splittingEnabled !== splittingEnabled) {
    this._splittingEnabled = splittingEnabled;
    shadersDirty = true;
  }
  if (shadersDirty) {
    createShaders2(this, frameState, this._style);
  }
  this._drawCommand.castShadows = ShadowMode_default.castShadows(this.shadows);
  this._drawCommand.receiveShadows = ShadowMode_default.receiveShadows(this.shadows);
  const isTranslucent2 = this._highlightColor.alpha < 1 || this._constantColor.alpha < 1 || this._styleTranslucent;
  this._drawCommand.renderState = isTranslucent2 ? this._translucentRenderState : this._opaqueRenderState;
  this._drawCommand.pass = isTranslucent2 ? Pass_default.TRANSLUCENT : this._opaquePass;
  const commandList = frameState.commandList;
  const passes = frameState.passes;
  if (passes.render || passes.pick) {
    commandList.push(this._drawCommand);
  }
};
PointCloud.prototype.isDestroyed = function() {
  return false;
};
PointCloud.prototype.destroy = function() {
  const command = this._drawCommand;
  if (defined_default(command)) {
    command.vertexArray = command.vertexArray && command.vertexArray.destroy();
    command.shaderProgram = command.shaderProgram && command.shaderProgram.destroy();
  }
  return destroyObject_default(this);
};
var PointCloud_default = PointCloud;

// node_modules/cesium/Source/Renderer/Framebuffer.js
function attachTexture(framebuffer, attachment, texture) {
  const gl = framebuffer._gl;
  gl.framebufferTexture2D(
    gl.FRAMEBUFFER,
    attachment,
    texture._target,
    texture._texture,
    0
  );
}
function attachRenderbuffer(framebuffer, attachment, renderbuffer) {
  const gl = framebuffer._gl;
  gl.framebufferRenderbuffer(
    gl.FRAMEBUFFER,
    attachment,
    gl.RENDERBUFFER,
    renderbuffer._getRenderbuffer()
  );
}
function Framebuffer(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const context = options.context;
  Check_default.defined("options.context", context);
  const gl = context._gl;
  const maximumColorAttachments = ContextLimits_default.maximumColorAttachments;
  this._gl = gl;
  this._framebuffer = gl.createFramebuffer();
  this._colorTextures = [];
  this._colorRenderbuffers = [];
  this._activeColorAttachments = [];
  this._depthTexture = void 0;
  this._depthRenderbuffer = void 0;
  this._stencilRenderbuffer = void 0;
  this._depthStencilTexture = void 0;
  this._depthStencilRenderbuffer = void 0;
  this.destroyAttachments = defaultValue_default(options.destroyAttachments, true);
  if (defined_default(options.colorTextures) && defined_default(options.colorRenderbuffers)) {
    throw new DeveloperError_default(
      "Cannot have both color texture and color renderbuffer attachments."
    );
  }
  if (defined_default(options.depthTexture) && defined_default(options.depthRenderbuffer)) {
    throw new DeveloperError_default(
      "Cannot have both a depth texture and depth renderbuffer attachment."
    );
  }
  if (defined_default(options.depthStencilTexture) && defined_default(options.depthStencilRenderbuffer)) {
    throw new DeveloperError_default(
      "Cannot have both a depth-stencil texture and depth-stencil renderbuffer attachment."
    );
  }
  const depthAttachment = defined_default(options.depthTexture) || defined_default(options.depthRenderbuffer);
  const depthStencilAttachment = defined_default(options.depthStencilTexture) || defined_default(options.depthStencilRenderbuffer);
  if (depthAttachment && depthStencilAttachment) {
    throw new DeveloperError_default(
      "Cannot have both a depth and depth-stencil attachment."
    );
  }
  if (defined_default(options.stencilRenderbuffer) && depthStencilAttachment) {
    throw new DeveloperError_default(
      "Cannot have both a stencil and depth-stencil attachment."
    );
  }
  if (depthAttachment && defined_default(options.stencilRenderbuffer)) {
    throw new DeveloperError_default(
      "Cannot have both a depth and stencil attachment."
    );
  }
  this._bind();
  let texture;
  let renderbuffer;
  let i2;
  let length3;
  let attachmentEnum;
  if (defined_default(options.colorTextures)) {
    const textures = options.colorTextures;
    length3 = this._colorTextures.length = this._activeColorAttachments.length = textures.length;
    if (length3 > maximumColorAttachments) {
      throw new DeveloperError_default(
        "The number of color attachments exceeds the number supported."
      );
    }
    for (i2 = 0; i2 < length3; ++i2) {
      texture = textures[i2];
      if (!PixelFormat_default.isColorFormat(texture.pixelFormat)) {
        throw new DeveloperError_default(
          "The color-texture pixel-format must be a color format."
        );
      }
      if (texture.pixelDatatype === PixelDatatype_default.FLOAT && !context.colorBufferFloat) {
        throw new DeveloperError_default(
          "The color texture pixel datatype is FLOAT and the WebGL implementation does not support the EXT_color_buffer_float or WEBGL_color_buffer_float extensions. See Context.colorBufferFloat."
        );
      }
      if (texture.pixelDatatype === PixelDatatype_default.HALF_FLOAT && !context.colorBufferHalfFloat) {
        throw new DeveloperError_default(
          "The color texture pixel datatype is HALF_FLOAT and the WebGL implementation does not support the EXT_color_buffer_half_float extension. See Context.colorBufferHalfFloat."
        );
      }
      attachmentEnum = this._gl.COLOR_ATTACHMENT0 + i2;
      attachTexture(this, attachmentEnum, texture);
      this._activeColorAttachments[i2] = attachmentEnum;
      this._colorTextures[i2] = texture;
    }
  }
  if (defined_default(options.colorRenderbuffers)) {
    const renderbuffers = options.colorRenderbuffers;
    length3 = this._colorRenderbuffers.length = this._activeColorAttachments.length = renderbuffers.length;
    if (length3 > maximumColorAttachments) {
      throw new DeveloperError_default(
        "The number of color attachments exceeds the number supported."
      );
    }
    for (i2 = 0; i2 < length3; ++i2) {
      renderbuffer = renderbuffers[i2];
      attachmentEnum = this._gl.COLOR_ATTACHMENT0 + i2;
      attachRenderbuffer(this, attachmentEnum, renderbuffer);
      this._activeColorAttachments[i2] = attachmentEnum;
      this._colorRenderbuffers[i2] = renderbuffer;
    }
  }
  if (defined_default(options.depthTexture)) {
    texture = options.depthTexture;
    if (texture.pixelFormat !== PixelFormat_default.DEPTH_COMPONENT) {
      throw new DeveloperError_default(
        "The depth-texture pixel-format must be DEPTH_COMPONENT."
      );
    }
    attachTexture(this, this._gl.DEPTH_ATTACHMENT, texture);
    this._depthTexture = texture;
  }
  if (defined_default(options.depthRenderbuffer)) {
    renderbuffer = options.depthRenderbuffer;
    attachRenderbuffer(this, this._gl.DEPTH_ATTACHMENT, renderbuffer);
    this._depthRenderbuffer = renderbuffer;
  }
  if (defined_default(options.stencilRenderbuffer)) {
    renderbuffer = options.stencilRenderbuffer;
    attachRenderbuffer(this, this._gl.STENCIL_ATTACHMENT, renderbuffer);
    this._stencilRenderbuffer = renderbuffer;
  }
  if (defined_default(options.depthStencilTexture)) {
    texture = options.depthStencilTexture;
    if (texture.pixelFormat !== PixelFormat_default.DEPTH_STENCIL) {
      throw new DeveloperError_default(
        "The depth-stencil pixel-format must be DEPTH_STENCIL."
      );
    }
    attachTexture(this, this._gl.DEPTH_STENCIL_ATTACHMENT, texture);
    this._depthStencilTexture = texture;
  }
  if (defined_default(options.depthStencilRenderbuffer)) {
    renderbuffer = options.depthStencilRenderbuffer;
    attachRenderbuffer(this, this._gl.DEPTH_STENCIL_ATTACHMENT, renderbuffer);
    this._depthStencilRenderbuffer = renderbuffer;
  }
  this._unBind();
}
Object.defineProperties(Framebuffer.prototype, {
  status: {
    get: function() {
      this._bind();
      const status = this._gl.checkFramebufferStatus(this._gl.FRAMEBUFFER);
      this._unBind();
      return status;
    }
  },
  numberOfColorAttachments: {
    get: function() {
      return this._activeColorAttachments.length;
    }
  },
  depthTexture: {
    get: function() {
      return this._depthTexture;
    }
  },
  depthRenderbuffer: {
    get: function() {
      return this._depthRenderbuffer;
    }
  },
  stencilRenderbuffer: {
    get: function() {
      return this._stencilRenderbuffer;
    }
  },
  depthStencilTexture: {
    get: function() {
      return this._depthStencilTexture;
    }
  },
  depthStencilRenderbuffer: {
    get: function() {
      return this._depthStencilRenderbuffer;
    }
  },
  hasDepthAttachment: {
    get: function() {
      return !!(this.depthTexture || this.depthRenderbuffer || this.depthStencilTexture || this.depthStencilRenderbuffer);
    }
  }
});
Framebuffer.prototype._bind = function() {
  const gl = this._gl;
  gl.bindFramebuffer(gl.FRAMEBUFFER, this._framebuffer);
};
Framebuffer.prototype._unBind = function() {
  const gl = this._gl;
  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
};
Framebuffer.prototype.bindDraw = function() {
  const gl = this._gl;
  gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this._framebuffer);
};
Framebuffer.prototype.bindRead = function() {
  const gl = this._gl;
  gl.bindFramebuffer(gl.READ_FRAMEBUFFER, this._framebuffer);
};
Framebuffer.prototype._getActiveColorAttachments = function() {
  return this._activeColorAttachments;
};
Framebuffer.prototype.getColorTexture = function(index2) {
  if (!defined_default(index2) || index2 < 0 || index2 >= this._colorTextures.length) {
    throw new DeveloperError_default(
      "index is required, must be greater than or equal to zero and must be less than the number of color attachments."
    );
  }
  return this._colorTextures[index2];
};
Framebuffer.prototype.getColorRenderbuffer = function(index2) {
  if (!defined_default(index2) || index2 < 0 || index2 >= this._colorRenderbuffers.length) {
    throw new DeveloperError_default(
      "index is required, must be greater than or equal to zero and must be less than the number of color attachments."
    );
  }
  return this._colorRenderbuffers[index2];
};
Framebuffer.prototype.isDestroyed = function() {
  return false;
};
Framebuffer.prototype.destroy = function() {
  if (this.destroyAttachments) {
    let i2 = 0;
    const textures = this._colorTextures;
    let length3 = textures.length;
    for (; i2 < length3; ++i2) {
      const texture = textures[i2];
      if (defined_default(texture)) {
        texture.destroy();
      }
    }
    const renderbuffers = this._colorRenderbuffers;
    length3 = renderbuffers.length;
    for (i2 = 0; i2 < length3; ++i2) {
      const renderbuffer = renderbuffers[i2];
      if (defined_default(renderbuffer)) {
        renderbuffer.destroy();
      }
    }
    this._depthTexture = this._depthTexture && this._depthTexture.destroy();
    this._depthRenderbuffer = this._depthRenderbuffer && this._depthRenderbuffer.destroy();
    this._stencilRenderbuffer = this._stencilRenderbuffer && this._stencilRenderbuffer.destroy();
    this._depthStencilTexture = this._depthStencilTexture && this._depthStencilTexture.destroy();
    this._depthStencilRenderbuffer = this._depthStencilRenderbuffer && this._depthStencilRenderbuffer.destroy();
  }
  this._gl.deleteFramebuffer(this._framebuffer);
  return destroyObject_default(this);
};
var Framebuffer_default = Framebuffer;

// node_modules/cesium/Source/Renderer/MultisampleFramebuffer.js
function MultisampleFramebuffer(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const context = options.context;
  const width = options.width;
  const height = options.height;
  Check_default.defined("options.context", context);
  Check_default.defined("options.width", width);
  Check_default.defined("options.height", height);
  this._width = width;
  this._height = height;
  const colorRenderbuffers = options.colorRenderbuffers;
  const colorTextures = options.colorTextures;
  if (defined_default(colorRenderbuffers) !== defined_default(colorTextures)) {
    throw new DeveloperError_default(
      "Both color renderbuffer and texture attachments must be provided."
    );
  }
  const depthStencilRenderbuffer = options.depthStencilRenderbuffer;
  const depthStencilTexture = options.depthStencilTexture;
  if (defined_default(depthStencilRenderbuffer) !== defined_default(depthStencilTexture)) {
    throw new DeveloperError_default(
      "Both depth-stencil renderbuffer and texture attachments must be provided."
    );
  }
  this._renderFramebuffer = new Framebuffer_default({
    context,
    colorRenderbuffers,
    depthStencilRenderbuffer,
    destroyAttachments: options.destroyAttachments
  });
  this._colorFramebuffer = new Framebuffer_default({
    context,
    colorTextures,
    depthStencilTexture,
    destroyAttachments: options.destroyAttachments
  });
}
MultisampleFramebuffer.prototype.getRenderFramebuffer = function() {
  return this._renderFramebuffer;
};
MultisampleFramebuffer.prototype.getColorFramebuffer = function() {
  return this._colorFramebuffer;
};
MultisampleFramebuffer.prototype.blitFramebuffers = function(context, blitStencil) {
  this._renderFramebuffer.bindRead();
  this._colorFramebuffer.bindDraw();
  const gl = context._gl;
  let mask = 0;
  if (this._colorFramebuffer._colorTextures.length > 0) {
    mask |= gl.COLOR_BUFFER_BIT;
  }
  if (defined_default(this._colorFramebuffer.depthStencilTexture)) {
    mask |= gl.DEPTH_BUFFER_BIT | (blitStencil ? gl.STENCIL_BUFFER_BIT : 0);
  }
  gl.blitFramebuffer(
    0,
    0,
    this._width,
    this._height,
    0,
    0,
    this._width,
    this._height,
    mask,
    gl.NEAREST
  );
  gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null);
  gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
};
MultisampleFramebuffer.prototype.isDestroyed = function() {
  return false;
};
MultisampleFramebuffer.prototype.destroy = function() {
  this._renderFramebuffer.destroy();
  this._colorFramebuffer.destroy();
  return destroyObject_default(this);
};
var MultisampleFramebuffer_default = MultisampleFramebuffer;

// node_modules/cesium/Source/Renderer/RenderbufferFormat.js
var RenderbufferFormat = {
  RGBA4: WebGLConstants_default.RGBA4,
  RGBA8: WebGLConstants_default.RGBA8,
  RGBA16F: WebGLConstants_default.RGBA16F,
  RGBA32F: WebGLConstants_default.RGBA32F,
  RGB5_A1: WebGLConstants_default.RGB5_A1,
  RGB565: WebGLConstants_default.RGB565,
  DEPTH_COMPONENT16: WebGLConstants_default.DEPTH_COMPONENT16,
  STENCIL_INDEX8: WebGLConstants_default.STENCIL_INDEX8,
  DEPTH_STENCIL: WebGLConstants_default.DEPTH_STENCIL,
  DEPTH24_STENCIL8: WebGLConstants_default.DEPTH24_STENCIL8,
  validate: function(renderbufferFormat) {
    return renderbufferFormat === RenderbufferFormat.RGBA4 || renderbufferFormat === RenderbufferFormat.RGBA8 || renderbufferFormat === RenderbufferFormat.RGBA16F || renderbufferFormat === RenderbufferFormat.RGBA32F || renderbufferFormat === RenderbufferFormat.RGB5_A1 || renderbufferFormat === RenderbufferFormat.RGB565 || renderbufferFormat === RenderbufferFormat.DEPTH_COMPONENT16 || renderbufferFormat === RenderbufferFormat.STENCIL_INDEX8 || renderbufferFormat === RenderbufferFormat.DEPTH_STENCIL || renderbufferFormat === RenderbufferFormat.DEPTH24_STENCIL8;
  },
  getColorFormat: function(datatype) {
    if (datatype === WebGLConstants_default.FLOAT) {
      return RenderbufferFormat.RGBA32F;
    } else if (datatype === WebGLConstants_default.HALF_FLOAT_OES) {
      return RenderbufferFormat.RGBA16F;
    }
    return RenderbufferFormat.RGBA8;
  }
};
var RenderbufferFormat_default = Object.freeze(RenderbufferFormat);

// node_modules/cesium/Source/Renderer/Renderbuffer.js
function Renderbuffer(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.context", options.context);
  const context = options.context;
  const gl = context._gl;
  const maximumRenderbufferSize = ContextLimits_default.maximumRenderbufferSize;
  const format = defaultValue_default(options.format, RenderbufferFormat_default.RGBA4);
  const width = defined_default(options.width) ? options.width : gl.drawingBufferWidth;
  const height = defined_default(options.height) ? options.height : gl.drawingBufferHeight;
  const numSamples = defaultValue_default(options.numSamples, 1);
  if (!RenderbufferFormat_default.validate(format)) {
    throw new DeveloperError_default("Invalid format.");
  }
  Check_default.typeOf.number.greaterThan("width", width, 0);
  if (width > maximumRenderbufferSize) {
    throw new DeveloperError_default(
      `Width must be less than or equal to the maximum renderbuffer size (${maximumRenderbufferSize}).  Check maximumRenderbufferSize.`
    );
  }
  Check_default.typeOf.number.greaterThan("height", height, 0);
  if (height > maximumRenderbufferSize) {
    throw new DeveloperError_default(
      `Height must be less than or equal to the maximum renderbuffer size (${maximumRenderbufferSize}).  Check maximumRenderbufferSize.`
    );
  }
  this._gl = gl;
  this._format = format;
  this._width = width;
  this._height = height;
  this._renderbuffer = this._gl.createRenderbuffer();
  gl.bindRenderbuffer(gl.RENDERBUFFER, this._renderbuffer);
  if (numSamples > 1) {
    gl.renderbufferStorageMultisample(
      gl.RENDERBUFFER,
      numSamples,
      format,
      width,
      height
    );
  } else {
    gl.renderbufferStorage(gl.RENDERBUFFER, format, width, height);
  }
  gl.bindRenderbuffer(gl.RENDERBUFFER, null);
}
Object.defineProperties(Renderbuffer.prototype, {
  format: {
    get: function() {
      return this._format;
    }
  },
  width: {
    get: function() {
      return this._width;
    }
  },
  height: {
    get: function() {
      return this._height;
    }
  }
});
Renderbuffer.prototype._getRenderbuffer = function() {
  return this._renderbuffer;
};
Renderbuffer.prototype.isDestroyed = function() {
  return false;
};
Renderbuffer.prototype.destroy = function() {
  this._gl.deleteRenderbuffer(this._renderbuffer);
  return destroyObject_default(this);
};
var Renderbuffer_default = Renderbuffer;

// node_modules/cesium/Source/Renderer/FramebufferManager.js
function FramebufferManager(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._numSamples = defaultValue_default(options.numSamples, 1);
  this._colorAttachmentsLength = defaultValue_default(
    options.colorAttachmentsLength,
    1
  );
  this._color = defaultValue_default(options.color, true);
  this._depth = defaultValue_default(options.depth, false);
  this._depthStencil = defaultValue_default(options.depthStencil, false);
  this._supportsDepthTexture = defaultValue_default(
    options.supportsDepthTexture,
    false
  );
  if (!this._color && !this._depth && !this._depthStencil) {
    throw new DeveloperError_default(
      "Must enable at least one type of framebuffer attachment."
    );
  }
  if (this._depth && this._depthStencil) {
    throw new DeveloperError_default(
      "Cannot have both a depth and depth-stencil attachment."
    );
  }
  this._createColorAttachments = defaultValue_default(
    options.createColorAttachments,
    true
  );
  this._createDepthAttachments = defaultValue_default(
    options.createDepthAttachments,
    true
  );
  this._pixelDatatype = options.pixelDatatype;
  this._pixelFormat = options.pixelFormat;
  this._width = void 0;
  this._height = void 0;
  this._framebuffer = void 0;
  this._multisampleFramebuffer = void 0;
  this._colorTextures = void 0;
  if (this._color) {
    this._colorTextures = new Array(this._colorAttachmentsLength);
    this._colorRenderbuffers = new Array(this._colorAttachmentsLength);
  }
  this._colorRenderbuffer = void 0;
  this._depthStencilRenderbuffer = void 0;
  this._depthStencilTexture = void 0;
  this._depthRenderbuffer = void 0;
  this._depthTexture = void 0;
  this._attachmentsDirty = false;
}
Object.defineProperties(FramebufferManager.prototype, {
  framebuffer: {
    get: function() {
      if (this._numSamples > 1) {
        return this._multisampleFramebuffer.getRenderFramebuffer();
      }
      return this._framebuffer;
    }
  },
  numSamples: {
    get: function() {
      return this._numSamples;
    }
  },
  status: {
    get: function() {
      return this.framebuffer.status;
    }
  }
});
FramebufferManager.prototype.isDirty = function(width, height, numSamples, pixelDatatype, pixelFormat) {
  numSamples = defaultValue_default(numSamples, 1);
  const dimensionChanged = this._width !== width || this._height !== height;
  const samplesChanged = this._numSamples !== numSamples;
  const pixelChanged = defined_default(pixelDatatype) && this._pixelDatatype !== pixelDatatype || defined_default(pixelFormat) && this._pixelFormat !== pixelFormat;
  const framebufferDefined = numSamples === 1 ? defined_default(this._framebuffer) : defined_default(this._multisampleFramebuffer);
  return this._attachmentsDirty || dimensionChanged || samplesChanged || pixelChanged || !framebufferDefined || this._color && !defined_default(this._colorTextures[0]);
};
FramebufferManager.prototype.update = function(context, width, height, numSamples, pixelDatatype, pixelFormat) {
  if (!defined_default(width) || !defined_default(height)) {
    throw new DeveloperError_default("width and height must be defined.");
  }
  numSamples = context.msaa ? defaultValue_default(numSamples, 1) : 1;
  pixelDatatype = defaultValue_default(
    pixelDatatype,
    this._color ? defaultValue_default(this._pixelDatatype, PixelDatatype_default.UNSIGNED_BYTE) : void 0
  );
  pixelFormat = defaultValue_default(
    pixelFormat,
    this._color ? defaultValue_default(this._pixelFormat, PixelFormat_default.RGBA) : void 0
  );
  if (this.isDirty(width, height, numSamples, pixelDatatype, pixelFormat)) {
    this.destroy();
    this._width = width;
    this._height = height;
    this._numSamples = numSamples;
    this._pixelDatatype = pixelDatatype;
    this._pixelFormat = pixelFormat;
    this._attachmentsDirty = false;
    if (this._color && this._createColorAttachments) {
      for (let i2 = 0; i2 < this._colorAttachmentsLength; ++i2) {
        this._colorTextures[i2] = new Texture_default({
          context,
          width,
          height,
          pixelFormat,
          pixelDatatype,
          sampler: Sampler_default.NEAREST
        });
        if (this._numSamples > 1) {
          const format = RenderbufferFormat_default.getColorFormat(pixelDatatype);
          this._colorRenderbuffers[i2] = new Renderbuffer_default({
            context,
            width,
            height,
            format,
            numSamples: this._numSamples
          });
        }
      }
    }
    if (this._depthStencil && this._createDepthAttachments) {
      if (this._supportsDepthTexture && context.depthTexture) {
        this._depthStencilTexture = new Texture_default({
          context,
          width,
          height,
          pixelFormat: PixelFormat_default.DEPTH_STENCIL,
          pixelDatatype: PixelDatatype_default.UNSIGNED_INT_24_8,
          sampler: Sampler_default.NEAREST
        });
        if (this._numSamples > 1) {
          this._depthStencilRenderbuffer = new Renderbuffer_default({
            context,
            width,
            height,
            format: RenderbufferFormat_default.DEPTH24_STENCIL8,
            numSamples: this._numSamples
          });
        }
      } else {
        this._depthStencilRenderbuffer = new Renderbuffer_default({
          context,
          width,
          height,
          format: RenderbufferFormat_default.DEPTH_STENCIL
        });
      }
    }
    if (this._depth && this._createDepthAttachments) {
      if (this._supportsDepthTexture && context.depthTexture) {
        this._depthTexture = new Texture_default({
          context,
          width,
          height,
          pixelFormat: PixelFormat_default.DEPTH_COMPONENT,
          pixelDatatype: PixelDatatype_default.UNSIGNED_INT,
          sampler: Sampler_default.NEAREST
        });
      } else {
        this._depthRenderbuffer = new Renderbuffer_default({
          context,
          width,
          height,
          format: RenderbufferFormat_default.DEPTH_COMPONENT16
        });
      }
    }
    if (this._numSamples > 1) {
      this._multisampleFramebuffer = new MultisampleFramebuffer_default({
        context,
        width: this._width,
        height: this._height,
        colorTextures: this._colorTextures,
        colorRenderbuffers: this._colorRenderbuffers,
        depthStencilTexture: this._depthStencilTexture,
        depthStencilRenderbuffer: this._depthStencilRenderbuffer,
        destroyAttachments: false
      });
    } else {
      this._framebuffer = new Framebuffer_default({
        context,
        colorTextures: this._colorTextures,
        depthTexture: this._depthTexture,
        depthRenderbuffer: this._depthRenderbuffer,
        depthStencilTexture: this._depthStencilTexture,
        depthStencilRenderbuffer: this._depthStencilRenderbuffer,
        destroyAttachments: false
      });
    }
  }
};
FramebufferManager.prototype.getColorTexture = function(index2) {
  index2 = defaultValue_default(index2, 0);
  if (index2 >= this._colorAttachmentsLength) {
    throw new DeveloperError_default(
      "index must be smaller than total number of color attachments."
    );
  }
  return this._colorTextures[index2];
};
FramebufferManager.prototype.setColorTexture = function(texture, index2) {
  index2 = defaultValue_default(index2, 0);
  if (this._createColorAttachments) {
    throw new DeveloperError_default(
      "createColorAttachments must be false if setColorTexture is called."
    );
  }
  if (index2 >= this._colorAttachmentsLength) {
    throw new DeveloperError_default(
      "index must be smaller than total number of color attachments."
    );
  }
  this._attachmentsDirty = texture !== this._colorTextures[index2];
  this._colorTextures[index2] = texture;
};
FramebufferManager.prototype.getColorRenderbuffer = function(index2) {
  index2 = defaultValue_default(index2, 0);
  if (index2 >= this._colorAttachmentsLength) {
    throw new DeveloperError_default(
      "index must be smaller than total number of color attachments."
    );
  }
  return this._colorRenderbuffers[index2];
};
FramebufferManager.prototype.setColorRenderbuffer = function(renderbuffer, index2) {
  index2 = defaultValue_default(index2, 0);
  if (this._createColorAttachments) {
    throw new DeveloperError_default(
      "createColorAttachments must be false if setColorRenderbuffer is called."
    );
  }
  if (index2 >= this._colorAttachmentsLength) {
    throw new DeveloperError_default(
      "index must be smaller than total number of color attachments."
    );
  }
  this._attachmentsDirty = renderbuffer !== this._colorRenderbuffers[index2];
  this._colorRenderbuffers[index2] = renderbuffer;
};
FramebufferManager.prototype.getDepthRenderbuffer = function() {
  return this._depthRenderbuffer;
};
FramebufferManager.prototype.setDepthRenderbuffer = function(renderbuffer) {
  if (this._createDepthAttachments) {
    throw new DeveloperError_default(
      "createDepthAttachments must be false if setDepthRenderbuffer is called."
    );
  }
  this._attachmentsDirty = renderbuffer !== this._depthRenderbuffer;
  this._depthRenderbuffer = renderbuffer;
};
FramebufferManager.prototype.getDepthTexture = function() {
  return this._depthTexture;
};
FramebufferManager.prototype.setDepthTexture = function(texture) {
  if (this._createDepthAttachments) {
    throw new DeveloperError_default(
      "createDepthAttachments must be false if setDepthTexture is called."
    );
  }
  this._attachmentsDirty = texture !== this._depthTexture;
  this._depthTexture = texture;
};
FramebufferManager.prototype.getDepthStencilRenderbuffer = function() {
  return this._depthStencilRenderbuffer;
};
FramebufferManager.prototype.setDepthStencilRenderbuffer = function(renderbuffer) {
  if (this._createDepthAttachments) {
    throw new DeveloperError_default(
      "createDepthAttachments must be false if setDepthStencilRenderbuffer is called."
    );
  }
  this._attachmentsDirty = renderbuffer !== this._depthStencilRenderbuffer;
  this._depthStencilRenderbuffer = renderbuffer;
};
FramebufferManager.prototype.getDepthStencilTexture = function() {
  return this._depthStencilTexture;
};
FramebufferManager.prototype.setDepthStencilTexture = function(texture) {
  if (this._createDepthAttachments) {
    throw new DeveloperError_default(
      "createDepthAttachments must be false if setDepthStencilTexture is called."
    );
  }
  this._attachmentsDirty = texture !== this._depthStencilTexture;
  this._depthStencilTexture = texture;
};
FramebufferManager.prototype.prepareTextures = function(context, blitStencil) {
  if (this._numSamples > 1) {
    this._multisampleFramebuffer.blitFramebuffers(context, blitStencil);
  }
};
FramebufferManager.prototype.clear = function(context, clearCommand, passState) {
  const framebuffer = clearCommand.framebuffer;
  clearCommand.framebuffer = this.framebuffer;
  clearCommand.execute(context, passState);
  clearCommand.framebuffer = framebuffer;
};
FramebufferManager.prototype.destroyFramebuffer = function() {
  this._framebuffer = this._framebuffer && this._framebuffer.destroy();
  this._multisampleFramebuffer = this._multisampleFramebuffer && this._multisampleFramebuffer.destroy();
};
FramebufferManager.prototype.destroy = function() {
  if (this._color) {
    let i2;
    const length3 = this._colorTextures.length;
    for (i2 = 0; i2 < length3; ++i2) {
      const texture = this._colorTextures[i2];
      if (this._createColorAttachments) {
        if (defined_default(texture) && !texture.isDestroyed()) {
          this._colorTextures[i2].destroy();
          this._colorTextures[i2] = void 0;
        }
      }
      if (defined_default(texture) && texture.isDestroyed()) {
        this._colorTextures[i2] = void 0;
      }
      const renderbuffer = this._colorRenderbuffers[i2];
      if (this._createColorAttachments) {
        if (defined_default(renderbuffer) && !renderbuffer.isDestroyed()) {
          this._colorRenderbuffers[i2].destroy();
          this._colorRenderbuffers[i2] = void 0;
        }
      }
      if (defined_default(renderbuffer) && renderbuffer.isDestroyed()) {
        this._colorRenderbuffers[i2] = void 0;
      }
    }
  }
  if (this._depthStencil) {
    if (this._createDepthAttachments) {
      this._depthStencilTexture = this._depthStencilTexture && this._depthStencilTexture.destroy();
      this._depthStencilRenderbuffer = this._depthStencilRenderbuffer && this._depthStencilRenderbuffer.destroy();
    }
    if (defined_default(this._depthStencilTexture) && this._depthStencilTexture.isDestroyed()) {
      this._depthStencilTexture = void 0;
    }
    if (defined_default(this._depthStencilRenderbuffer) && this._depthStencilRenderbuffer.isDestroyed()) {
      this._depthStencilRenderbuffer = void 0;
    }
  }
  if (this._depth) {
    if (this._createDepthAttachments) {
      this._depthTexture = this._depthTexture && this._depthTexture.destroy();
      this._depthRenderbuffer = this._depthRenderbuffer && this._depthRenderbuffer.destroy();
    }
    if (defined_default(this._depthTexture) && this._depthTexture.isDestroyed()) {
      this._depthTexture = void 0;
    }
    if (defined_default(this._depthRenderbuffer) && this._depthRenderbuffer.isDestroyed()) {
      this._depthRenderbuffer = void 0;
    }
  }
  this.destroyFramebuffer();
};
var FramebufferManager_default = FramebufferManager;

// node_modules/cesium/Source/Shaders/PostProcessStages/PointCloudEyeDomeLighting.js
var PointCloudEyeDomeLighting_default = "#extension GL_EXT_frag_depth : enable\n\nuniform sampler2D u_pointCloud_colorGBuffer;\nuniform sampler2D u_pointCloud_depthGBuffer;\nuniform vec2 u_distanceAndEdlStrength;\nvarying vec2 v_textureCoordinates;\n\nvec2 neighborContribution(float log2Depth, vec2 offset)\n{\n    float dist = u_distanceAndEdlStrength.x;\n    vec2 texCoordOrig = v_textureCoordinates + offset * dist;\n    vec2 texCoord0 = v_textureCoordinates + offset * floor(dist);\n    vec2 texCoord1 = v_textureCoordinates + offset * ceil(dist);\n\n    float depthOrLogDepth0 = czm_unpackDepth(texture2D(u_pointCloud_depthGBuffer, texCoord0));\n    float depthOrLogDepth1 = czm_unpackDepth(texture2D(u_pointCloud_depthGBuffer, texCoord1));\n\n    // ignore depth values that are the clear depth\n    if (depthOrLogDepth0 == 0.0 || depthOrLogDepth1 == 0.0) {\n        return vec2(0.0);\n    }\n\n    // interpolate the two adjacent depth values\n    float depthMix = mix(depthOrLogDepth0, depthOrLogDepth1, fract(dist));\n    vec4 eyeCoordinate = czm_windowToEyeCoordinates(texCoordOrig, depthMix);\n    return vec2(max(0.0, log2Depth - log2(-eyeCoordinate.z / eyeCoordinate.w)), 1.0);\n}\n\nvoid main()\n{\n    float depthOrLogDepth = czm_unpackDepth(texture2D(u_pointCloud_depthGBuffer, v_textureCoordinates));\n\n    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, depthOrLogDepth);\n    eyeCoordinate /= eyeCoordinate.w;\n\n    float log2Depth = log2(-eyeCoordinate.z);\n\n    if (depthOrLogDepth == 0.0) // 0.0 is the clear value for the gbuffer\n    {\n        discard;\n    }\n\n    vec4 color = texture2D(u_pointCloud_colorGBuffer, v_textureCoordinates);\n\n    // sample from neighbors left, right, down, up\n    vec2 texelSize = 1.0 / czm_viewport.zw;\n\n    vec2 responseAndCount = vec2(0.0);\n\n    responseAndCount += neighborContribution(log2Depth, vec2(-texelSize.x, 0.0));\n    responseAndCount += neighborContribution(log2Depth, vec2(+texelSize.x, 0.0));\n    responseAndCount += neighborContribution(log2Depth, vec2(0.0, -texelSize.y));\n    responseAndCount += neighborContribution(log2Depth, vec2(0.0, +texelSize.y));\n\n    float response = responseAndCount.x / responseAndCount.y;\n    float strength = u_distanceAndEdlStrength.y;\n    float shade = exp(-response * 300.0 * strength);\n    color.rgb *= shade;\n    gl_FragColor = vec4(color);\n\n    // Input and output depth are the same.\n    gl_FragDepthEXT = depthOrLogDepth;\n}\n";

// node_modules/cesium/Source/Scene/PointCloudEyeDomeLighting.js
function PointCloudEyeDomeLighting() {
  this._framebuffer = new FramebufferManager_default({
    colorAttachmentsLength: 2,
    depth: true,
    supportsDepthTexture: true
  });
  this._drawCommand = void 0;
  this._clearCommand = void 0;
  this._strength = 1;
  this._radius = 1;
}
Object.defineProperties(PointCloudEyeDomeLighting.prototype, {
  framebuffer: {
    get: function() {
      return this._framebuffer.framebuffer;
    }
  },
  colorGBuffer: {
    get: function() {
      return this._framebuffer.getColorTexture(0);
    }
  },
  depthGBuffer: {
    get: function() {
      return this._framebuffer.getColorTexture(1);
    }
  }
});
function destroyFramebuffer(processor) {
  processor._framebuffer.destroy();
  processor._drawCommand = void 0;
  processor._clearCommand = void 0;
}
var distanceAndEdlStrengthScratch = new Cartesian2_default();
function createCommands5(processor, context) {
  const blendFS = new ShaderSource_default({
    defines: ["LOG_DEPTH_WRITE"],
    sources: [PointCloudEyeDomeLighting_default]
  });
  const blendUniformMap = {
    u_pointCloud_colorGBuffer: function() {
      return processor.colorGBuffer;
    },
    u_pointCloud_depthGBuffer: function() {
      return processor.depthGBuffer;
    },
    u_distanceAndEdlStrength: function() {
      distanceAndEdlStrengthScratch.x = processor._radius;
      distanceAndEdlStrengthScratch.y = processor._strength;
      return distanceAndEdlStrengthScratch;
    }
  };
  const blendRenderState = RenderState_default.fromCache({
    blending: BlendingState_default.ALPHA_BLEND,
    depthMask: true,
    depthTest: {
      enabled: true
    },
    stencilTest: StencilConstants_default.setCesium3DTileBit(),
    stencilMask: StencilConstants_default.CESIUM_3D_TILE_MASK
  });
  processor._drawCommand = context.createViewportQuadCommand(blendFS, {
    uniformMap: blendUniformMap,
    renderState: blendRenderState,
    pass: Pass_default.CESIUM_3D_TILE,
    owner: processor
  });
  processor._clearCommand = new ClearCommand_default({
    framebuffer: processor.framebuffer,
    color: new Color_default(0, 0, 0, 0),
    depth: 1,
    renderState: RenderState_default.fromCache(),
    pass: Pass_default.CESIUM_3D_TILE,
    owner: processor
  });
}
function createResources4(processor, context) {
  const width = context.drawingBufferWidth;
  const height = context.drawingBufferHeight;
  processor._framebuffer.update(context, width, height);
  createCommands5(processor, context);
}
function isSupported(context) {
  return context.drawBuffers && context.fragmentDepth;
}
PointCloudEyeDomeLighting.isSupported = isSupported;
function getECShaderProgram(context, shaderProgram) {
  let shader = context.shaderCache.getDerivedShaderProgram(shaderProgram, "EC");
  if (!defined_default(shader)) {
    const attributeLocations8 = shaderProgram._attributeLocations;
    const fs = shaderProgram.fragmentShaderSource.clone();
    fs.sources = fs.sources.map(function(source) {
      source = ShaderSource_default.replaceMain(
        source,
        "czm_point_cloud_post_process_main"
      );
      source = source.replace(/gl_FragColor/g, "gl_FragData[0]");
      return source;
    });
    fs.sources.unshift("#extension GL_EXT_draw_buffers : enable \n");
    fs.sources.push(
      "void main() \n{ \n    czm_point_cloud_post_process_main(); \n#ifdef LOG_DEPTH\n    czm_writeLogDepth();\n    gl_FragData[1] = czm_packDepth(gl_FragDepthEXT); \n#else\n    gl_FragData[1] = czm_packDepth(gl_FragCoord.z);\n#endif\n}"
    );
    shader = context.shaderCache.createDerivedShaderProgram(
      shaderProgram,
      "EC",
      {
        vertexShaderSource: shaderProgram.vertexShaderSource,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations8
      }
    );
  }
  return shader;
}
PointCloudEyeDomeLighting.prototype.update = function(frameState, commandStart, pointCloudShading, boundingVolume) {
  if (!isSupported(frameState.context)) {
    return;
  }
  this._strength = pointCloudShading.eyeDomeLightingStrength;
  this._radius = pointCloudShading.eyeDomeLightingRadius * frameState.pixelRatio;
  createResources4(this, frameState.context);
  let i2;
  const commandList = frameState.commandList;
  const commandEnd = commandList.length;
  for (i2 = commandStart; i2 < commandEnd; ++i2) {
    const command = commandList[i2];
    if (command.primitiveType !== PrimitiveType_default.POINTS || command.pass === Pass_default.TRANSLUCENT) {
      continue;
    }
    let derivedCommand;
    let originalShaderProgram;
    let derivedCommandObject = command.derivedCommands.pointCloudProcessor;
    if (defined_default(derivedCommandObject)) {
      derivedCommand = derivedCommandObject.command;
      originalShaderProgram = derivedCommandObject.originalShaderProgram;
    }
    if (!defined_default(derivedCommand) || command.dirty || originalShaderProgram !== command.shaderProgram || derivedCommand.framebuffer !== this.framebuffer) {
      derivedCommand = DrawCommand_default.shallowClone(command, derivedCommand);
      derivedCommand.framebuffer = this.framebuffer;
      derivedCommand.shaderProgram = getECShaderProgram(
        frameState.context,
        command.shaderProgram
      );
      derivedCommand.castShadows = false;
      derivedCommand.receiveShadows = false;
      if (!defined_default(derivedCommandObject)) {
        derivedCommandObject = {
          command: derivedCommand,
          originalShaderProgram: command.shaderProgram
        };
        command.derivedCommands.pointCloudProcessor = derivedCommandObject;
      }
      derivedCommandObject.originalShaderProgram = command.shaderProgram;
    }
    commandList[i2] = derivedCommand;
  }
  const clearCommand = this._clearCommand;
  const blendCommand = this._drawCommand;
  blendCommand.boundingVolume = boundingVolume;
  commandList.push(blendCommand);
  commandList.push(clearCommand);
};
PointCloudEyeDomeLighting.prototype.isDestroyed = function() {
  return false;
};
PointCloudEyeDomeLighting.prototype.destroy = function() {
  destroyFramebuffer(this);
  return destroyObject_default(this);
};
var PointCloudEyeDomeLighting_default2 = PointCloudEyeDomeLighting;

// node_modules/cesium/Source/Scene/PointCloudShading.js
function PointCloudShading(options) {
  const pointCloudShading = defaultValue_default(options, {});
  this.attenuation = defaultValue_default(pointCloudShading.attenuation, false);
  this.geometricErrorScale = defaultValue_default(
    pointCloudShading.geometricErrorScale,
    1
  );
  this.maximumAttenuation = pointCloudShading.maximumAttenuation;
  this.baseResolution = pointCloudShading.baseResolution;
  this.eyeDomeLighting = defaultValue_default(pointCloudShading.eyeDomeLighting, true);
  this.eyeDomeLightingStrength = defaultValue_default(
    pointCloudShading.eyeDomeLightingStrength,
    1
  );
  this.eyeDomeLightingRadius = defaultValue_default(
    pointCloudShading.eyeDomeLightingRadius,
    1
  );
  this.backFaceCulling = defaultValue_default(pointCloudShading.backFaceCulling, false);
  this.normalShading = defaultValue_default(pointCloudShading.normalShading, true);
}
PointCloudShading.isSupported = function(scene) {
  return PointCloudEyeDomeLighting_default2.isSupported(scene.context);
};
var PointCloudShading_default = PointCloudShading;

// node_modules/cesium/Source/Scene/PointCloud3DTileContent.js
function PointCloud3DTileContent(tileset, tile, resource, arrayBuffer, byteOffset) {
  this._tileset = tileset;
  this._tile = tile;
  this._resource = resource;
  this._metadata = void 0;
  this._pickId = void 0;
  this._batchTable = void 0;
  this._styleDirty = false;
  this._features = void 0;
  this.featurePropertiesDirty = false;
  this._group = void 0;
  this._pointCloud = new PointCloud_default({
    arrayBuffer,
    byteOffset,
    cull: false,
    opaquePass: Pass_default.CESIUM_3D_TILE,
    vertexShaderLoaded: getVertexShaderLoaded(this),
    fragmentShaderLoaded: getFragmentShaderLoaded(this),
    uniformMapLoaded: getUniformMapLoaded(this),
    batchTableLoaded: getBatchTableLoaded(this),
    pickIdLoaded: getPickIdLoaded(this)
  });
}
Object.defineProperties(PointCloud3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      if (defined_default(this._batchTable)) {
        return this._batchTable.featuresLength;
      }
      return 0;
    }
  },
  pointsLength: {
    get: function() {
      return this._pointCloud.pointsLength;
    }
  },
  trianglesLength: {
    get: function() {
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      return this._pointCloud.geometryByteLength;
    }
  },
  texturesByteLength: {
    get: function() {
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      if (defined_default(this._batchTable)) {
        return this._batchTable.memorySizeInBytes;
      }
      return 0;
    }
  },
  innerContents: {
    get: function() {
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._pointCloud.readyPromise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return this._resource.getUrlComponent(true);
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    },
    set: function(value) {
      this._metadata = value;
    }
  },
  batchTable: {
    get: function() {
      return this._batchTable;
    }
  },
  group: {
    get: function() {
      return this._group;
    },
    set: function(value) {
      this._group = value;
    }
  }
});
function getVertexShaderLoaded(content) {
  return function(vs) {
    if (defined_default(content._batchTable)) {
      return content._batchTable.getVertexShaderCallback(
        false,
        "a_batchId",
        void 0
      )(vs);
    }
    return vs;
  };
}
function getFragmentShaderLoaded(content) {
  return function(fs) {
    if (defined_default(content._batchTable)) {
      return content._batchTable.getFragmentShaderCallback(
        false,
        void 0,
        false
      )(fs);
    }
    return `uniform vec4 czm_pickColor;
${fs}`;
  };
}
function getUniformMapLoaded(content) {
  return function(uniformMap2) {
    if (defined_default(content._batchTable)) {
      return content._batchTable.getUniformMapCallback()(uniformMap2);
    }
    return combine_default(uniformMap2, {
      czm_pickColor: function() {
        return content._pickId.color;
      }
    });
  };
}
function getBatchTableLoaded(content) {
  return function(batchLength, batchTableJson, batchTableBinary) {
    content._batchTable = new Cesium3DTileBatchTable_default(
      content,
      batchLength,
      batchTableJson,
      batchTableBinary
    );
  };
}
function getPickIdLoaded(content) {
  return function() {
    return defined_default(content._batchTable) ? content._batchTable.getPickId() : "czm_pickColor";
  };
}
function getGeometricError2(content) {
  const pointCloudShading = content._tileset.pointCloudShading;
  const sphereVolume = content._tile.contentBoundingVolume.boundingSphere.volume();
  const baseResolutionApproximation = Math_default.cbrt(
    sphereVolume / content.pointsLength
  );
  let geometricError = content._tile.geometricError;
  if (geometricError === 0) {
    if (defined_default(pointCloudShading) && defined_default(pointCloudShading.baseResolution)) {
      geometricError = pointCloudShading.baseResolution;
    } else {
      geometricError = baseResolutionApproximation;
    }
  }
  return geometricError;
}
function createFeatures4(content) {
  const featuresLength = content.featuresLength;
  if (!defined_default(content._features) && featuresLength > 0) {
    const features = new Array(featuresLength);
    for (let i2 = 0; i2 < featuresLength; ++i2) {
      features[i2] = new Cesium3DTileFeature_default(content, i2);
    }
    content._features = features;
  }
}
PointCloud3DTileContent.prototype.hasProperty = function(batchId, name) {
  if (defined_default(this._batchTable)) {
    return this._batchTable.hasProperty(batchId, name);
  }
  return false;
};
PointCloud3DTileContent.prototype.getFeature = function(batchId) {
  if (!defined_default(this._batchTable)) {
    return void 0;
  }
  const featuresLength = this.featuresLength;
  if (!defined_default(batchId) || batchId < 0 || batchId >= featuresLength) {
    throw new DeveloperError_default(
      `batchId is required and between zero and featuresLength - 1 (${featuresLength - 1}).`
    );
  }
  createFeatures4(this);
  return this._features[batchId];
};
PointCloud3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
  this._pointCloud.color = enabled ? color : Color_default.WHITE;
};
PointCloud3DTileContent.prototype.applyStyle = function(style) {
  if (defined_default(this._batchTable)) {
    this._batchTable.applyStyle(style);
  } else {
    this._styleDirty = true;
  }
};
var defaultShading = new PointCloudShading_default();
PointCloud3DTileContent.prototype.update = function(tileset, frameState) {
  const pointCloud = this._pointCloud;
  const pointCloudShading = defaultValue_default(
    tileset.pointCloudShading,
    defaultShading
  );
  const tile = this._tile;
  const batchTable = this._batchTable;
  const mode2 = frameState.mode;
  const clippingPlanes = tileset.clippingPlanes;
  if (!defined_default(this._pickId) && !defined_default(batchTable)) {
    this._pickId = frameState.context.createPickId({
      primitive: tileset,
      content: this
    });
  }
  if (defined_default(batchTable)) {
    batchTable.update(tileset, frameState);
  }
  let boundingSphere;
  if (defined_default(tile._contentBoundingVolume)) {
    boundingSphere = mode2 === SceneMode_default.SCENE3D ? tile._contentBoundingVolume.boundingSphere : tile._contentBoundingVolume2D.boundingSphere;
  } else {
    boundingSphere = mode2 === SceneMode_default.SCENE3D ? tile._boundingVolume.boundingSphere : tile._boundingVolume2D.boundingSphere;
  }
  const styleDirty = this._styleDirty;
  this._styleDirty = false;
  pointCloud.clippingPlanesOriginMatrix = tileset.clippingPlanesOriginMatrix;
  pointCloud.style = defined_default(batchTable) ? void 0 : tileset.style;
  pointCloud.styleDirty = styleDirty;
  pointCloud.modelMatrix = tile.computedTransform;
  pointCloud.time = tileset.timeSinceLoad;
  pointCloud.shadows = tileset.shadows;
  pointCloud.boundingSphere = boundingSphere;
  pointCloud.clippingPlanes = clippingPlanes;
  pointCloud.isClipped = defined_default(clippingPlanes) && clippingPlanes.enabled && tile._isClipped;
  pointCloud.clippingPlanesDirty = tile.clippingPlanesDirty;
  pointCloud.attenuation = pointCloudShading.attenuation;
  pointCloud.backFaceCulling = pointCloudShading.backFaceCulling;
  pointCloud.normalShading = pointCloudShading.normalShading;
  pointCloud.geometricError = getGeometricError2(this);
  pointCloud.geometricErrorScale = pointCloudShading.geometricErrorScale;
  pointCloud.splitDirection = tileset.splitDirection;
  if (defined_default(pointCloudShading) && defined_default(pointCloudShading.maximumAttenuation)) {
    pointCloud.maximumAttenuation = pointCloudShading.maximumAttenuation;
  } else if (tile.refine === Cesium3DTileRefine_default.ADD) {
    pointCloud.maximumAttenuation = 5;
  } else {
    pointCloud.maximumAttenuation = tileset.maximumScreenSpaceError;
  }
  pointCloud.update(frameState);
};
PointCloud3DTileContent.prototype.isDestroyed = function() {
  return false;
};
PointCloud3DTileContent.prototype.destroy = function() {
  this._pickId = this._pickId && this._pickId.destroy();
  this._pointCloud = this._pointCloud && this._pointCloud.destroy();
  this._batchTable = this._batchTable && this._batchTable.destroy();
  return destroyObject_default(this);
};
var PointCloud3DTileContent_default = PointCloud3DTileContent;

// node_modules/cesium/Source/Scene/Tileset3DTileContent.js
function Tileset3DTileContent(tileset, tile, resource, json) {
  this._tileset = tileset;
  this._tile = tile;
  this._resource = resource;
  this._readyPromise = defer_default();
  this.featurePropertiesDirty = false;
  this._metadata = void 0;
  this._group = void 0;
  initialize11(this, json);
}
Object.defineProperties(Tileset3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      return 0;
    }
  },
  pointsLength: {
    get: function() {
      return 0;
    }
  },
  trianglesLength: {
    get: function() {
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      return 0;
    }
  },
  texturesByteLength: {
    get: function() {
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      return 0;
    }
  },
  innerContents: {
    get: function() {
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return this._resource.getUrlComponent(true);
    }
  },
  batchTable: {
    get: function() {
      return void 0;
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    },
    set: function(value) {
      this._metadata = value;
    }
  },
  group: {
    get: function() {
      return this._group;
    },
    set: function(value) {
      this._group = value;
    }
  }
});
function initialize11(content, json) {
  content._tileset.loadTileset(content._resource, json, content._tile);
  content._readyPromise.resolve(content);
}
Tileset3DTileContent.prototype.hasProperty = function(batchId, name) {
  return false;
};
Tileset3DTileContent.prototype.getFeature = function(batchId) {
  return void 0;
};
Tileset3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
};
Tileset3DTileContent.prototype.applyStyle = function(style) {
};
Tileset3DTileContent.prototype.update = function(tileset, frameState) {
};
Tileset3DTileContent.prototype.isDestroyed = function() {
  return false;
};
Tileset3DTileContent.prototype.destroy = function() {
  return destroyObject_default(this);
};
var Tileset3DTileContent_default = Tileset3DTileContent;

// node_modules/cesium/Source/Renderer/VertexArrayFacade.js
function VertexArrayFacade(context, attributes, sizeInVertices, instanced) {
  Check_default.defined("context", context);
  if (!attributes || attributes.length === 0) {
    throw new DeveloperError_default("At least one attribute is required.");
  }
  const attrs = VertexArrayFacade._verifyAttributes(attributes);
  sizeInVertices = defaultValue_default(sizeInVertices, 0);
  const precreatedAttributes = [];
  const attributesByUsage = {};
  let attributesForUsage;
  let usage;
  const length3 = attrs.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const attribute = attrs[i2];
    if (attribute.vertexBuffer) {
      precreatedAttributes.push(attribute);
      continue;
    }
    usage = attribute.usage;
    attributesForUsage = attributesByUsage[usage];
    if (!defined_default(attributesForUsage)) {
      attributesForUsage = attributesByUsage[usage] = [];
    }
    attributesForUsage.push(attribute);
  }
  function compare(left, right) {
    return ComponentDatatype_default.getSizeInBytes(right.componentDatatype) - ComponentDatatype_default.getSizeInBytes(left.componentDatatype);
  }
  this._allBuffers = [];
  for (usage in attributesByUsage) {
    if (attributesByUsage.hasOwnProperty(usage)) {
      attributesForUsage = attributesByUsage[usage];
      attributesForUsage.sort(compare);
      const vertexSizeInBytes = VertexArrayFacade._vertexSizeInBytes(
        attributesForUsage
      );
      const bufferUsage = attributesForUsage[0].usage;
      const buffer = {
        vertexSizeInBytes,
        vertexBuffer: void 0,
        usage: bufferUsage,
        needsCommit: false,
        arrayBuffer: void 0,
        arrayViews: VertexArrayFacade._createArrayViews(
          attributesForUsage,
          vertexSizeInBytes
        )
      };
      this._allBuffers.push(buffer);
    }
  }
  this._size = 0;
  this._instanced = defaultValue_default(instanced, false);
  this._precreated = precreatedAttributes;
  this._context = context;
  this.writers = void 0;
  this.va = void 0;
  this.resize(sizeInVertices);
}
VertexArrayFacade._verifyAttributes = function(attributes) {
  const attrs = [];
  for (let i2 = 0; i2 < attributes.length; ++i2) {
    const attribute = attributes[i2];
    const attr = {
      index: defaultValue_default(attribute.index, i2),
      enabled: defaultValue_default(attribute.enabled, true),
      componentsPerAttribute: attribute.componentsPerAttribute,
      componentDatatype: defaultValue_default(
        attribute.componentDatatype,
        ComponentDatatype_default.FLOAT
      ),
      normalize: defaultValue_default(attribute.normalize, false),
      vertexBuffer: attribute.vertexBuffer,
      usage: defaultValue_default(attribute.usage, BufferUsage_default.STATIC_DRAW)
    };
    attrs.push(attr);
    if (attr.componentsPerAttribute !== 1 && attr.componentsPerAttribute !== 2 && attr.componentsPerAttribute !== 3 && attr.componentsPerAttribute !== 4) {
      throw new DeveloperError_default(
        "attribute.componentsPerAttribute must be in the range [1, 4]."
      );
    }
    const datatype = attr.componentDatatype;
    if (!ComponentDatatype_default.validate(datatype)) {
      throw new DeveloperError_default(
        "Attribute must have a valid componentDatatype or not specify it."
      );
    }
    if (!BufferUsage_default.validate(attr.usage)) {
      throw new DeveloperError_default(
        "Attribute must have a valid usage or not specify it."
      );
    }
  }
  const uniqueIndices = new Array(attrs.length);
  for (let j = 0; j < attrs.length; ++j) {
    const currentAttr = attrs[j];
    const index2 = currentAttr.index;
    if (uniqueIndices[index2]) {
      throw new DeveloperError_default(
        `Index ${index2} is used by more than one attribute.`
      );
    }
    uniqueIndices[index2] = true;
  }
  return attrs;
};
VertexArrayFacade._vertexSizeInBytes = function(attributes) {
  let sizeInBytes = 0;
  const length3 = attributes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const attribute = attributes[i2];
    sizeInBytes += attribute.componentsPerAttribute * ComponentDatatype_default.getSizeInBytes(attribute.componentDatatype);
  }
  const maxComponentSizeInBytes = length3 > 0 ? ComponentDatatype_default.getSizeInBytes(attributes[0].componentDatatype) : 0;
  const remainder = maxComponentSizeInBytes > 0 ? sizeInBytes % maxComponentSizeInBytes : 0;
  const padding = remainder === 0 ? 0 : maxComponentSizeInBytes - remainder;
  sizeInBytes += padding;
  return sizeInBytes;
};
VertexArrayFacade._createArrayViews = function(attributes, vertexSizeInBytes) {
  const views = [];
  let offsetInBytes = 0;
  const length3 = attributes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const attribute = attributes[i2];
    const componentDatatype = attribute.componentDatatype;
    views.push({
      index: attribute.index,
      enabled: attribute.enabled,
      componentsPerAttribute: attribute.componentsPerAttribute,
      componentDatatype,
      normalize: attribute.normalize,
      offsetInBytes,
      vertexSizeInComponentType: vertexSizeInBytes / ComponentDatatype_default.getSizeInBytes(componentDatatype),
      view: void 0
    });
    offsetInBytes += attribute.componentsPerAttribute * ComponentDatatype_default.getSizeInBytes(componentDatatype);
  }
  return views;
};
VertexArrayFacade.prototype.resize = function(sizeInVertices) {
  this._size = sizeInVertices;
  const allBuffers = this._allBuffers;
  this.writers = [];
  for (let i2 = 0, len = allBuffers.length; i2 < len; ++i2) {
    const buffer = allBuffers[i2];
    VertexArrayFacade._resize(buffer, this._size);
    VertexArrayFacade._appendWriters(this.writers, buffer);
  }
  destroyVA(this);
};
VertexArrayFacade._resize = function(buffer, size) {
  if (buffer.vertexSizeInBytes > 0) {
    const arrayBuffer = new ArrayBuffer(size * buffer.vertexSizeInBytes);
    if (defined_default(buffer.arrayBuffer)) {
      const destView = new Uint8Array(arrayBuffer);
      const sourceView = new Uint8Array(buffer.arrayBuffer);
      const sourceLength = sourceView.length;
      for (let j = 0; j < sourceLength; ++j) {
        destView[j] = sourceView[j];
      }
    }
    const views = buffer.arrayViews;
    const length3 = views.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      const view = views[i2];
      view.view = ComponentDatatype_default.createArrayBufferView(
        view.componentDatatype,
        arrayBuffer,
        view.offsetInBytes
      );
    }
    buffer.arrayBuffer = arrayBuffer;
  }
};
var createWriters = [
  function(buffer, view, vertexSizeInComponentType) {
    return function(index2, attribute) {
      view[index2 * vertexSizeInComponentType] = attribute;
      buffer.needsCommit = true;
    };
  },
  function(buffer, view, vertexSizeInComponentType) {
    return function(index2, component0, component1) {
      const i2 = index2 * vertexSizeInComponentType;
      view[i2] = component0;
      view[i2 + 1] = component1;
      buffer.needsCommit = true;
    };
  },
  function(buffer, view, vertexSizeInComponentType) {
    return function(index2, component0, component1, component2) {
      const i2 = index2 * vertexSizeInComponentType;
      view[i2] = component0;
      view[i2 + 1] = component1;
      view[i2 + 2] = component2;
      buffer.needsCommit = true;
    };
  },
  function(buffer, view, vertexSizeInComponentType) {
    return function(index2, component0, component1, component2, component3) {
      const i2 = index2 * vertexSizeInComponentType;
      view[i2] = component0;
      view[i2 + 1] = component1;
      view[i2 + 2] = component2;
      view[i2 + 3] = component3;
      buffer.needsCommit = true;
    };
  }
];
VertexArrayFacade._appendWriters = function(writers, buffer) {
  const arrayViews = buffer.arrayViews;
  const length3 = arrayViews.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const arrayView = arrayViews[i2];
    writers[arrayView.index] = createWriters[arrayView.componentsPerAttribute - 1](buffer, arrayView.view, arrayView.vertexSizeInComponentType);
  }
};
VertexArrayFacade.prototype.commit = function(indexBuffer) {
  let recreateVA = false;
  const allBuffers = this._allBuffers;
  let buffer;
  let i2;
  let length3;
  for (i2 = 0, length3 = allBuffers.length; i2 < length3; ++i2) {
    buffer = allBuffers[i2];
    recreateVA = commit(this, buffer) || recreateVA;
  }
  if (recreateVA || !defined_default(this.va)) {
    destroyVA(this);
    const va = this.va = [];
    const chunkSize = Math_default.SIXTY_FOUR_KILOBYTES - 4;
    const numberOfVertexArrays = defined_default(indexBuffer) && !this._instanced ? Math.ceil(this._size / chunkSize) : 1;
    for (let k = 0; k < numberOfVertexArrays; ++k) {
      let attributes = [];
      for (i2 = 0, length3 = allBuffers.length; i2 < length3; ++i2) {
        buffer = allBuffers[i2];
        const offset2 = k * (buffer.vertexSizeInBytes * chunkSize);
        VertexArrayFacade._appendAttributes(
          attributes,
          buffer,
          offset2,
          this._instanced
        );
      }
      attributes = attributes.concat(this._precreated);
      va.push({
        va: new VertexArray_default({
          context: this._context,
          attributes,
          indexBuffer
        }),
        indicesCount: 1.5 * (k !== numberOfVertexArrays - 1 ? chunkSize : this._size % chunkSize)
      });
    }
  }
};
function commit(vertexArrayFacade, buffer) {
  if (buffer.needsCommit && buffer.vertexSizeInBytes > 0) {
    buffer.needsCommit = false;
    const vertexBuffer = buffer.vertexBuffer;
    const vertexBufferSizeInBytes = vertexArrayFacade._size * buffer.vertexSizeInBytes;
    const vertexBufferDefined = defined_default(vertexBuffer);
    if (!vertexBufferDefined || vertexBuffer.sizeInBytes < vertexBufferSizeInBytes) {
      if (vertexBufferDefined) {
        vertexBuffer.destroy();
      }
      buffer.vertexBuffer = Buffer_default.createVertexBuffer({
        context: vertexArrayFacade._context,
        typedArray: buffer.arrayBuffer,
        usage: buffer.usage
      });
      buffer.vertexBuffer.vertexArrayDestroyable = false;
      return true;
    }
    buffer.vertexBuffer.copyFromArrayView(buffer.arrayBuffer);
  }
  return false;
}
VertexArrayFacade._appendAttributes = function(attributes, buffer, vertexBufferOffset, instanced) {
  const arrayViews = buffer.arrayViews;
  const length3 = arrayViews.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const view = arrayViews[i2];
    attributes.push({
      index: view.index,
      enabled: view.enabled,
      componentsPerAttribute: view.componentsPerAttribute,
      componentDatatype: view.componentDatatype,
      normalize: view.normalize,
      vertexBuffer: buffer.vertexBuffer,
      offsetInBytes: vertexBufferOffset + view.offsetInBytes,
      strideInBytes: buffer.vertexSizeInBytes,
      instanceDivisor: instanced ? 1 : 0
    });
  }
};
VertexArrayFacade.prototype.subCommit = function(offsetInVertices, lengthInVertices) {
  if (offsetInVertices < 0 || offsetInVertices >= this._size) {
    throw new DeveloperError_default(
      "offsetInVertices must be greater than or equal to zero and less than the vertex array size."
    );
  }
  if (offsetInVertices + lengthInVertices > this._size) {
    throw new DeveloperError_default(
      "offsetInVertices + lengthInVertices cannot exceed the vertex array size."
    );
  }
  const allBuffers = this._allBuffers;
  for (let i2 = 0, len = allBuffers.length; i2 < len; ++i2) {
    subCommit(allBuffers[i2], offsetInVertices, lengthInVertices);
  }
};
function subCommit(buffer, offsetInVertices, lengthInVertices) {
  if (buffer.needsCommit && buffer.vertexSizeInBytes > 0) {
    const byteOffset = buffer.vertexSizeInBytes * offsetInVertices;
    const byteLength = buffer.vertexSizeInBytes * lengthInVertices;
    buffer.vertexBuffer.copyFromArrayView(
      new Uint8Array(buffer.arrayBuffer, byteOffset, byteLength),
      byteOffset
    );
  }
}
VertexArrayFacade.prototype.endSubCommits = function() {
  const allBuffers = this._allBuffers;
  for (let i2 = 0, len = allBuffers.length; i2 < len; ++i2) {
    allBuffers[i2].needsCommit = false;
  }
};
function destroyVA(vertexArrayFacade) {
  const va = vertexArrayFacade.va;
  if (!defined_default(va)) {
    return;
  }
  const length3 = va.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    va[i2].va.destroy();
  }
  vertexArrayFacade.va = void 0;
}
VertexArrayFacade.prototype.isDestroyed = function() {
  return false;
};
VertexArrayFacade.prototype.destroy = function() {
  const allBuffers = this._allBuffers;
  for (let i2 = 0, len = allBuffers.length; i2 < len; ++i2) {
    const buffer = allBuffers[i2];
    buffer.vertexBuffer = buffer.vertexBuffer && buffer.vertexBuffer.destroy();
  }
  destroyVA(this);
  return destroyObject_default(this);
};
var VertexArrayFacade_default = VertexArrayFacade;

// node_modules/cesium/Source/Shaders/BillboardCollectionFS.js
var BillboardCollectionFS_default = `#ifdef GL_OES_standard_derivatives
#extension GL_OES_standard_derivatives : enable
#endif

uniform sampler2D u_atlas;

#ifdef VECTOR_TILE
uniform vec4 u_highlightColor;
#endif

varying vec2 v_textureCoordinates;
varying vec4 v_pickColor;
varying vec4 v_color;

#ifdef SDF
varying vec4 v_outlineColor;
varying float v_outlineWidth;
#endif

#ifdef FRAGMENT_DEPTH_CHECK
varying vec4 v_textureCoordinateBounds;                  // the min and max x and y values for the texture coordinates
varying vec4 v_originTextureCoordinateAndTranslate;      // texture coordinate at the origin, billboard translate (used for label glyphs)
varying vec4 v_compressed;                               // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize
varying mat2 v_rotationMatrix;

const float SHIFT_LEFT12 = 4096.0;
const float SHIFT_LEFT1 = 2.0;

const float SHIFT_RIGHT12 = 1.0 / 4096.0;
const float SHIFT_RIGHT1 = 1.0 / 2.0;

float getGlobeDepth(vec2 adjustedST, vec2 depthLookupST, bool applyTranslate, vec2 dimensions, vec2 imageSize)
{
    vec2 lookupVector = imageSize * (depthLookupST - adjustedST);
    lookupVector = v_rotationMatrix * lookupVector;
    vec2 labelOffset = (dimensions - imageSize) * (depthLookupST - vec2(0.0, v_originTextureCoordinateAndTranslate.y)); // aligns label glyph with bounding rectangle.  Will be zero for billboards because dimensions and imageSize will be equal

    vec2 translation = v_originTextureCoordinateAndTranslate.zw;

    if (applyTranslate)
    {
        // this is only needed for labels where the horizontal origin is not LEFT
        // it moves the label back to where the "origin" should be since all label glyphs are set to HorizontalOrigin.LEFT
        translation += (dimensions * v_originTextureCoordinateAndTranslate.xy * vec2(1.0, 0.0));
    }

    vec2 st = ((lookupVector - translation + labelOffset) + gl_FragCoord.xy) / czm_viewport.zw;
    float logDepthOrDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, st));

    if (logDepthOrDepth == 0.0)
    {
        return 0.0; // not on the globe
    }

    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth);
    return eyeCoordinate.z / eyeCoordinate.w;
}
#endif


#ifdef SDF

// Get the distance from the edge of a glyph at a given position sampling an SDF texture.
float getDistance(vec2 position)
{
    return texture2D(u_atlas, position).r;
}

// Samples the sdf texture at the given position and produces a color based on the fill color and the outline.
vec4 getSDFColor(vec2 position, float outlineWidth, vec4 outlineColor, float smoothing)
{
    float distance = getDistance(position);

    if (outlineWidth > 0.0)
    {
        // Don't get the outline edge exceed the SDF_EDGE
        float outlineEdge = clamp(SDF_EDGE - outlineWidth, 0.0, SDF_EDGE);
        float outlineFactor = smoothstep(SDF_EDGE - smoothing, SDF_EDGE + smoothing, distance);
        vec4 sdfColor = mix(outlineColor, v_color, outlineFactor);
        float alpha = smoothstep(outlineEdge - smoothing, outlineEdge + smoothing, distance);
        return vec4(sdfColor.rgb, sdfColor.a * alpha);
    }
    else
    {
        float alpha = smoothstep(SDF_EDGE - smoothing, SDF_EDGE + smoothing, distance);
        return vec4(v_color.rgb, v_color.a * alpha);
    }
}
#endif

void main()
{
    vec4 color = texture2D(u_atlas, v_textureCoordinates);

#ifdef SDF
    float outlineWidth = v_outlineWidth;
    vec4 outlineColor = v_outlineColor;

    // Get the current distance
    float distance = getDistance(v_textureCoordinates);

#ifdef GL_OES_standard_derivatives
    float smoothing = fwidth(distance);
    // Get an offset that is approximately half the distance to the neighbor pixels
    // 0.354 is approximately half of 1/sqrt(2)
    vec2 sampleOffset = 0.354 * vec2(dFdx(v_textureCoordinates) + dFdy(v_textureCoordinates));

    // Sample the center point
    vec4 center = getSDFColor(v_textureCoordinates, outlineWidth, outlineColor, smoothing);

    // Sample the 4 neighbors
    vec4 color1 = getSDFColor(v_textureCoordinates + vec2(sampleOffset.x, sampleOffset.y), outlineWidth, outlineColor, smoothing);
    vec4 color2 = getSDFColor(v_textureCoordinates + vec2(-sampleOffset.x, sampleOffset.y), outlineWidth, outlineColor, smoothing);
    vec4 color3 = getSDFColor(v_textureCoordinates + vec2(-sampleOffset.x, -sampleOffset.y), outlineWidth, outlineColor, smoothing);
    vec4 color4 = getSDFColor(v_textureCoordinates + vec2(sampleOffset.x, -sampleOffset.y), outlineWidth, outlineColor, smoothing);

    // Equally weight the center sample and the 4 neighboring samples
    color = (center + color1 + color2 + color3 + color4)/5.0;
#else
    // Just do a single sample
    float smoothing = 1.0/32.0;
    color = getSDFColor(v_textureCoordinates, outlineWidth, outlineColor, smoothing);
#endif

    color = czm_gammaCorrect(color);
#else
    color = czm_gammaCorrect(color);
    color *= czm_gammaCorrect(v_color);
#endif

// Fully transparent parts of the billboard are not pickable.
#if !defined(OPAQUE) && !defined(TRANSLUCENT)
    if (color.a < 0.005)   // matches 0/255 and 1/255
    {
        discard;
    }
#else
// The billboard is rendered twice. The opaque pass discards translucent fragments
// and the translucent pass discards opaque fragments.
#ifdef OPAQUE
    if (color.a < 0.995)   // matches < 254/255
    {
        discard;
    }
#else
    if (color.a >= 0.995)  // matches 254/255 and 255/255
    {
        discard;
    }
#endif
#endif

#ifdef VECTOR_TILE
    color *= u_highlightColor;
#endif
    gl_FragColor = color;

#ifdef LOG_DEPTH
    czm_writeLogDepth();
#endif

#ifdef FRAGMENT_DEPTH_CHECK
    float temp = v_compressed.y;

    temp = temp * SHIFT_RIGHT1;

    float temp2 = (temp - floor(temp)) * SHIFT_LEFT1;
    bool enableDepthTest = temp2 != 0.0;
    bool applyTranslate = floor(temp) != 0.0;

    if (enableDepthTest) {
        temp = v_compressed.z;
        temp = temp * SHIFT_RIGHT12;

        vec2 dimensions;
        dimensions.y = (temp - floor(temp)) * SHIFT_LEFT12;
        dimensions.x = floor(temp);

        temp = v_compressed.w;
        temp = temp * SHIFT_RIGHT12;

        vec2 imageSize;
        imageSize.y = (temp - floor(temp)) * SHIFT_LEFT12;
        imageSize.x = floor(temp);

        vec2 adjustedST = v_textureCoordinates - v_textureCoordinateBounds.xy;
        adjustedST = adjustedST / vec2(v_textureCoordinateBounds.z - v_textureCoordinateBounds.x, v_textureCoordinateBounds.w - v_textureCoordinateBounds.y);

        float epsilonEyeDepth = v_compressed.x + czm_epsilon1;
        float globeDepth1 = getGlobeDepth(adjustedST, v_originTextureCoordinateAndTranslate.xy, applyTranslate, dimensions, imageSize);

        // negative values go into the screen
        if (globeDepth1 != 0.0 && globeDepth1 > epsilonEyeDepth)
        {
            float globeDepth2 = getGlobeDepth(adjustedST, vec2(0.0, 1.0), applyTranslate, dimensions, imageSize); // top left corner
            if (globeDepth2 != 0.0 && globeDepth2 > epsilonEyeDepth)
            {
                float globeDepth3 = getGlobeDepth(adjustedST, vec2(1.0, 1.0), applyTranslate, dimensions, imageSize); // top right corner
                if (globeDepth3 != 0.0 && globeDepth3 > epsilonEyeDepth)
                {
                    discard;
                }
            }
        }
    }
#endif

}
`;

// node_modules/cesium/Source/Shaders/BillboardCollectionVS.js
var BillboardCollectionVS_default = `#ifdef INSTANCED
attribute vec2 direction;
#endif
attribute vec4 positionHighAndScale;
attribute vec4 positionLowAndRotation;
attribute vec4 compressedAttribute0;                       // pixel offset, translate, horizontal origin, vertical origin, show, direction, texture coordinates (texture offset)
attribute vec4 compressedAttribute1;                       // aligned axis, translucency by distance, image width
attribute vec4 compressedAttribute2;                       // label horizontal origin, image height, color, pick color, size in meters, valid aligned axis, 13 bits free
attribute vec4 eyeOffset;                                  // eye offset in meters, 4 bytes free (texture range)
attribute vec4 scaleByDistance;                            // near, nearScale, far, farScale
attribute vec4 pixelOffsetScaleByDistance;                 // near, nearScale, far, farScale
attribute vec4 compressedAttribute3;                       // distance display condition near, far, disableDepthTestDistance, dimensions
attribute vec2 sdf;                                        // sdf outline color (rgb) and width (w)
#if defined(VERTEX_DEPTH_CHECK) || defined(FRAGMENT_DEPTH_CHECK)
attribute vec4 textureCoordinateBoundsOrLabelTranslate;    // the min and max x and y values for the texture coordinates
#endif
#ifdef VECTOR_TILE
attribute float a_batchId;
#endif

varying vec2 v_textureCoordinates;
#ifdef FRAGMENT_DEPTH_CHECK
varying vec4 v_textureCoordinateBounds;
varying vec4 v_originTextureCoordinateAndTranslate;
varying vec4 v_compressed;                                 // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize
varying mat2 v_rotationMatrix;
#endif

varying vec4 v_pickColor;
varying vec4 v_color;
#ifdef SDF
varying vec4 v_outlineColor;
varying float v_outlineWidth;
#endif

const float UPPER_BOUND = 32768.0;

const float SHIFT_LEFT16 = 65536.0;
const float SHIFT_LEFT12 = 4096.0;
const float SHIFT_LEFT8 = 256.0;
const float SHIFT_LEFT7 = 128.0;
const float SHIFT_LEFT5 = 32.0;
const float SHIFT_LEFT3 = 8.0;
const float SHIFT_LEFT2 = 4.0;
const float SHIFT_LEFT1 = 2.0;

const float SHIFT_RIGHT12 = 1.0 / 4096.0;
const float SHIFT_RIGHT8 = 1.0 / 256.0;
const float SHIFT_RIGHT7 = 1.0 / 128.0;
const float SHIFT_RIGHT5 = 1.0 / 32.0;
const float SHIFT_RIGHT3 = 1.0 / 8.0;
const float SHIFT_RIGHT2 = 1.0 / 4.0;
const float SHIFT_RIGHT1 = 1.0 / 2.0;

vec4 addScreenSpaceOffset(vec4 positionEC, vec2 imageSize, float scale, vec2 direction, vec2 origin, vec2 translate, vec2 pixelOffset, vec3 alignedAxis, bool validAlignedAxis, float rotation, bool sizeInMeters, out mat2 rotationMatrix, out float mpp)
{
    // Note the halfSize cannot be computed in JavaScript because it is sent via
    // compressed vertex attributes that coerce it to an integer.
    vec2 halfSize = imageSize * scale * 0.5;
    halfSize *= ((direction * 2.0) - 1.0);

    vec2 originTranslate = origin * abs(halfSize);

#if defined(ROTATION) || defined(ALIGNED_AXIS)
    if (validAlignedAxis || rotation != 0.0)
    {
        float angle = rotation;
        if (validAlignedAxis)
        {
            vec4 projectedAlignedAxis = czm_modelViewProjection * vec4(alignedAxis, 0.0);
            angle += sign(-projectedAlignedAxis.x) * acos(sign(projectedAlignedAxis.y) * (projectedAlignedAxis.y * projectedAlignedAxis.y) /
                    (projectedAlignedAxis.x * projectedAlignedAxis.x + projectedAlignedAxis.y * projectedAlignedAxis.y));
        }

        float cosTheta = cos(angle);
        float sinTheta = sin(angle);
        rotationMatrix = mat2(cosTheta, sinTheta, -sinTheta, cosTheta);
        halfSize = rotationMatrix * halfSize;
    }
    else
    {
        rotationMatrix = mat2(1.0, 0.0, 0.0, 1.0);
    }
#endif

    mpp = czm_metersPerPixel(positionEC);
    positionEC.xy += (originTranslate + halfSize) * czm_branchFreeTernary(sizeInMeters, 1.0, mpp);
    positionEC.xy += (translate + pixelOffset) * mpp;

    return positionEC;
}

#ifdef VERTEX_DEPTH_CHECK
float getGlobeDepth(vec4 positionEC)
{
    vec4 posWC = czm_eyeToWindowCoordinates(positionEC);

    float globeDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, posWC.xy / czm_viewport.zw));

    if (globeDepth == 0.0)
    {
        return 0.0; // not on the globe
    }

    vec4 eyeCoordinate = czm_windowToEyeCoordinates(posWC.xy, globeDepth);
    return eyeCoordinate.z / eyeCoordinate.w;
}
#endif
void main()
{
    // Modifying this shader may also require modifications to Billboard._computeScreenSpacePosition

    // unpack attributes
    vec3 positionHigh = positionHighAndScale.xyz;
    vec3 positionLow = positionLowAndRotation.xyz;
    float scale = positionHighAndScale.w;

#if defined(ROTATION) || defined(ALIGNED_AXIS)
    float rotation = positionLowAndRotation.w;
#else
    float rotation = 0.0;
#endif

    float compressed = compressedAttribute0.x;

    vec2 pixelOffset;
    pixelOffset.x = floor(compressed * SHIFT_RIGHT7);
    compressed -= pixelOffset.x * SHIFT_LEFT7;
    pixelOffset.x -= UPPER_BOUND;

    vec2 origin;
    origin.x = floor(compressed * SHIFT_RIGHT5);
    compressed -= origin.x * SHIFT_LEFT5;

    origin.y = floor(compressed * SHIFT_RIGHT3);
    compressed -= origin.y * SHIFT_LEFT3;

#ifdef FRAGMENT_DEPTH_CHECK
    vec2 depthOrigin = origin.xy;
#endif
    origin -= vec2(1.0);

    float show = floor(compressed * SHIFT_RIGHT2);
    compressed -= show * SHIFT_LEFT2;

#ifdef INSTANCED
    vec2 textureCoordinatesBottomLeft = czm_decompressTextureCoordinates(compressedAttribute0.w);
    vec2 textureCoordinatesRange = czm_decompressTextureCoordinates(eyeOffset.w);
    vec2 textureCoordinates = textureCoordinatesBottomLeft + direction * textureCoordinatesRange;
#else
    vec2 direction;
    direction.x = floor(compressed * SHIFT_RIGHT1);
    direction.y = compressed - direction.x * SHIFT_LEFT1;

    vec2 textureCoordinates = czm_decompressTextureCoordinates(compressedAttribute0.w);
#endif

    float temp = compressedAttribute0.y  * SHIFT_RIGHT8;
    pixelOffset.y = -(floor(temp) - UPPER_BOUND);

    vec2 translate;
    translate.y = (temp - floor(temp)) * SHIFT_LEFT16;

    temp = compressedAttribute0.z * SHIFT_RIGHT8;
    translate.x = floor(temp) - UPPER_BOUND;

    translate.y += (temp - floor(temp)) * SHIFT_LEFT8;
    translate.y -= UPPER_BOUND;

    temp = compressedAttribute1.x * SHIFT_RIGHT8;
    float temp2 = floor(compressedAttribute2.w * SHIFT_RIGHT2);

    vec2 imageSize = vec2(floor(temp), temp2);

#ifdef FRAGMENT_DEPTH_CHECK
    float labelHorizontalOrigin = floor(compressedAttribute2.w - (temp2 * SHIFT_LEFT2));
    float applyTranslate = 0.0;
    if (labelHorizontalOrigin != 0.0) // is a billboard, so set apply translate to false
    {
        applyTranslate = 1.0;
        labelHorizontalOrigin -= 2.0;
        depthOrigin.x = labelHorizontalOrigin + 1.0;
    }

    depthOrigin = vec2(1.0) - (depthOrigin * 0.5);
#endif

#ifdef EYE_DISTANCE_TRANSLUCENCY
    vec4 translucencyByDistance;
    translucencyByDistance.x = compressedAttribute1.z;
    translucencyByDistance.z = compressedAttribute1.w;

    translucencyByDistance.y = ((temp - floor(temp)) * SHIFT_LEFT8) / 255.0;

    temp = compressedAttribute1.y * SHIFT_RIGHT8;
    translucencyByDistance.w = ((temp - floor(temp)) * SHIFT_LEFT8) / 255.0;
#endif

#if defined(VERTEX_DEPTH_CHECK) || defined(FRAGMENT_DEPTH_CHECK)
    temp = compressedAttribute3.w;
    temp = temp * SHIFT_RIGHT12;

    vec2 dimensions;
    dimensions.y = (temp - floor(temp)) * SHIFT_LEFT12;
    dimensions.x = floor(temp);
#endif

#ifdef ALIGNED_AXIS
    vec3 alignedAxis = czm_octDecode(floor(compressedAttribute1.y * SHIFT_RIGHT8));
    temp = compressedAttribute2.z * SHIFT_RIGHT5;
    bool validAlignedAxis = (temp - floor(temp)) * SHIFT_LEFT1 > 0.0;
#else
    vec3 alignedAxis = vec3(0.0);
    bool validAlignedAxis = false;
#endif

    vec4 pickColor;
    vec4 color;

    temp = compressedAttribute2.y;
    temp = temp * SHIFT_RIGHT8;
    pickColor.b = (temp - floor(temp)) * SHIFT_LEFT8;
    temp = floor(temp) * SHIFT_RIGHT8;
    pickColor.g = (temp - floor(temp)) * SHIFT_LEFT8;
    pickColor.r = floor(temp);

    temp = compressedAttribute2.x;
    temp = temp * SHIFT_RIGHT8;
    color.b = (temp - floor(temp)) * SHIFT_LEFT8;
    temp = floor(temp) * SHIFT_RIGHT8;
    color.g = (temp - floor(temp)) * SHIFT_LEFT8;
    color.r = floor(temp);

    temp = compressedAttribute2.z * SHIFT_RIGHT8;
    bool sizeInMeters = floor((temp - floor(temp)) * SHIFT_LEFT7) > 0.0;
    temp = floor(temp) * SHIFT_RIGHT8;

    pickColor.a = (temp - floor(temp)) * SHIFT_LEFT8;
    pickColor /= 255.0;

    color.a = floor(temp);
    color /= 255.0;

    ///////////////////////////////////////////////////////////////////////////

    vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);
    vec4 positionEC = czm_modelViewRelativeToEye * p;

#if defined(FRAGMENT_DEPTH_CHECK) || defined(VERTEX_DEPTH_CHECK)
    float eyeDepth = positionEC.z;
#endif

    positionEC = czm_eyeOffset(positionEC, eyeOffset.xyz);
    positionEC.xyz *= show;

    ///////////////////////////////////////////////////////////////////////////

#if defined(EYE_DISTANCE_SCALING) || defined(EYE_DISTANCE_TRANSLUCENCY) || defined(EYE_DISTANCE_PIXEL_OFFSET) || defined(DISTANCE_DISPLAY_CONDITION) || defined(DISABLE_DEPTH_DISTANCE)
    float lengthSq;
    if (czm_sceneMode == czm_sceneMode2D)
    {
        // 2D camera distance is a special case
        // treat all billboards as flattened to the z=0.0 plane
        lengthSq = czm_eyeHeight2D.y;
    }
    else
    {
        lengthSq = dot(positionEC.xyz, positionEC.xyz);
    }
#endif

#ifdef EYE_DISTANCE_SCALING
    float distanceScale = czm_nearFarScalar(scaleByDistance, lengthSq);
    scale *= distanceScale;
    translate *= distanceScale;
    // push vertex behind near plane for clipping
    if (scale == 0.0)
    {
        positionEC.xyz = vec3(0.0);
    }
#endif

    float translucency = 1.0;
#ifdef EYE_DISTANCE_TRANSLUCENCY
    translucency = czm_nearFarScalar(translucencyByDistance, lengthSq);
    // push vertex behind near plane for clipping
    if (translucency == 0.0)
    {
        positionEC.xyz = vec3(0.0);
    }
#endif

#ifdef EYE_DISTANCE_PIXEL_OFFSET
    float pixelOffsetScale = czm_nearFarScalar(pixelOffsetScaleByDistance, lengthSq);
    pixelOffset *= pixelOffsetScale;
#endif

#ifdef DISTANCE_DISPLAY_CONDITION
    float nearSq = compressedAttribute3.x;
    float farSq = compressedAttribute3.y;
    if (lengthSq < nearSq || lengthSq > farSq)
    {
        positionEC.xyz = vec3(0.0);
    }
#endif

    mat2 rotationMatrix;
    float mpp;

#ifdef DISABLE_DEPTH_DISTANCE
    float disableDepthTestDistance = compressedAttribute3.z;
#endif

#ifdef VERTEX_DEPTH_CHECK
if (lengthSq < disableDepthTestDistance) {
    float depthsilon = 10.0;

    vec2 labelTranslate = textureCoordinateBoundsOrLabelTranslate.xy;
    vec4 pEC1 = addScreenSpaceOffset(positionEC, dimensions, scale, vec2(0.0), origin, labelTranslate, pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
    float globeDepth1 = getGlobeDepth(pEC1);

    if (globeDepth1 != 0.0 && pEC1.z + depthsilon < globeDepth1)
    {
        vec4 pEC2 = addScreenSpaceOffset(positionEC, dimensions, scale, vec2(0.0, 1.0), origin, labelTranslate, pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
        float globeDepth2 = getGlobeDepth(pEC2);

        if (globeDepth2 != 0.0 && pEC2.z + depthsilon < globeDepth2)
        {
            vec4 pEC3 = addScreenSpaceOffset(positionEC, dimensions, scale, vec2(1.0), origin, labelTranslate, pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
            float globeDepth3 = getGlobeDepth(pEC3);
            if (globeDepth3 != 0.0 && pEC3.z + depthsilon < globeDepth3)
            {
                positionEC.xyz = vec3(0.0);
            }
        }
    }
}
#endif

    positionEC = addScreenSpaceOffset(positionEC, imageSize, scale, direction, origin, translate, pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
    gl_Position = czm_projection * positionEC;
    v_textureCoordinates = textureCoordinates;

#ifdef LOG_DEPTH
    czm_vertexLogDepth();
#endif

#ifdef DISABLE_DEPTH_DISTANCE
    if (disableDepthTestDistance == 0.0 && czm_minimumDisableDepthTestDistance != 0.0)
    {
        disableDepthTestDistance = czm_minimumDisableDepthTestDistance;
    }

    if (disableDepthTestDistance != 0.0)
    {
        // Don't try to "multiply both sides" by w.  Greater/less-than comparisons won't work for negative values of w.
        float zclip = gl_Position.z / gl_Position.w;
        bool clipped = (zclip < -1.0 || zclip > 1.0);
        if (!clipped && (disableDepthTestDistance < 0.0 || (lengthSq > 0.0 && lengthSq < disableDepthTestDistance)))
        {
            // Position z on the near plane.
            gl_Position.z = -gl_Position.w;
#ifdef LOG_DEPTH
            v_depthFromNearPlusOne = 1.0;
#endif
        }
    }
#endif

#ifdef FRAGMENT_DEPTH_CHECK
    if (sizeInMeters) {
        translate /= mpp;
        dimensions /= mpp;
        imageSize /= mpp;
    }

#if defined(ROTATION) || defined(ALIGNED_AXIS)
    v_rotationMatrix = rotationMatrix;
#else
    v_rotationMatrix = mat2(1.0, 0.0, 0.0, 1.0);
#endif

    float enableDepthCheck = 0.0;
    if (lengthSq < disableDepthTestDistance)
    {
        enableDepthCheck = 1.0;
    }

    float dw = floor(clamp(dimensions.x, 0.0, SHIFT_LEFT12));
    float dh = floor(clamp(dimensions.y, 0.0, SHIFT_LEFT12));

    float iw = floor(clamp(imageSize.x, 0.0, SHIFT_LEFT12));
    float ih = floor(clamp(imageSize.y, 0.0, SHIFT_LEFT12));

    v_compressed.x = eyeDepth;
    v_compressed.y = applyTranslate * SHIFT_LEFT1 + enableDepthCheck;
    v_compressed.z = dw * SHIFT_LEFT12 + dh;
    v_compressed.w = iw * SHIFT_LEFT12 + ih;
    v_originTextureCoordinateAndTranslate.xy = depthOrigin;
    v_originTextureCoordinateAndTranslate.zw = translate;
    v_textureCoordinateBounds = textureCoordinateBoundsOrLabelTranslate;

#endif

#ifdef SDF
    vec4 outlineColor;
    float outlineWidth;

    temp = sdf.x;
    temp = temp * SHIFT_RIGHT8;
    outlineColor.b = (temp - floor(temp)) * SHIFT_LEFT8;
    temp = floor(temp) * SHIFT_RIGHT8;
    outlineColor.g = (temp - floor(temp)) * SHIFT_LEFT8;
    outlineColor.r = floor(temp);

    temp = sdf.y;
    temp = temp * SHIFT_RIGHT8;
    float temp3 = (temp - floor(temp)) * SHIFT_LEFT8;
    temp = floor(temp) * SHIFT_RIGHT8;
    outlineWidth = (temp - floor(temp)) * SHIFT_LEFT8;
    outlineColor.a = floor(temp);
    outlineColor /= 255.0;

    v_outlineWidth = outlineWidth / 255.0;
    v_outlineColor = outlineColor;
    v_outlineColor.a *= translucency;
#endif

    v_pickColor = pickColor;

    v_color = color;
    v_color.a *= translucency;

}
`;

// node_modules/cesium/Source/Scene/SceneTransforms.js
var SceneTransforms = {};
var actualPositionScratch = new Cartesian4_default(0, 0, 0, 1);
var positionCC = new Cartesian4_default();
var scratchViewport2 = new BoundingRectangle_default();
var scratchWindowCoord0 = new Cartesian2_default();
var scratchWindowCoord1 = new Cartesian2_default();
SceneTransforms.wgs84ToWindowCoordinates = function(scene, position, result) {
  return SceneTransforms.wgs84WithEyeOffsetToWindowCoordinates(
    scene,
    position,
    Cartesian3_default.ZERO,
    result
  );
};
var scratchCartesian44 = new Cartesian4_default();
var scratchEyeOffset = new Cartesian3_default();
function worldToClip(position, eyeOffset, camera, result) {
  const viewMatrix = camera.viewMatrix;
  const positionEC = Matrix4_default.multiplyByVector(
    viewMatrix,
    Cartesian4_default.fromElements(
      position.x,
      position.y,
      position.z,
      1,
      scratchCartesian44
    ),
    scratchCartesian44
  );
  const zEyeOffset = Cartesian3_default.multiplyComponents(
    eyeOffset,
    Cartesian3_default.normalize(positionEC, scratchEyeOffset),
    scratchEyeOffset
  );
  positionEC.x += eyeOffset.x + zEyeOffset.x;
  positionEC.y += eyeOffset.y + zEyeOffset.y;
  positionEC.z += zEyeOffset.z;
  return Matrix4_default.multiplyByVector(
    camera.frustum.projectionMatrix,
    positionEC,
    result
  );
}
var scratchMaxCartographic = new Cartographic_default(
  Math.PI,
  Math_default.PI_OVER_TWO
);
var scratchProjectedCartesian = new Cartesian3_default();
var scratchCameraPosition = new Cartesian3_default();
SceneTransforms.wgs84WithEyeOffsetToWindowCoordinates = function(scene, position, eyeOffset, result) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  if (!defined_default(position)) {
    throw new DeveloperError_default("position is required.");
  }
  const frameState = scene.frameState;
  const actualPosition = SceneTransforms.computeActualWgs84Position(
    frameState,
    position,
    actualPositionScratch
  );
  if (!defined_default(actualPosition)) {
    return void 0;
  }
  const canvas = scene.canvas;
  const viewport = scratchViewport2;
  viewport.x = 0;
  viewport.y = 0;
  viewport.width = canvas.clientWidth;
  viewport.height = canvas.clientHeight;
  const camera = scene.camera;
  let cameraCentered = false;
  if (frameState.mode === SceneMode_default.SCENE2D) {
    const projection = scene.mapProjection;
    const maxCartographic = scratchMaxCartographic;
    const maxCoord = projection.project(
      maxCartographic,
      scratchProjectedCartesian
    );
    const cameraPosition = Cartesian3_default.clone(
      camera.position,
      scratchCameraPosition
    );
    const frustum = camera.frustum.clone();
    const viewportTransformation = Matrix4_default.computeViewportTransformation(
      viewport,
      0,
      1,
      new Matrix4_default()
    );
    const projectionMatrix = camera.frustum.projectionMatrix;
    const x = camera.positionWC.y;
    const eyePoint = Cartesian3_default.fromElements(
      Math_default.sign(x) * maxCoord.x - x,
      0,
      -camera.positionWC.x
    );
    const windowCoordinates = Transforms_default.pointToGLWindowCoordinates(
      projectionMatrix,
      viewportTransformation,
      eyePoint
    );
    if (x === 0 || windowCoordinates.x <= 0 || windowCoordinates.x >= canvas.clientWidth) {
      cameraCentered = true;
    } else {
      if (windowCoordinates.x > canvas.clientWidth * 0.5) {
        viewport.width = windowCoordinates.x;
        camera.frustum.right = maxCoord.x - x;
        positionCC = worldToClip(actualPosition, eyeOffset, camera, positionCC);
        SceneTransforms.clipToGLWindowCoordinates(
          viewport,
          positionCC,
          scratchWindowCoord0
        );
        viewport.x += windowCoordinates.x;
        camera.position.x = -camera.position.x;
        const right = camera.frustum.right;
        camera.frustum.right = -camera.frustum.left;
        camera.frustum.left = -right;
        positionCC = worldToClip(actualPosition, eyeOffset, camera, positionCC);
        SceneTransforms.clipToGLWindowCoordinates(
          viewport,
          positionCC,
          scratchWindowCoord1
        );
      } else {
        viewport.x += windowCoordinates.x;
        viewport.width -= windowCoordinates.x;
        camera.frustum.left = -maxCoord.x - x;
        positionCC = worldToClip(actualPosition, eyeOffset, camera, positionCC);
        SceneTransforms.clipToGLWindowCoordinates(
          viewport,
          positionCC,
          scratchWindowCoord0
        );
        viewport.x = viewport.x - viewport.width;
        camera.position.x = -camera.position.x;
        const left = camera.frustum.left;
        camera.frustum.left = -camera.frustum.right;
        camera.frustum.right = -left;
        positionCC = worldToClip(actualPosition, eyeOffset, camera, positionCC);
        SceneTransforms.clipToGLWindowCoordinates(
          viewport,
          positionCC,
          scratchWindowCoord1
        );
      }
      Cartesian3_default.clone(cameraPosition, camera.position);
      camera.frustum = frustum.clone();
      result = Cartesian2_default.clone(scratchWindowCoord0, result);
      if (result.x < 0 || result.x > canvas.clientWidth) {
        result.x = scratchWindowCoord1.x;
      }
    }
  }
  if (frameState.mode !== SceneMode_default.SCENE2D || cameraCentered) {
    positionCC = worldToClip(actualPosition, eyeOffset, camera, positionCC);
    if (positionCC.z < 0 && !(camera.frustum instanceof OrthographicFrustum_default) && !(camera.frustum instanceof OrthographicOffCenterFrustum_default)) {
      return void 0;
    }
    result = SceneTransforms.clipToGLWindowCoordinates(
      viewport,
      positionCC,
      result
    );
  }
  result.y = canvas.clientHeight - result.y;
  return result;
};
SceneTransforms.wgs84ToDrawingBufferCoordinates = function(scene, position, result) {
  result = SceneTransforms.wgs84ToWindowCoordinates(scene, position, result);
  if (!defined_default(result)) {
    return void 0;
  }
  return SceneTransforms.transformWindowToDrawingBuffer(scene, result, result);
};
var projectedPosition = new Cartesian3_default();
var positionInCartographic = new Cartographic_default();
SceneTransforms.computeActualWgs84Position = function(frameState, position, result) {
  const mode2 = frameState.mode;
  if (mode2 === SceneMode_default.SCENE3D) {
    return Cartesian3_default.clone(position, result);
  }
  const projection = frameState.mapProjection;
  const cartographic2 = projection.ellipsoid.cartesianToCartographic(
    position,
    positionInCartographic
  );
  if (!defined_default(cartographic2)) {
    return void 0;
  }
  projection.project(cartographic2, projectedPosition);
  if (mode2 === SceneMode_default.COLUMBUS_VIEW) {
    return Cartesian3_default.fromElements(
      projectedPosition.z,
      projectedPosition.x,
      projectedPosition.y,
      result
    );
  }
  if (mode2 === SceneMode_default.SCENE2D) {
    return Cartesian3_default.fromElements(
      0,
      projectedPosition.x,
      projectedPosition.y,
      result
    );
  }
  const morphTime = frameState.morphTime;
  return Cartesian3_default.fromElements(
    Math_default.lerp(projectedPosition.z, position.x, morphTime),
    Math_default.lerp(projectedPosition.x, position.y, morphTime),
    Math_default.lerp(projectedPosition.y, position.z, morphTime),
    result
  );
};
var positionNDC = new Cartesian3_default();
var positionWC = new Cartesian3_default();
var viewportTransform = new Matrix4_default();
SceneTransforms.clipToGLWindowCoordinates = function(viewport, position, result) {
  Cartesian3_default.divideByScalar(position, position.w, positionNDC);
  Matrix4_default.computeViewportTransformation(viewport, 0, 1, viewportTransform);
  Matrix4_default.multiplyByPoint(viewportTransform, positionNDC, positionWC);
  return Cartesian2_default.fromCartesian3(positionWC, result);
};
SceneTransforms.transformWindowToDrawingBuffer = function(scene, windowPosition, result) {
  const canvas = scene.canvas;
  const xScale = scene.drawingBufferWidth / canvas.clientWidth;
  const yScale = scene.drawingBufferHeight / canvas.clientHeight;
  return Cartesian2_default.fromElements(
    windowPosition.x * xScale,
    windowPosition.y * yScale,
    result
  );
};
var scratchNDC = new Cartesian4_default();
var scratchWorldCoords = new Cartesian4_default();
SceneTransforms.drawingBufferToWgs84Coordinates = function(scene, drawingBufferPosition, depth, result) {
  const context = scene.context;
  const uniformState = context.uniformState;
  const currentFrustum = uniformState.currentFrustum;
  const near = currentFrustum.x;
  const far = currentFrustum.y;
  if (scene.frameState.useLogDepth) {
    const log2Depth = depth * uniformState.log2FarDepthFromNearPlusOne;
    const depthFromNear = Math.pow(2, log2Depth) - 1;
    depth = far * (1 - near / (depthFromNear + near)) / (far - near);
  }
  const viewport = scene.view.passState.viewport;
  const ndc = Cartesian4_default.clone(Cartesian4_default.UNIT_W, scratchNDC);
  ndc.x = (drawingBufferPosition.x - viewport.x) / viewport.width * 2 - 1;
  ndc.y = (drawingBufferPosition.y - viewport.y) / viewport.height * 2 - 1;
  ndc.z = depth * 2 - 1;
  ndc.w = 1;
  let worldCoords;
  let frustum = scene.camera.frustum;
  if (!defined_default(frustum.fovy)) {
    if (defined_default(frustum._offCenterFrustum)) {
      frustum = frustum._offCenterFrustum;
    }
    worldCoords = scratchWorldCoords;
    worldCoords.x = (ndc.x * (frustum.right - frustum.left) + frustum.left + frustum.right) * 0.5;
    worldCoords.y = (ndc.y * (frustum.top - frustum.bottom) + frustum.bottom + frustum.top) * 0.5;
    worldCoords.z = (ndc.z * (near - far) - near - far) * 0.5;
    worldCoords.w = 1;
    worldCoords = Matrix4_default.multiplyByVector(
      uniformState.inverseView,
      worldCoords,
      worldCoords
    );
  } else {
    worldCoords = Matrix4_default.multiplyByVector(
      uniformState.inverseViewProjection,
      ndc,
      scratchWorldCoords
    );
    const w = 1 / worldCoords.w;
    Cartesian3_default.multiplyByScalar(worldCoords, w, worldCoords);
  }
  return Cartesian3_default.fromCartesian4(worldCoords, result);
};
var SceneTransforms_default = SceneTransforms;

// node_modules/cesium/Source/Scene/Billboard.js
function Billboard(options, billboardCollection) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (defined_default(options.disableDepthTestDistance) && options.disableDepthTestDistance < 0) {
    throw new DeveloperError_default(
      "disableDepthTestDistance must be greater than or equal to 0.0."
    );
  }
  let translucencyByDistance = options.translucencyByDistance;
  let pixelOffsetScaleByDistance = options.pixelOffsetScaleByDistance;
  let scaleByDistance = options.scaleByDistance;
  let distanceDisplayCondition = options.distanceDisplayCondition;
  if (defined_default(translucencyByDistance)) {
    if (translucencyByDistance.far <= translucencyByDistance.near) {
      throw new DeveloperError_default(
        "translucencyByDistance.far must be greater than translucencyByDistance.near."
      );
    }
    translucencyByDistance = NearFarScalar_default.clone(translucencyByDistance);
  }
  if (defined_default(pixelOffsetScaleByDistance)) {
    if (pixelOffsetScaleByDistance.far <= pixelOffsetScaleByDistance.near) {
      throw new DeveloperError_default(
        "pixelOffsetScaleByDistance.far must be greater than pixelOffsetScaleByDistance.near."
      );
    }
    pixelOffsetScaleByDistance = NearFarScalar_default.clone(
      pixelOffsetScaleByDistance
    );
  }
  if (defined_default(scaleByDistance)) {
    if (scaleByDistance.far <= scaleByDistance.near) {
      throw new DeveloperError_default(
        "scaleByDistance.far must be greater than scaleByDistance.near."
      );
    }
    scaleByDistance = NearFarScalar_default.clone(scaleByDistance);
  }
  if (defined_default(distanceDisplayCondition)) {
    if (distanceDisplayCondition.far <= distanceDisplayCondition.near) {
      throw new DeveloperError_default(
        "distanceDisplayCondition.far must be greater than distanceDisplayCondition.near."
      );
    }
    distanceDisplayCondition = DistanceDisplayCondition_default.clone(
      distanceDisplayCondition
    );
  }
  this._show = defaultValue_default(options.show, true);
  this._position = Cartesian3_default.clone(
    defaultValue_default(options.position, Cartesian3_default.ZERO)
  );
  this._actualPosition = Cartesian3_default.clone(this._position);
  this._pixelOffset = Cartesian2_default.clone(
    defaultValue_default(options.pixelOffset, Cartesian2_default.ZERO)
  );
  this._translate = new Cartesian2_default(0, 0);
  this._eyeOffset = Cartesian3_default.clone(
    defaultValue_default(options.eyeOffset, Cartesian3_default.ZERO)
  );
  this._heightReference = defaultValue_default(
    options.heightReference,
    HeightReference_default.NONE
  );
  this._verticalOrigin = defaultValue_default(
    options.verticalOrigin,
    VerticalOrigin_default.CENTER
  );
  this._horizontalOrigin = defaultValue_default(
    options.horizontalOrigin,
    HorizontalOrigin_default.CENTER
  );
  this._scale = defaultValue_default(options.scale, 1);
  this._color = Color_default.clone(defaultValue_default(options.color, Color_default.WHITE));
  this._rotation = defaultValue_default(options.rotation, 0);
  this._alignedAxis = Cartesian3_default.clone(
    defaultValue_default(options.alignedAxis, Cartesian3_default.ZERO)
  );
  this._width = options.width;
  this._height = options.height;
  this._scaleByDistance = scaleByDistance;
  this._translucencyByDistance = translucencyByDistance;
  this._pixelOffsetScaleByDistance = pixelOffsetScaleByDistance;
  this._sizeInMeters = defaultValue_default(options.sizeInMeters, false);
  this._distanceDisplayCondition = distanceDisplayCondition;
  this._disableDepthTestDistance = options.disableDepthTestDistance;
  this._id = options.id;
  this._collection = defaultValue_default(options.collection, billboardCollection);
  this._pickId = void 0;
  this._pickPrimitive = defaultValue_default(options._pickPrimitive, this);
  this._billboardCollection = billboardCollection;
  this._dirty = false;
  this._index = -1;
  this._batchIndex = void 0;
  this._imageIndex = -1;
  this._imageIndexPromise = void 0;
  this._imageId = void 0;
  this._image = void 0;
  this._imageSubRegion = void 0;
  this._imageWidth = void 0;
  this._imageHeight = void 0;
  this._labelDimensions = void 0;
  this._labelHorizontalOrigin = void 0;
  this._labelTranslate = void 0;
  const image = options.image;
  let imageId = options.imageId;
  if (defined_default(image)) {
    if (!defined_default(imageId)) {
      if (typeof image === "string") {
        imageId = image;
      } else if (defined_default(image.src)) {
        imageId = image.src;
      } else {
        imageId = createGuid_default();
      }
    }
    this._imageId = imageId;
    this._image = image;
  }
  if (defined_default(options.imageSubRegion)) {
    this._imageId = imageId;
    this._imageSubRegion = options.imageSubRegion;
  }
  if (defined_default(this._billboardCollection._textureAtlas)) {
    this._loadImage();
  }
  this._actualClampedPosition = void 0;
  this._removeCallbackFunc = void 0;
  this._mode = SceneMode_default.SCENE3D;
  this._clusterShow = true;
  this._outlineColor = Color_default.clone(
    defaultValue_default(options.outlineColor, Color_default.BLACK)
  );
  this._outlineWidth = defaultValue_default(options.outlineWidth, 0);
  this._updateClamping();
}
var SHOW_INDEX = Billboard.SHOW_INDEX = 0;
var POSITION_INDEX = Billboard.POSITION_INDEX = 1;
var PIXEL_OFFSET_INDEX = Billboard.PIXEL_OFFSET_INDEX = 2;
var EYE_OFFSET_INDEX = Billboard.EYE_OFFSET_INDEX = 3;
var HORIZONTAL_ORIGIN_INDEX = Billboard.HORIZONTAL_ORIGIN_INDEX = 4;
var VERTICAL_ORIGIN_INDEX = Billboard.VERTICAL_ORIGIN_INDEX = 5;
var SCALE_INDEX = Billboard.SCALE_INDEX = 6;
var IMAGE_INDEX_INDEX = Billboard.IMAGE_INDEX_INDEX = 7;
var COLOR_INDEX = Billboard.COLOR_INDEX = 8;
var ROTATION_INDEX = Billboard.ROTATION_INDEX = 9;
var ALIGNED_AXIS_INDEX = Billboard.ALIGNED_AXIS_INDEX = 10;
var SCALE_BY_DISTANCE_INDEX = Billboard.SCALE_BY_DISTANCE_INDEX = 11;
var TRANSLUCENCY_BY_DISTANCE_INDEX = Billboard.TRANSLUCENCY_BY_DISTANCE_INDEX = 12;
var PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX = Billboard.PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX = 13;
var DISTANCE_DISPLAY_CONDITION = Billboard.DISTANCE_DISPLAY_CONDITION = 14;
var DISABLE_DEPTH_DISTANCE = Billboard.DISABLE_DEPTH_DISTANCE = 15;
Billboard.TEXTURE_COORDINATE_BOUNDS = 16;
var SDF_INDEX = Billboard.SDF_INDEX = 17;
Billboard.NUMBER_OF_PROPERTIES = 18;
function makeDirty(billboard, propertyChanged) {
  const billboardCollection = billboard._billboardCollection;
  if (defined_default(billboardCollection)) {
    billboardCollection._updateBillboard(billboard, propertyChanged);
    billboard._dirty = true;
  }
}
Object.defineProperties(Billboard.prototype, {
  show: {
    get: function() {
      return this._show;
    },
    set: function(value) {
      Check_default.typeOf.bool("value", value);
      if (this._show !== value) {
        this._show = value;
        makeDirty(this, SHOW_INDEX);
      }
    }
  },
  position: {
    get: function() {
      return this._position;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      const position = this._position;
      if (!Cartesian3_default.equals(position, value)) {
        Cartesian3_default.clone(value, position);
        Cartesian3_default.clone(value, this._actualPosition);
        this._updateClamping();
        makeDirty(this, POSITION_INDEX);
      }
    }
  },
  heightReference: {
    get: function() {
      return this._heightReference;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      const heightReference = this._heightReference;
      if (value !== heightReference) {
        this._heightReference = value;
        this._updateClamping();
        makeDirty(this, POSITION_INDEX);
      }
    }
  },
  pixelOffset: {
    get: function() {
      return this._pixelOffset;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      const pixelOffset = this._pixelOffset;
      if (!Cartesian2_default.equals(pixelOffset, value)) {
        Cartesian2_default.clone(value, pixelOffset);
        makeDirty(this, PIXEL_OFFSET_INDEX);
      }
    }
  },
  scaleByDistance: {
    get: function() {
      return this._scaleByDistance;
    },
    set: function(value) {
      if (defined_default(value)) {
        Check_default.typeOf.object("value", value);
        if (value.far <= value.near) {
          throw new DeveloperError_default(
            "far distance must be greater than near distance."
          );
        }
      }
      const scaleByDistance = this._scaleByDistance;
      if (!NearFarScalar_default.equals(scaleByDistance, value)) {
        this._scaleByDistance = NearFarScalar_default.clone(value, scaleByDistance);
        makeDirty(this, SCALE_BY_DISTANCE_INDEX);
      }
    }
  },
  translucencyByDistance: {
    get: function() {
      return this._translucencyByDistance;
    },
    set: function(value) {
      if (defined_default(value)) {
        Check_default.typeOf.object("value", value);
        if (value.far <= value.near) {
          throw new DeveloperError_default(
            "far distance must be greater than near distance."
          );
        }
      }
      const translucencyByDistance = this._translucencyByDistance;
      if (!NearFarScalar_default.equals(translucencyByDistance, value)) {
        this._translucencyByDistance = NearFarScalar_default.clone(
          value,
          translucencyByDistance
        );
        makeDirty(this, TRANSLUCENCY_BY_DISTANCE_INDEX);
      }
    }
  },
  pixelOffsetScaleByDistance: {
    get: function() {
      return this._pixelOffsetScaleByDistance;
    },
    set: function(value) {
      if (defined_default(value)) {
        Check_default.typeOf.object("value", value);
        if (value.far <= value.near) {
          throw new DeveloperError_default(
            "far distance must be greater than near distance."
          );
        }
      }
      const pixelOffsetScaleByDistance = this._pixelOffsetScaleByDistance;
      if (!NearFarScalar_default.equals(pixelOffsetScaleByDistance, value)) {
        this._pixelOffsetScaleByDistance = NearFarScalar_default.clone(
          value,
          pixelOffsetScaleByDistance
        );
        makeDirty(this, PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX);
      }
    }
  },
  eyeOffset: {
    get: function() {
      return this._eyeOffset;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      const eyeOffset = this._eyeOffset;
      if (!Cartesian3_default.equals(eyeOffset, value)) {
        Cartesian3_default.clone(value, eyeOffset);
        makeDirty(this, EYE_OFFSET_INDEX);
      }
    }
  },
  horizontalOrigin: {
    get: function() {
      return this._horizontalOrigin;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      if (this._horizontalOrigin !== value) {
        this._horizontalOrigin = value;
        makeDirty(this, HORIZONTAL_ORIGIN_INDEX);
      }
    }
  },
  verticalOrigin: {
    get: function() {
      return this._verticalOrigin;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      if (this._verticalOrigin !== value) {
        this._verticalOrigin = value;
        makeDirty(this, VERTICAL_ORIGIN_INDEX);
      }
    }
  },
  scale: {
    get: function() {
      return this._scale;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      if (this._scale !== value) {
        this._scale = value;
        makeDirty(this, SCALE_INDEX);
      }
    }
  },
  color: {
    get: function() {
      return this._color;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      const color = this._color;
      if (!Color_default.equals(color, value)) {
        Color_default.clone(value, color);
        makeDirty(this, COLOR_INDEX);
      }
    }
  },
  rotation: {
    get: function() {
      return this._rotation;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      if (this._rotation !== value) {
        this._rotation = value;
        makeDirty(this, ROTATION_INDEX);
      }
    }
  },
  alignedAxis: {
    get: function() {
      return this._alignedAxis;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      const alignedAxis = this._alignedAxis;
      if (!Cartesian3_default.equals(alignedAxis, value)) {
        Cartesian3_default.clone(value, alignedAxis);
        makeDirty(this, ALIGNED_AXIS_INDEX);
      }
    }
  },
  width: {
    get: function() {
      return defaultValue_default(this._width, this._imageWidth);
    },
    set: function(value) {
      if (defined_default(value)) {
        Check_default.typeOf.number("value", value);
      }
      if (this._width !== value) {
        this._width = value;
        makeDirty(this, IMAGE_INDEX_INDEX);
      }
    }
  },
  height: {
    get: function() {
      return defaultValue_default(this._height, this._imageHeight);
    },
    set: function(value) {
      if (defined_default(value)) {
        Check_default.typeOf.number("value", value);
      }
      if (this._height !== value) {
        this._height = value;
        makeDirty(this, IMAGE_INDEX_INDEX);
      }
    }
  },
  sizeInMeters: {
    get: function() {
      return this._sizeInMeters;
    },
    set: function(value) {
      Check_default.typeOf.bool("value", value);
      if (this._sizeInMeters !== value) {
        this._sizeInMeters = value;
        makeDirty(this, COLOR_INDEX);
      }
    }
  },
  distanceDisplayCondition: {
    get: function() {
      return this._distanceDisplayCondition;
    },
    set: function(value) {
      if (!DistanceDisplayCondition_default.equals(value, this._distanceDisplayCondition)) {
        if (defined_default(value)) {
          Check_default.typeOf.object("value", value);
          if (value.far <= value.near) {
            throw new DeveloperError_default(
              "far distance must be greater than near distance."
            );
          }
        }
        this._distanceDisplayCondition = DistanceDisplayCondition_default.clone(
          value,
          this._distanceDisplayCondition
        );
        makeDirty(this, DISTANCE_DISPLAY_CONDITION);
      }
    }
  },
  disableDepthTestDistance: {
    get: function() {
      return this._disableDepthTestDistance;
    },
    set: function(value) {
      if (defined_default(value)) {
        Check_default.typeOf.number("value", value);
        if (value < 0) {
          throw new DeveloperError_default(
            "disableDepthTestDistance must be greater than or equal to 0.0."
          );
        }
      }
      if (this._disableDepthTestDistance !== value) {
        this._disableDepthTestDistance = value;
        makeDirty(this, DISABLE_DEPTH_DISTANCE);
      }
    }
  },
  id: {
    get: function() {
      return this._id;
    },
    set: function(value) {
      this._id = value;
      if (defined_default(this._pickId)) {
        this._pickId.object.id = value;
      }
    }
  },
  pickPrimitive: {
    get: function() {
      return this._pickPrimitive;
    },
    set: function(value) {
      this._pickPrimitive = value;
      if (defined_default(this._pickId)) {
        this._pickId.object.primitive = value;
      }
    }
  },
  pickId: {
    get: function() {
      return this._pickId;
    }
  },
  image: {
    get: function() {
      return this._imageId;
    },
    set: function(value) {
      if (!defined_default(value)) {
        this._imageIndex = -1;
        this._imageSubRegion = void 0;
        this._imageId = void 0;
        this._image = void 0;
        this._imageIndexPromise = void 0;
        makeDirty(this, IMAGE_INDEX_INDEX);
      } else if (typeof value === "string") {
        this.setImage(value, value);
      } else if (value instanceof Resource_default) {
        this.setImage(value.url, value);
      } else if (defined_default(value.src)) {
        this.setImage(value.src, value);
      } else {
        this.setImage(createGuid_default(), value);
      }
    }
  },
  ready: {
    get: function() {
      return this._imageIndex !== -1;
    }
  },
  _clampedPosition: {
    get: function() {
      return this._actualClampedPosition;
    },
    set: function(value) {
      this._actualClampedPosition = Cartesian3_default.clone(
        value,
        this._actualClampedPosition
      );
      makeDirty(this, POSITION_INDEX);
    }
  },
  clusterShow: {
    get: function() {
      return this._clusterShow;
    },
    set: function(value) {
      if (this._clusterShow !== value) {
        this._clusterShow = value;
        makeDirty(this, SHOW_INDEX);
      }
    }
  },
  outlineColor: {
    get: function() {
      return this._outlineColor;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const outlineColor = this._outlineColor;
      if (!Color_default.equals(outlineColor, value)) {
        Color_default.clone(value, outlineColor);
        makeDirty(this, SDF_INDEX);
      }
    }
  },
  outlineWidth: {
    get: function() {
      return this._outlineWidth;
    },
    set: function(value) {
      if (this._outlineWidth !== value) {
        this._outlineWidth = value;
        makeDirty(this, SDF_INDEX);
      }
    }
  }
});
Billboard.prototype.getPickId = function(context) {
  if (!defined_default(this._pickId)) {
    this._pickId = context.createPickId({
      primitive: this._pickPrimitive,
      collection: this._collection,
      id: this._id
    });
  }
  return this._pickId;
};
Billboard.prototype._updateClamping = function() {
  Billboard._updateClamping(this._billboardCollection, this);
};
var scratchCartographic6 = new Cartographic_default();
var scratchPosition9 = new Cartesian3_default();
Billboard._updateClamping = function(collection, owner) {
  const scene = collection._scene;
  if (!defined_default(scene) || !defined_default(scene.globe)) {
    if (owner._heightReference !== HeightReference_default.NONE) {
      throw new DeveloperError_default(
        "Height reference is not supported without a scene and globe."
      );
    }
    return;
  }
  const globe = scene.globe;
  const ellipsoid = globe.ellipsoid;
  const surface = globe._surface;
  const mode2 = scene.frameState.mode;
  const modeChanged = mode2 !== owner._mode;
  owner._mode = mode2;
  if ((owner._heightReference === HeightReference_default.NONE || modeChanged) && defined_default(owner._removeCallbackFunc)) {
    owner._removeCallbackFunc();
    owner._removeCallbackFunc = void 0;
    owner._clampedPosition = void 0;
  }
  if (owner._heightReference === HeightReference_default.NONE || !defined_default(owner._position)) {
    return;
  }
  const position = ellipsoid.cartesianToCartographic(owner._position);
  if (!defined_default(position)) {
    owner._actualClampedPosition = void 0;
    return;
  }
  if (defined_default(owner._removeCallbackFunc)) {
    owner._removeCallbackFunc();
  }
  function updateFunction(clampedPosition) {
    if (owner._heightReference === HeightReference_default.RELATIVE_TO_GROUND) {
      if (owner._mode === SceneMode_default.SCENE3D) {
        const clampedCart = ellipsoid.cartesianToCartographic(
          clampedPosition,
          scratchCartographic6
        );
        clampedCart.height += position.height;
        ellipsoid.cartographicToCartesian(clampedCart, clampedPosition);
      } else {
        clampedPosition.x += position.height;
      }
    }
    owner._clampedPosition = Cartesian3_default.clone(
      clampedPosition,
      owner._clampedPosition
    );
  }
  owner._removeCallbackFunc = surface.updateHeight(position, updateFunction);
  Cartographic_default.clone(position, scratchCartographic6);
  const height = globe.getHeight(position);
  if (defined_default(height)) {
    scratchCartographic6.height = height;
  }
  ellipsoid.cartographicToCartesian(scratchCartographic6, scratchPosition9);
  updateFunction(scratchPosition9);
};
Billboard.prototype._loadImage = function() {
  const atlas = this._billboardCollection._textureAtlas;
  const imageId = this._imageId;
  const image = this._image;
  const imageSubRegion = this._imageSubRegion;
  let imageIndexPromise;
  const that = this;
  function completeImageLoad(index2) {
    if (that._imageId !== imageId || that._image !== image || !BoundingRectangle_default.equals(that._imageSubRegion, imageSubRegion)) {
      return;
    }
    const textureCoordinates = atlas.textureCoordinates[index2];
    that._imageWidth = atlas.texture.width * textureCoordinates.width;
    that._imageHeight = atlas.texture.height * textureCoordinates.height;
    that._imageIndex = index2;
    that._ready = true;
    that._image = void 0;
    that._imageIndexPromise = void 0;
    makeDirty(that, IMAGE_INDEX_INDEX);
  }
  if (defined_default(image)) {
    const index2 = atlas.getImageIndex(imageId);
    if (defined_default(index2)) {
      completeImageLoad(index2);
      return;
    }
    imageIndexPromise = atlas.addImage(imageId, image);
  }
  if (defined_default(imageSubRegion)) {
    imageIndexPromise = atlas.addSubRegion(imageId, imageSubRegion);
  }
  this._imageIndexPromise = imageIndexPromise;
  if (!defined_default(imageIndexPromise)) {
    return;
  }
  imageIndexPromise.then(completeImageLoad).catch(function(error) {
    console.error(`Error loading image for billboard: ${error}`);
    that._imageIndexPromise = void 0;
  });
};
Billboard.prototype.setImage = function(id, image) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required.");
  }
  if (!defined_default(image)) {
    throw new DeveloperError_default("image is required.");
  }
  if (this._imageId === id) {
    return;
  }
  this._imageIndex = -1;
  this._imageSubRegion = void 0;
  this._imageId = id;
  this._image = image;
  if (defined_default(this._billboardCollection._textureAtlas)) {
    this._loadImage();
  }
};
Billboard.prototype.setImageSubRegion = function(id, subRegion) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required.");
  }
  if (!defined_default(subRegion)) {
    throw new DeveloperError_default("subRegion is required.");
  }
  if (this._imageId === id && BoundingRectangle_default.equals(this._imageSubRegion, subRegion)) {
    return;
  }
  this._imageIndex = -1;
  this._imageId = id;
  this._imageSubRegion = BoundingRectangle_default.clone(subRegion);
  if (defined_default(this._billboardCollection._textureAtlas)) {
    this._loadImage();
  }
};
Billboard.prototype._setTranslate = function(value) {
  if (!defined_default(value)) {
    throw new DeveloperError_default("value is required.");
  }
  const translate = this._translate;
  if (!Cartesian2_default.equals(translate, value)) {
    Cartesian2_default.clone(value, translate);
    makeDirty(this, PIXEL_OFFSET_INDEX);
  }
};
Billboard.prototype._getActualPosition = function() {
  return defined_default(this._clampedPosition) ? this._clampedPosition : this._actualPosition;
};
Billboard.prototype._setActualPosition = function(value) {
  if (!defined_default(this._clampedPosition)) {
    Cartesian3_default.clone(value, this._actualPosition);
  }
  makeDirty(this, POSITION_INDEX);
};
var tempCartesian3 = new Cartesian4_default();
Billboard._computeActualPosition = function(billboard, position, frameState, modelMatrix) {
  if (defined_default(billboard._clampedPosition)) {
    if (frameState.mode !== billboard._mode) {
      billboard._updateClamping();
    }
    return billboard._clampedPosition;
  } else if (frameState.mode === SceneMode_default.SCENE3D) {
    return position;
  }
  Matrix4_default.multiplyByPoint(modelMatrix, position, tempCartesian3);
  return SceneTransforms_default.computeActualWgs84Position(frameState, tempCartesian3);
};
var scratchCartesian310 = new Cartesian3_default();
Billboard._computeScreenSpacePosition = function(modelMatrix, position, eyeOffset, pixelOffset, scene, result) {
  const positionWorld = Matrix4_default.multiplyByPoint(
    modelMatrix,
    position,
    scratchCartesian310
  );
  const positionWC2 = SceneTransforms_default.wgs84WithEyeOffsetToWindowCoordinates(
    scene,
    positionWorld,
    eyeOffset,
    result
  );
  if (!defined_default(positionWC2)) {
    return void 0;
  }
  Cartesian2_default.add(positionWC2, pixelOffset, positionWC2);
  return positionWC2;
};
var scratchPixelOffset = new Cartesian2_default(0, 0);
Billboard.prototype.computeScreenSpacePosition = function(scene, result) {
  const billboardCollection = this._billboardCollection;
  if (!defined_default(result)) {
    result = new Cartesian2_default();
  }
  if (!defined_default(billboardCollection)) {
    throw new DeveloperError_default(
      "Billboard must be in a collection.  Was it removed?"
    );
  }
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  Cartesian2_default.clone(this._pixelOffset, scratchPixelOffset);
  Cartesian2_default.add(scratchPixelOffset, this._translate, scratchPixelOffset);
  let modelMatrix = billboardCollection.modelMatrix;
  let position = this._position;
  if (defined_default(this._clampedPosition)) {
    position = this._clampedPosition;
    if (scene.mode !== SceneMode_default.SCENE3D) {
      const projection = scene.mapProjection;
      const ellipsoid = projection.ellipsoid;
      const cart = projection.unproject(position, scratchCartographic6);
      position = ellipsoid.cartographicToCartesian(cart, scratchCartesian310);
      modelMatrix = Matrix4_default.IDENTITY;
    }
  }
  const windowCoordinates = Billboard._computeScreenSpacePosition(
    modelMatrix,
    position,
    this._eyeOffset,
    scratchPixelOffset,
    scene,
    result
  );
  return windowCoordinates;
};
Billboard.getScreenSpaceBoundingBox = function(billboard, screenSpacePosition, result) {
  let width = billboard.width;
  let height = billboard.height;
  const scale = billboard.scale;
  width *= scale;
  height *= scale;
  let x = screenSpacePosition.x;
  if (billboard.horizontalOrigin === HorizontalOrigin_default.RIGHT) {
    x -= width;
  } else if (billboard.horizontalOrigin === HorizontalOrigin_default.CENTER) {
    x -= width * 0.5;
  }
  let y = screenSpacePosition.y;
  if (billboard.verticalOrigin === VerticalOrigin_default.BOTTOM || billboard.verticalOrigin === VerticalOrigin_default.BASELINE) {
    y -= height;
  } else if (billboard.verticalOrigin === VerticalOrigin_default.CENTER) {
    y -= height * 0.5;
  }
  if (!defined_default(result)) {
    result = new BoundingRectangle_default();
  }
  result.x = x;
  result.y = y;
  result.width = width;
  result.height = height;
  return result;
};
Billboard.prototype.equals = function(other) {
  return this === other || defined_default(other) && this._id === other._id && Cartesian3_default.equals(this._position, other._position) && this._imageId === other._imageId && this._show === other._show && this._scale === other._scale && this._verticalOrigin === other._verticalOrigin && this._horizontalOrigin === other._horizontalOrigin && this._heightReference === other._heightReference && BoundingRectangle_default.equals(this._imageSubRegion, other._imageSubRegion) && Color_default.equals(this._color, other._color) && Cartesian2_default.equals(this._pixelOffset, other._pixelOffset) && Cartesian2_default.equals(this._translate, other._translate) && Cartesian3_default.equals(this._eyeOffset, other._eyeOffset) && NearFarScalar_default.equals(this._scaleByDistance, other._scaleByDistance) && NearFarScalar_default.equals(
    this._translucencyByDistance,
    other._translucencyByDistance
  ) && NearFarScalar_default.equals(
    this._pixelOffsetScaleByDistance,
    other._pixelOffsetScaleByDistance
  ) && DistanceDisplayCondition_default.equals(
    this._distanceDisplayCondition,
    other._distanceDisplayCondition
  ) && this._disableDepthTestDistance === other._disableDepthTestDistance;
};
Billboard.prototype._destroy = function() {
  if (defined_default(this._customData)) {
    this._billboardCollection._scene.globe._surface.removeTileCustomData(
      this._customData
    );
    this._customData = void 0;
  }
  if (defined_default(this._removeCallbackFunc)) {
    this._removeCallbackFunc();
    this._removeCallbackFunc = void 0;
  }
  this.image = void 0;
  this._pickId = this._pickId && this._pickId.destroy();
  this._billboardCollection = void 0;
};
var Billboard_default = Billboard;

// node_modules/cesium/Source/Scene/BlendOption.js
var BlendOption = {
  OPAQUE: 0,
  TRANSLUCENT: 1,
  OPAQUE_AND_TRANSLUCENT: 2
};
var BlendOption_default = Object.freeze(BlendOption);

// node_modules/cesium/Source/Scene/SDFSettings.js
var SDFSettings = {
  FONT_SIZE: 48,
  PADDING: 10,
  RADIUS: 8,
  CUTOFF: 0.25
};
var SDFSettings_default = Object.freeze(SDFSettings);

// node_modules/cesium/Source/Scene/TextureAtlas.js
function TextureAtlasNode(bottomLeft, topRight, childNode1, childNode2, imageIndex) {
  this.bottomLeft = defaultValue_default(bottomLeft, Cartesian2_default.ZERO);
  this.topRight = defaultValue_default(topRight, Cartesian2_default.ZERO);
  this.childNode1 = childNode1;
  this.childNode2 = childNode2;
  this.imageIndex = imageIndex;
}
var defaultInitialSize = new Cartesian2_default(16, 16);
function TextureAtlas(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const borderWidthInPixels = defaultValue_default(options.borderWidthInPixels, 1);
  const initialSize = defaultValue_default(options.initialSize, defaultInitialSize);
  if (!defined_default(options.context)) {
    throw new DeveloperError_default("context is required.");
  }
  if (borderWidthInPixels < 0) {
    throw new DeveloperError_default(
      "borderWidthInPixels must be greater than or equal to zero."
    );
  }
  if (initialSize.x < 1 || initialSize.y < 1) {
    throw new DeveloperError_default("initialSize must be greater than zero.");
  }
  this._context = options.context;
  this._pixelFormat = defaultValue_default(options.pixelFormat, PixelFormat_default.RGBA);
  this._borderWidthInPixels = borderWidthInPixels;
  this._textureCoordinates = [];
  this._guid = createGuid_default();
  this._idHash = {};
  this._indexHash = {};
  this._initialSize = initialSize;
  this._root = void 0;
}
Object.defineProperties(TextureAtlas.prototype, {
  borderWidthInPixels: {
    get: function() {
      return this._borderWidthInPixels;
    }
  },
  textureCoordinates: {
    get: function() {
      return this._textureCoordinates;
    }
  },
  texture: {
    get: function() {
      if (!defined_default(this._texture)) {
        this._texture = new Texture_default({
          context: this._context,
          width: this._initialSize.x,
          height: this._initialSize.y,
          pixelFormat: this._pixelFormat
        });
      }
      return this._texture;
    }
  },
  numberOfImages: {
    get: function() {
      return this._textureCoordinates.length;
    }
  },
  guid: {
    get: function() {
      return this._guid;
    }
  }
});
function resizeAtlas(textureAtlas, image) {
  const context = textureAtlas._context;
  const numImages = textureAtlas.numberOfImages;
  const scalingFactor = 2;
  const borderWidthInPixels = textureAtlas._borderWidthInPixels;
  if (numImages > 0) {
    const oldAtlasWidth = textureAtlas._texture.width;
    const oldAtlasHeight = textureAtlas._texture.height;
    const atlasWidth = scalingFactor * (oldAtlasWidth + image.width + borderWidthInPixels);
    const atlasHeight = scalingFactor * (oldAtlasHeight + image.height + borderWidthInPixels);
    const widthRatio = oldAtlasWidth / atlasWidth;
    const heightRatio = oldAtlasHeight / atlasHeight;
    const nodeBottomRight = new TextureAtlasNode(
      new Cartesian2_default(oldAtlasWidth + borderWidthInPixels, borderWidthInPixels),
      new Cartesian2_default(atlasWidth, oldAtlasHeight)
    );
    const nodeBottomHalf = new TextureAtlasNode(
      new Cartesian2_default(),
      new Cartesian2_default(atlasWidth, oldAtlasHeight),
      textureAtlas._root,
      nodeBottomRight
    );
    const nodeTopHalf = new TextureAtlasNode(
      new Cartesian2_default(borderWidthInPixels, oldAtlasHeight + borderWidthInPixels),
      new Cartesian2_default(atlasWidth, atlasHeight)
    );
    const nodeMain = new TextureAtlasNode(
      new Cartesian2_default(),
      new Cartesian2_default(atlasWidth, atlasHeight),
      nodeBottomHalf,
      nodeTopHalf
    );
    for (let i2 = 0; i2 < textureAtlas._textureCoordinates.length; i2++) {
      const texCoord = textureAtlas._textureCoordinates[i2];
      if (defined_default(texCoord)) {
        texCoord.x *= widthRatio;
        texCoord.y *= heightRatio;
        texCoord.width *= widthRatio;
        texCoord.height *= heightRatio;
      }
    }
    const newTexture = new Texture_default({
      context: textureAtlas._context,
      width: atlasWidth,
      height: atlasHeight,
      pixelFormat: textureAtlas._pixelFormat
    });
    const framebuffer = new Framebuffer_default({
      context,
      colorTextures: [textureAtlas._texture],
      destroyAttachments: false
    });
    framebuffer._bind();
    newTexture.copyFromFramebuffer(0, 0, 0, 0, atlasWidth, atlasHeight);
    framebuffer._unBind();
    framebuffer.destroy();
    textureAtlas._texture = textureAtlas._texture && textureAtlas._texture.destroy();
    textureAtlas._texture = newTexture;
    textureAtlas._root = nodeMain;
  } else {
    let initialWidth = scalingFactor * (image.width + 2 * borderWidthInPixels);
    let initialHeight = scalingFactor * (image.height + 2 * borderWidthInPixels);
    if (initialWidth < textureAtlas._initialSize.x) {
      initialWidth = textureAtlas._initialSize.x;
    }
    if (initialHeight < textureAtlas._initialSize.y) {
      initialHeight = textureAtlas._initialSize.y;
    }
    textureAtlas._texture = textureAtlas._texture && textureAtlas._texture.destroy();
    textureAtlas._texture = new Texture_default({
      context: textureAtlas._context,
      width: initialWidth,
      height: initialHeight,
      pixelFormat: textureAtlas._pixelFormat
    });
    textureAtlas._root = new TextureAtlasNode(
      new Cartesian2_default(borderWidthInPixels, borderWidthInPixels),
      new Cartesian2_default(initialWidth, initialHeight)
    );
  }
}
function findNode2(textureAtlas, node, image) {
  if (!defined_default(node)) {
    return void 0;
  }
  if (!defined_default(node.childNode1) && !defined_default(node.childNode2)) {
    if (defined_default(node.imageIndex)) {
      return void 0;
    }
    const nodeWidth = node.topRight.x - node.bottomLeft.x;
    const nodeHeight = node.topRight.y - node.bottomLeft.y;
    const widthDifference = nodeWidth - image.width;
    const heightDifference = nodeHeight - image.height;
    if (widthDifference < 0 || heightDifference < 0) {
      return void 0;
    }
    if (widthDifference === 0 && heightDifference === 0) {
      return node;
    }
    if (widthDifference > heightDifference) {
      node.childNode1 = new TextureAtlasNode(
        new Cartesian2_default(node.bottomLeft.x, node.bottomLeft.y),
        new Cartesian2_default(node.bottomLeft.x + image.width, node.topRight.y)
      );
      const childNode2BottomLeftX = node.bottomLeft.x + image.width + textureAtlas._borderWidthInPixels;
      if (childNode2BottomLeftX < node.topRight.x) {
        node.childNode2 = new TextureAtlasNode(
          new Cartesian2_default(childNode2BottomLeftX, node.bottomLeft.y),
          new Cartesian2_default(node.topRight.x, node.topRight.y)
        );
      }
    } else {
      node.childNode1 = new TextureAtlasNode(
        new Cartesian2_default(node.bottomLeft.x, node.bottomLeft.y),
        new Cartesian2_default(node.topRight.x, node.bottomLeft.y + image.height)
      );
      const childNode2BottomLeftY = node.bottomLeft.y + image.height + textureAtlas._borderWidthInPixels;
      if (childNode2BottomLeftY < node.topRight.y) {
        node.childNode2 = new TextureAtlasNode(
          new Cartesian2_default(node.bottomLeft.x, childNode2BottomLeftY),
          new Cartesian2_default(node.topRight.x, node.topRight.y)
        );
      }
    }
    return findNode2(textureAtlas, node.childNode1, image);
  }
  return findNode2(textureAtlas, node.childNode1, image) || findNode2(textureAtlas, node.childNode2, image);
}
function addImage(textureAtlas, image, index2) {
  const node = findNode2(textureAtlas, textureAtlas._root, image);
  if (defined_default(node)) {
    node.imageIndex = index2;
    const atlasWidth = textureAtlas._texture.width;
    const atlasHeight = textureAtlas._texture.height;
    const nodeWidth = node.topRight.x - node.bottomLeft.x;
    const nodeHeight = node.topRight.y - node.bottomLeft.y;
    const x = node.bottomLeft.x / atlasWidth;
    const y = node.bottomLeft.y / atlasHeight;
    const w = nodeWidth / atlasWidth;
    const h = nodeHeight / atlasHeight;
    textureAtlas._textureCoordinates[index2] = new BoundingRectangle_default(x, y, w, h);
    textureAtlas._texture.copyFrom({
      source: image,
      xOffset: node.bottomLeft.x,
      yOffset: node.bottomLeft.y
    });
  } else {
    resizeAtlas(textureAtlas, image);
    addImage(textureAtlas, image, index2);
  }
  textureAtlas._guid = createGuid_default();
}
function getIndex(atlas, image) {
  if (!defined_default(atlas) || atlas.isDestroyed()) {
    return -1;
  }
  const index2 = atlas.numberOfImages;
  addImage(atlas, image, index2);
  return index2;
}
TextureAtlas.prototype.getImageIndex = function(id) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required.");
  }
  return this._indexHash[id];
};
TextureAtlas.prototype.addImageSync = function(id, image) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required.");
  }
  if (!defined_default(image)) {
    throw new DeveloperError_default("image is required.");
  }
  let index2 = this._indexHash[id];
  if (defined_default(index2)) {
    return index2;
  }
  index2 = getIndex(this, image);
  this._idHash[id] = Promise.resolve(index2);
  this._indexHash[id] = index2;
  return index2;
};
TextureAtlas.prototype.addImage = function(id, image) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required.");
  }
  if (!defined_default(image)) {
    throw new DeveloperError_default("image is required.");
  }
  let indexPromise = this._idHash[id];
  if (defined_default(indexPromise)) {
    return indexPromise;
  }
  if (typeof image === "function") {
    image = image(id);
    if (!defined_default(image)) {
      throw new DeveloperError_default("image is required.");
    }
  } else if (typeof image === "string" || image instanceof Resource_default) {
    const resource = Resource_default.createIfNeeded(image);
    image = resource.fetchImage();
  }
  const that = this;
  indexPromise = Promise.resolve(image).then(function(image2) {
    const index2 = getIndex(that, image2);
    that._indexHash[id] = index2;
    return index2;
  });
  this._idHash[id] = indexPromise;
  return indexPromise;
};
TextureAtlas.prototype.addSubRegion = function(id, subRegion) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required.");
  }
  if (!defined_default(subRegion)) {
    throw new DeveloperError_default("subRegion is required.");
  }
  const indexPromise = this._idHash[id];
  if (!defined_default(indexPromise)) {
    throw new RuntimeError_default(`image with id "${id}" not found in the atlas.`);
  }
  const that = this;
  return Promise.resolve(indexPromise).then(function(index2) {
    if (index2 === -1) {
      return -1;
    }
    const atlasWidth = that._texture.width;
    const atlasHeight = that._texture.height;
    const numImages = that.numberOfImages;
    const baseRegion = that._textureCoordinates[index2];
    const x = baseRegion.x + subRegion.x / atlasWidth;
    const y = baseRegion.y + subRegion.y / atlasHeight;
    const w = subRegion.width / atlasWidth;
    const h = subRegion.height / atlasHeight;
    that._textureCoordinates.push(new BoundingRectangle_default(x, y, w, h));
    that._guid = createGuid_default();
    return numImages;
  });
};
TextureAtlas.prototype.isDestroyed = function() {
  return false;
};
TextureAtlas.prototype.destroy = function() {
  this._texture = this._texture && this._texture.destroy();
  return destroyObject_default(this);
};
var TextureAtlas_default = TextureAtlas;

// node_modules/cesium/Source/Scene/BillboardCollection.js
var SHOW_INDEX2 = Billboard_default.SHOW_INDEX;
var POSITION_INDEX2 = Billboard_default.POSITION_INDEX;
var PIXEL_OFFSET_INDEX2 = Billboard_default.PIXEL_OFFSET_INDEX;
var EYE_OFFSET_INDEX2 = Billboard_default.EYE_OFFSET_INDEX;
var HORIZONTAL_ORIGIN_INDEX2 = Billboard_default.HORIZONTAL_ORIGIN_INDEX;
var VERTICAL_ORIGIN_INDEX2 = Billboard_default.VERTICAL_ORIGIN_INDEX;
var SCALE_INDEX2 = Billboard_default.SCALE_INDEX;
var IMAGE_INDEX_INDEX2 = Billboard_default.IMAGE_INDEX_INDEX;
var COLOR_INDEX2 = Billboard_default.COLOR_INDEX;
var ROTATION_INDEX2 = Billboard_default.ROTATION_INDEX;
var ALIGNED_AXIS_INDEX2 = Billboard_default.ALIGNED_AXIS_INDEX;
var SCALE_BY_DISTANCE_INDEX2 = Billboard_default.SCALE_BY_DISTANCE_INDEX;
var TRANSLUCENCY_BY_DISTANCE_INDEX2 = Billboard_default.TRANSLUCENCY_BY_DISTANCE_INDEX;
var PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX2 = Billboard_default.PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX;
var DISTANCE_DISPLAY_CONDITION_INDEX = Billboard_default.DISTANCE_DISPLAY_CONDITION;
var DISABLE_DEPTH_DISTANCE2 = Billboard_default.DISABLE_DEPTH_DISTANCE;
var TEXTURE_COORDINATE_BOUNDS = Billboard_default.TEXTURE_COORDINATE_BOUNDS;
var SDF_INDEX2 = Billboard_default.SDF_INDEX;
var NUMBER_OF_PROPERTIES = Billboard_default.NUMBER_OF_PROPERTIES;
var attributeLocations;
var attributeLocationsBatched = {
  positionHighAndScale: 0,
  positionLowAndRotation: 1,
  compressedAttribute0: 2,
  compressedAttribute1: 3,
  compressedAttribute2: 4,
  eyeOffset: 5,
  scaleByDistance: 6,
  pixelOffsetScaleByDistance: 7,
  compressedAttribute3: 8,
  textureCoordinateBoundsOrLabelTranslate: 9,
  a_batchId: 10,
  sdf: 11
};
var attributeLocationsInstanced = {
  direction: 0,
  positionHighAndScale: 1,
  positionLowAndRotation: 2,
  compressedAttribute0: 3,
  compressedAttribute1: 4,
  compressedAttribute2: 5,
  eyeOffset: 6,
  scaleByDistance: 7,
  pixelOffsetScaleByDistance: 8,
  compressedAttribute3: 9,
  textureCoordinateBoundsOrLabelTranslate: 10,
  a_batchId: 11,
  sdf: 12
};
function BillboardCollection(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._scene = options.scene;
  this._batchTable = options.batchTable;
  this._textureAtlas = void 0;
  this._textureAtlasGUID = void 0;
  this._destroyTextureAtlas = true;
  this._sp = void 0;
  this._spTranslucent = void 0;
  this._rsOpaque = void 0;
  this._rsTranslucent = void 0;
  this._vaf = void 0;
  this._billboards = [];
  this._billboardsToUpdate = [];
  this._billboardsToUpdateIndex = 0;
  this._billboardsRemoved = false;
  this._createVertexArray = false;
  this._shaderRotation = false;
  this._compiledShaderRotation = false;
  this._shaderAlignedAxis = false;
  this._compiledShaderAlignedAxis = false;
  this._shaderScaleByDistance = false;
  this._compiledShaderScaleByDistance = false;
  this._shaderTranslucencyByDistance = false;
  this._compiledShaderTranslucencyByDistance = false;
  this._shaderPixelOffsetScaleByDistance = false;
  this._compiledShaderPixelOffsetScaleByDistance = false;
  this._shaderDistanceDisplayCondition = false;
  this._compiledShaderDistanceDisplayCondition = false;
  this._shaderDisableDepthDistance = false;
  this._compiledShaderDisableDepthDistance = false;
  this._shaderClampToGround = false;
  this._compiledShaderClampToGround = false;
  this._propertiesChanged = new Uint32Array(NUMBER_OF_PROPERTIES);
  this._maxSize = 0;
  this._maxEyeOffset = 0;
  this._maxScale = 1;
  this._maxPixelOffset = 0;
  this._allHorizontalCenter = true;
  this._allVerticalCenter = true;
  this._allSizedInMeters = true;
  this._baseVolume = new BoundingSphere_default();
  this._baseVolumeWC = new BoundingSphere_default();
  this._baseVolume2D = new BoundingSphere_default();
  this._boundingVolume = new BoundingSphere_default();
  this._boundingVolumeDirty = false;
  this._colorCommands = [];
  this.show = defaultValue_default(options.show, true);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._modelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this.debugShowTextureAtlas = defaultValue_default(
    options.debugShowTextureAtlas,
    false
  );
  this.blendOption = defaultValue_default(
    options.blendOption,
    BlendOption_default.OPAQUE_AND_TRANSLUCENT
  );
  this._blendOption = void 0;
  this._mode = SceneMode_default.SCENE3D;
  this._buffersUsage = [
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW
  ];
  this._highlightColor = Color_default.clone(Color_default.WHITE);
  const that = this;
  this._uniforms = {
    u_atlas: function() {
      return that._textureAtlas.texture;
    },
    u_highlightColor: function() {
      return that._highlightColor;
    }
  };
  const scene = this._scene;
  if (defined_default(scene) && defined_default(scene.terrainProviderChanged)) {
    this._removeCallbackFunc = scene.terrainProviderChanged.addEventListener(
      function() {
        const billboards = this._billboards;
        const length3 = billboards.length;
        for (let i2 = 0; i2 < length3; ++i2) {
          if (defined_default(billboards[i2])) {
            billboards[i2]._updateClamping();
          }
        }
      },
      this
    );
  }
}
Object.defineProperties(BillboardCollection.prototype, {
  length: {
    get: function() {
      removeBillboards(this);
      return this._billboards.length;
    }
  },
  textureAtlas: {
    get: function() {
      return this._textureAtlas;
    },
    set: function(value) {
      if (this._textureAtlas !== value) {
        this._textureAtlas = this._destroyTextureAtlas && this._textureAtlas && this._textureAtlas.destroy();
        this._textureAtlas = value;
        this._createVertexArray = true;
      }
    }
  },
  destroyTextureAtlas: {
    get: function() {
      return this._destroyTextureAtlas;
    },
    set: function(value) {
      this._destroyTextureAtlas = value;
    }
  }
});
function destroyBillboards(billboards) {
  const length3 = billboards.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (billboards[i2]) {
      billboards[i2]._destroy();
    }
  }
}
BillboardCollection.prototype.add = function(options) {
  const billboard = new Billboard_default(options, this);
  billboard._index = this._billboards.length;
  this._billboards.push(billboard);
  this._createVertexArray = true;
  return billboard;
};
BillboardCollection.prototype.remove = function(billboard) {
  if (this.contains(billboard)) {
    this._billboards[billboard._index] = void 0;
    this._billboardsRemoved = true;
    this._createVertexArray = true;
    billboard._destroy();
    return true;
  }
  return false;
};
BillboardCollection.prototype.removeAll = function() {
  destroyBillboards(this._billboards);
  this._billboards = [];
  this._billboardsToUpdate = [];
  this._billboardsToUpdateIndex = 0;
  this._billboardsRemoved = false;
  this._createVertexArray = true;
};
function removeBillboards(billboardCollection) {
  if (billboardCollection._billboardsRemoved) {
    billboardCollection._billboardsRemoved = false;
    const newBillboards = [];
    const billboards = billboardCollection._billboards;
    const length3 = billboards.length;
    for (let i2 = 0, j = 0; i2 < length3; ++i2) {
      const billboard = billboards[i2];
      if (defined_default(billboard)) {
        billboard._index = j++;
        newBillboards.push(billboard);
      }
    }
    billboardCollection._billboards = newBillboards;
  }
}
BillboardCollection.prototype._updateBillboard = function(billboard, propertyChanged) {
  if (!billboard._dirty) {
    this._billboardsToUpdate[this._billboardsToUpdateIndex++] = billboard;
  }
  ++this._propertiesChanged[propertyChanged];
};
BillboardCollection.prototype.contains = function(billboard) {
  return defined_default(billboard) && billboard._billboardCollection === this;
};
BillboardCollection.prototype.get = function(index2) {
  Check_default.typeOf.number("index", index2);
  removeBillboards(this);
  return this._billboards[index2];
};
var getIndexBuffer;
function getIndexBufferBatched(context) {
  const sixteenK = 16 * 1024;
  let indexBuffer = context.cache.billboardCollection_indexBufferBatched;
  if (defined_default(indexBuffer)) {
    return indexBuffer;
  }
  const length3 = sixteenK * 6 - 6;
  const indices2 = new Uint16Array(length3);
  for (let i2 = 0, j = 0; i2 < length3; i2 += 6, j += 4) {
    indices2[i2] = j;
    indices2[i2 + 1] = j + 1;
    indices2[i2 + 2] = j + 2;
    indices2[i2 + 3] = j + 0;
    indices2[i2 + 4] = j + 2;
    indices2[i2 + 5] = j + 3;
  }
  indexBuffer = Buffer_default.createIndexBuffer({
    context,
    typedArray: indices2,
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
  });
  indexBuffer.vertexArrayDestroyable = false;
  context.cache.billboardCollection_indexBufferBatched = indexBuffer;
  return indexBuffer;
}
function getIndexBufferInstanced(context) {
  let indexBuffer = context.cache.billboardCollection_indexBufferInstanced;
  if (defined_default(indexBuffer)) {
    return indexBuffer;
  }
  indexBuffer = Buffer_default.createIndexBuffer({
    context,
    typedArray: new Uint16Array([0, 1, 2, 0, 2, 3]),
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
  });
  indexBuffer.vertexArrayDestroyable = false;
  context.cache.billboardCollection_indexBufferInstanced = indexBuffer;
  return indexBuffer;
}
function getVertexBufferInstanced(context) {
  let vertexBuffer = context.cache.billboardCollection_vertexBufferInstanced;
  if (defined_default(vertexBuffer)) {
    return vertexBuffer;
  }
  vertexBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
    usage: BufferUsage_default.STATIC_DRAW
  });
  vertexBuffer.vertexArrayDestroyable = false;
  context.cache.billboardCollection_vertexBufferInstanced = vertexBuffer;
  return vertexBuffer;
}
BillboardCollection.prototype.computeNewBuffersUsage = function() {
  const buffersUsage = this._buffersUsage;
  let usageChanged = false;
  const properties = this._propertiesChanged;
  for (let k = 0; k < NUMBER_OF_PROPERTIES; ++k) {
    const newUsage = properties[k] === 0 ? BufferUsage_default.STATIC_DRAW : BufferUsage_default.STREAM_DRAW;
    usageChanged = usageChanged || buffersUsage[k] !== newUsage;
    buffersUsage[k] = newUsage;
  }
  return usageChanged;
};
function createVAF(context, numberOfBillboards, buffersUsage, instanced, batchTable, sdf) {
  const attributes = [
    {
      index: attributeLocations.positionHighAndScale,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[POSITION_INDEX2]
    },
    {
      index: attributeLocations.positionLowAndRotation,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[POSITION_INDEX2]
    },
    {
      index: attributeLocations.compressedAttribute0,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[PIXEL_OFFSET_INDEX2]
    },
    {
      index: attributeLocations.compressedAttribute1,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[TRANSLUCENCY_BY_DISTANCE_INDEX2]
    },
    {
      index: attributeLocations.compressedAttribute2,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[COLOR_INDEX2]
    },
    {
      index: attributeLocations.eyeOffset,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[EYE_OFFSET_INDEX2]
    },
    {
      index: attributeLocations.scaleByDistance,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[SCALE_BY_DISTANCE_INDEX2]
    },
    {
      index: attributeLocations.pixelOffsetScaleByDistance,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX2]
    },
    {
      index: attributeLocations.compressedAttribute3,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[DISTANCE_DISPLAY_CONDITION_INDEX]
    },
    {
      index: attributeLocations.textureCoordinateBoundsOrLabelTranslate,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[TEXTURE_COORDINATE_BOUNDS]
    }
  ];
  if (instanced) {
    attributes.push({
      index: attributeLocations.direction,
      componentsPerAttribute: 2,
      componentDatatype: ComponentDatatype_default.FLOAT,
      vertexBuffer: getVertexBufferInstanced(context)
    });
  }
  if (defined_default(batchTable)) {
    attributes.push({
      index: attributeLocations.a_batchId,
      componentsPerAttribute: 1,
      componentDatatype: ComponentDatatype_default.FLOAT,
      bufferUsage: BufferUsage_default.STATIC_DRAW
    });
  }
  if (sdf) {
    attributes.push({
      index: attributeLocations.sdf,
      componentsPerAttribute: 2,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: buffersUsage[SDF_INDEX2]
    });
  }
  const sizeInVertices = instanced ? numberOfBillboards : 4 * numberOfBillboards;
  return new VertexArrayFacade_default(context, attributes, sizeInVertices, instanced);
}
var writePositionScratch = new EncodedCartesian3_default();
function writePositionScaleAndRotation(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  let i2;
  const positionHighWriter = vafWriters[attributeLocations.positionHighAndScale];
  const positionLowWriter = vafWriters[attributeLocations.positionLowAndRotation];
  const position = billboard._getActualPosition();
  if (billboardCollection._mode === SceneMode_default.SCENE3D) {
    BoundingSphere_default.expand(
      billboardCollection._baseVolume,
      position,
      billboardCollection._baseVolume
    );
    billboardCollection._boundingVolumeDirty = true;
  }
  EncodedCartesian3_default.fromCartesian(position, writePositionScratch);
  const scale = billboard.scale;
  const rotation = billboard.rotation;
  if (rotation !== 0) {
    billboardCollection._shaderRotation = true;
  }
  billboardCollection._maxScale = Math.max(
    billboardCollection._maxScale,
    scale
  );
  const high = writePositionScratch.high;
  const low = writePositionScratch.low;
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    positionHighWriter(i2, high.x, high.y, high.z, scale);
    positionLowWriter(i2, low.x, low.y, low.z, rotation);
  } else {
    i2 = billboard._index * 4;
    positionHighWriter(i2 + 0, high.x, high.y, high.z, scale);
    positionHighWriter(i2 + 1, high.x, high.y, high.z, scale);
    positionHighWriter(i2 + 2, high.x, high.y, high.z, scale);
    positionHighWriter(i2 + 3, high.x, high.y, high.z, scale);
    positionLowWriter(i2 + 0, low.x, low.y, low.z, rotation);
    positionLowWriter(i2 + 1, low.x, low.y, low.z, rotation);
    positionLowWriter(i2 + 2, low.x, low.y, low.z, rotation);
    positionLowWriter(i2 + 3, low.x, low.y, low.z, rotation);
  }
}
var scratchCartesian210 = new Cartesian2_default();
var UPPER_BOUND = 32768;
var LEFT_SHIFT16 = 65536;
var LEFT_SHIFT12 = 4096;
var LEFT_SHIFT8 = 256;
var LEFT_SHIFT7 = 128;
var LEFT_SHIFT5 = 32;
var LEFT_SHIFT3 = 8;
var LEFT_SHIFT2 = 4;
var RIGHT_SHIFT8 = 1 / 256;
var LOWER_LEFT = 0;
var LOWER_RIGHT = 2;
var UPPER_RIGHT = 3;
var UPPER_LEFT = 1;
function writeCompressedAttrib0(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  let i2;
  const writer = vafWriters[attributeLocations.compressedAttribute0];
  const pixelOffset = billboard.pixelOffset;
  const pixelOffsetX = pixelOffset.x;
  const pixelOffsetY = pixelOffset.y;
  const translate = billboard._translate;
  const translateX = translate.x;
  const translateY = translate.y;
  billboardCollection._maxPixelOffset = Math.max(
    billboardCollection._maxPixelOffset,
    Math.abs(pixelOffsetX + translateX),
    Math.abs(-pixelOffsetY + translateY)
  );
  const horizontalOrigin = billboard.horizontalOrigin;
  let verticalOrigin = billboard._verticalOrigin;
  let show = billboard.show && billboard.clusterShow;
  if (billboard.color.alpha === 0) {
    show = false;
  }
  if (verticalOrigin === VerticalOrigin_default.BASELINE) {
    verticalOrigin = VerticalOrigin_default.BOTTOM;
  }
  billboardCollection._allHorizontalCenter = billboardCollection._allHorizontalCenter && horizontalOrigin === HorizontalOrigin_default.CENTER;
  billboardCollection._allVerticalCenter = billboardCollection._allVerticalCenter && verticalOrigin === VerticalOrigin_default.CENTER;
  let bottomLeftX = 0;
  let bottomLeftY = 0;
  let width = 0;
  let height = 0;
  const index2 = billboard._imageIndex;
  if (index2 !== -1) {
    const imageRectangle = textureAtlasCoordinates[index2];
    if (!defined_default(imageRectangle)) {
      throw new DeveloperError_default(`Invalid billboard image index: ${index2}`);
    }
    bottomLeftX = imageRectangle.x;
    bottomLeftY = imageRectangle.y;
    width = imageRectangle.width;
    height = imageRectangle.height;
  }
  const topRightX = bottomLeftX + width;
  const topRightY = bottomLeftY + height;
  let compressed0 = Math.floor(
    Math_default.clamp(pixelOffsetX, -UPPER_BOUND, UPPER_BOUND) + UPPER_BOUND
  ) * LEFT_SHIFT7;
  compressed0 += (horizontalOrigin + 1) * LEFT_SHIFT5;
  compressed0 += (verticalOrigin + 1) * LEFT_SHIFT3;
  compressed0 += (show ? 1 : 0) * LEFT_SHIFT2;
  let compressed1 = Math.floor(
    Math_default.clamp(pixelOffsetY, -UPPER_BOUND, UPPER_BOUND) + UPPER_BOUND
  ) * LEFT_SHIFT8;
  let compressed2 = Math.floor(
    Math_default.clamp(translateX, -UPPER_BOUND, UPPER_BOUND) + UPPER_BOUND
  ) * LEFT_SHIFT8;
  const tempTanslateY = (Math_default.clamp(translateY, -UPPER_BOUND, UPPER_BOUND) + UPPER_BOUND) * RIGHT_SHIFT8;
  const upperTranslateY = Math.floor(tempTanslateY);
  const lowerTranslateY = Math.floor(
    (tempTanslateY - upperTranslateY) * LEFT_SHIFT8
  );
  compressed1 += upperTranslateY;
  compressed2 += lowerTranslateY;
  scratchCartesian210.x = bottomLeftX;
  scratchCartesian210.y = bottomLeftY;
  const compressedTexCoordsLL = AttributeCompression_default.compressTextureCoordinates(
    scratchCartesian210
  );
  scratchCartesian210.x = topRightX;
  const compressedTexCoordsLR = AttributeCompression_default.compressTextureCoordinates(
    scratchCartesian210
  );
  scratchCartesian210.y = topRightY;
  const compressedTexCoordsUR = AttributeCompression_default.compressTextureCoordinates(
    scratchCartesian210
  );
  scratchCartesian210.x = bottomLeftX;
  const compressedTexCoordsUL = AttributeCompression_default.compressTextureCoordinates(
    scratchCartesian210
  );
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    writer(i2, compressed0, compressed1, compressed2, compressedTexCoordsLL);
  } else {
    i2 = billboard._index * 4;
    writer(
      i2 + 0,
      compressed0 + LOWER_LEFT,
      compressed1,
      compressed2,
      compressedTexCoordsLL
    );
    writer(
      i2 + 1,
      compressed0 + LOWER_RIGHT,
      compressed1,
      compressed2,
      compressedTexCoordsLR
    );
    writer(
      i2 + 2,
      compressed0 + UPPER_RIGHT,
      compressed1,
      compressed2,
      compressedTexCoordsUR
    );
    writer(
      i2 + 3,
      compressed0 + UPPER_LEFT,
      compressed1,
      compressed2,
      compressedTexCoordsUL
    );
  }
}
function writeCompressedAttrib1(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  let i2;
  const writer = vafWriters[attributeLocations.compressedAttribute1];
  const alignedAxis = billboard.alignedAxis;
  if (!Cartesian3_default.equals(alignedAxis, Cartesian3_default.ZERO)) {
    billboardCollection._shaderAlignedAxis = true;
  }
  let near = 0;
  let nearValue = 1;
  let far = 1;
  let farValue = 1;
  const translucency = billboard.translucencyByDistance;
  if (defined_default(translucency)) {
    near = translucency.near;
    nearValue = translucency.nearValue;
    far = translucency.far;
    farValue = translucency.farValue;
    if (nearValue !== 1 || farValue !== 1) {
      billboardCollection._shaderTranslucencyByDistance = true;
    }
  }
  let width = 0;
  const index2 = billboard._imageIndex;
  if (index2 !== -1) {
    const imageRectangle = textureAtlasCoordinates[index2];
    if (!defined_default(imageRectangle)) {
      throw new DeveloperError_default(`Invalid billboard image index: ${index2}`);
    }
    width = imageRectangle.width;
  }
  const textureWidth = billboardCollection._textureAtlas.texture.width;
  const imageWidth = Math.round(
    defaultValue_default(billboard.width, textureWidth * width)
  );
  billboardCollection._maxSize = Math.max(
    billboardCollection._maxSize,
    imageWidth
  );
  let compressed0 = Math_default.clamp(imageWidth, 0, LEFT_SHIFT16);
  let compressed1 = 0;
  if (Math.abs(Cartesian3_default.magnitudeSquared(alignedAxis) - 1) < Math_default.EPSILON6) {
    compressed1 = AttributeCompression_default.octEncodeFloat(alignedAxis);
  }
  nearValue = Math_default.clamp(nearValue, 0, 1);
  nearValue = nearValue === 1 ? 255 : nearValue * 255 | 0;
  compressed0 = compressed0 * LEFT_SHIFT8 + nearValue;
  farValue = Math_default.clamp(farValue, 0, 1);
  farValue = farValue === 1 ? 255 : farValue * 255 | 0;
  compressed1 = compressed1 * LEFT_SHIFT8 + farValue;
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    writer(i2, compressed0, compressed1, near, far);
  } else {
    i2 = billboard._index * 4;
    writer(i2 + 0, compressed0, compressed1, near, far);
    writer(i2 + 1, compressed0, compressed1, near, far);
    writer(i2 + 2, compressed0, compressed1, near, far);
    writer(i2 + 3, compressed0, compressed1, near, far);
  }
}
function writeCompressedAttrib2(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  let i2;
  const writer = vafWriters[attributeLocations.compressedAttribute2];
  const color = billboard.color;
  const pickColor = !defined_default(billboardCollection._batchTable) ? billboard.getPickId(frameState.context).color : Color_default.WHITE;
  const sizeInMeters = billboard.sizeInMeters ? 1 : 0;
  const validAlignedAxis = Math.abs(Cartesian3_default.magnitudeSquared(billboard.alignedAxis) - 1) < Math_default.EPSILON6 ? 1 : 0;
  billboardCollection._allSizedInMeters = billboardCollection._allSizedInMeters && sizeInMeters === 1;
  let height = 0;
  const index2 = billboard._imageIndex;
  if (index2 !== -1) {
    const imageRectangle = textureAtlasCoordinates[index2];
    if (!defined_default(imageRectangle)) {
      throw new DeveloperError_default(`Invalid billboard image index: ${index2}`);
    }
    height = imageRectangle.height;
  }
  const dimensions = billboardCollection._textureAtlas.texture.dimensions;
  const imageHeight = Math.round(
    defaultValue_default(billboard.height, dimensions.y * height)
  );
  billboardCollection._maxSize = Math.max(
    billboardCollection._maxSize,
    imageHeight
  );
  let labelHorizontalOrigin = defaultValue_default(
    billboard._labelHorizontalOrigin,
    -2
  );
  labelHorizontalOrigin += 2;
  const compressed3 = imageHeight * LEFT_SHIFT2 + labelHorizontalOrigin;
  let red = Color_default.floatToByte(color.red);
  let green = Color_default.floatToByte(color.green);
  let blue = Color_default.floatToByte(color.blue);
  const compressed0 = red * LEFT_SHIFT16 + green * LEFT_SHIFT8 + blue;
  red = Color_default.floatToByte(pickColor.red);
  green = Color_default.floatToByte(pickColor.green);
  blue = Color_default.floatToByte(pickColor.blue);
  const compressed1 = red * LEFT_SHIFT16 + green * LEFT_SHIFT8 + blue;
  let compressed2 = Color_default.floatToByte(color.alpha) * LEFT_SHIFT16 + Color_default.floatToByte(pickColor.alpha) * LEFT_SHIFT8;
  compressed2 += sizeInMeters * 2 + validAlignedAxis;
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    writer(i2, compressed0, compressed1, compressed2, compressed3);
  } else {
    i2 = billboard._index * 4;
    writer(i2 + 0, compressed0, compressed1, compressed2, compressed3);
    writer(i2 + 1, compressed0, compressed1, compressed2, compressed3);
    writer(i2 + 2, compressed0, compressed1, compressed2, compressed3);
    writer(i2 + 3, compressed0, compressed1, compressed2, compressed3);
  }
}
function writeEyeOffset(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  let i2;
  const writer = vafWriters[attributeLocations.eyeOffset];
  const eyeOffset = billboard.eyeOffset;
  let eyeOffsetZ = eyeOffset.z;
  if (billboard._heightReference !== HeightReference_default.NONE) {
    eyeOffsetZ *= 1.005;
  }
  billboardCollection._maxEyeOffset = Math.max(
    billboardCollection._maxEyeOffset,
    Math.abs(eyeOffset.x),
    Math.abs(eyeOffset.y),
    Math.abs(eyeOffsetZ)
  );
  if (billboardCollection._instanced) {
    let width = 0;
    let height = 0;
    const index2 = billboard._imageIndex;
    if (index2 !== -1) {
      const imageRectangle = textureAtlasCoordinates[index2];
      if (!defined_default(imageRectangle)) {
        throw new DeveloperError_default(`Invalid billboard image index: ${index2}`);
      }
      width = imageRectangle.width;
      height = imageRectangle.height;
    }
    scratchCartesian210.x = width;
    scratchCartesian210.y = height;
    const compressedTexCoordsRange = AttributeCompression_default.compressTextureCoordinates(
      scratchCartesian210
    );
    i2 = billboard._index;
    writer(i2, eyeOffset.x, eyeOffset.y, eyeOffsetZ, compressedTexCoordsRange);
  } else {
    i2 = billboard._index * 4;
    writer(i2 + 0, eyeOffset.x, eyeOffset.y, eyeOffsetZ, 0);
    writer(i2 + 1, eyeOffset.x, eyeOffset.y, eyeOffsetZ, 0);
    writer(i2 + 2, eyeOffset.x, eyeOffset.y, eyeOffsetZ, 0);
    writer(i2 + 3, eyeOffset.x, eyeOffset.y, eyeOffsetZ, 0);
  }
}
function writeScaleByDistance(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  let i2;
  const writer = vafWriters[attributeLocations.scaleByDistance];
  let near = 0;
  let nearValue = 1;
  let far = 1;
  let farValue = 1;
  const scale = billboard.scaleByDistance;
  if (defined_default(scale)) {
    near = scale.near;
    nearValue = scale.nearValue;
    far = scale.far;
    farValue = scale.farValue;
    if (nearValue !== 1 || farValue !== 1) {
      billboardCollection._shaderScaleByDistance = true;
    }
  }
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    writer(i2, near, nearValue, far, farValue);
  } else {
    i2 = billboard._index * 4;
    writer(i2 + 0, near, nearValue, far, farValue);
    writer(i2 + 1, near, nearValue, far, farValue);
    writer(i2 + 2, near, nearValue, far, farValue);
    writer(i2 + 3, near, nearValue, far, farValue);
  }
}
function writePixelOffsetScaleByDistance(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  let i2;
  const writer = vafWriters[attributeLocations.pixelOffsetScaleByDistance];
  let near = 0;
  let nearValue = 1;
  let far = 1;
  let farValue = 1;
  const pixelOffsetScale = billboard.pixelOffsetScaleByDistance;
  if (defined_default(pixelOffsetScale)) {
    near = pixelOffsetScale.near;
    nearValue = pixelOffsetScale.nearValue;
    far = pixelOffsetScale.far;
    farValue = pixelOffsetScale.farValue;
    if (nearValue !== 1 || farValue !== 1) {
      billboardCollection._shaderPixelOffsetScaleByDistance = true;
    }
  }
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    writer(i2, near, nearValue, far, farValue);
  } else {
    i2 = billboard._index * 4;
    writer(i2 + 0, near, nearValue, far, farValue);
    writer(i2 + 1, near, nearValue, far, farValue);
    writer(i2 + 2, near, nearValue, far, farValue);
    writer(i2 + 3, near, nearValue, far, farValue);
  }
}
function writeCompressedAttribute3(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  let i2;
  const writer = vafWriters[attributeLocations.compressedAttribute3];
  let near = 0;
  let far = Number.MAX_VALUE;
  const distanceDisplayCondition = billboard.distanceDisplayCondition;
  if (defined_default(distanceDisplayCondition)) {
    near = distanceDisplayCondition.near;
    far = distanceDisplayCondition.far;
    near *= near;
    far *= far;
    billboardCollection._shaderDistanceDisplayCondition = true;
  }
  let disableDepthTestDistance = billboard.disableDepthTestDistance;
  const clampToGround = billboard.heightReference === HeightReference_default.CLAMP_TO_GROUND && frameState.context.depthTexture;
  if (!defined_default(disableDepthTestDistance)) {
    disableDepthTestDistance = clampToGround ? 5e3 : 0;
  }
  disableDepthTestDistance *= disableDepthTestDistance;
  if (clampToGround || disableDepthTestDistance > 0) {
    billboardCollection._shaderDisableDepthDistance = true;
    if (disableDepthTestDistance === Number.POSITIVE_INFINITY) {
      disableDepthTestDistance = -1;
    }
  }
  let imageHeight;
  let imageWidth;
  if (!defined_default(billboard._labelDimensions)) {
    let height = 0;
    let width = 0;
    const index2 = billboard._imageIndex;
    if (index2 !== -1) {
      const imageRectangle = textureAtlasCoordinates[index2];
      if (!defined_default(imageRectangle)) {
        throw new DeveloperError_default(`Invalid billboard image index: ${index2}`);
      }
      height = imageRectangle.height;
      width = imageRectangle.width;
    }
    imageHeight = Math.round(
      defaultValue_default(
        billboard.height,
        billboardCollection._textureAtlas.texture.dimensions.y * height
      )
    );
    const textureWidth = billboardCollection._textureAtlas.texture.width;
    imageWidth = Math.round(
      defaultValue_default(billboard.width, textureWidth * width)
    );
  } else {
    imageWidth = billboard._labelDimensions.x;
    imageHeight = billboard._labelDimensions.y;
  }
  const w = Math.floor(Math_default.clamp(imageWidth, 0, LEFT_SHIFT12));
  const h = Math.floor(Math_default.clamp(imageHeight, 0, LEFT_SHIFT12));
  const dimensions = w * LEFT_SHIFT12 + h;
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    writer(i2, near, far, disableDepthTestDistance, dimensions);
  } else {
    i2 = billboard._index * 4;
    writer(i2 + 0, near, far, disableDepthTestDistance, dimensions);
    writer(i2 + 1, near, far, disableDepthTestDistance, dimensions);
    writer(i2 + 2, near, far, disableDepthTestDistance, dimensions);
    writer(i2 + 3, near, far, disableDepthTestDistance, dimensions);
  }
}
function writeTextureCoordinateBoundsOrLabelTranslate(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  if (billboard.heightReference === HeightReference_default.CLAMP_TO_GROUND) {
    const scene = billboardCollection._scene;
    const context = frameState.context;
    const globeTranslucent = frameState.globeTranslucencyState.translucent;
    const depthTestAgainstTerrain = defined_default(scene.globe) && scene.globe.depthTestAgainstTerrain;
    billboardCollection._shaderClampToGround = context.depthTexture && !globeTranslucent && depthTestAgainstTerrain;
  }
  let i2;
  const writer = vafWriters[attributeLocations.textureCoordinateBoundsOrLabelTranslate];
  if (ContextLimits_default.maximumVertexTextureImageUnits > 0) {
    let translateX = 0;
    let translateY = 0;
    if (defined_default(billboard._labelTranslate)) {
      translateX = billboard._labelTranslate.x;
      translateY = billboard._labelTranslate.y;
    }
    if (billboardCollection._instanced) {
      i2 = billboard._index;
      writer(i2, translateX, translateY, 0, 0);
    } else {
      i2 = billboard._index * 4;
      writer(i2 + 0, translateX, translateY, 0, 0);
      writer(i2 + 1, translateX, translateY, 0, 0);
      writer(i2 + 2, translateX, translateY, 0, 0);
      writer(i2 + 3, translateX, translateY, 0, 0);
    }
    return;
  }
  let minX = 0;
  let minY = 0;
  let width = 0;
  let height = 0;
  const index2 = billboard._imageIndex;
  if (index2 !== -1) {
    const imageRectangle = textureAtlasCoordinates[index2];
    if (!defined_default(imageRectangle)) {
      throw new DeveloperError_default(`Invalid billboard image index: ${index2}`);
    }
    minX = imageRectangle.x;
    minY = imageRectangle.y;
    width = imageRectangle.width;
    height = imageRectangle.height;
  }
  const maxX = minX + width;
  const maxY = minY + height;
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    writer(i2, minX, minY, maxX, maxY);
  } else {
    i2 = billboard._index * 4;
    writer(i2 + 0, minX, minY, maxX, maxY);
    writer(i2 + 1, minX, minY, maxX, maxY);
    writer(i2 + 2, minX, minY, maxX, maxY);
    writer(i2 + 3, minX, minY, maxX, maxY);
  }
}
function writeBatchId(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  if (!defined_default(billboardCollection._batchTable)) {
    return;
  }
  const writer = vafWriters[attributeLocations.a_batchId];
  const id = billboard._batchIndex;
  let i2;
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    writer(i2, id);
  } else {
    i2 = billboard._index * 4;
    writer(i2 + 0, id);
    writer(i2 + 1, id);
    writer(i2 + 2, id);
    writer(i2 + 3, id);
  }
}
function writeSDF(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  if (!billboardCollection._sdf) {
    return;
  }
  let i2;
  const writer = vafWriters[attributeLocations.sdf];
  const outlineColor = billboard.outlineColor;
  const outlineWidth = billboard.outlineWidth;
  const red = Color_default.floatToByte(outlineColor.red);
  const green = Color_default.floatToByte(outlineColor.green);
  const blue = Color_default.floatToByte(outlineColor.blue);
  const compressed0 = red * LEFT_SHIFT16 + green * LEFT_SHIFT8 + blue;
  const outlineDistance = outlineWidth / SDFSettings_default.RADIUS;
  const compressed1 = Color_default.floatToByte(outlineColor.alpha) * LEFT_SHIFT16 + Color_default.floatToByte(outlineDistance) * LEFT_SHIFT8;
  if (billboardCollection._instanced) {
    i2 = billboard._index;
    writer(i2, compressed0, compressed1);
  } else {
    i2 = billboard._index * 4;
    writer(i2 + 0, compressed0 + LOWER_LEFT, compressed1);
    writer(i2 + 1, compressed0 + LOWER_RIGHT, compressed1);
    writer(i2 + 2, compressed0 + UPPER_RIGHT, compressed1);
    writer(i2 + 3, compressed0 + UPPER_LEFT, compressed1);
  }
}
function writeBillboard(billboardCollection, frameState, textureAtlasCoordinates, vafWriters, billboard) {
  writePositionScaleAndRotation(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writeCompressedAttrib0(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writeCompressedAttrib1(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writeCompressedAttrib2(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writeEyeOffset(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writeScaleByDistance(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writePixelOffsetScaleByDistance(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writeCompressedAttribute3(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writeTextureCoordinateBoundsOrLabelTranslate(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writeBatchId(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
  writeSDF(
    billboardCollection,
    frameState,
    textureAtlasCoordinates,
    vafWriters,
    billboard
  );
}
function recomputeActualPositions(billboardCollection, billboards, length3, frameState, modelMatrix, recomputeBoundingVolume) {
  let boundingVolume;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    boundingVolume = billboardCollection._baseVolume;
    billboardCollection._boundingVolumeDirty = true;
  } else {
    boundingVolume = billboardCollection._baseVolume2D;
  }
  const positions = [];
  for (let i2 = 0; i2 < length3; ++i2) {
    const billboard = billboards[i2];
    const position = billboard.position;
    const actualPosition = Billboard_default._computeActualPosition(
      billboard,
      position,
      frameState,
      modelMatrix
    );
    if (defined_default(actualPosition)) {
      billboard._setActualPosition(actualPosition);
      if (recomputeBoundingVolume) {
        positions.push(actualPosition);
      } else {
        BoundingSphere_default.expand(boundingVolume, actualPosition, boundingVolume);
      }
    }
  }
  if (recomputeBoundingVolume) {
    BoundingSphere_default.fromPoints(positions, boundingVolume);
  }
}
function updateMode(billboardCollection, frameState) {
  const mode2 = frameState.mode;
  const billboards = billboardCollection._billboards;
  const billboardsToUpdate = billboardCollection._billboardsToUpdate;
  const modelMatrix = billboardCollection._modelMatrix;
  if (billboardCollection._createVertexArray || billboardCollection._mode !== mode2 || mode2 !== SceneMode_default.SCENE3D && !Matrix4_default.equals(modelMatrix, billboardCollection.modelMatrix)) {
    billboardCollection._mode = mode2;
    Matrix4_default.clone(billboardCollection.modelMatrix, modelMatrix);
    billboardCollection._createVertexArray = true;
    if (mode2 === SceneMode_default.SCENE3D || mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.COLUMBUS_VIEW) {
      recomputeActualPositions(
        billboardCollection,
        billboards,
        billboards.length,
        frameState,
        modelMatrix,
        true
      );
    }
  } else if (mode2 === SceneMode_default.MORPHING) {
    recomputeActualPositions(
      billboardCollection,
      billboards,
      billboards.length,
      frameState,
      modelMatrix,
      true
    );
  } else if (mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.COLUMBUS_VIEW) {
    recomputeActualPositions(
      billboardCollection,
      billboardsToUpdate,
      billboardCollection._billboardsToUpdateIndex,
      frameState,
      modelMatrix,
      false
    );
  }
}
function updateBoundingVolume(collection, frameState, boundingVolume) {
  let pixelScale = 1;
  if (!collection._allSizedInMeters || collection._maxPixelOffset !== 0) {
    pixelScale = frameState.camera.getPixelSize(
      boundingVolume,
      frameState.context.drawingBufferWidth,
      frameState.context.drawingBufferHeight
    );
  }
  let size = pixelScale * collection._maxScale * collection._maxSize * 2;
  if (collection._allHorizontalCenter && collection._allVerticalCenter) {
    size *= 0.5;
  }
  const offset2 = pixelScale * collection._maxPixelOffset + collection._maxEyeOffset;
  boundingVolume.radius += size + offset2;
}
function createDebugCommand(billboardCollection, context) {
  const fs = "uniform sampler2D billboard_texture; \nvarying vec2 v_textureCoordinates; \nvoid main() \n{ \n    gl_FragColor = texture2D(billboard_texture, v_textureCoordinates); \n} \n";
  const drawCommand = context.createViewportQuadCommand(fs, {
    uniformMap: {
      billboard_texture: function() {
        return billboardCollection._textureAtlas.texture;
      }
    }
  });
  drawCommand.pass = Pass_default.OVERLAY;
  return drawCommand;
}
var scratchWriterArray = [];
BillboardCollection.prototype.update = function(frameState) {
  removeBillboards(this);
  if (!this.show) {
    return;
  }
  let billboards = this._billboards;
  let billboardsLength = billboards.length;
  const context = frameState.context;
  this._instanced = context.instancedArrays;
  attributeLocations = this._instanced ? attributeLocationsInstanced : attributeLocationsBatched;
  getIndexBuffer = this._instanced ? getIndexBufferInstanced : getIndexBufferBatched;
  let textureAtlas = this._textureAtlas;
  if (!defined_default(textureAtlas)) {
    textureAtlas = this._textureAtlas = new TextureAtlas_default({
      context
    });
    for (let ii = 0; ii < billboardsLength; ++ii) {
      billboards[ii]._loadImage();
    }
  }
  const textureAtlasCoordinates = textureAtlas.textureCoordinates;
  if (textureAtlasCoordinates.length === 0) {
    return;
  }
  updateMode(this, frameState);
  billboards = this._billboards;
  billboardsLength = billboards.length;
  const billboardsToUpdate = this._billboardsToUpdate;
  const billboardsToUpdateLength = this._billboardsToUpdateIndex;
  const properties = this._propertiesChanged;
  const textureAtlasGUID = textureAtlas.guid;
  const createVertexArray8 = this._createVertexArray || this._textureAtlasGUID !== textureAtlasGUID;
  this._textureAtlasGUID = textureAtlasGUID;
  let vafWriters;
  const pass = frameState.passes;
  const picking = pass.pick;
  if (createVertexArray8 || !picking && this.computeNewBuffersUsage()) {
    this._createVertexArray = false;
    for (let k = 0; k < NUMBER_OF_PROPERTIES; ++k) {
      properties[k] = 0;
    }
    this._vaf = this._vaf && this._vaf.destroy();
    if (billboardsLength > 0) {
      this._vaf = createVAF(
        context,
        billboardsLength,
        this._buffersUsage,
        this._instanced,
        this._batchTable,
        this._sdf
      );
      vafWriters = this._vaf.writers;
      for (let i2 = 0; i2 < billboardsLength; ++i2) {
        const billboard = this._billboards[i2];
        billboard._dirty = false;
        writeBillboard(
          this,
          frameState,
          textureAtlasCoordinates,
          vafWriters,
          billboard
        );
      }
      this._vaf.commit(getIndexBuffer(context));
    }
    this._billboardsToUpdateIndex = 0;
  } else if (billboardsToUpdateLength > 0) {
    const writers = scratchWriterArray;
    writers.length = 0;
    if (properties[POSITION_INDEX2] || properties[ROTATION_INDEX2] || properties[SCALE_INDEX2]) {
      writers.push(writePositionScaleAndRotation);
    }
    if (properties[IMAGE_INDEX_INDEX2] || properties[PIXEL_OFFSET_INDEX2] || properties[HORIZONTAL_ORIGIN_INDEX2] || properties[VERTICAL_ORIGIN_INDEX2] || properties[SHOW_INDEX2]) {
      writers.push(writeCompressedAttrib0);
      if (this._instanced) {
        writers.push(writeEyeOffset);
      }
    }
    if (properties[IMAGE_INDEX_INDEX2] || properties[ALIGNED_AXIS_INDEX2] || properties[TRANSLUCENCY_BY_DISTANCE_INDEX2]) {
      writers.push(writeCompressedAttrib1);
      writers.push(writeCompressedAttrib2);
    }
    if (properties[IMAGE_INDEX_INDEX2] || properties[COLOR_INDEX2]) {
      writers.push(writeCompressedAttrib2);
    }
    if (properties[EYE_OFFSET_INDEX2]) {
      writers.push(writeEyeOffset);
    }
    if (properties[SCALE_BY_DISTANCE_INDEX2]) {
      writers.push(writeScaleByDistance);
    }
    if (properties[PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX2]) {
      writers.push(writePixelOffsetScaleByDistance);
    }
    if (properties[DISTANCE_DISPLAY_CONDITION_INDEX] || properties[DISABLE_DEPTH_DISTANCE2] || properties[IMAGE_INDEX_INDEX2] || properties[POSITION_INDEX2]) {
      writers.push(writeCompressedAttribute3);
    }
    if (properties[IMAGE_INDEX_INDEX2] || properties[POSITION_INDEX2]) {
      writers.push(writeTextureCoordinateBoundsOrLabelTranslate);
    }
    if (properties[SDF_INDEX2]) {
      writers.push(writeSDF);
    }
    const numWriters = writers.length;
    vafWriters = this._vaf.writers;
    if (billboardsToUpdateLength / billboardsLength > 0.1) {
      for (let m = 0; m < billboardsToUpdateLength; ++m) {
        const b = billboardsToUpdate[m];
        b._dirty = false;
        for (let n2 = 0; n2 < numWriters; ++n2) {
          writers[n2](this, frameState, textureAtlasCoordinates, vafWriters, b);
        }
      }
      this._vaf.commit(getIndexBuffer(context));
    } else {
      for (let h = 0; h < billboardsToUpdateLength; ++h) {
        const bb = billboardsToUpdate[h];
        bb._dirty = false;
        for (let o2 = 0; o2 < numWriters; ++o2) {
          writers[o2](this, frameState, textureAtlasCoordinates, vafWriters, bb);
        }
        if (this._instanced) {
          this._vaf.subCommit(bb._index, 1);
        } else {
          this._vaf.subCommit(bb._index * 4, 4);
        }
      }
      this._vaf.endSubCommits();
    }
    this._billboardsToUpdateIndex = 0;
  }
  if (billboardsToUpdateLength > billboardsLength * 1.5) {
    billboardsToUpdate.length = billboardsLength;
  }
  if (!defined_default(this._vaf) || !defined_default(this._vaf.va)) {
    return;
  }
  if (this._boundingVolumeDirty) {
    this._boundingVolumeDirty = false;
    BoundingSphere_default.transform(
      this._baseVolume,
      this.modelMatrix,
      this._baseVolumeWC
    );
  }
  let boundingVolume;
  let modelMatrix = Matrix4_default.IDENTITY;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    modelMatrix = this.modelMatrix;
    boundingVolume = BoundingSphere_default.clone(
      this._baseVolumeWC,
      this._boundingVolume
    );
  } else {
    boundingVolume = BoundingSphere_default.clone(
      this._baseVolume2D,
      this._boundingVolume
    );
  }
  updateBoundingVolume(this, frameState, boundingVolume);
  const blendOptionChanged = this._blendOption !== this.blendOption;
  this._blendOption = this.blendOption;
  if (blendOptionChanged) {
    if (this._blendOption === BlendOption_default.OPAQUE || this._blendOption === BlendOption_default.OPAQUE_AND_TRANSLUCENT) {
      this._rsOpaque = RenderState_default.fromCache({
        depthTest: {
          enabled: true,
          func: WebGLConstants_default.LESS
        },
        depthMask: true
      });
    } else {
      this._rsOpaque = void 0;
    }
    const useTranslucentDepthMask = this._blendOption === BlendOption_default.TRANSLUCENT;
    if (this._blendOption === BlendOption_default.TRANSLUCENT || this._blendOption === BlendOption_default.OPAQUE_AND_TRANSLUCENT) {
      this._rsTranslucent = RenderState_default.fromCache({
        depthTest: {
          enabled: true,
          func: useTranslucentDepthMask ? WebGLConstants_default.LEQUAL : WebGLConstants_default.LESS
        },
        depthMask: useTranslucentDepthMask,
        blending: BlendingState_default.ALPHA_BLEND
      });
    } else {
      this._rsTranslucent = void 0;
    }
  }
  this._shaderDisableDepthDistance = this._shaderDisableDepthDistance || frameState.minimumDisableDepthTestDistance !== 0;
  let vsSource;
  let fsSource;
  let vs;
  let fs;
  let vertDefines;
  const supportVSTextureReads = ContextLimits_default.maximumVertexTextureImageUnits > 0;
  if (blendOptionChanged || this._shaderRotation !== this._compiledShaderRotation || this._shaderAlignedAxis !== this._compiledShaderAlignedAxis || this._shaderScaleByDistance !== this._compiledShaderScaleByDistance || this._shaderTranslucencyByDistance !== this._compiledShaderTranslucencyByDistance || this._shaderPixelOffsetScaleByDistance !== this._compiledShaderPixelOffsetScaleByDistance || this._shaderDistanceDisplayCondition !== this._compiledShaderDistanceDisplayCondition || this._shaderDisableDepthDistance !== this._compiledShaderDisableDepthDistance || this._shaderClampToGround !== this._compiledShaderClampToGround || this._sdf !== this._compiledSDF) {
    vsSource = BillboardCollectionVS_default;
    fsSource = BillboardCollectionFS_default;
    vertDefines = [];
    if (defined_default(this._batchTable)) {
      vertDefines.push("VECTOR_TILE");
      vsSource = this._batchTable.getVertexShaderCallback(
        false,
        "a_batchId",
        void 0
      )(vsSource);
      fsSource = this._batchTable.getFragmentShaderCallback(
        false,
        void 0
      )(fsSource);
    }
    vs = new ShaderSource_default({
      defines: vertDefines,
      sources: [vsSource]
    });
    if (this._instanced) {
      vs.defines.push("INSTANCED");
    }
    if (this._shaderRotation) {
      vs.defines.push("ROTATION");
    }
    if (this._shaderAlignedAxis) {
      vs.defines.push("ALIGNED_AXIS");
    }
    if (this._shaderScaleByDistance) {
      vs.defines.push("EYE_DISTANCE_SCALING");
    }
    if (this._shaderTranslucencyByDistance) {
      vs.defines.push("EYE_DISTANCE_TRANSLUCENCY");
    }
    if (this._shaderPixelOffsetScaleByDistance) {
      vs.defines.push("EYE_DISTANCE_PIXEL_OFFSET");
    }
    if (this._shaderDistanceDisplayCondition) {
      vs.defines.push("DISTANCE_DISPLAY_CONDITION");
    }
    if (this._shaderDisableDepthDistance) {
      vs.defines.push("DISABLE_DEPTH_DISTANCE");
    }
    if (this._shaderClampToGround) {
      if (supportVSTextureReads) {
        vs.defines.push("VERTEX_DEPTH_CHECK");
      } else {
        vs.defines.push("FRAGMENT_DEPTH_CHECK");
      }
    }
    const sdfEdge = 1 - SDFSettings_default.CUTOFF;
    if (this._sdf) {
      vs.defines.push("SDF");
    }
    const vectorFragDefine = defined_default(this._batchTable) ? "VECTOR_TILE" : "";
    if (this._blendOption === BlendOption_default.OPAQUE_AND_TRANSLUCENT) {
      fs = new ShaderSource_default({
        defines: ["OPAQUE", vectorFragDefine],
        sources: [fsSource]
      });
      if (this._shaderClampToGround) {
        if (supportVSTextureReads) {
          fs.defines.push("VERTEX_DEPTH_CHECK");
        } else {
          fs.defines.push("FRAGMENT_DEPTH_CHECK");
        }
      }
      if (this._sdf) {
        fs.defines.push("SDF");
        fs.defines.push(`SDF_EDGE ${sdfEdge}`);
      }
      this._sp = ShaderProgram_default.replaceCache({
        context,
        shaderProgram: this._sp,
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations
      });
      fs = new ShaderSource_default({
        defines: ["TRANSLUCENT", vectorFragDefine],
        sources: [fsSource]
      });
      if (this._shaderClampToGround) {
        if (supportVSTextureReads) {
          fs.defines.push("VERTEX_DEPTH_CHECK");
        } else {
          fs.defines.push("FRAGMENT_DEPTH_CHECK");
        }
      }
      if (this._sdf) {
        fs.defines.push("SDF");
        fs.defines.push(`SDF_EDGE ${sdfEdge}`);
      }
      this._spTranslucent = ShaderProgram_default.replaceCache({
        context,
        shaderProgram: this._spTranslucent,
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations
      });
    }
    if (this._blendOption === BlendOption_default.OPAQUE) {
      fs = new ShaderSource_default({
        defines: [vectorFragDefine],
        sources: [fsSource]
      });
      if (this._shaderClampToGround) {
        if (supportVSTextureReads) {
          fs.defines.push("VERTEX_DEPTH_CHECK");
        } else {
          fs.defines.push("FRAGMENT_DEPTH_CHECK");
        }
      }
      if (this._sdf) {
        fs.defines.push("SDF");
        fs.defines.push(`SDF_EDGE ${sdfEdge}`);
      }
      this._sp = ShaderProgram_default.replaceCache({
        context,
        shaderProgram: this._sp,
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations
      });
    }
    if (this._blendOption === BlendOption_default.TRANSLUCENT) {
      fs = new ShaderSource_default({
        defines: [vectorFragDefine],
        sources: [fsSource]
      });
      if (this._shaderClampToGround) {
        if (supportVSTextureReads) {
          fs.defines.push("VERTEX_DEPTH_CHECK");
        } else {
          fs.defines.push("FRAGMENT_DEPTH_CHECK");
        }
      }
      if (this._sdf) {
        fs.defines.push("SDF");
        fs.defines.push(`SDF_EDGE ${sdfEdge}`);
      }
      this._spTranslucent = ShaderProgram_default.replaceCache({
        context,
        shaderProgram: this._spTranslucent,
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations
      });
    }
    this._compiledShaderRotation = this._shaderRotation;
    this._compiledShaderAlignedAxis = this._shaderAlignedAxis;
    this._compiledShaderScaleByDistance = this._shaderScaleByDistance;
    this._compiledShaderTranslucencyByDistance = this._shaderTranslucencyByDistance;
    this._compiledShaderPixelOffsetScaleByDistance = this._shaderPixelOffsetScaleByDistance;
    this._compiledShaderDistanceDisplayCondition = this._shaderDistanceDisplayCondition;
    this._compiledShaderDisableDepthDistance = this._shaderDisableDepthDistance;
    this._compiledShaderClampToGround = this._shaderClampToGround;
    this._compiledSDF = this._sdf;
  }
  const commandList = frameState.commandList;
  if (pass.render || pass.pick) {
    const colorList = this._colorCommands;
    const opaque = this._blendOption === BlendOption_default.OPAQUE;
    const opaqueAndTranslucent = this._blendOption === BlendOption_default.OPAQUE_AND_TRANSLUCENT;
    const va = this._vaf.va;
    const vaLength = va.length;
    let uniforms = this._uniforms;
    let pickId;
    if (defined_default(this._batchTable)) {
      uniforms = this._batchTable.getUniformMapCallback()(uniforms);
      pickId = this._batchTable.getPickId();
    } else {
      pickId = "v_pickColor";
    }
    colorList.length = vaLength;
    const totalLength = opaqueAndTranslucent ? vaLength * 2 : vaLength;
    for (let j = 0; j < totalLength; ++j) {
      let command = colorList[j];
      if (!defined_default(command)) {
        command = colorList[j] = new DrawCommand_default();
      }
      const opaqueCommand = opaque || opaqueAndTranslucent && j % 2 === 0;
      command.pass = opaqueCommand || !opaqueAndTranslucent ? Pass_default.OPAQUE : Pass_default.TRANSLUCENT;
      command.owner = this;
      const index2 = opaqueAndTranslucent ? Math.floor(j / 2) : j;
      command.boundingVolume = boundingVolume;
      command.modelMatrix = modelMatrix;
      command.count = va[index2].indicesCount;
      command.shaderProgram = opaqueCommand ? this._sp : this._spTranslucent;
      command.uniformMap = uniforms;
      command.vertexArray = va[index2].va;
      command.renderState = opaqueCommand ? this._rsOpaque : this._rsTranslucent;
      command.debugShowBoundingVolume = this.debugShowBoundingVolume;
      command.pickId = pickId;
      if (this._instanced) {
        command.count = 6;
        command.instanceCount = billboardsLength;
      }
      commandList.push(command);
    }
    if (this.debugShowTextureAtlas) {
      if (!defined_default(this.debugCommand)) {
        this.debugCommand = createDebugCommand(this, frameState.context);
      }
      commandList.push(this.debugCommand);
    }
  }
};
BillboardCollection.prototype.isDestroyed = function() {
  return false;
};
BillboardCollection.prototype.destroy = function() {
  if (defined_default(this._removeCallbackFunc)) {
    this._removeCallbackFunc();
    this._removeCallbackFunc = void 0;
  }
  this._textureAtlas = this._destroyTextureAtlas && this._textureAtlas && this._textureAtlas.destroy();
  this._sp = this._sp && this._sp.destroy();
  this._spTranslucent = this._spTranslucent && this._spTranslucent.destroy();
  this._vaf = this._vaf && this._vaf.destroy();
  destroyBillboards(this._billboards);
  return destroyObject_default(this);
};
var BillboardCollection_default = BillboardCollection;

// node_modules/cesium/Source/Scene/createBillboardPointCallback.js
function createBillboardPointCallback(centerAlpha, cssColor, cssOutlineColor, cssOutlineWidth, pixelSize) {
  return function() {
    const canvas = document.createElement("canvas");
    const length3 = pixelSize + 2 * cssOutlineWidth;
    canvas.height = canvas.width = length3;
    const context2D = canvas.getContext("2d");
    context2D.clearRect(0, 0, length3, length3);
    if (cssOutlineWidth !== 0) {
      context2D.beginPath();
      context2D.arc(length3 / 2, length3 / 2, length3 / 2, 0, 2 * Math.PI, true);
      context2D.closePath();
      context2D.fillStyle = cssOutlineColor;
      context2D.fill();
      if (centerAlpha < 1) {
        context2D.save();
        context2D.globalCompositeOperation = "destination-out";
        context2D.beginPath();
        context2D.arc(
          length3 / 2,
          length3 / 2,
          pixelSize / 2,
          0,
          2 * Math.PI,
          true
        );
        context2D.closePath();
        context2D.fillStyle = "black";
        context2D.fill();
        context2D.restore();
      }
    }
    context2D.beginPath();
    context2D.arc(length3 / 2, length3 / 2, pixelSize / 2, 0, 2 * Math.PI, true);
    context2D.closePath();
    context2D.fillStyle = cssColor;
    context2D.fill();
    return canvas;
  };
}
var createBillboardPointCallback_default = createBillboardPointCallback;

// node_modules/cesium/Source/Scene/Cesium3DTilePointFeature.js
function Cesium3DTilePointFeature(content, batchId, billboard, label, polyline) {
  this._content = content;
  this._billboard = billboard;
  this._label = label;
  this._polyline = polyline;
  this._batchId = batchId;
  this._billboardImage = void 0;
  this._billboardColor = void 0;
  this._billboardOutlineColor = void 0;
  this._billboardOutlineWidth = void 0;
  this._billboardSize = void 0;
  this._pointSize = void 0;
  this._color = void 0;
  this._pointSize = void 0;
  this._pointOutlineColor = void 0;
  this._pointOutlineWidth = void 0;
  this._heightOffset = void 0;
  this._pickIds = new Array(3);
  setBillboardImage(this);
}
var scratchCartographic7 = new Cartographic_default();
Object.defineProperties(Cesium3DTilePointFeature.prototype, {
  show: {
    get: function() {
      return this._label.show;
    },
    set: function(value) {
      this._label.show = value;
      this._billboard.show = value;
      this._polyline.show = value;
    }
  },
  color: {
    get: function() {
      return this._color;
    },
    set: function(value) {
      this._color = Color_default.clone(value, this._color);
      setBillboardImage(this);
    }
  },
  pointSize: {
    get: function() {
      return this._pointSize;
    },
    set: function(value) {
      this._pointSize = value;
      setBillboardImage(this);
    }
  },
  pointOutlineColor: {
    get: function() {
      return this._pointOutlineColor;
    },
    set: function(value) {
      this._pointOutlineColor = Color_default.clone(value, this._pointOutlineColor);
      setBillboardImage(this);
    }
  },
  pointOutlineWidth: {
    get: function() {
      return this._pointOutlineWidth;
    },
    set: function(value) {
      this._pointOutlineWidth = value;
      setBillboardImage(this);
    }
  },
  labelColor: {
    get: function() {
      return this._label.fillColor;
    },
    set: function(value) {
      this._label.fillColor = value;
      this._polyline.show = this._label.show && value.alpha > 0;
    }
  },
  labelOutlineColor: {
    get: function() {
      return this._label.outlineColor;
    },
    set: function(value) {
      this._label.outlineColor = value;
    }
  },
  labelOutlineWidth: {
    get: function() {
      return this._label.outlineWidth;
    },
    set: function(value) {
      this._label.outlineWidth = value;
    }
  },
  font: {
    get: function() {
      return this._label.font;
    },
    set: function(value) {
      this._label.font = value;
    }
  },
  labelStyle: {
    get: function() {
      return this._label.style;
    },
    set: function(value) {
      this._label.style = value;
    }
  },
  labelText: {
    get: function() {
      return this._label.text;
    },
    set: function(value) {
      if (!defined_default(value)) {
        value = "";
      }
      this._label.text = value;
    }
  },
  backgroundColor: {
    get: function() {
      return this._label.backgroundColor;
    },
    set: function(value) {
      this._label.backgroundColor = value;
    }
  },
  backgroundPadding: {
    get: function() {
      return this._label.backgroundPadding;
    },
    set: function(value) {
      this._label.backgroundPadding = value;
    }
  },
  backgroundEnabled: {
    get: function() {
      return this._label.showBackground;
    },
    set: function(value) {
      this._label.showBackground = value;
    }
  },
  scaleByDistance: {
    get: function() {
      return this._label.scaleByDistance;
    },
    set: function(value) {
      this._label.scaleByDistance = value;
      this._billboard.scaleByDistance = value;
    }
  },
  translucencyByDistance: {
    get: function() {
      return this._label.translucencyByDistance;
    },
    set: function(value) {
      this._label.translucencyByDistance = value;
      this._billboard.translucencyByDistance = value;
    }
  },
  distanceDisplayCondition: {
    get: function() {
      return this._label.distanceDisplayCondition;
    },
    set: function(value) {
      this._label.distanceDisplayCondition = value;
      this._polyline.distanceDisplayCondition = value;
      this._billboard.distanceDisplayCondition = value;
    }
  },
  heightOffset: {
    get: function() {
      return this._heightOffset;
    },
    set: function(value) {
      const offset2 = defaultValue_default(this._heightOffset, 0);
      const ellipsoid = this._content.tileset.ellipsoid;
      const cart = ellipsoid.cartesianToCartographic(
        this._billboard.position,
        scratchCartographic7
      );
      cart.height = cart.height - offset2 + value;
      const newPosition = ellipsoid.cartographicToCartesian(cart);
      this._billboard.position = newPosition;
      this._label.position = this._billboard.position;
      this._polyline.positions = [this._polyline.positions[0], newPosition];
      this._heightOffset = value;
    }
  },
  anchorLineEnabled: {
    get: function() {
      return this._polyline.show;
    },
    set: function(value) {
      this._polyline.show = value;
    }
  },
  anchorLineColor: {
    get: function() {
      return this._polyline.material.uniforms.color;
    },
    set: function(value) {
      this._polyline.material.uniforms.color = Color_default.clone(
        value,
        this._polyline.material.uniforms.color
      );
    }
  },
  image: {
    get: function() {
      return this._billboardImage;
    },
    set: function(value) {
      const imageChanged = this._billboardImage !== value;
      this._billboardImage = value;
      if (imageChanged) {
        setBillboardImage(this);
      }
    }
  },
  disableDepthTestDistance: {
    get: function() {
      return this._label.disableDepthTestDistance;
    },
    set: function(value) {
      this._label.disableDepthTestDistance = value;
      this._billboard.disableDepthTestDistance = value;
    }
  },
  horizontalOrigin: {
    get: function() {
      return this._billboard.horizontalOrigin;
    },
    set: function(value) {
      this._billboard.horizontalOrigin = value;
    }
  },
  verticalOrigin: {
    get: function() {
      return this._billboard.verticalOrigin;
    },
    set: function(value) {
      this._billboard.verticalOrigin = value;
    }
  },
  labelHorizontalOrigin: {
    get: function() {
      return this._label.horizontalOrigin;
    },
    set: function(value) {
      this._label.horizontalOrigin = value;
    }
  },
  labelVerticalOrigin: {
    get: function() {
      return this._label.verticalOrigin;
    },
    set: function(value) {
      this._label.verticalOrigin = value;
    }
  },
  content: {
    get: function() {
      return this._content;
    }
  },
  tileset: {
    get: function() {
      return this._content.tileset;
    }
  },
  primitive: {
    get: function() {
      return this._content.tileset;
    }
  },
  pickIds: {
    get: function() {
      const ids = this._pickIds;
      ids[0] = this._billboard.pickId;
      ids[1] = this._label.pickId;
      ids[2] = this._polyline.pickId;
      return ids;
    }
  }
});
Cesium3DTilePointFeature.defaultColor = Color_default.WHITE;
Cesium3DTilePointFeature.defaultPointOutlineColor = Color_default.BLACK;
Cesium3DTilePointFeature.defaultPointOutlineWidth = 0;
Cesium3DTilePointFeature.defaultPointSize = 8;
function setBillboardImage(feature2) {
  const b = feature2._billboard;
  if (defined_default(feature2._billboardImage) && feature2._billboardImage !== b.image) {
    b.image = feature2._billboardImage;
    return;
  }
  if (defined_default(feature2._billboardImage)) {
    return;
  }
  const newColor = defaultValue_default(
    feature2._color,
    Cesium3DTilePointFeature.defaultColor
  );
  const newOutlineColor = defaultValue_default(
    feature2._pointOutlineColor,
    Cesium3DTilePointFeature.defaultPointOutlineColor
  );
  const newOutlineWidth = defaultValue_default(
    feature2._pointOutlineWidth,
    Cesium3DTilePointFeature.defaultPointOutlineWidth
  );
  const newPointSize = defaultValue_default(
    feature2._pointSize,
    Cesium3DTilePointFeature.defaultPointSize
  );
  const currentColor = feature2._billboardColor;
  const currentOutlineColor = feature2._billboardOutlineColor;
  const currentOutlineWidth = feature2._billboardOutlineWidth;
  const currentPointSize = feature2._billboardSize;
  if (Color_default.equals(newColor, currentColor) && Color_default.equals(newOutlineColor, currentOutlineColor) && newOutlineWidth === currentOutlineWidth && newPointSize === currentPointSize) {
    return;
  }
  feature2._billboardColor = Color_default.clone(newColor, feature2._billboardColor);
  feature2._billboardOutlineColor = Color_default.clone(
    newOutlineColor,
    feature2._billboardOutlineColor
  );
  feature2._billboardOutlineWidth = newOutlineWidth;
  feature2._billboardSize = newPointSize;
  const centerAlpha = newColor.alpha;
  const cssColor = newColor.toCssColorString();
  const cssOutlineColor = newOutlineColor.toCssColorString();
  const textureId = JSON.stringify([
    cssColor,
    newPointSize,
    cssOutlineColor,
    newOutlineWidth
  ]);
  b.setImage(
    textureId,
    createBillboardPointCallback_default(
      centerAlpha,
      cssColor,
      cssOutlineColor,
      newOutlineWidth,
      newPointSize
    )
  );
}
Cesium3DTilePointFeature.prototype.hasProperty = function(name) {
  return this._content.batchTable.hasProperty(this._batchId, name);
};
Cesium3DTilePointFeature.prototype.getPropertyNames = function(results) {
  return this._content.batchTable.getPropertyNames(this._batchId, results);
};
Cesium3DTilePointFeature.prototype.getProperty = function(name) {
  return this._content.batchTable.getProperty(this._batchId, name);
};
Cesium3DTilePointFeature.prototype.getPropertyInherited = function(name) {
  return Cesium3DTileFeature_default.getPropertyInherited(
    this._content,
    this._batchId,
    name
  );
};
Cesium3DTilePointFeature.prototype.setProperty = function(name, value) {
  this._content.batchTable.setProperty(this._batchId, name, value);
  this._content.featurePropertiesDirty = true;
};
Cesium3DTilePointFeature.prototype.isExactClass = function(className) {
  return this._content.batchTable.isExactClass(this._batchId, className);
};
Cesium3DTilePointFeature.prototype.isClass = function(className) {
  return this._content.batchTable.isClass(this._batchId, className);
};
Cesium3DTilePointFeature.prototype.getExactClassName = function() {
  return this._content.batchTable.getExactClassName(this._batchId);
};
var Cesium3DTilePointFeature_default = Cesium3DTilePointFeature;

// node_modules/cesium/Source/ThirdParty/bitmap-sdf.js
var clamp_1 = clamp;
function clamp(value, min3, max3) {
  return min3 < max3 ? value < min3 ? min3 : value > max3 ? max3 : value : value < max3 ? max3 : value > min3 ? min3 : value;
}
var bitmapSdf = calcSDF;
var INF = 1e20;
function calcSDF(src2, options) {
  if (!options)
    options = {};
  var cutoff = options.cutoff == null ? 0.25 : options.cutoff;
  var radius = options.radius == null ? 8 : options.radius;
  var channel = options.channel || 0;
  var w, h, size, data, intData, stride, ctx, canvas, imgData, i2, l2;
  if (ArrayBuffer.isView(src2) || Array.isArray(src2)) {
    if (!options.width || !options.height)
      throw Error("For raw data width and height should be provided by options");
    w = options.width, h = options.height;
    data = src2;
    if (!options.stride)
      stride = Math.floor(src2.length / w / h);
    else
      stride = options.stride;
  } else {
    if (window.HTMLCanvasElement && src2 instanceof window.HTMLCanvasElement) {
      canvas = src2;
      ctx = canvas.getContext("2d");
      w = canvas.width, h = canvas.height;
      imgData = ctx.getImageData(0, 0, w, h);
      data = imgData.data;
      stride = 4;
    } else if (window.CanvasRenderingContext2D && src2 instanceof window.CanvasRenderingContext2D) {
      canvas = src2.canvas;
      ctx = src2;
      w = canvas.width, h = canvas.height;
      imgData = ctx.getImageData(0, 0, w, h);
      data = imgData.data;
      stride = 4;
    } else if (window.ImageData && src2 instanceof window.ImageData) {
      imgData = src2;
      w = src2.width, h = src2.height;
      data = imgData.data;
      stride = 4;
    }
  }
  size = Math.max(w, h);
  if (window.Uint8ClampedArray && data instanceof window.Uint8ClampedArray || window.Uint8Array && data instanceof window.Uint8Array) {
    intData = data;
    data = Array(w * h);
    for (i2 = 0, l2 = intData.length; i2 < l2; i2++) {
      data[i2] = intData[i2 * stride + channel] / 255;
    }
  } else {
    if (stride !== 1)
      throw Error("Raw data can have only 1 value per pixel");
  }
  var gridOuter = Array(w * h);
  var gridInner = Array(w * h);
  var f2 = Array(size);
  var d = Array(size);
  var z = Array(size + 1);
  var v7 = Array(size);
  for (i2 = 0, l2 = w * h; i2 < l2; i2++) {
    var a4 = data[i2];
    gridOuter[i2] = a4 === 1 ? 0 : a4 === 0 ? INF : Math.pow(Math.max(0, 0.5 - a4), 2);
    gridInner[i2] = a4 === 1 ? INF : a4 === 0 ? 0 : Math.pow(Math.max(0, a4 - 0.5), 2);
  }
  edt(gridOuter, w, h, f2, d, v7, z);
  edt(gridInner, w, h, f2, d, v7, z);
  var dist = window.Float32Array ? new Float32Array(w * h) : new Array(w * h);
  for (i2 = 0, l2 = w * h; i2 < l2; i2++) {
    dist[i2] = clamp_1(1 - ((gridOuter[i2] - gridInner[i2]) / radius + cutoff), 0, 1);
  }
  return dist;
}
function edt(data, width, height, f2, d, v7, z) {
  for (var x = 0; x < width; x++) {
    for (var y = 0; y < height; y++) {
      f2[y] = data[y * width + x];
    }
    edt1d(f2, d, v7, z, height);
    for (y = 0; y < height; y++) {
      data[y * width + x] = d[y];
    }
  }
  for (y = 0; y < height; y++) {
    for (x = 0; x < width; x++) {
      f2[x] = data[y * width + x];
    }
    edt1d(f2, d, v7, z, width);
    for (x = 0; x < width; x++) {
      data[y * width + x] = Math.sqrt(d[x]);
    }
  }
}
function edt1d(f2, d, v7, z, n2) {
  v7[0] = 0;
  z[0] = -INF;
  z[1] = +INF;
  for (var q = 1, k = 0; q < n2; q++) {
    var s2 = (f2[q] + q * q - (f2[v7[k]] + v7[k] * v7[k])) / (2 * q - 2 * v7[k]);
    while (s2 <= z[k]) {
      k--;
      s2 = (f2[q] + q * q - (f2[v7[k]] + v7[k] * v7[k])) / (2 * q - 2 * v7[k]);
    }
    k++;
    v7[k] = q;
    z[k] = s2;
    z[k + 1] = +INF;
  }
  for (q = 0, k = 0; q < n2; q++) {
    while (z[k + 1] < q)
      k++;
    d[q] = (q - v7[k]) * (q - v7[k]) + f2[v7[k]];
  }
}

// node_modules/cesium/Source/Scene/LabelStyle.js
var LabelStyle = {
  FILL: 0,
  OUTLINE: 1,
  FILL_AND_OUTLINE: 2
};
var LabelStyle_default = Object.freeze(LabelStyle);

// node_modules/cesium/Source/Scene/Label.js
var fontInfoCache = {};
var fontInfoCacheLength = 0;
var fontInfoCacheMaxSize = 256;
var defaultBackgroundColor = new Color_default(0.165, 0.165, 0.165, 0.8);
var defaultBackgroundPadding = new Cartesian2_default(7, 5);
var textTypes = Object.freeze({
  LTR: 0,
  RTL: 1,
  WEAK: 2,
  BRACKETS: 3
});
function rebindAllGlyphs(label) {
  if (!label._rebindAllGlyphs && !label._repositionAllGlyphs) {
    label._labelCollection._labelsToUpdate.push(label);
  }
  label._rebindAllGlyphs = true;
}
function repositionAllGlyphs(label) {
  if (!label._rebindAllGlyphs && !label._repositionAllGlyphs) {
    label._labelCollection._labelsToUpdate.push(label);
  }
  label._repositionAllGlyphs = true;
}
function getCSSValue(element, property) {
  return document.defaultView.getComputedStyle(element, null).getPropertyValue(property);
}
function parseFont(label) {
  let fontInfo = fontInfoCache[label._font];
  if (!defined_default(fontInfo)) {
    const div = document.createElement("div");
    div.style.position = "absolute";
    div.style.opacity = 0;
    div.style.font = label._font;
    document.body.appendChild(div);
    let lineHeight = parseFloat(getCSSValue(div, "line-height"));
    if (isNaN(lineHeight)) {
      lineHeight = void 0;
    }
    fontInfo = {
      family: getCSSValue(div, "font-family"),
      size: getCSSValue(div, "font-size").replace("px", ""),
      style: getCSSValue(div, "font-style"),
      weight: getCSSValue(div, "font-weight"),
      lineHeight
    };
    document.body.removeChild(div);
    if (fontInfoCacheLength < fontInfoCacheMaxSize) {
      fontInfoCache[label._font] = fontInfo;
      fontInfoCacheLength++;
    }
  }
  label._fontFamily = fontInfo.family;
  label._fontSize = fontInfo.size;
  label._fontStyle = fontInfo.style;
  label._fontWeight = fontInfo.weight;
  label._lineHeight = fontInfo.lineHeight;
}
function Label(options, labelCollection) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (defined_default(options.disableDepthTestDistance) && options.disableDepthTestDistance < 0) {
    throw new DeveloperError_default(
      "disableDepthTestDistance must be greater than 0.0."
    );
  }
  let translucencyByDistance = options.translucencyByDistance;
  let pixelOffsetScaleByDistance = options.pixelOffsetScaleByDistance;
  let scaleByDistance = options.scaleByDistance;
  let distanceDisplayCondition = options.distanceDisplayCondition;
  if (defined_default(translucencyByDistance)) {
    if (translucencyByDistance.far <= translucencyByDistance.near) {
      throw new DeveloperError_default(
        "translucencyByDistance.far must be greater than translucencyByDistance.near."
      );
    }
    translucencyByDistance = NearFarScalar_default.clone(translucencyByDistance);
  }
  if (defined_default(pixelOffsetScaleByDistance)) {
    if (pixelOffsetScaleByDistance.far <= pixelOffsetScaleByDistance.near) {
      throw new DeveloperError_default(
        "pixelOffsetScaleByDistance.far must be greater than pixelOffsetScaleByDistance.near."
      );
    }
    pixelOffsetScaleByDistance = NearFarScalar_default.clone(
      pixelOffsetScaleByDistance
    );
  }
  if (defined_default(scaleByDistance)) {
    if (scaleByDistance.far <= scaleByDistance.near) {
      throw new DeveloperError_default(
        "scaleByDistance.far must be greater than scaleByDistance.near."
      );
    }
    scaleByDistance = NearFarScalar_default.clone(scaleByDistance);
  }
  if (defined_default(distanceDisplayCondition)) {
    if (distanceDisplayCondition.far <= distanceDisplayCondition.near) {
      throw new DeveloperError_default(
        "distanceDisplayCondition.far must be greater than distanceDisplayCondition.near."
      );
    }
    distanceDisplayCondition = DistanceDisplayCondition_default.clone(
      distanceDisplayCondition
    );
  }
  this._renderedText = void 0;
  this._text = void 0;
  this._show = defaultValue_default(options.show, true);
  this._font = defaultValue_default(options.font, "30px sans-serif");
  this._fillColor = Color_default.clone(defaultValue_default(options.fillColor, Color_default.WHITE));
  this._outlineColor = Color_default.clone(
    defaultValue_default(options.outlineColor, Color_default.BLACK)
  );
  this._outlineWidth = defaultValue_default(options.outlineWidth, 1);
  this._showBackground = defaultValue_default(options.showBackground, false);
  this._backgroundColor = Color_default.clone(
    defaultValue_default(options.backgroundColor, defaultBackgroundColor)
  );
  this._backgroundPadding = Cartesian2_default.clone(
    defaultValue_default(options.backgroundPadding, defaultBackgroundPadding)
  );
  this._style = defaultValue_default(options.style, LabelStyle_default.FILL);
  this._verticalOrigin = defaultValue_default(
    options.verticalOrigin,
    VerticalOrigin_default.BASELINE
  );
  this._horizontalOrigin = defaultValue_default(
    options.horizontalOrigin,
    HorizontalOrigin_default.LEFT
  );
  this._pixelOffset = Cartesian2_default.clone(
    defaultValue_default(options.pixelOffset, Cartesian2_default.ZERO)
  );
  this._eyeOffset = Cartesian3_default.clone(
    defaultValue_default(options.eyeOffset, Cartesian3_default.ZERO)
  );
  this._position = Cartesian3_default.clone(
    defaultValue_default(options.position, Cartesian3_default.ZERO)
  );
  this._scale = defaultValue_default(options.scale, 1);
  this._id = options.id;
  this._translucencyByDistance = translucencyByDistance;
  this._pixelOffsetScaleByDistance = pixelOffsetScaleByDistance;
  this._scaleByDistance = scaleByDistance;
  this._heightReference = defaultValue_default(
    options.heightReference,
    HeightReference_default.NONE
  );
  this._distanceDisplayCondition = distanceDisplayCondition;
  this._disableDepthTestDistance = options.disableDepthTestDistance;
  this._labelCollection = labelCollection;
  this._glyphs = [];
  this._backgroundBillboard = void 0;
  this._batchIndex = void 0;
  this._rebindAllGlyphs = true;
  this._repositionAllGlyphs = true;
  this._actualClampedPosition = void 0;
  this._removeCallbackFunc = void 0;
  this._mode = void 0;
  this._clusterShow = true;
  this.text = defaultValue_default(options.text, "");
  this._relativeSize = 1;
  parseFont(this);
  this._updateClamping();
}
Object.defineProperties(Label.prototype, {
  show: {
    get: function() {
      return this._show;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._show !== value) {
        this._show = value;
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const billboard = glyphs[i2].billboard;
          if (defined_default(billboard)) {
            billboard.show = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.show = value;
        }
      }
    }
  },
  position: {
    get: function() {
      return this._position;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const position = this._position;
      if (!Cartesian3_default.equals(position, value)) {
        Cartesian3_default.clone(value, position);
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const billboard = glyphs[i2].billboard;
          if (defined_default(billboard)) {
            billboard.position = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.position = value;
        }
        this._updateClamping();
      }
    }
  },
  heightReference: {
    get: function() {
      return this._heightReference;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (value !== this._heightReference) {
        this._heightReference = value;
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const billboard = glyphs[i2].billboard;
          if (defined_default(billboard)) {
            billboard.heightReference = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.heightReference = value;
        }
        repositionAllGlyphs(this);
        this._updateClamping();
      }
    }
  },
  text: {
    get: function() {
      return this._text;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._text !== value) {
        this._text = value;
        const renderedValue = value.replace(/\u00ad/g, "");
        this._renderedText = Label.enableRightToLeftDetection ? reverseRtl(renderedValue) : renderedValue;
        rebindAllGlyphs(this);
      }
    }
  },
  font: {
    get: function() {
      return this._font;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._font !== value) {
        this._font = value;
        rebindAllGlyphs(this);
        parseFont(this);
      }
    }
  },
  fillColor: {
    get: function() {
      return this._fillColor;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const fillColor = this._fillColor;
      if (!Color_default.equals(fillColor, value)) {
        Color_default.clone(value, fillColor);
        rebindAllGlyphs(this);
      }
    }
  },
  outlineColor: {
    get: function() {
      return this._outlineColor;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const outlineColor = this._outlineColor;
      if (!Color_default.equals(outlineColor, value)) {
        Color_default.clone(value, outlineColor);
        rebindAllGlyphs(this);
      }
    }
  },
  outlineWidth: {
    get: function() {
      return this._outlineWidth;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._outlineWidth !== value) {
        this._outlineWidth = value;
        rebindAllGlyphs(this);
      }
    }
  },
  showBackground: {
    get: function() {
      return this._showBackground;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._showBackground !== value) {
        this._showBackground = value;
        rebindAllGlyphs(this);
      }
    }
  },
  backgroundColor: {
    get: function() {
      return this._backgroundColor;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const backgroundColor = this._backgroundColor;
      if (!Color_default.equals(backgroundColor, value)) {
        Color_default.clone(value, backgroundColor);
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.color = backgroundColor;
        }
      }
    }
  },
  backgroundPadding: {
    get: function() {
      return this._backgroundPadding;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const backgroundPadding = this._backgroundPadding;
      if (!Cartesian2_default.equals(backgroundPadding, value)) {
        Cartesian2_default.clone(value, backgroundPadding);
        repositionAllGlyphs(this);
      }
    }
  },
  style: {
    get: function() {
      return this._style;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._style !== value) {
        this._style = value;
        rebindAllGlyphs(this);
      }
    }
  },
  pixelOffset: {
    get: function() {
      return this._pixelOffset;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const pixelOffset = this._pixelOffset;
      if (!Cartesian2_default.equals(pixelOffset, value)) {
        Cartesian2_default.clone(value, pixelOffset);
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.pixelOffset = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.pixelOffset = value;
        }
      }
    }
  },
  translucencyByDistance: {
    get: function() {
      return this._translucencyByDistance;
    },
    set: function(value) {
      if (defined_default(value) && value.far <= value.near) {
        throw new DeveloperError_default(
          "far distance must be greater than near distance."
        );
      }
      const translucencyByDistance = this._translucencyByDistance;
      if (!NearFarScalar_default.equals(translucencyByDistance, value)) {
        this._translucencyByDistance = NearFarScalar_default.clone(
          value,
          translucencyByDistance
        );
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.translucencyByDistance = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.translucencyByDistance = value;
        }
      }
    }
  },
  pixelOffsetScaleByDistance: {
    get: function() {
      return this._pixelOffsetScaleByDistance;
    },
    set: function(value) {
      if (defined_default(value) && value.far <= value.near) {
        throw new DeveloperError_default(
          "far distance must be greater than near distance."
        );
      }
      const pixelOffsetScaleByDistance = this._pixelOffsetScaleByDistance;
      if (!NearFarScalar_default.equals(pixelOffsetScaleByDistance, value)) {
        this._pixelOffsetScaleByDistance = NearFarScalar_default.clone(
          value,
          pixelOffsetScaleByDistance
        );
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.pixelOffsetScaleByDistance = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.pixelOffsetScaleByDistance = value;
        }
      }
    }
  },
  scaleByDistance: {
    get: function() {
      return this._scaleByDistance;
    },
    set: function(value) {
      if (defined_default(value) && value.far <= value.near) {
        throw new DeveloperError_default(
          "far distance must be greater than near distance."
        );
      }
      const scaleByDistance = this._scaleByDistance;
      if (!NearFarScalar_default.equals(scaleByDistance, value)) {
        this._scaleByDistance = NearFarScalar_default.clone(value, scaleByDistance);
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.scaleByDistance = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.scaleByDistance = value;
        }
      }
    }
  },
  eyeOffset: {
    get: function() {
      return this._eyeOffset;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const eyeOffset = this._eyeOffset;
      if (!Cartesian3_default.equals(eyeOffset, value)) {
        Cartesian3_default.clone(value, eyeOffset);
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.eyeOffset = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.eyeOffset = value;
        }
      }
    }
  },
  horizontalOrigin: {
    get: function() {
      return this._horizontalOrigin;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._horizontalOrigin !== value) {
        this._horizontalOrigin = value;
        repositionAllGlyphs(this);
      }
    }
  },
  verticalOrigin: {
    get: function() {
      return this._verticalOrigin;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._verticalOrigin !== value) {
        this._verticalOrigin = value;
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.verticalOrigin = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.verticalOrigin = value;
        }
        repositionAllGlyphs(this);
      }
    }
  },
  scale: {
    get: function() {
      return this._scale;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._scale !== value) {
        this._scale = value;
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.scale = value * this._relativeSize;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.scale = value * this._relativeSize;
        }
        repositionAllGlyphs(this);
      }
    }
  },
  totalScale: {
    get: function() {
      return this._scale * this._relativeSize;
    }
  },
  distanceDisplayCondition: {
    get: function() {
      return this._distanceDisplayCondition;
    },
    set: function(value) {
      if (defined_default(value) && value.far <= value.near) {
        throw new DeveloperError_default("far must be greater than near");
      }
      if (!DistanceDisplayCondition_default.equals(value, this._distanceDisplayCondition)) {
        this._distanceDisplayCondition = DistanceDisplayCondition_default.clone(
          value,
          this._distanceDisplayCondition
        );
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.distanceDisplayCondition = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.distanceDisplayCondition = value;
        }
      }
    }
  },
  disableDepthTestDistance: {
    get: function() {
      return this._disableDepthTestDistance;
    },
    set: function(value) {
      if (this._disableDepthTestDistance !== value) {
        if (defined_default(value) && value < 0) {
          throw new DeveloperError_default(
            "disableDepthTestDistance must be greater than 0.0."
          );
        }
        this._disableDepthTestDistance = value;
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.disableDepthTestDistance = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.disableDepthTestDistance = value;
        }
      }
    }
  },
  id: {
    get: function() {
      return this._id;
    },
    set: function(value) {
      if (this._id !== value) {
        this._id = value;
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.id = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.id = value;
        }
      }
    }
  },
  pickId: {
    get: function() {
      if (this._glyphs.length === 0 || !defined_default(this._glyphs[0].billboard)) {
        return void 0;
      }
      return this._glyphs[0].billboard.pickId;
    }
  },
  _clampedPosition: {
    get: function() {
      return this._actualClampedPosition;
    },
    set: function(value) {
      this._actualClampedPosition = Cartesian3_default.clone(
        value,
        this._actualClampedPosition
      );
      const glyphs = this._glyphs;
      for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
        const glyph = glyphs[i2];
        if (defined_default(glyph.billboard)) {
          glyph.billboard._clampedPosition = value;
        }
      }
      const backgroundBillboard = this._backgroundBillboard;
      if (defined_default(backgroundBillboard)) {
        backgroundBillboard._clampedPosition = value;
      }
    }
  },
  clusterShow: {
    get: function() {
      return this._clusterShow;
    },
    set: function(value) {
      if (this._clusterShow !== value) {
        this._clusterShow = value;
        const glyphs = this._glyphs;
        for (let i2 = 0, len = glyphs.length; i2 < len; i2++) {
          const glyph = glyphs[i2];
          if (defined_default(glyph.billboard)) {
            glyph.billboard.clusterShow = value;
          }
        }
        const backgroundBillboard = this._backgroundBillboard;
        if (defined_default(backgroundBillboard)) {
          backgroundBillboard.clusterShow = value;
        }
      }
    }
  }
});
Label.prototype._updateClamping = function() {
  Billboard_default._updateClamping(this._labelCollection, this);
};
Label.prototype.computeScreenSpacePosition = function(scene, result) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian2_default();
  }
  const labelCollection = this._labelCollection;
  const modelMatrix = labelCollection.modelMatrix;
  const actualPosition = defined_default(this._actualClampedPosition) ? this._actualClampedPosition : this._position;
  const windowCoordinates = Billboard_default._computeScreenSpacePosition(
    modelMatrix,
    actualPosition,
    this._eyeOffset,
    this._pixelOffset,
    scene,
    result
  );
  return windowCoordinates;
};
Label.getScreenSpaceBoundingBox = function(label, screenSpacePosition, result) {
  let x = 0;
  let y = 0;
  let width = 0;
  let height = 0;
  const scale = label.totalScale;
  const backgroundBillboard = label._backgroundBillboard;
  if (defined_default(backgroundBillboard)) {
    x = screenSpacePosition.x + backgroundBillboard._translate.x;
    y = screenSpacePosition.y - backgroundBillboard._translate.y;
    width = backgroundBillboard.width * scale;
    height = backgroundBillboard.height * scale;
    if (label.verticalOrigin === VerticalOrigin_default.BOTTOM || label.verticalOrigin === VerticalOrigin_default.BASELINE) {
      y -= height;
    } else if (label.verticalOrigin === VerticalOrigin_default.CENTER) {
      y -= height * 0.5;
    }
  } else {
    x = Number.POSITIVE_INFINITY;
    y = Number.POSITIVE_INFINITY;
    let maxX = 0;
    let maxY = 0;
    const glyphs = label._glyphs;
    const length3 = glyphs.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      const glyph = glyphs[i2];
      const billboard = glyph.billboard;
      if (!defined_default(billboard)) {
        continue;
      }
      const glyphX = screenSpacePosition.x + billboard._translate.x;
      let glyphY = screenSpacePosition.y - billboard._translate.y;
      const glyphWidth = glyph.dimensions.width * scale;
      const glyphHeight = glyph.dimensions.height * scale;
      if (label.verticalOrigin === VerticalOrigin_default.BOTTOM || label.verticalOrigin === VerticalOrigin_default.BASELINE) {
        glyphY -= glyphHeight;
      } else if (label.verticalOrigin === VerticalOrigin_default.CENTER) {
        glyphY -= glyphHeight * 0.5;
      }
      if (label._verticalOrigin === VerticalOrigin_default.TOP) {
        glyphY += SDFSettings_default.PADDING * scale;
      } else if (label._verticalOrigin === VerticalOrigin_default.BOTTOM || label._verticalOrigin === VerticalOrigin_default.BASELINE) {
        glyphY -= SDFSettings_default.PADDING * scale;
      }
      x = Math.min(x, glyphX);
      y = Math.min(y, glyphY);
      maxX = Math.max(maxX, glyphX + glyphWidth);
      maxY = Math.max(maxY, glyphY + glyphHeight);
    }
    width = maxX - x;
    height = maxY - y;
  }
  if (!defined_default(result)) {
    result = new BoundingRectangle_default();
  }
  result.x = x;
  result.y = y;
  result.width = width;
  result.height = height;
  return result;
};
Label.prototype.equals = function(other) {
  return this === other || defined_default(other) && this._show === other._show && this._scale === other._scale && this._outlineWidth === other._outlineWidth && this._showBackground === other._showBackground && this._style === other._style && this._verticalOrigin === other._verticalOrigin && this._horizontalOrigin === other._horizontalOrigin && this._heightReference === other._heightReference && this._renderedText === other._renderedText && this._font === other._font && Cartesian3_default.equals(this._position, other._position) && Color_default.equals(this._fillColor, other._fillColor) && Color_default.equals(this._outlineColor, other._outlineColor) && Color_default.equals(this._backgroundColor, other._backgroundColor) && Cartesian2_default.equals(this._backgroundPadding, other._backgroundPadding) && Cartesian2_default.equals(this._pixelOffset, other._pixelOffset) && Cartesian3_default.equals(this._eyeOffset, other._eyeOffset) && NearFarScalar_default.equals(
    this._translucencyByDistance,
    other._translucencyByDistance
  ) && NearFarScalar_default.equals(
    this._pixelOffsetScaleByDistance,
    other._pixelOffsetScaleByDistance
  ) && NearFarScalar_default.equals(this._scaleByDistance, other._scaleByDistance) && DistanceDisplayCondition_default.equals(
    this._distanceDisplayCondition,
    other._distanceDisplayCondition
  ) && this._disableDepthTestDistance === other._disableDepthTestDistance && this._id === other._id;
};
Label.prototype.isDestroyed = function() {
  return false;
};
Label.enableRightToLeftDetection = false;
function convertTextToTypes(text2, rtlChars2) {
  const ltrChars = /[a-zA-Z0-9]/;
  const bracketsChars = /[()[\]{}<>]/;
  const parsedText = [];
  let word = "";
  let lastType = textTypes.LTR;
  let currentType = "";
  const textLength = text2.length;
  for (let textIndex = 0; textIndex < textLength; ++textIndex) {
    const character = text2.charAt(textIndex);
    if (rtlChars2.test(character)) {
      currentType = textTypes.RTL;
    } else if (ltrChars.test(character)) {
      currentType = textTypes.LTR;
    } else if (bracketsChars.test(character)) {
      currentType = textTypes.BRACKETS;
    } else {
      currentType = textTypes.WEAK;
    }
    if (textIndex === 0) {
      lastType = currentType;
    }
    if (lastType === currentType && currentType !== textTypes.BRACKETS) {
      word += character;
    } else {
      if (word !== "") {
        parsedText.push({ Type: lastType, Word: word });
      }
      lastType = currentType;
      word = character;
    }
  }
  parsedText.push({ Type: currentType, Word: word });
  return parsedText;
}
function reverseWord(word) {
  return word.split("").reverse().join("");
}
function spliceWord(result, pointer, word) {
  return result.slice(0, pointer) + word + result.slice(pointer);
}
function reverseBrackets(bracket) {
  switch (bracket) {
    case "(":
      return ")";
    case ")":
      return "(";
    case "[":
      return "]";
    case "]":
      return "[";
    case "{":
      return "}";
    case "}":
      return "{";
    case "<":
      return ">";
    case ">":
      return "<";
  }
}
var hebrew = "\u05D0-\u05EA";
var arabic = "\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF";
var rtlChars = new RegExp(`[${hebrew}${arabic}]`);
function reverseRtl(value) {
  const texts = value.split("\n");
  let result = "";
  for (let i2 = 0; i2 < texts.length; i2++) {
    const text2 = texts[i2];
    const rtlDir = rtlChars.test(text2.charAt(0));
    const parsedText = convertTextToTypes(text2, rtlChars);
    let splicePointer = 0;
    let line = "";
    for (let wordIndex = 0; wordIndex < parsedText.length; ++wordIndex) {
      const subText = parsedText[wordIndex];
      const reverse2 = subText.Type === textTypes.BRACKETS ? reverseBrackets(subText.Word) : reverseWord(subText.Word);
      if (rtlDir) {
        if (subText.Type === textTypes.RTL) {
          line = reverse2 + line;
          splicePointer = 0;
        } else if (subText.Type === textTypes.LTR) {
          line = spliceWord(line, splicePointer, subText.Word);
          splicePointer += subText.Word.length;
        } else if (subText.Type === textTypes.WEAK || subText.Type === textTypes.BRACKETS) {
          if (subText.Type === textTypes.WEAK && parsedText[wordIndex - 1].Type === textTypes.BRACKETS) {
            line = reverse2 + line;
          } else if (parsedText[wordIndex - 1].Type === textTypes.RTL) {
            line = reverse2 + line;
            splicePointer = 0;
          } else if (parsedText.length > wordIndex + 1) {
            if (parsedText[wordIndex + 1].Type === textTypes.RTL) {
              line = reverse2 + line;
              splicePointer = 0;
            } else {
              line = spliceWord(line, splicePointer, subText.Word);
              splicePointer += subText.Word.length;
            }
          } else {
            line = spliceWord(line, 0, reverse2);
          }
        }
      } else if (subText.Type === textTypes.RTL) {
        line = spliceWord(line, splicePointer, reverse2);
      } else if (subText.Type === textTypes.LTR) {
        line += subText.Word;
        splicePointer = line.length;
      } else if (subText.Type === textTypes.WEAK || subText.Type === textTypes.BRACKETS) {
        if (wordIndex > 0) {
          if (parsedText[wordIndex - 1].Type === textTypes.RTL) {
            if (parsedText.length > wordIndex + 1) {
              if (parsedText[wordIndex + 1].Type === textTypes.RTL) {
                line = spliceWord(line, splicePointer, reverse2);
              } else {
                line += subText.Word;
                splicePointer = line.length;
              }
            } else {
              line += subText.Word;
            }
          } else {
            line += subText.Word;
            splicePointer = line.length;
          }
        } else {
          line += subText.Word;
          splicePointer = line.length;
        }
      }
    }
    result += line;
    if (i2 < texts.length - 1) {
      result += "\n";
    }
  }
  return result;
}
var Label_default = Label;

// node_modules/cesium/Source/ThirdParty/grapheme-splitter.js
var graphemeSplitter = createCommonjsModule(function(module2) {
  function GraphemeSplitter() {
    var CR = 0, LF = 1, Control = 2, Extend = 3, Regional_Indicator = 4, SpacingMark = 5, L = 6, V = 7, T = 8, LV = 9, LVT = 10, Other = 11, Prepend = 12, E_Base = 13, E_Modifier = 14, ZWJ = 15, Glue_After_Zwj = 16, E_Base_GAZ = 17;
    var NotBreak = 0, BreakStart = 1, Break = 2, BreakLastRegional = 3, BreakPenultimateRegional = 4;
    function isSurrogate(str, pos) {
      return 55296 <= str.charCodeAt(pos) && str.charCodeAt(pos) <= 56319 && 56320 <= str.charCodeAt(pos + 1) && str.charCodeAt(pos + 1) <= 57343;
    }
    function codePointAt(str, idx) {
      if (idx === void 0) {
        idx = 0;
      }
      var code = str.charCodeAt(idx);
      if (55296 <= code && code <= 56319 && idx < str.length - 1) {
        var hi = code;
        var low = str.charCodeAt(idx + 1);
        if (56320 <= low && low <= 57343) {
          return (hi - 55296) * 1024 + (low - 56320) + 65536;
        }
        return hi;
      }
      if (56320 <= code && code <= 57343 && idx >= 1) {
        var hi = str.charCodeAt(idx - 1);
        var low = code;
        if (55296 <= hi && hi <= 56319) {
          return (hi - 55296) * 1024 + (low - 56320) + 65536;
        }
        return low;
      }
      return code;
    }
    function shouldBreak(start, mid, end) {
      var all = [start].concat(mid).concat([end]);
      var previous = all[all.length - 2];
      var next = end;
      var eModifierIndex = all.lastIndexOf(E_Modifier);
      if (eModifierIndex > 1 && all.slice(1, eModifierIndex).every(function(c14) {
        return c14 == Extend;
      }) && [Extend, E_Base, E_Base_GAZ].indexOf(start) == -1) {
        return Break;
      }
      var rIIndex = all.lastIndexOf(Regional_Indicator);
      if (rIIndex > 0 && all.slice(1, rIIndex).every(function(c14) {
        return c14 == Regional_Indicator;
      }) && [Prepend, Regional_Indicator].indexOf(previous) == -1) {
        if (all.filter(function(c14) {
          return c14 == Regional_Indicator;
        }).length % 2 == 1) {
          return BreakLastRegional;
        } else {
          return BreakPenultimateRegional;
        }
      }
      if (previous == CR && next == LF) {
        return NotBreak;
      } else if (previous == Control || previous == CR || previous == LF) {
        if (next == E_Modifier && mid.every(function(c14) {
          return c14 == Extend;
        })) {
          return Break;
        } else {
          return BreakStart;
        }
      } else if (next == Control || next == CR || next == LF) {
        return BreakStart;
      } else if (previous == L && (next == L || next == V || next == LV || next == LVT)) {
        return NotBreak;
      } else if ((previous == LV || previous == V) && (next == V || next == T)) {
        return NotBreak;
      } else if ((previous == LVT || previous == T) && next == T) {
        return NotBreak;
      } else if (next == Extend || next == ZWJ) {
        return NotBreak;
      } else if (next == SpacingMark) {
        return NotBreak;
      } else if (previous == Prepend) {
        return NotBreak;
      }
      var previousNonExtendIndex = all.indexOf(Extend) != -1 ? all.lastIndexOf(Extend) - 1 : all.length - 2;
      if ([E_Base, E_Base_GAZ].indexOf(all[previousNonExtendIndex]) != -1 && all.slice(previousNonExtendIndex + 1, -1).every(function(c14) {
        return c14 == Extend;
      }) && next == E_Modifier) {
        return NotBreak;
      }
      if (previous == ZWJ && [Glue_After_Zwj, E_Base_GAZ].indexOf(next) != -1) {
        return NotBreak;
      }
      if (mid.indexOf(Regional_Indicator) != -1) {
        return Break;
      }
      if (previous == Regional_Indicator && next == Regional_Indicator) {
        return NotBreak;
      }
      return BreakStart;
    }
    this.nextBreak = function(string, index2) {
      if (index2 === void 0) {
        index2 = 0;
      }
      if (index2 < 0) {
        return 0;
      }
      if (index2 >= string.length - 1) {
        return string.length;
      }
      var prev = getGraphemeBreakProperty(codePointAt(string, index2));
      var mid = [];
      for (var i2 = index2 + 1; i2 < string.length; i2++) {
        if (isSurrogate(string, i2 - 1)) {
          continue;
        }
        var next = getGraphemeBreakProperty(codePointAt(string, i2));
        if (shouldBreak(prev, mid, next)) {
          return i2;
        }
        mid.push(next);
      }
      return string.length;
    };
    this.splitGraphemes = function(str) {
      var res = [];
      var index2 = 0;
      var brk;
      while ((brk = this.nextBreak(str, index2)) < str.length) {
        res.push(str.slice(index2, brk));
        index2 = brk;
      }
      if (index2 < str.length) {
        res.push(str.slice(index2));
      }
      return res;
    };
    this.iterateGraphemes = function(str) {
      var index2 = 0;
      var res = {
        next: function() {
          var value;
          var brk;
          if ((brk = this.nextBreak(str, index2)) < str.length) {
            value = str.slice(index2, brk);
            index2 = brk;
            return { value, done: false };
          }
          if (index2 < str.length) {
            value = str.slice(index2);
            index2 = str.length;
            return { value, done: false };
          }
          return { value: void 0, done: true };
        }.bind(this)
      };
      if (typeof Symbol !== "undefined" && Symbol.iterator) {
        res[Symbol.iterator] = function() {
          return res;
        };
      }
      return res;
    };
    this.countGraphemes = function(str) {
      var count = 0;
      var index2 = 0;
      var brk;
      while ((brk = this.nextBreak(str, index2)) < str.length) {
        index2 = brk;
        count++;
      }
      if (index2 < str.length) {
        count++;
      }
      return count;
    };
    function getGraphemeBreakProperty(code) {
      if (1536 <= code && code <= 1541 || 1757 == code || 1807 == code || 2274 == code || 3406 == code || 69821 == code || 70082 <= code && code <= 70083 || 72250 == code || 72326 <= code && code <= 72329 || 73030 == code) {
        return Prepend;
      }
      if (13 == code) {
        return CR;
      }
      if (10 == code) {
        return LF;
      }
      if (0 <= code && code <= 9 || 11 <= code && code <= 12 || 14 <= code && code <= 31 || 127 <= code && code <= 159 || 173 == code || 1564 == code || 6158 == code || 8203 == code || 8206 <= code && code <= 8207 || 8232 == code || 8233 == code || 8234 <= code && code <= 8238 || 8288 <= code && code <= 8292 || 8293 == code || 8294 <= code && code <= 8303 || 55296 <= code && code <= 57343 || 65279 == code || 65520 <= code && code <= 65528 || 65529 <= code && code <= 65531 || 113824 <= code && code <= 113827 || 119155 <= code && code <= 119162 || 917504 == code || 917505 == code || 917506 <= code && code <= 917535 || 917632 <= code && code <= 917759 || 918e3 <= code && code <= 921599) {
        return Control;
      }
      if (768 <= code && code <= 879 || 1155 <= code && code <= 1159 || 1160 <= code && code <= 1161 || 1425 <= code && code <= 1469 || 1471 == code || 1473 <= code && code <= 1474 || 1476 <= code && code <= 1477 || 1479 == code || 1552 <= code && code <= 1562 || 1611 <= code && code <= 1631 || 1648 == code || 1750 <= code && code <= 1756 || 1759 <= code && code <= 1764 || 1767 <= code && code <= 1768 || 1770 <= code && code <= 1773 || 1809 == code || 1840 <= code && code <= 1866 || 1958 <= code && code <= 1968 || 2027 <= code && code <= 2035 || 2070 <= code && code <= 2073 || 2075 <= code && code <= 2083 || 2085 <= code && code <= 2087 || 2089 <= code && code <= 2093 || 2137 <= code && code <= 2139 || 2260 <= code && code <= 2273 || 2275 <= code && code <= 2306 || 2362 == code || 2364 == code || 2369 <= code && code <= 2376 || 2381 == code || 2385 <= code && code <= 2391 || 2402 <= code && code <= 2403 || 2433 == code || 2492 == code || 2494 == code || 2497 <= code && code <= 2500 || 2509 == code || 2519 == code || 2530 <= code && code <= 2531 || 2561 <= code && code <= 2562 || 2620 == code || 2625 <= code && code <= 2626 || 2631 <= code && code <= 2632 || 2635 <= code && code <= 2637 || 2641 == code || 2672 <= code && code <= 2673 || 2677 == code || 2689 <= code && code <= 2690 || 2748 == code || 2753 <= code && code <= 2757 || 2759 <= code && code <= 2760 || 2765 == code || 2786 <= code && code <= 2787 || 2810 <= code && code <= 2815 || 2817 == code || 2876 == code || 2878 == code || 2879 == code || 2881 <= code && code <= 2884 || 2893 == code || 2902 == code || 2903 == code || 2914 <= code && code <= 2915 || 2946 == code || 3006 == code || 3008 == code || 3021 == code || 3031 == code || 3072 == code || 3134 <= code && code <= 3136 || 3142 <= code && code <= 3144 || 3146 <= code && code <= 3149 || 3157 <= code && code <= 3158 || 3170 <= code && code <= 3171 || 3201 == code || 3260 == code || 3263 == code || 3266 == code || 3270 == code || 3276 <= code && code <= 3277 || 3285 <= code && code <= 3286 || 3298 <= code && code <= 3299 || 3328 <= code && code <= 3329 || 3387 <= code && code <= 3388 || 3390 == code || 3393 <= code && code <= 3396 || 3405 == code || 3415 == code || 3426 <= code && code <= 3427 || 3530 == code || 3535 == code || 3538 <= code && code <= 3540 || 3542 == code || 3551 == code || 3633 == code || 3636 <= code && code <= 3642 || 3655 <= code && code <= 3662 || 3761 == code || 3764 <= code && code <= 3769 || 3771 <= code && code <= 3772 || 3784 <= code && code <= 3789 || 3864 <= code && code <= 3865 || 3893 == code || 3895 == code || 3897 == code || 3953 <= code && code <= 3966 || 3968 <= code && code <= 3972 || 3974 <= code && code <= 3975 || 3981 <= code && code <= 3991 || 3993 <= code && code <= 4028 || 4038 == code || 4141 <= code && code <= 4144 || 4146 <= code && code <= 4151 || 4153 <= code && code <= 4154 || 4157 <= code && code <= 4158 || 4184 <= code && code <= 4185 || 4190 <= code && code <= 4192 || 4209 <= code && code <= 4212 || 4226 == code || 4229 <= code && code <= 4230 || 4237 == code || 4253 == code || 4957 <= code && code <= 4959 || 5906 <= code && code <= 5908 || 5938 <= code && code <= 5940 || 5970 <= code && code <= 5971 || 6002 <= code && code <= 6003 || 6068 <= code && code <= 6069 || 6071 <= code && code <= 6077 || 6086 == code || 6089 <= code && code <= 6099 || 6109 == code || 6155 <= code && code <= 6157 || 6277 <= code && code <= 6278 || 6313 == code || 6432 <= code && code <= 6434 || 6439 <= code && code <= 6440 || 6450 == code || 6457 <= code && code <= 6459 || 6679 <= code && code <= 6680 || 6683 == code || 6742 == code || 6744 <= code && code <= 6750 || 6752 == code || 6754 == code || 6757 <= code && code <= 6764 || 6771 <= code && code <= 6780 || 6783 == code || 6832 <= code && code <= 6845 || 6846 == code || 6912 <= code && code <= 6915 || 6964 == code || 6966 <= code && code <= 6970 || 6972 == code || 6978 == code || 7019 <= code && code <= 7027 || 7040 <= code && code <= 7041 || 7074 <= code && code <= 7077 || 7080 <= code && code <= 7081 || 7083 <= code && code <= 7085 || 7142 == code || 7144 <= code && code <= 7145 || 7149 == code || 7151 <= code && code <= 7153 || 7212 <= code && code <= 7219 || 7222 <= code && code <= 7223 || 7376 <= code && code <= 7378 || 7380 <= code && code <= 7392 || 7394 <= code && code <= 7400 || 7405 == code || 7412 == code || 7416 <= code && code <= 7417 || 7616 <= code && code <= 7673 || 7675 <= code && code <= 7679 || 8204 == code || 8400 <= code && code <= 8412 || 8413 <= code && code <= 8416 || 8417 == code || 8418 <= code && code <= 8420 || 8421 <= code && code <= 8432 || 11503 <= code && code <= 11505 || 11647 == code || 11744 <= code && code <= 11775 || 12330 <= code && code <= 12333 || 12334 <= code && code <= 12335 || 12441 <= code && code <= 12442 || 42607 == code || 42608 <= code && code <= 42610 || 42612 <= code && code <= 42621 || 42654 <= code && code <= 42655 || 42736 <= code && code <= 42737 || 43010 == code || 43014 == code || 43019 == code || 43045 <= code && code <= 43046 || 43204 <= code && code <= 43205 || 43232 <= code && code <= 43249 || 43302 <= code && code <= 43309 || 43335 <= code && code <= 43345 || 43392 <= code && code <= 43394 || 43443 == code || 43446 <= code && code <= 43449 || 43452 == code || 43493 == code || 43561 <= code && code <= 43566 || 43569 <= code && code <= 43570 || 43573 <= code && code <= 43574 || 43587 == code || 43596 == code || 43644 == code || 43696 == code || 43698 <= code && code <= 43700 || 43703 <= code && code <= 43704 || 43710 <= code && code <= 43711 || 43713 == code || 43756 <= code && code <= 43757 || 43766 == code || 44005 == code || 44008 == code || 44013 == code || 64286 == code || 65024 <= code && code <= 65039 || 65056 <= code && code <= 65071 || 65438 <= code && code <= 65439 || 66045 == code || 66272 == code || 66422 <= code && code <= 66426 || 68097 <= code && code <= 68099 || 68101 <= code && code <= 68102 || 68108 <= code && code <= 68111 || 68152 <= code && code <= 68154 || 68159 == code || 68325 <= code && code <= 68326 || 69633 == code || 69688 <= code && code <= 69702 || 69759 <= code && code <= 69761 || 69811 <= code && code <= 69814 || 69817 <= code && code <= 69818 || 69888 <= code && code <= 69890 || 69927 <= code && code <= 69931 || 69933 <= code && code <= 69940 || 70003 == code || 70016 <= code && code <= 70017 || 70070 <= code && code <= 70078 || 70090 <= code && code <= 70092 || 70191 <= code && code <= 70193 || 70196 == code || 70198 <= code && code <= 70199 || 70206 == code || 70367 == code || 70371 <= code && code <= 70378 || 70400 <= code && code <= 70401 || 70460 == code || 70462 == code || 70464 == code || 70487 == code || 70502 <= code && code <= 70508 || 70512 <= code && code <= 70516 || 70712 <= code && code <= 70719 || 70722 <= code && code <= 70724 || 70726 == code || 70832 == code || 70835 <= code && code <= 70840 || 70842 == code || 70845 == code || 70847 <= code && code <= 70848 || 70850 <= code && code <= 70851 || 71087 == code || 71090 <= code && code <= 71093 || 71100 <= code && code <= 71101 || 71103 <= code && code <= 71104 || 71132 <= code && code <= 71133 || 71219 <= code && code <= 71226 || 71229 == code || 71231 <= code && code <= 71232 || 71339 == code || 71341 == code || 71344 <= code && code <= 71349 || 71351 == code || 71453 <= code && code <= 71455 || 71458 <= code && code <= 71461 || 71463 <= code && code <= 71467 || 72193 <= code && code <= 72198 || 72201 <= code && code <= 72202 || 72243 <= code && code <= 72248 || 72251 <= code && code <= 72254 || 72263 == code || 72273 <= code && code <= 72278 || 72281 <= code && code <= 72283 || 72330 <= code && code <= 72342 || 72344 <= code && code <= 72345 || 72752 <= code && code <= 72758 || 72760 <= code && code <= 72765 || 72767 == code || 72850 <= code && code <= 72871 || 72874 <= code && code <= 72880 || 72882 <= code && code <= 72883 || 72885 <= code && code <= 72886 || 73009 <= code && code <= 73014 || 73018 == code || 73020 <= code && code <= 73021 || 73023 <= code && code <= 73029 || 73031 == code || 92912 <= code && code <= 92916 || 92976 <= code && code <= 92982 || 94095 <= code && code <= 94098 || 113821 <= code && code <= 113822 || 119141 == code || 119143 <= code && code <= 119145 || 119150 <= code && code <= 119154 || 119163 <= code && code <= 119170 || 119173 <= code && code <= 119179 || 119210 <= code && code <= 119213 || 119362 <= code && code <= 119364 || 121344 <= code && code <= 121398 || 121403 <= code && code <= 121452 || 121461 == code || 121476 == code || 121499 <= code && code <= 121503 || 121505 <= code && code <= 121519 || 122880 <= code && code <= 122886 || 122888 <= code && code <= 122904 || 122907 <= code && code <= 122913 || 122915 <= code && code <= 122916 || 122918 <= code && code <= 122922 || 125136 <= code && code <= 125142 || 125252 <= code && code <= 125258 || 917536 <= code && code <= 917631 || 917760 <= code && code <= 917999) {
        return Extend;
      }
      if (127462 <= code && code <= 127487) {
        return Regional_Indicator;
      }
      if (2307 == code || 2363 == code || 2366 <= code && code <= 2368 || 2377 <= code && code <= 2380 || 2382 <= code && code <= 2383 || 2434 <= code && code <= 2435 || 2495 <= code && code <= 2496 || 2503 <= code && code <= 2504 || 2507 <= code && code <= 2508 || 2563 == code || 2622 <= code && code <= 2624 || 2691 == code || 2750 <= code && code <= 2752 || 2761 == code || 2763 <= code && code <= 2764 || 2818 <= code && code <= 2819 || 2880 == code || 2887 <= code && code <= 2888 || 2891 <= code && code <= 2892 || 3007 == code || 3009 <= code && code <= 3010 || 3014 <= code && code <= 3016 || 3018 <= code && code <= 3020 || 3073 <= code && code <= 3075 || 3137 <= code && code <= 3140 || 3202 <= code && code <= 3203 || 3262 == code || 3264 <= code && code <= 3265 || 3267 <= code && code <= 3268 || 3271 <= code && code <= 3272 || 3274 <= code && code <= 3275 || 3330 <= code && code <= 3331 || 3391 <= code && code <= 3392 || 3398 <= code && code <= 3400 || 3402 <= code && code <= 3404 || 3458 <= code && code <= 3459 || 3536 <= code && code <= 3537 || 3544 <= code && code <= 3550 || 3570 <= code && code <= 3571 || 3635 == code || 3763 == code || 3902 <= code && code <= 3903 || 3967 == code || 4145 == code || 4155 <= code && code <= 4156 || 4182 <= code && code <= 4183 || 4228 == code || 6070 == code || 6078 <= code && code <= 6085 || 6087 <= code && code <= 6088 || 6435 <= code && code <= 6438 || 6441 <= code && code <= 6443 || 6448 <= code && code <= 6449 || 6451 <= code && code <= 6456 || 6681 <= code && code <= 6682 || 6741 == code || 6743 == code || 6765 <= code && code <= 6770 || 6916 == code || 6965 == code || 6971 == code || 6973 <= code && code <= 6977 || 6979 <= code && code <= 6980 || 7042 == code || 7073 == code || 7078 <= code && code <= 7079 || 7082 == code || 7143 == code || 7146 <= code && code <= 7148 || 7150 == code || 7154 <= code && code <= 7155 || 7204 <= code && code <= 7211 || 7220 <= code && code <= 7221 || 7393 == code || 7410 <= code && code <= 7411 || 7415 == code || 43043 <= code && code <= 43044 || 43047 == code || 43136 <= code && code <= 43137 || 43188 <= code && code <= 43203 || 43346 <= code && code <= 43347 || 43395 == code || 43444 <= code && code <= 43445 || 43450 <= code && code <= 43451 || 43453 <= code && code <= 43456 || 43567 <= code && code <= 43568 || 43571 <= code && code <= 43572 || 43597 == code || 43755 == code || 43758 <= code && code <= 43759 || 43765 == code || 44003 <= code && code <= 44004 || 44006 <= code && code <= 44007 || 44009 <= code && code <= 44010 || 44012 == code || 69632 == code || 69634 == code || 69762 == code || 69808 <= code && code <= 69810 || 69815 <= code && code <= 69816 || 69932 == code || 70018 == code || 70067 <= code && code <= 70069 || 70079 <= code && code <= 70080 || 70188 <= code && code <= 70190 || 70194 <= code && code <= 70195 || 70197 == code || 70368 <= code && code <= 70370 || 70402 <= code && code <= 70403 || 70463 == code || 70465 <= code && code <= 70468 || 70471 <= code && code <= 70472 || 70475 <= code && code <= 70477 || 70498 <= code && code <= 70499 || 70709 <= code && code <= 70711 || 70720 <= code && code <= 70721 || 70725 == code || 70833 <= code && code <= 70834 || 70841 == code || 70843 <= code && code <= 70844 || 70846 == code || 70849 == code || 71088 <= code && code <= 71089 || 71096 <= code && code <= 71099 || 71102 == code || 71216 <= code && code <= 71218 || 71227 <= code && code <= 71228 || 71230 == code || 71340 == code || 71342 <= code && code <= 71343 || 71350 == code || 71456 <= code && code <= 71457 || 71462 == code || 72199 <= code && code <= 72200 || 72249 == code || 72279 <= code && code <= 72280 || 72343 == code || 72751 == code || 72766 == code || 72873 == code || 72881 == code || 72884 == code || 94033 <= code && code <= 94078 || 119142 == code || 119149 == code) {
        return SpacingMark;
      }
      if (4352 <= code && code <= 4447 || 43360 <= code && code <= 43388) {
        return L;
      }
      if (4448 <= code && code <= 4519 || 55216 <= code && code <= 55238) {
        return V;
      }
      if (4520 <= code && code <= 4607 || 55243 <= code && code <= 55291) {
        return T;
      }
      if (44032 == code || 44060 == code || 44088 == code || 44116 == code || 44144 == code || 44172 == code || 44200 == code || 44228 == code || 44256 == code || 44284 == code || 44312 == code || 44340 == code || 44368 == code || 44396 == code || 44424 == code || 44452 == code || 44480 == code || 44508 == code || 44536 == code || 44564 == code || 44592 == code || 44620 == code || 44648 == code || 44676 == code || 44704 == code || 44732 == code || 44760 == code || 44788 == code || 44816 == code || 44844 == code || 44872 == code || 44900 == code || 44928 == code || 44956 == code || 44984 == code || 45012 == code || 45040 == code || 45068 == code || 45096 == code || 45124 == code || 45152 == code || 45180 == code || 45208 == code || 45236 == code || 45264 == code || 45292 == code || 45320 == code || 45348 == code || 45376 == code || 45404 == code || 45432 == code || 45460 == code || 45488 == code || 45516 == code || 45544 == code || 45572 == code || 45600 == code || 45628 == code || 45656 == code || 45684 == code || 45712 == code || 45740 == code || 45768 == code || 45796 == code || 45824 == code || 45852 == code || 45880 == code || 45908 == code || 45936 == code || 45964 == code || 45992 == code || 46020 == code || 46048 == code || 46076 == code || 46104 == code || 46132 == code || 46160 == code || 46188 == code || 46216 == code || 46244 == code || 46272 == code || 46300 == code || 46328 == code || 46356 == code || 46384 == code || 46412 == code || 46440 == code || 46468 == code || 46496 == code || 46524 == code || 46552 == code || 46580 == code || 46608 == code || 46636 == code || 46664 == code || 46692 == code || 46720 == code || 46748 == code || 46776 == code || 46804 == code || 46832 == code || 46860 == code || 46888 == code || 46916 == code || 46944 == code || 46972 == code || 47e3 == code || 47028 == code || 47056 == code || 47084 == code || 47112 == code || 47140 == code || 47168 == code || 47196 == code || 47224 == code || 47252 == code || 47280 == code || 47308 == code || 47336 == code || 47364 == code || 47392 == code || 47420 == code || 47448 == code || 47476 == code || 47504 == code || 47532 == code || 47560 == code || 47588 == code || 47616 == code || 47644 == code || 47672 == code || 47700 == code || 47728 == code || 47756 == code || 47784 == code || 47812 == code || 47840 == code || 47868 == code || 47896 == code || 47924 == code || 47952 == code || 47980 == code || 48008 == code || 48036 == code || 48064 == code || 48092 == code || 48120 == code || 48148 == code || 48176 == code || 48204 == code || 48232 == code || 48260 == code || 48288 == code || 48316 == code || 48344 == code || 48372 == code || 48400 == code || 48428 == code || 48456 == code || 48484 == code || 48512 == code || 48540 == code || 48568 == code || 48596 == code || 48624 == code || 48652 == code || 48680 == code || 48708 == code || 48736 == code || 48764 == code || 48792 == code || 48820 == code || 48848 == code || 48876 == code || 48904 == code || 48932 == code || 48960 == code || 48988 == code || 49016 == code || 49044 == code || 49072 == code || 49100 == code || 49128 == code || 49156 == code || 49184 == code || 49212 == code || 49240 == code || 49268 == code || 49296 == code || 49324 == code || 49352 == code || 49380 == code || 49408 == code || 49436 == code || 49464 == code || 49492 == code || 49520 == code || 49548 == code || 49576 == code || 49604 == code || 49632 == code || 49660 == code || 49688 == code || 49716 == code || 49744 == code || 49772 == code || 49800 == code || 49828 == code || 49856 == code || 49884 == code || 49912 == code || 49940 == code || 49968 == code || 49996 == code || 50024 == code || 50052 == code || 50080 == code || 50108 == code || 50136 == code || 50164 == code || 50192 == code || 50220 == code || 50248 == code || 50276 == code || 50304 == code || 50332 == code || 50360 == code || 50388 == code || 50416 == code || 50444 == code || 50472 == code || 50500 == code || 50528 == code || 50556 == code || 50584 == code || 50612 == code || 50640 == code || 50668 == code || 50696 == code || 50724 == code || 50752 == code || 50780 == code || 50808 == code || 50836 == code || 50864 == code || 50892 == code || 50920 == code || 50948 == code || 50976 == code || 51004 == code || 51032 == code || 51060 == code || 51088 == code || 51116 == code || 51144 == code || 51172 == code || 51200 == code || 51228 == code || 51256 == code || 51284 == code || 51312 == code || 51340 == code || 51368 == code || 51396 == code || 51424 == code || 51452 == code || 51480 == code || 51508 == code || 51536 == code || 51564 == code || 51592 == code || 51620 == code || 51648 == code || 51676 == code || 51704 == code || 51732 == code || 51760 == code || 51788 == code || 51816 == code || 51844 == code || 51872 == code || 51900 == code || 51928 == code || 51956 == code || 51984 == code || 52012 == code || 52040 == code || 52068 == code || 52096 == code || 52124 == code || 52152 == code || 52180 == code || 52208 == code || 52236 == code || 52264 == code || 52292 == code || 52320 == code || 52348 == code || 52376 == code || 52404 == code || 52432 == code || 52460 == code || 52488 == code || 52516 == code || 52544 == code || 52572 == code || 52600 == code || 52628 == code || 52656 == code || 52684 == code || 52712 == code || 52740 == code || 52768 == code || 52796 == code || 52824 == code || 52852 == code || 52880 == code || 52908 == code || 52936 == code || 52964 == code || 52992 == code || 53020 == code || 53048 == code || 53076 == code || 53104 == code || 53132 == code || 53160 == code || 53188 == code || 53216 == code || 53244 == code || 53272 == code || 53300 == code || 53328 == code || 53356 == code || 53384 == code || 53412 == code || 53440 == code || 53468 == code || 53496 == code || 53524 == code || 53552 == code || 53580 == code || 53608 == code || 53636 == code || 53664 == code || 53692 == code || 53720 == code || 53748 == code || 53776 == code || 53804 == code || 53832 == code || 53860 == code || 53888 == code || 53916 == code || 53944 == code || 53972 == code || 54e3 == code || 54028 == code || 54056 == code || 54084 == code || 54112 == code || 54140 == code || 54168 == code || 54196 == code || 54224 == code || 54252 == code || 54280 == code || 54308 == code || 54336 == code || 54364 == code || 54392 == code || 54420 == code || 54448 == code || 54476 == code || 54504 == code || 54532 == code || 54560 == code || 54588 == code || 54616 == code || 54644 == code || 54672 == code || 54700 == code || 54728 == code || 54756 == code || 54784 == code || 54812 == code || 54840 == code || 54868 == code || 54896 == code || 54924 == code || 54952 == code || 54980 == code || 55008 == code || 55036 == code || 55064 == code || 55092 == code || 55120 == code || 55148 == code || 55176 == code) {
        return LV;
      }
      if (44033 <= code && code <= 44059 || 44061 <= code && code <= 44087 || 44089 <= code && code <= 44115 || 44117 <= code && code <= 44143 || 44145 <= code && code <= 44171 || 44173 <= code && code <= 44199 || 44201 <= code && code <= 44227 || 44229 <= code && code <= 44255 || 44257 <= code && code <= 44283 || 44285 <= code && code <= 44311 || 44313 <= code && code <= 44339 || 44341 <= code && code <= 44367 || 44369 <= code && code <= 44395 || 44397 <= code && code <= 44423 || 44425 <= code && code <= 44451 || 44453 <= code && code <= 44479 || 44481 <= code && code <= 44507 || 44509 <= code && code <= 44535 || 44537 <= code && code <= 44563 || 44565 <= code && code <= 44591 || 44593 <= code && code <= 44619 || 44621 <= code && code <= 44647 || 44649 <= code && code <= 44675 || 44677 <= code && code <= 44703 || 44705 <= code && code <= 44731 || 44733 <= code && code <= 44759 || 44761 <= code && code <= 44787 || 44789 <= code && code <= 44815 || 44817 <= code && code <= 44843 || 44845 <= code && code <= 44871 || 44873 <= code && code <= 44899 || 44901 <= code && code <= 44927 || 44929 <= code && code <= 44955 || 44957 <= code && code <= 44983 || 44985 <= code && code <= 45011 || 45013 <= code && code <= 45039 || 45041 <= code && code <= 45067 || 45069 <= code && code <= 45095 || 45097 <= code && code <= 45123 || 45125 <= code && code <= 45151 || 45153 <= code && code <= 45179 || 45181 <= code && code <= 45207 || 45209 <= code && code <= 45235 || 45237 <= code && code <= 45263 || 45265 <= code && code <= 45291 || 45293 <= code && code <= 45319 || 45321 <= code && code <= 45347 || 45349 <= code && code <= 45375 || 45377 <= code && code <= 45403 || 45405 <= code && code <= 45431 || 45433 <= code && code <= 45459 || 45461 <= code && code <= 45487 || 45489 <= code && code <= 45515 || 45517 <= code && code <= 45543 || 45545 <= code && code <= 45571 || 45573 <= code && code <= 45599 || 45601 <= code && code <= 45627 || 45629 <= code && code <= 45655 || 45657 <= code && code <= 45683 || 45685 <= code && code <= 45711 || 45713 <= code && code <= 45739 || 45741 <= code && code <= 45767 || 45769 <= code && code <= 45795 || 45797 <= code && code <= 45823 || 45825 <= code && code <= 45851 || 45853 <= code && code <= 45879 || 45881 <= code && code <= 45907 || 45909 <= code && code <= 45935 || 45937 <= code && code <= 45963 || 45965 <= code && code <= 45991 || 45993 <= code && code <= 46019 || 46021 <= code && code <= 46047 || 46049 <= code && code <= 46075 || 46077 <= code && code <= 46103 || 46105 <= code && code <= 46131 || 46133 <= code && code <= 46159 || 46161 <= code && code <= 46187 || 46189 <= code && code <= 46215 || 46217 <= code && code <= 46243 || 46245 <= code && code <= 46271 || 46273 <= code && code <= 46299 || 46301 <= code && code <= 46327 || 46329 <= code && code <= 46355 || 46357 <= code && code <= 46383 || 46385 <= code && code <= 46411 || 46413 <= code && code <= 46439 || 46441 <= code && code <= 46467 || 46469 <= code && code <= 46495 || 46497 <= code && code <= 46523 || 46525 <= code && code <= 46551 || 46553 <= code && code <= 46579 || 46581 <= code && code <= 46607 || 46609 <= code && code <= 46635 || 46637 <= code && code <= 46663 || 46665 <= code && code <= 46691 || 46693 <= code && code <= 46719 || 46721 <= code && code <= 46747 || 46749 <= code && code <= 46775 || 46777 <= code && code <= 46803 || 46805 <= code && code <= 46831 || 46833 <= code && code <= 46859 || 46861 <= code && code <= 46887 || 46889 <= code && code <= 46915 || 46917 <= code && code <= 46943 || 46945 <= code && code <= 46971 || 46973 <= code && code <= 46999 || 47001 <= code && code <= 47027 || 47029 <= code && code <= 47055 || 47057 <= code && code <= 47083 || 47085 <= code && code <= 47111 || 47113 <= code && code <= 47139 || 47141 <= code && code <= 47167 || 47169 <= code && code <= 47195 || 47197 <= code && code <= 47223 || 47225 <= code && code <= 47251 || 47253 <= code && code <= 47279 || 47281 <= code && code <= 47307 || 47309 <= code && code <= 47335 || 47337 <= code && code <= 47363 || 47365 <= code && code <= 47391 || 47393 <= code && code <= 47419 || 47421 <= code && code <= 47447 || 47449 <= code && code <= 47475 || 47477 <= code && code <= 47503 || 47505 <= code && code <= 47531 || 47533 <= code && code <= 47559 || 47561 <= code && code <= 47587 || 47589 <= code && code <= 47615 || 47617 <= code && code <= 47643 || 47645 <= code && code <= 47671 || 47673 <= code && code <= 47699 || 47701 <= code && code <= 47727 || 47729 <= code && code <= 47755 || 47757 <= code && code <= 47783 || 47785 <= code && code <= 47811 || 47813 <= code && code <= 47839 || 47841 <= code && code <= 47867 || 47869 <= code && code <= 47895 || 47897 <= code && code <= 47923 || 47925 <= code && code <= 47951 || 47953 <= code && code <= 47979 || 47981 <= code && code <= 48007 || 48009 <= code && code <= 48035 || 48037 <= code && code <= 48063 || 48065 <= code && code <= 48091 || 48093 <= code && code <= 48119 || 48121 <= code && code <= 48147 || 48149 <= code && code <= 48175 || 48177 <= code && code <= 48203 || 48205 <= code && code <= 48231 || 48233 <= code && code <= 48259 || 48261 <= code && code <= 48287 || 48289 <= code && code <= 48315 || 48317 <= code && code <= 48343 || 48345 <= code && code <= 48371 || 48373 <= code && code <= 48399 || 48401 <= code && code <= 48427 || 48429 <= code && code <= 48455 || 48457 <= code && code <= 48483 || 48485 <= code && code <= 48511 || 48513 <= code && code <= 48539 || 48541 <= code && code <= 48567 || 48569 <= code && code <= 48595 || 48597 <= code && code <= 48623 || 48625 <= code && code <= 48651 || 48653 <= code && code <= 48679 || 48681 <= code && code <= 48707 || 48709 <= code && code <= 48735 || 48737 <= code && code <= 48763 || 48765 <= code && code <= 48791 || 48793 <= code && code <= 48819 || 48821 <= code && code <= 48847 || 48849 <= code && code <= 48875 || 48877 <= code && code <= 48903 || 48905 <= code && code <= 48931 || 48933 <= code && code <= 48959 || 48961 <= code && code <= 48987 || 48989 <= code && code <= 49015 || 49017 <= code && code <= 49043 || 49045 <= code && code <= 49071 || 49073 <= code && code <= 49099 || 49101 <= code && code <= 49127 || 49129 <= code && code <= 49155 || 49157 <= code && code <= 49183 || 49185 <= code && code <= 49211 || 49213 <= code && code <= 49239 || 49241 <= code && code <= 49267 || 49269 <= code && code <= 49295 || 49297 <= code && code <= 49323 || 49325 <= code && code <= 49351 || 49353 <= code && code <= 49379 || 49381 <= code && code <= 49407 || 49409 <= code && code <= 49435 || 49437 <= code && code <= 49463 || 49465 <= code && code <= 49491 || 49493 <= code && code <= 49519 || 49521 <= code && code <= 49547 || 49549 <= code && code <= 49575 || 49577 <= code && code <= 49603 || 49605 <= code && code <= 49631 || 49633 <= code && code <= 49659 || 49661 <= code && code <= 49687 || 49689 <= code && code <= 49715 || 49717 <= code && code <= 49743 || 49745 <= code && code <= 49771 || 49773 <= code && code <= 49799 || 49801 <= code && code <= 49827 || 49829 <= code && code <= 49855 || 49857 <= code && code <= 49883 || 49885 <= code && code <= 49911 || 49913 <= code && code <= 49939 || 49941 <= code && code <= 49967 || 49969 <= code && code <= 49995 || 49997 <= code && code <= 50023 || 50025 <= code && code <= 50051 || 50053 <= code && code <= 50079 || 50081 <= code && code <= 50107 || 50109 <= code && code <= 50135 || 50137 <= code && code <= 50163 || 50165 <= code && code <= 50191 || 50193 <= code && code <= 50219 || 50221 <= code && code <= 50247 || 50249 <= code && code <= 50275 || 50277 <= code && code <= 50303 || 50305 <= code && code <= 50331 || 50333 <= code && code <= 50359 || 50361 <= code && code <= 50387 || 50389 <= code && code <= 50415 || 50417 <= code && code <= 50443 || 50445 <= code && code <= 50471 || 50473 <= code && code <= 50499 || 50501 <= code && code <= 50527 || 50529 <= code && code <= 50555 || 50557 <= code && code <= 50583 || 50585 <= code && code <= 50611 || 50613 <= code && code <= 50639 || 50641 <= code && code <= 50667 || 50669 <= code && code <= 50695 || 50697 <= code && code <= 50723 || 50725 <= code && code <= 50751 || 50753 <= code && code <= 50779 || 50781 <= code && code <= 50807 || 50809 <= code && code <= 50835 || 50837 <= code && code <= 50863 || 50865 <= code && code <= 50891 || 50893 <= code && code <= 50919 || 50921 <= code && code <= 50947 || 50949 <= code && code <= 50975 || 50977 <= code && code <= 51003 || 51005 <= code && code <= 51031 || 51033 <= code && code <= 51059 || 51061 <= code && code <= 51087 || 51089 <= code && code <= 51115 || 51117 <= code && code <= 51143 || 51145 <= code && code <= 51171 || 51173 <= code && code <= 51199 || 51201 <= code && code <= 51227 || 51229 <= code && code <= 51255 || 51257 <= code && code <= 51283 || 51285 <= code && code <= 51311 || 51313 <= code && code <= 51339 || 51341 <= code && code <= 51367 || 51369 <= code && code <= 51395 || 51397 <= code && code <= 51423 || 51425 <= code && code <= 51451 || 51453 <= code && code <= 51479 || 51481 <= code && code <= 51507 || 51509 <= code && code <= 51535 || 51537 <= code && code <= 51563 || 51565 <= code && code <= 51591 || 51593 <= code && code <= 51619 || 51621 <= code && code <= 51647 || 51649 <= code && code <= 51675 || 51677 <= code && code <= 51703 || 51705 <= code && code <= 51731 || 51733 <= code && code <= 51759 || 51761 <= code && code <= 51787 || 51789 <= code && code <= 51815 || 51817 <= code && code <= 51843 || 51845 <= code && code <= 51871 || 51873 <= code && code <= 51899 || 51901 <= code && code <= 51927 || 51929 <= code && code <= 51955 || 51957 <= code && code <= 51983 || 51985 <= code && code <= 52011 || 52013 <= code && code <= 52039 || 52041 <= code && code <= 52067 || 52069 <= code && code <= 52095 || 52097 <= code && code <= 52123 || 52125 <= code && code <= 52151 || 52153 <= code && code <= 52179 || 52181 <= code && code <= 52207 || 52209 <= code && code <= 52235 || 52237 <= code && code <= 52263 || 52265 <= code && code <= 52291 || 52293 <= code && code <= 52319 || 52321 <= code && code <= 52347 || 52349 <= code && code <= 52375 || 52377 <= code && code <= 52403 || 52405 <= code && code <= 52431 || 52433 <= code && code <= 52459 || 52461 <= code && code <= 52487 || 52489 <= code && code <= 52515 || 52517 <= code && code <= 52543 || 52545 <= code && code <= 52571 || 52573 <= code && code <= 52599 || 52601 <= code && code <= 52627 || 52629 <= code && code <= 52655 || 52657 <= code && code <= 52683 || 52685 <= code && code <= 52711 || 52713 <= code && code <= 52739 || 52741 <= code && code <= 52767 || 52769 <= code && code <= 52795 || 52797 <= code && code <= 52823 || 52825 <= code && code <= 52851 || 52853 <= code && code <= 52879 || 52881 <= code && code <= 52907 || 52909 <= code && code <= 52935 || 52937 <= code && code <= 52963 || 52965 <= code && code <= 52991 || 52993 <= code && code <= 53019 || 53021 <= code && code <= 53047 || 53049 <= code && code <= 53075 || 53077 <= code && code <= 53103 || 53105 <= code && code <= 53131 || 53133 <= code && code <= 53159 || 53161 <= code && code <= 53187 || 53189 <= code && code <= 53215 || 53217 <= code && code <= 53243 || 53245 <= code && code <= 53271 || 53273 <= code && code <= 53299 || 53301 <= code && code <= 53327 || 53329 <= code && code <= 53355 || 53357 <= code && code <= 53383 || 53385 <= code && code <= 53411 || 53413 <= code && code <= 53439 || 53441 <= code && code <= 53467 || 53469 <= code && code <= 53495 || 53497 <= code && code <= 53523 || 53525 <= code && code <= 53551 || 53553 <= code && code <= 53579 || 53581 <= code && code <= 53607 || 53609 <= code && code <= 53635 || 53637 <= code && code <= 53663 || 53665 <= code && code <= 53691 || 53693 <= code && code <= 53719 || 53721 <= code && code <= 53747 || 53749 <= code && code <= 53775 || 53777 <= code && code <= 53803 || 53805 <= code && code <= 53831 || 53833 <= code && code <= 53859 || 53861 <= code && code <= 53887 || 53889 <= code && code <= 53915 || 53917 <= code && code <= 53943 || 53945 <= code && code <= 53971 || 53973 <= code && code <= 53999 || 54001 <= code && code <= 54027 || 54029 <= code && code <= 54055 || 54057 <= code && code <= 54083 || 54085 <= code && code <= 54111 || 54113 <= code && code <= 54139 || 54141 <= code && code <= 54167 || 54169 <= code && code <= 54195 || 54197 <= code && code <= 54223 || 54225 <= code && code <= 54251 || 54253 <= code && code <= 54279 || 54281 <= code && code <= 54307 || 54309 <= code && code <= 54335 || 54337 <= code && code <= 54363 || 54365 <= code && code <= 54391 || 54393 <= code && code <= 54419 || 54421 <= code && code <= 54447 || 54449 <= code && code <= 54475 || 54477 <= code && code <= 54503 || 54505 <= code && code <= 54531 || 54533 <= code && code <= 54559 || 54561 <= code && code <= 54587 || 54589 <= code && code <= 54615 || 54617 <= code && code <= 54643 || 54645 <= code && code <= 54671 || 54673 <= code && code <= 54699 || 54701 <= code && code <= 54727 || 54729 <= code && code <= 54755 || 54757 <= code && code <= 54783 || 54785 <= code && code <= 54811 || 54813 <= code && code <= 54839 || 54841 <= code && code <= 54867 || 54869 <= code && code <= 54895 || 54897 <= code && code <= 54923 || 54925 <= code && code <= 54951 || 54953 <= code && code <= 54979 || 54981 <= code && code <= 55007 || 55009 <= code && code <= 55035 || 55037 <= code && code <= 55063 || 55065 <= code && code <= 55091 || 55093 <= code && code <= 55119 || 55121 <= code && code <= 55147 || 55149 <= code && code <= 55175 || 55177 <= code && code <= 55203) {
        return LVT;
      }
      if (9757 == code || 9977 == code || 9994 <= code && code <= 9997 || 127877 == code || 127938 <= code && code <= 127940 || 127943 == code || 127946 <= code && code <= 127948 || 128066 <= code && code <= 128067 || 128070 <= code && code <= 128080 || 128110 == code || 128112 <= code && code <= 128120 || 128124 == code || 128129 <= code && code <= 128131 || 128133 <= code && code <= 128135 || 128170 == code || 128372 <= code && code <= 128373 || 128378 == code || 128400 == code || 128405 <= code && code <= 128406 || 128581 <= code && code <= 128583 || 128587 <= code && code <= 128591 || 128675 == code || 128692 <= code && code <= 128694 || 128704 == code || 128716 == code || 129304 <= code && code <= 129308 || 129310 <= code && code <= 129311 || 129318 == code || 129328 <= code && code <= 129337 || 129341 <= code && code <= 129342 || 129489 <= code && code <= 129501) {
        return E_Base;
      }
      if (127995 <= code && code <= 127999) {
        return E_Modifier;
      }
      if (8205 == code) {
        return ZWJ;
      }
      if (9792 == code || 9794 == code || 9877 <= code && code <= 9878 || 9992 == code || 10084 == code || 127752 == code || 127806 == code || 127859 == code || 127891 == code || 127908 == code || 127912 == code || 127979 == code || 127981 == code || 128139 == code || 128187 <= code && code <= 128188 || 128295 == code || 128300 == code || 128488 == code || 128640 == code || 128658 == code) {
        return Glue_After_Zwj;
      }
      if (128102 <= code && code <= 128105) {
        return E_Base_GAZ;
      }
      return Other;
    }
    return this;
  }
  if (module2.exports) {
    module2.exports = GraphemeSplitter;
  }
});

// node_modules/cesium/Source/Scene/LabelCollection.js
function Glyph() {
  this.textureInfo = void 0;
  this.dimensions = void 0;
  this.billboard = void 0;
}
function GlyphTextureInfo(labelCollection, index2, dimensions) {
  this.labelCollection = labelCollection;
  this.index = index2;
  this.dimensions = dimensions;
}
var defaultLineSpacingPercent = 1.2;
var whitePixelCanvasId = "ID_WHITE_PIXEL";
var whitePixelSize = new Cartesian2_default(4, 4);
var whitePixelBoundingRegion = new BoundingRectangle_default(1, 1, 1, 1);
function addWhitePixelCanvas(textureAtlas, labelCollection) {
  const canvas = document.createElement("canvas");
  canvas.width = whitePixelSize.x;
  canvas.height = whitePixelSize.y;
  const context2D = canvas.getContext("2d");
  context2D.fillStyle = "#fff";
  context2D.fillRect(0, 0, canvas.width, canvas.height);
  const index2 = textureAtlas.addImageSync(whitePixelCanvasId, canvas);
  labelCollection._whitePixelIndex = index2;
}
var writeTextToCanvasParameters = {};
function createGlyphCanvas(character, font, fillColor, outlineColor, outlineWidth, style, verticalOrigin) {
  writeTextToCanvasParameters.font = font;
  writeTextToCanvasParameters.fillColor = fillColor;
  writeTextToCanvasParameters.strokeColor = outlineColor;
  writeTextToCanvasParameters.strokeWidth = outlineWidth;
  writeTextToCanvasParameters.padding = SDFSettings_default.PADDING;
  if (verticalOrigin === VerticalOrigin_default.CENTER) {
    writeTextToCanvasParameters.textBaseline = "middle";
  } else if (verticalOrigin === VerticalOrigin_default.TOP) {
    writeTextToCanvasParameters.textBaseline = "top";
  } else {
    writeTextToCanvasParameters.textBaseline = "bottom";
  }
  writeTextToCanvasParameters.fill = style === LabelStyle_default.FILL || style === LabelStyle_default.FILL_AND_OUTLINE;
  writeTextToCanvasParameters.stroke = style === LabelStyle_default.OUTLINE || style === LabelStyle_default.FILL_AND_OUTLINE;
  writeTextToCanvasParameters.backgroundColor = Color_default.BLACK;
  return writeTextToCanvas_default(character, writeTextToCanvasParameters);
}
function unbindGlyph(labelCollection, glyph) {
  glyph.textureInfo = void 0;
  glyph.dimensions = void 0;
  const billboard = glyph.billboard;
  if (defined_default(billboard)) {
    billboard.show = false;
    billboard.image = void 0;
    if (defined_default(billboard._removeCallbackFunc)) {
      billboard._removeCallbackFunc();
      billboard._removeCallbackFunc = void 0;
    }
    labelCollection._spareBillboards.push(billboard);
    glyph.billboard = void 0;
  }
}
function addGlyphToTextureAtlas(textureAtlas, id, canvas, glyphTextureInfo) {
  glyphTextureInfo.index = textureAtlas.addImageSync(id, canvas);
}
var splitter = new graphemeSplitter();
function rebindAllGlyphs2(labelCollection, label) {
  const text2 = label._renderedText;
  const graphemes = splitter.splitGraphemes(text2);
  const textLength = graphemes.length;
  const glyphs = label._glyphs;
  const glyphsLength = glyphs.length;
  let glyph;
  let glyphIndex;
  let textIndex;
  label._relativeSize = label._fontSize / SDFSettings_default.FONT_SIZE;
  if (textLength < glyphsLength) {
    for (glyphIndex = textLength; glyphIndex < glyphsLength; ++glyphIndex) {
      unbindGlyph(labelCollection, glyphs[glyphIndex]);
    }
  }
  glyphs.length = textLength;
  const showBackground = label._showBackground && text2.split("\n").join("").length > 0;
  let backgroundBillboard = label._backgroundBillboard;
  const backgroundBillboardCollection = labelCollection._backgroundBillboardCollection;
  if (!showBackground) {
    if (defined_default(backgroundBillboard)) {
      backgroundBillboardCollection.remove(backgroundBillboard);
      label._backgroundBillboard = backgroundBillboard = void 0;
    }
  } else {
    if (!defined_default(backgroundBillboard)) {
      backgroundBillboard = backgroundBillboardCollection.add({
        collection: labelCollection,
        image: whitePixelCanvasId,
        imageSubRegion: whitePixelBoundingRegion
      });
      label._backgroundBillboard = backgroundBillboard;
    }
    backgroundBillboard.color = label._backgroundColor;
    backgroundBillboard.show = label._show;
    backgroundBillboard.position = label._position;
    backgroundBillboard.eyeOffset = label._eyeOffset;
    backgroundBillboard.pixelOffset = label._pixelOffset;
    backgroundBillboard.horizontalOrigin = HorizontalOrigin_default.LEFT;
    backgroundBillboard.verticalOrigin = label._verticalOrigin;
    backgroundBillboard.heightReference = label._heightReference;
    backgroundBillboard.scale = label.totalScale;
    backgroundBillboard.pickPrimitive = label;
    backgroundBillboard.id = label._id;
    backgroundBillboard.translucencyByDistance = label._translucencyByDistance;
    backgroundBillboard.pixelOffsetScaleByDistance = label._pixelOffsetScaleByDistance;
    backgroundBillboard.scaleByDistance = label._scaleByDistance;
    backgroundBillboard.distanceDisplayCondition = label._distanceDisplayCondition;
    backgroundBillboard.disableDepthTestDistance = label._disableDepthTestDistance;
  }
  const glyphTextureCache = labelCollection._glyphTextureCache;
  for (textIndex = 0; textIndex < textLength; ++textIndex) {
    const character = graphemes[textIndex];
    const verticalOrigin = label._verticalOrigin;
    const id = JSON.stringify([
      character,
      label._fontFamily,
      label._fontStyle,
      label._fontWeight,
      +verticalOrigin
    ]);
    let glyphTextureInfo = glyphTextureCache[id];
    if (!defined_default(glyphTextureInfo)) {
      const glyphFont = `${label._fontStyle} ${label._fontWeight} ${SDFSettings_default.FONT_SIZE}px ${label._fontFamily}`;
      const canvas = createGlyphCanvas(
        character,
        glyphFont,
        Color_default.WHITE,
        Color_default.WHITE,
        0,
        LabelStyle_default.FILL,
        verticalOrigin
      );
      glyphTextureInfo = new GlyphTextureInfo(
        labelCollection,
        -1,
        canvas.dimensions
      );
      glyphTextureCache[id] = glyphTextureInfo;
      if (canvas.width > 0 && canvas.height > 0) {
        const sdfValues = bitmapSdf(canvas, {
          cutoff: SDFSettings_default.CUTOFF,
          radius: SDFSettings_default.RADIUS
        });
        const ctx = canvas.getContext("2d");
        const canvasWidth = canvas.width;
        const canvasHeight = canvas.height;
        const imgData = ctx.getImageData(0, 0, canvasWidth, canvasHeight);
        for (let i2 = 0; i2 < canvasWidth; i2++) {
          for (let j = 0; j < canvasHeight; j++) {
            const baseIndex = j * canvasWidth + i2;
            const alpha = sdfValues[baseIndex] * 255;
            const imageIndex = baseIndex * 4;
            imgData.data[imageIndex + 0] = alpha;
            imgData.data[imageIndex + 1] = alpha;
            imgData.data[imageIndex + 2] = alpha;
            imgData.data[imageIndex + 3] = alpha;
          }
        }
        ctx.putImageData(imgData, 0, 0);
        if (character !== " ") {
          addGlyphToTextureAtlas(
            labelCollection._textureAtlas,
            id,
            canvas,
            glyphTextureInfo
          );
        }
      }
    }
    glyph = glyphs[textIndex];
    if (defined_default(glyph)) {
      if (glyphTextureInfo.index === -1) {
        unbindGlyph(labelCollection, glyph);
      } else if (defined_default(glyph.textureInfo)) {
        glyph.textureInfo = void 0;
      }
    } else {
      glyph = new Glyph();
      glyphs[textIndex] = glyph;
    }
    glyph.textureInfo = glyphTextureInfo;
    glyph.dimensions = glyphTextureInfo.dimensions;
    if (glyphTextureInfo.index !== -1) {
      let billboard = glyph.billboard;
      const spareBillboards = labelCollection._spareBillboards;
      if (!defined_default(billboard)) {
        if (spareBillboards.length > 0) {
          billboard = spareBillboards.pop();
        } else {
          billboard = labelCollection._billboardCollection.add({
            collection: labelCollection
          });
          billboard._labelDimensions = new Cartesian2_default();
          billboard._labelTranslate = new Cartesian2_default();
        }
        glyph.billboard = billboard;
      }
      billboard.show = label._show;
      billboard.position = label._position;
      billboard.eyeOffset = label._eyeOffset;
      billboard.pixelOffset = label._pixelOffset;
      billboard.horizontalOrigin = HorizontalOrigin_default.LEFT;
      billboard.verticalOrigin = label._verticalOrigin;
      billboard.heightReference = label._heightReference;
      billboard.scale = label.totalScale;
      billboard.pickPrimitive = label;
      billboard.id = label._id;
      billboard.image = id;
      billboard.translucencyByDistance = label._translucencyByDistance;
      billboard.pixelOffsetScaleByDistance = label._pixelOffsetScaleByDistance;
      billboard.scaleByDistance = label._scaleByDistance;
      billboard.distanceDisplayCondition = label._distanceDisplayCondition;
      billboard.disableDepthTestDistance = label._disableDepthTestDistance;
      billboard._batchIndex = label._batchIndex;
      billboard.outlineColor = label.outlineColor;
      if (label.style === LabelStyle_default.FILL_AND_OUTLINE) {
        billboard.color = label._fillColor;
        billboard.outlineWidth = label.outlineWidth;
      } else if (label.style === LabelStyle_default.FILL) {
        billboard.color = label._fillColor;
        billboard.outlineWidth = 0;
      } else if (label.style === LabelStyle_default.OUTLINE) {
        billboard.color = Color_default.TRANSPARENT;
        billboard.outlineWidth = label.outlineWidth;
      }
    }
  }
  label._repositionAllGlyphs = true;
}
function calculateWidthOffset(lineWidth, horizontalOrigin, backgroundPadding) {
  if (horizontalOrigin === HorizontalOrigin_default.CENTER) {
    return -lineWidth / 2;
  } else if (horizontalOrigin === HorizontalOrigin_default.RIGHT) {
    return -(lineWidth + backgroundPadding.x);
  }
  return backgroundPadding.x;
}
var glyphPixelOffset = new Cartesian2_default();
var scratchBackgroundPadding = new Cartesian2_default();
function repositionAllGlyphs2(label) {
  const glyphs = label._glyphs;
  const text2 = label._renderedText;
  let glyph;
  let dimensions;
  let lastLineWidth = 0;
  let maxLineWidth = 0;
  const lineWidths = [];
  let maxGlyphDescent = Number.NEGATIVE_INFINITY;
  let maxGlyphY = 0;
  let numberOfLines = 1;
  let glyphIndex;
  const glyphLength = glyphs.length;
  const backgroundBillboard = label._backgroundBillboard;
  const backgroundPadding = Cartesian2_default.clone(
    defined_default(backgroundBillboard) ? label._backgroundPadding : Cartesian2_default.ZERO,
    scratchBackgroundPadding
  );
  backgroundPadding.x /= label._relativeSize;
  backgroundPadding.y /= label._relativeSize;
  for (glyphIndex = 0; glyphIndex < glyphLength; ++glyphIndex) {
    if (text2.charAt(glyphIndex) === "\n") {
      lineWidths.push(lastLineWidth);
      ++numberOfLines;
      lastLineWidth = 0;
    } else {
      glyph = glyphs[glyphIndex];
      dimensions = glyph.dimensions;
      maxGlyphY = Math.max(maxGlyphY, dimensions.height - dimensions.descent);
      maxGlyphDescent = Math.max(maxGlyphDescent, dimensions.descent);
      lastLineWidth += dimensions.width - dimensions.minx;
      if (glyphIndex < glyphLength - 1) {
        lastLineWidth += glyphs[glyphIndex + 1].dimensions.minx;
      }
      maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
    }
  }
  lineWidths.push(lastLineWidth);
  const maxLineHeight = maxGlyphY + maxGlyphDescent;
  const scale = label.totalScale;
  const horizontalOrigin = label._horizontalOrigin;
  const verticalOrigin = label._verticalOrigin;
  let lineIndex = 0;
  let lineWidth = lineWidths[lineIndex];
  let widthOffset = calculateWidthOffset(
    lineWidth,
    horizontalOrigin,
    backgroundPadding
  );
  const lineSpacing = (defined_default(label._lineHeight) ? label._lineHeight : defaultLineSpacingPercent * label._fontSize) / label._relativeSize;
  const otherLinesHeight = lineSpacing * (numberOfLines - 1);
  let totalLineWidth = maxLineWidth;
  let totalLineHeight = maxLineHeight + otherLinesHeight;
  if (defined_default(backgroundBillboard)) {
    totalLineWidth += backgroundPadding.x * 2;
    totalLineHeight += backgroundPadding.y * 2;
    backgroundBillboard._labelHorizontalOrigin = horizontalOrigin;
  }
  glyphPixelOffset.x = widthOffset * scale;
  glyphPixelOffset.y = 0;
  let firstCharOfLine = true;
  let lineOffsetY = 0;
  for (glyphIndex = 0; glyphIndex < glyphLength; ++glyphIndex) {
    if (text2.charAt(glyphIndex) === "\n") {
      ++lineIndex;
      lineOffsetY += lineSpacing;
      lineWidth = lineWidths[lineIndex];
      widthOffset = calculateWidthOffset(
        lineWidth,
        horizontalOrigin,
        backgroundPadding
      );
      glyphPixelOffset.x = widthOffset * scale;
      firstCharOfLine = true;
    } else {
      glyph = glyphs[glyphIndex];
      dimensions = glyph.dimensions;
      if (verticalOrigin === VerticalOrigin_default.TOP) {
        glyphPixelOffset.y = dimensions.height - maxGlyphY - backgroundPadding.y;
        glyphPixelOffset.y += SDFSettings_default.PADDING;
      } else if (verticalOrigin === VerticalOrigin_default.CENTER) {
        glyphPixelOffset.y = (otherLinesHeight + dimensions.height - maxGlyphY) / 2;
      } else if (verticalOrigin === VerticalOrigin_default.BASELINE) {
        glyphPixelOffset.y = otherLinesHeight;
        glyphPixelOffset.y -= SDFSettings_default.PADDING;
      } else {
        glyphPixelOffset.y = otherLinesHeight + maxGlyphDescent + backgroundPadding.y;
        glyphPixelOffset.y -= SDFSettings_default.PADDING;
      }
      glyphPixelOffset.y = (glyphPixelOffset.y - dimensions.descent - lineOffsetY) * scale;
      if (firstCharOfLine) {
        glyphPixelOffset.x -= SDFSettings_default.PADDING * scale;
        firstCharOfLine = false;
      }
      if (defined_default(glyph.billboard)) {
        glyph.billboard._setTranslate(glyphPixelOffset);
        glyph.billboard._labelDimensions.x = totalLineWidth;
        glyph.billboard._labelDimensions.y = totalLineHeight;
        glyph.billboard._labelHorizontalOrigin = horizontalOrigin;
      }
      if (glyphIndex < glyphLength - 1) {
        const nextGlyph = glyphs[glyphIndex + 1];
        glyphPixelOffset.x += (dimensions.width - dimensions.minx + nextGlyph.dimensions.minx) * scale;
      }
    }
  }
  if (defined_default(backgroundBillboard) && text2.split("\n").join("").length > 0) {
    if (horizontalOrigin === HorizontalOrigin_default.CENTER) {
      widthOffset = -maxLineWidth / 2 - backgroundPadding.x;
    } else if (horizontalOrigin === HorizontalOrigin_default.RIGHT) {
      widthOffset = -(maxLineWidth + backgroundPadding.x * 2);
    } else {
      widthOffset = 0;
    }
    glyphPixelOffset.x = widthOffset * scale;
    if (verticalOrigin === VerticalOrigin_default.TOP) {
      glyphPixelOffset.y = maxLineHeight - maxGlyphY - maxGlyphDescent;
    } else if (verticalOrigin === VerticalOrigin_default.CENTER) {
      glyphPixelOffset.y = (maxLineHeight - maxGlyphY) / 2 - maxGlyphDescent;
    } else if (verticalOrigin === VerticalOrigin_default.BASELINE) {
      glyphPixelOffset.y = -backgroundPadding.y - maxGlyphDescent;
    } else {
      glyphPixelOffset.y = 0;
    }
    glyphPixelOffset.y = glyphPixelOffset.y * scale;
    backgroundBillboard.width = totalLineWidth;
    backgroundBillboard.height = totalLineHeight;
    backgroundBillboard._setTranslate(glyphPixelOffset);
    backgroundBillboard._labelTranslate = Cartesian2_default.clone(
      glyphPixelOffset,
      backgroundBillboard._labelTranslate
    );
  }
  if (label.heightReference === HeightReference_default.CLAMP_TO_GROUND) {
    for (glyphIndex = 0; glyphIndex < glyphLength; ++glyphIndex) {
      glyph = glyphs[glyphIndex];
      const billboard = glyph.billboard;
      if (defined_default(billboard)) {
        billboard._labelTranslate = Cartesian2_default.clone(
          glyphPixelOffset,
          billboard._labelTranslate
        );
      }
    }
  }
}
function destroyLabel(labelCollection, label) {
  const glyphs = label._glyphs;
  for (let i2 = 0, len = glyphs.length; i2 < len; ++i2) {
    unbindGlyph(labelCollection, glyphs[i2]);
  }
  if (defined_default(label._backgroundBillboard)) {
    labelCollection._backgroundBillboardCollection.remove(
      label._backgroundBillboard
    );
    label._backgroundBillboard = void 0;
  }
  label._labelCollection = void 0;
  if (defined_default(label._removeCallbackFunc)) {
    label._removeCallbackFunc();
  }
  destroyObject_default(label);
}
function LabelCollection(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._scene = options.scene;
  this._batchTable = options.batchTable;
  this._textureAtlas = void 0;
  this._backgroundTextureAtlas = void 0;
  this._whitePixelIndex = void 0;
  this._backgroundBillboardCollection = new BillboardCollection_default({
    scene: this._scene
  });
  this._backgroundBillboardCollection.destroyTextureAtlas = false;
  this._billboardCollection = new BillboardCollection_default({
    scene: this._scene,
    batchTable: this._batchTable
  });
  this._billboardCollection.destroyTextureAtlas = false;
  this._billboardCollection._sdf = true;
  this._spareBillboards = [];
  this._glyphTextureCache = {};
  this._labels = [];
  this._labelsToUpdate = [];
  this._totalGlyphCount = 0;
  this._highlightColor = Color_default.clone(Color_default.WHITE);
  this.show = defaultValue_default(options.show, true);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this.blendOption = defaultValue_default(
    options.blendOption,
    BlendOption_default.OPAQUE_AND_TRANSLUCENT
  );
}
Object.defineProperties(LabelCollection.prototype, {
  length: {
    get: function() {
      return this._labels.length;
    }
  }
});
LabelCollection.prototype.add = function(options) {
  const label = new Label_default(options, this);
  this._labels.push(label);
  this._labelsToUpdate.push(label);
  return label;
};
LabelCollection.prototype.remove = function(label) {
  if (defined_default(label) && label._labelCollection === this) {
    const index2 = this._labels.indexOf(label);
    if (index2 !== -1) {
      this._labels.splice(index2, 1);
      destroyLabel(this, label);
      return true;
    }
  }
  return false;
};
LabelCollection.prototype.removeAll = function() {
  const labels = this._labels;
  for (let i2 = 0, len = labels.length; i2 < len; ++i2) {
    destroyLabel(this, labels[i2]);
  }
  labels.length = 0;
};
LabelCollection.prototype.contains = function(label) {
  return defined_default(label) && label._labelCollection === this;
};
LabelCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.");
  }
  return this._labels[index2];
};
LabelCollection.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  const billboardCollection = this._billboardCollection;
  const backgroundBillboardCollection = this._backgroundBillboardCollection;
  billboardCollection.modelMatrix = this.modelMatrix;
  billboardCollection.debugShowBoundingVolume = this.debugShowBoundingVolume;
  backgroundBillboardCollection.modelMatrix = this.modelMatrix;
  backgroundBillboardCollection.debugShowBoundingVolume = this.debugShowBoundingVolume;
  const context = frameState.context;
  if (!defined_default(this._textureAtlas)) {
    this._textureAtlas = new TextureAtlas_default({
      context
    });
    billboardCollection.textureAtlas = this._textureAtlas;
  }
  if (!defined_default(this._backgroundTextureAtlas)) {
    this._backgroundTextureAtlas = new TextureAtlas_default({
      context,
      initialSize: whitePixelSize
    });
    backgroundBillboardCollection.textureAtlas = this._backgroundTextureAtlas;
    addWhitePixelCanvas(this._backgroundTextureAtlas, this);
  }
  const len = this._labelsToUpdate.length;
  for (let i2 = 0; i2 < len; ++i2) {
    const label = this._labelsToUpdate[i2];
    if (label.isDestroyed()) {
      continue;
    }
    const preUpdateGlyphCount = label._glyphs.length;
    if (label._rebindAllGlyphs) {
      rebindAllGlyphs2(this, label);
      label._rebindAllGlyphs = false;
    }
    if (label._repositionAllGlyphs) {
      repositionAllGlyphs2(label);
      label._repositionAllGlyphs = false;
    }
    const glyphCountDifference = label._glyphs.length - preUpdateGlyphCount;
    this._totalGlyphCount += glyphCountDifference;
  }
  const blendOption = backgroundBillboardCollection.length > 0 ? BlendOption_default.TRANSLUCENT : this.blendOption;
  billboardCollection.blendOption = blendOption;
  backgroundBillboardCollection.blendOption = blendOption;
  billboardCollection._highlightColor = this._highlightColor;
  backgroundBillboardCollection._highlightColor = this._highlightColor;
  this._labelsToUpdate.length = 0;
  backgroundBillboardCollection.update(frameState);
  billboardCollection.update(frameState);
};
LabelCollection.prototype.isDestroyed = function() {
  return false;
};
LabelCollection.prototype.destroy = function() {
  this.removeAll();
  this._billboardCollection = this._billboardCollection.destroy();
  this._textureAtlas = this._textureAtlas && this._textureAtlas.destroy();
  this._backgroundBillboardCollection = this._backgroundBillboardCollection.destroy();
  this._backgroundTextureAtlas = this._backgroundTextureAtlas && this._backgroundTextureAtlas.destroy();
  return destroyObject_default(this);
};
var LabelCollection_default = LabelCollection;

// node_modules/cesium/Source/Shaders/PolylineVS.js
var PolylineVS_default = "attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute vec3 position2DHigh;\nattribute vec3 position2DLow;\nattribute vec3 prevPosition3DHigh;\nattribute vec3 prevPosition3DLow;\nattribute vec3 prevPosition2DHigh;\nattribute vec3 prevPosition2DLow;\nattribute vec3 nextPosition3DHigh;\nattribute vec3 nextPosition3DLow;\nattribute vec3 nextPosition2DHigh;\nattribute vec3 nextPosition2DLow;\nattribute vec4 texCoordExpandAndBatchIndex;\n\nvarying vec2  v_st;\nvarying float v_width;\nvarying vec4 v_pickColor;\nvarying float v_polylineAngle;\n\nvoid main()\n{\n    float texCoord = texCoordExpandAndBatchIndex.x;\n    float expandDir = texCoordExpandAndBatchIndex.y;\n    bool usePrev = texCoordExpandAndBatchIndex.z < 0.0;\n    float batchTableIndex = texCoordExpandAndBatchIndex.w;\n\n    vec2 widthAndShow = batchTable_getWidthAndShow(batchTableIndex);\n    float width = widthAndShow.x + 0.5;\n    float show = widthAndShow.y;\n\n    if (width < 1.0)\n    {\n        show = 0.0;\n    }\n\n    vec4 pickColor = batchTable_getPickColor(batchTableIndex);\n\n    vec4 p, prev, next;\n    if (czm_morphTime == 1.0)\n    {\n        p = czm_translateRelativeToEye(position3DHigh.xyz, position3DLow.xyz);\n        prev = czm_translateRelativeToEye(prevPosition3DHigh.xyz, prevPosition3DLow.xyz);\n        next = czm_translateRelativeToEye(nextPosition3DHigh.xyz, nextPosition3DLow.xyz);\n    }\n    else if (czm_morphTime == 0.0)\n    {\n        p = czm_translateRelativeToEye(position2DHigh.zxy, position2DLow.zxy);\n        prev = czm_translateRelativeToEye(prevPosition2DHigh.zxy, prevPosition2DLow.zxy);\n        next = czm_translateRelativeToEye(nextPosition2DHigh.zxy, nextPosition2DLow.zxy);\n    }\n    else\n    {\n        p = czm_columbusViewMorph(\n                czm_translateRelativeToEye(position2DHigh.zxy, position2DLow.zxy),\n                czm_translateRelativeToEye(position3DHigh.xyz, position3DLow.xyz),\n                czm_morphTime);\n        prev = czm_columbusViewMorph(\n                czm_translateRelativeToEye(prevPosition2DHigh.zxy, prevPosition2DLow.zxy),\n                czm_translateRelativeToEye(prevPosition3DHigh.xyz, prevPosition3DLow.xyz),\n                czm_morphTime);\n        next = czm_columbusViewMorph(\n                czm_translateRelativeToEye(nextPosition2DHigh.zxy, nextPosition2DLow.zxy),\n                czm_translateRelativeToEye(nextPosition3DHigh.xyz, nextPosition3DLow.xyz),\n                czm_morphTime);\n    }\n\n    #ifdef DISTANCE_DISPLAY_CONDITION\n        vec3 centerHigh = batchTable_getCenterHigh(batchTableIndex);\n        vec4 centerLowAndRadius = batchTable_getCenterLowAndRadius(batchTableIndex);\n        vec3 centerLow = centerLowAndRadius.xyz;\n        float radius = centerLowAndRadius.w;\n        vec2 distanceDisplayCondition = batchTable_getDistanceDisplayCondition(batchTableIndex);\n\n        float lengthSq;\n        if (czm_sceneMode == czm_sceneMode2D)\n        {\n            lengthSq = czm_eyeHeight2D.y;\n        }\n        else\n        {\n            vec4 center = czm_translateRelativeToEye(centerHigh.xyz, centerLow.xyz);\n            lengthSq = max(0.0, dot(center.xyz, center.xyz) - radius * radius);\n        }\n\n        float nearSq = distanceDisplayCondition.x * distanceDisplayCondition.x;\n        float farSq = distanceDisplayCondition.y * distanceDisplayCondition.y;\n        if (lengthSq < nearSq || lengthSq > farSq)\n        {\n            show = 0.0;\n        }\n    #endif\n\n    float polylineAngle;\n    vec4 positionWC = getPolylineWindowCoordinates(p, prev, next, expandDir, width, usePrev, polylineAngle);\n    gl_Position = czm_viewportOrthographic * positionWC * show;\n\n    v_st.s = texCoord;\n    v_st.t = czm_writeNonPerspective(clamp(expandDir, 0.0, 1.0), gl_Position.w);\n\n    v_width = width;\n    v_pickColor = pickColor;\n    v_polylineAngle = polylineAngle;\n}\n";

// node_modules/cesium/Source/Scene/Polyline.js
function Polyline(options, polylineCollection) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._show = defaultValue_default(options.show, true);
  this._width = defaultValue_default(options.width, 1);
  this._loop = defaultValue_default(options.loop, false);
  this._distanceDisplayCondition = options.distanceDisplayCondition;
  this._material = options.material;
  if (!defined_default(this._material)) {
    this._material = Material_default.fromType(Material_default.ColorType, {
      color: new Color_default(1, 1, 1, 1)
    });
  }
  let positions = options.positions;
  if (!defined_default(positions)) {
    positions = [];
  }
  this._positions = positions;
  this._actualPositions = arrayRemoveDuplicates_default(
    positions,
    Cartesian3_default.equalsEpsilon
  );
  if (this._loop && this._actualPositions.length > 2) {
    if (this._actualPositions === this._positions) {
      this._actualPositions = positions.slice();
    }
    this._actualPositions.push(Cartesian3_default.clone(this._actualPositions[0]));
  }
  this._length = this._actualPositions.length;
  this._id = options.id;
  let modelMatrix;
  if (defined_default(polylineCollection)) {
    modelMatrix = Matrix4_default.clone(polylineCollection.modelMatrix);
  }
  this._modelMatrix = modelMatrix;
  this._segments = PolylinePipeline_default.wrapLongitude(
    this._actualPositions,
    modelMatrix
  );
  this._actualLength = void 0;
  this._propertiesChanged = new Uint32Array(NUMBER_OF_PROPERTIES2);
  this._polylineCollection = polylineCollection;
  this._dirty = false;
  this._pickId = void 0;
  this._boundingVolume = BoundingSphere_default.fromPoints(this._actualPositions);
  this._boundingVolumeWC = BoundingSphere_default.transform(
    this._boundingVolume,
    this._modelMatrix
  );
  this._boundingVolume2D = new BoundingSphere_default();
}
var POSITION_INDEX3 = Polyline.POSITION_INDEX = 0;
var SHOW_INDEX3 = Polyline.SHOW_INDEX = 1;
var WIDTH_INDEX = Polyline.WIDTH_INDEX = 2;
var MATERIAL_INDEX = Polyline.MATERIAL_INDEX = 3;
var POSITION_SIZE_INDEX = Polyline.POSITION_SIZE_INDEX = 4;
var DISTANCE_DISPLAY_CONDITION2 = Polyline.DISTANCE_DISPLAY_CONDITION = 5;
var NUMBER_OF_PROPERTIES2 = Polyline.NUMBER_OF_PROPERTIES = 6;
function makeDirty2(polyline, propertyChanged) {
  ++polyline._propertiesChanged[propertyChanged];
  const polylineCollection = polyline._polylineCollection;
  if (defined_default(polylineCollection)) {
    polylineCollection._updatePolyline(polyline, propertyChanged);
    polyline._dirty = true;
  }
}
Object.defineProperties(Polyline.prototype, {
  show: {
    get: function() {
      return this._show;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (value !== this._show) {
        this._show = value;
        makeDirty2(this, SHOW_INDEX3);
      }
    }
  },
  positions: {
    get: function() {
      return this._positions;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      let positions = arrayRemoveDuplicates_default(value, Cartesian3_default.equalsEpsilon);
      if (this._loop && positions.length > 2) {
        if (positions === value) {
          positions = value.slice();
        }
        positions.push(Cartesian3_default.clone(positions[0]));
      }
      if (this._actualPositions.length !== positions.length || this._actualPositions.length !== this._length) {
        makeDirty2(this, POSITION_SIZE_INDEX);
      }
      this._positions = value;
      this._actualPositions = positions;
      this._length = positions.length;
      this._boundingVolume = BoundingSphere_default.fromPoints(
        this._actualPositions,
        this._boundingVolume
      );
      this._boundingVolumeWC = BoundingSphere_default.transform(
        this._boundingVolume,
        this._modelMatrix,
        this._boundingVolumeWC
      );
      makeDirty2(this, POSITION_INDEX3);
      this.update();
    }
  },
  material: {
    get: function() {
      return this._material;
    },
    set: function(material) {
      if (!defined_default(material)) {
        throw new DeveloperError_default("material is required.");
      }
      if (this._material !== material) {
        this._material = material;
        makeDirty2(this, MATERIAL_INDEX);
      }
    }
  },
  width: {
    get: function() {
      return this._width;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const width = this._width;
      if (value !== width) {
        this._width = value;
        makeDirty2(this, WIDTH_INDEX);
      }
    }
  },
  loop: {
    get: function() {
      return this._loop;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (value !== this._loop) {
        let positions = this._actualPositions;
        if (value) {
          if (positions.length > 2 && !Cartesian3_default.equals(positions[0], positions[positions.length - 1])) {
            if (positions.length === this._positions.length) {
              this._actualPositions = positions = this._positions.slice();
            }
            positions.push(Cartesian3_default.clone(positions[0]));
          }
        } else if (positions.length > 2 && Cartesian3_default.equals(positions[0], positions[positions.length - 1])) {
          if (positions.length - 1 === this._positions.length) {
            this._actualPositions = this._positions;
          } else {
            positions.pop();
          }
        }
        this._loop = value;
        makeDirty2(this, POSITION_SIZE_INDEX);
      }
    }
  },
  id: {
    get: function() {
      return this._id;
    },
    set: function(value) {
      this._id = value;
      if (defined_default(this._pickId)) {
        this._pickId.object.id = value;
      }
    }
  },
  pickId: {
    get: function() {
      return this._pickId;
    }
  },
  isDestroyed: {
    get: function() {
      return !defined_default(this._polylineCollection);
    }
  },
  distanceDisplayCondition: {
    get: function() {
      return this._distanceDisplayCondition;
    },
    set: function(value) {
      if (defined_default(value) && value.far <= value.near) {
        throw new DeveloperError_default(
          "far distance must be greater than near distance."
        );
      }
      if (!DistanceDisplayCondition_default.equals(value, this._distanceDisplayCondition)) {
        this._distanceDisplayCondition = DistanceDisplayCondition_default.clone(
          value,
          this._distanceDisplayCondition
        );
        makeDirty2(this, DISTANCE_DISPLAY_CONDITION2);
      }
    }
  }
});
Polyline.prototype.update = function() {
  let modelMatrix = Matrix4_default.IDENTITY;
  if (defined_default(this._polylineCollection)) {
    modelMatrix = this._polylineCollection.modelMatrix;
  }
  const segmentPositionsLength = this._segments.positions.length;
  const segmentLengths = this._segments.lengths;
  const positionsChanged = this._propertiesChanged[POSITION_INDEX3] > 0 || this._propertiesChanged[POSITION_SIZE_INDEX] > 0;
  if (!Matrix4_default.equals(modelMatrix, this._modelMatrix) || positionsChanged) {
    this._segments = PolylinePipeline_default.wrapLongitude(
      this._actualPositions,
      modelMatrix
    );
    this._boundingVolumeWC = BoundingSphere_default.transform(
      this._boundingVolume,
      modelMatrix,
      this._boundingVolumeWC
    );
  }
  this._modelMatrix = Matrix4_default.clone(modelMatrix, this._modelMatrix);
  if (this._segments.positions.length !== segmentPositionsLength) {
    makeDirty2(this, POSITION_SIZE_INDEX);
  } else {
    const length3 = segmentLengths.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      if (segmentLengths[i2] !== this._segments.lengths[i2]) {
        makeDirty2(this, POSITION_SIZE_INDEX);
        break;
      }
    }
  }
};
Polyline.prototype.getPickId = function(context) {
  if (!defined_default(this._pickId)) {
    this._pickId = context.createPickId({
      primitive: this,
      collection: this._polylineCollection,
      id: this._id
    });
  }
  return this._pickId;
};
Polyline.prototype._clean = function() {
  this._dirty = false;
  const properties = this._propertiesChanged;
  for (let k = 0; k < NUMBER_OF_PROPERTIES2 - 1; ++k) {
    properties[k] = 0;
  }
};
Polyline.prototype._destroy = function() {
  this._pickId = this._pickId && this._pickId.destroy();
  this._material = this._material && this._material.destroy();
  this._polylineCollection = void 0;
};
var Polyline_default = Polyline;

// node_modules/cesium/Source/Scene/PolylineCollection.js
var SHOW_INDEX4 = Polyline_default.SHOW_INDEX;
var WIDTH_INDEX2 = Polyline_default.WIDTH_INDEX;
var POSITION_INDEX4 = Polyline_default.POSITION_INDEX;
var MATERIAL_INDEX2 = Polyline_default.MATERIAL_INDEX;
var POSITION_SIZE_INDEX2 = Polyline_default.POSITION_SIZE_INDEX;
var DISTANCE_DISPLAY_CONDITION3 = Polyline_default.DISTANCE_DISPLAY_CONDITION;
var NUMBER_OF_PROPERTIES3 = Polyline_default.NUMBER_OF_PROPERTIES;
var attributeLocations2 = {
  texCoordExpandAndBatchIndex: 0,
  position3DHigh: 1,
  position3DLow: 2,
  position2DHigh: 3,
  position2DLow: 4,
  prevPosition3DHigh: 5,
  prevPosition3DLow: 6,
  prevPosition2DHigh: 7,
  prevPosition2DLow: 8,
  nextPosition3DHigh: 9,
  nextPosition3DLow: 10,
  nextPosition2DHigh: 11,
  nextPosition2DLow: 12
};
function PolylineCollection(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.show = defaultValue_default(options.show, true);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._modelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this._opaqueRS = void 0;
  this._translucentRS = void 0;
  this._colorCommands = [];
  this._polylinesUpdated = false;
  this._polylinesRemoved = false;
  this._createVertexArray = false;
  this._propertiesChanged = new Uint32Array(NUMBER_OF_PROPERTIES3);
  this._polylines = [];
  this._polylineBuckets = {};
  this._positionBufferUsage = {
    bufferUsage: BufferUsage_default.STATIC_DRAW,
    frameCount: 0
  };
  this._mode = void 0;
  this._polylinesToUpdate = [];
  this._vertexArrays = [];
  this._positionBuffer = void 0;
  this._texCoordExpandAndBatchIndexBuffer = void 0;
  this._batchTable = void 0;
  this._createBatchTable = false;
  this._useHighlightColor = false;
  this._highlightColor = Color_default.clone(Color_default.WHITE);
  const that = this;
  this._uniformMap = {
    u_highlightColor: function() {
      return that._highlightColor;
    }
  };
}
Object.defineProperties(PolylineCollection.prototype, {
  length: {
    get: function() {
      removePolylines(this);
      return this._polylines.length;
    }
  }
});
PolylineCollection.prototype.add = function(options) {
  const p2 = new Polyline_default(options, this);
  p2._index = this._polylines.length;
  this._polylines.push(p2);
  this._createVertexArray = true;
  this._createBatchTable = true;
  return p2;
};
PolylineCollection.prototype.remove = function(polyline) {
  if (this.contains(polyline)) {
    this._polylinesRemoved = true;
    this._createVertexArray = true;
    this._createBatchTable = true;
    if (defined_default(polyline._bucket)) {
      const bucket = polyline._bucket;
      bucket.shaderProgram = bucket.shaderProgram && bucket.shaderProgram.destroy();
    }
    polyline._destroy();
    return true;
  }
  return false;
};
PolylineCollection.prototype.removeAll = function() {
  releaseShaders(this);
  destroyPolylines(this);
  this._polylineBuckets = {};
  this._polylinesRemoved = false;
  this._polylines.length = 0;
  this._polylinesToUpdate.length = 0;
  this._createVertexArray = true;
};
PolylineCollection.prototype.contains = function(polyline) {
  return defined_default(polyline) && polyline._polylineCollection === this;
};
PolylineCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.");
  }
  removePolylines(this);
  return this._polylines[index2];
};
function createBatchTable2(collection, context) {
  if (defined_default(collection._batchTable)) {
    collection._batchTable.destroy();
  }
  const attributes = [
    {
      functionName: "batchTable_getWidthAndShow",
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 2
    },
    {
      functionName: "batchTable_getPickColor",
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      componentsPerAttribute: 4,
      normalize: true
    },
    {
      functionName: "batchTable_getCenterHigh",
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 3
    },
    {
      functionName: "batchTable_getCenterLowAndRadius",
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 4
    },
    {
      functionName: "batchTable_getDistanceDisplayCondition",
      componentDatatype: ComponentDatatype_default.FLOAT,
      componentsPerAttribute: 2
    }
  ];
  collection._batchTable = new BatchTable_default(
    context,
    attributes,
    collection._polylines.length
  );
}
var scratchUpdatePolylineEncodedCartesian = new EncodedCartesian3_default();
var scratchUpdatePolylineCartesian4 = new Cartesian4_default();
var scratchNearFarCartesian2 = new Cartesian2_default();
PolylineCollection.prototype.update = function(frameState) {
  removePolylines(this);
  if (this._polylines.length === 0 || !this.show) {
    return;
  }
  updateMode2(this, frameState);
  const context = frameState.context;
  const projection = frameState.mapProjection;
  let polyline;
  let properties = this._propertiesChanged;
  if (this._createBatchTable) {
    if (ContextLimits_default.maximumVertexTextureImageUnits === 0) {
      throw new RuntimeError_default(
        "Vertex texture fetch support is required to render polylines. The maximum number of vertex texture image units must be greater than zero."
      );
    }
    createBatchTable2(this, context);
    this._createBatchTable = false;
  }
  if (this._createVertexArray || computeNewBuffersUsage(this)) {
    createVertexArrays2(this, context, projection);
  } else if (this._polylinesUpdated) {
    const polylinesToUpdate = this._polylinesToUpdate;
    if (this._mode !== SceneMode_default.SCENE3D) {
      const updateLength = polylinesToUpdate.length;
      for (let i2 = 0; i2 < updateLength; ++i2) {
        polyline = polylinesToUpdate[i2];
        polyline.update();
      }
    }
    if (properties[POSITION_SIZE_INDEX2] || properties[MATERIAL_INDEX2]) {
      createVertexArrays2(this, context, projection);
    } else {
      const length3 = polylinesToUpdate.length;
      const polylineBuckets = this._polylineBuckets;
      for (let ii = 0; ii < length3; ++ii) {
        polyline = polylinesToUpdate[ii];
        properties = polyline._propertiesChanged;
        const bucket = polyline._bucket;
        let index2 = 0;
        for (const x in polylineBuckets) {
          if (polylineBuckets.hasOwnProperty(x)) {
            if (polylineBuckets[x] === bucket) {
              if (properties[POSITION_INDEX4]) {
                bucket.writeUpdate(
                  index2,
                  polyline,
                  this._positionBuffer,
                  projection
                );
              }
              break;
            }
            index2 += polylineBuckets[x].lengthOfPositions;
          }
        }
        if (properties[SHOW_INDEX4] || properties[WIDTH_INDEX2]) {
          this._batchTable.setBatchedAttribute(
            polyline._index,
            0,
            new Cartesian2_default(polyline._width, polyline._show)
          );
        }
        if (this._batchTable.attributes.length > 2) {
          if (properties[POSITION_INDEX4] || properties[POSITION_SIZE_INDEX2]) {
            const boundingSphere = frameState.mode === SceneMode_default.SCENE2D ? polyline._boundingVolume2D : polyline._boundingVolumeWC;
            const encodedCenter = EncodedCartesian3_default.fromCartesian(
              boundingSphere.center,
              scratchUpdatePolylineEncodedCartesian
            );
            const low = Cartesian4_default.fromElements(
              encodedCenter.low.x,
              encodedCenter.low.y,
              encodedCenter.low.z,
              boundingSphere.radius,
              scratchUpdatePolylineCartesian4
            );
            this._batchTable.setBatchedAttribute(
              polyline._index,
              2,
              encodedCenter.high
            );
            this._batchTable.setBatchedAttribute(polyline._index, 3, low);
          }
          if (properties[DISTANCE_DISPLAY_CONDITION3]) {
            const nearFarCartesian = scratchNearFarCartesian2;
            nearFarCartesian.x = 0;
            nearFarCartesian.y = Number.MAX_VALUE;
            const distanceDisplayCondition = polyline.distanceDisplayCondition;
            if (defined_default(distanceDisplayCondition)) {
              nearFarCartesian.x = distanceDisplayCondition.near;
              nearFarCartesian.y = distanceDisplayCondition.far;
            }
            this._batchTable.setBatchedAttribute(
              polyline._index,
              4,
              nearFarCartesian
            );
          }
        }
        polyline._clean();
      }
    }
    polylinesToUpdate.length = 0;
    this._polylinesUpdated = false;
  }
  properties = this._propertiesChanged;
  for (let k = 0; k < NUMBER_OF_PROPERTIES3; ++k) {
    properties[k] = 0;
  }
  let modelMatrix = Matrix4_default.IDENTITY;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    modelMatrix = this.modelMatrix;
  }
  const pass = frameState.passes;
  const useDepthTest = frameState.morphTime !== 0;
  if (!defined_default(this._opaqueRS) || this._opaqueRS.depthTest.enabled !== useDepthTest) {
    this._opaqueRS = RenderState_default.fromCache({
      depthMask: useDepthTest,
      depthTest: {
        enabled: useDepthTest
      }
    });
  }
  if (!defined_default(this._translucentRS) || this._translucentRS.depthTest.enabled !== useDepthTest) {
    this._translucentRS = RenderState_default.fromCache({
      blending: BlendingState_default.ALPHA_BLEND,
      depthMask: !useDepthTest,
      depthTest: {
        enabled: useDepthTest
      }
    });
  }
  this._batchTable.update(frameState);
  if (pass.render || pass.pick) {
    const colorList = this._colorCommands;
    createCommandLists(this, frameState, colorList, modelMatrix);
  }
};
var boundingSphereScratch = new BoundingSphere_default();
var boundingSphereScratch2 = new BoundingSphere_default();
function createCommandLists(polylineCollection, frameState, commands, modelMatrix) {
  const context = frameState.context;
  const commandList = frameState.commandList;
  const commandsLength = commands.length;
  let commandIndex = 0;
  let cloneBoundingSphere = true;
  const vertexArrays = polylineCollection._vertexArrays;
  const debugShowBoundingVolume2 = polylineCollection.debugShowBoundingVolume;
  const batchTable = polylineCollection._batchTable;
  const uniformCallback = batchTable.getUniformMapCallback();
  const length3 = vertexArrays.length;
  for (let m = 0; m < length3; ++m) {
    const va = vertexArrays[m];
    const buckets = va.buckets;
    const bucketLength = buckets.length;
    for (let n2 = 0; n2 < bucketLength; ++n2) {
      const bucketLocator = buckets[n2];
      let offset2 = bucketLocator.offset;
      const sp = bucketLocator.bucket.shaderProgram;
      const polylines = bucketLocator.bucket.polylines;
      const polylineLength = polylines.length;
      let currentId2;
      let currentMaterial;
      let count = 0;
      let command;
      let uniformMap2;
      for (let s2 = 0; s2 < polylineLength; ++s2) {
        const polyline = polylines[s2];
        const mId = createMaterialId(polyline._material);
        if (mId !== currentId2) {
          if (defined_default(currentId2) && count > 0) {
            const translucent = currentMaterial.isTranslucent();
            if (commandIndex >= commandsLength) {
              command = new DrawCommand_default({
                owner: polylineCollection
              });
              commands.push(command);
            } else {
              command = commands[commandIndex];
            }
            ++commandIndex;
            uniformMap2 = combine_default(
              uniformCallback(currentMaterial._uniforms),
              polylineCollection._uniformMap
            );
            command.boundingVolume = BoundingSphere_default.clone(
              boundingSphereScratch,
              command.boundingVolume
            );
            command.modelMatrix = modelMatrix;
            command.shaderProgram = sp;
            command.vertexArray = va.va;
            command.renderState = translucent ? polylineCollection._translucentRS : polylineCollection._opaqueRS;
            command.pass = translucent ? Pass_default.TRANSLUCENT : Pass_default.OPAQUE;
            command.debugShowBoundingVolume = debugShowBoundingVolume2;
            command.pickId = "v_pickColor";
            command.uniformMap = uniformMap2;
            command.count = count;
            command.offset = offset2;
            offset2 += count;
            count = 0;
            cloneBoundingSphere = true;
            commandList.push(command);
          }
          currentMaterial = polyline._material;
          currentMaterial.update(context);
          currentId2 = mId;
        }
        const locators = polyline._locatorBuckets;
        const locatorLength = locators.length;
        for (let t = 0; t < locatorLength; ++t) {
          const locator = locators[t];
          if (locator.locator === bucketLocator) {
            count += locator.count;
          }
        }
        let boundingVolume;
        if (frameState.mode === SceneMode_default.SCENE3D) {
          boundingVolume = polyline._boundingVolumeWC;
        } else if (frameState.mode === SceneMode_default.COLUMBUS_VIEW) {
          boundingVolume = polyline._boundingVolume2D;
        } else if (frameState.mode === SceneMode_default.SCENE2D) {
          if (defined_default(polyline._boundingVolume2D)) {
            boundingVolume = BoundingSphere_default.clone(
              polyline._boundingVolume2D,
              boundingSphereScratch2
            );
            boundingVolume.center.x = 0;
          }
        } else if (defined_default(polyline._boundingVolumeWC) && defined_default(polyline._boundingVolume2D)) {
          boundingVolume = BoundingSphere_default.union(
            polyline._boundingVolumeWC,
            polyline._boundingVolume2D,
            boundingSphereScratch2
          );
        }
        if (cloneBoundingSphere) {
          cloneBoundingSphere = false;
          BoundingSphere_default.clone(boundingVolume, boundingSphereScratch);
        } else {
          BoundingSphere_default.union(
            boundingVolume,
            boundingSphereScratch,
            boundingSphereScratch
          );
        }
      }
      if (defined_default(currentId2) && count > 0) {
        if (commandIndex >= commandsLength) {
          command = new DrawCommand_default({
            owner: polylineCollection
          });
          commands.push(command);
        } else {
          command = commands[commandIndex];
        }
        ++commandIndex;
        uniformMap2 = combine_default(
          uniformCallback(currentMaterial._uniforms),
          polylineCollection._uniformMap
        );
        command.boundingVolume = BoundingSphere_default.clone(
          boundingSphereScratch,
          command.boundingVolume
        );
        command.modelMatrix = modelMatrix;
        command.shaderProgram = sp;
        command.vertexArray = va.va;
        command.renderState = currentMaterial.isTranslucent() ? polylineCollection._translucentRS : polylineCollection._opaqueRS;
        command.pass = currentMaterial.isTranslucent() ? Pass_default.TRANSLUCENT : Pass_default.OPAQUE;
        command.debugShowBoundingVolume = debugShowBoundingVolume2;
        command.pickId = "v_pickColor";
        command.uniformMap = uniformMap2;
        command.count = count;
        command.offset = offset2;
        cloneBoundingSphere = true;
        commandList.push(command);
      }
      currentId2 = void 0;
    }
  }
  commands.length = commandIndex;
}
PolylineCollection.prototype.isDestroyed = function() {
  return false;
};
PolylineCollection.prototype.destroy = function() {
  destroyVertexArrays(this);
  releaseShaders(this);
  destroyPolylines(this);
  this._batchTable = this._batchTable && this._batchTable.destroy();
  return destroyObject_default(this);
};
function computeNewBuffersUsage(collection) {
  let usageChanged = false;
  const properties = collection._propertiesChanged;
  const bufferUsage = collection._positionBufferUsage;
  if (properties[POSITION_INDEX4]) {
    if (bufferUsage.bufferUsage !== BufferUsage_default.STREAM_DRAW) {
      usageChanged = true;
      bufferUsage.bufferUsage = BufferUsage_default.STREAM_DRAW;
      bufferUsage.frameCount = 100;
    } else {
      bufferUsage.frameCount = 100;
    }
  } else if (bufferUsage.bufferUsage !== BufferUsage_default.STATIC_DRAW) {
    if (bufferUsage.frameCount === 0) {
      usageChanged = true;
      bufferUsage.bufferUsage = BufferUsage_default.STATIC_DRAW;
    } else {
      bufferUsage.frameCount--;
    }
  }
  return usageChanged;
}
var emptyVertexBuffer = [0, 0, 0];
function createVertexArrays2(collection, context, projection) {
  collection._createVertexArray = false;
  releaseShaders(collection);
  destroyVertexArrays(collection);
  sortPolylinesIntoBuckets(collection);
  const totalIndices = [[]];
  let indices2 = totalIndices[0];
  const batchTable = collection._batchTable;
  const useHighlightColor = collection._useHighlightColor;
  const vertexBufferOffset = [0];
  let offset2 = 0;
  const vertexArrayBuckets = [[]];
  let totalLength = 0;
  const polylineBuckets = collection._polylineBuckets;
  let x;
  let bucket;
  for (x in polylineBuckets) {
    if (polylineBuckets.hasOwnProperty(x)) {
      bucket = polylineBuckets[x];
      bucket.updateShader(context, batchTable, useHighlightColor);
      totalLength += bucket.lengthOfPositions;
    }
  }
  if (totalLength > 0) {
    const mode2 = collection._mode;
    const positionArray = new Float32Array(6 * totalLength * 3);
    const texCoordExpandAndBatchIndexArray = new Float32Array(totalLength * 4);
    let position3DArray;
    let positionIndex = 0;
    let colorIndex = 0;
    let texCoordExpandAndBatchIndexIndex = 0;
    for (x in polylineBuckets) {
      if (polylineBuckets.hasOwnProperty(x)) {
        bucket = polylineBuckets[x];
        bucket.write(
          positionArray,
          texCoordExpandAndBatchIndexArray,
          positionIndex,
          colorIndex,
          texCoordExpandAndBatchIndexIndex,
          batchTable,
          context,
          projection
        );
        if (mode2 === SceneMode_default.MORPHING) {
          if (!defined_default(position3DArray)) {
            position3DArray = new Float32Array(6 * totalLength * 3);
          }
          bucket.writeForMorph(position3DArray, positionIndex);
        }
        const bucketLength = bucket.lengthOfPositions;
        positionIndex += 6 * bucketLength * 3;
        colorIndex += bucketLength * 4;
        texCoordExpandAndBatchIndexIndex += bucketLength * 4;
        offset2 = bucket.updateIndices(
          totalIndices,
          vertexBufferOffset,
          vertexArrayBuckets,
          offset2
        );
      }
    }
    const positionBufferUsage = collection._positionBufferUsage.bufferUsage;
    const texCoordExpandAndBatchIndexBufferUsage = BufferUsage_default.STATIC_DRAW;
    collection._positionBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: positionArray,
      usage: positionBufferUsage
    });
    let position3DBuffer;
    if (defined_default(position3DArray)) {
      position3DBuffer = Buffer_default.createVertexBuffer({
        context,
        typedArray: position3DArray,
        usage: positionBufferUsage
      });
    }
    collection._texCoordExpandAndBatchIndexBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: texCoordExpandAndBatchIndexArray,
      usage: texCoordExpandAndBatchIndexBufferUsage
    });
    const positionSizeInBytes = 3 * Float32Array.BYTES_PER_ELEMENT;
    const texCoordExpandAndBatchIndexSizeInBytes = 4 * Float32Array.BYTES_PER_ELEMENT;
    let vbo = 0;
    const numberOfIndicesArrays = totalIndices.length;
    for (let k = 0; k < numberOfIndicesArrays; ++k) {
      indices2 = totalIndices[k];
      if (indices2.length > 0) {
        const indicesArray = new Uint16Array(indices2);
        const indexBuffer = Buffer_default.createIndexBuffer({
          context,
          typedArray: indicesArray,
          usage: BufferUsage_default.STATIC_DRAW,
          indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
        });
        vbo += vertexBufferOffset[k];
        const positionHighOffset = 6 * (k * (positionSizeInBytes * Math_default.SIXTY_FOUR_KILOBYTES) - vbo * positionSizeInBytes);
        const positionLowOffset = positionSizeInBytes + positionHighOffset;
        const prevPositionHighOffset = positionSizeInBytes + positionLowOffset;
        const prevPositionLowOffset = positionSizeInBytes + prevPositionHighOffset;
        const nextPositionHighOffset = positionSizeInBytes + prevPositionLowOffset;
        const nextPositionLowOffset = positionSizeInBytes + nextPositionHighOffset;
        const vertexTexCoordExpandAndBatchIndexBufferOffset = k * (texCoordExpandAndBatchIndexSizeInBytes * Math_default.SIXTY_FOUR_KILOBYTES) - vbo * texCoordExpandAndBatchIndexSizeInBytes;
        const attributes = [
          {
            index: attributeLocations2.position3DHigh,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: positionHighOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.position3DLow,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: positionLowOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.position2DHigh,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: positionHighOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.position2DLow,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: positionLowOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.prevPosition3DHigh,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: prevPositionHighOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.prevPosition3DLow,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: prevPositionLowOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.prevPosition2DHigh,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: prevPositionHighOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.prevPosition2DLow,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: prevPositionLowOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.nextPosition3DHigh,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: nextPositionHighOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.nextPosition3DLow,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: nextPositionLowOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.nextPosition2DHigh,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: nextPositionHighOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.nextPosition2DLow,
            componentsPerAttribute: 3,
            componentDatatype: ComponentDatatype_default.FLOAT,
            offsetInBytes: nextPositionLowOffset,
            strideInBytes: 6 * positionSizeInBytes
          },
          {
            index: attributeLocations2.texCoordExpandAndBatchIndex,
            componentsPerAttribute: 4,
            componentDatatype: ComponentDatatype_default.FLOAT,
            vertexBuffer: collection._texCoordExpandAndBatchIndexBuffer,
            offsetInBytes: vertexTexCoordExpandAndBatchIndexBufferOffset
          }
        ];
        let bufferProperty3D;
        let buffer3D;
        let buffer2D;
        let bufferProperty2D;
        if (mode2 === SceneMode_default.SCENE3D) {
          buffer3D = collection._positionBuffer;
          bufferProperty3D = "vertexBuffer";
          buffer2D = emptyVertexBuffer;
          bufferProperty2D = "value";
        } else if (mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.COLUMBUS_VIEW) {
          buffer3D = emptyVertexBuffer;
          bufferProperty3D = "value";
          buffer2D = collection._positionBuffer;
          bufferProperty2D = "vertexBuffer";
        } else {
          buffer3D = position3DBuffer;
          bufferProperty3D = "vertexBuffer";
          buffer2D = collection._positionBuffer;
          bufferProperty2D = "vertexBuffer";
        }
        attributes[0][bufferProperty3D] = buffer3D;
        attributes[1][bufferProperty3D] = buffer3D;
        attributes[2][bufferProperty2D] = buffer2D;
        attributes[3][bufferProperty2D] = buffer2D;
        attributes[4][bufferProperty3D] = buffer3D;
        attributes[5][bufferProperty3D] = buffer3D;
        attributes[6][bufferProperty2D] = buffer2D;
        attributes[7][bufferProperty2D] = buffer2D;
        attributes[8][bufferProperty3D] = buffer3D;
        attributes[9][bufferProperty3D] = buffer3D;
        attributes[10][bufferProperty2D] = buffer2D;
        attributes[11][bufferProperty2D] = buffer2D;
        const va = new VertexArray_default({
          context,
          attributes,
          indexBuffer
        });
        collection._vertexArrays.push({
          va,
          buckets: vertexArrayBuckets[k]
        });
      }
    }
  }
}
function replacer(key, value) {
  if (value instanceof Texture_default) {
    return value.id;
  }
  return value;
}
var scratchUniformArray2 = [];
function createMaterialId(material) {
  const uniforms = Material_default._uniformList[material.type];
  const length3 = uniforms.length;
  scratchUniformArray2.length = 2 * length3;
  let index2 = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const uniform = uniforms[i2];
    scratchUniformArray2[index2] = uniform;
    scratchUniformArray2[index2 + 1] = material._uniforms[uniform]();
    index2 += 2;
  }
  return `${material.type}:${JSON.stringify(scratchUniformArray2, replacer)}`;
}
function sortPolylinesIntoBuckets(collection) {
  const mode2 = collection._mode;
  const modelMatrix = collection._modelMatrix;
  const polylineBuckets = collection._polylineBuckets = {};
  const polylines = collection._polylines;
  const length3 = polylines.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const p2 = polylines[i2];
    if (p2._actualPositions.length > 1) {
      p2.update();
      const material = p2.material;
      let value = polylineBuckets[material.type];
      if (!defined_default(value)) {
        value = polylineBuckets[material.type] = new PolylineBucket(
          material,
          mode2,
          modelMatrix
        );
      }
      value.addPolyline(p2);
    }
  }
}
function updateMode2(collection, frameState) {
  const mode2 = frameState.mode;
  if (collection._mode !== mode2 || !Matrix4_default.equals(collection._modelMatrix, collection.modelMatrix)) {
    collection._mode = mode2;
    collection._modelMatrix = Matrix4_default.clone(collection.modelMatrix);
    collection._createVertexArray = true;
  }
}
function removePolylines(collection) {
  if (collection._polylinesRemoved) {
    collection._polylinesRemoved = false;
    const definedPolylines = [];
    const definedPolylinesToUpdate = [];
    let polyIndex = 0;
    let polyline;
    const length3 = collection._polylines.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      polyline = collection._polylines[i2];
      if (!polyline.isDestroyed) {
        polyline._index = polyIndex++;
        definedPolylinesToUpdate.push(polyline);
        definedPolylines.push(polyline);
      }
    }
    collection._polylines = definedPolylines;
    collection._polylinesToUpdate = definedPolylinesToUpdate;
  }
}
function releaseShaders(collection) {
  const polylines = collection._polylines;
  const length3 = polylines.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (!polylines[i2].isDestroyed) {
      const bucket = polylines[i2]._bucket;
      if (defined_default(bucket)) {
        bucket.shaderProgram = bucket.shaderProgram && bucket.shaderProgram.destroy();
      }
    }
  }
}
function destroyVertexArrays(collection) {
  const length3 = collection._vertexArrays.length;
  for (let t = 0; t < length3; ++t) {
    collection._vertexArrays[t].va.destroy();
  }
  collection._vertexArrays.length = 0;
}
PolylineCollection.prototype._updatePolyline = function(polyline, propertyChanged) {
  this._polylinesUpdated = true;
  if (!polyline._dirty) {
    this._polylinesToUpdate.push(polyline);
  }
  ++this._propertiesChanged[propertyChanged];
};
function destroyPolylines(collection) {
  const polylines = collection._polylines;
  const length3 = polylines.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (!polylines[i2].isDestroyed) {
      polylines[i2]._destroy();
    }
  }
}
function VertexArrayBucketLocator(count, offset2, bucket) {
  this.count = count;
  this.offset = offset2;
  this.bucket = bucket;
}
function PolylineBucket(material, mode2, modelMatrix) {
  this.polylines = [];
  this.lengthOfPositions = 0;
  this.material = material;
  this.shaderProgram = void 0;
  this.mode = mode2;
  this.modelMatrix = modelMatrix;
}
PolylineBucket.prototype.addPolyline = function(p2) {
  const polylines = this.polylines;
  polylines.push(p2);
  p2._actualLength = this.getPolylinePositionsLength(p2);
  this.lengthOfPositions += p2._actualLength;
  p2._bucket = this;
};
PolylineBucket.prototype.updateShader = function(context, batchTable, useHighlightColor) {
  if (defined_default(this.shaderProgram)) {
    return;
  }
  const defines = ["DISTANCE_DISPLAY_CONDITION"];
  if (useHighlightColor) {
    defines.push("VECTOR_TILE");
  }
  if (this.material.shaderSource.search(/varying\s+float\s+v_polylineAngle;/g) !== -1) {
    defines.push("POLYLINE_DASH");
  }
  if (!FeatureDetection_default.isInternetExplorer()) {
    defines.push("CLIP_POLYLINE");
  }
  const fs = new ShaderSource_default({
    defines,
    sources: [
      "varying vec4 v_pickColor;\n",
      this.material.shaderSource,
      PolylineFS_default
    ]
  });
  const vsSource = batchTable.getVertexShaderCallback()(PolylineVS_default);
  const vs = new ShaderSource_default({
    defines,
    sources: [PolylineCommon_default, vsSource]
  });
  this.shaderProgram = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: vs,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations2
  });
};
function intersectsIDL(polyline) {
  return Cartesian3_default.dot(Cartesian3_default.UNIT_X, polyline._boundingVolume.center) < 0 || polyline._boundingVolume.intersectPlane(Plane_default.ORIGIN_ZX_PLANE) === Intersect_default.INTERSECTING;
}
PolylineBucket.prototype.getPolylinePositionsLength = function(polyline) {
  let length3;
  if (this.mode === SceneMode_default.SCENE3D || !intersectsIDL(polyline)) {
    length3 = polyline._actualPositions.length;
    return length3 * 4 - 4;
  }
  let count = 0;
  const segmentLengths = polyline._segments.lengths;
  length3 = segmentLengths.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    count += segmentLengths[i2] * 4 - 4;
  }
  return count;
};
var scratchWritePosition = new Cartesian3_default();
var scratchWritePrevPosition = new Cartesian3_default();
var scratchWriteNextPosition = new Cartesian3_default();
var scratchWriteVector = new Cartesian3_default();
var scratchPickColorCartesian = new Cartesian4_default();
var scratchWidthShowCartesian = new Cartesian2_default();
PolylineBucket.prototype.write = function(positionArray, texCoordExpandAndBatchIndexArray, positionIndex, colorIndex, texCoordExpandAndBatchIndexIndex, batchTable, context, projection) {
  const mode2 = this.mode;
  const maxLon = projection.ellipsoid.maximumRadius * Math_default.PI;
  const polylines = this.polylines;
  const length3 = polylines.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const polyline = polylines[i2];
    const width = polyline.width;
    const show = polyline.show && width > 0;
    const polylineBatchIndex = polyline._index;
    const segments = this.getSegments(polyline, projection);
    const positions = segments.positions;
    const lengths = segments.lengths;
    const positionsLength = positions.length;
    const pickColor = polyline.getPickId(context).color;
    let segmentIndex = 0;
    let count = 0;
    let position;
    for (let j = 0; j < positionsLength; ++j) {
      if (j === 0) {
        if (polyline._loop) {
          position = positions[positionsLength - 2];
        } else {
          position = scratchWriteVector;
          Cartesian3_default.subtract(positions[0], positions[1], position);
          Cartesian3_default.add(positions[0], position, position);
        }
      } else {
        position = positions[j - 1];
      }
      Cartesian3_default.clone(position, scratchWritePrevPosition);
      Cartesian3_default.clone(positions[j], scratchWritePosition);
      if (j === positionsLength - 1) {
        if (polyline._loop) {
          position = positions[1];
        } else {
          position = scratchWriteVector;
          Cartesian3_default.subtract(
            positions[positionsLength - 1],
            positions[positionsLength - 2],
            position
          );
          Cartesian3_default.add(positions[positionsLength - 1], position, position);
        }
      } else {
        position = positions[j + 1];
      }
      Cartesian3_default.clone(position, scratchWriteNextPosition);
      const segmentLength = lengths[segmentIndex];
      if (j === count + segmentLength) {
        count += segmentLength;
        ++segmentIndex;
      }
      const segmentStart = j - count === 0;
      const segmentEnd = j === count + lengths[segmentIndex] - 1;
      if (mode2 === SceneMode_default.SCENE2D) {
        scratchWritePrevPosition.z = 0;
        scratchWritePosition.z = 0;
        scratchWriteNextPosition.z = 0;
      }
      if (mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.MORPHING) {
        if ((segmentStart || segmentEnd) && maxLon - Math.abs(scratchWritePosition.x) < 1) {
          if (scratchWritePosition.x < 0 && scratchWritePrevPosition.x > 0 || scratchWritePosition.x > 0 && scratchWritePrevPosition.x < 0) {
            Cartesian3_default.clone(scratchWritePosition, scratchWritePrevPosition);
          }
          if (scratchWritePosition.x < 0 && scratchWriteNextPosition.x > 0 || scratchWritePosition.x > 0 && scratchWriteNextPosition.x < 0) {
            Cartesian3_default.clone(scratchWritePosition, scratchWriteNextPosition);
          }
        }
      }
      const startK = segmentStart ? 2 : 0;
      const endK = segmentEnd ? 2 : 4;
      for (let k = startK; k < endK; ++k) {
        EncodedCartesian3_default.writeElements(
          scratchWritePosition,
          positionArray,
          positionIndex
        );
        EncodedCartesian3_default.writeElements(
          scratchWritePrevPosition,
          positionArray,
          positionIndex + 6
        );
        EncodedCartesian3_default.writeElements(
          scratchWriteNextPosition,
          positionArray,
          positionIndex + 12
        );
        const direction2 = k - 2 < 0 ? -1 : 1;
        texCoordExpandAndBatchIndexArray[texCoordExpandAndBatchIndexIndex] = j / (positionsLength - 1);
        texCoordExpandAndBatchIndexArray[texCoordExpandAndBatchIndexIndex + 1] = 2 * (k % 2) - 1;
        texCoordExpandAndBatchIndexArray[texCoordExpandAndBatchIndexIndex + 2] = direction2;
        texCoordExpandAndBatchIndexArray[texCoordExpandAndBatchIndexIndex + 3] = polylineBatchIndex;
        positionIndex += 6 * 3;
        texCoordExpandAndBatchIndexIndex += 4;
      }
    }
    const colorCartesian = scratchPickColorCartesian;
    colorCartesian.x = Color_default.floatToByte(pickColor.red);
    colorCartesian.y = Color_default.floatToByte(pickColor.green);
    colorCartesian.z = Color_default.floatToByte(pickColor.blue);
    colorCartesian.w = Color_default.floatToByte(pickColor.alpha);
    const widthShowCartesian = scratchWidthShowCartesian;
    widthShowCartesian.x = width;
    widthShowCartesian.y = show ? 1 : 0;
    const boundingSphere = mode2 === SceneMode_default.SCENE2D ? polyline._boundingVolume2D : polyline._boundingVolumeWC;
    const encodedCenter = EncodedCartesian3_default.fromCartesian(
      boundingSphere.center,
      scratchUpdatePolylineEncodedCartesian
    );
    const high = encodedCenter.high;
    const low = Cartesian4_default.fromElements(
      encodedCenter.low.x,
      encodedCenter.low.y,
      encodedCenter.low.z,
      boundingSphere.radius,
      scratchUpdatePolylineCartesian4
    );
    const nearFarCartesian = scratchNearFarCartesian2;
    nearFarCartesian.x = 0;
    nearFarCartesian.y = Number.MAX_VALUE;
    const distanceDisplayCondition = polyline.distanceDisplayCondition;
    if (defined_default(distanceDisplayCondition)) {
      nearFarCartesian.x = distanceDisplayCondition.near;
      nearFarCartesian.y = distanceDisplayCondition.far;
    }
    batchTable.setBatchedAttribute(polylineBatchIndex, 0, widthShowCartesian);
    batchTable.setBatchedAttribute(polylineBatchIndex, 1, colorCartesian);
    if (batchTable.attributes.length > 2) {
      batchTable.setBatchedAttribute(polylineBatchIndex, 2, high);
      batchTable.setBatchedAttribute(polylineBatchIndex, 3, low);
      batchTable.setBatchedAttribute(polylineBatchIndex, 4, nearFarCartesian);
    }
  }
};
var morphPositionScratch = new Cartesian3_default();
var morphPrevPositionScratch = new Cartesian3_default();
var morphNextPositionScratch = new Cartesian3_default();
var morphVectorScratch = new Cartesian3_default();
PolylineBucket.prototype.writeForMorph = function(positionArray, positionIndex) {
  const modelMatrix = this.modelMatrix;
  const polylines = this.polylines;
  const length3 = polylines.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const polyline = polylines[i2];
    const positions = polyline._segments.positions;
    const lengths = polyline._segments.lengths;
    const positionsLength = positions.length;
    let segmentIndex = 0;
    let count = 0;
    for (let j = 0; j < positionsLength; ++j) {
      let prevPosition;
      if (j === 0) {
        if (polyline._loop) {
          prevPosition = positions[positionsLength - 2];
        } else {
          prevPosition = morphVectorScratch;
          Cartesian3_default.subtract(positions[0], positions[1], prevPosition);
          Cartesian3_default.add(positions[0], prevPosition, prevPosition);
        }
      } else {
        prevPosition = positions[j - 1];
      }
      prevPosition = Matrix4_default.multiplyByPoint(
        modelMatrix,
        prevPosition,
        morphPrevPositionScratch
      );
      const position = Matrix4_default.multiplyByPoint(
        modelMatrix,
        positions[j],
        morphPositionScratch
      );
      let nextPosition;
      if (j === positionsLength - 1) {
        if (polyline._loop) {
          nextPosition = positions[1];
        } else {
          nextPosition = morphVectorScratch;
          Cartesian3_default.subtract(
            positions[positionsLength - 1],
            positions[positionsLength - 2],
            nextPosition
          );
          Cartesian3_default.add(
            positions[positionsLength - 1],
            nextPosition,
            nextPosition
          );
        }
      } else {
        nextPosition = positions[j + 1];
      }
      nextPosition = Matrix4_default.multiplyByPoint(
        modelMatrix,
        nextPosition,
        morphNextPositionScratch
      );
      const segmentLength = lengths[segmentIndex];
      if (j === count + segmentLength) {
        count += segmentLength;
        ++segmentIndex;
      }
      const segmentStart = j - count === 0;
      const segmentEnd = j === count + lengths[segmentIndex] - 1;
      const startK = segmentStart ? 2 : 0;
      const endK = segmentEnd ? 2 : 4;
      for (let k = startK; k < endK; ++k) {
        EncodedCartesian3_default.writeElements(position, positionArray, positionIndex);
        EncodedCartesian3_default.writeElements(
          prevPosition,
          positionArray,
          positionIndex + 6
        );
        EncodedCartesian3_default.writeElements(
          nextPosition,
          positionArray,
          positionIndex + 12
        );
        positionIndex += 6 * 3;
      }
    }
  }
};
var scratchSegmentLengths = new Array(1);
PolylineBucket.prototype.updateIndices = function(totalIndices, vertexBufferOffset, vertexArrayBuckets, offset2) {
  let vaCount = vertexArrayBuckets.length - 1;
  let bucketLocator = new VertexArrayBucketLocator(0, offset2, this);
  vertexArrayBuckets[vaCount].push(bucketLocator);
  let count = 0;
  let indices2 = totalIndices[totalIndices.length - 1];
  let indicesCount = 0;
  if (indices2.length > 0) {
    indicesCount = indices2[indices2.length - 1] + 1;
  }
  const polylines = this.polylines;
  const length3 = polylines.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const polyline = polylines[i2];
    polyline._locatorBuckets = [];
    let segments;
    if (this.mode === SceneMode_default.SCENE3D) {
      segments = scratchSegmentLengths;
      const positionsLength = polyline._actualPositions.length;
      if (positionsLength > 0) {
        segments[0] = positionsLength;
      } else {
        continue;
      }
    } else {
      segments = polyline._segments.lengths;
    }
    const numberOfSegments = segments.length;
    if (numberOfSegments > 0) {
      let segmentIndexCount = 0;
      for (let j = 0; j < numberOfSegments; ++j) {
        const segmentLength = segments[j] - 1;
        for (let k = 0; k < segmentLength; ++k) {
          if (indicesCount + 4 > Math_default.SIXTY_FOUR_KILOBYTES) {
            polyline._locatorBuckets.push({
              locator: bucketLocator,
              count: segmentIndexCount
            });
            segmentIndexCount = 0;
            vertexBufferOffset.push(4);
            indices2 = [];
            totalIndices.push(indices2);
            indicesCount = 0;
            bucketLocator.count = count;
            count = 0;
            offset2 = 0;
            bucketLocator = new VertexArrayBucketLocator(0, 0, this);
            vertexArrayBuckets[++vaCount] = [bucketLocator];
          }
          indices2.push(indicesCount, indicesCount + 2, indicesCount + 1);
          indices2.push(indicesCount + 1, indicesCount + 2, indicesCount + 3);
          segmentIndexCount += 6;
          count += 6;
          offset2 += 6;
          indicesCount += 4;
        }
      }
      polyline._locatorBuckets.push({
        locator: bucketLocator,
        count: segmentIndexCount
      });
      if (indicesCount + 4 > Math_default.SIXTY_FOUR_KILOBYTES) {
        vertexBufferOffset.push(0);
        indices2 = [];
        totalIndices.push(indices2);
        indicesCount = 0;
        bucketLocator.count = count;
        offset2 = 0;
        count = 0;
        bucketLocator = new VertexArrayBucketLocator(0, 0, this);
        vertexArrayBuckets[++vaCount] = [bucketLocator];
      }
    }
    polyline._clean();
  }
  bucketLocator.count = count;
  return offset2;
};
PolylineBucket.prototype.getPolylineStartIndex = function(polyline) {
  const polylines = this.polylines;
  let positionIndex = 0;
  const length3 = polylines.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const p2 = polylines[i2];
    if (p2 === polyline) {
      break;
    }
    positionIndex += p2._actualLength;
  }
  return positionIndex;
};
var scratchSegments = {
  positions: void 0,
  lengths: void 0
};
var scratchLengths = new Array(1);
var pscratch = new Cartesian3_default();
var scratchCartographic8 = new Cartographic_default();
PolylineBucket.prototype.getSegments = function(polyline, projection) {
  let positions = polyline._actualPositions;
  if (this.mode === SceneMode_default.SCENE3D) {
    scratchLengths[0] = positions.length;
    scratchSegments.positions = positions;
    scratchSegments.lengths = scratchLengths;
    return scratchSegments;
  }
  if (intersectsIDL(polyline)) {
    positions = polyline._segments.positions;
  }
  const ellipsoid = projection.ellipsoid;
  const newPositions = [];
  const modelMatrix = this.modelMatrix;
  const length3 = positions.length;
  let position;
  let p2 = pscratch;
  for (let n2 = 0; n2 < length3; ++n2) {
    position = positions[n2];
    p2 = Matrix4_default.multiplyByPoint(modelMatrix, position, p2);
    newPositions.push(
      projection.project(
        ellipsoid.cartesianToCartographic(p2, scratchCartographic8)
      )
    );
  }
  if (newPositions.length > 0) {
    polyline._boundingVolume2D = BoundingSphere_default.fromPoints(
      newPositions,
      polyline._boundingVolume2D
    );
    const center2D = polyline._boundingVolume2D.center;
    polyline._boundingVolume2D.center = new Cartesian3_default(
      center2D.z,
      center2D.x,
      center2D.y
    );
  }
  scratchSegments.positions = newPositions;
  scratchSegments.lengths = polyline._segments.lengths;
  return scratchSegments;
};
var scratchPositionsArray;
PolylineBucket.prototype.writeUpdate = function(index2, polyline, positionBuffer, projection) {
  const mode2 = this.mode;
  const maxLon = projection.ellipsoid.maximumRadius * Math_default.PI;
  let positionsLength = polyline._actualLength;
  if (positionsLength) {
    index2 += this.getPolylineStartIndex(polyline);
    let positionArray = scratchPositionsArray;
    const positionsArrayLength = 6 * positionsLength * 3;
    if (!defined_default(positionArray) || positionArray.length < positionsArrayLength) {
      positionArray = scratchPositionsArray = new Float32Array(
        positionsArrayLength
      );
    } else if (positionArray.length > positionsArrayLength) {
      positionArray = new Float32Array(
        positionArray.buffer,
        0,
        positionsArrayLength
      );
    }
    const segments = this.getSegments(polyline, projection);
    const positions = segments.positions;
    const lengths = segments.lengths;
    let positionIndex = 0;
    let segmentIndex = 0;
    let count = 0;
    let position;
    positionsLength = positions.length;
    for (let i2 = 0; i2 < positionsLength; ++i2) {
      if (i2 === 0) {
        if (polyline._loop) {
          position = positions[positionsLength - 2];
        } else {
          position = scratchWriteVector;
          Cartesian3_default.subtract(positions[0], positions[1], position);
          Cartesian3_default.add(positions[0], position, position);
        }
      } else {
        position = positions[i2 - 1];
      }
      Cartesian3_default.clone(position, scratchWritePrevPosition);
      Cartesian3_default.clone(positions[i2], scratchWritePosition);
      if (i2 === positionsLength - 1) {
        if (polyline._loop) {
          position = positions[1];
        } else {
          position = scratchWriteVector;
          Cartesian3_default.subtract(
            positions[positionsLength - 1],
            positions[positionsLength - 2],
            position
          );
          Cartesian3_default.add(positions[positionsLength - 1], position, position);
        }
      } else {
        position = positions[i2 + 1];
      }
      Cartesian3_default.clone(position, scratchWriteNextPosition);
      const segmentLength = lengths[segmentIndex];
      if (i2 === count + segmentLength) {
        count += segmentLength;
        ++segmentIndex;
      }
      const segmentStart = i2 - count === 0;
      const segmentEnd = i2 === count + lengths[segmentIndex] - 1;
      if (mode2 === SceneMode_default.SCENE2D) {
        scratchWritePrevPosition.z = 0;
        scratchWritePosition.z = 0;
        scratchWriteNextPosition.z = 0;
      }
      if (mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.MORPHING) {
        if ((segmentStart || segmentEnd) && maxLon - Math.abs(scratchWritePosition.x) < 1) {
          if (scratchWritePosition.x < 0 && scratchWritePrevPosition.x > 0 || scratchWritePosition.x > 0 && scratchWritePrevPosition.x < 0) {
            Cartesian3_default.clone(scratchWritePosition, scratchWritePrevPosition);
          }
          if (scratchWritePosition.x < 0 && scratchWriteNextPosition.x > 0 || scratchWritePosition.x > 0 && scratchWriteNextPosition.x < 0) {
            Cartesian3_default.clone(scratchWritePosition, scratchWriteNextPosition);
          }
        }
      }
      const startJ = segmentStart ? 2 : 0;
      const endJ = segmentEnd ? 2 : 4;
      for (let j = startJ; j < endJ; ++j) {
        EncodedCartesian3_default.writeElements(
          scratchWritePosition,
          positionArray,
          positionIndex
        );
        EncodedCartesian3_default.writeElements(
          scratchWritePrevPosition,
          positionArray,
          positionIndex + 6
        );
        EncodedCartesian3_default.writeElements(
          scratchWriteNextPosition,
          positionArray,
          positionIndex + 12
        );
        positionIndex += 6 * 3;
      }
    }
    positionBuffer.copyFromArrayView(
      positionArray,
      6 * 3 * Float32Array.BYTES_PER_ELEMENT * index2
    );
  }
};
var PolylineCollection_default = PolylineCollection;

// node_modules/cesium/Source/Scene/Vector3DTilePoints.js
function Vector3DTilePoints(options) {
  this._positions = options.positions;
  this._batchTable = options.batchTable;
  this._batchIds = options.batchIds;
  this._rectangle = options.rectangle;
  this._minHeight = options.minimumHeight;
  this._maxHeight = options.maximumHeight;
  this._billboardCollection = void 0;
  this._labelCollection = void 0;
  this._polylineCollection = void 0;
  this._verticesPromise = void 0;
  this._packedBuffer = void 0;
  this._ready = false;
  this._readyPromise = defer_default();
  this._resolvedPromise = false;
}
Object.defineProperties(Vector3DTilePoints.prototype, {
  pointsLength: {
    get: function() {
      return this._billboardCollection.length;
    }
  },
  texturesByteLength: {
    get: function() {
      const billboardSize = this._billboardCollection.textureAtlas.texture.sizeInBytes;
      const labelSize = this._labelCollection._textureAtlas.texture.sizeInBytes;
      return billboardSize + labelSize;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  }
});
function packBuffer2(points, ellipsoid) {
  const rectangle = points._rectangle;
  const minimumHeight = points._minHeight;
  const maximumHeight = points._maxHeight;
  const packedLength = 2 + Rectangle_default.packedLength + Ellipsoid_default.packedLength;
  const packedBuffer = new Float64Array(packedLength);
  let offset2 = 0;
  packedBuffer[offset2++] = minimumHeight;
  packedBuffer[offset2++] = maximumHeight;
  Rectangle_default.pack(rectangle, packedBuffer, offset2);
  offset2 += Rectangle_default.packedLength;
  Ellipsoid_default.pack(ellipsoid, packedBuffer, offset2);
  return packedBuffer;
}
var createVerticesTaskProcessor2 = new TaskProcessor_default(
  "createVectorTilePoints",
  5
);
var scratchPosition10 = new Cartesian3_default();
function createPoints(points, ellipsoid) {
  if (defined_default(points._billboardCollection)) {
    return;
  }
  let positions;
  if (!defined_default(points._verticesPromise)) {
    positions = points._positions;
    let packedBuffer = points._packedBuffer;
    if (!defined_default(packedBuffer)) {
      positions = points._positions = arraySlice_default(positions);
      points._batchIds = arraySlice_default(points._batchIds);
      packedBuffer = points._packedBuffer = packBuffer2(points, ellipsoid);
    }
    const transferrableObjects = [positions.buffer, packedBuffer.buffer];
    const parameters = {
      positions: positions.buffer,
      packedBuffer: packedBuffer.buffer
    };
    const verticesPromise = points._verticesPromise = createVerticesTaskProcessor2.scheduleTask(
      parameters,
      transferrableObjects
    );
    if (!defined_default(verticesPromise)) {
      return;
    }
    verticesPromise.then(function(result) {
      points._positions = new Float64Array(result.positions);
      points._ready = true;
    });
  }
  if (points._ready && !defined_default(points._billboardCollection)) {
    positions = points._positions;
    const batchTable = points._batchTable;
    const batchIds = points._batchIds;
    const billboardCollection = points._billboardCollection = new BillboardCollection_default(
      { batchTable }
    );
    const labelCollection = points._labelCollection = new LabelCollection_default({
      batchTable
    });
    const polylineCollection = points._polylineCollection = new PolylineCollection_default();
    polylineCollection._useHighlightColor = true;
    const numberOfPoints = positions.length / 3;
    for (let i2 = 0; i2 < numberOfPoints; ++i2) {
      const id = batchIds[i2];
      const position = Cartesian3_default.unpack(positions, i2 * 3, scratchPosition10);
      const b = billboardCollection.add();
      b.position = position;
      b._batchIndex = id;
      const l2 = labelCollection.add();
      l2.text = " ";
      l2.position = position;
      l2._batchIndex = id;
      const p2 = polylineCollection.add();
      p2.positions = [Cartesian3_default.clone(position), Cartesian3_default.clone(position)];
    }
    points._positions = void 0;
    points._packedBuffer = void 0;
  }
}
Vector3DTilePoints.prototype.createFeatures = function(content, features) {
  const billboardCollection = this._billboardCollection;
  const labelCollection = this._labelCollection;
  const polylineCollection = this._polylineCollection;
  const batchIds = this._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    const billboard = billboardCollection.get(i2);
    const label = labelCollection.get(i2);
    const polyline = polylineCollection.get(i2);
    features[batchId] = new Cesium3DTilePointFeature_default(
      content,
      batchId,
      billboard,
      label,
      polyline
    );
  }
};
Vector3DTilePoints.prototype.applyDebugSettings = function(enabled, color) {
  if (enabled) {
    Color_default.clone(color, this._billboardCollection._highlightColor);
    Color_default.clone(color, this._labelCollection._highlightColor);
    Color_default.clone(color, this._polylineCollection._highlightColor);
  } else {
    Color_default.clone(Color_default.WHITE, this._billboardCollection._highlightColor);
    Color_default.clone(Color_default.WHITE, this._labelCollection._highlightColor);
    Color_default.clone(Color_default.WHITE, this._polylineCollection._highlightColor);
  }
};
function clearStyle2(polygons, features) {
  const batchIds = polygons._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    const feature2 = features[batchId];
    feature2.show = true;
    feature2.pointSize = Cesium3DTilePointFeature_default.defaultPointSize;
    feature2.color = Cesium3DTilePointFeature_default.defaultColor;
    feature2.pointOutlineColor = Cesium3DTilePointFeature_default.defaultPointOutlineColor;
    feature2.pointOutlineWidth = Cesium3DTilePointFeature_default.defaultPointOutlineWidth;
    feature2.labelColor = Color_default.WHITE;
    feature2.labelOutlineColor = Color_default.WHITE;
    feature2.labelOutlineWidth = 1;
    feature2.font = "30px sans-serif";
    feature2.labelStyle = LabelStyle_default.FILL;
    feature2.labelText = void 0;
    feature2.backgroundColor = new Color_default(0.165, 0.165, 0.165, 0.8);
    feature2.backgroundPadding = new Cartesian2_default(7, 5);
    feature2.backgroundEnabled = false;
    feature2.scaleByDistance = void 0;
    feature2.translucencyByDistance = void 0;
    feature2.distanceDisplayCondition = void 0;
    feature2.heightOffset = 0;
    feature2.anchorLineEnabled = false;
    feature2.anchorLineColor = Color_default.WHITE;
    feature2.image = void 0;
    feature2.disableDepthTestDistance = 0;
    feature2.horizontalOrigin = HorizontalOrigin_default.CENTER;
    feature2.verticalOrigin = VerticalOrigin_default.CENTER;
    feature2.labelHorizontalOrigin = HorizontalOrigin_default.RIGHT;
    feature2.labelVerticalOrigin = VerticalOrigin_default.BASELINE;
  }
}
var scratchColor7 = new Color_default();
var scratchColor22 = new Color_default();
var scratchColor32 = new Color_default();
var scratchColor42 = new Color_default();
var scratchColor52 = new Color_default();
var scratchColor62 = new Color_default();
var scratchScaleByDistance = new NearFarScalar_default();
var scratchTranslucencyByDistance = new NearFarScalar_default();
var scratchDistanceDisplayCondition = new DistanceDisplayCondition_default();
Vector3DTilePoints.prototype.applyStyle = function(style, features) {
  if (!defined_default(style)) {
    clearStyle2(this, features);
    return;
  }
  const batchIds = this._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    const feature2 = features[batchId];
    if (defined_default(style.show)) {
      feature2.show = style.show.evaluate(feature2);
    }
    if (defined_default(style.pointSize)) {
      feature2.pointSize = style.pointSize.evaluate(feature2);
    }
    if (defined_default(style.color)) {
      feature2.color = style.color.evaluateColor(feature2, scratchColor7);
    }
    if (defined_default(style.pointOutlineColor)) {
      feature2.pointOutlineColor = style.pointOutlineColor.evaluateColor(
        feature2,
        scratchColor22
      );
    }
    if (defined_default(style.pointOutlineWidth)) {
      feature2.pointOutlineWidth = style.pointOutlineWidth.evaluate(feature2);
    }
    if (defined_default(style.labelColor)) {
      feature2.labelColor = style.labelColor.evaluateColor(
        feature2,
        scratchColor32
      );
    }
    if (defined_default(style.labelOutlineColor)) {
      feature2.labelOutlineColor = style.labelOutlineColor.evaluateColor(
        feature2,
        scratchColor42
      );
    }
    if (defined_default(style.labelOutlineWidth)) {
      feature2.labelOutlineWidth = style.labelOutlineWidth.evaluate(feature2);
    }
    if (defined_default(style.font)) {
      feature2.font = style.font.evaluate(feature2);
    }
    if (defined_default(style.labelStyle)) {
      feature2.labelStyle = style.labelStyle.evaluate(feature2);
    }
    if (defined_default(style.labelText)) {
      feature2.labelText = style.labelText.evaluate(feature2);
    } else {
      feature2.labelText = void 0;
    }
    if (defined_default(style.backgroundColor)) {
      feature2.backgroundColor = style.backgroundColor.evaluateColor(
        feature2,
        scratchColor52
      );
    }
    if (defined_default(style.backgroundPadding)) {
      feature2.backgroundPadding = style.backgroundPadding.evaluate(feature2);
    }
    if (defined_default(style.backgroundEnabled)) {
      feature2.backgroundEnabled = style.backgroundEnabled.evaluate(feature2);
    }
    if (defined_default(style.scaleByDistance)) {
      const scaleByDistanceCart4 = style.scaleByDistance.evaluate(feature2);
      scratchScaleByDistance.near = scaleByDistanceCart4.x;
      scratchScaleByDistance.nearValue = scaleByDistanceCart4.y;
      scratchScaleByDistance.far = scaleByDistanceCart4.z;
      scratchScaleByDistance.farValue = scaleByDistanceCart4.w;
      feature2.scaleByDistance = scratchScaleByDistance;
    } else {
      feature2.scaleByDistance = void 0;
    }
    if (defined_default(style.translucencyByDistance)) {
      const translucencyByDistanceCart4 = style.translucencyByDistance.evaluate(
        feature2
      );
      scratchTranslucencyByDistance.near = translucencyByDistanceCart4.x;
      scratchTranslucencyByDistance.nearValue = translucencyByDistanceCart4.y;
      scratchTranslucencyByDistance.far = translucencyByDistanceCart4.z;
      scratchTranslucencyByDistance.farValue = translucencyByDistanceCart4.w;
      feature2.translucencyByDistance = scratchTranslucencyByDistance;
    } else {
      feature2.translucencyByDistance = void 0;
    }
    if (defined_default(style.distanceDisplayCondition)) {
      const distanceDisplayConditionCart2 = style.distanceDisplayCondition.evaluate(
        feature2
      );
      scratchDistanceDisplayCondition.near = distanceDisplayConditionCart2.x;
      scratchDistanceDisplayCondition.far = distanceDisplayConditionCart2.y;
      feature2.distanceDisplayCondition = scratchDistanceDisplayCondition;
    } else {
      feature2.distanceDisplayCondition = void 0;
    }
    if (defined_default(style.heightOffset)) {
      feature2.heightOffset = style.heightOffset.evaluate(feature2);
    }
    if (defined_default(style.anchorLineEnabled)) {
      feature2.anchorLineEnabled = style.anchorLineEnabled.evaluate(feature2);
    }
    if (defined_default(style.anchorLineColor)) {
      feature2.anchorLineColor = style.anchorLineColor.evaluateColor(
        feature2,
        scratchColor62
      );
    }
    if (defined_default(style.image)) {
      feature2.image = style.image.evaluate(feature2);
    } else {
      feature2.image = void 0;
    }
    if (defined_default(style.disableDepthTestDistance)) {
      feature2.disableDepthTestDistance = style.disableDepthTestDistance.evaluate(
        feature2
      );
    }
    if (defined_default(style.horizontalOrigin)) {
      feature2.horizontalOrigin = style.horizontalOrigin.evaluate(feature2);
    }
    if (defined_default(style.verticalOrigin)) {
      feature2.verticalOrigin = style.verticalOrigin.evaluate(feature2);
    }
    if (defined_default(style.labelHorizontalOrigin)) {
      feature2.labelHorizontalOrigin = style.labelHorizontalOrigin.evaluate(
        feature2
      );
    }
    if (defined_default(style.labelVerticalOrigin)) {
      feature2.labelVerticalOrigin = style.labelVerticalOrigin.evaluate(feature2);
    }
  }
};
Vector3DTilePoints.prototype.update = function(frameState) {
  createPoints(this, frameState.mapProjection.ellipsoid);
  if (!this._ready) {
    return;
  }
  this._polylineCollection.update(frameState);
  this._billboardCollection.update(frameState);
  this._labelCollection.update(frameState);
  if (!this._resolvedPromise) {
    this._readyPromise.resolve();
    this._resolvedPromise = true;
  }
};
Vector3DTilePoints.prototype.isDestroyed = function() {
  return false;
};
Vector3DTilePoints.prototype.destroy = function() {
  this._billboardCollection = this._billboardCollection && this._billboardCollection.destroy();
  this._labelCollection = this._labelCollection && this._labelCollection.destroy();
  this._polylineCollection = this._polylineCollection && this._polylineCollection.destroy();
  return destroyObject_default(this);
};
var Vector3DTilePoints_default = Vector3DTilePoints;

// node_modules/cesium/Source/Scene/Vector3DTilePolygons.js
function Vector3DTilePolygons(options) {
  this._batchTable = options.batchTable;
  this._batchIds = options.batchIds;
  this._positions = options.positions;
  this._counts = options.counts;
  this._indices = options.indices;
  this._indexCounts = options.indexCounts;
  this._indexOffsets = void 0;
  this._batchTableColors = void 0;
  this._packedBuffer = void 0;
  this._batchedPositions = void 0;
  this._transferrableBatchIds = void 0;
  this._vertexBatchIds = void 0;
  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._minimumHeight = options.minimumHeight;
  this._maximumHeight = options.maximumHeight;
  this._polygonMinimumHeights = options.polygonMinimumHeights;
  this._polygonMaximumHeights = options.polygonMaximumHeights;
  this._center = defaultValue_default(options.center, Cartesian3_default.ZERO);
  this._rectangle = options.rectangle;
  this._center = void 0;
  this._boundingVolume = options.boundingVolume;
  this._boundingVolumes = void 0;
  this._batchedIndices = void 0;
  this._ready = false;
  this._readyPromise = defer_default();
  this._verticesPromise = void 0;
  this._primitive = void 0;
  this.debugWireframe = false;
  this.forceRebatch = false;
  this.classificationType = ClassificationType_default.BOTH;
}
Object.defineProperties(Vector3DTilePolygons.prototype, {
  trianglesLength: {
    get: function() {
      if (defined_default(this._primitive)) {
        return this._primitive.trianglesLength;
      }
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      if (defined_default(this._primitive)) {
        return this._primitive.geometryByteLength;
      }
      return 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  }
});
function packBuffer3(polygons) {
  const packedBuffer = new Float64Array(
    3 + Cartesian3_default.packedLength + Ellipsoid_default.packedLength + Rectangle_default.packedLength
  );
  let offset2 = 0;
  packedBuffer[offset2++] = polygons._indices.BYTES_PER_ELEMENT;
  packedBuffer[offset2++] = polygons._minimumHeight;
  packedBuffer[offset2++] = polygons._maximumHeight;
  Cartesian3_default.pack(polygons._center, packedBuffer, offset2);
  offset2 += Cartesian3_default.packedLength;
  Ellipsoid_default.pack(polygons._ellipsoid, packedBuffer, offset2);
  offset2 += Ellipsoid_default.packedLength;
  Rectangle_default.pack(polygons._rectangle, packedBuffer, offset2);
  return packedBuffer;
}
function unpackBuffer2(polygons, packedBuffer) {
  let offset2 = 1;
  const numBVS = packedBuffer[offset2++];
  const bvs = polygons._boundingVolumes = new Array(numBVS);
  for (let i2 = 0; i2 < numBVS; ++i2) {
    bvs[i2] = OrientedBoundingBox_default.unpack(packedBuffer, offset2);
    offset2 += OrientedBoundingBox_default.packedLength;
  }
  const numBatchedIndices = packedBuffer[offset2++];
  const bis = polygons._batchedIndices = new Array(numBatchedIndices);
  for (let j = 0; j < numBatchedIndices; ++j) {
    const color = Color_default.unpack(packedBuffer, offset2);
    offset2 += Color_default.packedLength;
    const indexOffset = packedBuffer[offset2++];
    const count = packedBuffer[offset2++];
    const length3 = packedBuffer[offset2++];
    const batchIds = new Array(length3);
    for (let k = 0; k < length3; ++k) {
      batchIds[k] = packedBuffer[offset2++];
    }
    bis[j] = new Vector3DTileBatch_default({
      color,
      offset: indexOffset,
      count,
      batchIds
    });
  }
}
var createVerticesTaskProcessor3 = new TaskProcessor_default(
  "createVectorTilePolygons",
  5
);
var scratchColor8 = new Color_default();
function createPrimitive3(polygons) {
  if (defined_default(polygons._primitive)) {
    return;
  }
  if (!defined_default(polygons._verticesPromise)) {
    let positions = polygons._positions;
    let counts = polygons._counts;
    let indexCounts = polygons._indexCounts;
    let indices2 = polygons._indices;
    let batchIds = polygons._transferrableBatchIds;
    let batchTableColors = polygons._batchTableColors;
    let packedBuffer = polygons._packedBuffer;
    if (!defined_default(batchTableColors)) {
      positions = polygons._positions = arraySlice_default(polygons._positions);
      counts = polygons._counts = arraySlice_default(polygons._counts);
      indexCounts = polygons._indexCounts = arraySlice_default(polygons._indexCounts);
      indices2 = polygons._indices = arraySlice_default(polygons._indices);
      polygons._center = polygons._ellipsoid.cartographicToCartesian(
        Rectangle_default.center(polygons._rectangle)
      );
      batchIds = polygons._transferrableBatchIds = new Uint32Array(
        polygons._batchIds
      );
      batchTableColors = polygons._batchTableColors = new Uint32Array(
        batchIds.length
      );
      const batchTable = polygons._batchTable;
      const length3 = batchTableColors.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        const color = batchTable.getColor(i2, scratchColor8);
        batchTableColors[i2] = color.toRgba();
      }
      packedBuffer = polygons._packedBuffer = packBuffer3(polygons);
    }
    const transferrableObjects = [
      positions.buffer,
      counts.buffer,
      indexCounts.buffer,
      indices2.buffer,
      batchIds.buffer,
      batchTableColors.buffer,
      packedBuffer.buffer
    ];
    const parameters = {
      packedBuffer: packedBuffer.buffer,
      positions: positions.buffer,
      counts: counts.buffer,
      indexCounts: indexCounts.buffer,
      indices: indices2.buffer,
      batchIds: batchIds.buffer,
      batchTableColors: batchTableColors.buffer
    };
    let minimumHeights = polygons._polygonMinimumHeights;
    let maximumHeights = polygons._polygonMaximumHeights;
    if (defined_default(minimumHeights) && defined_default(maximumHeights)) {
      minimumHeights = arraySlice_default(minimumHeights);
      maximumHeights = arraySlice_default(maximumHeights);
      transferrableObjects.push(minimumHeights.buffer, maximumHeights.buffer);
      parameters.minimumHeights = minimumHeights;
      parameters.maximumHeights = maximumHeights;
    }
    const verticesPromise = polygons._verticesPromise = createVerticesTaskProcessor3.scheduleTask(
      parameters,
      transferrableObjects
    );
    if (!defined_default(verticesPromise)) {
      return;
    }
    verticesPromise.then(function(result) {
      polygons._positions = void 0;
      polygons._counts = void 0;
      polygons._polygonMinimumHeights = void 0;
      polygons._polygonMaximumHeights = void 0;
      const packedBuffer2 = new Float64Array(result.packedBuffer);
      const indexDatatype = packedBuffer2[0];
      unpackBuffer2(polygons, packedBuffer2);
      polygons._indices = IndexDatatype_default.getSizeInBytes(indexDatatype) === 2 ? new Uint16Array(result.indices) : new Uint32Array(result.indices);
      polygons._indexOffsets = new Uint32Array(result.indexOffsets);
      polygons._indexCounts = new Uint32Array(result.indexCounts);
      polygons._batchedPositions = new Float32Array(result.positions);
      polygons._vertexBatchIds = new Uint16Array(result.batchIds);
      polygons._ready = true;
    });
  }
  if (polygons._ready && !defined_default(polygons._primitive)) {
    polygons._primitive = new Vector3DTilePrimitive_default({
      batchTable: polygons._batchTable,
      positions: polygons._batchedPositions,
      batchIds: polygons._batchIds,
      vertexBatchIds: polygons._vertexBatchIds,
      indices: polygons._indices,
      indexOffsets: polygons._indexOffsets,
      indexCounts: polygons._indexCounts,
      batchedIndices: polygons._batchedIndices,
      boundingVolume: polygons._boundingVolume,
      boundingVolumes: polygons._boundingVolumes,
      center: polygons._center
    });
    polygons._batchTable = void 0;
    polygons._batchIds = void 0;
    polygons._positions = void 0;
    polygons._counts = void 0;
    polygons._indices = void 0;
    polygons._indexCounts = void 0;
    polygons._indexOffsets = void 0;
    polygons._batchTableColors = void 0;
    polygons._packedBuffer = void 0;
    polygons._batchedPositions = void 0;
    polygons._transferrableBatchIds = void 0;
    polygons._vertexBatchIds = void 0;
    polygons._ellipsoid = void 0;
    polygons._minimumHeight = void 0;
    polygons._maximumHeight = void 0;
    polygons._polygonMinimumHeights = void 0;
    polygons._polygonMaximumHeights = void 0;
    polygons._center = void 0;
    polygons._rectangle = void 0;
    polygons._boundingVolume = void 0;
    polygons._boundingVolumes = void 0;
    polygons._batchedIndices = void 0;
    polygons._verticesPromise = void 0;
    polygons._readyPromise.resolve();
  }
}
Vector3DTilePolygons.prototype.createFeatures = function(content, features) {
  this._primitive.createFeatures(content, features);
};
Vector3DTilePolygons.prototype.applyDebugSettings = function(enabled, color) {
  this._primitive.applyDebugSettings(enabled, color);
};
Vector3DTilePolygons.prototype.applyStyle = function(style, features) {
  this._primitive.applyStyle(style, features);
};
Vector3DTilePolygons.prototype.updateCommands = function(batchId, color) {
  this._primitive.updateCommands(batchId, color);
};
Vector3DTilePolygons.prototype.update = function(frameState) {
  createPrimitive3(this);
  if (!this._ready) {
    return;
  }
  this._primitive.debugWireframe = this.debugWireframe;
  this._primitive.forceRebatch = this.forceRebatch;
  this._primitive.classificationType = this.classificationType;
  this._primitive.update(frameState);
};
Vector3DTilePolygons.prototype.isDestroyed = function() {
  return false;
};
Vector3DTilePolygons.prototype.destroy = function() {
  this._primitive = this._primitive && this._primitive.destroy();
  return destroyObject_default(this);
};
var Vector3DTilePolygons_default = Vector3DTilePolygons;

// node_modules/cesium/Source/Shaders/Vector3DTilePolylinesVS.js
var Vector3DTilePolylinesVS_default = "attribute vec4 currentPosition;\nattribute vec4 previousPosition;\nattribute vec4 nextPosition;\nattribute vec2 expandAndWidth;\nattribute float a_batchId;\n\nuniform mat4 u_modifiedModelView;\n\nvoid main()\n{\n    float expandDir = expandAndWidth.x;\n    float width = abs(expandAndWidth.y) + 0.5;\n    bool usePrev = expandAndWidth.y < 0.0;\n\n    vec4 p = u_modifiedModelView * currentPosition;\n    vec4 prev = u_modifiedModelView * previousPosition;\n    vec4 next = u_modifiedModelView * nextPosition;\n\n    float angle;\n    vec4 positionWC = getPolylineWindowCoordinatesEC(p, prev, next, expandDir, width, usePrev, angle);\n    gl_Position = czm_viewportOrthographic * positionWC;\n}\n";

// node_modules/cesium/Source/Scene/Vector3DTilePolylines.js
function Vector3DTilePolylines(options) {
  this._positions = options.positions;
  this._widths = options.widths;
  this._counts = options.counts;
  this._batchIds = options.batchIds;
  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._minimumHeight = options.minimumHeight;
  this._maximumHeight = options.maximumHeight;
  this._center = options.center;
  this._rectangle = options.rectangle;
  this._boundingVolume = options.boundingVolume;
  this._batchTable = options.batchTable;
  this._va = void 0;
  this._sp = void 0;
  this._rs = void 0;
  this._uniformMap = void 0;
  this._command = void 0;
  this._transferrableBatchIds = void 0;
  this._packedBuffer = void 0;
  this._keepDecodedPositions = options.keepDecodedPositions;
  this._decodedPositions = void 0;
  this._decodedPositionOffsets = void 0;
  this._currentPositions = void 0;
  this._previousPositions = void 0;
  this._nextPositions = void 0;
  this._expandAndWidth = void 0;
  this._vertexBatchIds = void 0;
  this._indices = void 0;
  this._constantColor = Color_default.clone(Color_default.WHITE);
  this._highlightColor = this._constantColor;
  this._trianglesLength = 0;
  this._geometryByteLength = 0;
  this._ready = false;
  this._readyPromise = defer_default();
  this._verticesPromise = void 0;
}
Object.defineProperties(Vector3DTilePolylines.prototype, {
  trianglesLength: {
    get: function() {
      return this._trianglesLength;
    }
  },
  geometryByteLength: {
    get: function() {
      return this._geometryByteLength;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  }
});
function packBuffer4(polylines) {
  const rectangle = polylines._rectangle;
  const minimumHeight = polylines._minimumHeight;
  const maximumHeight = polylines._maximumHeight;
  const ellipsoid = polylines._ellipsoid;
  const center = polylines._center;
  const packedLength = 2 + Rectangle_default.packedLength + Ellipsoid_default.packedLength + Cartesian3_default.packedLength;
  const packedBuffer = new Float64Array(packedLength);
  let offset2 = 0;
  packedBuffer[offset2++] = minimumHeight;
  packedBuffer[offset2++] = maximumHeight;
  Rectangle_default.pack(rectangle, packedBuffer, offset2);
  offset2 += Rectangle_default.packedLength;
  Ellipsoid_default.pack(ellipsoid, packedBuffer, offset2);
  offset2 += Ellipsoid_default.packedLength;
  Cartesian3_default.pack(center, packedBuffer, offset2);
  return packedBuffer;
}
var createVerticesTaskProcessor4 = new TaskProcessor_default(
  "createVectorTilePolylines",
  5
);
var attributeLocations3 = {
  previousPosition: 0,
  currentPosition: 1,
  nextPosition: 2,
  expandAndWidth: 3,
  a_batchId: 4
};
function createVertexArray5(polylines, context) {
  if (defined_default(polylines._va)) {
    return;
  }
  if (!defined_default(polylines._verticesPromise)) {
    let positions = polylines._positions;
    let widths = polylines._widths;
    let counts = polylines._counts;
    let batchIds = polylines._transferrableBatchIds;
    let packedBuffer = polylines._packedBuffer;
    if (!defined_default(packedBuffer)) {
      positions = polylines._positions = arraySlice_default(positions);
      widths = polylines._widths = arraySlice_default(widths);
      counts = polylines._counts = arraySlice_default(counts);
      batchIds = polylines._transferrableBatchIds = arraySlice_default(
        polylines._batchIds
      );
      packedBuffer = polylines._packedBuffer = packBuffer4(polylines);
    }
    const transferrableObjects = [
      positions.buffer,
      widths.buffer,
      counts.buffer,
      batchIds.buffer,
      packedBuffer.buffer
    ];
    const parameters = {
      positions: positions.buffer,
      widths: widths.buffer,
      counts: counts.buffer,
      batchIds: batchIds.buffer,
      packedBuffer: packedBuffer.buffer,
      keepDecodedPositions: polylines._keepDecodedPositions
    };
    const verticesPromise = polylines._verticesPromise = createVerticesTaskProcessor4.scheduleTask(
      parameters,
      transferrableObjects
    );
    if (!defined_default(verticesPromise)) {
      return;
    }
    verticesPromise.then(function(result) {
      if (polylines._keepDecodedPositions) {
        polylines._decodedPositions = new Float64Array(
          result.decodedPositions
        );
        polylines._decodedPositionOffsets = new Uint32Array(
          result.decodedPositionOffsets
        );
      }
      polylines._currentPositions = new Float32Array(result.currentPositions);
      polylines._previousPositions = new Float32Array(
        result.previousPositions
      );
      polylines._nextPositions = new Float32Array(result.nextPositions);
      polylines._expandAndWidth = new Float32Array(result.expandAndWidth);
      polylines._vertexBatchIds = new Uint16Array(result.batchIds);
      const indexDatatype = result.indexDatatype;
      polylines._indices = indexDatatype === IndexDatatype_default.UNSIGNED_SHORT ? new Uint16Array(result.indices) : new Uint32Array(result.indices);
      polylines._ready = true;
    }).catch(function(error) {
      polylines._readyPromise.reject(error);
    });
  }
  if (polylines._ready && !defined_default(polylines._va)) {
    const curPositions = polylines._currentPositions;
    const prevPositions = polylines._previousPositions;
    const nextPositions = polylines._nextPositions;
    const expandAndWidth = polylines._expandAndWidth;
    const vertexBatchIds = polylines._vertexBatchIds;
    const indices2 = polylines._indices;
    let byteLength = prevPositions.byteLength + curPositions.byteLength + nextPositions.byteLength;
    byteLength += expandAndWidth.byteLength + vertexBatchIds.byteLength + indices2.byteLength;
    polylines._trianglesLength = indices2.length / 3;
    polylines._geometryByteLength = byteLength;
    const prevPositionBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: prevPositions,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const curPositionBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: curPositions,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const nextPositionBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: nextPositions,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const expandAndWidthBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: expandAndWidth,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const idBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: vertexBatchIds,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const indexBuffer = Buffer_default.createIndexBuffer({
      context,
      typedArray: indices2,
      usage: BufferUsage_default.STATIC_DRAW,
      indexDatatype: indices2.BYTES_PER_ELEMENT === 2 ? IndexDatatype_default.UNSIGNED_SHORT : IndexDatatype_default.UNSIGNED_INT
    });
    const vertexAttributes = [
      {
        index: attributeLocations3.previousPosition,
        vertexBuffer: prevPositionBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3
      },
      {
        index: attributeLocations3.currentPosition,
        vertexBuffer: curPositionBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3
      },
      {
        index: attributeLocations3.nextPosition,
        vertexBuffer: nextPositionBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3
      },
      {
        index: attributeLocations3.expandAndWidth,
        vertexBuffer: expandAndWidthBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 2
      },
      {
        index: attributeLocations3.a_batchId,
        vertexBuffer: idBuffer,
        componentDatatype: ComponentDatatype_default.UNSIGNED_SHORT,
        componentsPerAttribute: 1
      }
    ];
    polylines._va = new VertexArray_default({
      context,
      attributes: vertexAttributes,
      indexBuffer
    });
    polylines._positions = void 0;
    polylines._widths = void 0;
    polylines._counts = void 0;
    polylines._ellipsoid = void 0;
    polylines._minimumHeight = void 0;
    polylines._maximumHeight = void 0;
    polylines._rectangle = void 0;
    polylines._transferrableBatchIds = void 0;
    polylines._packedBuffer = void 0;
    polylines._currentPositions = void 0;
    polylines._previousPositions = void 0;
    polylines._nextPositions = void 0;
    polylines._expandAndWidth = void 0;
    polylines._vertexBatchIds = void 0;
    polylines._indices = void 0;
    polylines._readyPromise.resolve();
  }
}
var modifiedModelViewScratch3 = new Matrix4_default();
var rtcScratch3 = new Cartesian3_default();
function createUniformMap4(primitive, context) {
  if (defined_default(primitive._uniformMap)) {
    return;
  }
  primitive._uniformMap = {
    u_modifiedModelView: function() {
      const viewMatrix = context.uniformState.view;
      Matrix4_default.clone(viewMatrix, modifiedModelViewScratch3);
      Matrix4_default.multiplyByPoint(
        modifiedModelViewScratch3,
        primitive._center,
        rtcScratch3
      );
      Matrix4_default.setTranslation(
        modifiedModelViewScratch3,
        rtcScratch3,
        modifiedModelViewScratch3
      );
      return modifiedModelViewScratch3;
    },
    u_highlightColor: function() {
      return primitive._highlightColor;
    }
  };
}
function createRenderStates5(primitive) {
  if (defined_default(primitive._rs)) {
    return;
  }
  const polygonOffset = {
    enabled: true,
    factor: -5,
    units: -5
  };
  primitive._rs = RenderState_default.fromCache({
    blending: BlendingState_default.ALPHA_BLEND,
    depthMask: false,
    depthTest: {
      enabled: true
    },
    polygonOffset
  });
}
var PolylineFS = "uniform vec4 u_highlightColor; \nvoid main()\n{\n    gl_FragColor = u_highlightColor;\n}\n";
function createShaders3(primitive, context) {
  if (defined_default(primitive._sp)) {
    return;
  }
  const batchTable = primitive._batchTable;
  const vsSource = batchTable.getVertexShaderCallback(
    false,
    "a_batchId",
    void 0
  )(Vector3DTilePolylinesVS_default);
  const fsSource = batchTable.getFragmentShaderCallback(
    false,
    void 0,
    false
  )(PolylineFS);
  const vs = new ShaderSource_default({
    defines: [
      "VECTOR_TILE",
      !FeatureDetection_default.isInternetExplorer() ? "CLIP_POLYLINE" : ""
    ],
    sources: [PolylineCommon_default, vsSource]
  });
  const fs = new ShaderSource_default({
    defines: ["VECTOR_TILE"],
    sources: [fsSource]
  });
  primitive._sp = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: vs,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations3
  });
}
function queueCommands2(primitive, frameState) {
  if (!defined_default(primitive._command)) {
    const uniformMap2 = primitive._batchTable.getUniformMapCallback()(
      primitive._uniformMap
    );
    primitive._command = new DrawCommand_default({
      owner: primitive,
      vertexArray: primitive._va,
      renderState: primitive._rs,
      shaderProgram: primitive._sp,
      uniformMap: uniformMap2,
      boundingVolume: primitive._boundingVolume,
      pass: Pass_default.TRANSLUCENT,
      pickId: primitive._batchTable.getPickId()
    });
  }
  frameState.commandList.push(primitive._command);
}
Vector3DTilePolylines.getPolylinePositions = function(polylines, batchId) {
  const batchIds = polylines._batchIds;
  const positions = polylines._decodedPositions;
  const offsets = polylines._decodedPositionOffsets;
  if (!defined_default(batchIds) || !defined_default(positions)) {
    return void 0;
  }
  let i2;
  let j;
  const polylinesLength = batchIds.length;
  let positionsLength = 0;
  let resultCounter = 0;
  for (i2 = 0; i2 < polylinesLength; ++i2) {
    if (batchIds[i2] === batchId) {
      positionsLength += offsets[i2 + 1] - offsets[i2];
    }
  }
  if (positionsLength === 0) {
    return void 0;
  }
  const results = new Float64Array(positionsLength * 3);
  for (i2 = 0; i2 < polylinesLength; ++i2) {
    if (batchIds[i2] === batchId) {
      const offset2 = offsets[i2];
      const count = offsets[i2 + 1] - offset2;
      for (j = 0; j < count; ++j) {
        const decodedOffset = (offset2 + j) * 3;
        results[resultCounter++] = positions[decodedOffset];
        results[resultCounter++] = positions[decodedOffset + 1];
        results[resultCounter++] = positions[decodedOffset + 2];
      }
    }
  }
  return results;
};
Vector3DTilePolylines.prototype.getPositions = function(batchId) {
  return Vector3DTilePolylines.getPolylinePositions(this, batchId);
};
Vector3DTilePolylines.prototype.createFeatures = function(content, features) {
  const batchIds = this._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    features[batchId] = new Cesium3DTileFeature_default(content, batchId);
  }
};
Vector3DTilePolylines.prototype.applyDebugSettings = function(enabled, color) {
  this._highlightColor = enabled ? color : this._constantColor;
};
function clearStyle3(polygons, features) {
  const batchIds = polygons._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    const feature2 = features[batchId];
    feature2.show = true;
    feature2.color = Color_default.WHITE;
  }
}
var scratchColor9 = new Color_default();
var DEFAULT_COLOR_VALUE3 = Color_default.WHITE;
var DEFAULT_SHOW_VALUE3 = true;
Vector3DTilePolylines.prototype.applyStyle = function(style, features) {
  if (!defined_default(style)) {
    clearStyle3(this, features);
    return;
  }
  const batchIds = this._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    const feature2 = features[batchId];
    feature2.color = defined_default(style.color) ? style.color.evaluateColor(feature2, scratchColor9) : DEFAULT_COLOR_VALUE3;
    feature2.show = defined_default(style.show) ? style.show.evaluate(feature2) : DEFAULT_SHOW_VALUE3;
  }
};
Vector3DTilePolylines.prototype.update = function(frameState) {
  const context = frameState.context;
  createVertexArray5(this, context);
  createUniformMap4(this, context);
  createShaders3(this, context);
  createRenderStates5(this);
  if (!this._ready) {
    return;
  }
  const passes = frameState.passes;
  if (passes.render || passes.pick) {
    queueCommands2(this, frameState);
  }
};
Vector3DTilePolylines.prototype.isDestroyed = function() {
  return false;
};
Vector3DTilePolylines.prototype.destroy = function() {
  this._va = this._va && this._va.destroy();
  this._sp = this._sp && this._sp.destroy();
  return destroyObject_default(this);
};
var Vector3DTilePolylines_default = Vector3DTilePolylines;

// node_modules/cesium/Source/Shaders/Vector3DTileClampedPolylinesVS.js
var Vector3DTileClampedPolylinesVS_default = 'attribute vec3 startEllipsoidNormal;\nattribute vec3 endEllipsoidNormal;\nattribute vec4 startPositionAndHeight;\nattribute vec4 endPositionAndHeight;\nattribute vec4 startFaceNormalAndVertexCorner;\nattribute vec4 endFaceNormalAndHalfWidth;\nattribute float a_batchId;\n\nuniform mat4 u_modifiedModelView;\nuniform vec2 u_minimumMaximumVectorHeights;\n\nvarying vec4 v_startPlaneEC;\nvarying vec4 v_endPlaneEC;\nvarying vec4 v_rightPlaneEC;\nvarying float v_halfWidth;\nvarying vec3 v_volumeUpEC;\n\nvoid main()\n{\n    // vertex corner IDs\n    //          3-----------7\n    //         /|   left   /|\n    //        / | 1       / |\n    //       2-----------6  5  end\n    //       | /         | /\n    // start |/  right   |/\n    //       0-----------4\n    //\n    float isEnd = floor(startFaceNormalAndVertexCorner.w * 0.251); // 0 for front, 1 for end\n    float isTop = floor(startFaceNormalAndVertexCorner.w * mix(0.51, 0.19, isEnd)); // 0 for bottom, 1 for top\n\n    vec3 forward = endPositionAndHeight.xyz - startPositionAndHeight.xyz;\n    vec3 right = normalize(cross(forward, startEllipsoidNormal));\n\n    vec4 position = vec4(startPositionAndHeight.xyz, 1.0);\n    position.xyz += forward * isEnd;\n\n    v_volumeUpEC = czm_normal * normalize(cross(right, forward));\n\n    // Push for volume height\n    float offset;\n    vec3 ellipsoidNormal = mix(startEllipsoidNormal, endEllipsoidNormal, isEnd);\n\n    // offset height to create volume\n    offset = mix(startPositionAndHeight.w, endPositionAndHeight.w, isEnd);\n    offset = mix(u_minimumMaximumVectorHeights.y, u_minimumMaximumVectorHeights.x, isTop) - offset;\n    position.xyz += offset * ellipsoidNormal;\n\n    // move from RTC to EC\n    position = u_modifiedModelView * position;\n    right = czm_normal * right;\n\n    // Push for width in a direction that is in the start or end plane and in a plane with right\n    // N = normalEC ("right-facing" direction for push)\n    // R = right\n    // p = angle between N and R\n    // w = distance to push along R if R == N\n    // d = distance to push along N\n    //\n    //   N   R\n    //  {  p| }      * cos(p) = dot(N, R) = w / d\n    //  d  |  |w    * d = w / dot(N, R)\n    //    { | }\n    //       o---------- polyline segment ---->\n    //\n    vec3 scratchNormal = mix(-startFaceNormalAndVertexCorner.xyz, endFaceNormalAndHalfWidth.xyz, isEnd);\n    scratchNormal = cross(scratchNormal, mix(startEllipsoidNormal, endEllipsoidNormal, isEnd));\n    vec3 miterPushNormal = czm_normal * normalize(scratchNormal);\n\n    offset = 2.0 * endFaceNormalAndHalfWidth.w * max(0.0, czm_metersPerPixel(position)); // offset = widthEC\n    offset = offset / dot(miterPushNormal, right);\n    position.xyz += miterPushNormal * (offset * sign(0.5 - mod(startFaceNormalAndVertexCorner.w, 2.0)));\n\n    gl_Position = czm_depthClamp(czm_projection * position);\n\n    position = u_modifiedModelView * vec4(startPositionAndHeight.xyz, 1.0);\n    vec3 startNormalEC = czm_normal * startFaceNormalAndVertexCorner.xyz;\n    v_startPlaneEC = vec4(startNormalEC, -dot(startNormalEC, position.xyz));\n    v_rightPlaneEC = vec4(right, -dot(right, position.xyz));\n\n    position = u_modifiedModelView * vec4(endPositionAndHeight.xyz, 1.0);\n    vec3 endNormalEC = czm_normal * endFaceNormalAndHalfWidth.xyz;\n    v_endPlaneEC = vec4(endNormalEC, -dot(endNormalEC, position.xyz));\n    v_halfWidth = endFaceNormalAndHalfWidth.w;\n}\n';

// node_modules/cesium/Source/Shaders/Vector3DTileClampedPolylinesFS.js
var Vector3DTileClampedPolylinesFS_default = "#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n#endif\n\nvarying vec4 v_startPlaneEC;\nvarying vec4 v_endPlaneEC;\nvarying vec4 v_rightPlaneEC;\nvarying float v_halfWidth;\nvarying vec3 v_volumeUpEC;\n\nuniform vec4 u_highlightColor;\nvoid main()\n{\n    float logDepthOrDepth = czm_branchFreeTernary(czm_sceneMode == czm_sceneMode2D, gl_FragCoord.z, czm_unpackDepth(texture2D(czm_globeDepthTexture, gl_FragCoord.xy / czm_viewport.zw)));\n\n    // Discard for sky\n    if (logDepthOrDepth == 0.0) {\n#ifdef DEBUG_SHOW_VOLUME\n        gl_FragColor = vec4(0.0, 0.0, 1.0, 0.5);\n        return;\n#else // DEBUG_SHOW_VOLUME\n        discard;\n#endif // DEBUG_SHOW_VOLUME\n    }\n\n    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth);\n    eyeCoordinate /= eyeCoordinate.w;\n\n    float halfMaxWidth = v_halfWidth * czm_metersPerPixel(eyeCoordinate);\n\n    // Expand halfMaxWidth if direction to camera is almost perpendicular with the volume's up direction\n    halfMaxWidth += halfMaxWidth * (1.0 - dot(-normalize(eyeCoordinate.xyz), v_volumeUpEC));\n\n    // Check distance of the eye coordinate against the right-facing plane\n    float widthwiseDistance = czm_planeDistance(v_rightPlaneEC, eyeCoordinate.xyz);\n\n    // Check eye coordinate against the mitering planes\n    float distanceFromStart = czm_planeDistance(v_startPlaneEC, eyeCoordinate.xyz);\n    float distanceFromEnd = czm_planeDistance(v_endPlaneEC, eyeCoordinate.xyz);\n\n    if (abs(widthwiseDistance) > halfMaxWidth || distanceFromStart < 0.0 || distanceFromEnd < 0.0) {\n#ifdef DEBUG_SHOW_VOLUME\n        gl_FragColor = vec4(logDepthOrDepth, 0.0, 0.0, 0.5);\n        return;\n#else // DEBUG_SHOW_VOLUME\n        discard;\n#endif // DEBUG_SHOW_VOLUME\n    }\n    gl_FragColor = u_highlightColor;\n\n    czm_writeDepthClamp();\n}\n";

// node_modules/cesium/Source/Scene/Vector3DTileClampedPolylines.js
function Vector3DTileClampedPolylines(options) {
  this._positions = options.positions;
  this._widths = options.widths;
  this._counts = options.counts;
  this._batchIds = options.batchIds;
  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._minimumHeight = options.minimumHeight;
  this._maximumHeight = options.maximumHeight;
  this._center = options.center;
  this._rectangle = options.rectangle;
  this._batchTable = options.batchTable;
  this._va = void 0;
  this._sp = void 0;
  this._rs = void 0;
  this._uniformMap = void 0;
  this._command = void 0;
  this._transferrableBatchIds = void 0;
  this._packedBuffer = void 0;
  this._minimumMaximumVectorHeights = new Cartesian2_default(
    ApproximateTerrainHeights_default._defaultMinTerrainHeight,
    ApproximateTerrainHeights_default._defaultMaxTerrainHeight
  );
  this._boundingVolume = OrientedBoundingBox_default.fromRectangle(
    options.rectangle,
    ApproximateTerrainHeights_default._defaultMinTerrainHeight,
    ApproximateTerrainHeights_default._defaultMaxTerrainHeight,
    this._ellipsoid
  );
  this._classificationType = options.classificationType;
  this._keepDecodedPositions = options.keepDecodedPositions;
  this._decodedPositions = void 0;
  this._decodedPositionOffsets = void 0;
  this._startEllipsoidNormals = void 0;
  this._endEllipsoidNormals = void 0;
  this._startPositionAndHeights = void 0;
  this._startFaceNormalAndVertexCornerIds = void 0;
  this._endPositionAndHeights = void 0;
  this._endFaceNormalAndHalfWidths = void 0;
  this._vertexBatchIds = void 0;
  this._indices = void 0;
  this._constantColor = Color_default.clone(Color_default.WHITE);
  this._highlightColor = this._constantColor;
  this._trianglesLength = 0;
  this._geometryByteLength = 0;
  this._ready = false;
  this._readyPromise = defer_default();
  this._verticesPromise = void 0;
  const that = this;
  ApproximateTerrainHeights_default.initialize().then(function() {
    updateMinimumMaximumHeights(that, that._rectangle, that._ellipsoid);
  }).catch(function(error) {
    this._readyPromise.reject(error);
  });
}
Object.defineProperties(Vector3DTileClampedPolylines.prototype, {
  trianglesLength: {
    get: function() {
      return this._trianglesLength;
    }
  },
  geometryByteLength: {
    get: function() {
      return this._geometryByteLength;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  }
});
function updateMinimumMaximumHeights(polylines, rectangle, ellipsoid) {
  const result = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
    rectangle,
    ellipsoid
  );
  const min3 = result.minimumTerrainHeight;
  const max3 = result.maximumTerrainHeight;
  const minimumMaximumVectorHeights = polylines._minimumMaximumVectorHeights;
  minimumMaximumVectorHeights.x = min3;
  minimumMaximumVectorHeights.y = max3;
  const obb = polylines._boundingVolume;
  const rect = polylines._rectangle;
  OrientedBoundingBox_default.fromRectangle(rect, min3, max3, ellipsoid, obb);
}
function packBuffer5(polylines) {
  const rectangle = polylines._rectangle;
  const minimumHeight = polylines._minimumHeight;
  const maximumHeight = polylines._maximumHeight;
  const ellipsoid = polylines._ellipsoid;
  const center = polylines._center;
  const packedLength = 2 + Rectangle_default.packedLength + Ellipsoid_default.packedLength + Cartesian3_default.packedLength;
  const packedBuffer = new Float64Array(packedLength);
  let offset2 = 0;
  packedBuffer[offset2++] = minimumHeight;
  packedBuffer[offset2++] = maximumHeight;
  Rectangle_default.pack(rectangle, packedBuffer, offset2);
  offset2 += Rectangle_default.packedLength;
  Ellipsoid_default.pack(ellipsoid, packedBuffer, offset2);
  offset2 += Ellipsoid_default.packedLength;
  Cartesian3_default.pack(center, packedBuffer, offset2);
  return packedBuffer;
}
var createVerticesTaskProcessor5 = new TaskProcessor_default(
  "createVectorTileClampedPolylines"
);
var attributeLocations4 = {
  startEllipsoidNormal: 0,
  endEllipsoidNormal: 1,
  startPositionAndHeight: 2,
  endPositionAndHeight: 3,
  startFaceNormalAndVertexCorner: 4,
  endFaceNormalAndHalfWidth: 5,
  a_batchId: 6
};
function createVertexArray6(polylines, context) {
  if (defined_default(polylines._va)) {
    return;
  }
  if (!defined_default(polylines._verticesPromise)) {
    let positions = polylines._positions;
    let widths = polylines._widths;
    let counts = polylines._counts;
    let batchIds = polylines._transferrableBatchIds;
    let packedBuffer = polylines._packedBuffer;
    if (!defined_default(packedBuffer)) {
      positions = polylines._positions = arraySlice_default(positions);
      widths = polylines._widths = arraySlice_default(widths);
      counts = polylines._counts = arraySlice_default(counts);
      batchIds = polylines._transferrableBatchIds = arraySlice_default(
        polylines._batchIds
      );
      packedBuffer = polylines._packedBuffer = packBuffer5(polylines);
    }
    const transferrableObjects = [
      positions.buffer,
      widths.buffer,
      counts.buffer,
      batchIds.buffer,
      packedBuffer.buffer
    ];
    const parameters = {
      positions: positions.buffer,
      widths: widths.buffer,
      counts: counts.buffer,
      batchIds: batchIds.buffer,
      packedBuffer: packedBuffer.buffer,
      keepDecodedPositions: polylines._keepDecodedPositions
    };
    const verticesPromise = polylines._verticesPromise = createVerticesTaskProcessor5.scheduleTask(
      parameters,
      transferrableObjects
    );
    if (!defined_default(verticesPromise)) {
      return;
    }
    Promise.resolve(verticesPromise).then(function(result) {
      if (polylines._keepDecodedPositions) {
        polylines._decodedPositions = new Float64Array(
          result.decodedPositions
        );
        polylines._decodedPositionOffsets = new Uint32Array(
          result.decodedPositionOffsets
        );
      }
      polylines._startEllipsoidNormals = new Float32Array(
        result.startEllipsoidNormals
      );
      polylines._endEllipsoidNormals = new Float32Array(
        result.endEllipsoidNormals
      );
      polylines._startPositionAndHeights = new Float32Array(
        result.startPositionAndHeights
      );
      polylines._startFaceNormalAndVertexCornerIds = new Float32Array(
        result.startFaceNormalAndVertexCornerIds
      );
      polylines._endPositionAndHeights = new Float32Array(
        result.endPositionAndHeights
      );
      polylines._endFaceNormalAndHalfWidths = new Float32Array(
        result.endFaceNormalAndHalfWidths
      );
      polylines._vertexBatchIds = new Uint16Array(result.vertexBatchIds);
      const indexDatatype = result.indexDatatype;
      polylines._indices = indexDatatype === IndexDatatype_default.UNSIGNED_SHORT ? new Uint16Array(result.indices) : new Uint32Array(result.indices);
      polylines._ready = true;
    }).catch(function(error) {
      polylines._readyPromise.reject(error);
    });
  }
  if (polylines._ready && !defined_default(polylines._va)) {
    const startEllipsoidNormals = polylines._startEllipsoidNormals;
    const endEllipsoidNormals = polylines._endEllipsoidNormals;
    const startPositionAndHeights = polylines._startPositionAndHeights;
    const endPositionAndHeights = polylines._endPositionAndHeights;
    const startFaceNormalAndVertexCornerIds = polylines._startFaceNormalAndVertexCornerIds;
    const endFaceNormalAndHalfWidths = polylines._endFaceNormalAndHalfWidths;
    const batchIdAttribute = polylines._vertexBatchIds;
    const indices2 = polylines._indices;
    let byteLength = startEllipsoidNormals.byteLength + endEllipsoidNormals.byteLength;
    byteLength += startPositionAndHeights.byteLength + endPositionAndHeights.byteLength;
    byteLength += startFaceNormalAndVertexCornerIds.byteLength + endFaceNormalAndHalfWidths.byteLength;
    byteLength += batchIdAttribute.byteLength + indices2.byteLength;
    polylines._trianglesLength = indices2.length / 3;
    polylines._geometryByteLength = byteLength;
    const startEllipsoidNormalsBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: startEllipsoidNormals,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const endEllipsoidNormalsBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: endEllipsoidNormals,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const startPositionAndHeightsBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: startPositionAndHeights,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const endPositionAndHeightsBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: endPositionAndHeights,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const startFaceNormalAndVertexCornerIdsBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: startFaceNormalAndVertexCornerIds,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const endFaceNormalAndHalfWidthsBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: endFaceNormalAndHalfWidths,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const batchIdAttributeBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: batchIdAttribute,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const indexBuffer = Buffer_default.createIndexBuffer({
      context,
      typedArray: indices2,
      usage: BufferUsage_default.STATIC_DRAW,
      indexDatatype: indices2.BYTES_PER_ELEMENT === 2 ? IndexDatatype_default.UNSIGNED_SHORT : IndexDatatype_default.UNSIGNED_INT
    });
    const vertexAttributes = [
      {
        index: attributeLocations4.startEllipsoidNormal,
        vertexBuffer: startEllipsoidNormalsBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3
      },
      {
        index: attributeLocations4.endEllipsoidNormal,
        vertexBuffer: endEllipsoidNormalsBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 3
      },
      {
        index: attributeLocations4.startPositionAndHeight,
        vertexBuffer: startPositionAndHeightsBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 4
      },
      {
        index: attributeLocations4.endPositionAndHeight,
        vertexBuffer: endPositionAndHeightsBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 4
      },
      {
        index: attributeLocations4.startFaceNormalAndVertexCorner,
        vertexBuffer: startFaceNormalAndVertexCornerIdsBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 4
      },
      {
        index: attributeLocations4.endFaceNormalAndHalfWidth,
        vertexBuffer: endFaceNormalAndHalfWidthsBuffer,
        componentDatatype: ComponentDatatype_default.FLOAT,
        componentsPerAttribute: 4
      },
      {
        index: attributeLocations4.a_batchId,
        vertexBuffer: batchIdAttributeBuffer,
        componentDatatype: ComponentDatatype_default.UNSIGNED_SHORT,
        componentsPerAttribute: 1
      }
    ];
    polylines._va = new VertexArray_default({
      context,
      attributes: vertexAttributes,
      indexBuffer
    });
    polylines._positions = void 0;
    polylines._widths = void 0;
    polylines._counts = void 0;
    polylines._ellipsoid = void 0;
    polylines._minimumHeight = void 0;
    polylines._maximumHeight = void 0;
    polylines._rectangle = void 0;
    polylines._transferrableBatchIds = void 0;
    polylines._packedBuffer = void 0;
    polylines._startEllipsoidNormals = void 0;
    polylines._endEllipsoidNormals = void 0;
    polylines._startPositionAndHeights = void 0;
    polylines._startFaceNormalAndVertexCornerIds = void 0;
    polylines._endPositionAndHeights = void 0;
    polylines._endFaceNormalAndHalfWidths = void 0;
    polylines._vertexBatchIds = void 0;
    polylines._indices = void 0;
    polylines._readyPromise.resolve();
  }
}
var modifiedModelViewScratch4 = new Matrix4_default();
var rtcScratch4 = new Cartesian3_default();
function createUniformMap5(primitive, context) {
  if (defined_default(primitive._uniformMap)) {
    return;
  }
  primitive._uniformMap = {
    u_modifiedModelView: function() {
      const viewMatrix = context.uniformState.view;
      Matrix4_default.clone(viewMatrix, modifiedModelViewScratch4);
      Matrix4_default.multiplyByPoint(
        modifiedModelViewScratch4,
        primitive._center,
        rtcScratch4
      );
      Matrix4_default.setTranslation(
        modifiedModelViewScratch4,
        rtcScratch4,
        modifiedModelViewScratch4
      );
      return modifiedModelViewScratch4;
    },
    u_highlightColor: function() {
      return primitive._highlightColor;
    },
    u_minimumMaximumVectorHeights: function() {
      return primitive._minimumMaximumVectorHeights;
    }
  };
}
function getRenderState2(mask3DTiles) {
  return RenderState_default.fromCache({
    cull: {
      enabled: true,
      face: CullFace_default.FRONT
    },
    blending: BlendingState_default.PRE_MULTIPLIED_ALPHA_BLEND,
    depthMask: false,
    stencilTest: {
      enabled: mask3DTiles,
      frontFunction: StencilFunction_default.EQUAL,
      frontOperation: {
        fail: StencilOperation_default.KEEP,
        zFail: StencilOperation_default.KEEP,
        zPass: StencilOperation_default.KEEP
      },
      backFunction: StencilFunction_default.EQUAL,
      backOperation: {
        fail: StencilOperation_default.KEEP,
        zFail: StencilOperation_default.KEEP,
        zPass: StencilOperation_default.KEEP
      },
      reference: StencilConstants_default.CESIUM_3D_TILE_MASK,
      mask: StencilConstants_default.CESIUM_3D_TILE_MASK
    }
  });
}
function createRenderStates6(primitive) {
  if (defined_default(primitive._rs)) {
    return;
  }
  primitive._rs = getRenderState2(false);
  primitive._rs3DTiles = getRenderState2(true);
}
function createShaders4(primitive, context) {
  if (defined_default(primitive._sp)) {
    return;
  }
  const batchTable = primitive._batchTable;
  const vsSource = batchTable.getVertexShaderCallback(
    false,
    "a_batchId",
    void 0
  )(Vector3DTileClampedPolylinesVS_default);
  const fsSource = batchTable.getFragmentShaderCallback(
    false,
    void 0,
    true
  )(Vector3DTileClampedPolylinesFS_default);
  const vs = new ShaderSource_default({
    defines: [
      "VECTOR_TILE",
      !FeatureDetection_default.isInternetExplorer() ? "CLIP_POLYLINE" : ""
    ],
    sources: [PolylineCommon_default, vsSource]
  });
  const fs = new ShaderSource_default({
    defines: ["VECTOR_TILE"],
    sources: [fsSource]
  });
  primitive._sp = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: vs,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations4
  });
}
function queueCommands3(primitive, frameState) {
  let command = primitive._command;
  if (!defined_default(primitive._command)) {
    const uniformMap2 = primitive._batchTable.getUniformMapCallback()(
      primitive._uniformMap
    );
    command = primitive._command = new DrawCommand_default({
      owner: primitive,
      vertexArray: primitive._va,
      renderState: primitive._rs,
      shaderProgram: primitive._sp,
      uniformMap: uniformMap2,
      boundingVolume: primitive._boundingVolume,
      pass: Pass_default.TERRAIN_CLASSIFICATION,
      pickId: primitive._batchTable.getPickId()
    });
    const derivedTilesetCommand = DrawCommand_default.shallowClone(
      command,
      command.derivedCommands.tileset
    );
    derivedTilesetCommand.renderState = primitive._rs3DTiles;
    derivedTilesetCommand.pass = Pass_default.CESIUM_3D_TILE_CLASSIFICATION;
    command.derivedCommands.tileset = derivedTilesetCommand;
  }
  const classificationType = primitive._classificationType;
  if (classificationType === ClassificationType_default.TERRAIN || classificationType === ClassificationType_default.BOTH) {
    frameState.commandList.push(command);
  }
  if (classificationType === ClassificationType_default.CESIUM_3D_TILE || classificationType === ClassificationType_default.BOTH) {
    frameState.commandList.push(command.derivedCommands.tileset);
  }
}
Vector3DTileClampedPolylines.prototype.getPositions = function(batchId) {
  return Vector3DTilePolylines_default.getPolylinePositions(this, batchId);
};
Vector3DTileClampedPolylines.prototype.createFeatures = function(content, features) {
  const batchIds = this._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    features[batchId] = new Cesium3DTileFeature_default(content, batchId);
  }
};
Vector3DTileClampedPolylines.prototype.applyDebugSettings = function(enabled, color) {
  this._highlightColor = enabled ? color : this._constantColor;
};
function clearStyle4(polygons, features) {
  const batchIds = polygons._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    const feature2 = features[batchId];
    feature2.show = true;
    feature2.color = Color_default.WHITE;
  }
}
var scratchColor10 = new Color_default();
var DEFAULT_COLOR_VALUE4 = Color_default.WHITE;
var DEFAULT_SHOW_VALUE4 = true;
Vector3DTileClampedPolylines.prototype.applyStyle = function(style, features) {
  if (!defined_default(style)) {
    clearStyle4(this, features);
    return;
  }
  const batchIds = this._batchIds;
  const length3 = batchIds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const batchId = batchIds[i2];
    const feature2 = features[batchId];
    feature2.color = defined_default(style.color) ? style.color.evaluateColor(feature2, scratchColor10) : DEFAULT_COLOR_VALUE4;
    feature2.show = defined_default(style.show) ? style.show.evaluate(feature2) : DEFAULT_SHOW_VALUE4;
  }
};
Vector3DTileClampedPolylines.prototype.update = function(frameState) {
  const context = frameState.context;
  createVertexArray6(this, context);
  createUniformMap5(this, context);
  createShaders4(this, context);
  createRenderStates6(this);
  if (!this._ready) {
    return;
  }
  const passes = frameState.passes;
  if (passes.render || passes.pick) {
    queueCommands3(this, frameState);
  }
};
Vector3DTileClampedPolylines.prototype.isDestroyed = function() {
  return false;
};
Vector3DTileClampedPolylines.prototype.destroy = function() {
  this._va = this._va && this._va.destroy();
  this._sp = this._sp && this._sp.destroy();
  return destroyObject_default(this);
};
var Vector3DTileClampedPolylines_default = Vector3DTileClampedPolylines;

// node_modules/cesium/Source/Scene/Vector3DTileContent.js
function Vector3DTileContent(tileset, tile, resource, arrayBuffer, byteOffset) {
  this._tileset = tileset;
  this._tile = tile;
  this._resource = resource;
  this._polygons = void 0;
  this._polylines = void 0;
  this._points = void 0;
  this._contentReadyPromise = void 0;
  this._readyPromise = defer_default();
  this._metadata = void 0;
  this._batchTable = void 0;
  this._features = void 0;
  this.featurePropertiesDirty = false;
  this._group = void 0;
  initialize12(this, arrayBuffer, byteOffset);
}
Object.defineProperties(Vector3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      return defined_default(this._batchTable) ? this._batchTable.featuresLength : 0;
    }
  },
  pointsLength: {
    get: function() {
      if (defined_default(this._points)) {
        return this._points.pointsLength;
      }
      return 0;
    }
  },
  trianglesLength: {
    get: function() {
      let trianglesLength = 0;
      if (defined_default(this._polygons)) {
        trianglesLength += this._polygons.trianglesLength;
      }
      if (defined_default(this._polylines)) {
        trianglesLength += this._polylines.trianglesLength;
      }
      return trianglesLength;
    }
  },
  geometryByteLength: {
    get: function() {
      let geometryByteLength = 0;
      if (defined_default(this._polygons)) {
        geometryByteLength += this._polygons.geometryByteLength;
      }
      if (defined_default(this._polylines)) {
        geometryByteLength += this._polylines.geometryByteLength;
      }
      return geometryByteLength;
    }
  },
  texturesByteLength: {
    get: function() {
      if (defined_default(this._points)) {
        return this._points.texturesByteLength;
      }
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      return defined_default(this._batchTable) ? this._batchTable.memorySizeInBytes : 0;
    }
  },
  innerContents: {
    get: function() {
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return this._resource.getUrlComponent(true);
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    },
    set: function(value) {
      this._metadata = value;
    }
  },
  batchTable: {
    get: function() {
      return this._batchTable;
    }
  },
  group: {
    get: function() {
      return this._group;
    },
    set: function(value) {
      this._group = value;
    }
  }
});
function createColorChangedCallback3(content) {
  return function(batchId, color) {
    if (defined_default(content._polygons)) {
      content._polygons.updateCommands(batchId, color);
    }
  };
}
function getBatchIds2(featureTableJson, featureTableBinary) {
  let polygonBatchIds;
  let polylineBatchIds;
  let pointBatchIds;
  let i2;
  const numberOfPolygons = defaultValue_default(featureTableJson.POLYGONS_LENGTH, 0);
  const numberOfPolylines = defaultValue_default(featureTableJson.POLYLINES_LENGTH, 0);
  const numberOfPoints = defaultValue_default(featureTableJson.POINTS_LENGTH, 0);
  if (numberOfPolygons > 0 && defined_default(featureTableJson.POLYGON_BATCH_IDS)) {
    const polygonBatchIdsByteOffset = featureTableBinary.byteOffset + featureTableJson.POLYGON_BATCH_IDS.byteOffset;
    polygonBatchIds = new Uint16Array(
      featureTableBinary.buffer,
      polygonBatchIdsByteOffset,
      numberOfPolygons
    );
  }
  if (numberOfPolylines > 0 && defined_default(featureTableJson.POLYLINE_BATCH_IDS)) {
    const polylineBatchIdsByteOffset = featureTableBinary.byteOffset + featureTableJson.POLYLINE_BATCH_IDS.byteOffset;
    polylineBatchIds = new Uint16Array(
      featureTableBinary.buffer,
      polylineBatchIdsByteOffset,
      numberOfPolylines
    );
  }
  if (numberOfPoints > 0 && defined_default(featureTableJson.POINT_BATCH_IDS)) {
    const pointBatchIdsByteOffset = featureTableBinary.byteOffset + featureTableJson.POINT_BATCH_IDS.byteOffset;
    pointBatchIds = new Uint16Array(
      featureTableBinary.buffer,
      pointBatchIdsByteOffset,
      numberOfPoints
    );
  }
  const atLeastOneDefined = defined_default(polygonBatchIds) || defined_default(polylineBatchIds) || defined_default(pointBatchIds);
  const atLeastOneUndefined = numberOfPolygons > 0 && !defined_default(polygonBatchIds) || numberOfPolylines > 0 && !defined_default(polylineBatchIds) || numberOfPoints > 0 && !defined_default(pointBatchIds);
  if (atLeastOneDefined && atLeastOneUndefined) {
    throw new RuntimeError_default(
      "If one group of batch ids is defined, then all batch ids must be defined."
    );
  }
  const allUndefinedBatchIds = !defined_default(polygonBatchIds) && !defined_default(polylineBatchIds) && !defined_default(pointBatchIds);
  if (allUndefinedBatchIds) {
    let id = 0;
    if (!defined_default(polygonBatchIds) && numberOfPolygons > 0) {
      polygonBatchIds = new Uint16Array(numberOfPolygons);
      for (i2 = 0; i2 < numberOfPolygons; ++i2) {
        polygonBatchIds[i2] = id++;
      }
    }
    if (!defined_default(polylineBatchIds) && numberOfPolylines > 0) {
      polylineBatchIds = new Uint16Array(numberOfPolylines);
      for (i2 = 0; i2 < numberOfPolylines; ++i2) {
        polylineBatchIds[i2] = id++;
      }
    }
    if (!defined_default(pointBatchIds) && numberOfPoints > 0) {
      pointBatchIds = new Uint16Array(numberOfPoints);
      for (i2 = 0; i2 < numberOfPoints; ++i2) {
        pointBatchIds[i2] = id++;
      }
    }
  }
  return {
    polygons: polygonBatchIds,
    polylines: polylineBatchIds,
    points: pointBatchIds
  };
}
var sizeOfUint328 = Uint32Array.BYTES_PER_ELEMENT;
function createFloatingPolylines(options) {
  return new Vector3DTilePolylines_default(options);
}
function createClampedPolylines(options) {
  return new Vector3DTileClampedPolylines_default(options);
}
function initialize12(content, arrayBuffer, byteOffset) {
  byteOffset = defaultValue_default(byteOffset, 0);
  const uint8Array = new Uint8Array(arrayBuffer);
  const view = new DataView(arrayBuffer);
  byteOffset += sizeOfUint328;
  const version = view.getUint32(byteOffset, true);
  if (version !== 1) {
    throw new RuntimeError_default(
      `Only Vector tile version 1 is supported.  Version ${version} is not.`
    );
  }
  byteOffset += sizeOfUint328;
  const byteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint328;
  if (byteLength === 0) {
    content._readyPromise.resolve(content);
    return;
  }
  const featureTableJSONByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint328;
  if (featureTableJSONByteLength === 0) {
    throw new RuntimeError_default(
      "Feature table must have a byte length greater than zero"
    );
  }
  const featureTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint328;
  const batchTableJSONByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint328;
  const batchTableBinaryByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint328;
  const indicesByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint328;
  const positionByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint328;
  const polylinePositionByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint328;
  const pointsPositionByteLength = view.getUint32(byteOffset, true);
  byteOffset += sizeOfUint328;
  const featureTableJson = getJsonFromTypedArray_default(
    uint8Array,
    byteOffset,
    featureTableJSONByteLength
  );
  byteOffset += featureTableJSONByteLength;
  const featureTableBinary = new Uint8Array(
    arrayBuffer,
    byteOffset,
    featureTableBinaryByteLength
  );
  byteOffset += featureTableBinaryByteLength;
  let batchTableJson;
  let batchTableBinary;
  if (batchTableJSONByteLength > 0) {
    batchTableJson = getJsonFromTypedArray_default(
      uint8Array,
      byteOffset,
      batchTableJSONByteLength
    );
    byteOffset += batchTableJSONByteLength;
    if (batchTableBinaryByteLength > 0) {
      batchTableBinary = new Uint8Array(
        arrayBuffer,
        byteOffset,
        batchTableBinaryByteLength
      );
      batchTableBinary = new Uint8Array(batchTableBinary);
      byteOffset += batchTableBinaryByteLength;
    }
  }
  const numberOfPolygons = defaultValue_default(featureTableJson.POLYGONS_LENGTH, 0);
  const numberOfPolylines = defaultValue_default(featureTableJson.POLYLINES_LENGTH, 0);
  const numberOfPoints = defaultValue_default(featureTableJson.POINTS_LENGTH, 0);
  const totalPrimitives = numberOfPolygons + numberOfPolylines + numberOfPoints;
  const batchTable = new Cesium3DTileBatchTable_default(
    content,
    totalPrimitives,
    batchTableJson,
    batchTableBinary,
    createColorChangedCallback3(content)
  );
  content._batchTable = batchTable;
  if (totalPrimitives === 0) {
    return;
  }
  const featureTable = new Cesium3DTileFeatureTable_default(
    featureTableJson,
    featureTableBinary
  );
  const region = featureTable.getGlobalProperty("REGION");
  if (!defined_default(region)) {
    throw new RuntimeError_default(
      "Feature table global property: REGION must be defined"
    );
  }
  const rectangle = Rectangle_default.unpack(region);
  const minHeight = region[4];
  const maxHeight = region[5];
  const modelMatrix = content._tile.computedTransform;
  let center = featureTable.getGlobalProperty(
    "RTC_CENTER",
    ComponentDatatype_default.FLOAT,
    3
  );
  if (defined_default(center)) {
    center = Cartesian3_default.unpack(center);
    Matrix4_default.multiplyByPoint(modelMatrix, center, center);
  } else {
    center = Rectangle_default.center(rectangle);
    center.height = Math_default.lerp(minHeight, maxHeight, 0.5);
    center = Ellipsoid_default.WGS84.cartographicToCartesian(center);
  }
  const batchIds = getBatchIds2(featureTableJson, featureTableBinary);
  byteOffset += (4 - byteOffset % 4) % 4;
  if (numberOfPolygons > 0) {
    featureTable.featuresLength = numberOfPolygons;
    const polygonCounts = defaultValue_default(
      featureTable.getPropertyArray(
        "POLYGON_COUNTS",
        ComponentDatatype_default.UNSIGNED_INT,
        1
      ),
      featureTable.getPropertyArray(
        "POLYGON_COUNT",
        ComponentDatatype_default.UNSIGNED_INT,
        1
      )
    );
    if (!defined_default(polygonCounts)) {
      throw new RuntimeError_default(
        "Feature table property: POLYGON_COUNTS must be defined when POLYGONS_LENGTH is greater than 0"
      );
    }
    const polygonIndexCounts = defaultValue_default(
      featureTable.getPropertyArray(
        "POLYGON_INDEX_COUNTS",
        ComponentDatatype_default.UNSIGNED_INT,
        1
      ),
      featureTable.getPropertyArray(
        "POLYGON_INDEX_COUNT",
        ComponentDatatype_default.UNSIGNED_INT,
        1
      )
    );
    if (!defined_default(polygonIndexCounts)) {
      throw new RuntimeError_default(
        "Feature table property: POLYGON_INDEX_COUNTS must be defined when POLYGONS_LENGTH is greater than 0"
      );
    }
    const numPolygonPositions = polygonCounts.reduce(function(total, count) {
      return total + count * 2;
    }, 0);
    const numPolygonIndices = polygonIndexCounts.reduce(
      function(total, count) {
        return total + count;
      },
      0
    );
    const indices2 = new Uint32Array(arrayBuffer, byteOffset, numPolygonIndices);
    byteOffset += indicesByteLength;
    const polygonPositions = new Uint16Array(
      arrayBuffer,
      byteOffset,
      numPolygonPositions
    );
    byteOffset += positionByteLength;
    let polygonMinimumHeights;
    let polygonMaximumHeights;
    if (defined_default(featureTableJson.POLYGON_MINIMUM_HEIGHTS) && defined_default(featureTableJson.POLYGON_MAXIMUM_HEIGHTS)) {
      polygonMinimumHeights = featureTable.getPropertyArray(
        "POLYGON_MINIMUM_HEIGHTS",
        ComponentDatatype_default.FLOAT,
        1
      );
      polygonMaximumHeights = featureTable.getPropertyArray(
        "POLYGON_MAXIMUM_HEIGHTS",
        ComponentDatatype_default.FLOAT,
        1
      );
    }
    content._polygons = new Vector3DTilePolygons_default({
      positions: polygonPositions,
      counts: polygonCounts,
      indexCounts: polygonIndexCounts,
      indices: indices2,
      minimumHeight: minHeight,
      maximumHeight: maxHeight,
      polygonMinimumHeights,
      polygonMaximumHeights,
      center,
      rectangle,
      boundingVolume: content.tile.boundingVolume.boundingVolume,
      batchTable,
      batchIds: batchIds.polygons,
      modelMatrix
    });
  }
  if (numberOfPolylines > 0) {
    featureTable.featuresLength = numberOfPolylines;
    const polylineCounts = defaultValue_default(
      featureTable.getPropertyArray(
        "POLYLINE_COUNTS",
        ComponentDatatype_default.UNSIGNED_INT,
        1
      ),
      featureTable.getPropertyArray(
        "POLYLINE_COUNT",
        ComponentDatatype_default.UNSIGNED_INT,
        1
      )
    );
    if (!defined_default(polylineCounts)) {
      throw new RuntimeError_default(
        "Feature table property: POLYLINE_COUNTS must be defined when POLYLINES_LENGTH is greater than 0"
      );
    }
    let widths = featureTable.getPropertyArray(
      "POLYLINE_WIDTHS",
      ComponentDatatype_default.UNSIGNED_SHORT,
      1
    );
    if (!defined_default(widths)) {
      widths = new Uint16Array(numberOfPolylines);
      for (let i2 = 0; i2 < numberOfPolylines; ++i2) {
        widths[i2] = 2;
      }
    }
    const numPolylinePositions = polylineCounts.reduce(function(total, count) {
      return total + count * 3;
    }, 0);
    const polylinePositions = new Uint16Array(
      arrayBuffer,
      byteOffset,
      numPolylinePositions
    );
    byteOffset += polylinePositionByteLength;
    const tileset = content._tileset;
    const examineVectorLinesFunction = tileset.examineVectorLinesFunction;
    if (defined_default(examineVectorLinesFunction)) {
      const decodedPositions = decodeVectorPolylinePositions_default(
        new Uint16Array(polylinePositions),
        rectangle,
        minHeight,
        maxHeight,
        Ellipsoid_default.WGS84
      );
      examineVectorLines(
        decodedPositions,
        polylineCounts,
        batchIds.polylines,
        batchTable,
        content.url,
        examineVectorLinesFunction
      );
    }
    let createPolylines = createFloatingPolylines;
    if (defined_default(tileset.classificationType)) {
      createPolylines = createClampedPolylines;
    }
    content._polylines = createPolylines({
      positions: polylinePositions,
      widths,
      counts: polylineCounts,
      batchIds: batchIds.polylines,
      minimumHeight: minHeight,
      maximumHeight: maxHeight,
      center,
      rectangle,
      boundingVolume: content.tile.boundingVolume.boundingVolume,
      batchTable,
      classificationType: tileset.classificationType,
      keepDecodedPositions: tileset.vectorKeepDecodedPositions
    });
  }
  if (numberOfPoints > 0) {
    const pointPositions = new Uint16Array(
      arrayBuffer,
      byteOffset,
      numberOfPoints * 3
    );
    byteOffset += pointsPositionByteLength;
    content._points = new Vector3DTilePoints_default({
      positions: pointPositions,
      batchIds: batchIds.points,
      minimumHeight: minHeight,
      maximumHeight: maxHeight,
      rectangle,
      batchTable
    });
  }
}
function createFeatures5(content) {
  const featuresLength = content.featuresLength;
  if (!defined_default(content._features) && featuresLength > 0) {
    const features = new Array(featuresLength);
    if (defined_default(content._polygons)) {
      content._polygons.createFeatures(content, features);
    }
    if (defined_default(content._polylines)) {
      content._polylines.createFeatures(content, features);
    }
    if (defined_default(content._points)) {
      content._points.createFeatures(content, features);
    }
    content._features = features;
  }
}
Vector3DTileContent.prototype.hasProperty = function(batchId, name) {
  return this._batchTable.hasProperty(batchId, name);
};
Vector3DTileContent.prototype.getFeature = function(batchId) {
  const featuresLength = this.featuresLength;
  if (!defined_default(batchId) || batchId < 0 || batchId >= featuresLength) {
    throw new DeveloperError_default(
      `batchId is required and between zero and featuresLength - 1 (${featuresLength - 1}).`
    );
  }
  createFeatures5(this);
  return this._features[batchId];
};
Vector3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
  if (defined_default(this._polygons)) {
    this._polygons.applyDebugSettings(enabled, color);
  }
  if (defined_default(this._polylines)) {
    this._polylines.applyDebugSettings(enabled, color);
  }
  if (defined_default(this._points)) {
    this._points.applyDebugSettings(enabled, color);
  }
};
Vector3DTileContent.prototype.applyStyle = function(style) {
  createFeatures5(this);
  if (defined_default(this._polygons)) {
    this._polygons.applyStyle(style, this._features);
  }
  if (defined_default(this._polylines)) {
    this._polylines.applyStyle(style, this._features);
  }
  if (defined_default(this._points)) {
    this._points.applyStyle(style, this._features);
  }
};
Vector3DTileContent.prototype.update = function(tileset, frameState) {
  let ready = true;
  if (defined_default(this._polygons)) {
    this._polygons.classificationType = this._tileset.classificationType;
    this._polygons.debugWireframe = this._tileset.debugWireframe;
    this._polygons.update(frameState);
    ready = ready && this._polygons._ready;
  }
  if (defined_default(this._polylines)) {
    this._polylines.update(frameState);
    ready = ready && this._polylines._ready;
  }
  if (defined_default(this._points)) {
    this._points.update(frameState);
    ready = ready && this._points._ready;
  }
  if (defined_default(this._batchTable) && ready) {
    this._batchTable.update(tileset, frameState);
  }
  if (!defined_default(this._contentReadyPromise)) {
    const pointsPromise = defined_default(this._points) ? this._points.readyPromise : void 0;
    const polygonPromise = defined_default(this._polygons) ? this._polygons.readyPromise : void 0;
    const polylinePromise = defined_default(this._polylines) ? this._polylines.readyPromise : void 0;
    const that = this;
    this._contentReadyPromise = Promise.all([
      pointsPromise,
      polygonPromise,
      polylinePromise
    ]).then(function() {
      that._readyPromise.resolve(that);
    }).catch(function(error) {
      that._readyPromise.reject(error);
    });
  }
};
Vector3DTileContent.prototype.getPolylinePositions = function(batchId) {
  const polylines = this._polylines;
  if (!defined_default(polylines)) {
    return void 0;
  }
  return polylines.getPositions(batchId);
};
Vector3DTileContent.prototype.isDestroyed = function() {
  return false;
};
Vector3DTileContent.prototype.destroy = function() {
  this._polygons = this._polygons && this._polygons.destroy();
  this._polylines = this._polylines && this._polylines.destroy();
  this._points = this._points && this._points.destroy();
  this._batchTable = this._batchTable && this._batchTable.destroy();
  return destroyObject_default(this);
};
function examineVectorLines(positions, counts, batchIds, batchTable, url2, callback) {
  const countsLength = counts.length;
  let polylineStart = 0;
  for (let i2 = 0; i2 < countsLength; i2++) {
    const count = counts[i2] * 3;
    const linePositions = positions.slice(polylineStart, polylineStart + count);
    polylineStart += count;
    callback(linePositions, batchIds[i2], url2, batchTable);
  }
}
var Vector3DTileContent_default = Vector3DTileContent;

// node_modules/cesium/Source/Scene/PropertyTable.js
function PropertyTable(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.number("options.count", options.count);
  this._name = options.name;
  this._id = options.id;
  this._count = options.count;
  this._extras = options.extras;
  this._extensions = options.extensions;
  this._metadataTable = options.metadataTable;
  this._jsonMetadataTable = options.jsonMetadataTable;
  this._batchTableHierarchy = options.batchTableHierarchy;
}
Object.defineProperties(PropertyTable.prototype, {
  name: {
    get: function() {
      return this._name;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  count: {
    get: function() {
      return this._count;
    }
  },
  class: {
    get: function() {
      if (defined_default(this._metadataTable)) {
        return this._metadataTable.class;
      }
      return void 0;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
PropertyTable.prototype.hasProperty = function(index2, propertyId) {
  Check_default.typeOf.number("index", index2);
  Check_default.typeOf.string("propertyId", propertyId);
  if (defined_default(this._metadataTable) && this._metadataTable.hasProperty(propertyId)) {
    return true;
  }
  if (defined_default(this._jsonMetadataTable) && this._jsonMetadataTable.hasProperty(propertyId)) {
    return true;
  }
  if (defined_default(this._batchTableHierarchy) && this._batchTableHierarchy.hasProperty(index2, propertyId)) {
    return true;
  }
  return false;
};
PropertyTable.prototype.hasPropertyBySemantic = function(index2, semantic) {
  Check_default.typeOf.number("index", index2);
  Check_default.typeOf.string("semantic", semantic);
  if (defined_default(this._metadataTable)) {
    return this._metadataTable.hasPropertyBySemantic(semantic);
  }
  return false;
};
PropertyTable.prototype.propertyExists = function(propertyId) {
  Check_default.typeOf.string("propertyId", propertyId);
  if (defined_default(this._metadataTable) && this._metadataTable.hasProperty(propertyId)) {
    return true;
  }
  if (defined_default(this._jsonMetadataTable) && this._jsonMetadataTable.hasProperty(propertyId)) {
    return true;
  }
  if (defined_default(this._batchTableHierarchy) && this._batchTableHierarchy.propertyExists(propertyId)) {
    return true;
  }
  return false;
};
PropertyTable.prototype.propertyExistsBySemantic = function(semantic) {
  Check_default.typeOf.string("semantic", semantic);
  if (defined_default(this._metadataTable)) {
    return this._metadataTable.hasPropertyBySemantic(semantic);
  }
  return false;
};
var scratchResults = [];
PropertyTable.prototype.getPropertyIds = function(index2, results) {
  results = defined_default(results) ? results : [];
  results.length = 0;
  if (defined_default(this._metadataTable)) {
    results.push.apply(
      results,
      this._metadataTable.getPropertyIds(scratchResults)
    );
  }
  if (defined_default(this._jsonMetadataTable)) {
    results.push.apply(
      results,
      this._jsonMetadataTable.getPropertyIds(scratchResults)
    );
  }
  if (defined_default(this._batchTableHierarchy)) {
    results.push.apply(
      results,
      this._batchTableHierarchy.getPropertyIds(index2, scratchResults)
    );
  }
  return results;
};
PropertyTable.prototype.getProperty = function(index2, propertyId) {
  let result;
  if (defined_default(this._metadataTable)) {
    result = this._metadataTable.getProperty(index2, propertyId);
    if (defined_default(result)) {
      return result;
    }
  }
  if (defined_default(this._jsonMetadataTable)) {
    result = this._jsonMetadataTable.getProperty(index2, propertyId);
    if (defined_default(result)) {
      return result;
    }
  }
  if (defined_default(this._batchTableHierarchy)) {
    result = this._batchTableHierarchy.getProperty(index2, propertyId);
    if (defined_default(result)) {
      return result;
    }
  }
  return void 0;
};
PropertyTable.prototype.setProperty = function(index2, propertyId, value) {
  if (defined_default(this._metadataTable) && this._metadataTable.setProperty(index2, propertyId, value)) {
    return true;
  }
  if (defined_default(this._jsonMetadataTable) && this._jsonMetadataTable.setProperty(index2, propertyId, value)) {
    return true;
  }
  return defined_default(this._batchTableHierarchy) && this._batchTableHierarchy.setProperty(index2, propertyId, value);
};
PropertyTable.prototype.getPropertyBySemantic = function(index2, semantic) {
  if (defined_default(this._metadataTable)) {
    return this._metadataTable.getPropertyBySemantic(index2, semantic);
  }
  return void 0;
};
PropertyTable.prototype.setPropertyBySemantic = function(index2, semantic, value) {
  if (defined_default(this._metadataTable)) {
    return this._metadataTable.setPropertyBySemantic(index2, semantic, value);
  }
  return false;
};
PropertyTable.prototype.getPropertyTypedArray = function(propertyId) {
  Check_default.typeOf.string("propertyId", propertyId);
  if (defined_default(this._metadataTable)) {
    return this._metadataTable.getPropertyTypedArray(propertyId);
  }
  return void 0;
};
PropertyTable.prototype.getPropertyTypedArrayBySemantic = function(semantic) {
  Check_default.typeOf.string("semantic", semantic);
  if (defined_default(this._metadataTable)) {
    return this._metadataTable.getPropertyTypedArrayBySemantic(semantic);
  }
  return void 0;
};
var PropertyTable_default = PropertyTable;

// node_modules/cesium/Source/Scene/PropertyTextureProperty.js
function PropertyTextureProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const property = options.property;
  const classProperty = options.classProperty;
  const textures = options.textures;
  Check_default.typeOf.object("options.property", property);
  Check_default.typeOf.object("options.classProperty", classProperty);
  Check_default.typeOf.object("options.textures", textures);
  const textureInfo = property;
  const textureReader = GltfLoaderUtil_default.createModelTextureReader({
    textureInfo,
    channels: reformatChannels(property.channels),
    texture: textures[textureInfo.index]
  });
  this._min = property.min;
  this._max = property.max;
  let offset2 = property.offset;
  let scale = property.scale;
  const hasValueTransform = classProperty.hasValueTransform || defined_default(offset2) || defined_default(scale);
  offset2 = defaultValue_default(offset2, classProperty.offset);
  scale = defaultValue_default(scale, classProperty.scale);
  offset2 = classProperty.unpackVectorAndMatrixTypes(offset2);
  scale = classProperty.unpackVectorAndMatrixTypes(scale);
  this._offset = offset2;
  this._scale = scale;
  this._hasValueTransform = hasValueTransform;
  this._textureReader = textureReader;
  this._classProperty = classProperty;
  this._extras = property.extras;
  this._extensions = property.extensions;
}
Object.defineProperties(PropertyTextureProperty.prototype, {
  textureReader: {
    get: function() {
      return this._textureReader;
    }
  },
  hasValueTransform: {
    get: function() {
      return this._hasValueTransform;
    }
  },
  offset: {
    get: function() {
      return this._offset;
    }
  },
  scale: {
    get: function() {
      return this._scale;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
PropertyTextureProperty.prototype.isGpuCompatible = function() {
  const classProperty = this._classProperty;
  const type = classProperty.type;
  const componentType = classProperty.componentType;
  if (classProperty.isArray) {
    return !classProperty.isVariableLengthArray && classProperty.arrayLength <= 4 && type === MetadataType_default.SCALAR && componentType === MetadataComponentType_default.UINT8;
  }
  if (MetadataType_default.isVectorType(type) || type === MetadataType_default.SCALAR) {
    return componentType === MetadataComponentType_default.UINT8;
  }
  return false;
};
var floatTypesByComponentCount = [void 0, "float", "vec2", "vec3", "vec4"];
var integerTypesByComponentCount = [
  void 0,
  "int",
  "ivec2",
  "ivec3",
  "ivec4"
];
PropertyTextureProperty.prototype.getGlslType = function() {
  const classProperty = this._classProperty;
  let componentCount = MetadataType_default.getComponentCount(classProperty.type);
  if (classProperty.isArray) {
    componentCount = classProperty.arrayLength;
  }
  if (classProperty.normalized) {
    return floatTypesByComponentCount[componentCount];
  }
  return integerTypesByComponentCount[componentCount];
};
PropertyTextureProperty.prototype.unpackInShader = function(packedValueGlsl) {
  const classProperty = this._classProperty;
  if (classProperty.normalized) {
    return packedValueGlsl;
  }
  const glslType = this.getGlslType();
  return `${glslType}(255.0 * ${packedValueGlsl})`;
};
function reformatChannels(channels) {
  return channels.map(function(channelIndex) {
    return "rgba".charAt(channelIndex);
  }).join("");
}
var PropertyTextureProperty_default = PropertyTextureProperty;

// node_modules/cesium/Source/Scene/PropertyTexture.js
function PropertyTexture(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const propertyTexture = options.propertyTexture;
  const classDefinition = options.class;
  const textures = options.textures;
  Check_default.typeOf.object("options.propertyTexture", propertyTexture);
  Check_default.typeOf.object("options.class", classDefinition);
  Check_default.typeOf.object("options.textures", textures);
  const extensions = propertyTexture.extensions;
  const extras = propertyTexture.extras;
  const properties = {};
  if (defined_default(propertyTexture.properties)) {
    for (const propertyId in propertyTexture.properties) {
      if (propertyTexture.properties.hasOwnProperty(propertyId)) {
        properties[propertyId] = new PropertyTextureProperty_default({
          property: propertyTexture.properties[propertyId],
          classProperty: classDefinition.properties[propertyId],
          textures
        });
      }
    }
  }
  this._name = options.name;
  this._id = options.id;
  this._class = classDefinition;
  this._properties = properties;
  this._extras = extras;
  this._extensions = extensions;
}
Object.defineProperties(PropertyTexture.prototype, {
  name: {
    get: function() {
      return this._name;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  class: {
    get: function() {
      return this._class;
    }
  },
  properties: {
    get: function() {
      return this._properties;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
PropertyTexture.prototype.getProperty = function(propertyId) {
  Check_default.typeOf.string("propertyId", propertyId);
  return this._properties[propertyId];
};
var PropertyTexture_default = PropertyTexture;

// node_modules/cesium/Source/Scene/PropertyAttributeProperty.js
function PropertyAttributeProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const property = options.property;
  const classProperty = options.classProperty;
  Check_default.typeOf.object("options.property", property);
  Check_default.typeOf.object("options.classProperty", classProperty);
  this._attribute = property.attribute;
  this._classProperty = classProperty;
  this._min = property.min;
  this._max = property.max;
  let offset2 = property.offset;
  let scale = property.scale;
  const hasValueTransform = classProperty.hasValueTransform || defined_default(offset2) || defined_default(scale);
  offset2 = defaultValue_default(offset2, classProperty.offset);
  scale = defaultValue_default(scale, classProperty.scale);
  offset2 = classProperty.unpackVectorAndMatrixTypes(offset2);
  scale = classProperty.unpackVectorAndMatrixTypes(scale);
  this._offset = offset2;
  this._scale = scale;
  this._hasValueTransform = hasValueTransform;
  this._extras = property.extras;
  this._extensions = property.extensions;
}
Object.defineProperties(PropertyAttributeProperty.prototype, {
  attribute: {
    get: function() {
      return this._attribute;
    }
  },
  hasValueTransform: {
    get: function() {
      return this._hasValueTransform;
    }
  },
  offset: {
    get: function() {
      return this._offset;
    }
  },
  scale: {
    get: function() {
      return this._scale;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});

// node_modules/cesium/Source/Scene/PropertyAttribute.js
function PropertyAttribute(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const propertyAttribute = options.propertyAttribute;
  const classDefinition = options.class;
  Check_default.typeOf.object("options.propertyAttribute", propertyAttribute);
  Check_default.typeOf.object("options.class", classDefinition);
  const properties = {};
  if (defined_default(propertyAttribute.properties)) {
    for (const propertyId in propertyAttribute.properties) {
      if (propertyAttribute.properties.hasOwnProperty(propertyId)) {
        properties[propertyId] = new PropertyAttributeProperty({
          property: propertyAttribute.properties[propertyId],
          classProperty: classDefinition.properties[propertyId]
        });
      }
    }
  }
  this._name = options.name;
  this._id = options.id;
  this._class = classDefinition;
  this._properties = properties;
  this._extras = propertyAttribute.extras;
  this._extensions = propertyAttribute.extensions;
}
Object.defineProperties(PropertyAttribute.prototype, {
  name: {
    get: function() {
      return this._name;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  class: {
    get: function() {
      return this._class;
    }
  },
  properties: {
    get: function() {
      return this._properties;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
PropertyAttribute.prototype.getProperty = function(propertyId) {
  Check_default.typeOf.string("propertyId", propertyId);
  return this._properties[propertyId];
};

// node_modules/cesium/Source/Scene/StructuralMetadata.js
function StructuralMetadata(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.schema", options.schema);
  this._schema = options.schema;
  const propertyTables = options.propertyTables;
  this._propertyTableCount = defined_default(propertyTables) ? propertyTables.length : 0;
  this._propertyTables = propertyTables;
  this._propertyTextures = options.propertyTextures;
  this._propertyAttributes = options.propertyAttributes;
  this._statistics = options.statistics;
  this._extras = options.extras;
  this._extensions = options.extensions;
}
Object.defineProperties(StructuralMetadata.prototype, {
  schema: {
    get: function() {
      return this._schema;
    }
  },
  statistics: {
    get: function() {
      return this._statistics;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  },
  propertyTableCount: {
    get: function() {
      return this._propertyTableCount;
    }
  },
  propertyTables: {
    get: function() {
      return this._propertyTables;
    }
  },
  propertyTextures: {
    get: function() {
      return this._propertyTextures;
    }
  },
  propertyAttributes: {
    get: function() {
      return this._propertyAttributes;
    }
  }
});
StructuralMetadata.prototype.getPropertyTable = function(propertyTableId) {
  Check_default.typeOf.number("propertyTableId", propertyTableId);
  return this._propertyTables[propertyTableId];
};
StructuralMetadata.prototype.getPropertyTexture = function(propertyTextureId) {
  Check_default.typeOf.number("propertyTextureId", propertyTextureId);
  return this._propertyTextures[propertyTextureId];
};
StructuralMetadata.prototype.getPropertyAttribute = function(propertyAttributeId) {
  Check_default.typeOf.number("propertyAttributeId", propertyAttributeId);
  return this._propertyAttributes[propertyAttributeId];
};
var StructuralMetadata_default = StructuralMetadata;

// node_modules/cesium/Source/Scene/parseStructuralMetadata.js
function parseStructuralMetadata(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const extension = options.extension;
  const schema = options.schema;
  Check_default.typeOf.object("options.extension", extension);
  Check_default.typeOf.object("options.schema", schema);
  const propertyTables = [];
  if (defined_default(extension.propertyTables)) {
    for (let i2 = 0; i2 < extension.propertyTables.length; i2++) {
      const propertyTable = extension.propertyTables[i2];
      const classDefinition = schema.classes[propertyTable.class];
      const metadataTable = new MetadataTable_default({
        count: propertyTable.count,
        properties: propertyTable.properties,
        class: classDefinition,
        bufferViews: options.bufferViews
      });
      propertyTables.push(
        new PropertyTable_default({
          id: i2,
          name: propertyTable.name,
          count: propertyTable.count,
          metadataTable,
          extras: propertyTable.extras,
          extensions: propertyTable.extensions
        })
      );
    }
  }
  const propertyTextures = [];
  if (defined_default(extension.propertyTextures)) {
    for (let i2 = 0; i2 < extension.propertyTextures.length; i2++) {
      const propertyTexture = extension.propertyTextures[i2];
      propertyTextures.push(
        new PropertyTexture_default({
          id: i2,
          name: propertyTexture.name,
          propertyTexture,
          class: schema.classes[propertyTexture.class],
          textures: options.textures
        })
      );
    }
  }
  const propertyAttributes = [];
  if (defined_default(extension.propertyAttributes)) {
    for (let i2 = 0; i2 < extension.propertyAttributes.length; i2++) {
      const propertyAttribute = extension.propertyAttributes[i2];
      propertyAttributes.push(
        new PropertyAttribute({
          id: i2,
          name: propertyAttribute.name,
          class: schema.classes[propertyAttribute.class],
          propertyAttribute
        })
      );
    }
  }
  return new StructuralMetadata_default({
    schema,
    propertyTables,
    propertyTextures,
    propertyAttributes,
    statistics: extension.statistics,
    extras: extension.extras,
    extensions: extension.extensions
  });
}

// node_modules/cesium/Source/Scene/parseFeatureMetadataLegacy.js
function parseFeatureMetadataLegacy(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const extension = options.extension;
  const schema = options.schema;
  Check_default.typeOf.object("options.extension", extension);
  Check_default.typeOf.object("options.schema", schema);
  let i2;
  const propertyTables = [];
  let sortedIds;
  if (defined_default(extension.featureTables)) {
    sortedIds = Object.keys(extension.featureTables).sort();
    for (i2 = 0; i2 < sortedIds.length; i2++) {
      const featureTableId = sortedIds[i2];
      const featureTable = extension.featureTables[featureTableId];
      const classDefinition = schema.classes[featureTable.class];
      const metadataTable = new MetadataTable_default({
        count: featureTable.count,
        properties: featureTable.properties,
        class: classDefinition,
        bufferViews: options.bufferViews
      });
      propertyTables.push(
        new PropertyTable_default({
          id: featureTableId,
          count: featureTable.count,
          metadataTable,
          extras: featureTable.extras,
          extensions: featureTable.extensions
        })
      );
    }
  }
  const propertyTextures = [];
  if (defined_default(extension.featureTextures)) {
    sortedIds = Object.keys(extension.featureTextures).sort();
    for (i2 = 0; i2 < sortedIds.length; i2++) {
      const featureTextureId = sortedIds[i2];
      const featureTexture = extension.featureTextures[featureTextureId];
      propertyTextures.push(
        new PropertyTexture_default({
          id: featureTextureId,
          propertyTexture: transcodeToPropertyTexture(featureTexture),
          class: schema.classes[featureTexture.class],
          textures: options.textures
        })
      );
    }
  }
  return new StructuralMetadata_default({
    schema,
    propertyTables,
    propertyTextures,
    statistics: extension.statistics,
    extras: extension.extras,
    extensions: extension.extensions
  });
}
function transcodeToPropertyTexture(featureTexture) {
  const propertyTexture = {
    class: featureTexture.class,
    properties: {}
  };
  const properties = featureTexture.properties;
  for (const propertyId in properties) {
    if (properties.hasOwnProperty(propertyId)) {
      const oldProperty = properties[propertyId];
      const property = {
        channels: reformatChannels2(oldProperty.channels),
        extras: oldProperty.extras,
        extensions: oldProperty.extensions
      };
      propertyTexture.properties[propertyId] = combine_default(
        oldProperty.texture,
        property,
        true
      );
    }
  }
  return propertyTexture;
}
function reformatChannels2(channelsString) {
  const length3 = channelsString.length;
  const result = new Array(length3);
  for (let i2 = 0; i2 < length3; i2++) {
    result[i2] = "rgba".indexOf(channelsString[i2]);
  }
  return result;
}

// node_modules/cesium/Source/Scene/GltfStructuralMetadataLoader.js
function GltfStructuralMetadataLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltf = options.gltf;
  const extension = options.extension;
  const extensionLegacy = options.extensionLegacy;
  const gltfResource = options.gltfResource;
  const baseResource2 = options.baseResource;
  const supportedImageFormats = options.supportedImageFormats;
  const cacheKey = options.cacheKey;
  const asynchronous = defaultValue_default(options.asynchronous, true);
  Check_default.typeOf.object("options.gltf", gltf);
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  Check_default.typeOf.object("options.baseResource", baseResource2);
  Check_default.typeOf.object("options.supportedImageFormats", supportedImageFormats);
  if (!defined_default(options.extension) && !defined_default(options.extensionLegacy)) {
    throw new DeveloperError_default(
      "One of options.extension or options.extensionLegacy must be specified"
    );
  }
  this._gltfResource = gltfResource;
  this._baseResource = baseResource2;
  this._gltf = gltf;
  this._extension = extension;
  this._extensionLegacy = extensionLegacy;
  this._supportedImageFormats = supportedImageFormats;
  this._cacheKey = cacheKey;
  this._asynchronous = asynchronous;
  this._bufferViewLoaders = [];
  this._textureLoaders = [];
  this._schemaLoader = void 0;
  this._structuralMetadata = void 0;
  this._state = ResourceLoaderState_default.UNLOADED;
  this._promise = defer_default();
}
if (defined_default(Object.create)) {
  GltfStructuralMetadataLoader.prototype = Object.create(
    ResourceLoader.prototype
  );
  GltfStructuralMetadataLoader.prototype.constructor = GltfStructuralMetadataLoader;
}
Object.defineProperties(GltfStructuralMetadataLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return this._cacheKey;
    }
  },
  structuralMetadata: {
    get: function() {
      return this._structuralMetadata;
    }
  }
});
GltfStructuralMetadataLoader.prototype.load = function() {
  const bufferViewsPromise = loadBufferViews(this);
  const texturesPromise = loadTextures(this);
  const schemaPromise = loadSchema(this);
  this._gltf = void 0;
  this._state = ResourceLoaderState_default.LOADING;
  const that = this;
  Promise.all([bufferViewsPromise, texturesPromise, schemaPromise]).then(function(results) {
    if (that.isDestroyed()) {
      return;
    }
    const bufferViews = results[0];
    const textures = results[1];
    const schema = results[2];
    if (defined_default(that._extension)) {
      that._structuralMetadata = parseStructuralMetadata({
        extension: that._extension,
        schema,
        bufferViews,
        textures
      });
    } else {
      that._structuralMetadata = parseFeatureMetadataLegacy({
        extension: that._extensionLegacy,
        schema,
        bufferViews,
        textures
      });
    }
    that._state = ResourceLoaderState_default.READY;
    that._promise.resolve(that);
  }).catch(function(error) {
    if (that.isDestroyed()) {
      return;
    }
    that.unload();
    that._state = ResourceLoaderState_default.FAILED;
    const errorMessage = "Failed to load structural metadata";
    that._promise.reject(that.getError(errorMessage, error));
  });
};
function gatherBufferViewIdsFromProperties(properties, bufferViewIdSet) {
  for (const propertyId in properties) {
    if (properties.hasOwnProperty(propertyId)) {
      const property = properties[propertyId];
      const values = property.values;
      const arrayOffsets = property.arrayOffsets;
      const stringOffsets = property.stringOffsets;
      if (defined_default(values)) {
        bufferViewIdSet[values] = true;
      }
      if (defined_default(arrayOffsets)) {
        bufferViewIdSet[arrayOffsets] = true;
      }
      if (defined_default(stringOffsets)) {
        bufferViewIdSet[stringOffsets] = true;
      }
    }
  }
}
function gatherBufferViewIdsFromPropertiesLegacy(properties, bufferViewIdSet) {
  for (const propertyId in properties) {
    if (properties.hasOwnProperty(propertyId)) {
      const property = properties[propertyId];
      const bufferView = property.bufferView;
      const arrayOffsetBufferView = property.arrayOffsetBufferView;
      const stringOffsetBufferView = property.stringOffsetBufferView;
      if (defined_default(bufferView)) {
        bufferViewIdSet[bufferView] = true;
      }
      if (defined_default(arrayOffsetBufferView)) {
        bufferViewIdSet[arrayOffsetBufferView] = true;
      }
      if (defined_default(stringOffsetBufferView)) {
        bufferViewIdSet[stringOffsetBufferView] = true;
      }
    }
  }
}
function gatherUsedBufferViewIds(extension) {
  const propertyTables = extension.propertyTables;
  const bufferViewIdSet = {};
  if (defined_default(propertyTables)) {
    for (let i2 = 0; i2 < propertyTables.length; i2++) {
      const propertyTable = propertyTables[i2];
      gatherBufferViewIdsFromProperties(
        propertyTable.properties,
        bufferViewIdSet
      );
    }
  }
  return bufferViewIdSet;
}
function gatherUsedBufferViewIdsLegacy(extensionLegacy) {
  const featureTables = extensionLegacy.featureTables;
  const bufferViewIdSet = {};
  if (defined_default(featureTables)) {
    for (const featureTableId in featureTables) {
      if (featureTables.hasOwnProperty(featureTableId)) {
        const featureTable = featureTables[featureTableId];
        const properties = featureTable.properties;
        if (defined_default(properties)) {
          gatherBufferViewIdsFromPropertiesLegacy(properties, bufferViewIdSet);
        }
      }
    }
  }
  return bufferViewIdSet;
}
function loadBufferViews(structuralMetadataLoader) {
  let bufferViewIds;
  if (defined_default(structuralMetadataLoader._extension)) {
    bufferViewIds = gatherUsedBufferViewIds(
      structuralMetadataLoader._extension
    );
  } else {
    bufferViewIds = gatherUsedBufferViewIdsLegacy(
      structuralMetadataLoader._extensionLegacy
    );
  }
  const bufferViewPromises = [];
  const bufferViewLoaders = {};
  for (const bufferViewId in bufferViewIds) {
    if (bufferViewIds.hasOwnProperty(bufferViewId)) {
      const bufferViewLoader = ResourceCache_default.loadBufferView({
        gltf: structuralMetadataLoader._gltf,
        bufferViewId: parseInt(bufferViewId),
        gltfResource: structuralMetadataLoader._gltfResource,
        baseResource: structuralMetadataLoader._baseResource
      });
      bufferViewPromises.push(bufferViewLoader.promise);
      structuralMetadataLoader._bufferViewLoaders.push(bufferViewLoader);
      bufferViewLoaders[bufferViewId] = bufferViewLoader;
    }
  }
  return Promise.all(bufferViewPromises).then(function() {
    const bufferViews = {};
    for (const bufferViewId in bufferViewLoaders) {
      if (bufferViewLoaders.hasOwnProperty(bufferViewId)) {
        const bufferViewLoader = bufferViewLoaders[bufferViewId];
        const bufferViewTypedArray = new Uint8Array(
          bufferViewLoader.typedArray
        );
        bufferViews[bufferViewId] = bufferViewTypedArray;
      }
    }
    unloadBufferViews(structuralMetadataLoader);
    return bufferViews;
  });
}
function gatherUsedTextureIds(structuralMetadataExtension) {
  const textureIds = {};
  const propertyTextures = structuralMetadataExtension.propertyTextures;
  if (defined_default(propertyTextures)) {
    for (let i2 = 0; i2 < propertyTextures.length; i2++) {
      const propertyTexture = propertyTextures[i2];
      const properties = propertyTexture.properties;
      if (defined_default(properties)) {
        gatherTextureIdsFromProperties(properties, textureIds);
      }
    }
  }
  return textureIds;
}
function gatherTextureIdsFromProperties(properties, textureIds) {
  for (const propertyId in properties) {
    if (properties.hasOwnProperty(propertyId)) {
      const textureInfo = properties[propertyId];
      textureIds[textureInfo.index] = textureInfo;
    }
  }
}
function gatherUsedTextureIdsLegacy(extensionLegacy) {
  const textureIds = {};
  const featureTextures = extensionLegacy.featureTextures;
  if (defined_default(featureTextures)) {
    for (const featureTextureId in featureTextures) {
      if (featureTextures.hasOwnProperty(featureTextureId)) {
        const featureTexture = featureTextures[featureTextureId];
        const properties = featureTexture.properties;
        if (defined_default(properties)) {
          gatherTextureIdsFromPropertiesLegacy(properties, textureIds);
        }
      }
    }
  }
  return textureIds;
}
function gatherTextureIdsFromPropertiesLegacy(properties, textureIds) {
  for (const propertyId in properties) {
    if (properties.hasOwnProperty(propertyId)) {
      const property = properties[propertyId];
      const textureInfo = property.texture;
      textureIds[textureInfo.index] = textureInfo;
    }
  }
}
function loadTextures(structuralMetadataLoader) {
  let textureIds;
  if (defined_default(structuralMetadataLoader._extension)) {
    textureIds = gatherUsedTextureIds(structuralMetadataLoader._extension);
  } else {
    textureIds = gatherUsedTextureIdsLegacy(
      structuralMetadataLoader._extensionLegacy
    );
  }
  const gltf = structuralMetadataLoader._gltf;
  const gltfResource = structuralMetadataLoader._gltfResource;
  const baseResource2 = structuralMetadataLoader._baseResource;
  const supportedImageFormats = structuralMetadataLoader._supportedImageFormats;
  const asynchronous = structuralMetadataLoader._asynchronous;
  const texturePromises = [];
  const textureLoaders = {};
  for (const textureId in textureIds) {
    if (textureIds.hasOwnProperty(textureId)) {
      const textureLoader = ResourceCache_default.loadTexture({
        gltf,
        textureInfo: textureIds[textureId],
        gltfResource,
        baseResource: baseResource2,
        supportedImageFormats,
        asynchronous
      });
      texturePromises.push(textureLoader.promise);
      structuralMetadataLoader._textureLoaders.push(textureLoader);
      textureLoaders[textureId] = textureLoader;
    }
  }
  return Promise.all(texturePromises).then(function() {
    const textures = {};
    for (const textureId in textureLoaders) {
      if (textureLoaders.hasOwnProperty(textureId)) {
        const textureLoader = textureLoaders[textureId];
        textures[textureId] = textureLoader.texture;
      }
    }
    return textures;
  });
}
function loadSchema(structuralMetadataLoader) {
  const extension = defaultValue_default(
    structuralMetadataLoader._extension,
    structuralMetadataLoader._extensionLegacy
  );
  let schemaLoader;
  if (defined_default(extension.schemaUri)) {
    const resource = structuralMetadataLoader._baseResource.getDerivedResource({
      url: extension.schemaUri
    });
    schemaLoader = ResourceCache_default.loadSchema({
      resource
    });
  } else {
    schemaLoader = ResourceCache_default.loadSchema({
      schema: extension.schema
    });
  }
  structuralMetadataLoader._schemaLoader = schemaLoader;
  return schemaLoader.promise.then(function(schemaLoader2) {
    return schemaLoader2.schema;
  });
}
GltfStructuralMetadataLoader.prototype.process = function(frameState) {
  Check_default.typeOf.object("frameState", frameState);
  if (this._state !== ResourceLoaderState_default.LOADING) {
    return;
  }
  const textureLoaders = this._textureLoaders;
  const textureLoadersLength = textureLoaders.length;
  for (let i2 = 0; i2 < textureLoadersLength; ++i2) {
    const textureLoader = textureLoaders[i2];
    textureLoader.process(frameState);
  }
};
function unloadBufferViews(structuralMetadataLoader) {
  const bufferViewLoaders = structuralMetadataLoader._bufferViewLoaders;
  const bufferViewLoadersLength = bufferViewLoaders.length;
  for (let i2 = 0; i2 < bufferViewLoadersLength; ++i2) {
    ResourceCache_default.unload(bufferViewLoaders[i2]);
  }
  structuralMetadataLoader._bufferViewLoaders.length = 0;
}
function unloadTextures(structuralMetadataLoader) {
  const textureLoaders = structuralMetadataLoader._textureLoaders;
  const textureLoadersLength = textureLoaders.length;
  for (let i2 = 0; i2 < textureLoadersLength; ++i2) {
    ResourceCache_default.unload(textureLoaders[i2]);
  }
  structuralMetadataLoader._textureLoaders.length = 0;
}
GltfStructuralMetadataLoader.prototype.unload = function() {
  unloadBufferViews(this);
  unloadTextures(this);
  if (defined_default(this._schemaLoader)) {
    ResourceCache_default.unload(this._schemaLoader);
  }
  this._schemaLoader = void 0;
  this._structuralMetadata = void 0;
};

// node_modules/cesium/Source/Scene/InstanceAttributeSemantic.js
var InstanceAttributeSemantic = {
  TRANSLATION: "TRANSLATION",
  ROTATION: "ROTATION",
  SCALE: "SCALE",
  FEATURE_ID: "_FEATURE_ID"
};
InstanceAttributeSemantic.fromGltfSemantic = function(gltfSemantic) {
  Check_default.typeOf.string("gltfSemantic", gltfSemantic);
  let semantic = gltfSemantic;
  const setIndexRegex = /^(\w+)_\d+$/;
  const setIndexMatch = setIndexRegex.exec(gltfSemantic);
  if (setIndexMatch !== null) {
    semantic = setIndexMatch[1];
  }
  switch (semantic) {
    case "TRANSLATION":
      return InstanceAttributeSemantic.TRANSLATION;
    case "ROTATION":
      return InstanceAttributeSemantic.ROTATION;
    case "SCALE":
      return InstanceAttributeSemantic.SCALE;
    case "_FEATURE_ID":
      return InstanceAttributeSemantic.FEATURE_ID;
  }
  return void 0;
};
var InstanceAttributeSemantic_default = Object.freeze(InstanceAttributeSemantic);

// node_modules/cesium/Source/Scene/SupportedImageFormats.js
function SupportedImageFormats(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.webp = defaultValue_default(options.webp, false);
  this.basis = defaultValue_default(options.basis, false);
}

// node_modules/cesium/Source/Scene/GltfLoader.js
var Attribute2 = ModelComponents_default.Attribute;
var Indices2 = ModelComponents_default.Indices;
var FeatureIdAttribute2 = ModelComponents_default.FeatureIdAttribute;
var FeatureIdTexture2 = ModelComponents_default.FeatureIdTexture;
var FeatureIdImplicitRange2 = ModelComponents_default.FeatureIdImplicitRange;
var MorphTarget2 = ModelComponents_default.MorphTarget;
var Primitive3 = ModelComponents_default.Primitive;
var Instances2 = ModelComponents_default.Instances;
var Skin2 = ModelComponents_default.Skin;
var Node5 = ModelComponents_default.Node;
var AnimatedPropertyType2 = ModelComponents_default.AnimatedPropertyType;
var AnimationSampler2 = ModelComponents_default.AnimationSampler;
var AnimationTarget2 = ModelComponents_default.AnimationTarget;
var AnimationChannel2 = ModelComponents_default.AnimationChannel;
var Animation2 = ModelComponents_default.Animation;
var Asset2 = ModelComponents_default.Asset;
var Scene2 = ModelComponents_default.Scene;
var Components2 = ModelComponents_default.Components;
var MetallicRoughness2 = ModelComponents_default.MetallicRoughness;
var SpecularGlossiness2 = ModelComponents_default.SpecularGlossiness;
var Material3 = ModelComponents_default.Material;
var GltfLoaderState = {
  UNLOADED: 0,
  LOADING: 1,
  LOADED: 2,
  PROCESSING: 3,
  PROCESSED: 4,
  READY: 4,
  FAILED: 5
};
function GltfLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const gltfResource = options.gltfResource;
  let baseResource2 = options.baseResource;
  const typedArray = options.typedArray;
  const releaseGltfJson = defaultValue_default(options.releaseGltfJson, false);
  const asynchronous = defaultValue_default(options.asynchronous, true);
  const incrementallyLoadTextures = defaultValue_default(
    options.incrementallyLoadTextures,
    true
  );
  const upAxis = defaultValue_default(options.upAxis, Axis_default.Y);
  const forwardAxis = defaultValue_default(options.forwardAxis, Axis_default.Z);
  const loadAsTypedArray = defaultValue_default(options.loadAsTypedArray, false);
  const renameBatchIdSemantic = defaultValue_default(
    options.renameBatchIdSemantic,
    false
  );
  Check_default.typeOf.object("options.gltfResource", gltfResource);
  baseResource2 = defined_default(baseResource2) ? baseResource2 : gltfResource.clone();
  this._gltfJson = options.gltfJson;
  this._gltfResource = gltfResource;
  this._baseResource = baseResource2;
  this._typedArray = typedArray;
  this._releaseGltfJson = releaseGltfJson;
  this._asynchronous = asynchronous;
  this._incrementallyLoadTextures = incrementallyLoadTextures;
  this._upAxis = upAxis;
  this._forwardAxis = forwardAxis;
  this._loadAsTypedArray = loadAsTypedArray;
  this._renameBatchIdSemantic = renameBatchIdSemantic;
  this._sortedPropertyTableIds = void 0;
  this._sortedFeatureTextureIds = void 0;
  this._gltfJsonLoader = void 0;
  this._state = GltfLoaderState.UNLOADED;
  this._textureState = GltfLoaderState.UNLOADED;
  this._promise = defer_default();
  this._texturesLoadedPromise = defer_default();
  this._textureLoaders = [];
  this._bufferViewLoaders = [];
  this._geometryLoaders = [];
  this._structuralMetadataLoader = void 0;
  this._components = void 0;
}
if (defined_default(Object.create)) {
  GltfLoader.prototype = Object.create(ResourceLoader.prototype);
  GltfLoader.prototype.constructor = GltfLoader;
}
Object.defineProperties(GltfLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return void 0;
    }
  },
  components: {
    get: function() {
      return this._components;
    }
  },
  texturesLoadedPromise: {
    get: function() {
      return this._texturesLoadedPromise.promise;
    }
  }
});
GltfLoader.prototype.load = function() {
  const gltfJsonLoader = ResourceCache_default.loadGltfJson({
    gltfResource: this._gltfResource,
    baseResource: this._baseResource,
    typedArray: this._typedArray,
    gltfJson: this._gltfJson
  });
  this._gltfJsonLoader = gltfJsonLoader;
  this._state = GltfLoaderState.LOADING;
  this._textureState = GltfLoaderState.LOADING;
  const that = this;
  gltfJsonLoader.promise.then(function() {
    if (that.isDestroyed()) {
      return;
    }
    that._state = GltfLoaderState.LOADED;
    that._textureState = GltfLoaderState.LOADED;
  }).catch(function(error) {
    if (that.isDestroyed()) {
      return;
    }
    handleError6(that, error);
  });
};
function handleError6(gltfLoader, error) {
  gltfLoader.unload();
  gltfLoader._state = GltfLoaderState.FAILED;
  gltfLoader._textureState = GltfLoaderState.FAILED;
  const errorMessage = "Failed to load glTF";
  error = gltfLoader.getError(errorMessage, error);
  gltfLoader._promise.reject(error);
  gltfLoader._texturesLoadedPromise.reject(error);
}
function process2(loader, frameState) {
  let i2;
  const textureLoaders = loader._textureLoaders;
  const textureLoadersLength = textureLoaders.length;
  for (i2 = 0; i2 < textureLoadersLength; ++i2) {
    textureLoaders[i2].process(frameState);
  }
  const bufferViewLoaders = loader._bufferViewLoaders;
  const bufferViewLoadersLength = bufferViewLoaders.length;
  for (i2 = 0; i2 < bufferViewLoadersLength; ++i2) {
    bufferViewLoaders[i2].process(frameState);
  }
  const geometryLoaders = loader._geometryLoaders;
  const geometryLoadersLength = geometryLoaders.length;
  for (i2 = 0; i2 < geometryLoadersLength; ++i2) {
    geometryLoaders[i2].process(frameState);
  }
  if (defined_default(loader._structuralMetadataLoader)) {
    loader._structuralMetadataLoader.process(frameState);
  }
}
GltfLoader.prototype.process = function(frameState) {
  Check_default.typeOf.object("frameState", frameState);
  if (!FeatureDetection_default.supportsWebP.initialized) {
    FeatureDetection_default.supportsWebP.initialize();
    return;
  }
  if (this._state === GltfLoaderState.LOADED) {
    this._state = GltfLoaderState.PROCESSING;
    const supportedImageFormats = new SupportedImageFormats({
      webp: FeatureDetection_default.supportsWebP(),
      basis: frameState.context.supportsBasis
    });
    let gltf;
    if (defined_default(this._gltfJsonLoader)) {
      gltf = this._gltfJsonLoader.gltf;
    } else {
      gltf = this._gltfJson;
    }
    parse(this, gltf, supportedImageFormats, frameState);
    if (defined_default(this._gltfJsonLoader) && this._releaseGltfJson) {
      ResourceCache_default.unload(this._gltfJsonLoader);
      this._gltfJsonLoader = void 0;
    }
  }
  if (this._textureState === GltfLoaderState.LOADED) {
    this._textureState = GltfLoaderState.PROCESSING;
  }
  if (this._state === GltfLoaderState.PROCESSING || this._textureState === GltfLoaderState.PROCESSING) {
    process2(this, frameState);
  }
  if (this._state === GltfLoaderState.PROCESSED) {
    unloadBufferViews2(this);
    this._state = GltfLoaderState.READY;
    this._promise.resolve(this);
  }
  if (this._textureState === GltfLoaderState.PROCESSED) {
    this._textureState = GltfLoaderState.READY;
    this._texturesLoadedPromise.resolve(this);
  }
};
function loadVertexBuffer(loader, gltf, accessorId, semantic, draco, dequantize, loadAsTypedArray) {
  const accessor = gltf.accessors[accessorId];
  const bufferViewId = accessor.bufferView;
  const vertexBufferLoader = ResourceCache_default.loadVertexBuffer({
    gltf,
    gltfResource: loader._gltfResource,
    baseResource: loader._baseResource,
    bufferViewId,
    draco,
    attributeSemantic: semantic,
    accessorId,
    asynchronous: loader._asynchronous,
    dequantize,
    loadAsTypedArray
  });
  loader._geometryLoaders.push(vertexBufferLoader);
  return vertexBufferLoader;
}
function loadIndexBuffer(loader, gltf, accessorId, draco, loadAsTypedArray) {
  const indexBufferLoader = ResourceCache_default.loadIndexBuffer({
    gltf,
    accessorId,
    gltfResource: loader._gltfResource,
    baseResource: loader._baseResource,
    draco,
    asynchronous: loader._asynchronous,
    loadAsTypedArray
  });
  loader._geometryLoaders.push(indexBufferLoader);
  return indexBufferLoader;
}
function loadBufferView(loader, gltf, bufferViewId) {
  const bufferViewLoader = ResourceCache_default.loadBufferView({
    gltf,
    bufferViewId,
    gltfResource: loader._gltfResource,
    baseResource: loader._baseResource
  });
  loader._bufferViewLoaders.push(bufferViewLoader);
  return bufferViewLoader;
}
function getPackedTypedArray(gltf, accessor, bufferViewTypedArray) {
  let byteOffset = accessor.byteOffset;
  const byteStride = getAccessorByteStride_default(gltf, accessor);
  const count = accessor.count;
  const componentCount = numberOfComponentsForType_default(accessor.type);
  const componentType = accessor.componentType;
  const componentByteLength = ComponentDatatype_default.getSizeInBytes(componentType);
  const defaultByteStride = componentByteLength * componentCount;
  const componentsLength = count * componentCount;
  if (byteStride === defaultByteStride) {
    bufferViewTypedArray = new Uint8Array(bufferViewTypedArray);
    return ComponentDatatype_default.createArrayBufferView(
      componentType,
      bufferViewTypedArray.buffer,
      bufferViewTypedArray.byteOffset + byteOffset,
      componentsLength
    );
  }
  const accessorTypedArray = ComponentDatatype_default.createTypedArray(
    componentType,
    componentsLength
  );
  const dataView = new DataView(bufferViewTypedArray.buffer);
  const components = new Array(componentCount);
  const componentReader = getComponentReader_default(accessor.componentType);
  byteOffset = bufferViewTypedArray.byteOffset + byteOffset;
  for (let i2 = 0; i2 < count; ++i2) {
    componentReader(
      dataView,
      byteOffset,
      componentCount,
      componentByteLength,
      components
    );
    for (let j = 0; j < componentCount; ++j) {
      accessorTypedArray[i2 * componentCount + j] = components[j];
    }
    byteOffset += byteStride;
  }
  return accessorTypedArray;
}
function loadDefaultAccessorValues(accessor, values) {
  const accessorType = accessor.type;
  if (accessorType === AttributeType_default.SCALAR) {
    return arrayFill_default(values, 0);
  }
  const MathType = AttributeType_default.getMathType(accessorType);
  return arrayFill_default(values, MathType.clone(MathType.ZERO));
}
function loadAccessorValues(accessor, packedTypedArray, values, useQuaternion) {
  const accessorType = accessor.type;
  const accessorCount = accessor.count;
  if (accessorType === AttributeType_default.SCALAR) {
    for (let i2 = 0; i2 < accessorCount; i2++) {
      values[i2] = packedTypedArray[i2];
    }
  } else if (accessorType === AttributeType_default.VEC4 && useQuaternion) {
    for (let i2 = 0; i2 < accessorCount; i2++) {
      values[i2] = Quaternion_default.unpack(packedTypedArray, i2 * 4);
    }
  } else {
    const MathType = AttributeType_default.getMathType(accessorType);
    const numberOfComponents = AttributeType_default.getNumberOfComponents(
      accessorType
    );
    for (let i2 = 0; i2 < accessorCount; i2++) {
      values[i2] = MathType.unpack(packedTypedArray, i2 * numberOfComponents);
    }
  }
  return values;
}
function loadAccessor(loader, gltf, accessorId, useQuaternion) {
  const accessor = gltf.accessors[accessorId];
  const accessorCount = accessor.count;
  const values = new Array(accessorCount);
  const bufferViewId = accessor.bufferView;
  if (defined_default(bufferViewId)) {
    const bufferViewLoader = loadBufferView(loader, gltf, bufferViewId);
    bufferViewLoader.promise.then(function(bufferViewLoader2) {
      if (loader.isDestroyed()) {
        return;
      }
      const bufferViewTypedArray = bufferViewLoader2.typedArray;
      const packedTypedArray = getPackedTypedArray(
        gltf,
        accessor,
        bufferViewTypedArray
      );
      useQuaternion = defaultValue_default(useQuaternion, false);
      loadAccessorValues(accessor, packedTypedArray, values, useQuaternion);
    }).catch(function() {
      loadDefaultAccessorValues(accessor, values);
    });
    return values;
  }
  return loadDefaultAccessorValues(accessor, values);
}
function fromArray(MathType, values) {
  if (!defined_default(values)) {
    return void 0;
  }
  if (MathType === Number) {
    return values[0];
  }
  return MathType.unpack(values);
}
function getDefault2(MathType) {
  if (MathType === Number) {
    return 0;
  }
  return new MathType();
}
function createAttribute(gltf, accessorId, name, semantic, setIndex) {
  const accessor = gltf.accessors[accessorId];
  const MathType = AttributeType_default.getMathType(accessor.type);
  const attribute = new Attribute2();
  attribute.name = name;
  attribute.semantic = semantic;
  attribute.setIndex = setIndex;
  attribute.constant = getDefault2(MathType);
  attribute.componentDatatype = accessor.componentType;
  attribute.normalized = defaultValue_default(accessor.normalized, false);
  attribute.count = accessor.count;
  attribute.type = accessor.type;
  attribute.min = fromArray(MathType, accessor.min);
  attribute.max = fromArray(MathType, accessor.max);
  attribute.byteOffset = accessor.byteOffset;
  attribute.byteStride = getAccessorByteStride_default(gltf, accessor);
  return attribute;
}
function getSetIndex(gltfSemantic) {
  const setIndexRegex = /^\w+_(\d+)$/;
  const setIndexMatch = setIndexRegex.exec(gltfSemantic);
  if (setIndexMatch !== null) {
    return parseInt(setIndexMatch[1]);
  }
  return void 0;
}
function loadAttribute(loader, gltf, accessorId, semanticType, gltfSemantic, draco, dequantize, loadAsTypedArray, loadAsTypedArrayPacked) {
  const accessor = gltf.accessors[accessorId];
  const bufferViewId = accessor.bufferView;
  let renamedSemantic = gltfSemantic;
  if (loader._renameBatchIdSemantic && (gltfSemantic === "_BATCHID" || gltfSemantic === "BATCHID")) {
    renamedSemantic = "_FEATURE_ID_0";
  }
  const name = gltfSemantic;
  const modelSemantic = semanticType.fromGltfSemantic(renamedSemantic);
  const setIndex = defined_default(modelSemantic) ? getSetIndex(renamedSemantic) : void 0;
  const attribute = createAttribute(
    gltf,
    accessorId,
    name,
    modelSemantic,
    setIndex
  );
  if (!defined_default(draco) && !defined_default(bufferViewId)) {
    return attribute;
  }
  const vertexBufferLoader = loadVertexBuffer(
    loader,
    gltf,
    accessorId,
    gltfSemantic,
    draco,
    dequantize,
    loadAsTypedArray
  );
  vertexBufferLoader.promise.then(function(vertexBufferLoader2) {
    if (loader.isDestroyed()) {
      return;
    }
    if (loadAsTypedArrayPacked) {
      const bufferViewTypedArray = vertexBufferLoader2.typedArray;
      attribute.packedTypedArray = getPackedTypedArray(
        gltf,
        accessor,
        bufferViewTypedArray
      );
      attribute.byteOffset = 0;
      attribute.byteStride = void 0;
    } else if (loadAsTypedArray) {
      attribute.typedArray = vertexBufferLoader2.typedArray;
    } else {
      attribute.buffer = vertexBufferLoader2.buffer;
    }
    attribute.count = accessor.count;
    if (defined_default(draco) && defined_default(draco.attributes) && defined_default(draco.attributes[gltfSemantic])) {
      attribute.byteOffset = 0;
      attribute.byteStride = void 0;
      attribute.quantization = vertexBufferLoader2.quantization;
    }
  });
  return attribute;
}
function loadVertexAttribute(loader, gltf, accessorId, gltfSemantic, draco) {
  return loadAttribute(
    loader,
    gltf,
    accessorId,
    VertexAttributeSemantic_default,
    gltfSemantic,
    draco,
    false,
    loader._loadAsTypedArray,
    false
  );
}
function loadInstancedAttribute(loader, gltf, accessorId, gltfSemantic, loadAsTypedArrayPacked) {
  return loadAttribute(
    loader,
    gltf,
    accessorId,
    InstanceAttributeSemantic_default,
    gltfSemantic,
    void 0,
    true,
    loadAsTypedArrayPacked,
    loadAsTypedArrayPacked
  );
}
function loadIndices(loader, gltf, accessorId, draco) {
  const accessor = gltf.accessors[accessorId];
  const bufferViewId = accessor.bufferView;
  if (!defined_default(draco) && !defined_default(bufferViewId)) {
    return void 0;
  }
  const indices2 = new Indices2();
  indices2.count = accessor.count;
  const loadAsTypedArray = loader._loadAsTypedArray;
  const indexBufferLoader = loadIndexBuffer(
    loader,
    gltf,
    accessorId,
    draco,
    loadAsTypedArray
  );
  indexBufferLoader.promise.then(function(indexBufferLoader2) {
    if (loader.isDestroyed()) {
      return;
    }
    indices2.indexDatatype = indexBufferLoader2.indexDatatype;
    if (defined_default(indexBufferLoader2.buffer)) {
      indices2.buffer = indexBufferLoader2.buffer;
    } else {
      indices2.typedArray = indexBufferLoader2.typedArray;
    }
  });
  return indices2;
}
function loadTexture(loader, gltf, textureInfo, supportedImageFormats, samplerOverride) {
  const imageId = GltfLoaderUtil_default.getImageIdFromTexture({
    gltf,
    textureId: textureInfo.index,
    supportedImageFormats
  });
  if (!defined_default(imageId)) {
    return void 0;
  }
  const textureLoader = ResourceCache_default.loadTexture({
    gltf,
    textureInfo,
    gltfResource: loader._gltfResource,
    baseResource: loader._baseResource,
    supportedImageFormats,
    asynchronous: loader._asynchronous
  });
  loader._textureLoaders.push(textureLoader);
  const textureReader = GltfLoaderUtil_default.createModelTextureReader({
    textureInfo
  });
  textureLoader.promise.then(function(textureLoader2) {
    if (loader.isDestroyed()) {
      return;
    }
    textureReader.texture = textureLoader2.texture;
    if (defined_default(samplerOverride)) {
      textureReader.texture.sampler = samplerOverride;
    }
  });
  return textureReader;
}
function loadMaterial(loader, gltf, gltfMaterial, supportedImageFormats) {
  const material = new Material3();
  const extensions = defaultValue_default(
    gltfMaterial.extensions,
    defaultValue_default.EMPTY_OBJECT
  );
  const pbrSpecularGlossiness = extensions.KHR_materials_pbrSpecularGlossiness;
  const pbrMetallicRoughness = gltfMaterial.pbrMetallicRoughness;
  material.unlit = defined_default(extensions.KHR_materials_unlit);
  if (defined_default(pbrSpecularGlossiness)) {
    const specularGlossiness = new SpecularGlossiness2();
    material.specularGlossiness = specularGlossiness;
    if (defined_default(pbrSpecularGlossiness.diffuseTexture)) {
      specularGlossiness.diffuseTexture = loadTexture(
        loader,
        gltf,
        pbrSpecularGlossiness.diffuseTexture,
        supportedImageFormats
      );
    }
    if (defined_default(pbrSpecularGlossiness.specularGlossinessTexture)) {
      if (defined_default(pbrSpecularGlossiness.specularGlossinessTexture)) {
        specularGlossiness.specularGlossinessTexture = loadTexture(
          loader,
          gltf,
          pbrSpecularGlossiness.specularGlossinessTexture,
          supportedImageFormats
        );
      }
    }
    specularGlossiness.diffuseFactor = fromArray(
      Cartesian4_default,
      pbrSpecularGlossiness.diffuseFactor
    );
    specularGlossiness.specularFactor = fromArray(
      Cartesian3_default,
      pbrSpecularGlossiness.specularFactor
    );
    specularGlossiness.glossinessFactor = pbrSpecularGlossiness.glossinessFactor;
    material.pbrSpecularGlossiness = pbrSpecularGlossiness;
  } else if (defined_default(pbrMetallicRoughness)) {
    const metallicRoughness = new MetallicRoughness2();
    material.metallicRoughness = metallicRoughness;
    if (defined_default(pbrMetallicRoughness.baseColorTexture)) {
      metallicRoughness.baseColorTexture = loadTexture(
        loader,
        gltf,
        pbrMetallicRoughness.baseColorTexture,
        supportedImageFormats
      );
    }
    if (defined_default(pbrMetallicRoughness.metallicRoughnessTexture)) {
      metallicRoughness.metallicRoughnessTexture = loadTexture(
        loader,
        gltf,
        pbrMetallicRoughness.metallicRoughnessTexture,
        supportedImageFormats
      );
    }
    metallicRoughness.baseColorFactor = fromArray(
      Cartesian4_default,
      pbrMetallicRoughness.baseColorFactor
    );
    metallicRoughness.metallicFactor = pbrMetallicRoughness.metallicFactor;
    metallicRoughness.roughnessFactor = pbrMetallicRoughness.roughnessFactor;
    material.pbrMetallicRoughness = pbrMetallicRoughness;
  }
  if (defined_default(gltfMaterial.emissiveTexture)) {
    material.emissiveTexture = loadTexture(
      loader,
      gltf,
      gltfMaterial.emissiveTexture,
      supportedImageFormats
    );
  }
  if (defined_default(gltfMaterial.normalTexture)) {
    material.normalTexture = loadTexture(
      loader,
      gltf,
      gltfMaterial.normalTexture,
      supportedImageFormats
    );
  }
  if (defined_default(gltfMaterial.occlusionTexture)) {
    material.occlusionTexture = loadTexture(
      loader,
      gltf,
      gltfMaterial.occlusionTexture,
      supportedImageFormats
    );
  }
  material.emissiveFactor = fromArray(Cartesian3_default, gltfMaterial.emissiveFactor);
  material.alphaMode = gltfMaterial.alphaMode;
  material.alphaCutoff = gltfMaterial.alphaCutoff;
  material.doubleSided = gltfMaterial.doubleSided;
  return material;
}
function loadFeatureIdAttribute(featureIds, positionalLabel) {
  const featureIdAttribute = new FeatureIdAttribute2();
  featureIdAttribute.featureCount = featureIds.featureCount;
  featureIdAttribute.nullFeatureId = featureIds.nullFeatureId;
  featureIdAttribute.propertyTableId = featureIds.propertyTable;
  featureIdAttribute.setIndex = featureIds.attribute;
  featureIdAttribute.label = featureIds.label;
  featureIdAttribute.positionalLabel = positionalLabel;
  return featureIdAttribute;
}
function loadFeatureIdAttributeLegacy(gltfFeatureIdAttribute, featureTableId, featureCount, positionalLabel) {
  const featureIdAttribute = new FeatureIdAttribute2();
  const featureIds = gltfFeatureIdAttribute.featureIds;
  featureIdAttribute.featureCount = featureCount;
  featureIdAttribute.propertyTableId = featureTableId;
  featureIdAttribute.setIndex = getSetIndex(featureIds.attribute);
  featureIdAttribute.positionalLabel = positionalLabel;
  return featureIdAttribute;
}
function loadDefaultFeatureIds(featureIds, positionalLabel) {
  const featureIdRange = new FeatureIdImplicitRange2();
  featureIdRange.propertyTableId = featureIds.propertyTable;
  featureIdRange.featureCount = featureIds.featureCount;
  featureIdRange.nullFeatureId = featureIds.nullFeatureId;
  featureIdRange.label = featureIds.label;
  featureIdRange.positionalLabel = positionalLabel;
  featureIdRange.offset = 0;
  featureIdRange.repeat = 1;
  return featureIdRange;
}
function loadFeatureIdImplicitRangeLegacy(gltfFeatureIdAttribute, featureTableId, featureCount, positionalLabel) {
  const featureIdRange = new FeatureIdImplicitRange2();
  const featureIds = gltfFeatureIdAttribute.featureIds;
  featureIdRange.propertyTableId = featureTableId;
  featureIdRange.featureCount = featureCount;
  featureIdRange.offset = defaultValue_default(featureIds.constant, 0);
  const divisor = defaultValue_default(featureIds.divisor, 0);
  featureIdRange.repeat = divisor === 0 ? void 0 : divisor;
  featureIdRange.positionalLabel = positionalLabel;
  return featureIdRange;
}
function loadFeatureIdTexture(loader, gltf, gltfFeatureIdTexture, supportedImageFormats, positionalLabel) {
  const featureIdTexture = new FeatureIdTexture2();
  featureIdTexture.featureCount = gltfFeatureIdTexture.featureCount;
  featureIdTexture.nullFeatureId = gltfFeatureIdTexture.nullFeatureId;
  featureIdTexture.propertyTableId = gltfFeatureIdTexture.propertyTable;
  featureIdTexture.label = gltfFeatureIdTexture.label;
  featureIdTexture.positionalLabel = positionalLabel;
  const textureInfo = gltfFeatureIdTexture.texture;
  featureIdTexture.textureReader = loadTexture(
    loader,
    gltf,
    textureInfo,
    supportedImageFormats,
    Sampler_default.NEAREST
  );
  const channelString = textureInfo.channels.map(function(channelIndex) {
    return "rgba".charAt(channelIndex);
  }).join("");
  featureIdTexture.textureReader.channels = channelString;
  return featureIdTexture;
}
function loadFeatureIdTextureLegacy(loader, gltf, gltfFeatureIdTexture, featureTableId, supportedImageFormats, featureCount, positionalLabel) {
  const featureIdTexture = new FeatureIdTexture2();
  const featureIds = gltfFeatureIdTexture.featureIds;
  const textureInfo = featureIds.texture;
  featureIdTexture.featureCount = featureCount;
  featureIdTexture.propertyTableId = featureTableId;
  featureIdTexture.textureReader = loadTexture(
    loader,
    gltf,
    textureInfo,
    supportedImageFormats,
    Sampler_default.NEAREST
  );
  featureIdTexture.textureReader.channels = featureIds.channels;
  featureIdTexture.positionalLabel = positionalLabel;
  return featureIdTexture;
}
function loadMorphTarget(loader, gltf, target) {
  const morphTarget = new MorphTarget2();
  for (const semantic in target) {
    if (target.hasOwnProperty(semantic)) {
      const accessorId = target[semantic];
      morphTarget.attributes.push(
        loadVertexAttribute(loader, gltf, accessorId, semantic, void 0)
      );
    }
  }
  return morphTarget;
}
function loadPrimitive(loader, gltf, gltfPrimitive, supportedImageFormats) {
  const primitive = new Primitive3();
  const materialId = gltfPrimitive.material;
  if (defined_default(materialId)) {
    primitive.material = loadMaterial(
      loader,
      gltf,
      gltf.materials[materialId],
      supportedImageFormats
    );
  }
  const extensions = defaultValue_default(
    gltfPrimitive.extensions,
    defaultValue_default.EMPTY_OBJECT
  );
  const draco = extensions.KHR_draco_mesh_compression;
  const attributes = gltfPrimitive.attributes;
  if (defined_default(attributes)) {
    for (const semantic in attributes) {
      if (attributes.hasOwnProperty(semantic)) {
        const accessorId = attributes[semantic];
        primitive.attributes.push(
          loadVertexAttribute(loader, gltf, accessorId, semantic, draco)
        );
      }
    }
  }
  const targets = gltfPrimitive.targets;
  if (defined_default(targets)) {
    const targetsLength = targets.length;
    for (let i2 = 0; i2 < targetsLength; ++i2) {
      primitive.morphTargets.push(loadMorphTarget(loader, gltf, targets[i2]));
    }
  }
  const indices2 = gltfPrimitive.indices;
  if (defined_default(indices2)) {
    primitive.indices = loadIndices(loader, gltf, indices2, draco);
  }
  const structuralMetadata = extensions.EXT_structural_metadata;
  const meshFeatures = extensions.EXT_mesh_features;
  const featureMetadataLegacy = extensions.EXT_feature_metadata;
  const hasFeatureMetadataLegacy = defined_default(featureMetadataLegacy);
  if (defined_default(meshFeatures)) {
    loadPrimitiveFeatures(
      loader,
      gltf,
      primitive,
      meshFeatures,
      supportedImageFormats
    );
  } else if (hasFeatureMetadataLegacy) {
    loadPrimitiveFeaturesLegacy(
      loader,
      gltf,
      primitive,
      featureMetadataLegacy,
      supportedImageFormats
    );
  }
  if (defined_default(structuralMetadata)) {
    loadPrimitiveMetadata(primitive, structuralMetadata);
  } else if (hasFeatureMetadataLegacy) {
    loadPrimitiveMetadataLegacy(loader, primitive, featureMetadataLegacy);
  }
  primitive.primitiveType = gltfPrimitive.mode;
  return primitive;
}
function loadPrimitiveFeatures(loader, gltf, primitive, meshFeaturesExtension, supportedImageFormats) {
  let featureIdsArray;
  if (defined_default(meshFeaturesExtension) && defined_default(meshFeaturesExtension.featureIds)) {
    featureIdsArray = meshFeaturesExtension.featureIds;
  } else {
    featureIdsArray = [];
  }
  for (let i2 = 0; i2 < featureIdsArray.length; i2++) {
    const featureIds = featureIdsArray[i2];
    const label = `featureId_${i2}`;
    let featureIdComponent;
    if (defined_default(featureIds.texture)) {
      featureIdComponent = loadFeatureIdTexture(
        loader,
        gltf,
        featureIds,
        supportedImageFormats,
        label
      );
    } else if (defined_default(featureIds.attribute)) {
      featureIdComponent = loadFeatureIdAttribute(featureIds, label);
    } else {
      featureIdComponent = loadDefaultFeatureIds(featureIds, label);
    }
    primitive.featureIds.push(featureIdComponent);
  }
}
function loadPrimitiveFeaturesLegacy(loader, gltf, primitive, metadataExtension, supportedImageFormats) {
  const featureTables = gltf.extensions.EXT_feature_metadata.featureTables;
  let nextFeatureIdIndex = 0;
  const featureIdAttributes = metadataExtension.featureIdAttributes;
  if (defined_default(featureIdAttributes)) {
    const featureIdAttributesLength = featureIdAttributes.length;
    for (let i2 = 0; i2 < featureIdAttributesLength; ++i2) {
      const featureIdAttribute = featureIdAttributes[i2];
      const featureTableId = featureIdAttribute.featureTable;
      const propertyTableId = loader._sortedPropertyTableIds.indexOf(
        featureTableId
      );
      const featureCount = featureTables[featureTableId].count;
      const label = `featureId_${nextFeatureIdIndex}`;
      nextFeatureIdIndex++;
      let featureIdComponent;
      if (defined_default(featureIdAttribute.featureIds.attribute)) {
        featureIdComponent = loadFeatureIdAttributeLegacy(
          featureIdAttribute,
          propertyTableId,
          featureCount,
          label
        );
      } else {
        featureIdComponent = loadFeatureIdImplicitRangeLegacy(
          featureIdAttribute,
          propertyTableId,
          featureCount,
          label
        );
      }
      primitive.featureIds.push(featureIdComponent);
    }
  }
  const featureIdTextures = metadataExtension.featureIdTextures;
  if (defined_default(featureIdTextures)) {
    const featureIdTexturesLength = featureIdTextures.length;
    for (let i2 = 0; i2 < featureIdTexturesLength; ++i2) {
      const featureIdTexture = featureIdTextures[i2];
      const featureTableId = featureIdTexture.featureTable;
      const propertyTableId = loader._sortedPropertyTableIds.indexOf(
        featureTableId
      );
      const featureCount = featureTables[featureTableId].count;
      const featureIdLabel = `featureId_${nextFeatureIdIndex}`;
      nextFeatureIdIndex++;
      const featureIdComponent = loadFeatureIdTextureLegacy(
        loader,
        gltf,
        featureIdTexture,
        propertyTableId,
        supportedImageFormats,
        featureCount,
        featureIdLabel
      );
      primitive.featureIds.push(featureIdComponent);
    }
  }
}
function loadPrimitiveMetadata(primitive, structuralMetadataExtension) {
  if (!defined_default(structuralMetadataExtension)) {
    return;
  }
  if (defined_default(structuralMetadataExtension.propertyTextures)) {
    primitive.propertyTextureIds = structuralMetadataExtension.propertyTextures;
  }
  if (defined_default(structuralMetadataExtension.propertyAttributes)) {
    primitive.propertyAttributeIds = structuralMetadataExtension.propertyAttributes;
  }
}
function loadPrimitiveMetadataLegacy(loader, primitive, metadataExtension) {
  if (defined_default(metadataExtension.featureTextures)) {
    primitive.propertyTextureIds = metadataExtension.featureTextures.map(
      function(id) {
        return loader._sortedFeatureTextureIds.indexOf(id);
      }
    );
  }
}
function loadInstances(loader, gltf, nodeExtensions, frameState) {
  const instancingExtension = nodeExtensions.EXT_mesh_gpu_instancing;
  const instances = new Instances2();
  const attributes = instancingExtension.attributes;
  if (defined_default(attributes)) {
    const hasRotation = defined_default(attributes.ROTATION);
    const hasTranslationMinMax = defined_default(attributes.TRANSLATION) && defined_default(gltf.accessors[attributes.TRANSLATION].min) && defined_default(gltf.accessors[attributes.TRANSLATION].max);
    for (const semantic in attributes) {
      if (attributes.hasOwnProperty(semantic)) {
        const loadAsTypedArrayPacked = loader._loadAsTypedArray || !frameState.context.instancedArrays || (hasRotation || !hasTranslationMinMax) && (semantic === InstanceAttributeSemantic_default.TRANSLATION || semantic === InstanceAttributeSemantic_default.ROTATION || semantic === InstanceAttributeSemantic_default.SCALE) || semantic.indexOf(InstanceAttributeSemantic_default.FEATURE_ID) >= 0;
        const accessorId = attributes[semantic];
        instances.attributes.push(
          loadInstancedAttribute(
            loader,
            gltf,
            accessorId,
            semantic,
            loadAsTypedArrayPacked
          )
        );
      }
    }
  }
  const instancingExtExtensions = defaultValue_default(
    instancingExtension.extensions,
    defaultValue_default.EMPTY_OBJECT
  );
  const instanceFeatures = nodeExtensions.EXT_instance_features;
  const featureMetadataLegacy = instancingExtExtensions.EXT_feature_metadata;
  if (defined_default(instanceFeatures)) {
    loadInstanceFeatures(instances, instanceFeatures);
  } else if (defined_default(featureMetadataLegacy)) {
    loadInstanceFeaturesLegacy(
      gltf,
      instances,
      featureMetadataLegacy,
      loader._sortedPropertyTableIds
    );
  }
  return instances;
}
function loadInstanceFeatures(instances, instanceFeaturesExtension) {
  const featureIdsArray = instanceFeaturesExtension.featureIds;
  for (let i2 = 0; i2 < featureIdsArray.length; i2++) {
    const featureIds = featureIdsArray[i2];
    const label = `instanceFeatureId_${i2}`;
    let featureIdComponent;
    if (defined_default(featureIds.attribute)) {
      featureIdComponent = loadFeatureIdAttribute(featureIds, label);
    } else {
      featureIdComponent = loadDefaultFeatureIds(featureIds, label);
    }
    instances.featureIds.push(featureIdComponent);
  }
}
function loadInstanceFeaturesLegacy(gltf, instances, metadataExtension, sortedPropertyTableIds) {
  const featureTables = gltf.extensions.EXT_feature_metadata.featureTables;
  const featureIdAttributes = metadataExtension.featureIdAttributes;
  if (defined_default(featureIdAttributes)) {
    const featureIdAttributesLength = featureIdAttributes.length;
    for (let i2 = 0; i2 < featureIdAttributesLength; ++i2) {
      const featureIdAttribute = featureIdAttributes[i2];
      const featureTableId = featureIdAttribute.featureTable;
      const propertyTableId = sortedPropertyTableIds.indexOf(featureTableId);
      const featureCount = featureTables[featureTableId].count;
      const label = `instanceFeatureId_${i2}`;
      let featureIdComponent;
      if (defined_default(featureIdAttribute.featureIds.attribute)) {
        featureIdComponent = loadFeatureIdAttributeLegacy(
          featureIdAttribute,
          propertyTableId,
          featureCount,
          label
        );
      } else {
        featureIdComponent = loadFeatureIdImplicitRangeLegacy(
          featureIdAttribute,
          propertyTableId,
          featureCount,
          label
        );
      }
      instances.featureIds.push(featureIdComponent);
    }
  }
}
function loadNode(loader, gltf, gltfNode, supportedImageFormats, frameState) {
  const node = new Node5();
  node.name = gltfNode.name;
  node.matrix = fromArray(Matrix4_default, gltfNode.matrix);
  node.translation = fromArray(Cartesian3_default, gltfNode.translation);
  node.rotation = fromArray(Quaternion_default, gltfNode.rotation);
  node.scale = fromArray(Cartesian3_default, gltfNode.scale);
  const meshId = gltfNode.mesh;
  if (defined_default(meshId)) {
    const mesh2 = gltf.meshes[meshId];
    const primitives = mesh2.primitives;
    const primitivesLength = primitives.length;
    for (let i2 = 0; i2 < primitivesLength; ++i2) {
      node.primitives.push(
        loadPrimitive(loader, gltf, primitives[i2], supportedImageFormats)
      );
    }
    const morphWeights = defaultValue_default(gltfNode.weights, mesh2.weights);
    const targets = node.primitives[0].morphTargets;
    const targetsLength = targets.length;
    node.morphWeights = defined_default(morphWeights) ? morphWeights.slice() : arrayFill_default(new Array(targetsLength), 0);
  }
  const nodeExtensions = defaultValue_default(
    gltfNode.extensions,
    defaultValue_default.EMPTY_OBJECT
  );
  const instancingExtension = nodeExtensions.EXT_mesh_gpu_instancing;
  if (defined_default(instancingExtension)) {
    node.instances = loadInstances(loader, gltf, nodeExtensions, frameState);
  }
  return node;
}
function loadNodes(loader, gltf, supportedImageFormats, frameState) {
  let i2;
  let j;
  const nodesLength = gltf.nodes.length;
  const nodes = new Array(nodesLength);
  for (i2 = 0; i2 < nodesLength; ++i2) {
    const node = loadNode(
      loader,
      gltf,
      gltf.nodes[i2],
      supportedImageFormats,
      frameState
    );
    node.index = i2;
    nodes[i2] = node;
  }
  for (i2 = 0; i2 < nodesLength; ++i2) {
    const childrenNodeIds = gltf.nodes[i2].children;
    if (defined_default(childrenNodeIds)) {
      const childrenLength = childrenNodeIds.length;
      for (j = 0; j < childrenLength; ++j) {
        nodes[i2].children.push(nodes[childrenNodeIds[j]]);
      }
    }
  }
  return nodes;
}
function loadSkin(loader, gltf, gltfSkin, nodes) {
  const skin = new Skin2();
  const jointIds = gltfSkin.joints;
  const jointsLength = jointIds.length;
  const joints = new Array(jointsLength);
  for (let i2 = 0; i2 < jointsLength; ++i2) {
    joints[i2] = nodes[jointIds[i2]];
  }
  skin.joints = joints;
  const inverseBindMatricesAccessorId = gltfSkin.inverseBindMatrices;
  if (defined_default(inverseBindMatricesAccessorId)) {
    skin.inverseBindMatrices = loadAccessor(
      loader,
      gltf,
      inverseBindMatricesAccessorId
    );
  } else {
    skin.inverseBindMatrices = arrayFill_default(
      new Array(jointsLength),
      Matrix4_default.IDENTITY
    );
  }
  return skin;
}
function loadSkins(loader, gltf, nodes) {
  let i2;
  const gltfSkins = gltf.skins;
  if (!defined_default(gltfSkins)) {
    return [];
  }
  const skinsLength = gltf.skins.length;
  const skins = new Array(skinsLength);
  for (i2 = 0; i2 < skinsLength; ++i2) {
    const skin = loadSkin(loader, gltf, gltf.skins[i2], nodes);
    skin.index = i2;
    skins[i2] = skin;
  }
  const nodesLength = nodes.length;
  for (i2 = 0; i2 < nodesLength; ++i2) {
    const skinId = gltf.nodes[i2].skin;
    if (defined_default(skinId)) {
      nodes[i2].skin = skins[skinId];
    }
  }
  return skins;
}
function loadStructuralMetadata(loader, gltf, extension, extensionLegacy, supportedImageFormats) {
  const structuralMetadataLoader = new GltfStructuralMetadataLoader({
    gltf,
    extension,
    extensionLegacy,
    gltfResource: loader._gltfResource,
    baseResource: loader._baseResource,
    supportedImageFormats,
    asynchronous: loader._asynchronous
  });
  structuralMetadataLoader.load();
  loader._structuralMetadataLoader = structuralMetadataLoader;
  return structuralMetadataLoader;
}
function loadAnimationSampler(loader, gltf, gltfSampler) {
  const animationSampler = new AnimationSampler2();
  const inputAccessorId = gltfSampler.input;
  animationSampler.input = loadAccessor(loader, gltf, inputAccessorId);
  const gltfInterpolation = gltfSampler.interpolation;
  animationSampler.interpolation = defaultValue_default(
    InterpolationType_default[gltfInterpolation],
    InterpolationType_default.LINEAR
  );
  const outputAccessorId = gltfSampler.output;
  animationSampler.output = loadAccessor(loader, gltf, outputAccessorId, true);
  return animationSampler;
}
function loadAnimationTarget(gltfTarget, nodes) {
  const animationTarget = new AnimationTarget2();
  const nodeIndex = gltfTarget.node;
  if (!defined_default(nodeIndex)) {
    return void 0;
  }
  animationTarget.node = nodes[nodeIndex];
  const path = gltfTarget.path.toUpperCase();
  animationTarget.path = AnimatedPropertyType2[path];
  return animationTarget;
}
function loadAnimationChannel(gltfChannel, samplers, nodes) {
  const animationChannel = new AnimationChannel2();
  const samplerIndex = gltfChannel.sampler;
  animationChannel.sampler = samplers[samplerIndex];
  animationChannel.target = loadAnimationTarget(gltfChannel.target, nodes);
  return animationChannel;
}
function loadAnimation(loader, gltf, gltfAnimation, nodes) {
  let i2;
  const animation = new Animation2();
  animation.name = gltfAnimation.name;
  const gltfSamplers = gltfAnimation.samplers;
  const samplersLength = gltfSamplers.length;
  const samplers = new Array(samplersLength);
  for (i2 = 0; i2 < samplersLength; i2++) {
    const sampler = loadAnimationSampler(loader, gltf, gltfSamplers[i2]);
    sampler.index = i2;
    samplers[i2] = sampler;
  }
  const gltfChannels = gltfAnimation.channels;
  const channelsLength = gltfChannels.length;
  const channels = new Array(channelsLength);
  for (i2 = 0; i2 < channelsLength; i2++) {
    channels[i2] = loadAnimationChannel(gltfChannels[i2], samplers, nodes);
  }
  animation.samplers = samplers;
  animation.channels = channels;
  return animation;
}
function loadAnimations(loader, gltf, nodes) {
  let i2;
  const gltfAnimations = gltf.animations;
  if (!defined_default(gltfAnimations)) {
    return [];
  }
  const animationsLength = gltf.animations.length;
  const animations = new Array(animationsLength);
  for (i2 = 0; i2 < animationsLength; ++i2) {
    const animation = loadAnimation(loader, gltf, gltf.animations[i2], nodes);
    animation.index = i2;
    animations[i2] = animation;
  }
  return animations;
}
function getSceneNodeIds(gltf) {
  let nodesIds;
  if (defined_default(gltf.scenes) && defined_default(gltf.scene)) {
    nodesIds = gltf.scenes[gltf.scene].nodes;
  }
  nodesIds = defaultValue_default(nodesIds, gltf.nodes);
  nodesIds = defined_default(nodesIds) ? nodesIds : [];
  return nodesIds;
}
function loadScene(gltf, nodes) {
  const scene = new Scene2();
  const sceneNodeIds = getSceneNodeIds(gltf);
  scene.nodes = sceneNodeIds.map(function(sceneNodeId) {
    return nodes[sceneNodeId];
  });
  return scene;
}
function parse(loader, gltf, supportedImageFormats, frameState) {
  const extensions = defaultValue_default(gltf.extensions, defaultValue_default.EMPTY_OBJECT);
  const structuralMetadataExtension = extensions.EXT_structural_metadata;
  const featureMetadataExtensionLegacy = extensions.EXT_feature_metadata;
  if (defined_default(featureMetadataExtensionLegacy)) {
    const featureTables = featureMetadataExtensionLegacy.featureTables;
    const featureTextures = featureMetadataExtensionLegacy.featureTextures;
    const allPropertyTableIds = defined_default(featureTables) ? featureTables : [];
    const allFeatureTextureIds = defined_default(featureTextures) ? featureTextures : [];
    loader._sortedPropertyTableIds = Object.keys(allPropertyTableIds).sort();
    loader._sortedFeatureTextureIds = Object.keys(allFeatureTextureIds).sort();
  }
  const nodes = loadNodes(loader, gltf, supportedImageFormats, frameState);
  const skins = loadSkins(loader, gltf, nodes);
  const animations = loadAnimations(loader, gltf, nodes);
  const scene = loadScene(gltf, nodes);
  const components = new Components2();
  const asset = new Asset2();
  const copyright = gltf.asset.copyright;
  if (defined_default(copyright)) {
    const credits = copyright.split(";").map(function(string) {
      return new Credit_default(string.trim());
    });
    asset.credits = credits;
  }
  components.asset = asset;
  components.scene = scene;
  components.nodes = nodes;
  components.skins = skins;
  components.animations = animations;
  components.upAxis = loader._upAxis;
  components.forwardAxis = loader._forwardAxis;
  loader._components = components;
  if (defined_default(structuralMetadataExtension) || defined_default(featureMetadataExtensionLegacy)) {
    const structuralMetadataLoader = loadStructuralMetadata(
      loader,
      gltf,
      structuralMetadataExtension,
      featureMetadataExtensionLegacy,
      supportedImageFormats
    );
    structuralMetadataLoader.promise.then(function(structuralMetadataLoader2) {
      if (loader.isDestroyed()) {
        return;
      }
      components.structuralMetadata = structuralMetadataLoader2.structuralMetadata;
    });
  }
  const loaders = [];
  loaders.push.apply(loaders, loader._bufferViewLoaders);
  loaders.push.apply(loaders, loader._geometryLoaders);
  if (defined_default(loader._structuralMetadataLoader)) {
    loaders.push(loader._structuralMetadataLoader);
  }
  if (!loader._incrementallyLoadTextures) {
    loaders.push.apply(loaders, loader._textureLoaders);
  }
  const readyPromises = loaders.map(function(loader2) {
    return loader2.promise;
  });
  const texturePromises = loader._textureLoaders.map(function(loader2) {
    return loader2.promise;
  });
  Promise.all(readyPromises).then(function() {
    if (loader.isDestroyed()) {
      return;
    }
    loader._state = GltfLoaderState.PROCESSED;
  }).catch(function(error) {
    if (loader.isDestroyed()) {
      return;
    }
    handleError6(loader, error);
  });
  Promise.all(texturePromises).then(function() {
    if (loader.isDestroyed()) {
      return;
    }
    loader._textureState = GltfLoaderState.PROCESSED;
  });
}
function unloadTextures2(loader) {
  const textureLoaders = loader._textureLoaders;
  const textureLoadersLength = textureLoaders.length;
  for (let i2 = 0; i2 < textureLoadersLength; ++i2) {
    ResourceCache_default.unload(textureLoaders[i2]);
  }
  loader._textureLoaders.length = 0;
}
function unloadBufferViews2(loader) {
  const bufferViewLoaders = loader._bufferViewLoaders;
  const bufferViewLoadersLength = bufferViewLoaders.length;
  for (let i2 = 0; i2 < bufferViewLoadersLength; ++i2) {
    ResourceCache_default.unload(bufferViewLoaders[i2]);
  }
  loader._bufferViewLoaders.length = 0;
}
function unloadGeometry(loader) {
  const geometryLoaders = loader._geometryLoaders;
  const geometryLoadersLength = geometryLoaders.length;
  for (let i2 = 0; i2 < geometryLoadersLength; ++i2) {
    ResourceCache_default.unload(geometryLoaders[i2]);
  }
  loader._geometryLoaders.length = 0;
}
function unloadStructuralMetadata(loader) {
  if (defined_default(loader._structuralMetadataLoader)) {
    loader._structuralMetadataLoader.destroy();
    loader._structuralMetadataLoader = void 0;
  }
}
GltfLoader.prototype.unload = function() {
  if (defined_default(this._gltfJsonLoader)) {
    ResourceCache_default.unload(this._gltfJsonLoader);
  }
  this._gltfJsonLoader = void 0;
  unloadTextures2(this);
  unloadBufferViews2(this);
  unloadGeometry(this);
  unloadStructuralMetadata(this);
  this._components = void 0;
};

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimentalAnimationChannel.js
var AnimatedPropertyType3 = ModelComponents_default.AnimatedPropertyType;
function ModelExperimentalAnimationChannel(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const channel = options.channel;
  const runtimeAnimation = options.runtimeAnimation;
  const runtimeNode = options.runtimeNode;
  Check_default.typeOf.object("options.channel", channel);
  Check_default.typeOf.object("options.runtimeAnimation", runtimeAnimation);
  Check_default.typeOf.object("options.runtimeNode", runtimeNode);
  this._channel = channel;
  this._runtimeAnimation = runtimeAnimation;
  this._runtimeNode = runtimeNode;
  this._splines = [];
  this._path = void 0;
  initialize13(this);
}
Object.defineProperties(ModelExperimentalAnimationChannel.prototype, {
  channel: {
    get: function() {
      return this._channel;
    }
  },
  runtimeAnimation: {
    get: function() {
      return this._runtimeAnimation;
    }
  },
  runtimeNode: {
    get: function() {
      return this._runtimeNode;
    }
  },
  splines: {
    get: function() {
      return this._splines;
    }
  }
});
function createCubicSpline(times, points) {
  const cubicPoints = [];
  const inTangents = [];
  const outTangents = [];
  const length3 = points.length;
  for (let i2 = 0; i2 < length3; i2 += 3) {
    inTangents.push(points[i2]);
    cubicPoints.push(points[i2 + 1]);
    outTangents.push(points[i2 + 2]);
  }
  inTangents.splice(0, 1);
  outTangents.length = outTangents.length - 1;
  return new HermiteSpline_default({
    times,
    points: cubicPoints,
    inTangents,
    outTangents
  });
}
function createSpline(times, points, interpolation, path) {
  if (times.length === 1 && points.length === 1) {
    return new ConstantSpline_default(points[0]);
  }
  switch (interpolation) {
    case InterpolationType_default.STEP:
      return new SteppedSpline_default({
        times,
        points
      });
    case InterpolationType_default.CUBICSPLINE:
      return createCubicSpline(times, points);
    case InterpolationType_default.LINEAR:
      if (path === AnimatedPropertyType3.ROTATION) {
        return new QuaternionSpline_default({
          times,
          points
        });
      }
      return new LinearSpline_default({
        times,
        points
      });
  }
}
function createSplines(times, points, interpolation, path, count) {
  const splines = [];
  if (path === AnimatedPropertyType3.WEIGHTS) {
    const pointsLength = points.length;
    const outputLength = pointsLength / count;
    let targetIndex, i2;
    for (targetIndex = 0; targetIndex < count; targetIndex++) {
      const output = new Array(outputLength);
      let pointsIndex = targetIndex;
      if (interpolation === InterpolationType_default.CUBICSPLINE) {
        for (i2 = 0; i2 < outputLength; i2 += 3) {
          output[i2] = points[pointsIndex];
          output[i2 + 1] = points[pointsIndex + count];
          output[i2 + 2] = points[pointsIndex + 2 * count];
          pointsIndex += count * 3;
        }
      } else {
        for (i2 = 0; i2 < outputLength; i2++) {
          output[i2] = points[pointsIndex];
          pointsIndex += count;
        }
      }
      splines.push(createSpline(times, output, interpolation, path));
    }
  } else {
    splines.push(createSpline(times, points, interpolation, path));
  }
  return splines;
}
var scratchVariable;
function initialize13(runtimeChannel) {
  const channel = runtimeChannel._channel;
  const sampler = channel.sampler;
  const times = sampler.input;
  const points = sampler.output;
  const interpolation = sampler.interpolation;
  const target = channel.target;
  const path = target.path;
  const runtimeNode = runtimeChannel._runtimeNode;
  const count = defined_default(runtimeNode.morphWeights) ? runtimeNode.morphWeights.length : 1;
  const splines = createSplines(times, points, interpolation, path, count);
  runtimeChannel._splines = splines;
  runtimeChannel._path = path;
  switch (path) {
    case AnimatedPropertyType3.TRANSLATION:
    case AnimatedPropertyType3.SCALE:
      scratchVariable = new Cartesian3_default();
      break;
    case AnimatedPropertyType3.ROTATION:
      scratchVariable = new Quaternion_default();
      break;
    case AnimatedPropertyType3.WEIGHTS:
      break;
  }
}
ModelExperimentalAnimationChannel.prototype.animate = function(time) {
  const splines = this._splines;
  const path = this._path;
  const model = this._runtimeAnimation.model;
  if (path === AnimatedPropertyType3.WEIGHTS) {
    const morphWeights = this._runtimeNode.morphWeights;
    const length3 = morphWeights.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const spline = splines[i2];
      const localAnimationTime = model.clampAnimations ? spline.clampTime(time) : spline.wrapTime(time);
      morphWeights[i2] = spline.evaluate(localAnimationTime);
    }
  } else {
    const spline = splines[0];
    const localAnimationTime = model.clampAnimations ? spline.clampTime(time) : spline.wrapTime(time);
    this._runtimeNode[path] = spline.evaluate(
      localAnimationTime,
      scratchVariable
    );
  }
};
var ModelExperimentalAnimationChannel_default = ModelExperimentalAnimationChannel;

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimentalAnimation.js
function ModelExperimentalAnimation(model, animation, options) {
  this._animation = animation;
  this._name = animation.name;
  this._runtimeChannels = void 0;
  this._startTime = JulianDate_default.clone(options.startTime);
  this._delay = defaultValue_default(options.delay, 0);
  this._stopTime = JulianDate_default.clone(options.stopTime);
  this.removeOnStop = defaultValue_default(options.removeOnStop, false);
  this._multiplier = defaultValue_default(options.multiplier, 1);
  this._reverse = defaultValue_default(options.reverse, false);
  this._loop = defaultValue_default(options.loop, ModelAnimationLoop_default.NONE);
  this.start = new Event_default();
  this.update = new Event_default();
  this.stop = new Event_default();
  this._state = ModelAnimationState_default.STOPPED;
  this._computedStartTime = void 0;
  this._duration = void 0;
  const that = this;
  this._raiseStartEvent = function() {
    that.start.raiseEvent(model, that);
  };
  this._updateEventTime = 0;
  this._raiseUpdateEvent = function() {
    that.update.raiseEvent(model, that, that._updateEventTime);
  };
  this._raiseStopEvent = function() {
    that.stop.raiseEvent(model, that);
  };
  this._model = model;
  this._localStartTime = void 0;
  this._localStopTime = void 0;
  initialize14(this);
}
Object.defineProperties(ModelExperimentalAnimation.prototype, {
  animation: {
    get: function() {
      return this._animation;
    }
  },
  name: {
    get: function() {
      return this._name;
    }
  },
  runtimeChannels: {
    get: function() {
      return this._runtimeChannels;
    }
  },
  model: {
    get: function() {
      return this._model;
    }
  },
  localStartTime: {
    get: function() {
      return this._localStartTime;
    }
  },
  localStopTime: {
    get: function() {
      return this._localStopTime;
    }
  },
  startTime: {
    get: function() {
      return this._startTime;
    }
  },
  delay: {
    get: function() {
      return this._delay;
    }
  },
  stopTime: {
    get: function() {
      return this._stopTime;
    }
  },
  multiplier: {
    get: function() {
      return this._multiplier;
    }
  },
  reverse: {
    get: function() {
      return this._reverse;
    }
  },
  loop: {
    get: function() {
      return this._loop;
    }
  }
});
function initialize14(runtimeAnimation) {
  let localStartTime = Number.MAX_VALUE;
  let localStopTime = -Number.MAX_VALUE;
  const sceneGraph = runtimeAnimation._model.sceneGraph;
  const animation = runtimeAnimation._animation;
  const channels = animation.channels;
  const length3 = channels.length;
  const runtimeChannels = [];
  for (let i2 = 0; i2 < length3; i2++) {
    const channel = channels[i2];
    const target = channel.target;
    if (!defined_default(target)) {
      continue;
    }
    const nodeIndex = target.node.index;
    const runtimeNode = sceneGraph._runtimeNodes[nodeIndex];
    const runtimeChannel = new ModelExperimentalAnimationChannel_default({
      channel,
      runtimeAnimation,
      runtimeNode
    });
    const times = channel.sampler.input;
    localStartTime = Math.min(localStartTime, times[0]);
    localStopTime = Math.max(localStopTime, times[times.length - 1]);
    runtimeChannels.push(runtimeChannel);
  }
  runtimeAnimation._runtimeChannels = runtimeChannels;
  runtimeAnimation._localStartTime = localStartTime;
  runtimeAnimation._localStopTime = localStopTime;
}
ModelExperimentalAnimation.prototype.animate = function(time) {
  const runtimeChannels = this._runtimeChannels;
  const length3 = runtimeChannels.length;
  for (let i2 = 0; i2 < length3; i2++) {
    runtimeChannels[i2].animate(time);
  }
};
var ModelExperimentalAnimation_default = ModelExperimentalAnimation;

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimentalAnimationCollection.js
function ModelExperimentalAnimationCollection(model) {
  this.animationAdded = new Event_default();
  this.animationRemoved = new Event_default();
  this._model = model;
  this._runtimeAnimations = [];
  this._previousTime = void 0;
}
Object.defineProperties(ModelExperimentalAnimationCollection.prototype, {
  length: {
    get: function() {
      return this._runtimeAnimations.length;
    }
  },
  model: {
    get: function() {
      return this._model;
    }
  }
});
function addAnimation(collection, animation, options) {
  const model = collection._model;
  const runtimeAnimation = new ModelExperimentalAnimation_default(
    model,
    animation,
    options
  );
  collection._runtimeAnimations.push(runtimeAnimation);
  collection.animationAdded.raiseEvent(model, runtimeAnimation);
  return runtimeAnimation;
}
ModelExperimentalAnimationCollection.prototype.add = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const model = this._model;
  if (!model.ready) {
    throw new DeveloperError_default(
      "Animations are not loaded.  Wait for ModelExperimental.readyPromise to resolve."
    );
  }
  const animations = model.sceneGraph.components.animations;
  if (!defined_default(options.name) && !defined_default(options.index)) {
    throw new DeveloperError_default(
      "Either options.name or options.index must be defined."
    );
  }
  if (defined_default(options.multiplier) && options.multiplier <= 0) {
    throw new DeveloperError_default("options.multiplier must be greater than zero.");
  }
  if (defined_default(options.index) && (options.index >= animations.length || options.index < 0)) {
    throw new DeveloperError_default("options.index must be a valid animation index.");
  }
  let index2 = options.index;
  if (defined_default(index2)) {
    return addAnimation(this, animations[index2], options);
  }
  const length3 = animations.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (animations[i2].name === options.name) {
      index2 = i2;
      break;
    }
  }
  if (!defined_default(index2)) {
    throw new DeveloperError_default("options.name must be a valid animation name.");
  }
  return addAnimation(this, animations[index2], options);
};
ModelExperimentalAnimationCollection.prototype.addAll = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const model = this._model;
  if (!model.ready) {
    throw new DeveloperError_default(
      "Animations are not loaded.  Wait for Model.readyPromise to resolve."
    );
  }
  if (defined_default(options.multiplier) && options.multiplier <= 0) {
    throw new DeveloperError_default("options.multiplier must be greater than zero.");
  }
  const animations = model.sceneGraph.components.animations;
  const addedAnimations = [];
  const length3 = animations.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const animation = addAnimation(this, animations[i2], options);
    addedAnimations.push(animation);
  }
  return addedAnimations;
};
ModelExperimentalAnimationCollection.prototype.remove = function(runtimeAnimation) {
  if (!defined_default(runtimeAnimation)) {
    return false;
  }
  const animations = this._runtimeAnimations;
  const i2 = animations.indexOf(runtimeAnimation);
  if (i2 !== -1) {
    animations.splice(i2, 1);
    this.animationRemoved.raiseEvent(this._model, runtimeAnimation);
    return true;
  }
  return false;
};
ModelExperimentalAnimationCollection.prototype.removeAll = function() {
  const model = this._model;
  const animations = this._runtimeAnimations;
  const length3 = animations.length;
  this._runtimeAnimations.length = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    this.animationRemoved.raiseEvent(model, animations[i2]);
  }
};
ModelExperimentalAnimationCollection.prototype.contains = function(runtimeAnimation) {
  if (defined_default(runtimeAnimation)) {
    return this._runtimeAnimations.indexOf(runtimeAnimation) !== -1;
  }
  return false;
};
ModelExperimentalAnimationCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.");
  }
  if (index2 >= this._runtimeAnimations.length || index2 < 0) {
    throw new DeveloperError_default(
      "index must be valid within the range of the collection"
    );
  }
  return this._runtimeAnimations[index2];
};
var animationsToRemove2 = [];
function createAnimationRemovedFunction2(modelAnimationCollection, model, animation) {
  return function() {
    modelAnimationCollection.animationRemoved.raiseEvent(model, animation);
  };
}
ModelExperimentalAnimationCollection.prototype.update = function(frameState) {
  const runtimeAnimations = this._runtimeAnimations;
  let length3 = runtimeAnimations.length;
  if (length3 === 0) {
    this._previousTime = void 0;
    return false;
  }
  if (JulianDate_default.equals(frameState.time, this._previousTime)) {
    return false;
  }
  this._previousTime = JulianDate_default.clone(frameState.time, this._previousTime);
  let animationOccurred = false;
  const sceneTime = frameState.time;
  const model = this._model;
  for (let i2 = 0; i2 < length3; ++i2) {
    const runtimeAnimation = runtimeAnimations[i2];
    if (!defined_default(runtimeAnimation._computedStartTime)) {
      runtimeAnimation._computedStartTime = JulianDate_default.addSeconds(
        defaultValue_default(runtimeAnimation.startTime, sceneTime),
        runtimeAnimation.delay,
        new JulianDate_default()
      );
    }
    if (!defined_default(runtimeAnimation._duration)) {
      runtimeAnimation._duration = runtimeAnimation.localStopTime * (1 / runtimeAnimation.multiplier);
    }
    const startTime = runtimeAnimation._computedStartTime;
    const duration = runtimeAnimation._duration;
    const stopTime = runtimeAnimation.stopTime;
    let delta = duration !== 0 ? JulianDate_default.secondsDifference(sceneTime, startTime) / duration : 0;
    if (duration !== 0 && defined_default(stopTime) && JulianDate_default.greaterThan(sceneTime, stopTime)) {
      delta = JulianDate_default.secondsDifference(stopTime, startTime) / duration;
    }
    const pastStartTime = delta >= 0;
    const repeat = runtimeAnimation.loop === ModelAnimationLoop_default.REPEAT || runtimeAnimation.loop === ModelAnimationLoop_default.MIRRORED_REPEAT;
    const reachedStopTime = defined_default(stopTime) && JulianDate_default.greaterThan(sceneTime, stopTime);
    const play = (pastStartTime || repeat && !defined_default(runtimeAnimation.startTime)) && (delta <= 1 || repeat) && !reachedStopTime;
    if (play || runtimeAnimation._state === ModelAnimationState_default.ANIMATING) {
      if (play && runtimeAnimation._state === ModelAnimationState_default.STOPPED) {
        runtimeAnimation._state = ModelAnimationState_default.ANIMATING;
        if (runtimeAnimation.start.numberOfListeners > 0) {
          frameState.afterRender.push(runtimeAnimation._raiseStartEvent);
        }
      }
      if (runtimeAnimation.loop === ModelAnimationLoop_default.REPEAT) {
        delta = delta - Math.floor(delta);
      } else if (runtimeAnimation.loop === ModelAnimationLoop_default.MIRRORED_REPEAT) {
        const floor = Math.floor(delta);
        const fract2 = delta - floor;
        delta = floor % 2 === 1 ? 1 - fract2 : fract2;
      }
      if (runtimeAnimation.reverse) {
        delta = 1 - delta;
      }
      let localAnimationTime = delta * duration * runtimeAnimation.multiplier;
      localAnimationTime = Math_default.clamp(
        localAnimationTime,
        runtimeAnimation.localStartTime,
        runtimeAnimation.localStopTime
      );
      runtimeAnimation.animate(localAnimationTime);
      if (runtimeAnimation.update.numberOfListeners > 0) {
        runtimeAnimation._updateEventTime = localAnimationTime;
        frameState.afterRender.push(runtimeAnimation._raiseUpdateEvent);
      }
      animationOccurred = true;
      if (!play) {
        runtimeAnimation._state = ModelAnimationState_default.STOPPED;
        if (runtimeAnimation.stop.numberOfListeners > 0) {
          frameState.afterRender.push(runtimeAnimation._raiseStopEvent);
        }
        if (runtimeAnimation.removeOnStop) {
          animationsToRemove2.push(runtimeAnimation);
        }
      }
    }
  }
  length3 = animationsToRemove2.length;
  for (let j = 0; j < length3; ++j) {
    const animationToRemove = animationsToRemove2[j];
    runtimeAnimations.splice(runtimeAnimations.indexOf(animationToRemove), 1);
    frameState.afterRender.push(
      createAnimationRemovedFunction2(this, model, animationToRemove)
    );
  }
  animationsToRemove2.length = 0;
  return animationOccurred;
};
var ModelExperimentalAnimationCollection_default = ModelExperimentalAnimationCollection;

// node_modules/cesium/Source/Shaders/ModelExperimental/ModelExperimentalFS.js
var ModelExperimentalFS_default = "#if defined(HAS_NORMALS) && !defined(HAS_TANGENTS) && !defined(LIGHTING_UNLIT)\n    #ifdef GL_OES_standard_derivatives\n    #extension GL_OES_standard_derivatives : enable\n    #endif\n#endif\n\nczm_modelMaterial defaultModelMaterial()\n{\n    czm_modelMaterial material;\n    material.diffuse = vec3(1.0);\n    material.specular = vec3(0.04); // dielectric (non-metal)\n    material.roughness = 0.0;\n    material.occlusion = 1.0;\n    material.normalEC = vec3(0.0, 0.0, 1.0);\n    material.emissive = vec3(0.0);\n    material.alpha = 1.0;\n    return material;\n}\n\nvec4 handleAlpha(vec3 color, float alpha)\n{\n    #ifdef ALPHA_MODE_MASK\n    if (alpha < u_alphaCutoff) {\n        discard;\n    }\n    return vec4(color, 1.0);\n    #elif defined(ALPHA_MODE_BLEND)\n    return vec4(color, alpha);\n    #else // OPAQUE\n    return vec4(color, 1.0);\n    #endif\n}\n\nSelectedFeature selectedFeature;\n\nvoid main()\n{\n    #ifdef HAS_MODEL_SPLITTER\n    modelSplitterStage();\n    #endif\n\n    czm_modelMaterial material = defaultModelMaterial();\n\n    ProcessedAttributes attributes;\n    geometryStage(attributes);\n\n    FeatureIds featureIds;\n    featureIdStage(featureIds, attributes);\n\n    Metadata metadata;\n    metadataStage(metadata, attributes);\n\n    #ifdef HAS_SELECTED_FEATURE_ID\n    selectedFeatureIdStage(selectedFeature, featureIds);\n    #endif\n\n    #ifndef CUSTOM_SHADER_REPLACE_MATERIAL\n    materialStage(material, attributes, selectedFeature);\n    #endif\n\n    #ifdef HAS_CUSTOM_FRAGMENT_SHADER\n    customShaderStage(material, attributes, featureIds, metadata);\n    #endif\n\n    lightingStage(material, attributes);\n\n    #ifdef HAS_SELECTED_FEATURE_ID\n    cpuStylingStage(material, selectedFeature);\n    #endif\n\n    #ifdef HAS_MODEL_COLOR\n    modelColorStage(material);\n    #endif\n\n    vec4 color = handleAlpha(material.diffuse, material.alpha);\n\n    #ifdef HAS_CLIPPING_PLANES\n    modelClippingPlanesStage(color);\n    #endif\n\n    gl_FragColor = color;\n}\n";

// node_modules/cesium/Source/Shaders/ModelExperimental/ModelExperimentalVS.js
var ModelExperimentalVS_default = "precision highp float;\n\nczm_modelVertexOutput defaultVertexOutput(vec3 positionMC) {\n    czm_modelVertexOutput vsOutput;\n    vsOutput.positionMC = positionMC;\n    vsOutput.pointSize = 1.0;\n    return vsOutput;\n}\n\nvoid main() \n{\n    // Initialize the attributes struct with all\n    // attributes except quantized ones.\n    ProcessedAttributes attributes;\n    initializeAttributes(attributes);\n\n    // Dequantize the quantized ones and add them to the\n    // attributes struct.\n    #ifdef USE_DEQUANTIZATION\n    dequantizationStage(attributes);\n    #endif\n\n    #ifdef HAS_MORPH_TARGETS\n    morphTargetsStage(attributes);\n    #endif\n\n    #ifdef HAS_SKINNING\n    skinningStage(attributes);\n    #endif\n\n    // Compute the bitangent according to the formula in the glTF spec.\n    // Normal and tangents can be affected by morphing and skinning, so\n    // the bitangent should not be computed until their values are finalized.\n    #ifdef HAS_BITANGENTS\n    attributes.bitangentMC = normalize(cross(attributes.normalMC, attributes.tangentMC) * attributes.tangentSignMC);\n    #endif\n\n    FeatureIds featureIds;\n    featureIdStage(featureIds, attributes);\n\n    #ifdef HAS_SELECTED_FEATURE_ID\n    SelectedFeature feature;\n    selectedFeatureIdStage(feature, featureIds);\n    cpuStylingStage(attributes.positionMC, feature);\n    #endif\n\n    mat4 modelView = czm_modelView;\n    mat3 normal = czm_normal;\n\n    // Update the position for this instance in place\n    #ifdef HAS_INSTANCING\n\n        // The legacy instance stage  is used when rendering I3DM models that \n        // encode instances transforms in world space, as opposed to glTF models\n        // that use EXT_mesh_gpu_instancing, where instance transforms are encoded\n        // in object space.\n        #ifdef USE_LEGACY_INSTANCING\n        mat4 instanceModelView;\n        mat3 instanceModelViewInverseTranspose;\n        \n        legacyInstancingStage(attributes.positionMC, instanceModelView, instanceModelViewInverseTranspose);\n\n        modelView = instanceModelView;\n        normal = instanceModelViewInverseTranspose;\n        #else\n        instancingStage(attributes.positionMC);\n        #endif\n\n        #ifdef USE_PICKING\n        v_pickColor = a_pickColor;\n        #endif\n\n    #endif\n\n    Metadata metadata;\n    metadataStage(metadata, attributes);\n\n    #ifdef HAS_CUSTOM_VERTEX_SHADER\n    czm_modelVertexOutput vsOutput = defaultVertexOutput(attributes.positionMC);\n    customShaderStage(vsOutput, attributes, featureIds, metadata);\n    #endif\n\n    // Compute the final position in each coordinate system needed.\n    // This also sets gl_Position.\n    geometryStage(attributes, modelView, normal);    \n\n    #ifdef PRIMITIVE_TYPE_POINTS\n        #ifdef HAS_CUSTOM_VERTEX_SHADER\n        gl_PointSize = vsOutput.pointSize;\n        #elif defined(USE_POINT_CLOUD_ATTENUATION)\n        gl_PointSize = pointCloudAttenuationStage(v_positionEC);\n        #else\n        gl_PointSize = 1.0;\n        #endif\n    #endif\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/StyleCommandsNeeded.js
var StyleCommandsNeeded2 = {
  ALL_OPAQUE: 0,
  ALL_TRANSLUCENT: 1,
  OPAQUE_AND_TRANSLUCENT: 2
};
StyleCommandsNeeded2.getStyleCommandsNeeded = function(featuresLength, translucentFeaturesLength) {
  if (translucentFeaturesLength === 0) {
    return StyleCommandsNeeded2.ALL_OPAQUE;
  } else if (translucentFeaturesLength === featuresLength) {
    return StyleCommandsNeeded2.ALL_TRANSLUCENT;
  }
  return StyleCommandsNeeded2.OPAQUE_AND_TRANSLUCENT;
};
var StyleCommandsNeeded_default = Object.freeze(StyleCommandsNeeded2);

// node_modules/cesium/Source/Scene/ModelExperimental/buildDrawCommands.js
function buildDrawCommands(primitiveRenderResources, frameState) {
  const shaderBuilder = primitiveRenderResources.shaderBuilder;
  shaderBuilder.addVertexLines([ModelExperimentalVS_default]);
  shaderBuilder.addFragmentLines([ModelExperimentalFS_default]);
  const model = primitiveRenderResources.model;
  let primitiveType = primitiveRenderResources.primitiveType;
  const debugWireframe = model.debugWireframe && PrimitiveType_default.isTriangles(primitiveType);
  const indexBuffer = getIndexBuffer2(
    primitiveRenderResources,
    debugWireframe,
    frameState
  );
  const vertexArray = new VertexArray_default({
    context: frameState.context,
    indexBuffer,
    attributes: primitiveRenderResources.attributes
  });
  model._resources.push(vertexArray);
  let renderState = primitiveRenderResources.renderStateOptions;
  if (model.opaquePass === Pass_default.CESIUM_3D_TILE) {
    renderState = clone_default(renderState, true);
    renderState.stencilTest = StencilConstants_default.setCesium3DTileBit();
    renderState.stencilMask = StencilConstants_default.CESIUM_3D_TILE_MASK;
  }
  renderState = RenderState_default.fromCache(renderState);
  const shaderProgram = shaderBuilder.buildShaderProgram(frameState.context);
  model._resources.push(shaderProgram);
  const pass = primitiveRenderResources.alphaOptions.pass;
  const sceneGraph = model.sceneGraph;
  const modelMatrix = Matrix4_default.multiply(
    sceneGraph.computedModelMatrix,
    primitiveRenderResources.runtimeNode.computedTransform,
    new Matrix4_default()
  );
  primitiveRenderResources.boundingSphere = BoundingSphere_default.transform(
    primitiveRenderResources.boundingSphere,
    modelMatrix,
    primitiveRenderResources.boundingSphere
  );
  let count = primitiveRenderResources.count;
  if (debugWireframe) {
    count = WireframeIndexGenerator_default.getWireframeIndicesCount(
      primitiveType,
      count
    );
    primitiveType = PrimitiveType_default.LINES;
  }
  const command = new DrawCommand_default({
    boundingVolume: primitiveRenderResources.boundingSphere,
    modelMatrix,
    uniformMap: primitiveRenderResources.uniformMap,
    renderState,
    vertexArray,
    shaderProgram,
    cull: model.cull,
    pass,
    count,
    pickId: primitiveRenderResources.pickId,
    instanceCount: primitiveRenderResources.instanceCount,
    primitiveType,
    debugShowBoundingVolume: model.debugShowBoundingVolume,
    castShadows: ShadowMode_default.castShadows(model.shadows),
    receiveShadows: ShadowMode_default.receiveShadows(model.shadows)
  });
  const styleCommandsNeeded = primitiveRenderResources.styleCommandsNeeded;
  const commandList = [];
  if (defined_default(styleCommandsNeeded)) {
    const derivedCommands = createDerivedCommands(command);
    if (pass !== Pass_default.TRANSLUCENT) {
      switch (styleCommandsNeeded) {
        case StyleCommandsNeeded_default.ALL_OPAQUE:
          commandList.push(command);
          break;
        case StyleCommandsNeeded_default.ALL_TRANSLUCENT:
          commandList.push(derivedCommands.translucent);
          break;
        case StyleCommandsNeeded_default.OPAQUE_AND_TRANSLUCENT:
          commandList.push(command, derivedCommands.translucent);
          break;
        default:
          throw new RuntimeError_default("styleCommandsNeeded is not a valid value.");
      }
    } else {
      commandList.push(command);
    }
  } else {
    commandList.push(command);
  }
  return commandList;
}
function createDerivedCommands(command) {
  const derivedCommands = {};
  derivedCommands.translucent = deriveTranslucentCommand3(command);
  return derivedCommands;
}
function deriveTranslucentCommand3(command) {
  const derivedCommand = DrawCommand_default.shallowClone(command);
  derivedCommand.pass = Pass_default.TRANSLUCENT;
  const rs = clone_default(command.renderState, true);
  rs.cull.enabled = false;
  rs.depthTest.enabled = true;
  rs.depthMask = false;
  rs.blending = BlendingState_default.ALPHA_BLEND;
  derivedCommand.renderState = RenderState_default.fromCache(rs);
  return derivedCommand;
}
function getIndexBuffer2(primitiveRenderResources, debugWireframe, frameState) {
  if (debugWireframe) {
    return createWireframeIndexBuffer(primitiveRenderResources, frameState);
  }
  const indices2 = primitiveRenderResources.indices;
  if (!defined_default(indices2)) {
    return void 0;
  }
  if (defined_default(indices2.buffer)) {
    return indices2.buffer;
  }
  const typedArray = indices2.typedArray;
  const indexDatatype = IndexDatatype_default.fromSizeInBytes(
    typedArray.BYTES_PER_ELEMENT
  );
  return Buffer_default.createIndexBuffer({
    context: frameState.context,
    typedArray,
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype
  });
}
function createWireframeIndexBuffer(primitiveRenderResources, frameState) {
  let positionAttribute;
  const attributes = primitiveRenderResources.attributes;
  const length3 = attributes.length;
  for (let i2 = 0; i2 < length3; i2++) {
    if (attributes[i2].index === 0) {
      positionAttribute = attributes[i2];
      break;
    }
  }
  const vertexCount = positionAttribute.count;
  const indices2 = primitiveRenderResources.indices;
  const context = frameState.context;
  let originalIndices;
  if (defined_default(indices2)) {
    const indicesBuffer = indices2.buffer;
    const indicesCount = indices2.count;
    const useWebgl2 = context.webgl2;
    if (useWebgl2 && defined_default(indicesBuffer)) {
      originalIndices = IndexDatatype_default.createTypedArray(
        vertexCount,
        indicesCount
      );
      indicesBuffer.getBufferData(originalIndices);
    } else {
      originalIndices = indices2.typedArray;
    }
  }
  const primitiveType = primitiveRenderResources.primitiveType;
  const wireframeIndices = WireframeIndexGenerator_default.createWireframeIndices(
    primitiveType,
    vertexCount,
    originalIndices
  );
  const indexDatatype = IndexDatatype_default.fromSizeInBytes(
    wireframeIndices.BYTES_PER_ELEMENT
  );
  return Buffer_default.createIndexBuffer({
    context,
    typedArray: wireframeIndices,
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype
  });
}

// node_modules/cesium/Source/Shaders/ModelExperimental/ImageBasedLightingStageFS.js
var ImageBasedLightingStageFS_default = "vec3 proceduralIBL(\n    vec3 positionEC,\n    vec3 normalEC,\n    vec3 lightDirectionEC,\n    vec3 lightColorHdr,\n    czm_pbrParameters pbrParameters\n) {\n    vec3 v = -positionEC;\n    vec3 positionWC = vec3(czm_inverseView * vec4(positionEC, 1.0));\n    vec3 vWC = -normalize(positionWC);\n    vec3 l = normalize(lightDirectionEC);\n    vec3 n = normalEC;\n    vec3 r = normalize(czm_inverseViewRotation * normalize(reflect(v, n)));\n\n    float NdotL = clamp(dot(n, l), 0.001, 1.0);\n    float NdotV = abs(dot(n, v)) + 0.001;\n\n    // Figure out if the reflection vector hits the ellipsoid\n    float vertexRadius = length(positionWC);\n    float horizonDotNadir = 1.0 - min(1.0, czm_ellipsoidRadii.x / vertexRadius);\n    float reflectionDotNadir = dot(r, normalize(positionWC));\n    // Flipping the X vector is a cheap way to get the inverse of czm_temeToPseudoFixed, since that's a rotation about Z.\n    r.x = -r.x;\n    r = -normalize(czm_temeToPseudoFixed * r);\n    r.x = -r.x;\n\n    vec3 diffuseColor = pbrParameters.diffuseColor;\n    float roughness = pbrParameters.roughness;\n    vec3 specularColor = pbrParameters.f0;\n\n    float inverseRoughness = 1.04 - roughness;\n    inverseRoughness *= inverseRoughness;\n    vec3 sceneSkyBox = textureCube(czm_environmentMap, r).rgb * inverseRoughness;\n\n    float atmosphereHeight = 0.05;\n    float blendRegionSize = 0.1 * ((1.0 - inverseRoughness) * 8.0 + 1.1 - horizonDotNadir);\n    float blendRegionOffset = roughness * -1.0;\n    float farAboveHorizon = clamp(horizonDotNadir - blendRegionSize * 0.5 + blendRegionOffset, 1.0e-10 - blendRegionSize, 0.99999);\n    float aroundHorizon = clamp(horizonDotNadir + blendRegionSize * 0.5, 1.0e-10 - blendRegionSize, 0.99999);\n    float farBelowHorizon = clamp(horizonDotNadir + blendRegionSize * 1.5, 1.0e-10 - blendRegionSize, 0.99999);\n    float smoothstepHeight = smoothstep(0.0, atmosphereHeight, horizonDotNadir);\n    vec3 belowHorizonColor = mix(vec3(0.1, 0.15, 0.25), vec3(0.4, 0.7, 0.9), smoothstepHeight);\n    vec3 nadirColor = belowHorizonColor * 0.5;\n    vec3 aboveHorizonColor = mix(vec3(0.9, 1.0, 1.2), belowHorizonColor, roughness * 0.5);\n    vec3 blueSkyColor = mix(vec3(0.18, 0.26, 0.48), aboveHorizonColor, reflectionDotNadir * inverseRoughness * 0.5 + 0.75);\n    vec3 zenithColor = mix(blueSkyColor, sceneSkyBox, smoothstepHeight);\n    vec3 blueSkyDiffuseColor = vec3(0.7, 0.85, 0.9); \n    float diffuseIrradianceFromEarth = (1.0 - horizonDotNadir) * (reflectionDotNadir * 0.25 + 0.75) * smoothstepHeight;  \n    float diffuseIrradianceFromSky = (1.0 - smoothstepHeight) * (1.0 - (reflectionDotNadir * 0.25 + 0.25));\n    vec3 diffuseIrradiance = blueSkyDiffuseColor * clamp(diffuseIrradianceFromEarth + diffuseIrradianceFromSky, 0.0, 1.0);\n    float notDistantRough = (1.0 - horizonDotNadir * roughness * 0.8);\n    vec3 specularIrradiance = mix(zenithColor, aboveHorizonColor, smoothstep(farAboveHorizon, aroundHorizon, reflectionDotNadir) * notDistantRough);\n    specularIrradiance = mix(specularIrradiance, belowHorizonColor, smoothstep(aroundHorizon, farBelowHorizon, reflectionDotNadir) * inverseRoughness);\n    specularIrradiance = mix(specularIrradiance, nadirColor, smoothstep(farBelowHorizon, 1.0, reflectionDotNadir) * inverseRoughness);\n\n    // Luminance model from page 40 of http://silviojemma.com/public/papers/lighting/spherical-harmonic-lighting.pdf\n    #ifdef USE_SUN_LUMINANCE \n    // Angle between sun and zenith\n    float LdotZenith = clamp(dot(normalize(czm_inverseViewRotation * l), vWC), 0.001, 1.0);\n    float S = acos(LdotZenith);\n    // Angle between zenith and current pixel\n    float NdotZenith = clamp(dot(normalize(czm_inverseViewRotation * n), vWC), 0.001, 1.0);\n    // Angle between sun and current pixel\n    float gamma = acos(NdotL);\n    float numerator = ((0.91 + 10.0 * exp(-3.0 * gamma) + 0.45 * pow(NdotL, 2.0)) * (1.0 - exp(-0.32 / NdotZenith)));\n    float denominator = (0.91 + 10.0 * exp(-3.0 * S) + 0.45 * pow(LdotZenith,2.0)) * (1.0 - exp(-0.32));\n    float luminance = model_luminanceAtZenith * (numerator / denominator);\n    #endif \n\n    vec2 brdfLut = texture2D(czm_brdfLut, vec2(NdotV, roughness)).rg;\n    vec3 iblColor = (diffuseIrradiance * diffuseColor * model_iblFactor.x) + (specularIrradiance * czm_srgbToLinear(specularColor * brdfLut.x + brdfLut.y) * model_iblFactor.y);\n    float maximumComponent = max(max(lightColorHdr.x, lightColorHdr.y), lightColorHdr.z);\n    vec3 lightColor = lightColorHdr / max(maximumComponent, 1.0);\n    iblColor *= lightColor;\n\n    #ifdef USE_SUN_LUMINANCE \n    iblColor *= luminance;\n    #endif\n\n    return iblColor;\n}\n\nvec3 textureIBL(\n    vec3 positionEC,\n    vec3 normalEC,\n    vec3 lightDirectionEC,\n    czm_pbrParameters pbrParameters\n) {\n    vec3 diffuseColor = pbrParameters.diffuseColor;\n    float roughness = pbrParameters.roughness;\n    vec3 specularColor = pbrParameters.f0;\n\n    vec3 v = -positionEC;\n    vec3 n = normalEC;\n    vec3 l = normalize(lightDirectionEC);\n    vec3 h = normalize(v + l);\n\n    float NdotV = abs(dot(n, v)) + 0.001;\n    float VdotH = clamp(dot(v, h), 0.0, 1.0);\n\n    const mat3 yUpToZUp = mat3(\n        -1.0, 0.0, 0.0,\n        0.0, 0.0, -1.0, \n        0.0, 1.0, 0.0\n    ); \n    vec3 cubeDir = normalize(yUpToZUp * model_iblReferenceFrameMatrix * normalize(reflect(-v, n))); \n\n    #ifdef DIFFUSE_IBL \n        #ifdef CUSTOM_SPHERICAL_HARMONICS\n        vec3 diffuseIrradiance = czm_sphericalHarmonics(cubeDir, model_sphericalHarmonicCoefficients); \n        #else\n        vec3 diffuseIrradiance = czm_sphericalHarmonics(cubeDir, czm_sphericalHarmonicCoefficients); \n        #endif \n    #else \n    vec3 diffuseIrradiance = vec3(0.0); \n    #endif \n\n    #ifdef SPECULAR_IBL\n    vec3 r0 = specularColor.rgb;\n    float reflectance = max(max(r0.r, r0.g), r0.b);\n    vec3 r90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));\n    vec3 F = fresnelSchlick2(r0, r90, VdotH);\n    \n    vec2 brdfLut = texture2D(czm_brdfLut, vec2(NdotV, roughness)).rg;\n      #ifdef CUSTOM_SPECULAR_IBL \n      vec3 specularIBL = czm_sampleOctahedralProjection(model_specularEnvironmentMaps, model_specularEnvironmentMapsSize, cubeDir, roughness * model_specularEnvironmentMapsMaximumLOD, model_specularEnvironmentMapsMaximumLOD);\n      #else \n      vec3 specularIBL = czm_sampleOctahedralProjection(czm_specularEnvironmentMaps, czm_specularEnvironmentMapSize, cubeDir,  roughness * czm_specularEnvironmentMapsMaximumLOD, czm_specularEnvironmentMapsMaximumLOD);\n      #endif \n    specularIBL *= F * brdfLut.x + brdfLut.y;\n    #else \n    vec3 specularIBL = vec3(0.0); \n    #endif\n\n    return diffuseColor * diffuseIrradiance + specularColor * specularIBL;\n}\n\nvec3 imageBasedLightingStage(\n    vec3 positionEC,\n    vec3 normalEC,\n    vec3 lightDirectionEC,\n    vec3 lightColorHdr,\n    czm_pbrParameters pbrParameters\n) {\n  #if defined(DIFFUSE_IBL) || defined(SPECULAR_IBL)\n  // Environment maps were provided, use them for IBL\n  return textureIBL(\n      positionEC,\n      normalEC,\n      lightDirectionEC,\n      pbrParameters\n  );\n  #else\n  // Use the procedural IBL if there are no environment maps\n  return proceduralIBL(\n      positionEC,\n      normalEC,\n      lightDirectionEC,\n      lightColorHdr,\n      pbrParameters\n  );\n  #endif\n}";

// node_modules/cesium/Source/Renderer/ShaderDestination.js
var ShaderDestination = {
  VERTEX: 0,
  FRAGMENT: 1,
  BOTH: 2
};
ShaderDestination.includesVertexShader = function(destination) {
  Check_default.typeOf.number("destination", destination);
  return destination === ShaderDestination.VERTEX || destination === ShaderDestination.BOTH;
};
ShaderDestination.includesFragmentShader = function(destination) {
  Check_default.typeOf.number("destination", destination);
  return destination === ShaderDestination.FRAGMENT || destination === ShaderDestination.BOTH;
};
var ShaderDestination_default = Object.freeze(ShaderDestination);

// node_modules/cesium/Source/Scene/ModelExperimental/ImageBasedLightingPipelineStage.js
var ImageBasedLightingPipelineStage = {};
ImageBasedLightingPipelineStage.name = "ImageBasedLightingPipelineStage";
ImageBasedLightingPipelineStage.process = function(renderResources, model, frameState) {
  const imageBasedLighting = model.imageBasedLighting;
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addDefine(
    "USE_IBL_LIGHTING",
    void 0,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addUniform(
    "vec2",
    "model_iblFactor",
    ShaderDestination_default.FRAGMENT
  );
  if (OctahedralProjectedCubeMap_default.isSupported(frameState.context)) {
    const addMatrix = imageBasedLighting.useSphericalHarmonics || imageBasedLighting.useSpecularEnvironmentMaps || imageBasedLighting.enabled;
    if (addMatrix) {
      shaderBuilder.addUniform(
        "mat3",
        "model_iblReferenceFrameMatrix",
        ShaderDestination_default.FRAGMENT
      );
    }
    if (defined_default(imageBasedLighting.sphericalHarmonicCoefficients)) {
      shaderBuilder.addDefine(
        "DIFFUSE_IBL",
        void 0,
        ShaderDestination_default.FRAGMENT
      );
      shaderBuilder.addDefine(
        "CUSTOM_SPHERICAL_HARMONICS",
        void 0,
        ShaderDestination_default.FRAGMENT
      );
      shaderBuilder.addUniform(
        "vec3",
        "model_sphericalHarmonicCoefficients[9]",
        ShaderDestination_default.FRAGMENT
      );
    } else if (imageBasedLighting.useDefaultSphericalHarmonics) {
      shaderBuilder.addDefine(
        "DIFFUSE_IBL",
        void 0,
        ShaderDestination_default.FRAGMENT
      );
    }
    if (defined_default(imageBasedLighting.specularEnvironmentMapAtlas) && imageBasedLighting.specularEnvironmentMapAtlas.ready) {
      shaderBuilder.addDefine(
        "SPECULAR_IBL",
        void 0,
        ShaderDestination_default.FRAGMENT
      );
      shaderBuilder.addDefine(
        "CUSTOM_SPECULAR_IBL",
        void 0,
        ShaderDestination_default.FRAGMENT
      );
      shaderBuilder.addUniform(
        "sampler2D",
        "model_specularEnvironmentMaps",
        ShaderDestination_default.FRAGMENT
      );
      shaderBuilder.addUniform(
        "vec2",
        "model_specularEnvironmentMapsSize",
        ShaderDestination_default.FRAGMENT
      );
      shaderBuilder.addUniform(
        "float",
        "model_specularEnvironmentMapsMaximumLOD",
        ShaderDestination_default.FRAGMENT
      );
    } else if (model.useDefaultSpecularMaps) {
      shaderBuilder.addDefine(
        "SPECULAR_IBL",
        void 0,
        ShaderDestination_default.FRAGMENT
      );
    }
  }
  if (defined_default(imageBasedLighting.luminanceAtZenith)) {
    shaderBuilder.addDefine(
      "USE_SUN_LUMINANCE",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
    shaderBuilder.addUniform(
      "float",
      "model_luminanceAtZenith",
      ShaderDestination_default.FRAGMENT
    );
  }
  shaderBuilder.addFragmentLines([ImageBasedLightingStageFS_default]);
  const uniformMap2 = {
    model_iblFactor: function() {
      return imageBasedLighting.imageBasedLightingFactor;
    },
    model_iblReferenceFrameMatrix: function() {
      return model._iblReferenceFrameMatrix;
    },
    model_luminanceAtZenith: function() {
      return imageBasedLighting.luminanceAtZenith;
    },
    model_sphericalHarmonicCoefficients: function() {
      return imageBasedLighting.sphericalHarmonicCoefficients;
    },
    model_specularEnvironmentMaps: function() {
      return imageBasedLighting.specularEnvironmentMapAtlas.texture;
    },
    model_specularEnvironmentMapsSize: function() {
      return imageBasedLighting.specularEnvironmentMapAtlas.texture.dimensions;
    },
    model_specularEnvironmentMapsMaximumLOD: function() {
      return imageBasedLighting.specularEnvironmentMapAtlas.maximumMipmapLevel;
    }
  };
  renderResources.uniformMap = combine_default(uniformMap2, renderResources.uniformMap);
};
var ImageBasedLightingPipelineStage_default = ImageBasedLightingPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/ModelColorStageFS.js
var ModelColorStageFS_default = "void modelColorStage(inout czm_modelMaterial material)\n{\n    material.diffuse = mix(material.diffuse, model_color.rgb, model_colorBlend);\n    float highlight = ceil(model_colorBlend);\n    material.diffuse *= mix(model_color.rgb, vec3(1.0), highlight);\n    material.alpha *= model_color.a;\n}";

// node_modules/cesium/Source/Scene/ModelExperimental/ModelColorPipelineStage.js
var ModelColorPipelineStage = {};
ModelColorPipelineStage.name = "ModelColorPipelineStage";
ModelColorPipelineStage.COLOR_UNIFORM_NAME = "model_color";
ModelColorPipelineStage.COLOR_BLEND_UNIFORM_NAME = "model_colorBlend";
ModelColorPipelineStage.process = function(renderResources, model, frameState) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addDefine(
    "HAS_MODEL_COLOR",
    void 0,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addFragmentLines([ModelColorStageFS_default]);
  const stageUniforms = {};
  const color = model.color;
  const renderStateOptions = renderResources.renderStateOptions;
  if (color.alpha === 0) {
    renderStateOptions.colorMask = {
      red: false,
      green: false,
      blue: false,
      alpha: false
    };
    renderStateOptions.depthMask = false;
  } else if (color.alpha < 1) {
    renderResources.alphaOptions.pass = Pass_default.TRANSLUCENT;
    renderResources.alphaOptions.alphaMode = AlphaMode_default.BLEND;
  }
  shaderBuilder.addUniform(
    "vec4",
    ModelColorPipelineStage.COLOR_UNIFORM_NAME,
    ShaderDestination_default.FRAGMENT
  );
  stageUniforms[ModelColorPipelineStage.COLOR_UNIFORM_NAME] = function() {
    return model.color;
  };
  shaderBuilder.addUniform(
    "float",
    ModelColorPipelineStage.COLOR_BLEND_UNIFORM_NAME,
    ShaderDestination_default.FRAGMENT
  );
  stageUniforms[ModelColorPipelineStage.COLOR_BLEND_UNIFORM_NAME] = function() {
    return ColorBlendMode_default.getColorBlend(
      model.colorBlendMode,
      model.colorBlendAmount
    );
  };
  renderResources.uniformMap = combine_default(
    stageUniforms,
    renderResources.uniformMap
  );
};
var ModelColorPipelineStage_default = ModelColorPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/ModelClippingPlanesStageFS.js
var ModelClippingPlanesStageFS_default = "#ifdef USE_CLIPPING_PLANES_FLOAT_TEXTURE\nvec4 getClippingPlane(\n    highp sampler2D packedClippingPlanes,\n    int clippingPlaneNumber,\n    mat4 transform\n) {\n    int pixY = clippingPlaneNumber / CLIPPING_PLANES_TEXTURE_WIDTH;\n    int pixX = clippingPlaneNumber - (pixY * CLIPPING_PLANES_TEXTURE_WIDTH);\n    float pixelWidth = 1.0 / float(CLIPPING_PLANES_TEXTURE_WIDTH);\n    float pixelHeight = 1.0 / float(CLIPPING_PLANES_TEXTURE_HEIGHT);\n    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel\n    float v = (float(pixY) + 0.5) * pixelHeight;\n    vec4 plane = texture2D(packedClippingPlanes, vec2(u, v));\n    return czm_transformPlane(plane, transform);\n}\n#else\n// Handle uint8 clipping texture instead\nvec4 getClippingPlane(\n    highp sampler2D packedClippingPlanes,\n    int clippingPlaneNumber,\n    mat4 transform\n) {\n    int clippingPlaneStartIndex = clippingPlaneNumber * 2; // clipping planes are two pixels each\n    int pixY = clippingPlaneStartIndex / CLIPPING_PLANES_TEXTURE_WIDTH;\n    int pixX = clippingPlaneStartIndex - (pixY * CLIPPING_PLANES_TEXTURE_WIDTH);\n    float pixelWidth = 1.0 / float(CLIPPING_PLANES_TEXTURE_WIDTH);\n    float pixelHeight = 1.0 / float(CLIPPING_PLANES_TEXTURE_HEIGHT);\n    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel\n    float v = (float(pixY) + 0.5) * pixelHeight;\n    vec4 oct32 = texture2D(packedClippingPlanes, vec2(u, v)) * 255.0;\n    vec2 oct = vec2(oct32.x * 256.0 + oct32.y, oct32.z * 256.0 + oct32.w);\n    vec4 plane;\n    plane.xyz = czm_octDecode(oct, 65535.0);\n    plane.w = czm_unpackFloat(texture2D(packedClippingPlanes, vec2(u + pixelWidth, v)));\n    return czm_transformPlane(plane, transform);\n}\n#endif\n\nfloat clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix) {\n    vec4 position = czm_windowToEyeCoordinates(fragCoord);\n    vec3 clipNormal = vec3(0.0);\n    vec3 clipPosition = vec3(0.0);\n    float pixelWidth = czm_metersPerPixel(position);\n    \n    #ifdef UNION_CLIPPING_REGIONS\n    float clipAmount; // For union planes, we want to get the min distance. So we set the initial value to the first plane distance in the loop below.\n    #else\n    float clipAmount = 0.0;\n    bool clipped = true;\n    #endif\n\n    for (int i = 0; i < CLIPPING_PLANES_LENGTH; ++i) {\n        vec4 clippingPlane = getClippingPlane(clippingPlanes, i, clippingPlanesMatrix);\n        clipNormal = clippingPlane.xyz;\n        clipPosition = -clippingPlane.w * clipNormal;\n        float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;\n        \n        #ifdef UNION_CLIPPING_REGIONS\n        clipAmount = czm_branchFreeTernary(i == 0, amount, min(amount, clipAmount));\n        if (amount <= 0.0) {\n            discard;\n        }\n        #else\n        clipAmount = max(amount, clipAmount);\n        clipped = clipped && (amount <= 0.0);\n        #endif\n    }\n\n    #ifndef UNION_CLIPPING_REGIONS\n    if (clipped) {\n        discard;\n    }\n    #endif\n    \n    return clipAmount;\n}\n\nvoid modelClippingPlanesStage(inout vec4 color)\n{\n    float clipDistance = clip(gl_FragCoord, model_clippingPlanes, model_clippingPlanesMatrix);\n    vec4 clippingPlanesEdgeColor = vec4(1.0);\n    clippingPlanesEdgeColor.rgb = model_clippingPlanesEdgeStyle.rgb;\n    float clippingPlanesEdgeWidth = model_clippingPlanesEdgeStyle.a;\n    \n    if (clipDistance > 0.0 && clipDistance < clippingPlanesEdgeWidth) {\n        color = clippingPlanesEdgeColor;\n    }\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/ModelClippingPlanesPipelineStage.js
var ModelClippingPlanesPipelineStage = {};
ModelClippingPlanesPipelineStage.name = "ModelClippingPlanesPipelineStage";
var textureResolutionScratch3 = new Cartesian2_default();
ModelClippingPlanesPipelineStage.process = function(renderResources, model, frameState) {
  const clippingPlanes = model.clippingPlanes;
  const context = frameState.context;
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addDefine(
    "HAS_CLIPPING_PLANES",
    void 0,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addDefine(
    "CLIPPING_PLANES_LENGTH",
    clippingPlanes.length,
    ShaderDestination_default.FRAGMENT
  );
  if (clippingPlanes.unionClippingRegions) {
    shaderBuilder.addDefine(
      "UNION_CLIPPING_REGIONS",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  if (ClippingPlaneCollection_default.useFloatTexture(context)) {
    shaderBuilder.addDefine(
      "USE_CLIPPING_PLANES_FLOAT_TEXTURE",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  const textureResolution = ClippingPlaneCollection_default.getTextureResolution(
    clippingPlanes,
    context,
    textureResolutionScratch3
  );
  shaderBuilder.addDefine(
    "CLIPPING_PLANES_TEXTURE_WIDTH",
    textureResolution.x,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addDefine(
    "CLIPPING_PLANES_TEXTURE_HEIGHT",
    textureResolution.y,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addUniform(
    "sampler2D",
    "model_clippingPlanes",
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addUniform(
    "vec4",
    "model_clippingPlanesEdgeStyle",
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addUniform(
    "mat4",
    "model_clippingPlanesMatrix",
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addFragmentLines([ModelClippingPlanesStageFS_default]);
  const uniformMap2 = {
    model_clippingPlanes: function() {
      return clippingPlanes.texture;
    },
    model_clippingPlanesEdgeStyle: function() {
      const style = Color_default.clone(clippingPlanes.edgeColor);
      style.alpha = clippingPlanes.edgeWidth;
      return style;
    },
    model_clippingPlanesMatrix: function() {
      return model._clippingPlanesMatrix;
    }
  };
  renderResources.uniformMap = combine_default(uniformMap2, renderResources.uniformMap);
};
var ModelClippingPlanesPipelineStage_default = ModelClippingPlanesPipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/AlphaPipelineStage.js
var AlphaPipelineStage = {};
AlphaPipelineStage.name = "AlphaPipelineStage";
AlphaPipelineStage.process = function(renderResources, primitive, frameState) {
  const alphaOptions = renderResources.alphaOptions;
  const model = renderResources.model;
  alphaOptions.pass = defaultValue_default(alphaOptions.pass, model.opaquePass);
  const renderStateOptions = renderResources.renderStateOptions;
  if (alphaOptions.pass === Pass_default.TRANSLUCENT) {
    renderStateOptions.blending = BlendingState_default.ALPHA_BLEND;
  } else {
    renderStateOptions.blending = BlendingState_default.DISABLED;
  }
  const shaderBuilder = renderResources.shaderBuilder;
  const uniformMap2 = renderResources.uniformMap;
  const alphaMode = alphaOptions.alphaMode;
  if (alphaMode === AlphaMode_default.MASK) {
    shaderBuilder.addDefine(
      "ALPHA_MODE_MASK",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
    shaderBuilder.addUniform(
      "float",
      "u_alphaCutoff",
      ShaderDestination_default.FRAGMENT
    );
    uniformMap2.u_alphaCutoff = function() {
      return alphaOptions.alphaCutoff;
    };
  } else if (alphaMode === AlphaMode_default.BLEND) {
    shaderBuilder.addDefine(
      "ALPHA_MODE_BLEND",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  } else {
    shaderBuilder.addDefine(
      "ALPHA_MODE_OPAQUE",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
};
var AlphaPipelineStage_default = AlphaPipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/BatchTexturePipelineStage.js
var BatchTexturePipelineStage = {};
BatchTexturePipelineStage.name = "BatchTexturePipelineStage";
BatchTexturePipelineStage.process = function(renderResources, primitive, frameState) {
  const shaderBuilder = renderResources.shaderBuilder;
  const batchTextureUniforms = {};
  const model = renderResources.model;
  const featureTable = model.featureTables[model.featureTableId];
  const featuresLength = featureTable.featuresLength;
  shaderBuilder.addUniform("int", "model_featuresLength");
  batchTextureUniforms.model_featuresLength = function() {
    return featuresLength;
  };
  const batchTexture = featureTable.batchTexture;
  shaderBuilder.addUniform("sampler2D", "model_batchTexture");
  batchTextureUniforms.model_batchTexture = function() {
    return defaultValue_default(batchTexture.batchTexture, batchTexture.defaultTexture);
  };
  shaderBuilder.addUniform("vec4", "model_textureStep");
  batchTextureUniforms.model_textureStep = function() {
    return batchTexture.textureStep;
  };
  if (batchTexture.textureDimensions.y > 1) {
    shaderBuilder.addDefine("MULTILINE_BATCH_TEXTURE");
    shaderBuilder.addUniform("vec2", "model_textureDimensions");
    batchTextureUniforms.model_textureDimensions = function() {
      return batchTexture.textureDimensions;
    };
  }
  renderResources.uniformMap = combine_default(
    batchTextureUniforms,
    renderResources.uniformMap
  );
};
var BatchTexturePipelineStage_default = BatchTexturePipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/CustomShaderMode.js
var CustomShaderMode = {
  MODIFY_MATERIAL: "MODIFY_MATERIAL",
  REPLACE_MATERIAL: "REPLACE_MATERIAL"
};
CustomShaderMode.getDefineName = function(customShaderMode) {
  return `CUSTOM_SHADER_${customShaderMode}`;
};
var CustomShaderMode_default = Object.freeze(CustomShaderMode);

// node_modules/cesium/Source/Shaders/ModelExperimental/CustomShaderStageVS.js
var CustomShaderStageVS_default = "void customShaderStage(\n    inout czm_modelVertexOutput vsOutput, \n    inout ProcessedAttributes attributes, \n    FeatureIds featureIds,\n    Metadata metadata\n) {\n    // VertexInput and initializeInputStruct() are dynamically generated in JS, \n    // see CustomShaderPipelineStage.js\n    VertexInput vsInput;\n    initializeInputStruct(vsInput, attributes);\n    vsInput.featureIds = featureIds;\n    vsInput.metadata = metadata;\n    vertexMain(vsInput, vsOutput);\n    attributes.positionMC = vsOutput.positionMC;\n}\n";

// node_modules/cesium/Source/Shaders/ModelExperimental/CustomShaderStageFS.js
var CustomShaderStageFS_default = "void customShaderStage(\n    inout czm_modelMaterial material,\n    ProcessedAttributes attributes,\n    FeatureIds featureIds,\n    Metadata metadata\n) {\n    // FragmentInput and initializeInputStruct() are dynamically generated in JS, \n    // see CustomShaderPipelineStage.js\n    FragmentInput fsInput;\n    initializeInputStruct(fsInput, attributes);\n    fsInput.featureIds = featureIds;\n    fsInput.metadata = metadata;\n    fragmentMain(fsInput, material);\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimentalUtility.js
function ModelExperimentalUtility() {
}
ModelExperimentalUtility.getFailedLoadFunction = function(model, type, path) {
  return function(error) {
    let message = `Failed to load ${type}: ${path}`;
    if (defined_default(error)) {
      message += `
${error.message}`;
    }
    model._readyPromise.reject(new RuntimeError_default(message));
  };
};
ModelExperimentalUtility.getNodeTransform = function(node) {
  if (defined_default(node.matrix)) {
    return node.matrix;
  }
  return Matrix4_default.fromTranslationQuaternionRotationScale(
    defined_default(node.translation) ? node.translation : Cartesian3_default.ZERO,
    defined_default(node.rotation) ? node.rotation : Quaternion_default.IDENTITY,
    defined_default(node.scale) ? node.scale : Cartesian3_default.ONE
  );
};
ModelExperimentalUtility.getAttributeBySemantic = function(object2, semantic, setIndex) {
  const attributes = object2.attributes;
  const attributesLength = attributes.length;
  for (let i2 = 0; i2 < attributesLength; ++i2) {
    const attribute = attributes[i2];
    const matchesSetIndex = defined_default(setIndex) ? attribute.setIndex === setIndex : true;
    if (attribute.semantic === semantic && matchesSetIndex) {
      return attribute;
    }
  }
};
ModelExperimentalUtility.getAttributeByName = function(object2, name) {
  const attributes = object2.attributes;
  const attributesLength = attributes.length;
  for (let i2 = 0; i2 < attributesLength; ++i2) {
    const attribute = attributes[i2];
    if (attribute.name === name) {
      return attribute;
    }
  }
};
ModelExperimentalUtility.getFeatureIdsByLabel = function(featureIds, label) {
  for (let i2 = 0; i2 < featureIds.length; i2++) {
    const featureIdSet = featureIds[i2];
    if (featureIdSet.positionalLabel === label || featureIdSet.label === label) {
      return featureIdSet;
    }
  }
  return void 0;
};
ModelExperimentalUtility.hasQuantizedAttributes = function(attributes) {
  if (!defined_default(attributes)) {
    return false;
  }
  for (let i2 = 0; i2 < attributes.length; i2++) {
    const attribute = attributes[i2];
    if (defined_default(attribute.quantization)) {
      return true;
    }
  }
  return false;
};
ModelExperimentalUtility.getAttributeInfo = function(attribute) {
  const semantic = attribute.semantic;
  const setIndex = attribute.setIndex;
  let variableName;
  let hasSemantic = false;
  if (defined_default(semantic)) {
    variableName = VertexAttributeSemantic_default.getVariableName(semantic, setIndex);
    hasSemantic = true;
  } else {
    variableName = attribute.name;
    variableName = variableName.replace(/^_/, "");
    variableName = variableName.toLowerCase();
  }
  const isVertexColor = /^color_\d+$/.test(variableName);
  const attributeType = attribute.type;
  let glslType = AttributeType_default.getGlslType(attributeType);
  if (isVertexColor) {
    glslType = "vec4";
  }
  const isQuantized = defined_default(attribute.quantization);
  let quantizedGlslType;
  if (isQuantized) {
    quantizedGlslType = isVertexColor ? "vec4" : AttributeType_default.getGlslType(attribute.quantization.type);
  }
  return {
    attribute,
    isQuantized,
    variableName,
    hasSemantic,
    glslType,
    quantizedGlslType
  };
};
var cartesianMaxScratch = new Cartesian3_default();
var cartesianMinScratch = new Cartesian3_default();
ModelExperimentalUtility.createBoundingSphere = function(primitive, modelMatrix, instancingTranslationMax, instancingTranslationMin) {
  const positionGltfAttribute = ModelExperimentalUtility.getAttributeBySemantic(
    primitive,
    "POSITION"
  );
  const positionMax = positionGltfAttribute.max;
  const positionMin = positionGltfAttribute.min;
  let boundingSphere;
  if (defined_default(instancingTranslationMax) && defined_default(instancingTranslationMin)) {
    const computedMin = Cartesian3_default.add(
      positionMin,
      instancingTranslationMin,
      cartesianMinScratch
    );
    const computedMax = Cartesian3_default.add(
      positionMax,
      instancingTranslationMax,
      cartesianMaxScratch
    );
    boundingSphere = BoundingSphere_default.fromCornerPoints(computedMin, computedMax);
  } else {
    boundingSphere = BoundingSphere_default.fromCornerPoints(positionMin, positionMax);
  }
  BoundingSphere_default.transform(boundingSphere, modelMatrix, boundingSphere);
  return boundingSphere;
};
ModelExperimentalUtility.getAxisCorrectionMatrix = function(upAxis, forwardAxis, result) {
  result = Matrix4_default.clone(Matrix4_default.IDENTITY, result);
  if (upAxis === Axis_default.Y) {
    result = Matrix4_default.clone(Axis_default.Y_UP_TO_Z_UP, result);
  } else if (upAxis === Axis_default.X) {
    result = Matrix4_default.clone(Axis_default.X_UP_TO_Z_UP, result);
  }
  if (forwardAxis === Axis_default.Z) {
    result = Matrix4_default.multiplyTransformation(result, Axis_default.Z_UP_TO_X_UP, result);
  }
  return result;
};

// node_modules/cesium/Source/Shaders/ModelExperimental/FeatureIdStageFS.js
var FeatureIdStageFS_default = "void featureIdStage(out FeatureIds featureIds, ProcessedAttributes attributes) {\n  initializeFeatureIds(featureIds, attributes);\n  initializeFeatureIdAliases(featureIds);\n}\n";

// node_modules/cesium/Source/Shaders/ModelExperimental/FeatureIdStageVS.js
var FeatureIdStageVS_default = "void featureIdStage(out FeatureIds featureIds, ProcessedAttributes attributes) \n{\n  initializeFeatureIds(featureIds, attributes);\n  initializeFeatureIdAliases(featureIds);\n  setFeatureIdVaryings();\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/FeatureIdPipelineStage.js
var FeatureIdPipelineStage = {};
FeatureIdPipelineStage.name = "FeatureIdPipelineStage";
FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS = "FeatureIdsVS";
FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS = "FeatureIdsFS";
FeatureIdPipelineStage.STRUCT_NAME_FEATURE_IDS = "FeatureIds";
FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_VS = "initializeFeatureIdsVS";
FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS = "initializeFeatureIdsFS";
FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_VS = "initializeFeatureIdAliasesVS";
FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_FS = "initializeFeatureIdAliasesFS";
FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_IDS = "void initializeFeatureIds(out FeatureIds featureIds, ProcessedAttributes attributes)";
FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_ID_ALIASES = "void initializeFeatureIdAliases(inout FeatureIds featureIds)";
FeatureIdPipelineStage.FUNCTION_ID_SET_FEATURE_ID_VARYINGS = "setFeatureIdVaryings";
FeatureIdPipelineStage.FUNCTION_SIGNATURE_SET_FEATURE_ID_VARYINGS = "void setFeatureIdVaryings()";
FeatureIdPipelineStage.process = function(renderResources, primitive, frameState) {
  const shaderBuilder = renderResources.shaderBuilder;
  declareStructsAndFunctions(shaderBuilder);
  const instances = renderResources.runtimeNode.node.instances;
  if (defined_default(instances)) {
    processInstanceFeatureIds(renderResources, instances, frameState);
  }
  processPrimitiveFeatureIds(renderResources, primitive, frameState);
  shaderBuilder.addVertexLines([FeatureIdStageVS_default]);
  shaderBuilder.addFragmentLines([FeatureIdStageFS_default]);
};
function declareStructsAndFunctions(shaderBuilder) {
  shaderBuilder.addStruct(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
    FeatureIdPipelineStage.STRUCT_NAME_FEATURE_IDS,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addStruct(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
    FeatureIdPipelineStage.STRUCT_NAME_FEATURE_IDS,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addFunction(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_VS,
    FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_IDS,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addFunction(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
    FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_IDS,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addFunction(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_VS,
    FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_ID_ALIASES,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addFunction(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_FS,
    FeatureIdPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_FEATURE_ID_ALIASES,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addFunction(
    FeatureIdPipelineStage.FUNCTION_ID_SET_FEATURE_ID_VARYINGS,
    FeatureIdPipelineStage.FUNCTION_SIGNATURE_SET_FEATURE_ID_VARYINGS,
    ShaderDestination_default.VERTEX
  );
}
function processInstanceFeatureIds(renderResources, instances, frameState) {
  const featureIdsArray = instances.featureIds;
  const count = instances.attributes[0].count;
  for (let i2 = 0; i2 < featureIdsArray.length; i2++) {
    const featureIds = featureIdsArray[i2];
    const variableName = featureIds.positionalLabel;
    if (featureIds instanceof ModelComponents_default.FeatureIdAttribute) {
      processInstanceAttribute(renderResources, featureIds, variableName);
    } else {
      const instanceDivisor = 1;
      processImplicitRange(
        renderResources,
        featureIds,
        variableName,
        count,
        instanceDivisor,
        frameState
      );
    }
    const label = featureIds.label;
    if (defined_default(label)) {
      addAlias(renderResources, variableName, label, ShaderDestination_default.BOTH);
    }
  }
}
function processPrimitiveFeatureIds(renderResources, primitive, frameState) {
  const featureIdsArray = primitive.featureIds;
  const positionAttribute = ModelExperimentalUtility.getAttributeBySemantic(
    primitive,
    VertexAttributeSemantic_default.POSITION
  );
  const count = positionAttribute.count;
  for (let i2 = 0; i2 < featureIdsArray.length; i2++) {
    const featureIds = featureIdsArray[i2];
    const variableName = featureIds.positionalLabel;
    let aliasDestination = ShaderDestination_default.BOTH;
    if (featureIds instanceof ModelComponents_default.FeatureIdAttribute) {
      processAttribute(renderResources, featureIds, variableName);
    } else if (featureIds instanceof ModelComponents_default.FeatureIdImplicitRange) {
      processImplicitRange(
        renderResources,
        featureIds,
        variableName,
        count,
        void 0,
        frameState
      );
    } else {
      processTexture(renderResources, featureIds, variableName, i2, frameState);
      aliasDestination = ShaderDestination_default.FRAGMENT;
    }
    const label = featureIds.label;
    if (defined_default(label)) {
      addAlias(renderResources, variableName, label, aliasDestination);
    }
  }
}
function processInstanceAttribute(renderResources, featureIdAttribute, variableName) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addStructField(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
    "int",
    variableName
  );
  shaderBuilder.addStructField(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
    "int",
    variableName
  );
  const setIndex = featureIdAttribute.setIndex;
  const prefix = variableName.replace(/_\d+$/, "_");
  const attributeName = `a_${prefix}${setIndex}`;
  const varyingName = `v_${prefix}${setIndex}`;
  const vertexLine = `featureIds.${variableName} = int(czm_round(${attributeName}));`;
  const fragmentLine = `featureIds.${variableName} = int(czm_round(${varyingName}));`;
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_VS,
    [vertexLine]
  );
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
    [fragmentLine]
  );
  shaderBuilder.addVarying("float", varyingName);
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_SET_FEATURE_ID_VARYINGS,
    [`${varyingName} = ${attributeName};`]
  );
}
function processAttribute(renderResources, featureIdAttribute, variableName) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addStructField(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
    "int",
    variableName
  );
  shaderBuilder.addStructField(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
    "int",
    variableName
  );
  const setIndex = featureIdAttribute.setIndex;
  const prefix = variableName.replace(/_\d+$/, "_");
  const initializationLines = [
    `featureIds.${variableName} = int(czm_round(attributes.${prefix}${setIndex}));`
  ];
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_VS,
    initializationLines
  );
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
    initializationLines
  );
}
function processImplicitRange(renderResources, implicitFeatureIds, variableName, count, instanceDivisor, frameState) {
  generateImplicitFeatureIdAttribute(
    renderResources,
    implicitFeatureIds,
    count,
    instanceDivisor,
    frameState
  );
  const shaderBuilder = renderResources.shaderBuilder;
  const implicitAttributeName = `a_implicit_${variableName}`;
  shaderBuilder.addAttribute("float", implicitAttributeName);
  const implicitVaryingName = `v_implicit_${variableName}`;
  shaderBuilder.addVarying("float", implicitVaryingName);
  shaderBuilder.addStructField(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
    "int",
    variableName
  );
  shaderBuilder.addStructField(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
    "int",
    variableName
  );
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_SET_FEATURE_ID_VARYINGS,
    [`${implicitVaryingName} = ${implicitAttributeName};`]
  );
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_VS,
    [`featureIds.${variableName} = int(czm_round(${implicitAttributeName}));`]
  );
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
    [`featureIds.${variableName} = int(czm_round(${implicitVaryingName}));`]
  );
}
function processTexture(renderResources, featureIdTexture, variableName, index2, frameState) {
  const uniformName = `u_featureIdTexture_${index2}`;
  const uniformMap2 = renderResources.uniformMap;
  const textureReader = featureIdTexture.textureReader;
  uniformMap2[uniformName] = function() {
    return defaultValue_default(
      textureReader.texture,
      frameState.context.defaultTexture
    );
  };
  const channels = textureReader.channels;
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addStructField(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
    "int",
    variableName
  );
  shaderBuilder.addUniform(
    "sampler2D",
    uniformName,
    ShaderDestination_default.FRAGMENT
  );
  const texCoord = `v_texCoord_${textureReader.texCoord}`;
  const textureRead = `texture2D(${uniformName}, ${texCoord}).${channels}`;
  const initializationLine = `featureIds.${variableName} = czm_unpackUint(${textureRead});`;
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_IDS_FS,
    [initializationLine]
  );
}
function addAlias(renderResources, variableName, alias, shaderDestination) {
  const shaderBuilder = renderResources.shaderBuilder;
  const updateVS = ShaderDestination_default.includesVertexShader(shaderDestination);
  if (updateVS) {
    shaderBuilder.addStructField(
      FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_VS,
      "int",
      alias
    );
  }
  shaderBuilder.addStructField(
    FeatureIdPipelineStage.STRUCT_ID_FEATURE_IDS_FS,
    "int",
    alias
  );
  const initializationLines = [
    `featureIds.${alias} = featureIds.${variableName};`
  ];
  if (updateVS) {
    shaderBuilder.addFunctionLines(
      FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_VS,
      initializationLines
    );
  }
  shaderBuilder.addFunctionLines(
    FeatureIdPipelineStage.FUNCTION_ID_INITIALIZE_FEATURE_ID_ALIASES_FS,
    initializationLines
  );
}
function generateImplicitFeatureIdAttribute(renderResources, implicitFeatureIds, count, instanceDivisor, frameState) {
  const model = renderResources.model;
  let vertexBuffer;
  let value;
  if (defined_default(implicitFeatureIds.repeat)) {
    const typedArray = generateImplicitFeatureIdTypedArray(
      implicitFeatureIds,
      count
    );
    vertexBuffer = Buffer_default.createVertexBuffer({
      context: frameState.context,
      typedArray,
      usage: BufferUsage_default.STATIC_DRAW
    });
    vertexBuffer.vertexArrayDestroyable = false;
    model._resources.push(vertexBuffer);
  } else {
    value = [implicitFeatureIds.offset];
  }
  const generatedFeatureIdAttribute = {
    index: renderResources.attributeIndex++,
    instanceDivisor,
    value,
    vertexBuffer,
    normalize: false,
    componentsPerAttribute: 1,
    componentDatatype: ComponentDatatype_default.FLOAT,
    strideInBytes: ComponentDatatype_default.getSizeInBytes(ComponentDatatype_default.FLOAT),
    offsetInBytes: 0
  };
  renderResources.attributes.push(generatedFeatureIdAttribute);
}
function generateImplicitFeatureIdTypedArray(implicitFeatureIds, count) {
  const offset2 = implicitFeatureIds.offset;
  const repeat = implicitFeatureIds.repeat;
  const typedArray = new Float32Array(count);
  for (let i2 = 0; i2 < count; i2++) {
    typedArray[i2] = offset2 + Math.floor(i2 / repeat);
  }
  return typedArray;
}
var FeatureIdPipelineStage_default = FeatureIdPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/MetadataStageFS.js
var MetadataStageFS_default = "void metadataStage(out Metadata metadata, ProcessedAttributes attributes)\n{\n  initializeMetadata(metadata, attributes);\n}\n";

// node_modules/cesium/Source/Shaders/ModelExperimental/MetadataStageVS.js
var MetadataStageVS_default = "void metadataStage(out Metadata metadata, ProcessedAttributes attributes)\n{\n  initializeMetadata(metadata, attributes);\n  setMetadataVaryings();\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/MetadataPipelineStage.js
var MetadataPipelineStage = {};
MetadataPipelineStage.name = "MetadataPipelineStage";
MetadataPipelineStage.STRUCT_ID_METADATA_VS = "MetadataVS";
MetadataPipelineStage.STRUCT_ID_METADATA_FS = "MetadataFS";
MetadataPipelineStage.STRUCT_NAME_METADATA = "Metadata";
MetadataPipelineStage.FUNCTION_ID_INITIALIZE_METADATA_VS = "initializeMetadataVS";
MetadataPipelineStage.FUNCTION_ID_INITIALIZE_METADATA_FS = "initializeMetadataFS";
MetadataPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_METADATA = "void initializeMetadata(out Metadata metadata, ProcessedAttributes attributes)";
MetadataPipelineStage.FUNCTION_ID_SET_METADATA_VARYINGS = "setMetadataVaryings";
MetadataPipelineStage.FUNCTION_SIGNATURE_SET_METADATA_VARYINGS = "void setMetadataVaryings()";
MetadataPipelineStage.process = function(renderResources, primitive, frameState) {
  const shaderBuilder = renderResources.shaderBuilder;
  declareStructsAndFunctions2(shaderBuilder);
  shaderBuilder.addVertexLines([MetadataStageVS_default]);
  shaderBuilder.addFragmentLines([MetadataStageFS_default]);
  const structuralMetadata = renderResources.model.structuralMetadata;
  if (!defined_default(structuralMetadata)) {
    return;
  }
  processPropertyAttributes(renderResources, primitive, structuralMetadata);
  processPropertyTextures(renderResources, structuralMetadata);
};
function declareStructsAndFunctions2(shaderBuilder) {
  shaderBuilder.addStruct(
    MetadataPipelineStage.STRUCT_ID_METADATA_VS,
    MetadataPipelineStage.STRUCT_NAME_METADATA,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addStruct(
    MetadataPipelineStage.STRUCT_ID_METADATA_FS,
    MetadataPipelineStage.STRUCT_NAME_METADATA,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addFunction(
    MetadataPipelineStage.FUNCTION_ID_INITIALIZE_METADATA_VS,
    MetadataPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_METADATA,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addFunction(
    MetadataPipelineStage.FUNCTION_ID_INITIALIZE_METADATA_FS,
    MetadataPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_METADATA,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addFunction(
    MetadataPipelineStage.FUNCTION_ID_SET_METADATA_VARYINGS,
    MetadataPipelineStage.FUNCTION_SIGNATURE_SET_METADATA_VARYINGS,
    ShaderDestination_default.VERTEX
  );
}
function processPropertyAttributes(renderResources, primitive, structuralMetadata) {
  const propertyAttributes = structuralMetadata.propertyAttributes;
  if (!defined_default(propertyAttributes)) {
    return;
  }
  for (let i2 = 0; i2 < propertyAttributes.length; i2++) {
    const propertyAttribute = propertyAttributes[i2];
    const properties = propertyAttribute.properties;
    for (const propertyId in properties) {
      if (properties.hasOwnProperty(propertyId)) {
        const property = properties[propertyId];
        const modelAttribute = ModelExperimentalUtility.getAttributeByName(
          primitive,
          property.attribute
        );
        const attributeInfo = ModelExperimentalUtility.getAttributeInfo(
          modelAttribute
        );
        addPropertyAttributeProperty(
          renderResources,
          attributeInfo,
          propertyId,
          property
        );
      }
    }
  }
}
function addPropertyAttributeProperty(renderResources, attributeInfo, propertyId, property) {
  const metadataVariable = sanitizeGlslIdentifier(propertyId);
  const attributeVariable = attributeInfo.variableName;
  const glslType = attributeInfo.glslType;
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addStructField(
    MetadataPipelineStage.STRUCT_ID_METADATA_VS,
    glslType,
    metadataVariable
  );
  shaderBuilder.addStructField(
    MetadataPipelineStage.STRUCT_ID_METADATA_FS,
    glslType,
    metadataVariable
  );
  let unpackedValue = `attributes.${attributeVariable}`;
  if (property.hasValueTransform) {
    unpackedValue = addValueTransformUniforms(unpackedValue, {
      renderResources,
      glslType,
      metadataVariable,
      shaderDestination: ShaderDestination_default.BOTH,
      offset: property.offset,
      scale: property.scale
    });
  }
  const initializationLine = `metadata.${metadataVariable} = ${unpackedValue};`;
  shaderBuilder.addFunctionLines(
    MetadataPipelineStage.FUNCTION_ID_INITIALIZE_METADATA_VS,
    [initializationLine]
  );
  shaderBuilder.addFunctionLines(
    MetadataPipelineStage.FUNCTION_ID_INITIALIZE_METADATA_FS,
    [initializationLine]
  );
}
function processPropertyTextures(renderResources, structuralMetadata) {
  const propertyTextures = structuralMetadata.propertyTextures;
  if (!defined_default(propertyTextures)) {
    return;
  }
  for (let i2 = 0; i2 < propertyTextures.length; i2++) {
    const propertyTexture = propertyTextures[i2];
    const properties = propertyTexture.properties;
    for (const propertyId in properties) {
      if (properties.hasOwnProperty(propertyId)) {
        const property = properties[propertyId];
        if (property.isGpuCompatible()) {
          addPropertyTextureProperty(renderResources, propertyId, property);
        }
      }
    }
  }
}
function addPropertyTextureProperty(renderResources, propertyId, property) {
  const textureReader = property.textureReader;
  const textureIndex = textureReader.index;
  const textureUniformName = `u_propertyTexture_${textureIndex}`;
  if (!renderResources.uniformMap.hasOwnProperty(textureUniformName)) {
    addPropertyTextureUniform(
      renderResources,
      textureUniformName,
      textureReader
    );
  }
  const metadataVariable = sanitizeGlslIdentifier(propertyId);
  const glslType = property.getGlslType();
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addStructField(
    MetadataPipelineStage.STRUCT_ID_METADATA_FS,
    glslType,
    metadataVariable
  );
  const texCoord = textureReader.texCoord;
  const texCoordVariable = `attributes.texCoord_${texCoord}`;
  const channels = textureReader.channels;
  let unpackedValue = `texture2D(${textureUniformName}, ${texCoordVariable}).${channels}`;
  unpackedValue = property.unpackInShader(unpackedValue);
  if (property.hasValueTransform) {
    unpackedValue = addValueTransformUniforms(unpackedValue, {
      renderResources,
      glslType,
      metadataVariable,
      shaderDestination: ShaderDestination_default.FRAGMENT,
      offset: property.offset,
      scale: property.scale
    });
  }
  const initializationLine = `metadata.${metadataVariable} = ${unpackedValue};`;
  shaderBuilder.addFunctionLines(
    MetadataPipelineStage.FUNCTION_ID_INITIALIZE_METADATA_FS,
    [initializationLine]
  );
}
function addPropertyTextureUniform(renderResources, uniformName, textureReader) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addUniform(
    "sampler2D",
    uniformName,
    ShaderDestination_default.FRAGMENT
  );
  const uniformMap2 = renderResources.uniformMap;
  uniformMap2[uniformName] = function() {
    return textureReader.texture;
  };
}
function addValueTransformUniforms(valueExpression, options) {
  const metadataVariable = options.metadataVariable;
  const offsetUniformName = `u_${metadataVariable}_offset`;
  const scaleUniformName = `u_${metadataVariable}_scale`;
  const renderResources = options.renderResources;
  const shaderBuilder = renderResources.shaderBuilder;
  const glslType = options.glslType;
  const shaderDestination = options.shaderDestination;
  shaderBuilder.addUniform(glslType, offsetUniformName, shaderDestination);
  shaderBuilder.addUniform(glslType, scaleUniformName, shaderDestination);
  const uniformMap2 = renderResources.uniformMap;
  uniformMap2[offsetUniformName] = function() {
    return options.offset;
  };
  uniformMap2[scaleUniformName] = function() {
    return options.scale;
  };
  return `czm_valueTransform(${offsetUniformName}, ${scaleUniformName}, ${valueExpression})`;
}
function sanitizeGlslIdentifier(identifier) {
  return identifier.replaceAll(/[^_a-zA-Z0-9]+/g, "_");
}
var MetadataPipelineStage_default = MetadataPipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/CustomShaderPipelineStage.js
var CustomShaderPipelineStage = {};
CustomShaderPipelineStage.name = "CustomShaderPipelineStage";
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_VS = "AttributesVS";
CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_FS = "AttributesFS";
CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES = "Attributes";
CustomShaderPipelineStage.STRUCT_ID_VERTEX_INPUT = "VertexInput";
CustomShaderPipelineStage.STRUCT_NAME_VERTEX_INPUT = "VertexInput";
CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT = "FragmentInput";
CustomShaderPipelineStage.STRUCT_NAME_FRAGMENT_INPUT = "FragmentInput";
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_VS = "initializeInputStructVS";
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_VS = "void initializeInputStruct(out VertexInput vsInput, ProcessedAttributes attributes)";
CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_FS = "initializeInputStructFS";
CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_FS = "void initializeInputStruct(out FragmentInput fsInput, ProcessedAttributes attributes)";
CustomShaderPipelineStage.process = function(renderResources, primitive, frameState) {
  const shaderBuilder = renderResources.shaderBuilder;
  const customShader = renderResources.model.customShader;
  if (defined_default(customShader.lightingModel)) {
    renderResources.lightingOptions.lightingModel = customShader.lightingModel;
  }
  const alphaOptions = renderResources.alphaOptions;
  if (customShader.isTranslucent) {
    alphaOptions.pass = Pass_default.TRANSLUCENT;
    alphaOptions.alphaMode = AlphaMode_default.BLEND;
  } else {
    alphaOptions.pass = void 0;
    alphaOptions.alphaMode = AlphaMode_default.OPAQUE;
  }
  const generatedCode = generateShaderLines(customShader, primitive);
  if (!generatedCode.customShaderEnabled) {
    return;
  }
  addLinesToShader(shaderBuilder, customShader, generatedCode);
  if (generatedCode.shouldComputePositionWC) {
    shaderBuilder.addDefine(
      "COMPUTE_POSITION_WC",
      void 0,
      ShaderDestination_default.BOTH
    );
  }
  if (defined_default(customShader.vertexShaderText)) {
    shaderBuilder.addDefine(
      "HAS_CUSTOM_VERTEX_SHADER",
      void 0,
      ShaderDestination_default.VERTEX
    );
  }
  if (defined_default(customShader.fragmentShaderText)) {
    shaderBuilder.addDefine(
      "HAS_CUSTOM_FRAGMENT_SHADER",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
    const shaderModeDefine = CustomShaderMode_default.getDefineName(customShader.mode);
    shaderBuilder.addDefine(
      shaderModeDefine,
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  const uniforms = customShader.uniforms;
  for (const uniformName in uniforms) {
    if (uniforms.hasOwnProperty(uniformName)) {
      const uniform = uniforms[uniformName];
      shaderBuilder.addUniform(uniform.type, uniformName);
    }
  }
  const varyings = customShader.varyings;
  for (const varyingName in varyings) {
    if (varyings.hasOwnProperty(varyingName)) {
      const varyingType = varyings[varyingName];
      shaderBuilder.addVarying(varyingType, varyingName);
    }
  }
  renderResources.uniformMap = combine_default(
    renderResources.uniformMap,
    customShader.uniformMap
  );
};
function getAttributesByName(attributes) {
  const names = {};
  for (let i2 = 0; i2 < attributes.length; i2++) {
    const attribute = attributes[i2];
    const attributeInfo = ModelExperimentalUtility.getAttributeInfo(attribute);
    names[attributeInfo.variableName] = attributeInfo;
  }
  return names;
}
var attributeTypeLUT = {
  position: "vec3",
  normal: "vec3",
  tangent: "vec3",
  bitangent: "vec3",
  texCoord: "vec2",
  color: "vec4",
  joints: "ivec4",
  weights: "vec4"
};
var attributeDefaultValueLUT = {
  position: "vec3(0.0)",
  normal: "vec3(0.0, 0.0, 1.0)",
  tangent: "vec3(1.0, 0.0, 0.0)",
  bitangent: "vec3(0.0, 1.0, 0.0)",
  texCoord: "vec2(0.0)",
  color: "vec4(1.0)",
  joints: "ivec4(0)",
  weights: "vec4(0.0)"
};
function inferAttributeDefaults(attributeName) {
  let trimmed = attributeName.replace(/_[0-9]+$/, "");
  trimmed = trimmed.replace(/(MC|EC)$/, "");
  const glslType = attributeTypeLUT[trimmed];
  const value = attributeDefaultValueLUT[trimmed];
  if (!defined_default(glslType)) {
    return void 0;
  }
  return {
    attributeField: [glslType, attributeName],
    value
  };
}
function generateVertexShaderLines(customShader, attributesByName, vertexLines) {
  const categories = partitionAttributes(
    attributesByName,
    customShader.usedVariablesVertex.attributeSet,
    false
  );
  const addToShader = categories.addToShader;
  const needsDefault = categories.missingAttributes;
  let variableName;
  let vertexInitialization;
  const attributeFields = [];
  const initializationLines = [];
  for (variableName in addToShader) {
    if (addToShader.hasOwnProperty(variableName)) {
      const attributeInfo = addToShader[variableName];
      const attributeField = [attributeInfo.glslType, variableName];
      attributeFields.push(attributeField);
      vertexInitialization = `vsInput.attributes.${variableName} = attributes.${variableName};`;
      initializationLines.push(vertexInitialization);
    }
  }
  for (let i2 = 0; i2 < needsDefault.length; i2++) {
    variableName = needsDefault[i2];
    const attributeDefaults = inferAttributeDefaults(variableName);
    if (!defined_default(attributeDefaults)) {
      CustomShaderPipelineStage._oneTimeWarning(
        "CustomShaderPipelineStage.incompatiblePrimitiveVS",
        `Primitive is missing attribute ${variableName}, disabling custom vertex shader`
      );
      return;
    }
    attributeFields.push(attributeDefaults.attributeField);
    vertexInitialization = `vsInput.attributes.${variableName} = ${attributeDefaults.value};`;
    initializationLines.push(vertexInitialization);
  }
  vertexLines.enabled = true;
  vertexLines.attributeFields = attributeFields;
  vertexLines.initializationLines = initializationLines;
}
function generatePositionBuiltins(customShader) {
  const attributeFields = [];
  const initializationLines = [];
  const usedVariables = customShader.usedVariablesFragment.attributeSet;
  if (usedVariables.hasOwnProperty("positionWC")) {
    attributeFields.push(["vec3", "positionWC"]);
    initializationLines.push(
      "fsInput.attributes.positionWC = attributes.positionWC;"
    );
  }
  if (usedVariables.hasOwnProperty("positionEC")) {
    attributeFields.push(["vec3", "positionEC"]);
    initializationLines.push(
      "fsInput.attributes.positionEC = attributes.positionEC;"
    );
  }
  return {
    attributeFields,
    initializationLines
  };
}
function generateFragmentShaderLines(customShader, attributesByName, fragmentLines) {
  const categories = partitionAttributes(
    attributesByName,
    customShader.usedVariablesFragment.attributeSet,
    true
  );
  const addToShader = categories.addToShader;
  const needsDefault = categories.missingAttributes;
  let variableName;
  let fragmentInitialization;
  const attributeFields = [];
  const initializationLines = [];
  for (variableName in addToShader) {
    if (addToShader.hasOwnProperty(variableName)) {
      const attributeInfo = addToShader[variableName];
      const attributeField = [attributeInfo.glslType, variableName];
      attributeFields.push(attributeField);
      fragmentInitialization = `fsInput.attributes.${variableName} = attributes.${variableName};`;
      initializationLines.push(fragmentInitialization);
    }
  }
  for (let i2 = 0; i2 < needsDefault.length; i2++) {
    variableName = needsDefault[i2];
    const attributeDefaults = inferAttributeDefaults(variableName);
    if (!defined_default(attributeDefaults)) {
      CustomShaderPipelineStage._oneTimeWarning(
        "CustomShaderPipelineStage.incompatiblePrimitiveFS",
        `Primitive is missing attribute ${variableName}, disabling custom fragment shader.`
      );
      return;
    }
    attributeFields.push(attributeDefaults.attributeField);
    fragmentInitialization = `fsInput.attributes.${variableName} = ${attributeDefaults.value};`;
    initializationLines.push(fragmentInitialization);
  }
  const positionBuiltins = generatePositionBuiltins(customShader);
  fragmentLines.enabled = true;
  fragmentLines.attributeFields = attributeFields.concat(
    positionBuiltins.attributeFields
  );
  fragmentLines.initializationLines = positionBuiltins.initializationLines.concat(
    initializationLines
  );
}
var builtinAttributes = {
  positionWC: true,
  positionEC: true
};
function partitionAttributes(primitiveAttributes, shaderAttributeSet, isFragmentShader) {
  let renamed;
  let attributeName;
  const addToShader = {};
  for (attributeName in primitiveAttributes) {
    if (primitiveAttributes.hasOwnProperty(attributeName)) {
      const attribute = primitiveAttributes[attributeName];
      renamed = attributeName;
      if (isFragmentShader && attributeName === "normalMC") {
        renamed = "normalEC";
      } else if (isFragmentShader && attributeName === "tangentMC") {
        renamed = "tangentEC";
      }
      if (shaderAttributeSet.hasOwnProperty(renamed)) {
        addToShader[renamed] = attribute;
      }
    }
  }
  const missingAttributes = [];
  for (attributeName in shaderAttributeSet) {
    if (shaderAttributeSet.hasOwnProperty(attributeName)) {
      if (builtinAttributes.hasOwnProperty(attributeName)) {
        continue;
      }
      renamed = attributeName;
      if (isFragmentShader && attributeName === "normalEC") {
        renamed = "normalMC";
      } else if (isFragmentShader && attributeName === "tangentEC") {
        renamed = "tangentMC";
      }
      if (!primitiveAttributes.hasOwnProperty(renamed)) {
        missingAttributes.push(attributeName);
      }
    }
  }
  return {
    addToShader,
    missingAttributes
  };
}
function generateShaderLines(customShader, primitive) {
  const vertexLines = {
    enabled: false
  };
  const fragmentLines = {
    enabled: false
  };
  const attributesByName = getAttributesByName(primitive.attributes);
  if (defined_default(customShader.vertexShaderText)) {
    generateVertexShaderLines(customShader, attributesByName, vertexLines);
  }
  if (defined_default(customShader.fragmentShaderText)) {
    generateFragmentShaderLines(customShader, attributesByName, fragmentLines);
  }
  const attributeSetFS = customShader.usedVariablesFragment.attributeSet;
  const shouldComputePositionWC = attributeSetFS.hasOwnProperty("positionWC") && fragmentLines.enabled;
  return {
    vertexLines,
    fragmentLines,
    vertexLinesEnabled: vertexLines.enabled,
    fragmentLinesEnabled: fragmentLines.enabled,
    customShaderEnabled: vertexLines.enabled || fragmentLines.enabled,
    shouldComputePositionWC
  };
}
function addVertexLinesToShader(shaderBuilder, vertexLines) {
  let i2;
  let structId = CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_VS;
  shaderBuilder.addStruct(
    structId,
    CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
    ShaderDestination_default.VERTEX
  );
  const attributeFields = vertexLines.attributeFields;
  for (i2 = 0; i2 < attributeFields.length; i2++) {
    const field = attributeFields[i2];
    const glslType = field[0];
    const variableName = field[1];
    shaderBuilder.addStructField(structId, glslType, variableName);
  }
  structId = CustomShaderPipelineStage.STRUCT_ID_VERTEX_INPUT;
  shaderBuilder.addStruct(
    structId,
    CustomShaderPipelineStage.STRUCT_NAME_VERTEX_INPUT,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addStructField(
    structId,
    CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
    "attributes"
  );
  shaderBuilder.addStructField(
    structId,
    FeatureIdPipelineStage_default.STRUCT_NAME_FEATURE_IDS,
    "featureIds"
  );
  shaderBuilder.addStructField(
    structId,
    MetadataPipelineStage_default.STRUCT_NAME_METADATA,
    "metadata"
  );
  const functionId = CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_VS;
  shaderBuilder.addFunction(
    functionId,
    CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_VS,
    ShaderDestination_default.VERTEX
  );
  const initializationLines = vertexLines.initializationLines;
  shaderBuilder.addFunctionLines(functionId, initializationLines);
}
function addFragmentLinesToShader(shaderBuilder, fragmentLines) {
  let i2;
  let structId = CustomShaderPipelineStage.STRUCT_ID_ATTRIBUTES_FS;
  shaderBuilder.addStruct(
    structId,
    CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
    ShaderDestination_default.FRAGMENT
  );
  let field;
  let glslType;
  let variableName;
  const attributeFields = fragmentLines.attributeFields;
  for (i2 = 0; i2 < attributeFields.length; i2++) {
    field = attributeFields[i2];
    glslType = field[0];
    variableName = field[1];
    shaderBuilder.addStructField(structId, glslType, variableName);
  }
  structId = CustomShaderPipelineStage.STRUCT_ID_FRAGMENT_INPUT;
  shaderBuilder.addStruct(
    structId,
    CustomShaderPipelineStage.STRUCT_NAME_FRAGMENT_INPUT,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addStructField(
    structId,
    CustomShaderPipelineStage.STRUCT_NAME_ATTRIBUTES,
    "attributes"
  );
  shaderBuilder.addStructField(
    structId,
    FeatureIdPipelineStage_default.STRUCT_NAME_FEATURE_IDS,
    "featureIds"
  );
  shaderBuilder.addStructField(
    structId,
    MetadataPipelineStage_default.STRUCT_NAME_METADATA,
    "metadata"
  );
  const functionId = CustomShaderPipelineStage.FUNCTION_ID_INITIALIZE_INPUT_STRUCT_FS;
  shaderBuilder.addFunction(
    functionId,
    CustomShaderPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_INPUT_STRUCT_FS,
    ShaderDestination_default.FRAGMENT
  );
  const initializationLines = fragmentLines.initializationLines;
  shaderBuilder.addFunctionLines(functionId, initializationLines);
}
function addLinesToShader(shaderBuilder, customShader, generatedCode) {
  const vertexLines = generatedCode.vertexLines;
  if (vertexLines.enabled) {
    addVertexLinesToShader(shaderBuilder, vertexLines);
    shaderBuilder.addVertexLines([
      "#line 0",
      customShader.vertexShaderText,
      CustomShaderStageVS_default
    ]);
  }
  const fragmentLines = generatedCode.fragmentLines;
  if (fragmentLines.enabled) {
    addFragmentLinesToShader(shaderBuilder, fragmentLines);
    shaderBuilder.addFragmentLines([
      "#line 0",
      customShader.fragmentShaderText,
      CustomShaderStageFS_default
    ]);
  }
}
CustomShaderPipelineStage._oneTimeWarning = oneTimeWarning_default;
var CustomShaderPipelineStage_default = CustomShaderPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/CPUStylingStageVS.js
var CPUStylingStageVS_default = "void filterByPassType(inout vec3 positionMC, vec4 featureColor)\n{\n    bool styleTranslucent = (featureColor.a != 1.0);\n    // Only render translucent features in the translucent pass (if the style or the original command has translucency).\n    if (czm_pass == czm_passTranslucent && !styleTranslucent && !model_commandTranslucent)\n    {\n        positionMC *= 0.0;\n    }\n    // If the current pass is not the transluceny pass and the style is not translucent, don't rendeer the feature.\n    else if (czm_pass != czm_passTranslucent && styleTranslucent)\n    {\n        positionMC *= 0.0;\n    }\n}\n\nvoid cpuStylingStage(inout vec3 positionMC, inout SelectedFeature feature)\n{\n    float show = ceil(feature.color.a);\n    positionMC *= show;\n\n    #ifdef HAS_SELECTED_FEATURE_ID_ATTRIBUTE\n    filterByPassType(positionMC, feature.color);\n    #endif\n}\n";

// node_modules/cesium/Source/Shaders/ModelExperimental/CPUStylingStageFS.js
var CPUStylingStageFS_default = "void filterByPassType(vec4 featureColor)\n{\n    bool styleTranslucent = (featureColor.a != 1.0);\n    // Only render translucent features in the translucent pass (if the style or the original command has translucency).\n    if (czm_pass == czm_passTranslucent && !styleTranslucent && !model_commandTranslucent)\n    {\n        discard;\n    }\n    // If the current pass is not the translucent pass and the style is not translucent, don't render the feature.\n    else if (czm_pass != czm_passTranslucent && styleTranslucent)\n    {\n        discard;\n    }\n}\n\nvoid cpuStylingStage(inout czm_modelMaterial material, SelectedFeature feature)\n{\n    vec4 featureColor = feature.color;\n\n    if (featureColor.a == 0.0)\n    {\n        discard;\n    }\n\n    // If a feature ID vertex attribute is used, the pass type filter is applied in the vertex shader.\n    // So, we only apply in in the fragment shader if the feature ID texture is used.\n    #ifdef HAS_SELECTED_FEATURE_ID_TEXTURE\n    filterByPassType(featureColor);\n    #endif\n\n    featureColor = czm_gammaCorrect(featureColor);\n\n    float highlight = ceil(model_colorBlend);\n    material.diffuse *= mix(featureColor.rgb, vec3(1.0), highlight);\n    material.alpha *= featureColor.a;\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/CPUStylingPipelineStage.js
var CPUStylingPipelineStage = {};
CPUStylingPipelineStage.name = "CPUStylingPipelineStage";
CPUStylingPipelineStage.process = function(renderResources, primitive, frameState) {
  const model = renderResources.model;
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addVertexLines([CPUStylingStageVS_default]);
  shaderBuilder.addFragmentLines([CPUStylingStageFS_default]);
  shaderBuilder.addDefine("USE_CPU_STYLING", void 0, ShaderDestination_default.BOTH);
  if (!defined_default(model.color)) {
    shaderBuilder.addUniform(
      "float",
      ModelColorPipelineStage_default.COLOR_BLEND_UNIFORM_NAME,
      ShaderDestination_default.FRAGMENT
    );
    renderResources.uniformMap[ModelColorPipelineStage_default.COLOR_BLEND_UNIFORM_NAME] = function() {
      return ColorBlendMode_default.getColorBlend(
        model.colorBlendMode,
        model.colorBlendAmount
      );
    };
  }
  shaderBuilder.addUniform(
    "bool",
    "model_commandTranslucent",
    ShaderDestination_default.BOTH
  );
  renderResources.uniformMap.model_commandTranslucent = function() {
    return renderResources.alphaOptions.pass === Pass_default.TRANSLUCENT;
  };
  const featureTable = model.featureTables[model.featureTableId];
  const styleCommandsNeeded = StyleCommandsNeeded_default.getStyleCommandsNeeded(
    featureTable.featuresLength,
    featureTable.batchTexture.translucentFeaturesLength
  );
  if (styleCommandsNeeded !== StyleCommandsNeeded_default.ALL_OPAQUE) {
    renderResources.alphaOptions.alphaMode = AlphaMode_default.BLEND;
  }
  renderResources.styleCommandsNeeded = styleCommandsNeeded;
};
var CPUStylingPipelineStage_default = CPUStylingPipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/DequantizationPipelineStage.js
var DequantizationPipelineStage = {};
DequantizationPipelineStage.name = "DequantizationPipelineStage";
DequantizationPipelineStage.FUNCTION_ID_DEQUANTIZATION_STAGE_VS = "dequantizationStage";
DequantizationPipelineStage.FUNCTION_SIGNATURE_DEQUANTIZATION_STAGE_VS = "void dequantizationStage(inout ProcessedAttributes attributes)";
DequantizationPipelineStage.process = function(renderResources, primitive) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addFunction(
    DequantizationPipelineStage.FUNCTION_ID_DEQUANTIZATION_STAGE_VS,
    DequantizationPipelineStage.FUNCTION_SIGNATURE_DEQUANTIZATION_STAGE_VS,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addDefine(
    "USE_DEQUANTIZATION",
    void 0,
    ShaderDestination_default.VERTEX
  );
  const attributes = primitive.attributes;
  for (let i2 = 0; i2 < attributes.length; i2++) {
    const attribute = attributes[i2];
    const quantization = attribute.quantization;
    if (!defined_default(quantization)) {
      continue;
    }
    const attributeInfo = ModelExperimentalUtility.getAttributeInfo(attribute);
    updateDequantizationFunction(shaderBuilder, attributeInfo);
    addDequantizationUniforms(renderResources, attributeInfo);
  }
};
function addDequantizationUniforms(renderResources, attributeInfo) {
  const shaderBuilder = renderResources.shaderBuilder;
  const uniformMap2 = renderResources.uniformMap;
  const variableName = attributeInfo.variableName;
  const quantization = attributeInfo.attribute.quantization;
  if (quantization.octEncoded) {
    const normalizationRange = `model_normalizationRange_${variableName}`;
    shaderBuilder.addUniform(
      "float",
      normalizationRange,
      ShaderDestination_default.VERTEX
    );
    uniformMap2[normalizationRange] = function() {
      return quantization.normalizationRange;
    };
  } else {
    const offset2 = `model_quantizedVolumeOffset_${variableName}`;
    const stepSize = `model_quantizedVolumeStepSize_${variableName}`;
    const glslType = attributeInfo.glslType;
    shaderBuilder.addUniform(glslType, offset2, ShaderDestination_default.VERTEX);
    shaderBuilder.addUniform(glslType, stepSize, ShaderDestination_default.VERTEX);
    let quantizedVolumeOffset = quantization.quantizedVolumeOffset;
    let quantizedVolumeStepSize = quantization.quantizedVolumeStepSize;
    if (/^color_\d+$/.test(variableName)) {
      quantizedVolumeOffset = promoteToVec4(quantizedVolumeOffset, 0);
      quantizedVolumeStepSize = promoteToVec4(quantizedVolumeStepSize, 1);
    }
    uniformMap2[offset2] = function() {
      return quantizedVolumeOffset;
    };
    uniformMap2[stepSize] = function() {
      return quantizedVolumeStepSize;
    };
  }
}
function promoteToVec4(value, defaultAlpha) {
  if (value instanceof Cartesian4_default) {
    return value;
  }
  return new Cartesian4_default(value.x, value.y, value.z, defaultAlpha);
}
function updateDequantizationFunction(shaderBuilder, attributeInfo) {
  const variableName = attributeInfo.variableName;
  const quantization = attributeInfo.attribute.quantization;
  let line;
  if (quantization.octEncoded) {
    line = generateOctDecodeLine(variableName, quantization);
  } else {
    line = generateDequantizeLine(variableName);
  }
  shaderBuilder.addFunctionLines(
    DequantizationPipelineStage.FUNCTION_ID_DEQUANTIZATION_STAGE_VS,
    [line]
  );
}
function generateOctDecodeLine(variableName, quantization) {
  const structField = `attributes.${variableName}`;
  const quantizedAttribute = `a_quantized_${variableName}`;
  const normalizationRange = `model_normalizationRange_${variableName}`;
  const swizzle = quantization.octEncodedZXY ? ".zxy" : ".xyz";
  return `${structField} = czm_octDecode(${quantizedAttribute}, ${normalizationRange})${swizzle};`;
}
function generateDequantizeLine(variableName) {
  const structField = `attributes.${variableName}`;
  const quantizedAttribute = `a_quantized_${variableName}`;
  const offset2 = `model_quantizedVolumeOffset_${variableName}`;
  const stepSize = `model_quantizedVolumeStepSize_${variableName}`;
  return `${structField} = ${offset2} + ${quantizedAttribute} * ${stepSize};`;
}
var DequantizationPipelineStage_default = DequantizationPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/GeometryStageFS.js
var GeometryStageFS_default = "void geometryStage(out ProcessedAttributes attributes)\n{\n  attributes.positionMC = v_positionMC;\n  attributes.positionEC = v_positionEC;\n\n  #ifdef COMPUTE_POSITION_WC\n  attributes.positionWC = v_positionWC;\n  #endif\n\n  #ifdef HAS_NORMALS\n  // renormalize after interpolation\n  attributes.normalEC = normalize(v_normalEC);\n  #endif\n\n  #ifdef HAS_TANGENTS\n  attributes.tangentEC = normalize(v_tangentEC);\n  #endif\n\n  #ifdef HAS_BITANGENTS\n  attributes.bitangentEC = normalize(v_bitangentEC);\n  #endif\n\n  // Everything else is dynamically generated in GeometryPipelineStage\n  setDynamicVaryings(attributes);\n}\n";

// node_modules/cesium/Source/Shaders/ModelExperimental/GeometryStageVS.js
var GeometryStageVS_default = "void geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 normal) \n{\n    // Compute positions in different coordinate systems\n    vec3 positionMC = attributes.positionMC;\n    v_positionMC = positionMC;\n    v_positionEC = (modelView * vec4(positionMC, 1.0)).xyz;\n    gl_Position = czm_projection * vec4(v_positionEC, 1.0);\n\n    // Sometimes the fragment shader needs this (e.g. custom shaders)\n    #ifdef COMPUTE_POSITION_WC\n    // Note that this is a 32-bit position which may result in jitter on small\n    // scales.\n    v_positionWC = (czm_model * vec4(positionMC, 1.0)).xyz;\n    #endif\n\n    #ifdef HAS_NORMALS\n    v_normalEC = normal * attributes.normalMC;\n    #endif\n\n    #ifdef HAS_TANGENTS\n    v_tangentEC = normalize(normal * attributes.tangentMC);    \n    #endif\n\n    #ifdef HAS_BITANGENTS\n    v_bitangentEC = normalize(normal * attributes.bitangentMC);\n    #endif\n\n    // All other varyings need to be dynamically generated in\n    // GeometryPipelineStage\n    setDynamicVaryings(attributes);\n}\n";

// node_modules/cesium/Source/Shaders/ModelExperimental/SelectedFeatureIdStageCommon.js
var SelectedFeatureIdStageCommon_default = "vec2 computeSt(float featureId)\n{\n    float stepX = model_textureStep.x;\n    float centerX = model_textureStep.y;\n\n    #ifdef MULTILINE_BATCH_TEXTURE\n    float stepY = model_textureStep.z;\n    float centerY = model_textureStep.w;\n\n    float xId = mod(featureId, model_textureDimensions.x); \n    float yId = floor(featureId / model_textureDimensions.x);\n    \n    return vec2(centerX + (xId * stepX), centerY + (yId * stepY));\n    #else\n    return vec2(centerX + (featureId * stepX), 0.5);\n    #endif\n}\n\nvoid selectedFeatureIdStage(out SelectedFeature feature, FeatureIds featureIds)\n{   \n    int featureId = featureIds.SELECTED_FEATURE_ID;\n\n\n    if (featureId < model_featuresLength)\n    {\n        vec2 featureSt = computeSt(float(featureId));\n\n        feature.id = featureId;\n        feature.st = featureSt;\n        feature.color = texture2D(model_batchTexture, featureSt);\n    }\n    // Floating point comparisons can be unreliable in GLSL, so we\n    // increment the feature ID to make sure it's always greater\n    // then the model_featuresLength - a condition we check for in the\n    // pick ID, to avoid sampling the pick texture if the feature ID is\n    // greater than the number of features.\n    else\n    {\n        feature.id = model_featuresLength + 1;\n        feature.st = vec2(0.0);\n        feature.color = vec4(1.0);\n    }\n\n    #ifdef HAS_NULL_FEATURE_ID\n    if (featureId == model_nullFeatureId) {\n        feature.id = featureId;\n        feature.st = vec2(0.0);\n        feature.color = vec4(1.0);\n    }\n    #endif\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/SelectedFeatureIdPipelineStage.js
var SelectedFeatureIdPipelineStage = {};
SelectedFeatureIdPipelineStage.name = "SelectedFeatureIdPipelineStage";
SelectedFeatureIdPipelineStage.STRUCT_ID_SELECTED_FEATURE = "SelectedFeature";
SelectedFeatureIdPipelineStage.STRUCT_NAME_SELECTED_FEATURE = "SelectedFeature";
SelectedFeatureIdPipelineStage.FUNCTION_ID_FEATURE_VARYINGS_VS = "updateFeatureStructVS";
SelectedFeatureIdPipelineStage.FUNCTION_ID_FEATURE_VARYINGS_FS = "updateFeatureStructFS";
SelectedFeatureIdPipelineStage.FUNCTION_SIGNATURE_UPDATE_FEATURE = "void updateFeatureStruct(inout SelectedFeature feature)";
SelectedFeatureIdPipelineStage.process = function(renderResources, primitive, frameState) {
  const shaderBuilder = renderResources.shaderBuilder;
  renderResources.hasPropertyTable = true;
  const model = renderResources.model;
  const node = renderResources.runtimeNode.node;
  const selectedFeatureIds = getSelectedFeatureIds(model, node, primitive);
  const shaderDestination = selectedFeatureIds.shaderDestination;
  shaderBuilder.addDefine(
    "HAS_SELECTED_FEATURE_ID",
    void 0,
    shaderDestination
  );
  shaderBuilder.addDefine(
    "SELECTED_FEATURE_ID",
    selectedFeatureIds.variableName,
    shaderDestination
  );
  shaderBuilder.addDefine(
    selectedFeatureIds.featureIdDefine,
    void 0,
    shaderDestination
  );
  updateFeatureStruct(shaderBuilder);
  const nullFeatureId = selectedFeatureIds.featureIds.nullFeatureId;
  const uniformMap2 = renderResources.uniformMap;
  if (defined_default(nullFeatureId)) {
    shaderBuilder.addDefine(
      "HAS_NULL_FEATURE_ID",
      void 0,
      shaderDestination
    );
    shaderBuilder.addUniform("int", "model_nullFeatureId", shaderDestination);
    uniformMap2.model_nullFeatureId = function() {
      return nullFeatureId;
    };
  }
  if (selectedFeatureIds.shaderDestination === ShaderDestination_default.BOTH) {
    shaderBuilder.addVertexLines([SelectedFeatureIdStageCommon_default]);
  }
  shaderBuilder.addFragmentLines([SelectedFeatureIdStageCommon_default]);
};
function getFeatureIdDefine(featureIds) {
  if (featureIds instanceof ModelComponents_default.FeatureIdTexture) {
    return "HAS_SELECTED_FEATURE_ID_TEXTURE";
  }
  return "HAS_SELECTED_FEATURE_ID_ATTRIBUTE";
}
function getShaderDestination(featureIds) {
  if (featureIds instanceof ModelComponents_default.FeatureIdTexture) {
    return ShaderDestination_default.FRAGMENT;
  }
  return ShaderDestination_default.BOTH;
}
function getSelectedFeatureIds(model, node, primitive) {
  let variableName;
  let featureIds;
  if (defined_default(node.instances)) {
    featureIds = ModelExperimentalUtility.getFeatureIdsByLabel(
      node.instances.featureIds,
      model.instanceFeatureIdLabel
    );
    if (defined_default(featureIds)) {
      variableName = defaultValue_default(featureIds.label, featureIds.positionalLabel);
      return {
        featureIds,
        variableName,
        shaderDestination: getShaderDestination(featureIds),
        featureIdDefine: getFeatureIdDefine(featureIds)
      };
    }
  }
  featureIds = ModelExperimentalUtility.getFeatureIdsByLabel(
    primitive.featureIds,
    model.featureIdLabel
  );
  variableName = defaultValue_default(featureIds.label, featureIds.positionalLabel);
  return {
    featureIds,
    variableName,
    shaderDestination: getShaderDestination(featureIds),
    featureIdDefine: getFeatureIdDefine(featureIds)
  };
}
function updateFeatureStruct(shaderBuilder) {
  shaderBuilder.addStructField(
    SelectedFeatureIdPipelineStage.STRUCT_ID_SELECTED_FEATURE,
    "int",
    "id"
  );
  shaderBuilder.addStructField(
    SelectedFeatureIdPipelineStage.STRUCT_ID_SELECTED_FEATURE,
    "vec2",
    "st"
  );
  shaderBuilder.addStructField(
    SelectedFeatureIdPipelineStage.STRUCT_ID_SELECTED_FEATURE,
    "vec4",
    "color"
  );
}
var SelectedFeatureIdPipelineStage_default = SelectedFeatureIdPipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimentalType.js
var ModelExperimentalType = {
  GLTF: "GLTF",
  TILE_GLTF: "TILE_GLTF",
  TILE_B3DM: "B3DM",
  TILE_I3DM: "I3DM",
  TILE_PNTS: "PNTS"
};
ModelExperimentalType.is3DTiles = function(modelType) {
  Check_default.typeOf.string("modelType", modelType);
  switch (modelType) {
    case ModelExperimentalType.TILE_GLTF:
    case ModelExperimentalType.TILE_B3DM:
    case ModelExperimentalType.TILE_I3DM:
    case ModelExperimentalType.TILE_PNTS:
      return true;
    case ModelExperimentalType.GLTF:
      return false;
    default:
      throw new DeveloperError_default("modelType is not a valid value.");
  }
};
var ModelExperimentalType_default = Object.freeze(ModelExperimentalType);

// node_modules/cesium/Source/Scene/ModelExperimental/GeometryPipelineStage.js
var GeometryPipelineStage = {};
GeometryPipelineStage.name = "GeometryPipelineStage";
GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_VS = "ProcessedAttributesVS";
GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_FS = "ProcessedAttributesFS";
GeometryPipelineStage.STRUCT_NAME_PROCESSED_ATTRIBUTES = "ProcessedAttributes";
GeometryPipelineStage.FUNCTION_ID_INITIALIZE_ATTRIBUTES = "initializeAttributes";
GeometryPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_ATTRIBUTES = "void initializeAttributes(out ProcessedAttributes attributes)";
GeometryPipelineStage.FUNCTION_ID_SET_DYNAMIC_VARYINGS_VS = "setDynamicVaryingsVS";
GeometryPipelineStage.FUNCTION_ID_SET_DYNAMIC_VARYINGS_FS = "setDynamicVaryingsFS";
GeometryPipelineStage.FUNCTION_SIGNATURE_SET_DYNAMIC_VARYINGS = "void setDynamicVaryings(inout ProcessedAttributes attributes)";
GeometryPipelineStage.process = function(renderResources, primitive) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addStruct(
    GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_VS,
    "ProcessedAttributes",
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addStruct(
    GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_FS,
    "ProcessedAttributes",
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addStruct(
    SelectedFeatureIdPipelineStage_default.STRUCT_ID_SELECTED_FEATURE,
    SelectedFeatureIdPipelineStage_default.STRUCT_NAME_SELECTED_FEATURE,
    ShaderDestination_default.BOTH
  );
  shaderBuilder.addFunction(
    GeometryPipelineStage.FUNCTION_ID_INITIALIZE_ATTRIBUTES,
    GeometryPipelineStage.FUNCTION_SIGNATURE_INITIALIZE_ATTRIBUTES,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addVarying("vec3", "v_positionWC");
  shaderBuilder.addVarying("vec3", "v_positionEC");
  shaderBuilder.addStructField(
    GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_FS,
    "vec3",
    "positionWC"
  );
  shaderBuilder.addStructField(
    GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_FS,
    "vec3",
    "positionEC"
  );
  shaderBuilder.addFunction(
    GeometryPipelineStage.FUNCTION_ID_SET_DYNAMIC_VARYINGS_VS,
    GeometryPipelineStage.FUNCTION_SIGNATURE_SET_DYNAMIC_VARYINGS,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addFunction(
    GeometryPipelineStage.FUNCTION_ID_SET_DYNAMIC_VARYINGS_FS,
    GeometryPipelineStage.FUNCTION_SIGNATURE_SET_DYNAMIC_VARYINGS,
    ShaderDestination_default.FRAGMENT
  );
  const modelType = renderResources.model.type;
  if (modelType === ModelExperimentalType_default.TILE_PNTS) {
    shaderBuilder.addDefine(
      "HAS_SRGB_COLOR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  for (let i2 = 0; i2 < primitive.attributes.length; i2++) {
    const attribute = primitive.attributes[i2];
    const attributeLocationCount = AttributeType_default.getAttributeLocationCount(
      attribute.type
    );
    let index2;
    if (attributeLocationCount > 1) {
      index2 = renderResources.attributeIndex;
      renderResources.attributeIndex += attributeLocationCount;
    } else if (attribute.semantic === VertexAttributeSemantic_default.POSITION) {
      index2 = 0;
    } else {
      index2 = renderResources.attributeIndex++;
    }
    processAttribute2(renderResources, attribute, index2, attributeLocationCount);
  }
  handleBitangents(shaderBuilder, primitive.attributes);
  if (primitive.primitiveType === PrimitiveType_default.POINTS) {
    shaderBuilder.addDefine("PRIMITIVE_TYPE_POINTS");
  }
  shaderBuilder.addVertexLines([GeometryStageVS_default]);
  shaderBuilder.addFragmentLines([GeometryStageFS_default]);
};
function processAttribute2(renderResources, attribute, attributeIndex, attributeLocationCount) {
  const shaderBuilder = renderResources.shaderBuilder;
  const attributeInfo = ModelExperimentalUtility.getAttributeInfo(attribute);
  if (attributeLocationCount > 1) {
    addMatrixAttributeToRenderResources(
      renderResources,
      attribute,
      attributeIndex,
      attributeLocationCount
    );
  } else {
    addAttributeToRenderResources(renderResources, attribute, attributeIndex);
  }
  addAttributeDeclaration(shaderBuilder, attributeInfo);
  addVaryingDeclaration(shaderBuilder, attributeInfo);
  if (defined_default(attribute.semantic)) {
    addSemanticDefine(shaderBuilder, attribute);
  }
  updateAttributesStruct(shaderBuilder, attributeInfo);
  updateInitializeAttributesFunction(shaderBuilder, attributeInfo);
  updateSetDynamicVaryingsFunction(shaderBuilder, attributeInfo);
}
function addSemanticDefine(shaderBuilder, attribute) {
  const semantic = attribute.semantic;
  const setIndex = attribute.setIndex;
  switch (semantic) {
    case VertexAttributeSemantic_default.NORMAL:
      shaderBuilder.addDefine("HAS_NORMALS");
      break;
    case VertexAttributeSemantic_default.TANGENT:
      shaderBuilder.addDefine("HAS_TANGENTS");
      break;
    case VertexAttributeSemantic_default.FEATURE_ID:
      shaderBuilder.addDefine(`HAS${semantic}_${setIndex}`);
      break;
    case VertexAttributeSemantic_default.TEXCOORD:
    case VertexAttributeSemantic_default.COLOR:
      shaderBuilder.addDefine(`HAS_${semantic}_${setIndex}`);
  }
}
function addAttributeToRenderResources(renderResources, attribute, attributeIndex) {
  const quantization = attribute.quantization;
  let type;
  let componentDatatype;
  if (defined_default(quantization)) {
    type = quantization.type;
    componentDatatype = quantization.componentDatatype;
  } else {
    type = attribute.type;
    componentDatatype = attribute.componentDatatype;
  }
  const semantic = attribute.semantic;
  const setIndex = attribute.setIndex;
  if (semantic === VertexAttributeSemantic_default.FEATURE_ID && setIndex >= renderResources.featureIdVertexAttributeSetIndex) {
    renderResources.featureIdVertexAttributeSetIndex = setIndex + 1;
  }
  const vertexAttribute = {
    index: attributeIndex,
    value: defined_default(attribute.buffer) ? void 0 : attribute.constant,
    vertexBuffer: attribute.buffer,
    count: attribute.count,
    componentsPerAttribute: AttributeType_default.getNumberOfComponents(type),
    componentDatatype,
    offsetInBytes: attribute.byteOffset,
    strideInBytes: attribute.byteStride,
    normalize: attribute.normalized
  };
  renderResources.attributes.push(vertexAttribute);
}
function addMatrixAttributeToRenderResources(renderResources, attribute, attributeIndex, columnCount) {
  const quantization = attribute.quantization;
  let type;
  let componentDatatype;
  if (defined_default(quantization)) {
    type = quantization.type;
    componentDatatype = quantization.componentDatatype;
  } else {
    type = attribute.type;
    componentDatatype = attribute.componentDatatype;
  }
  const normalized = attribute.normalized;
  const componentCount = AttributeType_default.getNumberOfComponents(type);
  const componentsPerColumn = componentCount / columnCount;
  const componentSizeInBytes = ComponentDatatype_default.getSizeInBytes(
    componentDatatype
  );
  const columnLengthInBytes = componentsPerColumn * componentSizeInBytes;
  const strideInBytes = attribute.byteStride;
  for (let i2 = 0; i2 < columnCount; i2++) {
    const offsetInBytes = attribute.byteOffset + i2 * columnLengthInBytes;
    const columnAttribute = {
      index: attributeIndex + i2,
      vertexBuffer: attribute.buffer,
      componentsPerAttribute: componentsPerColumn,
      componentDatatype,
      offsetInBytes,
      strideInBytes,
      normalize: normalized
    };
    renderResources.attributes.push(columnAttribute);
  }
}
function addVaryingDeclaration(shaderBuilder, attributeInfo) {
  const variableName = attributeInfo.variableName;
  let varyingName = `v_${variableName}`;
  let glslType;
  if (variableName === "normalMC") {
    varyingName = "v_normalEC";
    glslType = attributeInfo.glslType;
  } else if (variableName === "tangentMC") {
    glslType = "vec3";
    varyingName = "v_tangentEC";
  } else {
    glslType = attributeInfo.glslType;
  }
  shaderBuilder.addVarying(glslType, varyingName);
}
function addAttributeDeclaration(shaderBuilder, attributeInfo) {
  const semantic = attributeInfo.attribute.semantic;
  const variableName = attributeInfo.variableName;
  let attributeName;
  let glslType;
  if (attributeInfo.isQuantized) {
    attributeName = `a_quantized_${variableName}`;
    glslType = attributeInfo.quantizedGlslType;
  } else {
    attributeName = `a_${variableName}`;
    glslType = attributeInfo.glslType;
  }
  if (semantic === VertexAttributeSemantic_default.POSITION) {
    shaderBuilder.setPositionAttribute(glslType, attributeName);
  } else {
    shaderBuilder.addAttribute(glslType, attributeName);
  }
}
function updateAttributesStruct(shaderBuilder, attributeInfo) {
  const vsStructId = GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_VS;
  const fsStructId = GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_FS;
  const variableName = attributeInfo.variableName;
  if (variableName === "tangentMC") {
    shaderBuilder.addStructField(vsStructId, "vec3", "tangentMC");
    shaderBuilder.addStructField(vsStructId, "float", "tangentSignMC");
    shaderBuilder.addStructField(fsStructId, "vec3", "tangentEC");
  } else if (variableName === "normalMC") {
    shaderBuilder.addStructField(vsStructId, "vec3", "normalMC");
    shaderBuilder.addStructField(fsStructId, "vec3", "normalEC");
  } else {
    shaderBuilder.addStructField(
      vsStructId,
      attributeInfo.glslType,
      variableName
    );
    shaderBuilder.addStructField(
      fsStructId,
      attributeInfo.glslType,
      variableName
    );
  }
}
function updateInitializeAttributesFunction(shaderBuilder, attributeInfo) {
  if (attributeInfo.isQuantized) {
    return;
  }
  const functionId = GeometryPipelineStage.FUNCTION_ID_INITIALIZE_ATTRIBUTES;
  const variableName = attributeInfo.variableName;
  const lines = [];
  if (variableName === "tangentMC") {
    lines.push("attributes.tangentMC = a_tangentMC.xyz;");
    lines.push("attributes.tangentSignMC = a_tangentMC.w;");
  } else {
    lines.push(`attributes.${variableName} = a_${variableName};`);
  }
  shaderBuilder.addFunctionLines(functionId, lines);
}
function updateSetDynamicVaryingsFunction(shaderBuilder, attributeInfo) {
  const semantic = attributeInfo.attribute.semantic;
  const setIndex = attributeInfo.attribute.setIndex;
  if (defined_default(semantic) && !defined_default(setIndex)) {
    return;
  }
  let functionId = GeometryPipelineStage.FUNCTION_ID_SET_DYNAMIC_VARYINGS_VS;
  const variableName = attributeInfo.variableName;
  let line = `v_${variableName} = attributes.${variableName};`;
  shaderBuilder.addFunctionLines(functionId, [line]);
  functionId = GeometryPipelineStage.FUNCTION_ID_SET_DYNAMIC_VARYINGS_FS;
  line = `attributes.${variableName} = v_${variableName};`;
  shaderBuilder.addFunctionLines(functionId, [line]);
}
function handleBitangents(shaderBuilder, attributes) {
  let hasNormals = false;
  let hasTangents = false;
  for (let i2 = 0; i2 < attributes.length; i2++) {
    const attribute = attributes[i2];
    if (attribute.semantic === VertexAttributeSemantic_default.NORMAL) {
      hasNormals = true;
    } else if (attribute.semantic === VertexAttributeSemantic_default.TANGENT) {
      hasTangents = true;
    }
  }
  if (!hasNormals || !hasTangents) {
    return;
  }
  shaderBuilder.addDefine("HAS_BITANGENTS");
  shaderBuilder.addVarying("vec3", "v_bitangentEC");
  shaderBuilder.addStructField(
    GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_VS,
    "vec3",
    "bitangentMC"
  );
  shaderBuilder.addStructField(
    GeometryPipelineStage.STRUCT_ID_PROCESSED_ATTRIBUTES_FS,
    "vec3",
    "bitangentEC"
  );
}
var GeometryPipelineStage_default = GeometryPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/LightingStageFS.js
var LightingStageFS_default = "#ifdef LIGHTING_PBR\nvec3 computePbrLighting(czm_modelMaterial inputMaterial, ProcessedAttributes attributes)\n{\n    czm_pbrParameters pbrParameters;\n    pbrParameters.diffuseColor = inputMaterial.diffuse;\n    pbrParameters.f0 = inputMaterial.specular;\n    pbrParameters.roughness = inputMaterial.roughness;\n    \n    #ifdef USE_CUSTOM_LIGHT_COLOR\n    vec3 lightColorHdr = model_lightColorHdr;\n    #else\n    vec3 lightColorHdr = czm_lightColorHdr;\n    #endif\n\n    vec3 color = inputMaterial.diffuse;\n    #ifdef HAS_NORMALS\n    color = czm_pbrLighting(\n        attributes.positionEC,\n        inputMaterial.normalEC,\n        czm_lightDirectionEC,\n        lightColorHdr,\n        pbrParameters\n    );\n\n        #ifdef USE_IBL_LIGHTING\n        color += imageBasedLightingStage(\n            attributes.positionEC,\n            inputMaterial.normalEC,\n            czm_lightDirectionEC,\n            lightColorHdr,\n            pbrParameters\n        );\n        #endif\n    #endif\n\n    color *= inputMaterial.occlusion;\n    color += inputMaterial.emissive;\n\n    // In HDR mode, the frame buffer is in linear color space. The\n    // post-processing stages (see PostProcessStageCollection) will handle\n    // tonemapping. However, if HDR is not enabled, we must tonemap else large\n    // values may be clamped to 1.0\n    #ifndef HDR \n    color = czm_acesTonemapping(color);\n    #endif \n\n    return color;\n}\n#endif\n\nvoid lightingStage(inout czm_modelMaterial material, ProcessedAttributes attributes)\n{\n    // Even though the lighting will only set the diffuse color,\n    // pass all other properties so further stages have access to them.\n    vec3 color = vec3(0.0);\n\n    #ifdef LIGHTING_PBR\n    color = computePbrLighting(material, attributes);\n    #else // unlit\n    color = material.diffuse;\n    #endif\n\n    // If HDR is not enabled, the frame buffer stores sRGB colors rather than\n    // linear colors so the linear value must be converted.\n    #ifndef HDR\n    color = czm_linearToSrgb(color);\n    #endif\n\n    material.diffuse = color;\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/LightingModel.js
var LightingModel = {
  UNLIT: 0,
  PBR: 1
};
var LightingModel_default = Object.freeze(LightingModel);

// node_modules/cesium/Source/Scene/ModelExperimental/LightingPipelineStage.js
var LightingPipelineStage = {};
LightingPipelineStage.name = "LightingPipelineStage";
LightingPipelineStage.process = function(renderResources, primitive) {
  const model = renderResources.model;
  const lightingOptions = renderResources.lightingOptions;
  const shaderBuilder = renderResources.shaderBuilder;
  if (defined_default(model.lightColor)) {
    shaderBuilder.addDefine(
      "USE_CUSTOM_LIGHT_COLOR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
    shaderBuilder.addUniform(
      "vec3",
      "model_lightColorHdr",
      ShaderDestination_default.FRAGMENT
    );
    const uniformMap2 = renderResources.uniformMap;
    uniformMap2.model_lightColorHdr = function() {
      return model.lightColor;
    };
  }
  const lightingModel = lightingOptions.lightingModel;
  if (lightingModel === LightingModel_default.PBR) {
    shaderBuilder.addDefine(
      "LIGHTING_PBR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  } else {
    shaderBuilder.addDefine(
      "LIGHTING_UNLIT",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  shaderBuilder.addFragmentLines([LightingStageFS_default]);
};
var LightingPipelineStage_default = LightingPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/MaterialStageFS.js
var MaterialStageFS_default = "// If the style color is white, it implies the feature has not been styled.\nbool isDefaultStyleColor(vec3 color)\n{\n    return all(greaterThan(color, vec3(1.0 - czm_epsilon3)));\n}\n\nvec3 blend(vec3 sourceColor, vec3 styleColor, float styleColorBlend)\n{\n    vec3 blendColor = mix(sourceColor, styleColor, styleColorBlend);\n    vec3 color = isDefaultStyleColor(styleColor.rgb) ? sourceColor : blendColor;\n    return color;\n}\n\nvec2 computeTextureTransform(vec2 texCoord, mat3 textureTransform)\n{\n    return vec2(textureTransform * vec3(texCoord, 1.0));\n}\n\n#ifdef HAS_NORMALS\nvec3 computeNormal(ProcessedAttributes attributes)\n{\n    // Geometry normal. This is already normalized \n    vec3 ng = attributes.normalEC;\n\n    vec3 normal = ng;\n    #if defined(HAS_NORMAL_TEXTURE) && !defined(USE_WIREFRAME)\n    vec2 normalTexCoords = TEXCOORD_NORMAL;\n        #ifdef HAS_NORMAL_TEXTURE_TRANSFORM\n        normalTexCoords = computeTextureTransform(normalTexCoords, u_normalTextureTransform);\n        #endif\n\n        // If HAS_BITANGENTS is set, then HAS_TANGENTS is also set\n        #ifdef HAS_BITANGENTS\n        vec3 t = attributes.tangentEC;\n        vec3 b = attributes.bitangentEC;\n        mat3 tbn = mat3(t, b, ng);\n        vec3 n = texture2D(u_normalTexture, normalTexCoords).rgb;\n        normal = normalize(tbn * (2.0 * n - 1.0));\n        #elif defined(GL_OES_standard_derivatives)\n        // Compute tangents\n        vec3 positionEC = attributes.positionEC;\n        vec3 pos_dx = dFdx(positionEC);\n        vec3 pos_dy = dFdy(positionEC);\n        vec3 tex_dx = dFdx(vec3(normalTexCoords,0.0));\n        vec3 tex_dy = dFdy(vec3(normalTexCoords,0.0));\n        vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);\n        t = normalize(t - ng * dot(ng, t));\n        vec3 b = normalize(cross(ng, t));\n        mat3 tbn = mat3(t, b, ng);\n        vec3 n = texture2D(u_normalTexture, normalTexCoords).rgb;\n        normal = normalize(tbn * (2.0 * n - 1.0));\n        #endif\n    #endif\n\n    return normal;\n}\n#endif\n\nvoid materialStage(inout czm_modelMaterial material, ProcessedAttributes attributes, SelectedFeature feature)\n{\n\n    #ifdef HAS_NORMALS\n    material.normalEC = computeNormal(attributes);\n    #endif\n\n    vec4 baseColorWithAlpha = vec4(1.0);\n    // Regardless of whether we use PBR, set a base color\n    #ifdef HAS_BASE_COLOR_TEXTURE\n    vec2 baseColorTexCoords = TEXCOORD_BASE_COLOR;\n\n        #ifdef HAS_BASE_COLOR_TEXTURE_TRANSFORM\n        baseColorTexCoords = computeTextureTransform(baseColorTexCoords, u_baseColorTextureTransform);\n        #endif\n\n    baseColorWithAlpha = czm_srgbToLinear(texture2D(u_baseColorTexture, baseColorTexCoords));\n\n        #ifdef HAS_BASE_COLOR_FACTOR\n        baseColorWithAlpha *= u_baseColorFactor;\n        #endif\n    #elif defined(HAS_BASE_COLOR_FACTOR)\n    baseColorWithAlpha = u_baseColorFactor;\n    #endif\n\n    #ifdef HAS_COLOR_0\n    vec4 color = attributes.color_0;\n        // .pnts files store colors in the sRGB color space\n        #ifdef HAS_SRGB_COLOR\n        color = czm_srgbToLinear(color);\n        #endif\n    baseColorWithAlpha *= color;\n    #endif\n\n    material.diffuse = baseColorWithAlpha.rgb;\n    material.alpha = baseColorWithAlpha.a;\n\n    #ifdef USE_CPU_STYLING\n    material.diffuse = blend(material.diffuse, feature.color.rgb, model_colorBlend);\n    #endif\n\n    #ifdef HAS_OCCLUSION_TEXTURE\n    vec2 occlusionTexCoords = TEXCOORD_OCCLUSION;\n        #ifdef HAS_OCCLUSION_TEXTURE_TRANSFORM\n        occlusionTexCoords = computeTextureTransform(occlusionTexCoords, u_occlusionTextureTransform);\n        #endif\n    material.occlusion = texture2D(u_occlusionTexture, occlusionTexCoords).r;\n    #endif\n\n    #ifdef HAS_EMISSIVE_TEXTURE\n    vec2 emissiveTexCoords = TEXCOORD_EMISSIVE;\n        #ifdef HAS_EMISSIVE_TEXTURE_TRANSFORM\n        emissiveTexCoords = computeTextureTransform(emissiveTexCoords, u_emissiveTextureTransform);\n        #endif\n\n    vec3 emissive = czm_srgbToLinear(texture2D(u_emissiveTexture, emissiveTexCoords).rgb);\n        #ifdef HAS_EMISSIVE_FACTOR\n        emissive *= u_emissiveFactor;\n        #endif\n    material.emissive = emissive;\n    #elif defined(HAS_EMISSIVE_FACTOR)\n    material.emissive = u_emissiveFactor;\n    #endif\n\n    #if defined(LIGHTING_PBR) && defined(USE_SPECULAR_GLOSSINESS)\n        #ifdef HAS_SPECULAR_GLOSSINESS_TEXTURE\n        vec2 specularGlossinessTexCoords = TEXCOORD_SPECULAR_GLOSSINESS;\n          #ifdef HAS_SPECULAR_GLOSSINESS_TEXTURE_TRANSFORM\n          specularGlossinessTexCoords = computeTextureTransform(specularGlossinessTexCoords, u_specularGlossinessTextureTransform);\n          #endif\n\n        vec4 specularGlossiness = czm_srgbToLinear(texture2D(u_specularGlossinessTexture, specularGlossinessTexCoords));\n        vec3 specular = specularGlossiness.rgb;\n        float glossiness = specularGlossiness.a;\n            #ifdef HAS_SPECULAR_FACTOR\n            specular *= u_specularFactor;\n            #endif\n\n            #ifdef HAS_GLOSSINESS_FACTOR\n            glossiness *= u_glossinessFactor;\n            #endif\n        #else\n            #ifdef HAS_SPECULAR_FACTOR\n            vec3 specular = clamp(u_specularFactor, vec3(0.0), vec3(1.0));\n            #else\n            vec3 specular = vec3(1.0);\n            #endif\n\n            #ifdef HAS_GLOSSINESS_FACTOR\n            float glossiness = clamp(u_glossinessFactor, 0.0, 1.0);\n            #else\n            float glossiness = 1.0;\n            #endif\n        #endif\n\n        #ifdef HAS_DIFFUSE_TEXTURE\n        vec2 diffuseTexCoords = TEXCOORD_DIFFUSE;\n            #ifdef HAS_DIFFUSE_TEXTURE_TRANSFORM\n            diffuseTexCoords = computeTextureTransform(diffuseTexCoords, u_diffuseTextureTransform);\n            #endif\n\n        vec4 diffuse = czm_srgbToLinear(texture2D(u_diffuseTexture, diffuseTexCoords));\n            #ifdef HAS_DIFFUSE_FACTOR\n            diffuse *= u_diffuseFactor;\n            #endif\n        #elif defined(HAS_DIFFUSE_FACTOR)\n        vec4 diffuse = clamp(u_diffuseFactor, vec4(0.0), vec4(1.0));\n        #else\n        vec4 diffuse = vec4(1.0);\n        #endif\n    czm_pbrParameters parameters = czm_pbrSpecularGlossinessMaterial(\n      diffuse.rgb,\n      specular,\n      glossiness\n    );\n    material.diffuse = parameters.diffuseColor;\n    // the specular glossiness extension's alpha overrides anything set\n    // by the base material.\n    material.alpha = diffuse.a;\n    material.specular = parameters.f0;\n    material.roughness = parameters.roughness;\n    #elif defined(LIGHTING_PBR)\n        #ifdef HAS_METALLIC_ROUGHNESS_TEXTURE\n        vec2 metallicRoughnessTexCoords = TEXCOORD_METALLIC_ROUGHNESS;\n            #ifdef HAS_METALLIC_ROUGHNESS_TEXTURE_TRANSFORM\n            metallicRoughnessTexCoords = computeTextureTransform(metallicRoughnessTexCoords, u_metallicRoughnessTextureTransform);\n            #endif\n\n        vec3 metallicRoughness = texture2D(u_metallicRoughnessTexture, metallicRoughnessTexCoords).rgb;\n        float metalness = clamp(metallicRoughness.b, 0.0, 1.0);\n        float roughness = clamp(metallicRoughness.g, 0.04, 1.0);\n            #ifdef HAS_METALLIC_FACTOR\n            metalness *= u_metallicFactor;\n            #endif\n\n            #ifdef HAS_ROUGHNESS_FACTOR\n            roughness *= u_roughnessFactor;\n            #endif\n        #else\n            #ifdef HAS_METALLIC_FACTOR\n            float metalness = clamp(u_metallicFactor, 0.0, 1.0);\n            #else\n            float metalness = 1.0;\n            #endif\n\n            #ifdef HAS_ROUGHNESS_FACTOR\n            float roughness = clamp(u_roughnessFactor, 0.04, 1.0);\n            #else\n            float roughness = 1.0;\n            #endif\n        #endif\n    czm_pbrParameters parameters = czm_pbrMetallicRoughnessMaterial(\n      material.diffuse,\n      metalness,\n      roughness\n    );\n    material.diffuse = parameters.diffuseColor;\n    material.specular = parameters.f0;\n    material.roughness = parameters.roughness;\n    #endif\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/MaterialPipelineStage.js
var Material4 = ModelComponents_default.Material;
var MetallicRoughness3 = ModelComponents_default.MetallicRoughness;
var SpecularGlossiness3 = ModelComponents_default.SpecularGlossiness;
var MaterialPipelineStage = {};
MaterialPipelineStage.name = "MaterialPipelineStage";
MaterialPipelineStage.process = function(renderResources, primitive, frameState) {
  const material = primitive.material;
  const uniformMap2 = renderResources.uniformMap;
  const shaderBuilder = renderResources.shaderBuilder;
  const defaultTexture = frameState.context.defaultTexture;
  const defaultNormalTexture = frameState.context.defaultNormalTexture;
  const defaultEmissiveTexture = frameState.context.defaultEmissiveTexture;
  processMaterialUniforms(
    material,
    uniformMap2,
    shaderBuilder,
    defaultTexture,
    defaultNormalTexture,
    defaultEmissiveTexture
  );
  if (defined_default(material.specularGlossiness)) {
    processSpecularGlossinessUniforms(
      material,
      uniformMap2,
      shaderBuilder,
      defaultTexture
    );
  } else {
    processMetallicRoughnessUniforms(
      material,
      uniformMap2,
      shaderBuilder,
      defaultTexture
    );
  }
  const hasNormals = ModelExperimentalUtility.getAttributeBySemantic(
    primitive,
    VertexAttributeSemantic_default.NORMAL
  );
  const lightingOptions = renderResources.lightingOptions;
  if (material.unlit || !hasNormals) {
    lightingOptions.lightingModel = LightingModel_default.UNLIT;
  } else {
    lightingOptions.lightingModel = LightingModel_default.PBR;
  }
  const model = renderResources.model;
  const cull = model.backFaceCulling && !material.doubleSided;
  const translucent = defined_default(model.color) && model.color.alpha < 1;
  renderResources.renderStateOptions.cull = {
    enabled: cull && !translucent
  };
  const alphaOptions = renderResources.alphaOptions;
  if (!defined_default(alphaOptions.alphaMode)) {
    alphaOptions.alphaMode = material.alphaMode;
    if (material.alphaMode === AlphaMode_default.BLEND) {
      alphaOptions.pass = Pass_default.TRANSLUCENT;
    } else if (material.alphaMode === AlphaMode_default.MASK) {
      alphaOptions.alphaCutoff = material.alphaCutoff;
    }
  }
  shaderBuilder.addFragmentLines([MaterialStageFS_default]);
  if (model.debugWireframe) {
    shaderBuilder.addDefine(
      "USE_WIREFRAME",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
};
function processTextureTransform(shaderBuilder, uniformMap2, textureReader, uniformName, defineName) {
  const transformDefine = `HAS_${defineName}_TEXTURE_TRANSFORM`;
  shaderBuilder.addDefine(
    transformDefine,
    void 0,
    ShaderDestination_default.FRAGMENT
  );
  const transformUniformName = `${uniformName}Transform`;
  shaderBuilder.addUniform(
    "mat3",
    transformUniformName,
    ShaderDestination_default.FRAGMENT
  );
  uniformMap2[transformUniformName] = function() {
    return textureReader.transform;
  };
}
function processTexture2(shaderBuilder, uniformMap2, textureReader, uniformName, defineName, defaultTexture) {
  shaderBuilder.addUniform(
    "sampler2D",
    uniformName,
    ShaderDestination_default.FRAGMENT
  );
  uniformMap2[uniformName] = function() {
    return defaultValue_default(textureReader.texture, defaultTexture);
  };
  const textureDefine = `HAS_${defineName}_TEXTURE`;
  shaderBuilder.addDefine(textureDefine, void 0, ShaderDestination_default.FRAGMENT);
  const texCoordIndex = textureReader.texCoord;
  const texCoordVarying = `v_texCoord_${texCoordIndex}`;
  const texCoordDefine = `TEXCOORD_${defineName}`;
  shaderBuilder.addDefine(
    texCoordDefine,
    texCoordVarying,
    ShaderDestination_default.FRAGMENT
  );
  const textureTransform = textureReader.transform;
  if (defined_default(textureTransform) && !Matrix3_default.equals(textureTransform, Matrix3_default.IDENTITY)) {
    processTextureTransform(
      shaderBuilder,
      uniformMap2,
      textureReader,
      uniformName,
      defineName
    );
  }
}
function processMaterialUniforms(material, uniformMap2, shaderBuilder, defaultTexture, defaultNormalTexture, defaultEmissiveTexture) {
  const emissiveTexture = material.emissiveTexture;
  if (defined_default(emissiveTexture)) {
    processTexture2(
      shaderBuilder,
      uniformMap2,
      emissiveTexture,
      "u_emissiveTexture",
      "EMISSIVE",
      defaultEmissiveTexture
    );
  }
  const emissiveFactor = material.emissiveFactor;
  if (defined_default(emissiveFactor) && !Cartesian3_default.equals(emissiveFactor, Material4.DEFAULT_EMISSIVE_FACTOR)) {
    shaderBuilder.addUniform(
      "vec3",
      "u_emissiveFactor",
      ShaderDestination_default.FRAGMENT
    );
    uniformMap2.u_emissiveFactor = function() {
      return material.emissiveFactor;
    };
    shaderBuilder.addDefine(
      "HAS_EMISSIVE_FACTOR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  const normalTexture = material.normalTexture;
  if (defined_default(normalTexture)) {
    processTexture2(
      shaderBuilder,
      uniformMap2,
      normalTexture,
      "u_normalTexture",
      "NORMAL",
      defaultNormalTexture
    );
  }
  const occlusionTexture = material.occlusionTexture;
  if (defined_default(occlusionTexture)) {
    processTexture2(
      shaderBuilder,
      uniformMap2,
      occlusionTexture,
      "u_occlusionTexture",
      "OCCLUSION",
      defaultTexture
    );
  }
}
function processSpecularGlossinessUniforms(material, uniformMap2, shaderBuilder, defaultTexture) {
  const specularGlossiness = material.specularGlossiness;
  shaderBuilder.addDefine(
    "USE_SPECULAR_GLOSSINESS",
    void 0,
    ShaderDestination_default.FRAGMENT
  );
  const diffuseTexture = specularGlossiness.diffuseTexture;
  if (defined_default(diffuseTexture)) {
    processTexture2(
      shaderBuilder,
      uniformMap2,
      diffuseTexture,
      "u_diffuseTexture",
      "DIFFUSE",
      defaultTexture
    );
  }
  const diffuseFactor = specularGlossiness.diffuseFactor;
  if (defined_default(diffuseFactor) && !Cartesian4_default.equals(diffuseFactor, SpecularGlossiness3.DEFAULT_DIFFUSE_FACTOR)) {
    shaderBuilder.addUniform(
      "vec4",
      "u_diffuseFactor",
      ShaderDestination_default.FRAGMENT
    );
    uniformMap2.u_diffuseFactor = function() {
      return specularGlossiness.diffuseFactor;
    };
    shaderBuilder.addDefine(
      "HAS_DIFFUSE_FACTOR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  const specularGlossinessTexture = specularGlossiness.specularGlossinessTexture;
  if (defined_default(specularGlossinessTexture)) {
    processTexture2(
      shaderBuilder,
      uniformMap2,
      specularGlossinessTexture,
      "u_specularGlossinessTexture",
      "SPECULAR_GLOSSINESS",
      defaultTexture
    );
  }
  const specularFactor = specularGlossiness.specularFactor;
  if (defined_default(specularFactor) && !Cartesian3_default.equals(
    specularFactor,
    SpecularGlossiness3.DEFAULT_SPECULAR_FACTOR
  )) {
    shaderBuilder.addUniform(
      "vec3",
      "u_specularFactor",
      ShaderDestination_default.FRAGMENT
    );
    uniformMap2.u_specularFactor = function() {
      return specularGlossiness.specularFactor;
    };
    shaderBuilder.addDefine(
      "HAS_SPECULAR_FACTOR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  const glossinessFactor = specularGlossiness.glossinessFactor;
  if (defined_default(glossinessFactor) && glossinessFactor !== SpecularGlossiness3.DEFAULT_GLOSSINESS_FACTOR) {
    shaderBuilder.addUniform(
      "float",
      "u_glossinessFactor",
      ShaderDestination_default.FRAGMENT
    );
    uniformMap2.u_glossinessFactor = function() {
      return specularGlossiness.glossinessFactor;
    };
    shaderBuilder.addDefine(
      "HAS_GLOSSINESS_FACTOR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
}
function processMetallicRoughnessUniforms(material, uniformMap2, shaderBuilder, defaultTexture) {
  const metallicRoughness = material.metallicRoughness;
  shaderBuilder.addDefine(
    "USE_METALLIC_ROUGHNESS",
    void 0,
    ShaderDestination_default.FRAGMENT
  );
  const baseColorTexture = metallicRoughness.baseColorTexture;
  if (defined_default(baseColorTexture)) {
    processTexture2(
      shaderBuilder,
      uniformMap2,
      baseColorTexture,
      "u_baseColorTexture",
      "BASE_COLOR",
      defaultTexture
    );
  }
  const baseColorFactor = metallicRoughness.baseColorFactor;
  if (defined_default(baseColorFactor) && !Cartesian4_default.equals(
    baseColorFactor,
    MetallicRoughness3.DEFAULT_BASE_COLOR_FACTOR
  )) {
    shaderBuilder.addUniform(
      "vec4",
      "u_baseColorFactor",
      ShaderDestination_default.FRAGMENT
    );
    uniformMap2.u_baseColorFactor = function() {
      return metallicRoughness.baseColorFactor;
    };
    shaderBuilder.addDefine(
      "HAS_BASE_COLOR_FACTOR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  const metallicRoughnessTexture = metallicRoughness.metallicRoughnessTexture;
  if (defined_default(metallicRoughnessTexture)) {
    processTexture2(
      shaderBuilder,
      uniformMap2,
      metallicRoughnessTexture,
      "u_metallicRoughnessTexture",
      "METALLIC_ROUGHNESS",
      defaultTexture
    );
  }
  const metallicFactor = metallicRoughness.metallicFactor;
  if (defined_default(metallicFactor) && metallicFactor !== MetallicRoughness3.DEFAULT_METALLIC_FACTOR) {
    shaderBuilder.addUniform(
      "float",
      "u_metallicFactor",
      ShaderDestination_default.FRAGMENT
    );
    uniformMap2.u_metallicFactor = function() {
      return metallicRoughness.metallicFactor;
    };
    shaderBuilder.addDefine(
      "HAS_METALLIC_FACTOR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
  const roughnessFactor = metallicRoughness.roughnessFactor;
  if (defined_default(roughnessFactor) && roughnessFactor !== MetallicRoughness3.DEFAULT_ROUGHNESS_FACTOR) {
    shaderBuilder.addUniform(
      "float",
      "u_roughnessFactor",
      ShaderDestination_default.FRAGMENT
    );
    uniformMap2.u_roughnessFactor = function() {
      return metallicRoughness.roughnessFactor;
    };
    shaderBuilder.addDefine(
      "HAS_ROUGHNESS_FACTOR",
      void 0,
      ShaderDestination_default.FRAGMENT
    );
  }
}
MaterialPipelineStage._processTexture = processTexture2;
MaterialPipelineStage._processTextureTransform = processTextureTransform;
var MaterialPipelineStage_default = MaterialPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/MorphTargetsStageVS.js
var MorphTargetsStageVS_default = "void morphTargetsStage(inout ProcessedAttributes attributes) \n{\n    vec3 positionMC = attributes.positionMC;\n    attributes.positionMC = getMorphedPosition(positionMC);\n\n    #ifdef HAS_NORMALS\n    vec3 normalMC = attributes.normalMC;\n    attributes.normalMC = getMorphedNormal(normalMC);\n    #endif\n\n    #ifdef HAS_TANGENTS\n    vec3 tangentMC = attributes.tangentMC;\n    attributes.tangentMC = getMorphedTangent(tangentMC);\n    #endif\n}";

// node_modules/cesium/Source/Scene/ModelExperimental/MorphTargetsPipelineStage.js
var MorphTargetsPipelineStage = {};
MorphTargetsPipelineStage.name = "MorphTargetsPipelineStage";
MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_POSITION = "getMorphedPosition";
MorphTargetsPipelineStage.FUNCTION_SIGNATURE_GET_MORPHED_POSITION = "vec3 getMorphedPosition(in vec3 position)";
MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_NORMAL = "getMorphedNormal";
MorphTargetsPipelineStage.FUNCTION_SIGNATURE_GET_MORPHED_NORMAL = "vec3 getMorphedNormal(in vec3 normal)";
MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_TANGENT = "getMorphedTangent";
MorphTargetsPipelineStage.FUNCTION_SIGNATURE_GET_MORPHED_TANGENT = "vec3 getMorphedTangent(in vec3 tangent)";
MorphTargetsPipelineStage.process = function(renderResources, primitive) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addDefine(
    "HAS_MORPH_TARGETS",
    void 0,
    ShaderDestination_default.VERTEX
  );
  addGetMorphedAttributeFunctionDeclarations(shaderBuilder);
  for (let i2 = 0; i2 < primitive.morphTargets.length; i2++) {
    const morphTarget = primitive.morphTargets[i2];
    const attributes = morphTarget.attributes;
    for (let j = 0; j < attributes.length; j++) {
      const attribute = attributes[j];
      const semantic = attribute.semantic;
      if (semantic !== VertexAttributeSemantic_default.POSITION && semantic !== VertexAttributeSemantic_default.NORMAL && semantic !== VertexAttributeSemantic_default.TANGENT) {
        continue;
      }
      processMorphTargetAttribute(
        renderResources,
        attribute,
        renderResources.attributeIndex,
        i2
      );
      renderResources.attributeIndex++;
    }
  }
  addGetMorphedAttributeFunctionReturns(shaderBuilder);
  const weights2 = renderResources.runtimeNode.morphWeights;
  const weightsLength = weights2.length;
  shaderBuilder.addUniform(
    "float",
    `u_morphWeights[${weightsLength}]`,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addVertexLines([MorphTargetsStageVS_default]);
  const uniformMap2 = {
    u_morphWeights: function() {
      return renderResources.runtimeNode.morphWeights;
    }
  };
  renderResources.uniformMap = combine_default(uniformMap2, renderResources.uniformMap);
};
var scratchAttributeInfo = {
  attributeString: void 0,
  functionId: void 0
};
function processMorphTargetAttribute(renderResources, attribute, attributeIndex, morphTargetIndex) {
  const shaderBuilder = renderResources.shaderBuilder;
  addMorphTargetAttributeToRenderResources(
    renderResources,
    attribute,
    attributeIndex
  );
  const attributeInfo = getMorphTargetAttributeInfo(
    attribute,
    scratchAttributeInfo
  );
  addMorphTargetAttributeDeclarationAndFunctionLine(
    shaderBuilder,
    attributeInfo,
    morphTargetIndex
  );
}
function addMorphTargetAttributeToRenderResources(renderResources, attribute, attributeIndex) {
  const vertexAttribute = {
    index: attributeIndex,
    value: defined_default(attribute.buffer) ? void 0 : attribute.constant,
    vertexBuffer: attribute.buffer,
    componentsPerAttribute: AttributeType_default.getNumberOfComponents(attribute.type),
    componentDatatype: attribute.componentDatatype,
    offsetInBytes: attribute.byteOffset,
    strideInBytes: attribute.byteStride,
    normalize: attribute.normalized
  };
  renderResources.attributes.push(vertexAttribute);
}
function getMorphTargetAttributeInfo(attribute, result) {
  const semantic = attribute.semantic;
  switch (semantic) {
    case VertexAttributeSemantic_default.POSITION:
      result.attributeString = "Position";
      result.functionId = MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_POSITION;
      break;
    case VertexAttributeSemantic_default.NORMAL:
      result.attributeString = "Normal";
      result.functionId = MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_NORMAL;
      break;
    case VertexAttributeSemantic_default.TANGENT:
      result.attributeString = "Tangent";
      result.functionId = MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_TANGENT;
      break;
    default:
      break;
  }
  return result;
}
function addMorphTargetAttributeDeclarationAndFunctionLine(shaderBuilder, attributeInfo, morphTargetIndex) {
  const attributeString = attributeInfo.attributeString;
  const attributeName = `a_target${attributeString}_${morphTargetIndex}`;
  const line = `morphed${attributeString} += u_morphWeights[${morphTargetIndex}] * a_target${attributeString}_${morphTargetIndex};`;
  shaderBuilder.addAttribute("vec3", attributeName);
  shaderBuilder.addFunctionLines(attributeInfo.functionId, [line]);
}
function addGetMorphedAttributeFunctionDeclarations(shaderBuilder) {
  shaderBuilder.addFunction(
    MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_POSITION,
    MorphTargetsPipelineStage.FUNCTION_SIGNATURE_GET_MORPHED_POSITION,
    ShaderDestination_default.VERTEX
  );
  const positionLine = "vec3 morphedPosition = position;";
  shaderBuilder.addFunctionLines(
    MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_POSITION,
    [positionLine]
  );
  shaderBuilder.addFunction(
    MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_NORMAL,
    MorphTargetsPipelineStage.FUNCTION_SIGNATURE_GET_MORPHED_NORMAL,
    ShaderDestination_default.VERTEX
  );
  const normalLine = "vec3 morphedNormal = normal;";
  shaderBuilder.addFunctionLines(
    MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_NORMAL,
    [normalLine]
  );
  shaderBuilder.addFunction(
    MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_TANGENT,
    MorphTargetsPipelineStage.FUNCTION_SIGNATURE_GET_MORPHED_TANGENT,
    ShaderDestination_default.VERTEX
  );
  const tangentLine = "vec3 morphedTangent = tangent;";
  shaderBuilder.addFunctionLines(
    MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_TANGENT,
    [tangentLine]
  );
}
function addGetMorphedAttributeFunctionReturns(shaderBuilder) {
  const positionLine = "return morphedPosition;";
  shaderBuilder.addFunctionLines(
    MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_POSITION,
    [positionLine]
  );
  const normalLine = "return morphedNormal;";
  shaderBuilder.addFunctionLines(
    MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_NORMAL,
    [normalLine]
  );
  const tangentLine = "return morphedTangent;";
  shaderBuilder.addFunctionLines(
    MorphTargetsPipelineStage.FUNCTION_ID_GET_MORPHED_TANGENT,
    [tangentLine]
  );
}
var MorphTargetsPipelineStage_default = MorphTargetsPipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/PickingPipelineStage.js
var PickingPipelineStage = {};
PickingPipelineStage.name = "PickingPipelineStage";
PickingPipelineStage.process = function(renderResources, primitive, frameState) {
  const context = frameState.context;
  const runtimeNode = renderResources.runtimeNode;
  const shaderBuilder = renderResources.shaderBuilder;
  const model = renderResources.model;
  const instances = runtimeNode.node.instances;
  if (renderResources.hasPropertyTable) {
    processPickTexture(renderResources, primitive, instances, context);
  } else if (defined_default(instances)) {
    processInstancedPickIds(renderResources, instances, context);
  } else {
    const pickObject = buildPickObject(renderResources);
    const pickId = context.createPickId(pickObject);
    model._resources.push(pickId);
    shaderBuilder.addUniform(
      "vec4",
      "czm_pickColor",
      ShaderDestination_default.FRAGMENT
    );
    const uniformMap2 = renderResources.uniformMap;
    uniformMap2.czm_pickColor = function() {
      return pickId.color;
    };
    renderResources.pickId = "czm_pickColor";
  }
};
function buildPickObject(renderResources, instanceId) {
  const model = renderResources.model;
  const detailPickObject = {
    model,
    node: renderResources.runtimeNode,
    primitive: renderResources.runtimePrimitive
  };
  let pickObject;
  if (ModelExperimentalType_default.is3DTiles(model.type)) {
    const content = model.content;
    pickObject = {
      content,
      primitive: content.tileset,
      detail: detailPickObject
    };
  } else {
    pickObject = {
      primitive: model,
      detail: detailPickObject
    };
  }
  if (defined_default(instanceId)) {
    pickObject.instanceId = instanceId;
  }
  return pickObject;
}
function processPickTexture(renderResources, primitive, instances) {
  const model = renderResources.model;
  let featureTableId;
  let featureIdAttribute;
  const featureIdLabel = model.featureIdLabel;
  const instanceFeatureIdLabel = model.instanceFeatureIdLabel;
  if (defined_default(model.featureTableId)) {
    featureTableId = model.featureTableId;
  } else if (defined_default(instances)) {
    featureIdAttribute = ModelExperimentalUtility.getFeatureIdsByLabel(
      instances.featureIds,
      instanceFeatureIdLabel
    );
    featureTableId = featureIdAttribute.propertyTableId;
  } else {
    featureIdAttribute = ModelExperimentalUtility.getFeatureIdsByLabel(
      primitive.featureIds,
      featureIdLabel
    );
    featureTableId = featureIdAttribute.propertyTableId;
  }
  const featureTable = model.featureTables[featureTableId];
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addUniform(
    "sampler2D",
    "model_pickTexture",
    ShaderDestination_default.FRAGMENT
  );
  const batchTexture = featureTable.batchTexture;
  renderResources.uniformMap.model_pickTexture = function() {
    return defaultValue_default(batchTexture.pickTexture, batchTexture.defaultTexture);
  };
  renderResources.pickId = "((selectedFeature.id < int(model_featuresLength)) ? texture2D(model_pickTexture, selectedFeature.st) : vec4(0.0))";
}
function processInstancedPickIds(renderResources, instances, context) {
  const instanceCount = renderResources.instanceCount;
  const pickIds = new Array(instanceCount);
  const pickIdsTypedArray = new Uint8Array(instanceCount * 4);
  const model = renderResources.model;
  const modelResources = model._resources;
  for (let i2 = 0; i2 < instanceCount; i2++) {
    const pickObject = buildPickObject(renderResources, i2);
    const pickId = context.createPickId(pickObject);
    modelResources.push(pickId);
    pickIds[i2] = pickId;
    const pickColor = pickId.color;
    pickIdsTypedArray[i2 * 4 + 0] = Color_default.floatToByte(pickColor.red);
    pickIdsTypedArray[i2 * 4 + 1] = Color_default.floatToByte(pickColor.green);
    pickIdsTypedArray[i2 * 4 + 2] = Color_default.floatToByte(pickColor.blue);
    pickIdsTypedArray[i2 * 4 + 3] = Color_default.floatToByte(pickColor.alpha);
  }
  const pickIdsBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: pickIdsTypedArray,
    usage: BufferUsage_default.STATIC_DRAW
  });
  pickIdsBuffer.vertexArrayDestroyable = false;
  modelResources.push(pickIdsBuffer);
  const pickIdsVertexAttribute = {
    index: renderResources.attributeIndex++,
    vertexBuffer: pickIdsBuffer,
    componentsPerAttribute: 4,
    componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
    normalize: true,
    offsetInBytes: 0,
    strideInBytes: 0,
    instanceDivisor: 1
  };
  renderResources.attributes.push(pickIdsVertexAttribute);
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addDefine("USE_PICKING", void 0, ShaderDestination_default.BOTH);
  shaderBuilder.addAttribute("vec4", "a_pickColor");
  shaderBuilder.addVarying("vec4", "v_pickColor");
  renderResources.pickId = "v_pickColor";
}
var PickingPipelineStage_default = PickingPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/PointCloudAttenuationStageVS.js
var PointCloudAttenuationStageVS_default = "float pointCloudAttenuationStage(vec3 positionEC) {\n  // Variables are packed into a single vector to minimize gl.uniformXXX() calls\n  float pointSize = model_pointCloudAttenuation.x;\n  float geometricError = model_pointCloudAttenuation.y;\n  float depthMultiplier = model_pointCloudAttenuation.z;\n  float depth = -positionEC.z;\n  return min((geometricError / depth) * depthMultiplier, pointSize);\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/PointCloudAttenuationPipelineStage.js
var PointCloudAttenuationPipelineStage = {};
PointCloudAttenuationPipelineStage.name = "PointCloudAttenuationPipelineStage";
var scratchAttenuationUniform = new Cartesian3_default();
PointCloudAttenuationPipelineStage.process = function(renderResources, primitive, frameState) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addVertexLines([PointCloudAttenuationStageVS_default]);
  shaderBuilder.addDefine(
    "USE_POINT_CLOUD_ATTENUATION",
    void 0,
    ShaderDestination_default.VERTEX
  );
  const model = renderResources.model;
  const pointCloudShading = model.pointCloudShading;
  let content;
  let is3DTiles;
  let usesAddRefinement;
  if (ModelExperimentalType_default.is3DTiles(model.type)) {
    is3DTiles = true;
    content = model.content;
    usesAddRefinement = content.tile.refine === Cesium3DTileRefine_default.ADD;
  }
  shaderBuilder.addUniform(
    "vec3",
    "model_pointCloudAttenuation",
    ShaderDestination_default.VERTEX
  );
  renderResources.uniformMap.model_pointCloudAttenuation = function() {
    const scratch = scratchAttenuationUniform;
    let defaultPointSize = 1;
    if (is3DTiles) {
      defaultPointSize = usesAddRefinement ? 5 : content.tileset.maximumScreenSpaceError;
    }
    scratch.x = defaultValue_default(
      pointCloudShading.maximumAttenuation,
      defaultPointSize
    );
    scratch.x *= frameState.pixelRatio;
    const geometricError = getGeometricError3(
      renderResources,
      primitive,
      pointCloudShading,
      content
    );
    scratch.y = geometricError * pointCloudShading.geometricErrorScale;
    const context = frameState.context;
    const frustum = frameState.camera.frustum;
    let depthMultiplier;
    if (frameState.mode === SceneMode_default.SCENE2D || frustum instanceof OrthographicFrustum_default) {
      depthMultiplier = Number.POSITIVE_INFINITY;
    } else {
      depthMultiplier = context.drawingBufferHeight / frameState.camera.frustum.sseDenominator;
    }
    scratch.z = depthMultiplier;
    return scratch;
  };
};
var scratchDimensions = new Cartesian3_default();
function getGeometricError3(renderResources, primitive, pointCloudShading, content) {
  if (defined_default(content)) {
    const geometricError = content.tile.geometricError;
    if (geometricError > 0) {
      return geometricError;
    }
  }
  if (defined_default(pointCloudShading.baseResolution)) {
    return pointCloudShading.baseResolution;
  }
  const positionAttribute = ModelExperimentalUtility.getAttributeBySemantic(
    primitive,
    VertexAttributeSemantic_default.POSITION
  );
  const pointsLength = positionAttribute.count;
  const nodeTransform = renderResources.runtimeNode.transform;
  let dimensions = Cartesian3_default.subtract(
    positionAttribute.max,
    positionAttribute.min,
    scratchDimensions
  );
  dimensions = Matrix4_default.multiplyByPointAsVector(
    nodeTransform,
    dimensions,
    scratchDimensions
  );
  const volume = dimensions.x * dimensions.y * dimensions.z;
  const geometricErrorEstimate = Math_default.cbrt(volume / pointsLength);
  return geometricErrorEstimate;
}
var PointCloudAttenuationPipelineStage_default = PointCloudAttenuationPipelineStage;

// node_modules/cesium/Source/Shaders/ModelExperimental/SkinningStageVS.js
var SkinningStageVS_default = "void skinningStage(inout ProcessedAttributes attributes) \n{\n    mat4 skinningMatrix = getSkinningMatrix();\n    mat3 skinningMatrixMat3 = mat3(skinningMatrix);\n\n    vec4 positionMC = vec4(attributes.positionMC, 1.0);\n    attributes.positionMC = vec3(skinningMatrix * positionMC);\n\n    #ifdef HAS_NORMALS\n    vec3 normalMC = attributes.normalMC;\n    attributes.normalMC = skinningMatrixMat3 * normalMC;\n    #endif\n\n    #ifdef HAS_TANGENTS\n    vec3 tangentMC = attributes.tangentMC;\n    attributes.tangentMC = skinningMatrixMat3 * tangentMC;\n    #endif\n}";

// node_modules/cesium/Source/Scene/ModelExperimental/SkinningPipelineStage.js
var SkinningPipelineStage = {};
SkinningPipelineStage.name = "SkinningPipelineStage";
SkinningPipelineStage.FUNCTION_ID_GET_SKINNING_MATRIX = "getSkinningMatrix";
SkinningPipelineStage.FUNCTION_SIGNATURE_GET_SKINNING_MATRIX = "mat4 getSkinningMatrix()";
SkinningPipelineStage.process = function(renderResources, primitive) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addDefine("HAS_SKINNING", void 0, ShaderDestination_default.VERTEX);
  addGetSkinningMatrixFunction(shaderBuilder, primitive);
  const runtimeNode = renderResources.runtimeNode;
  const jointMatrices = runtimeNode.computedJointMatrices;
  shaderBuilder.addUniform(
    "mat4",
    `u_jointMatrices[${jointMatrices.length}]`,
    ShaderDestination_default.VERTEX
  );
  shaderBuilder.addVertexLines([SkinningStageVS_default]);
  const uniformMap2 = {
    u_jointMatrices: function() {
      return runtimeNode.computedJointMatrices;
    }
  };
  renderResources.uniformMap = combine_default(uniformMap2, renderResources.uniformMap);
};
function getMaximumAttributeSetIndex(primitive) {
  let setIndex = -1;
  const attributes = primitive.attributes;
  const length3 = attributes.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const attribute = attributes[i2];
    const isJointsOrWeights = attribute.semantic === VertexAttributeSemantic_default.JOINTS || attribute.semantic === VertexAttributeSemantic_default.WEIGHTS;
    if (!isJointsOrWeights) {
      continue;
    }
    setIndex = Math.max(setIndex, attribute.setIndex);
  }
  return setIndex;
}
function addGetSkinningMatrixFunction(shaderBuilder, primitive) {
  shaderBuilder.addFunction(
    SkinningPipelineStage.FUNCTION_ID_GET_SKINNING_MATRIX,
    SkinningPipelineStage.FUNCTION_SIGNATURE_GET_SKINNING_MATRIX,
    ShaderDestination_default.VERTEX
  );
  const initialLine = "mat4 skinnedMatrix = mat4(0);";
  shaderBuilder.addFunctionLines(
    SkinningPipelineStage.FUNCTION_ID_GET_SKINNING_MATRIX,
    [initialLine]
  );
  let setIndex;
  let componentIndex;
  const componentStrings = ["x", "y", "z", "w"];
  const maximumSetIndex = getMaximumAttributeSetIndex(primitive);
  for (setIndex = 0; setIndex <= maximumSetIndex; setIndex++) {
    for (componentIndex = 0; componentIndex <= 3; componentIndex++) {
      const component = componentStrings[componentIndex];
      const line = `skinnedMatrix += a_weights_${setIndex}.${component} * u_jointMatrices[int(a_joints_${setIndex}.${component})];`;
      shaderBuilder.addFunctionLines(
        SkinningPipelineStage.FUNCTION_ID_GET_SKINNING_MATRIX,
        [line]
      );
    }
  }
  const returnLine = "return skinnedMatrix;";
  shaderBuilder.addFunctionLines(
    SkinningPipelineStage.FUNCTION_ID_GET_SKINNING_MATRIX,
    [returnLine]
  );
}
var SkinningPipelineStage_default = SkinningPipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimentalPrimitive.js
function ModelExperimentalPrimitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const primitive = options.primitive;
  const node = options.node;
  const model = options.model;
  Check_default.typeOf.object("options.primitive", primitive);
  Check_default.typeOf.object("options.node", node);
  Check_default.typeOf.object("options.model", model);
  this.primitive = primitive;
  this.node = node;
  this.model = model;
  this.pipelineStages = [];
  this.drawCommands = [];
  this.boundingSphere = void 0;
  this.updateStages = [];
  this.configurePipeline();
}
ModelExperimentalPrimitive.prototype.configurePipeline = function() {
  const pipelineStages = this.pipelineStages;
  pipelineStages.length = 0;
  const primitive = this.primitive;
  const node = this.node;
  const model = this.model;
  const customShader = model.customShader;
  const hasMorphTargets = defined_default(primitive.morphTargets) && primitive.morphTargets.length > 0;
  const hasSkinning = defined_default(node.skin);
  const hasCustomShader = defined_default(customShader);
  const hasCustomFragmentShader = hasCustomShader && defined_default(customShader.fragmentShaderText);
  const materialsEnabled = !hasCustomFragmentShader || customShader.mode !== CustomShaderMode_default.REPLACE_MATERIAL;
  const hasQuantization = ModelExperimentalUtility.hasQuantizedAttributes(
    primitive.attributes
  );
  const pointCloudShading = model.pointCloudShading;
  const hasAttenuation = defined_default(pointCloudShading) && pointCloudShading.attenuation;
  const featureIdFlags = inspectFeatureIds(model, node, primitive);
  pipelineStages.push(GeometryPipelineStage_default);
  if (hasMorphTargets) {
    pipelineStages.push(MorphTargetsPipelineStage_default);
  }
  if (hasSkinning) {
    pipelineStages.push(SkinningPipelineStage_default);
  }
  if (hasAttenuation && primitive.primitiveType === PrimitiveType_default.POINTS) {
    pipelineStages.push(PointCloudAttenuationPipelineStage_default);
  }
  if (hasQuantization) {
    pipelineStages.push(DequantizationPipelineStage_default);
  }
  if (materialsEnabled) {
    pipelineStages.push(MaterialPipelineStage_default);
  }
  pipelineStages.push(FeatureIdPipelineStage_default);
  pipelineStages.push(MetadataPipelineStage_default);
  if (featureIdFlags.hasPropertyTable) {
    pipelineStages.push(SelectedFeatureIdPipelineStage_default);
    pipelineStages.push(BatchTexturePipelineStage_default);
    pipelineStages.push(CPUStylingPipelineStage_default);
  }
  if (hasCustomShader) {
    pipelineStages.push(CustomShaderPipelineStage_default);
  }
  pipelineStages.push(LightingPipelineStage_default);
  if (model.allowPicking) {
    pipelineStages.push(PickingPipelineStage_default);
  }
  pipelineStages.push(AlphaPipelineStage_default);
  return;
};
function inspectFeatureIds(model, node, primitive) {
  let featureIds;
  if (defined_default(node.instances)) {
    featureIds = ModelExperimentalUtility.getFeatureIdsByLabel(
      node.instances.featureIds,
      model.instanceFeatureIdLabel
    );
    if (defined_default(featureIds)) {
      return {
        hasFeatureIds: true,
        hasPropertyTable: defined_default(featureIds.propertyTableId)
      };
    }
  }
  featureIds = ModelExperimentalUtility.getFeatureIdsByLabel(
    primitive.featureIds,
    model.featureIdLabel
  );
  if (defined_default(featureIds)) {
    return {
      hasFeatureIds: true,
      hasPropertyTable: defined_default(featureIds.propertyTableId)
    };
  }
  return {
    hasFeatureIds: false,
    hasPropertyTable: false
  };
}

// node_modules/cesium/Source/Shaders/ModelExperimental/InstancingStageCommon.js
var InstancingStageCommon_default = "mat4 getInstancingTransform()\n{\n    mat4 instancingTransform;\n\n    #ifdef HAS_INSTANCE_MATRICES\n    instancingTransform = mat4(\n        a_instancingTransformRow0.x, a_instancingTransformRow1.x, a_instancingTransformRow2.x, 0.0, // Column 1\n        a_instancingTransformRow0.y, a_instancingTransformRow1.y, a_instancingTransformRow2.y, 0.0, // Column 2\n        a_instancingTransformRow0.z, a_instancingTransformRow1.z, a_instancingTransformRow2.z, 0.0, // Column 3\n        a_instancingTransformRow0.w, a_instancingTransformRow1.w, a_instancingTransformRow2.w, 1.0  // Column 4\n    );\n    #else\n    vec3 translation = vec3(0.0, 0.0, 0.0);\n    vec3 scale = vec3(1.0, 1.0, 1.0);\n    \n        #ifdef HAS_INSTANCE_TRANSLATION\n        translation = a_instanceTranslation;\n        #endif\n        #ifdef HAS_INSTANCE_SCALE\n        scale = a_instanceScale;\n        #endif\n\n    instancingTransform = mat4(\n        scale.x, 0.0, 0.0, 0.0,\n        0.0, scale.y, 0.0, 0.0,\n        0.0, 0.0, scale.z, 0.0,\n        translation.x, translation.y, translation.z, 1.0\n    ); \n    #endif\n\n    return instancingTransform;\n}\n";

// node_modules/cesium/Source/Shaders/ModelExperimental/InstancingStageVS.js
var InstancingStageVS_default = "void instancingStage(inout vec3 positionMC) \n{\n    mat4 instancingTransform = getInstancingTransform();\n\n    positionMC = (instancingTransform * vec4(positionMC, 1.0)).xyz;\n}\n";

// node_modules/cesium/Source/Shaders/ModelExperimental/LegacyInstancingStageVS.js
var LegacyInstancingStageVS_default = "void legacyInstancingStage(inout vec3 positionMC, out mat4 instanceModelView, out mat3 instanceModelViewInverseTranspose)\n{\n    mat4 instancingTransform = getInstancingTransform();\n\n    mat4 instanceModel = instancingTransform * u_instance_nodeTransform;\n    instanceModelView = u_instance_modifiedModelView;\n    instanceModelViewInverseTranspose = mat3(u_instance_modifiedModelView * instanceModel);\n\n    positionMC = (instanceModel * vec4(positionMC, 1.0)).xyz;\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/InstancingPipelineStage.js
var modelViewScratch = new Matrix4_default();
var nodeTransformScratch = new Matrix4_default();
var InstancingPipelineStage = {};
InstancingPipelineStage.name = "InstancingPipelineStage";
InstancingPipelineStage.process = function(renderResources, node, frameState) {
  const instances = node.instances;
  const count = instances.attributes[0].count;
  let instancingVertexAttributes = [];
  const sceneGraph = renderResources.model.sceneGraph;
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addDefine("HAS_INSTANCING");
  shaderBuilder.addVertexLines([InstancingStageCommon_default]);
  const translationAttribute = ModelExperimentalUtility.getAttributeBySemantic(
    instances,
    InstanceAttributeSemantic_default.TRANSLATION
  );
  let translationMax;
  let translationMin;
  if (defined_default(translationAttribute)) {
    translationMax = translationAttribute.max;
    translationMin = translationAttribute.min;
  }
  const rotationAttribute = ModelExperimentalUtility.getAttributeBySemantic(
    instances,
    InstanceAttributeSemantic_default.ROTATION
  );
  if (defined_default(rotationAttribute) || !defined_default(translationMax) || !defined_default(translationMin)) {
    instancingVertexAttributes = processMatrixAttributes(
      node,
      count,
      renderResources,
      frameState
    );
  } else {
    if (defined_default(translationAttribute)) {
      instancingVertexAttributes.push({
        index: renderResources.attributeIndex++,
        vertexBuffer: translationAttribute.buffer,
        componentsPerAttribute: AttributeType_default.getNumberOfComponents(
          translationAttribute.type
        ),
        componentDatatype: translationAttribute.componentDatatype,
        normalize: false,
        offsetInBytes: translationAttribute.byteOffset,
        strideInBytes: translationAttribute.byteStride,
        instanceDivisor: 1
      });
      renderResources.instancingTranslationMax = translationMax;
      renderResources.instancingTranslationMin = translationMin;
      shaderBuilder.addDefine("HAS_INSTANCE_TRANSLATION");
      shaderBuilder.addAttribute("vec3", "a_instanceTranslation");
    }
    const scaleAttribute = ModelExperimentalUtility.getAttributeBySemantic(
      instances,
      InstanceAttributeSemantic_default.SCALE
    );
    if (defined_default(scaleAttribute)) {
      instancingVertexAttributes.push({
        index: renderResources.attributeIndex++,
        vertexBuffer: scaleAttribute.buffer,
        componentsPerAttribute: AttributeType_default.getNumberOfComponents(
          scaleAttribute.type
        ),
        componentDatatype: scaleAttribute.componentDatatype,
        normalize: false,
        offsetInBytes: scaleAttribute.byteOffset,
        strideInBytes: scaleAttribute.byteStride,
        instanceDivisor: 1
      });
      shaderBuilder.addDefine("HAS_INSTANCE_SCALE");
      shaderBuilder.addAttribute("vec3", "a_instanceScale");
    }
  }
  processFeatureIdAttributes(
    renderResources,
    frameState,
    instances,
    instancingVertexAttributes
  );
  if (instances.transformInWorldSpace) {
    const uniformMap2 = renderResources.uniformMap;
    shaderBuilder.addDefine(
      "USE_LEGACY_INSTANCING",
      void 0,
      ShaderDestination_default.VERTEX
    );
    shaderBuilder.addUniform(
      "mat4",
      "u_instance_modifiedModelView",
      ShaderDestination_default.VERTEX
    );
    shaderBuilder.addUniform(
      "mat4",
      "u_instance_nodeTransform",
      ShaderDestination_default.VERTEX
    );
    uniformMap2.u_instance_modifiedModelView = function() {
      const modifiedModelMatrix = Matrix4_default.multiplyTransformation(
        renderResources.model.modelMatrix,
        sceneGraph.components.transform,
        modelViewScratch
      );
      return Matrix4_default.multiplyTransformation(
        frameState.context.uniformState.view,
        modifiedModelMatrix,
        modelViewScratch
      );
    };
    uniformMap2.u_instance_nodeTransform = function() {
      return Matrix4_default.multiplyTransformation(
        sceneGraph.axisCorrectionMatrix,
        renderResources.runtimeNode.computedTransform,
        nodeTransformScratch
      );
    };
    shaderBuilder.addVertexLines([LegacyInstancingStageVS_default]);
  } else {
    shaderBuilder.addVertexLines([InstancingStageVS_default]);
  }
  renderResources.instanceCount = count;
  renderResources.attributes.push.apply(
    renderResources.attributes,
    instancingVertexAttributes
  );
};
var translationScratch = new Cartesian3_default();
var rotationScratch = new Quaternion_default();
var scaleScratch = new Cartesian3_default();
var transformScratch = new Matrix4_default();
function getInstanceTransformsTypedArray(instances, count, renderResources) {
  const elements = 12;
  const transformsTypedArray = new Float32Array(count * elements);
  const translationAttribute = ModelExperimentalUtility.getAttributeBySemantic(
    instances,
    InstanceAttributeSemantic_default.TRANSLATION
  );
  const rotationAttribute = ModelExperimentalUtility.getAttributeBySemantic(
    instances,
    InstanceAttributeSemantic_default.ROTATION
  );
  const scaleAttribute = ModelExperimentalUtility.getAttributeBySemantic(
    instances,
    InstanceAttributeSemantic_default.SCALE
  );
  const instancingTranslationMax = new Cartesian3_default(
    -Number.MAX_VALUE,
    -Number.MAX_VALUE,
    -Number.MAX_VALUE
  );
  const instancingTranslationMin = new Cartesian3_default(
    Number.MAX_VALUE,
    Number.MAX_VALUE,
    Number.MAX_VALUE
  );
  const hasTranslation = defined_default(translationAttribute);
  const hasRotation = defined_default(rotationAttribute);
  const hasScale = defined_default(scaleAttribute);
  const translationTypedArray = hasTranslation ? translationAttribute.packedTypedArray : new Float32Array(count * 3);
  const rotationTypedArray = hasRotation ? rotationAttribute.packedTypedArray : new Float32Array(count * 4);
  let scaleTypedArray;
  if (hasScale) {
    scaleTypedArray = scaleAttribute.packedTypedArray;
  } else {
    scaleTypedArray = new Float32Array(count * 3);
    scaleTypedArray.fill(1);
  }
  for (let i2 = 0; i2 < count; i2++) {
    const translation3 = new Cartesian3_default(
      translationTypedArray[i2 * 3],
      translationTypedArray[i2 * 3 + 1],
      translationTypedArray[i2 * 3 + 2],
      translationScratch
    );
    Cartesian3_default.maximumByComponent(
      instancingTranslationMax,
      translation3,
      instancingTranslationMax
    );
    Cartesian3_default.minimumByComponent(
      instancingTranslationMin,
      translation3,
      instancingTranslationMin
    );
    const rotation = new Quaternion_default(
      rotationTypedArray[i2 * 4],
      rotationTypedArray[i2 * 4 + 1],
      rotationTypedArray[i2 * 4 + 2],
      hasRotation ? rotationTypedArray[i2 * 4 + 3] : 1,
      rotationScratch
    );
    const scale = new Cartesian3_default(
      scaleTypedArray[i2 * 3],
      scaleTypedArray[i2 * 3 + 1],
      scaleTypedArray[i2 * 3 + 2],
      scaleScratch
    );
    const transform4 = Matrix4_default.fromTranslationQuaternionRotationScale(
      translation3,
      rotation,
      scale,
      transformScratch
    );
    const offset2 = elements * i2;
    transformsTypedArray[offset2 + 0] = transform4[0];
    transformsTypedArray[offset2 + 1] = transform4[4];
    transformsTypedArray[offset2 + 2] = transform4[8];
    transformsTypedArray[offset2 + 3] = transform4[12];
    transformsTypedArray[offset2 + 4] = transform4[1];
    transformsTypedArray[offset2 + 5] = transform4[5];
    transformsTypedArray[offset2 + 6] = transform4[9];
    transformsTypedArray[offset2 + 7] = transform4[13];
    transformsTypedArray[offset2 + 8] = transform4[2];
    transformsTypedArray[offset2 + 9] = transform4[6];
    transformsTypedArray[offset2 + 10] = transform4[10];
    transformsTypedArray[offset2 + 11] = transform4[14];
    renderResources.instancingTranslationMax = instancingTranslationMax;
    renderResources.instancingTranslationMin = instancingTranslationMin;
  }
  return transformsTypedArray;
}
function processFeatureIdAttributes(renderResources, frameState, instances, instancingVertexAttributes) {
  const attributes = instances.attributes;
  const model = renderResources.model;
  const shaderBuilder = renderResources.shaderBuilder;
  for (let i2 = 0; i2 < attributes.length; i2++) {
    const attribute = attributes[i2];
    if (attribute.semantic !== InstanceAttributeSemantic_default.FEATURE_ID) {
      continue;
    }
    if (attribute.setIndex >= renderResources.featureIdVertexAttributeSetIndex) {
      renderResources.featureIdVertexAttributeSetIndex = attribute.setIndex + 1;
    }
    const vertexBuffer = Buffer_default.createVertexBuffer({
      context: frameState.context,
      typedArray: attribute.packedTypedArray,
      usage: BufferUsage_default.STATIC_DRAW
    });
    vertexBuffer.vertexArrayDestroyable = false;
    model._resources.push(vertexBuffer);
    instancingVertexAttributes.push({
      index: renderResources.attributeIndex++,
      vertexBuffer,
      componentsPerAttribute: AttributeType_default.getNumberOfComponents(
        attribute.type
      ),
      componentDatatype: attribute.componentDatatype,
      normalize: false,
      offsetInBytes: attribute.byteOffset,
      strideInBytes: attribute.byteStride,
      instanceDivisor: 1
    });
    shaderBuilder.addAttribute(
      "float",
      `a_instanceFeatureId_${attribute.setIndex}`
    );
  }
}
function processMatrixAttributes(node, count, renderResources, frameState) {
  const transformsTypedArray = getInstanceTransformsTypedArray(
    node.instances,
    count,
    renderResources
  );
  const transformsVertexBuffer = Buffer_default.createVertexBuffer({
    context: frameState.context,
    typedArray: transformsTypedArray,
    usage: BufferUsage_default.STATIC_DRAW
  });
  transformsVertexBuffer.vertexArrayDestroyable = false;
  renderResources.model._resources.push(transformsVertexBuffer);
  const vertexSizeInFloats = 12;
  const componentByteSize = ComponentDatatype_default.getSizeInBytes(
    ComponentDatatype_default.FLOAT
  );
  const strideInBytes = componentByteSize * vertexSizeInFloats;
  const instancingVertexAttributes = [
    {
      index: renderResources.attributeIndex++,
      vertexBuffer: transformsVertexBuffer,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      normalize: false,
      offsetInBytes: 0,
      strideInBytes,
      instanceDivisor: 1
    },
    {
      index: renderResources.attributeIndex++,
      vertexBuffer: transformsVertexBuffer,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      normalize: false,
      offsetInBytes: componentByteSize * 4,
      strideInBytes,
      instanceDivisor: 1
    },
    {
      index: renderResources.attributeIndex++,
      vertexBuffer: transformsVertexBuffer,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      normalize: false,
      offsetInBytes: componentByteSize * 8,
      strideInBytes,
      instanceDivisor: 1
    }
  ];
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addDefine("HAS_INSTANCE_MATRICES");
  shaderBuilder.addAttribute("vec4", "a_instancingTransformRow0");
  shaderBuilder.addAttribute("vec4", "a_instancingTransformRow1");
  shaderBuilder.addAttribute("vec4", "a_instancingTransformRow2");
  return instancingVertexAttributes;
}
InstancingPipelineStage._getInstanceTransformsTypedArray = getInstanceTransformsTypedArray;
var InstancingPipelineStage_default = InstancingPipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/ModelMatrixUpdateStage.js
var ModelMatrixUpdateStage = {};
ModelMatrixUpdateStage.name = "ModelMatrixUpdateStage";
ModelMatrixUpdateStage.update = function(runtimeNode, sceneGraph, frameState) {
  if (runtimeNode._transformDirty) {
    updateRuntimeNode(runtimeNode, sceneGraph, runtimeNode.transformToRoot);
    runtimeNode._transformDirty = false;
  }
};
function updateRuntimeNode(runtimeNode, sceneGraph, transformToRoot) {
  let i2, j;
  transformToRoot = Matrix4_default.multiplyTransformation(
    transformToRoot,
    runtimeNode.transform,
    new Matrix4_default()
  );
  runtimeNode.updateComputedTransform();
  const primitivesLength = runtimeNode.runtimePrimitives.length;
  for (i2 = 0; i2 < primitivesLength; i2++) {
    const runtimePrimitive = runtimeNode.runtimePrimitives[i2];
    const drawCommandsLength = runtimePrimitive.drawCommands.length;
    for (j = 0; j < drawCommandsLength; j++) {
      const drawCommand = runtimePrimitive.drawCommands[j];
      drawCommand.modelMatrix = Matrix4_default.multiplyTransformation(
        sceneGraph._computedModelMatrix,
        transformToRoot,
        drawCommand.modelMatrix
      );
      drawCommand.boundingVolume = BoundingSphere_default.transform(
        runtimePrimitive.boundingSphere,
        drawCommand.modelMatrix,
        drawCommand.boundingVolume
      );
    }
  }
  const childrenLength = runtimeNode.children.length;
  for (i2 = 0; i2 < childrenLength; i2++) {
    const childRuntimeNode = sceneGraph._runtimeNodes[runtimeNode.children[i2]];
    childRuntimeNode._transformToRoot = Matrix4_default.clone(
      transformToRoot,
      childRuntimeNode._transformToRoot
    );
    updateRuntimeNode(childRuntimeNode, sceneGraph, transformToRoot);
    childRuntimeNode._transformDirty = false;
  }
}
var ModelMatrixUpdateStage_default = ModelMatrixUpdateStage;

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimentalNode.js
function ModelExperimentalNode(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.node", options.node);
  Check_default.typeOf.object("options.transform", options.transform);
  Check_default.typeOf.object("options.transformToRoot", options.transformToRoot);
  Check_default.typeOf.object("options.sceneGraph", options.sceneGraph);
  Check_default.typeOf.object("options.children", options.children);
  const sceneGraph = options.sceneGraph;
  const transform4 = options.transform;
  const transformToRoot = options.transformToRoot;
  const node = options.node;
  this._sceneGraph = sceneGraph;
  this._children = options.children;
  this._node = node;
  this._name = node.name;
  this._originalTransform = Matrix4_default.clone(transform4, this._originalTransform);
  this._transform = Matrix4_default.clone(transform4, this._transform);
  this._transformToRoot = Matrix4_default.clone(transformToRoot, this._transformToRoot);
  this._originalTransform = Matrix4_default.clone(transform4, this._originalTransform);
  const computedTransform = Matrix4_default.multiply(
    transformToRoot,
    transform4,
    new Matrix4_default()
  );
  this._computedTransform = computedTransform;
  this._transformDirty = false;
  this._transformParameters = defined_default(node.matrix) ? void 0 : new TranslationRotationScale_default(node.translation, node.rotation, node.scale);
  this._morphWeights = defined_default(node.morphWeights) ? node.morphWeights.slice() : [];
  this._runtimeSkin = void 0;
  this._computedJointMatrices = [];
  this.pipelineStages = [];
  this.runtimePrimitives = [];
  this.updateStages = [];
  this.configurePipeline();
}
Object.defineProperties(ModelExperimentalNode.prototype, {
  node: {
    get: function() {
      return this._node;
    }
  },
  sceneGraph: {
    get: function() {
      return this._sceneGraph;
    }
  },
  children: {
    get: function() {
      return this._children;
    }
  },
  transform: {
    get: function() {
      return this._transform;
    },
    set: function(value) {
      if (Matrix4_default.equals(this._transform, value)) {
        return;
      }
      this._transformDirty = true;
      this._transform = Matrix4_default.clone(value, this._transform);
    }
  },
  transformToRoot: {
    get: function() {
      return this._transformToRoot;
    }
  },
  computedTransform: {
    get: function() {
      return this._computedTransform;
    }
  },
  originalTransform: {
    get: function() {
      return this._originalTransform;
    }
  },
  translation: {
    get: function() {
      return defined_default(this._transformParameters) ? this._transformParameters.translation : void 0;
    },
    set: function(value) {
      const transformParameters = this._transformParameters;
      if (!defined_default(transformParameters)) {
        throw new DeveloperError_default(
          "The translation of a node cannot be set if it was defined using a matrix in the model."
        );
      }
      const currentTranslation = transformParameters.translation;
      if (Cartesian3_default.equals(currentTranslation, value)) {
        return;
      }
      transformParameters.translation = Cartesian3_default.clone(
        value,
        transformParameters.translation
      );
      updateTransformFromParameters(this, transformParameters);
    }
  },
  rotation: {
    get: function() {
      return defined_default(this._transformParameters) ? this._transformParameters.rotation : void 0;
    },
    set: function(value) {
      const transformParameters = this._transformParameters;
      if (!defined_default(transformParameters)) {
        throw new DeveloperError_default(
          "The rotation of a node cannot be set if it was defined using a matrix in the model."
        );
      }
      const currentRotation = transformParameters.rotation;
      if (Quaternion_default.equals(currentRotation, value)) {
        return;
      }
      transformParameters.rotation = Quaternion_default.clone(
        value,
        transformParameters.rotation
      );
      updateTransformFromParameters(this, transformParameters);
    }
  },
  scale: {
    get: function() {
      return defined_default(this._transformParameters) ? this._transformParameters.scale : void 0;
    },
    set: function(value) {
      const transformParameters = this._transformParameters;
      if (!defined_default(transformParameters)) {
        throw new DeveloperError_default(
          "The scale of a node cannot be set if it was defined using a matrix in the model."
        );
      }
      const currentScale = transformParameters.scale;
      if (Cartesian3_default.equals(currentScale, value)) {
        return;
      }
      transformParameters.scale = Cartesian3_default.clone(
        value,
        transformParameters.scale
      );
      updateTransformFromParameters(this, transformParameters);
    }
  },
  morphWeights: {
    get: function() {
      return this._morphWeights;
    },
    set: function(value) {
      const valueLength = value.length;
      if (this._morphWeights.length !== valueLength) {
        throw new DeveloperError_default(
          "value must have the same length as the original weights array."
        );
      }
      for (let i2 = 0; i2 < valueLength; i2++) {
        this._morphWeights[i2] = value[i2];
      }
    }
  },
  runtimeSkin: {
    get: function() {
      return this._runtimeSkin;
    }
  },
  computedJointMatrices: {
    get: function() {
      return this._computedJointMatrices;
    }
  }
});
function updateTransformFromParameters(runtimeNode, transformParameters) {
  runtimeNode._transformDirty = true;
  runtimeNode._transform = Matrix4_default.fromTranslationRotationScale(
    transformParameters,
    runtimeNode._transform
  );
}
ModelExperimentalNode.prototype.getChild = function(index2) {
  Check_default.typeOf.number("index", index2);
  if (index2 < 0 || index2 >= this.children.length) {
    throw new DeveloperError_default(
      "index must be greater than or equal to 0 and less than the number of children."
    );
  }
  return this.sceneGraph.runtimeNodes[this.children[index2]];
};
ModelExperimentalNode.prototype.configurePipeline = function() {
  const node = this.node;
  const pipelineStages = this.pipelineStages;
  pipelineStages.length = 0;
  const updateStages = this.updateStages;
  updateStages.length = 0;
  if (defined_default(node.instances)) {
    pipelineStages.push(InstancingPipelineStage_default);
  }
  updateStages.push(ModelMatrixUpdateStage_default);
};
ModelExperimentalNode.prototype.updateComputedTransform = function() {
  this._computedTransform = Matrix4_default.multiply(
    this._transformToRoot,
    this._transform,
    this._computedTransform
  );
};
ModelExperimentalNode.prototype.updateJointMatrices = function() {
  const runtimeSkin = this._runtimeSkin;
  if (!defined_default(runtimeSkin)) {
    return;
  }
  runtimeSkin.updateJointMatrices();
  const computedJointMatrices = this._computedJointMatrices;
  const skinJointMatrices = runtimeSkin.jointMatrices;
  const length3 = skinJointMatrices.length;
  for (let i2 = 0; i2 < length3; i2++) {
    if (!defined_default(computedJointMatrices[i2])) {
      computedJointMatrices[i2] = new Matrix4_default();
    }
    const nodeWorldTransform = Matrix4_default.multiplyTransformation(
      this.transformToRoot,
      this.transform,
      computedJointMatrices[i2]
    );
    const inverseNodeWorldTransform = Matrix4_default.inverseTransformation(
      nodeWorldTransform,
      computedJointMatrices[i2]
    );
    computedJointMatrices[i2] = Matrix4_default.multiplyTransformation(
      inverseNodeWorldTransform,
      skinJointMatrices[i2],
      computedJointMatrices[i2]
    );
  }
};

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimentalSkin.js
function ModelExperimentalSkin(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.skin", options.skin);
  Check_default.typeOf.object("options.sceneGraph", options.sceneGraph);
  this._sceneGraph = options.sceneGraph;
  const skin = options.skin;
  this._skin = skin;
  this._inverseBindMatrices = void 0;
  this._joints = [];
  this._jointMatrices = [];
  initialize15(this);
}
Object.defineProperties(ModelExperimentalSkin.prototype, {
  skin: {
    get: function() {
      return this._skin;
    }
  },
  sceneGraph: {
    get: function() {
      return this._sceneGraph;
    }
  },
  inverseBindMatrices: {
    get: function() {
      return this._inverseBindMatrices;
    }
  },
  joints: {
    get: function() {
      return this._joints;
    }
  },
  jointMatrices: {
    get: function() {
      return this._jointMatrices;
    }
  }
});
function initialize15(runtimeSkin) {
  const skin = runtimeSkin.skin;
  const inverseBindMatrices = skin.inverseBindMatrices;
  runtimeSkin._inverseBindMatrices = inverseBindMatrices;
  const joints = skin.joints;
  const length3 = joints.length;
  const runtimeNodes = runtimeSkin.sceneGraph._runtimeNodes;
  const runtimeJoints = runtimeSkin.joints;
  const runtimeJointMatrices = runtimeSkin._jointMatrices;
  for (let i2 = 0; i2 < length3; i2++) {
    const jointIndex = joints[i2].index;
    const runtimeNode = runtimeNodes[jointIndex];
    runtimeJoints.push(runtimeNode);
    const inverseBindMatrix = inverseBindMatrices[i2];
    const jointMatrix = computeJointMatrix(
      runtimeNode,
      inverseBindMatrix,
      new Matrix4_default()
    );
    runtimeJointMatrices.push(jointMatrix);
  }
}
function computeJointMatrix(joint, inverseBindMatrix, result) {
  const jointWorldTransform = Matrix4_default.multiplyTransformation(
    joint.transformToRoot,
    joint.transform,
    result
  );
  result = Matrix4_default.multiplyTransformation(
    jointWorldTransform,
    inverseBindMatrix,
    result
  );
  return result;
}
ModelExperimentalSkin.prototype.updateJointMatrices = function() {
  const jointMatrices = this._jointMatrices;
  const length3 = jointMatrices.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const joint = this.joints[i2];
    const inverseBindMatrix = this.inverseBindMatrices[i2];
    jointMatrices[i2] = computeJointMatrix(
      joint,
      inverseBindMatrix,
      jointMatrices[i2]
    );
  }
};

// node_modules/cesium/Source/Scene/ModelExperimental/ModelAlphaOptions.js
function ModelAlphaOptions() {
  this.pass = void 0;
  this.alphaMode = void 0;
  this.alphaCutoff = void 0;
}

// node_modules/cesium/Source/Renderer/ShaderStruct.js
function ShaderStruct(name) {
  this.name = name;
  this.fields = [];
}
ShaderStruct.prototype.addField = function(type, identifier) {
  const field = `    ${type} ${identifier};`;
  this.fields.push(field);
};
ShaderStruct.prototype.generateGlslLines = function() {
  let fields = this.fields;
  if (fields.length === 0) {
    fields = ["    float _empty;"];
  }
  return [].concat(`struct ${this.name}`, "{", fields, "};");
};

// node_modules/cesium/Source/Renderer/ShaderFunction.js
function ShaderFunction(signature) {
  this.signature = signature;
  this.body = [];
}
ShaderFunction.prototype.addLines = function(lines) {
  const paddedLines = lines.map(function(line) {
    return `    ${line}`;
  });
  Array.prototype.push.apply(this.body, paddedLines);
};
ShaderFunction.prototype.generateGlslLines = function() {
  return [].concat(this.signature, "{", this.body, "}");
};

// node_modules/cesium/Source/Renderer/ShaderBuilder.js
function ShaderBuilder() {
  this._positionAttributeLine = void 0;
  this._nextAttributeLocation = 1;
  this._attributeLocations = {};
  this._attributeLines = [];
  this._structs = {};
  this._functions = {};
  this._vertexShaderParts = {
    defineLines: [],
    uniformLines: [],
    shaderLines: [],
    varyingLines: [],
    structIds: [],
    functionIds: []
  };
  this._fragmentShaderParts = {
    defineLines: [],
    uniformLines: [],
    shaderLines: [],
    varyingLines: [],
    structIds: [],
    functionIds: []
  };
}
Object.defineProperties(ShaderBuilder.prototype, {
  attributeLocations: {
    get: function() {
      return this._attributeLocations;
    }
  }
});
ShaderBuilder.prototype.addDefine = function(identifier, value, destination) {
  Check_default.typeOf.string("identifier", identifier);
  destination = defaultValue_default(destination, ShaderDestination_default.BOTH);
  let line = identifier;
  if (defined_default(value)) {
    line += ` ${value.toString()}`;
  }
  if (ShaderDestination_default.includesVertexShader(destination)) {
    this._vertexShaderParts.defineLines.push(line);
  }
  if (ShaderDestination_default.includesFragmentShader(destination)) {
    this._fragmentShaderParts.defineLines.push(line);
  }
};
ShaderBuilder.prototype.addStruct = function(structId, structName, destination) {
  Check_default.typeOf.string("structId", structId);
  Check_default.typeOf.string("structName", structName);
  Check_default.typeOf.number("destination", destination);
  this._structs[structId] = new ShaderStruct(structName);
  if (ShaderDestination_default.includesVertexShader(destination)) {
    this._vertexShaderParts.structIds.push(structId);
  }
  if (ShaderDestination_default.includesFragmentShader(destination)) {
    this._fragmentShaderParts.structIds.push(structId);
  }
};
ShaderBuilder.prototype.addStructField = function(structId, type, identifier) {
  Check_default.typeOf.string("structId", structId);
  Check_default.typeOf.string("type", type);
  Check_default.typeOf.string("identifier", identifier);
  this._structs[structId].addField(type, identifier);
};
ShaderBuilder.prototype.addFunction = function(functionName, signature, destination) {
  Check_default.typeOf.string("functionName", functionName);
  Check_default.typeOf.string("signature", signature);
  Check_default.typeOf.number("destination", destination);
  this._functions[functionName] = new ShaderFunction(signature);
  if (ShaderDestination_default.includesVertexShader(destination)) {
    this._vertexShaderParts.functionIds.push(functionName);
  }
  if (ShaderDestination_default.includesFragmentShader(destination)) {
    this._fragmentShaderParts.functionIds.push(functionName);
  }
};
ShaderBuilder.prototype.addFunctionLines = function(functionName, lines) {
  Check_default.typeOf.string("functionName", functionName);
  Check_default.typeOf.object("lines", lines);
  this._functions[functionName].addLines(lines);
};
ShaderBuilder.prototype.addUniform = function(type, identifier, destination) {
  Check_default.typeOf.string("type", type);
  Check_default.typeOf.string("identifier", identifier);
  destination = defaultValue_default(destination, ShaderDestination_default.BOTH);
  const line = `uniform ${type} ${identifier};`;
  if (ShaderDestination_default.includesVertexShader(destination)) {
    this._vertexShaderParts.uniformLines.push(line);
  }
  if (ShaderDestination_default.includesFragmentShader(destination)) {
    this._fragmentShaderParts.uniformLines.push(line);
  }
};
ShaderBuilder.prototype.setPositionAttribute = function(type, identifier) {
  Check_default.typeOf.string("type", type);
  Check_default.typeOf.string("identifier", identifier);
  if (defined_default(this._positionAttributeLine)) {
    throw new DeveloperError_default(
      "setPositionAttribute() must be called exactly once for the attribute used for gl_Position. For other attributes, use addAttribute()"
    );
  }
  this._positionAttributeLine = `attribute ${type} ${identifier};`;
  this._attributeLocations[identifier] = 0;
  return 0;
};
ShaderBuilder.prototype.addAttribute = function(type, identifier) {
  Check_default.typeOf.string("type", type);
  Check_default.typeOf.string("identifier", identifier);
  const line = `attribute ${type} ${identifier};`;
  this._attributeLines.push(line);
  const location2 = this._nextAttributeLocation;
  this._attributeLocations[identifier] = location2;
  this._nextAttributeLocation += getAttributeLocationCount(type);
  return location2;
};
ShaderBuilder.prototype.addVarying = function(type, identifier) {
  Check_default.typeOf.string("type", type);
  Check_default.typeOf.string("identifier", identifier);
  const line = `varying ${type} ${identifier};`;
  this._vertexShaderParts.varyingLines.push(line);
  this._fragmentShaderParts.varyingLines.push(line);
};
ShaderBuilder.prototype.addVertexLines = function(lines) {
  Check_default.typeOf.object("lines", lines);
  Array.prototype.push.apply(this._vertexShaderParts.shaderLines, lines);
};
ShaderBuilder.prototype.addFragmentLines = function(lines) {
  Check_default.typeOf.object("lines", lines);
  Array.prototype.push.apply(this._fragmentShaderParts.shaderLines, lines);
};
ShaderBuilder.prototype.buildShaderProgram = function(context) {
  Check_default.typeOf.object("context", context);
  const positionAttribute = defined_default(this._positionAttributeLine) ? [this._positionAttributeLine] : [];
  const structLines = generateStructLines(this);
  const functionLines = generateFunctionLines(this);
  const vertexLines = positionAttribute.concat(
    this._attributeLines,
    this._vertexShaderParts.uniformLines,
    this._vertexShaderParts.varyingLines,
    structLines.vertexLines,
    functionLines.vertexLines,
    this._vertexShaderParts.shaderLines
  ).join("\n");
  const vertexShaderSource = new ShaderSource_default({
    defines: this._vertexShaderParts.defineLines,
    sources: [vertexLines]
  });
  const fragmentLines = this._fragmentShaderParts.uniformLines.concat(
    this._fragmentShaderParts.varyingLines,
    structLines.fragmentLines,
    functionLines.fragmentLines,
    this._fragmentShaderParts.shaderLines
  ).join("\n");
  const fragmentShaderSource = new ShaderSource_default({
    defines: this._fragmentShaderParts.defineLines,
    sources: [fragmentLines]
  });
  return ShaderProgram_default.fromCache({
    context,
    vertexShaderSource,
    fragmentShaderSource,
    attributeLocations: this._attributeLocations
  });
};
ShaderBuilder.prototype.clone = function() {
  return clone_default(this, true);
};
function generateStructLines(shaderBuilder) {
  const vertexLines = [];
  const fragmentLines = [];
  let i2;
  let structIds = shaderBuilder._vertexShaderParts.structIds;
  let structId;
  let struct;
  let structLines;
  for (i2 = 0; i2 < structIds.length; i2++) {
    structId = structIds[i2];
    struct = shaderBuilder._structs[structId];
    structLines = struct.generateGlslLines();
    vertexLines.push.apply(vertexLines, structLines);
  }
  structIds = shaderBuilder._fragmentShaderParts.structIds;
  for (i2 = 0; i2 < structIds.length; i2++) {
    structId = structIds[i2];
    struct = shaderBuilder._structs[structId];
    structLines = struct.generateGlslLines();
    fragmentLines.push.apply(fragmentLines, structLines);
  }
  return {
    vertexLines,
    fragmentLines
  };
}
function getAttributeLocationCount(glslType) {
  switch (glslType) {
    case "mat2":
      return 2;
    case "mat3":
      return 3;
    case "mat4":
      return 4;
    default:
      return 1;
  }
}
function generateFunctionLines(shaderBuilder) {
  const vertexLines = [];
  const fragmentLines = [];
  let i2;
  let functionIds = shaderBuilder._vertexShaderParts.functionIds;
  let functionId;
  let func;
  let functionLines;
  for (i2 = 0; i2 < functionIds.length; i2++) {
    functionId = functionIds[i2];
    func = shaderBuilder._functions[functionId];
    functionLines = func.generateGlslLines();
    vertexLines.push.apply(vertexLines, functionLines);
  }
  functionIds = shaderBuilder._fragmentShaderParts.functionIds;
  for (i2 = 0; i2 < functionIds.length; i2++) {
    functionId = functionIds[i2];
    func = shaderBuilder._functions[functionId];
    functionLines = func.generateGlslLines();
    fragmentLines.push.apply(fragmentLines, functionLines);
  }
  return {
    vertexLines,
    fragmentLines
  };
}

// node_modules/cesium/Source/Scene/ModelExperimental/ModelRenderResources.js
function ModelRenderResources(model) {
  Check_default.typeOf.object("model", model);
  this.shaderBuilder = new ShaderBuilder();
  this.model = model;
  this.uniformMap = {};
  this.alphaOptions = new ModelAlphaOptions();
  this.renderStateOptions = {};
}

// node_modules/cesium/Source/Shaders/ModelExperimental/ModelSplitterStageFS.js
var ModelSplitterStageFS_default = "void modelSplitterStage()\n{\n    // Don't split when rendering the shadow map, because it is rendered from\n    // the perspective of a totally different camera.\n#ifndef SHADOW_MAP\n    if (model_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard;\n    if (model_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard;\n#endif\n}\n";

// node_modules/cesium/Source/Scene/ModelExperimental/ModelSplitterPipelineStage.js
var ModelSplitterPipelineStage = {};
ModelSplitterPipelineStage.name = "ModelSplitterPipelineStage";
ModelSplitterPipelineStage.SPLIT_DIRECTION_UNIFORM_NAME = "model_splitDirection";
ModelSplitterPipelineStage.process = function(renderResources, model, frameState) {
  const shaderBuilder = renderResources.shaderBuilder;
  shaderBuilder.addDefine(
    "HAS_MODEL_SPLITTER",
    void 0,
    ShaderDestination_default.FRAGMENT
  );
  shaderBuilder.addFragmentLines([ModelSplitterStageFS_default]);
  const stageUniforms = {};
  shaderBuilder.addUniform(
    "float",
    ModelSplitterPipelineStage.SPLIT_DIRECTION_UNIFORM_NAME,
    ShaderDestination_default.FRAGMENT
  );
  stageUniforms[ModelSplitterPipelineStage.SPLIT_DIRECTION_UNIFORM_NAME] = function() {
    return model.splitDirection;
  };
  renderResources.uniformMap = combine_default(
    stageUniforms,
    renderResources.uniformMap
  );
};
var ModelSplitterPipelineStage_default = ModelSplitterPipelineStage;

// node_modules/cesium/Source/Scene/ModelExperimental/NodeRenderResources.js
function NodeRenderResources(modelRenderResources, runtimeNode) {
  Check_default.typeOf.object("modelRenderResources", modelRenderResources);
  Check_default.typeOf.object("runtimeNode", runtimeNode);
  this.model = modelRenderResources.model;
  this.shaderBuilder = modelRenderResources.shaderBuilder.clone();
  this.uniformMap = clone_default(modelRenderResources.uniformMap);
  this.alphaOptions = clone_default(modelRenderResources.alphaOptions);
  this.renderStateOptions = clone_default(modelRenderResources.renderStateOptions);
  this.runtimeNode = runtimeNode;
  this.attributes = [];
  this.attributeIndex = 1;
  this.featureIdVertexAttributeSetIndex = 0;
  this.instanceCount = 0;
  this.instancingTranslationMax = void 0;
  this.instancingTranslationMin = void 0;
}

// node_modules/cesium/Source/Scene/ModelExperimental/ModelLightingOptions.js
function ModelLightingOptions(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.lightingModel = defaultValue_default(options.lightingModel, LightingModel_default.UNLIT);
}

// node_modules/cesium/Source/Scene/ModelExperimental/PrimitiveRenderResources.js
function PrimitiveRenderResources(nodeRenderResources, runtimePrimitive) {
  Check_default.typeOf.object("nodeRenderResources", nodeRenderResources);
  Check_default.typeOf.object("runtimePrimitive", runtimePrimitive);
  this.model = nodeRenderResources.model;
  this.runtimeNode = nodeRenderResources.runtimeNode;
  this.attributes = nodeRenderResources.attributes.slice();
  this.attributeIndex = nodeRenderResources.attributeIndex;
  this.featureIdVertexAttributeSetIndex = nodeRenderResources.featureIdVertexAttributeSetIndex;
  this.hasPropertyTable = false;
  this.uniformMap = clone_default(nodeRenderResources.uniformMap);
  this.alphaOptions = clone_default(nodeRenderResources.alphaOptions);
  this.shaderBuilder = nodeRenderResources.shaderBuilder.clone();
  this.instanceCount = nodeRenderResources.instanceCount;
  this.runtimePrimitive = runtimePrimitive;
  const primitive = runtimePrimitive.primitive;
  this.count = defined_default(primitive.indices) ? primitive.indices.count : ModelExperimentalUtility.getAttributeBySemantic(primitive, "POSITION").count;
  this.indices = primitive.indices;
  this.primitiveType = primitive.primitiveType;
  this.boundingSphere = ModelExperimentalUtility.createBoundingSphere(
    primitive,
    Matrix4_default.IDENTITY,
    nodeRenderResources.instancingTranslationMax,
    nodeRenderResources.instancingTranslationMin
  );
  this.lightingOptions = new ModelLightingOptions();
  this.pickId = void 0;
  this.renderStateOptions = combine_default(nodeRenderResources.renderStateOptions, {
    depthTest: {
      enabled: true,
      func: DepthFunction_default.LESS_OR_EQUAL
    },
    blending: BlendingState_default.DISABLED
  });
  this.styleCommandsNeeded = void 0;
}

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimentalSceneGraph.js
function ModelExperimentalSceneGraph(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const components = options.modelComponents;
  Check_default.typeOf.object("options.model", options.model);
  Check_default.typeOf.object("options.modelComponents", components);
  this._model = options.model;
  this._components = components;
  this._pipelineStages = [];
  this._updateStages = [];
  this._runtimeNodes = [];
  this._rootNodes = [];
  this._skinnedNodes = [];
  this._runtimeSkins = [];
  this._drawCommands = [];
  this.modelPipelineStages = [];
  this._boundingSphere = void 0;
  this._computedModelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._axisCorrectionMatrix = ModelExperimentalUtility.getAxisCorrectionMatrix(
    components.upAxis,
    components.forwardAxis,
    new Matrix4_default()
  );
  initialize16(this);
}
Object.defineProperties(ModelExperimentalSceneGraph.prototype, {
  components: {
    get: function() {
      return this._components;
    }
  },
  computedModelMatrix: {
    get: function() {
      return this._computedModelMatrix;
    }
  },
  axisCorrectionMatrix: {
    get: function() {
      return this._axisCorrectionMatrix;
    }
  },
  boundingSphere: {
    get: function() {
      return this._boundingSphere;
    }
  }
});
function initialize16(sceneGraph) {
  const components = sceneGraph._components;
  const scene = components.scene;
  computeModelMatrix(sceneGraph);
  const nodes = components.nodes;
  const nodesLength = nodes.length;
  sceneGraph._runtimeNodes = new Array(nodesLength);
  const rootNodes = scene.nodes;
  const rootNodesLength = rootNodes.length;
  const transformToRoot = Matrix4_default.IDENTITY;
  for (let i2 = 0; i2 < rootNodesLength; i2++) {
    const rootNode = scene.nodes[i2];
    const rootNodeIndex = traverseSceneGraph(
      sceneGraph,
      rootNode,
      transformToRoot
    );
    sceneGraph._rootNodes.push(rootNodeIndex);
  }
  const skins = components.skins;
  const runtimeSkins = sceneGraph._runtimeSkins;
  const skinsLength = skins.length;
  for (let i2 = 0; i2 < skinsLength; i2++) {
    const skin = skins[i2];
    runtimeSkins.push(
      new ModelExperimentalSkin({
        skin,
        sceneGraph
      })
    );
  }
  const skinnedNodes = sceneGraph._skinnedNodes;
  const skinnedNodesLength = skinnedNodes.length;
  for (let i2 = 0; i2 < skinnedNodesLength; i2++) {
    const skinnedNodeIndex = skinnedNodes[i2];
    const skinnedNode = sceneGraph._runtimeNodes[skinnedNodeIndex];
    const skin = nodes[skinnedNodeIndex].skin;
    const skinIndex = skin.index;
    skinnedNode._runtimeSkin = runtimeSkins[skinIndex];
    skinnedNode.updateJointMatrices();
  }
}
function computeModelMatrix(sceneGraph) {
  const components = sceneGraph._components;
  const model = sceneGraph._model;
  sceneGraph._computedModelMatrix = Matrix4_default.multiplyTransformation(
    model.modelMatrix,
    components.transform,
    sceneGraph._computedModelMatrix
  );
  sceneGraph._computedModelMatrix = Matrix4_default.multiplyTransformation(
    sceneGraph._computedModelMatrix,
    sceneGraph._axisCorrectionMatrix,
    sceneGraph._computedModelMatrix
  );
  sceneGraph._computedModelMatrix = Matrix4_default.multiplyByUniformScale(
    sceneGraph._computedModelMatrix,
    model.computedScale,
    sceneGraph._computedModelMatrix
  );
}
function traverseSceneGraph(sceneGraph, node, transformToRoot) {
  const childrenIndices = [];
  const transform4 = ModelExperimentalUtility.getNodeTransform(node);
  const childrenLength = node.children.length;
  for (let i2 = 0; i2 < childrenLength; i2++) {
    const childNode = node.children[i2];
    const childNodeTransformToRoot = Matrix4_default.multiplyTransformation(
      transformToRoot,
      transform4,
      new Matrix4_default()
    );
    const childIndex = traverseSceneGraph(
      sceneGraph,
      childNode,
      childNodeTransformToRoot
    );
    childrenIndices.push(childIndex);
  }
  const runtimeNode = new ModelExperimentalNode({
    node,
    transform: transform4,
    transformToRoot,
    children: childrenIndices,
    sceneGraph
  });
  const primitivesLength = node.primitives.length;
  for (let i2 = 0; i2 < primitivesLength; i2++) {
    runtimeNode.runtimePrimitives.push(
      new ModelExperimentalPrimitive({
        primitive: node.primitives[i2],
        node,
        model: sceneGraph._model
      })
    );
  }
  const index2 = node.index;
  sceneGraph._runtimeNodes[index2] = runtimeNode;
  if (defined_default(node.skin)) {
    sceneGraph._skinnedNodes.push(index2);
  }
  return index2;
}
ModelExperimentalSceneGraph.prototype.buildDrawCommands = function(frameState) {
  const model = this._model;
  const modelRenderResources = new ModelRenderResources(model);
  this.configurePipeline();
  const modelPipelineStages = this.modelPipelineStages;
  let i2, j, k;
  for (i2 = 0; i2 < modelPipelineStages.length; i2++) {
    const modelPipelineStage = modelPipelineStages[i2];
    modelPipelineStage.process(modelRenderResources, model, frameState);
  }
  const boundingSpheres = [];
  for (i2 = 0; i2 < this._runtimeNodes.length; i2++) {
    const runtimeNode = this._runtimeNodes[i2];
    runtimeNode.configurePipeline();
    const nodePipelineStages = runtimeNode.pipelineStages;
    const nodeRenderResources = new NodeRenderResources(
      modelRenderResources,
      runtimeNode
    );
    for (j = 0; j < nodePipelineStages.length; j++) {
      const nodePipelineStage = nodePipelineStages[j];
      nodePipelineStage.process(
        nodeRenderResources,
        runtimeNode.node,
        frameState
      );
    }
    for (j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
      const runtimePrimitive = runtimeNode.runtimePrimitives[j];
      runtimePrimitive.configurePipeline();
      const primitivePipelineStages = runtimePrimitive.pipelineStages;
      const primitiveRenderResources = new PrimitiveRenderResources(
        nodeRenderResources,
        runtimePrimitive
      );
      for (k = 0; k < primitivePipelineStages.length; k++) {
        const primitivePipelineStage = primitivePipelineStages[k];
        primitivePipelineStage.process(
          primitiveRenderResources,
          runtimePrimitive.primitive,
          frameState
        );
      }
      runtimePrimitive.boundingSphere = BoundingSphere_default.clone(
        primitiveRenderResources.boundingSphere
      );
      boundingSpheres.push(runtimePrimitive.boundingSphere);
      const drawCommands = buildDrawCommands(
        primitiveRenderResources,
        frameState
      );
      runtimePrimitive.drawCommands = drawCommands;
    }
  }
  this._boundingSphere = BoundingSphere_default.fromBoundingSpheres(boundingSpheres);
  model._boundingSphere = BoundingSphere_default.transform(
    this._boundingSphere,
    model.modelMatrix,
    model._boundingSphere
  );
  model._initialRadius = model._boundingSphere.radius;
  model._boundingSphere.radius *= model._clampedScale;
};
ModelExperimentalSceneGraph.prototype.configurePipeline = function() {
  const modelPipelineStages = this.modelPipelineStages;
  modelPipelineStages.length = 0;
  const model = this._model;
  if (defined_default(model.color)) {
    modelPipelineStages.push(ModelColorPipelineStage_default);
  }
  if (model.imageBasedLighting.enabled) {
    modelPipelineStages.push(ImageBasedLightingPipelineStage_default);
  }
  if (model.isClippingEnabled()) {
    modelPipelineStages.push(ModelClippingPlanesPipelineStage_default);
  }
  if (defined_default(model.splitDirection) && model.splitDirection !== SplitDirection_default.NONE) {
    modelPipelineStages.push(ModelSplitterPipelineStage_default);
  }
};
ModelExperimentalSceneGraph.prototype.update = function(frameState, updateForAnimations) {
  let i2, j, k;
  for (i2 = 0; i2 < this._runtimeNodes.length; i2++) {
    const runtimeNode = this._runtimeNodes[i2];
    for (j = 0; j < runtimeNode.updateStages.length; j++) {
      const nodeUpdateStage = runtimeNode.updateStages[j];
      nodeUpdateStage.update(runtimeNode, this, frameState);
    }
    if (updateForAnimations) {
      this.updateJointMatrices();
    }
    for (j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
      const runtimePrimitive = runtimeNode.runtimePrimitives[j];
      for (k = 0; k < runtimePrimitive.updateStages.length; k++) {
        const stage = runtimePrimitive.updateStages[k];
        stage.update(runtimePrimitive);
      }
    }
  }
};
ModelExperimentalSceneGraph.prototype.updateModelMatrix = function() {
  computeModelMatrix(this);
  const rootNodes = this._rootNodes;
  for (let i2 = 0; i2 < rootNodes.length; i2++) {
    const node = this._runtimeNodes[rootNodes[i2]];
    node._transformDirty = true;
  }
};
ModelExperimentalSceneGraph.prototype.updateJointMatrices = function() {
  const skinnedNodes = this._skinnedNodes;
  const length3 = skinnedNodes.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const nodeIndex = skinnedNodes[i2];
    const runtimeNode = this._runtimeNodes[nodeIndex];
    runtimeNode.updateJointMatrices();
  }
};
function forEachRuntimePrimitive(sceneGraph, callback) {
  for (let i2 = 0; i2 < sceneGraph._runtimeNodes.length; i2++) {
    const runtimeNode = sceneGraph._runtimeNodes[i2];
    for (let j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
      const runtimePrimitive = runtimeNode.runtimePrimitives[j];
      callback(runtimePrimitive);
    }
  }
}
ModelExperimentalSceneGraph.prototype.updateBackFaceCulling = function(backFaceCulling) {
  const model = this._model;
  forEachRuntimePrimitive(this, function(runtimePrimitive) {
    for (let k = 0; k < runtimePrimitive.drawCommands.length; k++) {
      const drawCommand = runtimePrimitive.drawCommands[k];
      const renderState = clone_default(drawCommand.renderState, true);
      const doubleSided = runtimePrimitive.primitive.material.doubleSided;
      const translucent = defined_default(model.color) && model.color.alpha < 1;
      renderState.cull.enabled = backFaceCulling && !doubleSided && !translucent;
      drawCommand.renderState = RenderState_default.fromCache(renderState);
    }
  });
};
ModelExperimentalSceneGraph.prototype.updateShadows = function(shadowMode) {
  const model = this._model;
  const castShadows = ShadowMode_default.castShadows(model.shadows);
  const receiveShadows = ShadowMode_default.receiveShadows(model.shadows);
  forEachRuntimePrimitive(this, function(runtimePrimitive) {
    for (let k = 0; k < runtimePrimitive.drawCommands.length; k++) {
      const drawCommand = runtimePrimitive.drawCommands[k];
      drawCommand.castShadows = castShadows;
      drawCommand.receiveShadows = receiveShadows;
    }
  });
};
ModelExperimentalSceneGraph.prototype.getDrawCommands = function() {
  const drawCommands = [];
  forEachRuntimePrimitive(this, function(runtimePrimitive) {
    drawCommands.push.apply(drawCommands, runtimePrimitive.drawCommands);
  });
  return drawCommands;
};

// node_modules/cesium/Source/Scene/ModelExperimental/ModelFeature.js
function ModelFeature(options) {
  this._model = options.model;
  this._featureTable = options.featureTable;
  this._featureId = options.featureId;
  this._color = void 0;
}
Object.defineProperties(ModelFeature.prototype, {
  show: {
    get: function() {
      return this._featureTable.getShow(this._featureId);
    },
    set: function(value) {
      this._featureTable.setShow(this._featureId, value);
    }
  },
  color: {
    get: function() {
      if (!defined_default(this._color)) {
        this._color = new Color_default();
      }
      return this._featureTable.getColor(this._featureId, this._color);
    },
    set: function(value) {
      this._featureTable.setColor(this._featureId, value);
    }
  },
  primitive: {
    get: function() {
      return this._model;
    }
  },
  featureTable: {
    get: function() {
      return this._featureTable;
    }
  },
  featureId: {
    get: function() {
      return this._featureId;
    }
  }
});
ModelFeature.prototype.hasProperty = function(name) {
  return this._featureTable.hasProperty(this._featureId, name);
};
ModelFeature.prototype.getProperty = function(name) {
  return this._featureTable.getProperty(this._featureId, name);
};
ModelFeature.prototype.getPropertyInherited = function(name) {
  if (this._featureTable.hasPropertyBySemantic(this._featureId, name)) {
    return this._featureTable.getPropertyBySemantic(this._featureId, name);
  }
  return this._featureTable.getProperty(this._featureId, name);
};
ModelFeature.prototype.getPropertyNames = function(results) {
  return this._featureTable.getPropertyNames(results);
};
ModelFeature.prototype.setProperty = function(name, value) {
  return this._featureTable.setProperty(this._featureId, name, value);
};

// node_modules/cesium/Source/Scene/ModelExperimental/ModelFeatureTable.js
function ModelFeatureTable(options) {
  const model = options.model;
  const propertyTable = options.propertyTable;
  Check_default.typeOf.object("propertyTable", propertyTable);
  Check_default.typeOf.object("model", model);
  this._propertyTable = propertyTable;
  this._model = model;
  this._features = void 0;
  this._featuresLength = 0;
  this._batchTexture = void 0;
  this._styleCommandsNeededDirty = false;
  this._styleCommandsNeeded = StyleCommandsNeeded_default.ALL_OPAQUE;
  initialize17(this);
}
Object.defineProperties(ModelFeatureTable.prototype, {
  batchTexture: {
    get: function() {
      return this._batchTexture;
    }
  },
  featuresLength: {
    get: function() {
      return this._featuresLength;
    }
  },
  styleCommandsNeededDirty: {
    get: function() {
      return this._styleCommandsNeededDirty;
    }
  }
});
function initialize17(modelFeatureTable) {
  const model = modelFeatureTable._model;
  const is3DTiles = ModelExperimentalType_default.is3DTiles(model.type);
  const featuresLength = modelFeatureTable._propertyTable.count;
  if (featuresLength === 0) {
    return;
  }
  let i2;
  const features = new Array(featuresLength);
  if (is3DTiles) {
    const content = model.content;
    for (i2 = 0; i2 < featuresLength; i2++) {
      features[i2] = new Cesium3DTileFeature_default(content, i2);
    }
  } else {
    for (i2 = 0; i2 < featuresLength; i2++) {
      features[i2] = new ModelFeature({
        model,
        featureId: i2,
        featureTable: modelFeatureTable
      });
    }
  }
  modelFeatureTable._features = features;
  modelFeatureTable._featuresLength = featuresLength;
  modelFeatureTable._batchTexture = new BatchTexture({
    featuresLength,
    owner: modelFeatureTable,
    statistics: is3DTiles ? model.content.tileset.statistics : modelFeatureTable._statistics
  });
}
ModelFeatureTable.prototype.update = function(frameState) {
  this._styleCommandsNeededDirty = false;
  this._batchTexture.update(void 0, frameState);
  const currentStyleCommandsNeeded = StyleCommandsNeeded_default.getStyleCommandsNeeded(
    this._featuresLength,
    this._batchTexture.translucentFeaturesLength
  );
  if (this._styleCommandsNeeded !== currentStyleCommandsNeeded) {
    this._styleCommandsNeededDirty = true;
    this._styleCommandsNeeded = currentStyleCommandsNeeded;
  }
};
ModelFeatureTable.prototype.setShow = function(featureId, show) {
  this._batchTexture.setShow(featureId, show);
};
ModelFeatureTable.prototype.setAllShow = function(show) {
  this._batchTexture.setAllShow(show);
};
ModelFeatureTable.prototype.getShow = function(featureId) {
  return this._batchTexture.getShow(featureId);
};
ModelFeatureTable.prototype.setColor = function(featureId, color) {
  this._batchTexture.setColor(featureId, color);
};
ModelFeatureTable.prototype.setAllColor = function(color) {
  this._batchTexture.setAllColor(color);
};
ModelFeatureTable.prototype.getColor = function(featureId, result) {
  return this._batchTexture.getColor(featureId, result);
};
ModelFeatureTable.prototype.getPickColor = function(featureId) {
  return this._batchTexture.getPickColor(featureId);
};
ModelFeatureTable.prototype.getFeature = function(featureId) {
  return this._features[featureId];
};
ModelFeatureTable.prototype.hasProperty = function(featureId, propertyName) {
  return this._propertyTable.hasProperty(featureId, propertyName);
};
ModelFeatureTable.prototype.hasPropertyBySemantic = function(featureId, propertyName) {
  return this._propertyTable.hasPropertyBySemantic(featureId, propertyName);
};
ModelFeatureTable.prototype.getProperty = function(featureId, name) {
  return this._propertyTable.getProperty(featureId, name);
};
ModelFeatureTable.prototype.getPropertyBySemantic = function(featureId, semantic) {
  return this._propertyTable.getPropertyBySemantic(featureId, semantic);
};
ModelFeatureTable.prototype.getPropertyNames = function(results) {
  return this._propertyTable.getPropertyIds(results);
};
ModelFeatureTable.prototype.setProperty = function(featureId, name, value) {
  return this._propertyTable.setProperty(featureId, name, value);
};
var scratchColor11 = new Color_default();
ModelFeatureTable.prototype.applyStyle = function(style) {
  if (!defined_default(style)) {
    this.setAllColor(BatchTexture.DEFAULT_COLOR_VALUE);
    this.setAllShow(BatchTexture.DEFAULT_SHOW_VALUE);
    return;
  }
  for (let i2 = 0; i2 < this._featuresLength; i2++) {
    const feature2 = this.getFeature(i2);
    const color = defined_default(style.color) ? defaultValue_default(
      style.color.evaluateColor(feature2, scratchColor11),
      BatchTexture.DEFAULT_COLOR_VALUE
    ) : BatchTexture.DEFAULT_COLOR_VALUE;
    const show = defined_default(style.show) ? defaultValue_default(
      style.show.evaluate(feature2),
      BatchTexture.DEFAULT_SHOW_VALUE
    ) : BatchTexture.DEFAULT_SHOW_VALUE;
    this.setColor(i2, color);
    this.setShow(i2, show);
  }
};
ModelFeatureTable.prototype.isDestroyed = function() {
  return false;
};
ModelFeatureTable.prototype.destroy = function(frameState) {
  this._batchTexture.destroy();
  destroyObject_default(this);
};

// node_modules/cesium/Source/Scene/JsonMetadataTable.js
var emptyClass = {};
function JsonMetadataTable(options) {
  Check_default.typeOf.number.greaterThan("options.count", options.count, 0);
  Check_default.typeOf.object("options.properties", options.properties);
  this._count = options.count;
  this._properties = clone_default(options.properties, true);
}
JsonMetadataTable.prototype.hasProperty = function(propertyId) {
  return MetadataEntity_default.hasProperty(propertyId, this._properties, emptyClass);
};
JsonMetadataTable.prototype.getPropertyIds = function(results) {
  return MetadataEntity_default.getPropertyIds(this._properties, emptyClass, results);
};
JsonMetadataTable.prototype.getProperty = function(index2, propertyId) {
  Check_default.typeOf.number("index", index2);
  Check_default.typeOf.string("propertyId", propertyId);
  if (index2 < 0 || index2 >= this._count) {
    throw new DeveloperError_default(`index must be in the range [0, ${this._count})`);
  }
  const property = this._properties[propertyId];
  if (defined_default(property)) {
    return clone_default(property[index2], true);
  }
  return void 0;
};
JsonMetadataTable.prototype.setProperty = function(index2, propertyId, value) {
  Check_default.typeOf.number("index", index2);
  Check_default.typeOf.string("propertyId", propertyId);
  if (index2 < 0 || index2 >= this._count) {
    throw new DeveloperError_default(`index must be in the range [0, ${this._count})`);
  }
  const property = this._properties[propertyId];
  if (defined_default(property)) {
    property[index2] = clone_default(value, true);
    return true;
  }
  return false;
};

// node_modules/cesium/Source/Scene/parseBatchTable.js
function parseBatchTable(options) {
  Check_default.typeOf.number("options.count", options.count);
  Check_default.typeOf.object("options.batchTable", options.batchTable);
  const featureCount = options.count;
  const batchTable = options.batchTable;
  const binaryBody = options.binaryBody;
  const partitionResults = partitionProperties(batchTable);
  const jsonMetadataTable = new JsonMetadataTable({
    count: featureCount,
    properties: partitionResults.jsonProperties
  });
  const hierarchy = initializeHierarchy2(partitionResults.hierarchy, binaryBody);
  const className = MetadataClass_default.BATCH_TABLE_CLASS_NAME;
  const binaryResults = transcodeBinaryProperties(
    featureCount,
    className,
    partitionResults.binaryProperties,
    binaryBody
  );
  const featureTableJson = binaryResults.featureTableJson;
  const metadataTable = new MetadataTable_default({
    count: featureTableJson.count,
    properties: featureTableJson.properties,
    class: binaryResults.transcodedClass,
    bufferViews: binaryResults.bufferViewsU8
  });
  const propertyTable = new PropertyTable_default({
    id: 0,
    name: "Batch Table",
    count: featureTableJson.count,
    metadataTable,
    jsonMetadataTable,
    batchTableHierarchy: hierarchy
  });
  return new StructuralMetadata_default({
    schema: binaryResults.transcodedSchema,
    propertyTables: [propertyTable],
    extensions: partitionResults.extensions,
    extras: partitionResults.extras
  });
}
function partitionProperties(batchTable) {
  const legacyHierarchy = batchTable.HIERARCHY;
  const extras = batchTable.extras;
  const extensions = batchTable.extensions;
  let hierarchyExtension;
  if (defined_default(legacyHierarchy)) {
    parseBatchTable._deprecationWarning(
      "batchTableHierarchyExtension",
      "The batch table HIERARCHY property has been moved to an extension. Use extensions.3DTILES_batch_table_hierarchy instead."
    );
    hierarchyExtension = legacyHierarchy;
  } else if (defined_default(extensions)) {
    hierarchyExtension = extensions["3DTILES_batch_table_hierarchy"];
  }
  const jsonProperties = {};
  const binaryProperties = {};
  for (const propertyId in batchTable) {
    if (!batchTable.hasOwnProperty(propertyId) || propertyId === "HIERARCHY" || propertyId === "extensions" || propertyId === "extras") {
      continue;
    }
    const property = batchTable[propertyId];
    if (Array.isArray(property)) {
      jsonProperties[propertyId] = property;
    } else {
      binaryProperties[propertyId] = property;
    }
  }
  return {
    binaryProperties,
    jsonProperties,
    hierarchy: hierarchyExtension,
    extras,
    extensions
  };
}
function transcodeBinaryProperties(featureCount, className, binaryProperties, binaryBody) {
  const classProperties = {};
  const featureTableProperties = {};
  const bufferViewsU8 = {};
  let bufferViewCount = 0;
  for (const propertyId in binaryProperties) {
    if (!binaryProperties.hasOwnProperty(propertyId)) {
      continue;
    }
    if (!defined_default(binaryBody)) {
      throw new RuntimeError_default(
        `Property ${propertyId} requires a batch table binary.`
      );
    }
    const property = binaryProperties[propertyId];
    const binaryAccessor = getBinaryAccessor_default(property);
    featureTableProperties[propertyId] = {
      bufferView: bufferViewCount
    };
    classProperties[propertyId] = transcodePropertyType(property);
    bufferViewsU8[bufferViewCount] = binaryAccessor.createArrayBufferView(
      binaryBody.buffer,
      binaryBody.byteOffset + property.byteOffset,
      featureCount
    );
    bufferViewCount++;
  }
  const schemaJson = {
    classes: {}
  };
  schemaJson.classes[className] = {
    properties: classProperties
  };
  const transcodedSchema = new MetadataSchema_default(schemaJson);
  const featureTableJson = {
    class: className,
    count: featureCount,
    properties: featureTableProperties
  };
  return {
    featureTableJson,
    bufferViewsU8,
    transcodedSchema,
    transcodedClass: transcodedSchema.classes[className]
  };
}
function transcodePropertyType(property) {
  const componentType = transcodeComponentType(property.componentType);
  return {
    type: property.type,
    componentType
  };
}
function transcodeComponentType(componentType) {
  switch (componentType) {
    case "BYTE":
      return "INT8";
    case "UNSIGNED_BYTE":
      return "UINT8";
    case "SHORT":
      return "INT16";
    case "UNSIGNED_SHORT":
      return "UINT16";
    case "INT":
      return "INT32";
    case "UNSIGNED_INT":
      return "UINT32";
    case "FLOAT":
      return "FLOAT32";
    case "DOUBLE":
      return "FLOAT64";
  }
}
function initializeHierarchy2(hierarchyExtension, binaryBody) {
  if (defined_default(hierarchyExtension)) {
    return new BatchTableHierarchy({
      extension: hierarchyExtension,
      binaryBody
    });
  }
  return void 0;
}
parseBatchTable._deprecationWarning = deprecationWarning_default;

// node_modules/cesium/Source/Scene/ModelExperimental/B3dmLoader.js
var B3dmLoaderState = {
  UNLOADED: 0,
  LOADING: 1,
  PROCESSING: 2,
  READY: 3,
  FAILED: 4
};
var FeatureIdAttribute3 = ModelComponents_default.FeatureIdAttribute;
function B3dmLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const b3dmResource = options.b3dmResource;
  let baseResource2 = options.baseResource;
  const arrayBuffer = options.arrayBuffer;
  const byteOffset = defaultValue_default(options.byteOffset, 0);
  const releaseGltfJson = defaultValue_default(options.releaseGltfJson, false);
  const asynchronous = defaultValue_default(options.asynchronous, true);
  const incrementallyLoadTextures = defaultValue_default(
    options.incrementallyLoadTextures,
    true
  );
  const upAxis = defaultValue_default(options.upAxis, Axis_default.Y);
  const forwardAxis = defaultValue_default(options.forwardAxis, Axis_default.X);
  const loadAsTypedArray = defaultValue_default(options.loadAsTypedArray, false);
  Check_default.typeOf.object("options.b3dmResource", b3dmResource);
  Check_default.typeOf.object("options.arrayBuffer", arrayBuffer);
  baseResource2 = defined_default(baseResource2) ? baseResource2 : b3dmResource.clone();
  this._b3dmResource = b3dmResource;
  this._baseResource = baseResource2;
  this._arrayBuffer = arrayBuffer;
  this._byteOffset = byteOffset;
  this._releaseGltfJson = releaseGltfJson;
  this._asynchronous = asynchronous;
  this._incrementallyLoadTextures = incrementallyLoadTextures;
  this._upAxis = upAxis;
  this._forwardAxis = forwardAxis;
  this._loadAsTypedArray = loadAsTypedArray;
  this._state = B3dmLoaderState.UNLOADED;
  this._promise = defer_default();
  this._gltfLoader = void 0;
  this._batchLength = 0;
  this._propertyTable = void 0;
  this._batchTable = void 0;
  this._components = void 0;
  this._transform = Matrix4_default.IDENTITY;
}
if (defined_default(Object.create)) {
  B3dmLoader.prototype = Object.create(ResourceLoader.prototype);
  B3dmLoader.prototype.constructor = B3dmLoader;
}
Object.defineProperties(B3dmLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  texturesLoadedPromise: {
    get: function() {
      return this._gltfLoader.texturesLoadedPromise;
    }
  },
  cacheKey: {
    get: function() {
      return void 0;
    }
  },
  components: {
    get: function() {
      return this._components;
    }
  }
});
B3dmLoader.prototype.load = function() {
  const b3dm = B3dmParser_default.parse(this._arrayBuffer, this._byteOffset);
  let batchLength = b3dm.batchLength;
  const featureTableJson = b3dm.featureTableJson;
  const featureTableBinary = b3dm.featureTableBinary;
  const batchTableJson = b3dm.batchTableJson;
  const batchTableBinary = b3dm.batchTableBinary;
  const featureTable = new Cesium3DTileFeatureTable_default(
    featureTableJson,
    featureTableBinary
  );
  batchLength = featureTable.getGlobalProperty("BATCH_LENGTH");
  this._batchLength = batchLength;
  const rtcCenter = featureTable.getGlobalProperty(
    "RTC_CENTER",
    ComponentDatatype_default.FLOAT,
    3
  );
  if (defined_default(rtcCenter)) {
    this._transform = Matrix4_default.fromTranslation(Cartesian3_default.fromArray(rtcCenter));
  }
  this._batchTable = {
    json: batchTableJson,
    binary: batchTableBinary
  };
  const gltfLoader = new GltfLoader({
    typedArray: b3dm.gltf,
    upAxis: this._upAxis,
    forwardAxis: this._forwardAxis,
    gltfResource: this._b3dmResource,
    baseResource: this._baseResource,
    releaseGltfJson: this._releaseGltfJson,
    incrementallyLoadTextures: this._incrementallyLoadTextures,
    loadAsTypedArray: this._loadAsTypedArray,
    renameBatchIdSemantic: true
  });
  this._gltfLoader = gltfLoader;
  this._state = B3dmLoaderState.LOADING;
  const that = this;
  gltfLoader.load();
  gltfLoader.promise.then(function() {
    if (that.isDestroyed()) {
      return;
    }
    const components = gltfLoader.components;
    components.transform = that._transform;
    createStructuralMetadata(that, components);
    that._components = components;
    that._state = B3dmLoaderState.READY;
    that._promise.resolve(that);
  }).catch(function(error) {
    if (that.isDestroyed()) {
      return;
    }
    handleError7(that, error);
  });
};
function handleError7(b3dmLoader, error) {
  b3dmLoader.unload();
  b3dmLoader._state = B3dmLoaderState.FAILED;
  const errorMessage = "Failed to load b3dm";
  error = b3dmLoader.getError(errorMessage, error);
  b3dmLoader._promise.reject(error);
}
B3dmLoader.prototype.process = function(frameState) {
  Check_default.typeOf.object("frameState", frameState);
  if (this._state === B3dmLoaderState.LOADING) {
    this._state = B3dmLoaderState.PROCESSING;
  }
  if (this._state === B3dmLoaderState.PROCESSING) {
    this._gltfLoader.process(frameState);
  }
};
function createStructuralMetadata(loader, components) {
  const batchTable = loader._batchTable;
  const batchLength = loader._batchLength;
  if (batchLength === 0) {
    return;
  }
  let structuralMetadata;
  if (defined_default(batchTable.json)) {
    structuralMetadata = parseBatchTable({
      count: batchLength,
      batchTable: batchTable.json,
      binaryBody: batchTable.binary
    });
  } else {
    const emptyPropertyTable = new PropertyTable_default({
      name: MetadataClass_default.BATCH_TABLE_CLASS_NAME,
      count: batchLength
    });
    structuralMetadata = new StructuralMetadata_default({
      schema: {},
      propertyTables: [emptyPropertyTable]
    });
  }
  const nodes = components.scene.nodes;
  const length3 = nodes.length;
  for (let i2 = 0; i2 < length3; i2++) {
    processNode(nodes[i2]);
  }
  components.structuralMetadata = structuralMetadata;
}
function processNode(node) {
  const childrenLength = node.children.length;
  for (let i2 = 0; i2 < childrenLength; i2++) {
    processNode(node.children[i2]);
  }
  const primitivesLength = node.primitives.length;
  for (let i2 = 0; i2 < primitivesLength; i2++) {
    const primitive = node.primitives[i2];
    const featureIdVertexAttribute = ModelExperimentalUtility.getAttributeBySemantic(
      primitive,
      VertexAttributeSemantic_default.FEATURE_ID
    );
    if (defined_default(featureIdVertexAttribute)) {
      featureIdVertexAttribute.setIndex = 0;
      const featureIdAttribute = new FeatureIdAttribute3();
      featureIdAttribute.propertyTableId = 0;
      featureIdAttribute.setIndex = 0;
      featureIdAttribute.positionalLabel = "featureId_0";
      primitive.featureIds.push(featureIdAttribute);
    }
  }
}
B3dmLoader.prototype.unload = function() {
  if (defined_default(this._gltfLoader)) {
    this._gltfLoader.unload();
  }
  this._components = void 0;
};
var B3dmLoader_default = B3dmLoader;

// node_modules/cesium/Source/Scene/ModelExperimental/PntsLoader.js
var Components3 = ModelComponents_default.Components;
var Scene3 = ModelComponents_default.Scene;
var Node6 = ModelComponents_default.Node;
var Primitive4 = ModelComponents_default.Primitive;
var Attribute3 = ModelComponents_default.Attribute;
var Quantization2 = ModelComponents_default.Quantization;
var FeatureIdAttribute4 = ModelComponents_default.FeatureIdAttribute;
var Material5 = ModelComponents_default.Material;
var MetallicRoughness4 = ModelComponents_default.MetallicRoughness;
function PntsLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const arrayBuffer = options.arrayBuffer;
  const byteOffset = defaultValue_default(options.byteOffset, 0);
  Check_default.typeOf.object("options.arrayBuffer", arrayBuffer);
  this._arrayBuffer = arrayBuffer;
  this._byteOffset = byteOffset;
  this._parsedContent = void 0;
  this._decodePromise = void 0;
  this._decodedAttributes = void 0;
  this._promise = defer_default();
  this._state = ResourceLoaderState_default.UNLOADED;
  this._buffers = [];
  this._components = void 0;
  this._transform = Matrix4_default.IDENTITY;
}
if (defined_default(Object.create)) {
  PntsLoader.prototype = Object.create(ResourceLoader.prototype);
  PntsLoader.prototype.constructor = PntsLoader;
}
Object.defineProperties(PntsLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  cacheKey: {
    get: function() {
      return void 0;
    }
  },
  components: {
    get: function() {
      return this._components;
    }
  },
  transform: {
    get: function() {
      return this._transform;
    }
  }
});
PntsLoader.prototype.load = function() {
  this._parsedContent = PntsParser_default.parse(this._arrayBuffer, this._byteOffset);
  this._state = ResourceLoaderState_default.PROCESSING;
};
PntsLoader.prototype.process = function(frameState) {
  if (this._state === ResourceLoaderState_default.PROCESSING) {
    if (!defined_default(this._decodePromise)) {
      decodeDraco2(this, frameState.context);
    }
  }
};
function decodeDraco2(loader, context) {
  const parsedContent = loader._parsedContent;
  const draco = parsedContent.draco;
  let decodePromise;
  if (!defined_default(draco)) {
    decodePromise = Promise.resolve();
  } else {
    decodePromise = DracoLoader_default.decodePointCloud(draco, context);
  }
  if (!defined_default(decodePromise)) {
    return;
  }
  loader._decodePromise = decodePromise;
  decodePromise.then(function(decodeDracoResult) {
    if (loader.isDestroyed()) {
      return;
    }
    if (defined_default(decodeDracoResult)) {
      processDracoAttributes(loader, draco, decodeDracoResult);
    }
    makeComponents(loader, context);
    loader._state = ResourceLoaderState_default.READY;
    loader._promise.resolve(loader);
  }).catch(function(error) {
    loader.unload();
    loader._state = ResourceLoaderState_default.FAILED;
    const errorMessage = "Failed to load Draco";
    loader._promise.reject(loader.getError(errorMessage, error));
  });
}
function processDracoAttributes(loader, draco, result) {
  loader._state = ResourceLoaderState_default.READY;
  const parsedContent = loader._parsedContent;
  let attribute;
  if (defined_default(result.POSITION)) {
    attribute = {
      name: "POSITION",
      semantic: VertexAttributeSemantic_default.POSITION,
      typedArray: result.POSITION.array,
      componentDatatype: ComponentDatatype_default.FLOAT,
      type: AttributeType_default.VEC3,
      isQuantized: false
    };
    if (defined_default(result.POSITION.data.quantization)) {
      const quantization = result.POSITION.data.quantization;
      const range2 = quantization.range;
      const quantizedVolumeScale = Cartesian3_default.fromElements(range2, range2, range2);
      const quantizedVolumeOffset = Cartesian3_default.unpack(quantization.minValues);
      const quantizedRange = (1 << quantization.quantizationBits) - 1;
      attribute.isQuantized = true;
      attribute.quantizedRange = quantizedRange;
      attribute.quantizedVolumeOffset = quantizedVolumeOffset;
      attribute.quantizedVolumeScale = quantizedVolumeScale;
      attribute.quantizedComponentDatatype = ComponentDatatype_default.UNSIGNED_SHORT;
      attribute.quantizedType = AttributeType_default.VEC3;
    }
    parsedContent.positions = attribute;
  }
  if (defined_default(result.NORMAL)) {
    attribute = {
      name: "NORMAL",
      semantic: VertexAttributeSemantic_default.NORMAL,
      typedArray: result.NORMAL.array,
      componentDatatype: ComponentDatatype_default.FLOAT,
      type: AttributeType_default.VEC3,
      isQuantized: false,
      octEncoded: false,
      octEncodedZXY: false
    };
    if (defined_default(result.NORMAL.data.quantization)) {
      const octEncodedRange = (1 << result.NORMAL.data.quantization.quantizationBits) - 1;
      attribute.quantizedRange = octEncodedRange;
      attribute.octEncoded = true;
      attribute.octEncodedZXY = true;
      attribute.quantizedComponentDatatype = ComponentDatatype_default.UNSIGNED_BYTE;
      attribute.quantizedType = AttributeType_default.VEC2;
    }
    parsedContent.normals = attribute;
  }
  if (defined_default(result.RGBA)) {
    parsedContent.colors = {
      name: "COLOR",
      semantic: VertexAttributeSemantic_default.COLOR,
      setIndex: 0,
      typedArray: result.RGBA.array,
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      type: AttributeType_default.VEC4,
      normalized: true,
      isTranslucent: true
    };
  } else if (defined_default(result.RGB)) {
    parsedContent.colors = {
      name: "COLOR",
      semantic: VertexAttributeSemantic_default.COLOR,
      setIndex: 0,
      typedArray: result.RGB.array,
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      type: AttributeType_default.VEC3,
      normalized: true,
      isTranslucent: false
    };
  }
  if (defined_default(result.BATCH_ID)) {
    const batchIds = result.BATCH_ID.array;
    parsedContent.batchIds = {
      name: "_FEATURE_ID",
      semantic: VertexAttributeSemantic_default.FEATURE_ID,
      setIndex: 0,
      typedArray: batchIds,
      componentDatatype: ComponentDatatype_default.fromTypedArray(batchIds),
      type: AttributeType_default.SCALAR
    };
  }
  let styleableProperties = parsedContent.styleableProperties;
  const batchTableProperties = draco.batchTableProperties;
  for (const name in batchTableProperties) {
    if (batchTableProperties.hasOwnProperty(name)) {
      const property = result[name];
      if (!defined_default(styleableProperties)) {
        styleableProperties = {};
      }
      styleableProperties[name] = {
        typedArray: property.array,
        componentCount: property.data.componentsPerAttribute
      };
    }
  }
  parsedContent.styleableProperties = styleableProperties;
}
function makeAttribute(loader, attributeInfo, context) {
  let typedArray = attributeInfo.typedArray;
  let quantization;
  if (attributeInfo.octEncoded) {
    quantization = new Quantization2();
    quantization.octEncoded = attributeInfo.octEncoded;
    quantization.octEncodedZXY = attributeInfo.octEncodedZXY;
    quantization.normalizationRange = attributeInfo.quantizedRange;
    quantization.type = attributeInfo.quantizedType;
    quantization.componentDatatype = attributeInfo.quantizedComponentDatatype;
  }
  if (attributeInfo.isQuantized) {
    quantization = new Quantization2();
    const normalizationRange = attributeInfo.quantizedRange;
    quantization.normalizationRange = normalizationRange;
    quantization.quantizedVolumeOffset = Cartesian3_default.ZERO;
    const quantizedVolumeDimensions = attributeInfo.quantizedVolumeScale;
    quantization.quantizedVolumeDimensions = quantizedVolumeDimensions;
    quantization.quantizedVolumeStepSize = Cartesian3_default.divideByScalar(
      quantizedVolumeDimensions,
      normalizationRange,
      new Cartesian3_default()
    );
    quantization.componentDatatype = attributeInfo.quantizedComponentDatatype;
    quantization.type = attributeInfo.quantizedType;
  }
  const attribute = new Attribute3();
  attribute.name = attributeInfo.name;
  attribute.semantic = attributeInfo.semantic;
  attribute.setIndex = attributeInfo.setIndex;
  attribute.componentDatatype = attributeInfo.componentDatatype;
  attribute.type = attributeInfo.type;
  attribute.normalized = defaultValue_default(attributeInfo.normalized, false);
  attribute.min = attributeInfo.min;
  attribute.max = attributeInfo.max;
  attribute.quantization = quantization;
  if (attributeInfo.isRGB565) {
    typedArray = AttributeCompression_default.decodeRGB565(typedArray);
  }
  if (defined_default(attributeInfo.constantColor)) {
    const packedColor = new Array(4);
    attribute.constant = Color_default.pack(attributeInfo.constantColor, packedColor);
  } else {
    const buffer = Buffer_default.createVertexBuffer({
      typedArray,
      context,
      usage: BufferUsage_default.STATIC_DRAW
    });
    buffer.vertexArrayDestroyable = false;
    loader._buffers.push(buffer);
    attribute.buffer = buffer;
  }
  return attribute;
}
var randomNumberGenerator3;
var randomValues2;
function getRandomValues2(samplesLength) {
  if (!defined_default(randomValues2)) {
    randomNumberGenerator3 = new mersenneTwister(0);
    randomValues2 = new Array(samplesLength);
    for (let i2 = 0; i2 < samplesLength; ++i2) {
      randomValues2[i2] = randomNumberGenerator3.random();
    }
  }
  return randomValues2;
}
var scratchMin4 = new Cartesian3_default();
var scratchMax4 = new Cartesian3_default();
var scratchPosition11 = new Cartesian3_default();
function computeApproximateExtrema(positions) {
  const positionsArray = positions.typedArray;
  const maximumSamplesLength = 20;
  const pointsLength = positionsArray.length / 3;
  const samplesLength = Math.min(pointsLength, maximumSamplesLength);
  const randomValues3 = getRandomValues2(maximumSamplesLength);
  const maxValue = Number.MAX_VALUE;
  const minValue = -Number.MAX_VALUE;
  let min3 = Cartesian3_default.fromElements(maxValue, maxValue, maxValue, scratchMin4);
  let max3 = Cartesian3_default.fromElements(minValue, minValue, minValue, scratchMax4);
  let i2;
  let index2;
  let position;
  if (positions.isQuantized) {
    min3 = Cartesian3_default.ZERO;
    max3 = positions.quantizedVolumeScale;
  } else {
    for (i2 = 0; i2 < samplesLength; ++i2) {
      index2 = Math.floor(randomValues3[i2] * pointsLength);
      position = Cartesian3_default.unpack(positionsArray, index2 * 3, scratchPosition11);
      Cartesian3_default.minimumByComponent(min3, position, min3);
      Cartesian3_default.maximumByComponent(max3, position, max3);
    }
  }
  positions.min = Cartesian3_default.clone(min3);
  positions.max = Cartesian3_default.clone(max3);
}
var defaultColorAttribute = {
  name: VertexAttributeSemantic_default.COLOR,
  semantic: VertexAttributeSemantic_default.COLOR,
  setIndex: 0,
  constantColor: Color_default.DARKGRAY,
  componentDatatype: ComponentDatatype_default.FLOAT,
  type: AttributeType_default.VEC4,
  isQuantized: false,
  isTranslucent: false
};
function makeAttributes(loader, parsedContent, context) {
  const attributes = [];
  let attribute;
  const positions = parsedContent.positions;
  if (defined_default(positions)) {
    computeApproximateExtrema(positions);
    attribute = makeAttribute(loader, positions, context);
    attribute.count = parsedContent.pointsLength;
    attributes.push(attribute);
  }
  if (defined_default(parsedContent.normals)) {
    attribute = makeAttribute(loader, parsedContent.normals, context);
    attributes.push(attribute);
  }
  if (defined_default(parsedContent.colors)) {
    attribute = makeAttribute(loader, parsedContent.colors, context);
    attributes.push(attribute);
  } else {
    attribute = makeAttribute(loader, defaultColorAttribute, context);
    attributes.push(attribute);
  }
  if (defined_default(parsedContent.batchIds)) {
    attribute = makeAttribute(loader, parsedContent.batchIds, context);
    attributes.push(attribute);
  }
  return attributes;
}
function makeStructuralMetadata(parsedContent) {
  const batchLength = parsedContent.batchLength;
  const pointsLength = parsedContent.pointsLength;
  const batchTableBinary = parsedContent.batchTableBinary;
  if (defined_default(batchTableBinary)) {
    const count = defaultValue_default(batchLength, pointsLength);
    return parseBatchTable({
      count,
      batchTable: parsedContent.batchTableJson,
      binaryBody: batchTableBinary
    });
  }
  const emptyPropertyTable = new PropertyTable_default({
    name: MetadataClass_default.BATCH_TABLE_CLASS_NAME,
    count: pointsLength
  });
  return new StructuralMetadata_default({
    schema: {},
    propertyTables: [emptyPropertyTable]
  });
}
function makeComponents(loader, context) {
  const parsedContent = loader._parsedContent;
  const metallicRoughness = new MetallicRoughness4();
  metallicRoughness.metallicFactor = 0;
  metallicRoughness.roughnessFactor = 0.9;
  const material = new Material5();
  material.metallicRoughness = metallicRoughness;
  const colors = parsedContent.colors;
  if (defined_default(colors) && colors.isTranslucent) {
    material.alphaMode = AlphaMode_default.BLEND;
  }
  const isUnlit = !defined_default(parsedContent.normals);
  material.unlit = isUnlit;
  const primitive = new Primitive4();
  primitive.attributes = makeAttributes(loader, parsedContent, context);
  primitive.primitiveType = PrimitiveType_default.POINTS;
  primitive.material = material;
  if (defined_default(parsedContent.batchIds)) {
    const featureIdAttribute = new FeatureIdAttribute4();
    featureIdAttribute.propertyTableId = 0;
    featureIdAttribute.setIndex = 0;
    featureIdAttribute.positionalLabel = "featureId_0";
    primitive.featureIds.push(featureIdAttribute);
  }
  const node = new Node6();
  node.index = 0;
  node.primitives = [primitive];
  const scene = new Scene3();
  scene.nodes = [node];
  scene.upAxis = Axis_default.Z;
  scene.forwardAxis = Axis_default.X;
  const components = new Components3();
  components.scene = scene;
  components.nodes = [node];
  components.structuralMetadata = makeStructuralMetadata(parsedContent);
  if (defined_default(parsedContent.rtcCenter)) {
    components.transform = Matrix4_default.multiplyByTranslation(
      components.transform,
      parsedContent.rtcCenter,
      components.transform
    );
  }
  const positions = parsedContent.positions;
  if (defined_default(positions) && positions.isQuantized) {
    components.transform = Matrix4_default.multiplyByTranslation(
      components.transform,
      positions.quantizedVolumeOffset,
      components.transform
    );
  }
  loader._components = components;
  loader._parsedContent = void 0;
}
PntsLoader.prototype.unload = function() {
  const buffers = this._buffers;
  for (let i2 = 0; i2 < buffers.length; i2++) {
    buffers[i2].destroy();
  }
  buffers.length = 0;
  this._components = void 0;
  this._parsedContent = void 0;
};

// node_modules/cesium/Source/Scene/ModelExperimental/I3dmLoader.js
var I3dmLoaderState = {
  UNLOADED: 0,
  LOADING: 1,
  PROCESSING: 2,
  READY: 3,
  FAILED: 4
};
var Attribute4 = ModelComponents_default.Attribute;
var FeatureIdAttribute5 = ModelComponents_default.FeatureIdAttribute;
var Instances3 = ModelComponents_default.Instances;
function I3dmLoader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const i3dmResource = options.i3dmResource;
  const arrayBuffer = options.arrayBuffer;
  let baseResource2 = options.baseResource;
  const byteOffset = defaultValue_default(options.byteOffset, 0);
  const releaseGltfJson = defaultValue_default(options.releaseGltfJson, false);
  const asynchronous = defaultValue_default(options.asynchronous, true);
  const incrementallyLoadTextures = defaultValue_default(
    options.incrementallyLoadTextures,
    true
  );
  const upAxis = defaultValue_default(options.upAxis, Axis_default.Y);
  const forwardAxis = defaultValue_default(options.forwardAxis, Axis_default.X);
  const loadAsTypedArray = defaultValue_default(options.loadAsTypedArray, false);
  Check_default.typeOf.object("options.i3dmResource", i3dmResource);
  Check_default.typeOf.object("options.arrayBuffer", arrayBuffer);
  baseResource2 = defined_default(baseResource2) ? baseResource2 : i3dmResource.clone();
  this._i3dmResource = i3dmResource;
  this._baseResource = baseResource2;
  this._arrayBuffer = arrayBuffer;
  this._byteOffset = byteOffset;
  this._releaseGltfJson = releaseGltfJson;
  this._asynchronous = asynchronous;
  this._incrementallyLoadTextures = incrementallyLoadTextures;
  this._upAxis = upAxis;
  this._forwardAxis = forwardAxis;
  this._loadAsTypedArray = loadAsTypedArray;
  this._state = I3dmLoaderState.UNLOADED;
  this._promise = defer_default();
  this._gltfLoader = void 0;
  this._transform = Matrix4_default.IDENTITY;
  this._batchTable = void 0;
  this._featureTable = void 0;
  this._instancesLength = 0;
}
if (defined_default(Object.create)) {
  I3dmLoader.prototype = Object.create(ResourceLoader.prototype);
  I3dmLoader.prototype.constructor = I3dmLoader;
}
Object.defineProperties(I3dmLoader.prototype, {
  promise: {
    get: function() {
      return this._promise.promise;
    }
  },
  texturesLoadedPromise: {
    get: function() {
      return this._gltfLoader.texturesLoadedPromise;
    }
  },
  cacheKey: {
    get: function() {
      return void 0;
    }
  },
  components: {
    get: function() {
      return this._components;
    }
  }
});
I3dmLoader.prototype.load = function() {
  const i3dm = I3dmParser_default.parse(this._arrayBuffer, this._byteOffset);
  const featureTableJson = i3dm.featureTableJson;
  const featureTableBinary = i3dm.featureTableBinary;
  const batchTableJson = i3dm.batchTableJson;
  const batchTableBinary = i3dm.batchTableBinary;
  const gltfFormat = i3dm.gltfFormat;
  const featureTable = new Cesium3DTileFeatureTable_default(
    featureTableJson,
    featureTableBinary
  );
  this._featureTable = featureTable;
  const instancesLength = featureTable.getGlobalProperty("INSTANCES_LENGTH");
  featureTable.featuresLength = instancesLength;
  if (!defined_default(instancesLength)) {
    throw new RuntimeError_default(
      "Feature table global property: INSTANCES_LENGTH must be defined"
    );
  }
  this._instancesLength = instancesLength;
  const rtcCenter = featureTable.getGlobalProperty(
    "RTC_CENTER",
    ComponentDatatype_default.FLOAT,
    3
  );
  if (defined_default(rtcCenter)) {
    this._transform = Matrix4_default.fromTranslation(Cartesian3_default.fromArray(rtcCenter));
  }
  this._batchTable = {
    json: batchTableJson,
    binary: batchTableBinary
  };
  const loaderOptions = {
    upAxis: this._upAxis,
    forwardAxis: this._forwardAxis,
    releaseGltfJson: this._releaseGltfJson,
    incrementallyLoadTextures: this._incrementallyLoadTextures,
    loadAsTypedArray: this._loadAsTypedArray
  };
  if (gltfFormat === 0) {
    let gltfUrl = getStringFromTypedArray_default(i3dm.gltf);
    gltfUrl = gltfUrl.replace(/[\s\0]+$/, "");
    const gltfResource = this._baseResource.getDerivedResource({
      url: gltfUrl
    });
    loaderOptions.gltfResource = gltfResource;
    loaderOptions.baseResource = gltfResource;
  } else {
    loaderOptions.gltfResource = this._i3dmResource;
    loaderOptions.typedArray = i3dm.gltf;
  }
  const gltfLoader = new GltfLoader(loaderOptions);
  this._gltfLoader = gltfLoader;
  this._state = I3dmLoaderState.LOADING;
  const that = this;
  gltfLoader.load();
  gltfLoader.promise.then(function() {
    if (that.isDestroyed()) {
      return;
    }
    const components = gltfLoader.components;
    components.transform = that._transform;
    createInstances2(that, components);
    createStructuralMetadata2(that, components);
    that._components = components;
    that._state = I3dmLoaderState.READY;
    that._promise.resolve(that);
  }).catch(function(error) {
    if (that.isDestroyed()) {
      return;
    }
    handleError8(that, error);
  });
};
function handleError8(i3dmLoader, error) {
  i3dmLoader.unload();
  i3dmLoader._state = I3dmLoaderState.FAILED;
  const errorMessage = "Failed to load I3DM";
  error = i3dmLoader.getError(errorMessage, error);
  i3dmLoader._promise.reject(error);
}
I3dmLoader.prototype.process = function(frameState) {
  Check_default.typeOf.object("frameState", frameState);
  if (this._state === I3dmLoaderState.LOADING) {
    this._state = I3dmLoaderState.PROCESSING;
  }
  if (this._state === I3dmLoaderState.PROCESSING) {
    this._gltfLoader.process(frameState);
  }
};
function createStructuralMetadata2(loader, components) {
  const batchTable = loader._batchTable;
  const instancesLength = loader._instancesLength;
  if (instancesLength === 0) {
    return;
  }
  let structuralMetadata;
  if (defined_default(batchTable.json)) {
    structuralMetadata = parseBatchTable({
      count: instancesLength,
      batchTable: batchTable.json,
      binaryBody: batchTable.binary
    });
  } else {
    const emptyPropertyTable = new PropertyTable_default({
      name: MetadataClass_default.BATCH_TABLE_CLASS_NAME,
      count: instancesLength
    });
    structuralMetadata = new StructuralMetadata_default({
      schema: {},
      propertyTables: [emptyPropertyTable]
    });
  }
  components.structuralMetadata = structuralMetadata;
}
var positionScratch8 = new Cartesian3_default();
var propertyScratch12 = new Array(4);
function createInstances2(loader, components) {
  let i2;
  const featureTable = loader._featureTable;
  const instancesLength = loader._instancesLength;
  if (instancesLength === 0) {
    return;
  }
  const rtcCenter = featureTable.getGlobalProperty(
    "RTC_CENTER",
    ComponentDatatype_default.FLOAT,
    3
  );
  const eastNorthUp = featureTable.getGlobalProperty("EAST_NORTH_UP");
  const hasRotation = featureTable.hasProperty("NORMAL_UP") || featureTable.hasProperty("NORMAL_UP_OCT32P") || eastNorthUp;
  const hasScale = featureTable.hasProperty("SCALE") || featureTable.hasProperty("SCALE_NON_UNIFORM");
  const translationTypedArray = getPositions(featureTable, instancesLength);
  let rotationTypedArray;
  if (hasRotation) {
    rotationTypedArray = new Float32Array(4 * instancesLength);
  }
  let scaleTypedArray;
  if (hasScale) {
    scaleTypedArray = new Float32Array(3 * instancesLength);
  }
  const featureIdArray = new Float32Array(instancesLength);
  const instancePositions = Cartesian3_default.unpackArray(translationTypedArray);
  let instancePosition = new Cartesian3_default();
  const instanceNormalRight = new Cartesian3_default();
  const instanceNormalUp = new Cartesian3_default();
  const instanceNormalForward = new Cartesian3_default();
  const instanceRotation = new Matrix3_default();
  const instanceQuaternion = new Quaternion_default();
  const instanceQuaternionArray = new Array(4);
  const instanceScale = new Cartesian3_default();
  const instanceScaleArray = new Array(3);
  const instanceTransform = new Matrix4_default();
  if (!defined_default(rtcCenter)) {
    const positionBoundingSphere = BoundingSphere_default.fromPoints(instancePositions);
    for (i2 = 0; i2 < instancePositions.length; i2++) {
      Cartesian3_default.subtract(
        instancePositions[i2],
        positionBoundingSphere.center,
        positionScratch8
      );
      translationTypedArray[3 * i2 + 0] = positionScratch8.x;
      translationTypedArray[3 * i2 + 1] = positionScratch8.y;
      translationTypedArray[3 * i2 + 2] = positionScratch8.z;
    }
    components.transform = Matrix4_default.fromTranslation(
      positionBoundingSphere.center
    );
  }
  for (i2 = 0; i2 < instancesLength; i2++) {
    instancePosition = Cartesian3_default.clone(instancePositions[i2]);
    if (defined_default(rtcCenter)) {
      Cartesian3_default.add(
        instancePosition,
        Cartesian3_default.unpack(rtcCenter),
        instancePosition
      );
    }
    if (hasRotation) {
      processRotation(
        featureTable,
        eastNorthUp,
        i2,
        instanceQuaternion,
        instancePosition,
        instanceNormalUp,
        instanceNormalRight,
        instanceNormalForward,
        instanceRotation,
        instanceTransform
      );
      Quaternion_default.pack(instanceQuaternion, instanceQuaternionArray, 0);
      rotationTypedArray[4 * i2 + 0] = instanceQuaternionArray[0];
      rotationTypedArray[4 * i2 + 1] = instanceQuaternionArray[1];
      rotationTypedArray[4 * i2 + 2] = instanceQuaternionArray[2];
      rotationTypedArray[4 * i2 + 3] = instanceQuaternionArray[3];
    }
    if (hasScale) {
      processScale(featureTable, i2, instanceScale);
      Cartesian3_default.pack(instanceScale, instanceScaleArray, 0);
      scaleTypedArray[3 * i2 + 0] = instanceScaleArray[0];
      scaleTypedArray[3 * i2 + 1] = instanceScaleArray[1];
      scaleTypedArray[3 * i2 + 2] = instanceScaleArray[2];
    }
    let batchId = featureTable.getProperty(
      "BATCH_ID",
      ComponentDatatype_default.UNSIGNED_SHORT,
      1,
      i2
    );
    if (!defined_default(batchId)) {
      batchId = i2;
    }
    featureIdArray[i2] = batchId;
  }
  const instances = new Instances3();
  instances.transformInWorldSpace = true;
  const translationAttribute = new Attribute4();
  translationAttribute.name = "Instance Translation";
  translationAttribute.semantic = InstanceAttributeSemantic_default.TRANSLATION;
  translationAttribute.componentDatatype = ComponentDatatype_default.FLOAT;
  translationAttribute.type = AttributeType_default.VEC3;
  translationAttribute.count = instancesLength;
  translationAttribute.packedTypedArray = translationTypedArray;
  instances.attributes.push(translationAttribute);
  if (hasRotation) {
    const rotationAttribute = new Attribute4();
    rotationAttribute.name = "Instance Rotation";
    rotationAttribute.semantic = InstanceAttributeSemantic_default.ROTATION;
    rotationAttribute.componentDatatype = ComponentDatatype_default.FLOAT;
    rotationAttribute.type = AttributeType_default.VEC4;
    rotationAttribute.count = instancesLength;
    rotationAttribute.packedTypedArray = rotationTypedArray;
    instances.attributes.push(rotationAttribute);
  }
  if (hasScale) {
    const scaleAttribute = new Attribute4();
    scaleAttribute.name = "Instance Scale";
    scaleAttribute.semantic = InstanceAttributeSemantic_default.SCALE;
    scaleAttribute.componentDatatype = ComponentDatatype_default.FLOAT;
    scaleAttribute.type = AttributeType_default.VEC3;
    scaleAttribute.count = instancesLength;
    scaleAttribute.packedTypedArray = scaleTypedArray;
    instances.attributes.push(scaleAttribute);
  }
  const featureIdAttribute = new Attribute4();
  featureIdAttribute.name = "Instance Feature ID";
  featureIdAttribute.setIndex = 0;
  featureIdAttribute.semantic = InstanceAttributeSemantic_default.FEATURE_ID;
  featureIdAttribute.componentDatatype = ComponentDatatype_default.FLOAT;
  featureIdAttribute.type = AttributeType_default.SCALAR;
  featureIdAttribute.count = instancesLength;
  featureIdAttribute.packedTypedArray = featureIdArray;
  instances.attributes.push(featureIdAttribute);
  const featureIdInstanceAttribute = new FeatureIdAttribute5();
  featureIdInstanceAttribute.propertyTableId = 0;
  featureIdInstanceAttribute.setIndex = 0;
  featureIdInstanceAttribute.positionalLabel = "instanceFeatureId_0";
  instances.featureIds.push(featureIdInstanceAttribute);
  for (i2 = 0; i2 < components.nodes.length; i2++) {
    const node = components.nodes[i2];
    if (node.primitives.length > 0) {
      node.instances = instances;
    }
  }
}
function getPositions(featureTable, instancesLength) {
  if (featureTable.hasProperty("POSITION")) {
    return featureTable.getPropertyArray(
      "POSITION",
      ComponentDatatype_default.FLOAT,
      3
    );
  } else if (featureTable.hasProperty("POSITION_QUANTIZED")) {
    const quantizedPositions = featureTable.getPropertyArray(
      "POSITION_QUANTIZED",
      ComponentDatatype_default.UNSIGNED_SHORT,
      3
    );
    const quantizedVolumeOffset = featureTable.getGlobalProperty(
      "QUANTIZED_VOLUME_OFFSET",
      ComponentDatatype_default.FLOAT,
      3
    );
    if (!defined_default(quantizedVolumeOffset)) {
      throw new RuntimeError_default(
        "Global property: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions."
      );
    }
    const quantizedVolumeScale = featureTable.getGlobalProperty(
      "QUANTIZED_VOLUME_SCALE",
      ComponentDatatype_default.FLOAT,
      3
    );
    if (!defined_default(quantizedVolumeScale)) {
      throw new RuntimeError_default(
        "Global property: QUANTIZED_VOLUME_SCALE must be defined for quantized positions."
      );
    }
    for (let i2 = 0; i2 < quantizedPositions.length / 3; i2++) {
      const quantizedPosition = quantizedPositions[i2];
      for (let j = 0; j < 3; j++) {
        quantizedPositions[3 * i2 + j] = quantizedPosition[j] / 65535 * quantizedVolumeScale[j] + quantizedVolumeOffset[j];
      }
    }
    return quantizedPositions;
  } else {
    throw new RuntimeError_default(
      "Either POSITION or POSITION_QUANTIZED must be defined for each instance."
    );
  }
}
var propertyScratch22 = new Array(4);
function processRotation(featureTable, eastNorthUp, i2, instanceQuaternion, instancePosition, instanceNormalUp, instanceNormalRight, instanceNormalForward, instanceRotation, instanceTransform) {
  const normalUp = featureTable.getProperty(
    "NORMAL_UP",
    ComponentDatatype_default.FLOAT,
    3,
    i2,
    propertyScratch12
  );
  const normalRight = featureTable.getProperty(
    "NORMAL_RIGHT",
    ComponentDatatype_default.FLOAT,
    3,
    i2,
    propertyScratch22
  );
  let hasCustomOrientation = false;
  if (defined_default(normalUp)) {
    if (!defined_default(normalRight)) {
      throw new RuntimeError_default(
        "To define a custom orientation, both NORMAL_UP and NORMAL_RIGHT must be defined."
      );
    }
    Cartesian3_default.unpack(normalUp, 0, instanceNormalUp);
    Cartesian3_default.unpack(normalRight, 0, instanceNormalRight);
    hasCustomOrientation = true;
  } else {
    const octNormalUp = featureTable.getProperty(
      "NORMAL_UP_OCT32P",
      ComponentDatatype_default.UNSIGNED_SHORT,
      2,
      i2,
      propertyScratch12
    );
    const octNormalRight = featureTable.getProperty(
      "NORMAL_RIGHT_OCT32P",
      ComponentDatatype_default.UNSIGNED_SHORT,
      2,
      i2,
      propertyScratch22
    );
    if (defined_default(octNormalUp)) {
      if (!defined_default(octNormalRight)) {
        throw new RuntimeError_default(
          "To define a custom orientation with oct-encoded vectors, both NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P must be defined."
        );
      }
      AttributeCompression_default.octDecodeInRange(
        octNormalUp[0],
        octNormalUp[1],
        65535,
        instanceNormalUp
      );
      AttributeCompression_default.octDecodeInRange(
        octNormalRight[0],
        octNormalRight[1],
        65535,
        instanceNormalRight
      );
      hasCustomOrientation = true;
    } else if (eastNorthUp) {
      Transforms_default.eastNorthUpToFixedFrame(
        instancePosition,
        Ellipsoid_default.WGS84,
        instanceTransform
      );
      Matrix4_default.getMatrix3(instanceTransform, instanceRotation);
    } else {
      Matrix3_default.clone(Matrix3_default.IDENTITY, instanceRotation);
    }
  }
  if (hasCustomOrientation) {
    Cartesian3_default.cross(
      instanceNormalRight,
      instanceNormalUp,
      instanceNormalForward
    );
    Cartesian3_default.normalize(instanceNormalForward, instanceNormalForward);
    Matrix3_default.setColumn(
      instanceRotation,
      0,
      instanceNormalRight,
      instanceRotation
    );
    Matrix3_default.setColumn(instanceRotation, 1, instanceNormalUp, instanceRotation);
    Matrix3_default.setColumn(
      instanceRotation,
      2,
      instanceNormalForward,
      instanceRotation
    );
  }
  Quaternion_default.fromRotationMatrix(instanceRotation, instanceQuaternion);
}
function processScale(featureTable, i2, instanceScale) {
  instanceScale = Cartesian3_default.fromElements(1, 1, 1, instanceScale);
  const scale = featureTable.getProperty(
    "SCALE",
    ComponentDatatype_default.FLOAT,
    1,
    i2
  );
  if (defined_default(scale)) {
    Cartesian3_default.multiplyByScalar(instanceScale, scale, instanceScale);
  }
  const nonUniformScale = featureTable.getProperty(
    "SCALE_NON_UNIFORM",
    ComponentDatatype_default.FLOAT,
    3,
    i2,
    propertyScratch12
  );
  if (defined_default(nonUniformScale)) {
    instanceScale.x *= nonUniformScale[0];
    instanceScale.y *= nonUniformScale[1];
    instanceScale.z *= nonUniformScale[2];
  }
}
I3dmLoader.prototype.unload = function() {
  if (defined_default(this._gltfLoader)) {
    this._gltfLoader.unload();
  }
  this._components = void 0;
};
var I3dmLoader_default = I3dmLoader;

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimental.js
function ModelExperimental(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.loader", options.loader);
  Check_default.typeOf.object("options.resource", options.resource);
  this._loader = options.loader;
  this._resource = options.resource;
  this.type = defaultValue_default(options.type, ModelExperimentalType_default.GLTF);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._modelMatrix = Matrix4_default.clone(this.modelMatrix);
  this._scale = defaultValue_default(options.scale, 1);
  this._minimumPixelSize = defaultValue_default(options.minimumPixelSize, 0);
  this._maximumScale = options.maximumScale;
  this._clampedScale = defined_default(this._maximumScale) ? Math.min(this._scale, this._maximumScale) : this._scale;
  this._computedScale = this._clampedScale;
  this._updateModelMatrix = false;
  this.referenceMatrix = void 0;
  this._iblReferenceFrameMatrix = Matrix3_default.clone(Matrix3_default.IDENTITY);
  this._resourcesLoaded = false;
  this._drawCommandsBuilt = false;
  this._ready = false;
  this._readyPromise = defer_default();
  this._customShader = options.customShader;
  this._content = options.content;
  this._texturesLoaded = false;
  this._defaultTexture = void 0;
  this._activeAnimations = new ModelExperimentalAnimationCollection_default(this);
  this._clampAnimations = defaultValue_default(options.clampAnimations, true);
  const color = options.color;
  this._color = defaultValue_default(color) ? Color_default.clone(color) : void 0;
  this._colorBlendMode = defaultValue_default(
    options.colorBlendMode,
    ColorBlendMode_default.HIGHLIGHT
  );
  this._colorBlendAmount = defaultValue_default(options.colorBlendAmount, 0.5);
  this._cull = defaultValue_default(options.cull, true);
  this._opaquePass = defaultValue_default(options.opaquePass, Pass_default.OPAQUE);
  this._allowPicking = defaultValue_default(options.allowPicking, true);
  this._show = defaultValue_default(options.show, true);
  this._style = void 0;
  let featureIdLabel = defaultValue_default(options.featureIdLabel, "featureId_0");
  if (typeof featureIdLabel === "number") {
    featureIdLabel = `featureId_${featureIdLabel}`;
  }
  this._featureIdLabel = featureIdLabel;
  let instanceFeatureIdLabel = defaultValue_default(
    options.instanceFeatureIdLabel,
    "instanceFeatureId_0"
  );
  if (typeof instanceFeatureIdLabel === "number") {
    instanceFeatureIdLabel = `instanceFeatureId_${instanceFeatureIdLabel}`;
  }
  this._instanceFeatureIdLabel = instanceFeatureIdLabel;
  this._featureTables = [];
  this._featureTableId = void 0;
  this._featureTableIdDirty = true;
  this._resources = [];
  this._boundingSphere = new BoundingSphere_default();
  this._initialRadius = void 0;
  const pointCloudShading = new PointCloudShading_default(options.pointCloudShading);
  this._attenuation = pointCloudShading.attenuation;
  this._pointCloudShading = pointCloudShading;
  const clippingPlanes = options.clippingPlanes;
  if (defined_default(clippingPlanes) && clippingPlanes.owner === void 0) {
    ClippingPlaneCollection_default.setOwner(clippingPlanes, this, "_clippingPlanes");
  } else {
    this._clippingPlanes = clippingPlanes;
  }
  this._clippingPlanesState = 0;
  this._clippingPlanesMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._lightColor = Cartesian3_default.clone(options.lightColor);
  this._imageBasedLighting = defined_default(options.imageBasedLighting) ? options.imageBasedLighting : new ImageBasedLighting();
  this._shouldDestroyImageBasedLighting = !defined_default(options.imageBasedLighting);
  this._backFaceCulling = defaultValue_default(options.backFaceCulling, true);
  this._backFaceCullingDirty = false;
  this._shadows = defaultValue_default(options.shadows, ShadowMode_default.ENABLED);
  this._shadowsDirty = false;
  this._debugShowBoundingVolumeDirty = false;
  this._debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this._debugWireframe = defaultValue_default(options.debugWireframe, false);
  this._showCreditsOnScreen = defaultValue_default(options.showCreditsOnScreen, false);
  this._splitDirection = defaultValue_default(
    options.splitDirection,
    SplitDirection_default.NONE
  );
  initialize18(this);
}
function createModelFeatureTables(model, structuralMetadata) {
  const featureTables = model._featureTables;
  const propertyTables = structuralMetadata.propertyTables;
  for (let i2 = 0; i2 < propertyTables.length; i2++) {
    const propertyTable = propertyTables[i2];
    const modelFeatureTable = new ModelFeatureTable({
      model,
      propertyTable
    });
    featureTables.push(modelFeatureTable);
  }
  return featureTables;
}
function selectFeatureTableId(components, model) {
  const featureIdLabel = model._featureIdLabel;
  const instanceFeatureIdLabel = model._instanceFeatureIdLabel;
  let i2, j;
  let featureIdAttribute;
  let node;
  for (i2 = 0; i2 < components.nodes.length; i2++) {
    node = components.nodes[i2];
    if (defined_default(node.instances)) {
      featureIdAttribute = ModelExperimentalUtility.getFeatureIdsByLabel(
        node.instances.featureIds,
        instanceFeatureIdLabel
      );
      if (defined_default(featureIdAttribute) && defined_default(featureIdAttribute.propertyTableId)) {
        return featureIdAttribute.propertyTableId;
      }
    }
  }
  for (i2 = 0; i2 < components.nodes.length; i2++) {
    node = components.nodes[i2];
    for (j = 0; j < node.primitives.length; j++) {
      const primitive = node.primitives[j];
      const featureIds = ModelExperimentalUtility.getFeatureIdsByLabel(
        primitive.featureIds,
        featureIdLabel
      );
      if (defined_default(featureIds)) {
        return featureIds.propertyTableId;
      }
    }
  }
}
function initialize18(model) {
  const loader = model._loader;
  const resource = model._resource;
  loader.load();
  loader.promise.then(function(loader2) {
    const components = loader2.components;
    const structuralMetadata = components.structuralMetadata;
    if (defined_default(structuralMetadata) && structuralMetadata.propertyTableCount > 0) {
      createModelFeatureTables(model, structuralMetadata);
    }
    model._sceneGraph = new ModelExperimentalSceneGraph({
      model,
      modelComponents: components
    });
    model._resourcesLoaded = true;
  }).catch(
    ModelExperimentalUtility.getFailedLoadFunction(model, "model", resource)
  );
  const texturesLoadedPromise = defaultValue_default(
    loader.texturesLoadedPromise,
    Promise.resolve()
  );
  texturesLoadedPromise.then(function() {
    model._texturesLoaded = true;
  }).catch(
    ModelExperimentalUtility.getFailedLoadFunction(model, "model", resource)
  );
}
Object.defineProperties(ModelExperimental.prototype, {
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  loader: {
    get: function() {
      return this._loader;
    }
  },
  activeAnimations: {
    get: function() {
      return this._activeAnimations;
    }
  },
  clampAnimations: {
    get: function() {
      return this._clampAnimations;
    },
    set: function(value) {
      this._clampAnimations = value;
    }
  },
  cull: {
    get: function() {
      return this._cull;
    }
  },
  opaquePass: {
    get: function() {
      return this._opaquePass;
    }
  },
  pointCloudShading: {
    get: function() {
      return this._pointCloudShading;
    },
    set: function(value) {
      Check_default.defined("pointCloudShading", value);
      if (value !== this._pointCloudShading) {
        this.resetDrawCommands();
      }
      this._pointCloudShading = value;
    }
  },
  customShader: {
    get: function() {
      return this._customShader;
    },
    set: function(value) {
      if (value !== this._customShader) {
        this.resetDrawCommands();
      }
      this._customShader = value;
    }
  },
  sceneGraph: {
    get: function() {
      return this._sceneGraph;
    }
  },
  content: {
    get: function() {
      return this._content;
    }
  },
  structuralMetadata: {
    get: function() {
      return this._sceneGraph.components.structuralMetadata;
    }
  },
  featureTableId: {
    get: function() {
      return this._featureTableId;
    },
    set: function(value) {
      this._featureTableId = value;
    }
  },
  featureTables: {
    get: function() {
      return this._featureTables;
    },
    set: function(value) {
      this._featureTables = value;
    }
  },
  allowPicking: {
    get: function() {
      return this._allowPicking;
    }
  },
  style: {
    get: function() {
      return this._style;
    },
    set: function(value) {
      if (value !== this._style) {
        this.applyStyle(value);
      }
      this._style = value;
    }
  },
  color: {
    get: function() {
      return this._color;
    },
    set: function(value) {
      if (!Color_default.equals(this._color, value)) {
        this.resetDrawCommands();
      }
      this._color = Color_default.clone(value, this._color);
    }
  },
  colorBlendMode: {
    get: function() {
      return this._colorBlendMode;
    },
    set: function(value) {
      this._colorBlendMode = value;
    }
  },
  colorBlendAmount: {
    get: function() {
      return this._colorBlendAmount;
    },
    set: function(value) {
      this._colorBlendAmount = value;
    }
  },
  boundingSphere: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The model is not loaded. Use ModelExperimental.readyPromise or wait for ModelExperimental.ready to be true."
        );
      }
      return this._boundingSphere;
    }
  },
  debugShowBoundingVolume: {
    get: function() {
      return this._debugShowBoundingVolume;
    },
    set: function(value) {
      if (this._debugShowBoundingVolume !== value) {
        this._debugShowBoundingVolumeDirty = true;
      }
      this._debugShowBoundingVolume = value;
    }
  },
  debugWireframe: {
    get: function() {
      return this._debugWireframe;
    },
    set: function(value) {
      if (this._debugWireframe !== value) {
        this.resetDrawCommands();
      }
      this._debugWireframe = value;
    }
  },
  show: {
    get: function() {
      return this._show;
    },
    set: function(value) {
      this._show = value;
    }
  },
  featureIdLabel: {
    get: function() {
      return this._featureIdLabel;
    },
    set: function(value) {
      if (typeof value === "number") {
        value = `featureId_${value}`;
      }
      Check_default.typeOf.string("value", value);
      if (value !== this._featureIdLabel) {
        this._featureTableIdDirty = true;
      }
      this._featureIdLabel = value;
    }
  },
  instanceFeatureIdLabel: {
    get: function() {
      return this._instanceFeatureIdLabel;
    },
    set: function(value) {
      if (typeof value === "number") {
        value = `instanceFeatureId_${value}`;
      }
      Check_default.typeOf.string("value", value);
      if (value !== this._instanceFeatureIdLabel) {
        this._featureTableIdDirty = true;
      }
      this._instanceFeatureIdLabel = value;
    }
  },
  clippingPlanes: {
    get: function() {
      return this._clippingPlanes;
    },
    set: function(value) {
      if (value !== this._clippingPlanes) {
        ClippingPlaneCollection_default.setOwner(value, this, "_clippingPlanes");
        this.resetDrawCommands();
      }
    }
  },
  lightColor: {
    get: function() {
      return this._lightColor;
    },
    set: function(value) {
      if (defined_default(value) !== defined_default(this._lightColor)) {
        this.resetDrawCommands();
      }
      this._lightColor = Cartesian3_default.clone(value, this._lightColor);
    }
  },
  imageBasedLighting: {
    get: function() {
      return this._imageBasedLighting;
    },
    set: function(value) {
      Check_default.typeOf.object("imageBasedLighting", this._imageBasedLighting);
      if (value !== this._imageBasedLighting) {
        if (this._shouldDestroyImageBasedLighting && !this._imageBasedLighting.isDestroyed()) {
          this._imageBasedLighting.destroy();
        }
        this._imageBasedLighting = value;
        this._shouldDestroyImageBasedLighting = false;
        this.resetDrawCommands();
      }
    }
  },
  backFaceCulling: {
    get: function() {
      return this._backFaceCulling;
    },
    set: function(value) {
      if (value !== this._backFaceCulling) {
        this._backFaceCullingDirty = true;
      }
      this._backFaceCulling = value;
    }
  },
  scale: {
    get: function() {
      return this._scale;
    },
    set: function(value) {
      if (value !== this._scale) {
        this._updateModelMatrix = true;
      }
      this._scale = value;
    }
  },
  computedScale: {
    get: function() {
      return this._computedScale;
    }
  },
  minimumPixelSize: {
    get: function() {
      return this._minimumPixelSize;
    },
    set: function(value) {
      if (value !== this._minimumPixelSize) {
        this._updateModelMatrix = true;
      }
      this._minimumPixelSize = value;
    }
  },
  maximumScale: {
    get: function() {
      return this._maximumScale;
    },
    set: function(value) {
      if (value !== this._maximumScale) {
        this._updateModelMatrix = true;
      }
      this._maximumScale = value;
    }
  },
  shadows: {
    get: function() {
      return this._shadows;
    },
    set: function(value) {
      if (value !== this._shadows) {
        this._shadowsDirty = true;
      }
      this._shadows = value;
    }
  },
  showCreditsOnScreen: {
    get: function() {
      return this._showCreditsOnScreen;
    },
    set: function(value) {
      this._showCreditsOnScreen = value;
    }
  },
  splitDirection: {
    get: function() {
      return this._splitDirection;
    },
    set: function(value) {
      if (this._splitDirection !== value) {
        this.resetDrawCommands();
      }
      this._splitDirection = value;
    }
  }
});
ModelExperimental.prototype.resetDrawCommands = function() {
  if (!this._drawCommandsBuilt) {
    return;
  }
  this.destroyResources();
  this._drawCommandsBuilt = false;
};
var scratchIBLReferenceFrameMatrix42 = new Matrix4_default();
var scratchIBLReferenceFrameMatrix32 = new Matrix3_default();
var scratchClippingPlanesMatrix3 = new Matrix4_default();
ModelExperimental.prototype.update = function(frameState) {
  if (!this._resourcesLoaded || !this._texturesLoaded) {
    this._loader.process(frameState);
  }
  if (defined_default(this._customShader)) {
    this._customShader.update(frameState);
  }
  if (this.pointCloudShading.attenuation !== this._attenuation) {
    this.resetDrawCommands();
    this._attenuation = this.pointCloudShading.attenuation;
  }
  const context = frameState.context;
  const referenceMatrix = defaultValue_default(this.referenceMatrix, this.modelMatrix);
  this._imageBasedLighting.update(frameState);
  if (this._imageBasedLighting.useSphericalHarmonicCoefficients || this._imageBasedLighting.useSpecularEnvironmentMaps) {
    let iblReferenceFrameMatrix3 = scratchIBLReferenceFrameMatrix32;
    let iblReferenceFrameMatrix4 = scratchIBLReferenceFrameMatrix42;
    iblReferenceFrameMatrix4 = Matrix4_default.multiply(
      context.uniformState.view3D,
      referenceMatrix,
      iblReferenceFrameMatrix4
    );
    iblReferenceFrameMatrix3 = Matrix4_default.getMatrix3(
      iblReferenceFrameMatrix4,
      iblReferenceFrameMatrix3
    );
    iblReferenceFrameMatrix3 = Matrix3_default.getRotation(
      iblReferenceFrameMatrix3,
      iblReferenceFrameMatrix3
    );
    this._iblReferenceFrameMatrix = Matrix3_default.transpose(
      iblReferenceFrameMatrix3,
      this._iblReferenceFrameMatrix
    );
  }
  if (this._imageBasedLighting.shouldRegenerateShaders) {
    this.resetDrawCommands();
  }
  let currentClippingPlanesState = 0;
  if (this.isClippingEnabled()) {
    if (this._clippingPlanes.owner === this) {
      this._clippingPlanes.update(frameState);
    }
    let clippingPlanesMatrix = scratchClippingPlanesMatrix3;
    clippingPlanesMatrix = Matrix4_default.multiply(
      context.uniformState.view3D,
      referenceMatrix,
      clippingPlanesMatrix
    );
    clippingPlanesMatrix = Matrix4_default.multiply(
      clippingPlanesMatrix,
      this._clippingPlanes.modelMatrix,
      clippingPlanesMatrix
    );
    this._clippingPlanesMatrix = Matrix4_default.inverseTranspose(
      clippingPlanesMatrix,
      this._clippingPlanesMatrix
    );
    currentClippingPlanesState = this._clippingPlanes.clippingPlanesState;
  }
  if (currentClippingPlanesState !== this._clippingPlanesState) {
    this.resetDrawCommands();
    this._clippingPlanesState = currentClippingPlanesState;
  }
  this._defaultTexture = context.defaultTexture;
  if (!this._resourcesLoaded) {
    return;
  }
  if (this._featureTableIdDirty) {
    updateFeatureTableId(this);
    this._featureTableIdDirty = false;
  }
  const featureTables = this._featureTables;
  for (let i2 = 0; i2 < featureTables.length; i2++) {
    featureTables[i2].update(frameState);
    if (featureTables[i2].styleCommandsNeededDirty) {
      this.resetDrawCommands();
    }
  }
  if (!this._drawCommandsBuilt) {
    this._sceneGraph.buildDrawCommands(frameState);
    this._drawCommandsBuilt = true;
    const model = this;
    if (!model._ready) {
      frameState.afterRender.push(function() {
        model._ready = true;
        model._readyPromise.resolve(model);
      });
      return;
    }
  }
  if (this._debugShowBoundingVolumeDirty) {
    updateShowBoundingVolume3(this._sceneGraph, this._debugShowBoundingVolume);
    this._debugShowBoundingVolumeDirty = false;
  }
  if (!Matrix4_default.equals(this.modelMatrix, this._modelMatrix)) {
    this._updateModelMatrix = true;
    this._modelMatrix = Matrix4_default.clone(this.modelMatrix, this._modelMatrix);
    this._boundingSphere = BoundingSphere_default.transform(
      this._sceneGraph.boundingSphere,
      this.modelMatrix,
      this._boundingSphere
    );
  }
  if (this._updateModelMatrix || this._minimumPixelSize !== 0) {
    this._clampedScale = defined_default(this._maximumScale) ? Math.min(this._scale, this._maximumScale) : this._scale;
    this._boundingSphere.radius = this._initialRadius * this._clampedScale;
    this._computedScale = getScale2(this, frameState);
    this._sceneGraph.updateModelMatrix();
    this._updateModelMatrix = false;
  }
  if (this._backFaceCullingDirty) {
    this.sceneGraph.updateBackFaceCulling(this._backFaceCulling);
    this._backFaceCullingDirty = false;
  }
  if (this._shadowsDirty) {
    this.sceneGraph.updateShadows(this._shadows);
    this._shadowsDirty = false;
  }
  const updateForAnimations = this._activeAnimations.update(frameState);
  this._sceneGraph.update(frameState, updateForAnimations);
  if (this._show && this._computedScale !== 0) {
    const asset = this._sceneGraph.components.asset;
    const credits = asset.credits;
    const length3 = credits.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const credit = credits[i2];
      credit.showOnScreen = this._showCreditsOnScreen;
      frameState.creditDisplay.addCredit(credit);
    }
    const drawCommands = this._sceneGraph.getDrawCommands();
    frameState.commandList.push.apply(frameState.commandList, drawCommands);
  }
};
function updateFeatureTableId(model) {
  const components = model._sceneGraph.components;
  const structuralMetadata = components.structuralMetadata;
  if (defined_default(structuralMetadata) && structuralMetadata.propertyTableCount > 0) {
    model.featureTableId = selectFeatureTableId(components, model);
    model.applyStyle(model._style);
  }
}
var scratchBoundingSphere5 = new BoundingSphere_default();
function scaleInPixels2(positionWC2, radius, frameState) {
  scratchBoundingSphere5.center = positionWC2;
  scratchBoundingSphere5.radius = radius;
  return frameState.camera.getPixelSize(
    scratchBoundingSphere5,
    frameState.context.drawingBufferWidth,
    frameState.context.drawingBufferHeight
  );
}
var scratchPosition12 = new Cartesian3_default();
function getScale2(model, frameState) {
  let scale = model.scale;
  if (model.minimumPixelSize !== 0) {
    const context = frameState.context;
    const maxPixelSize = Math.max(
      context.drawingBufferWidth,
      context.drawingBufferHeight
    );
    const m = model.modelMatrix;
    scratchPosition12.x = m[12];
    scratchPosition12.y = m[13];
    scratchPosition12.z = m[14];
    const radius = model.boundingSphere.radius;
    const metersPerPixel = scaleInPixels2(scratchPosition12, radius, frameState);
    const pixelsPerMeter = 1 / metersPerPixel;
    const diameterInPixels = Math.min(
      pixelsPerMeter * (2 * radius),
      maxPixelSize
    );
    if (diameterInPixels < model.minimumPixelSize) {
      scale = model.minimumPixelSize * metersPerPixel / (2 * model._initialRadius);
    }
  }
  return defined_default(model.maximumScale) ? Math.min(model.maximumScale, scale) : scale;
}
ModelExperimental.prototype.isClippingEnabled = function() {
  const clippingPlanes = this._clippingPlanes;
  return defined_default(clippingPlanes) && clippingPlanes.enabled && clippingPlanes.length !== 0;
};
ModelExperimental.prototype.isDestroyed = function() {
  return false;
};
ModelExperimental.prototype.destroy = function() {
  const loader = this._loader;
  if (defined_default(loader)) {
    loader.destroy();
  }
  const featureTables = this._featureTables;
  if (defined_default(featureTables)) {
    for (let i2 = 0; i2 < featureTables.length; i2++) {
      featureTables[i2].destroy();
    }
  }
  this.destroyResources();
  const clippingPlaneCollection = this._clippingPlanes;
  if (defined_default(clippingPlaneCollection) && !clippingPlaneCollection.isDestroyed() && clippingPlaneCollection.owner === this) {
    clippingPlaneCollection.destroy();
  }
  this._clippingPlanes = void 0;
  if (this._shouldDestroyImageBasedLighting && !this._imageBasedLighting.isDestroyed()) {
    this._imageBasedLighting.destroy();
  }
  this._imageBasedLighting = void 0;
  destroyObject_default(this);
};
ModelExperimental.prototype.destroyResources = function() {
  const resources = this._resources;
  for (let i2 = 0; i2 < resources.length; i2++) {
    resources[i2].destroy();
  }
  this._resources = [];
};
ModelExperimental.fromGltf = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.gltf", options.gltf);
  const loaderOptions = {
    releaseGltfJson: options.releaseGltfJson,
    incrementallyLoadTextures: options.incrementallyLoadTextures,
    upAxis: options.upAxis,
    forwardAxis: options.forwardAxis
  };
  const gltf = options.gltf;
  const basePath = defaultValue_default(options.basePath, "");
  const baseResource2 = Resource_default.createIfNeeded(basePath);
  if (defined_default(gltf.asset)) {
    loaderOptions.gltfJson = gltf;
    loaderOptions.baseResource = baseResource2;
    loaderOptions.gltfResource = baseResource2;
  } else if (gltf instanceof Uint8Array) {
    loaderOptions.typedArray = gltf;
    loaderOptions.baseResource = baseResource2;
    loaderOptions.gltfResource = baseResource2;
  } else {
    loaderOptions.gltfResource = Resource_default.createIfNeeded(options.gltf);
  }
  const loader = new GltfLoader(loaderOptions);
  const is3DTiles = defined_default(options.content);
  const type = is3DTiles ? ModelExperimentalType_default.TILE_GLTF : ModelExperimentalType_default.GLTF;
  const modelOptions = makeModelOptions(loader, type, options);
  modelOptions.resource = loaderOptions.gltfResource;
  const model = new ModelExperimental(modelOptions);
  return model;
};
ModelExperimental.fromB3dm = function(options) {
  const loaderOptions = {
    b3dmResource: options.resource,
    arrayBuffer: options.arrayBuffer,
    byteOffset: options.byteOffset,
    releaseGltfJson: options.releaseGltfJson,
    incrementallyLoadTextures: options.incrementallyLoadTextures,
    upAxis: options.upAxis,
    forwardAxis: options.forwardAxis
  };
  const loader = new B3dmLoader_default(loaderOptions);
  const modelOptions = makeModelOptions(
    loader,
    ModelExperimentalType_default.TILE_B3DM,
    options
  );
  const model = new ModelExperimental(modelOptions);
  return model;
};
ModelExperimental.fromPnts = function(options) {
  const loaderOptions = {
    arrayBuffer: options.arrayBuffer,
    byteOffset: options.byteOffset
  };
  const loader = new PntsLoader(loaderOptions);
  const modelOptions = makeModelOptions(
    loader,
    ModelExperimentalType_default.TILE_PNTS,
    options
  );
  const model = new ModelExperimental(modelOptions);
  return model;
};
ModelExperimental.fromI3dm = function(options) {
  const loaderOptions = {
    i3dmResource: options.resource,
    arrayBuffer: options.arrayBuffer,
    byteOffset: options.byteOffset,
    releaseGltfJson: options.releaseGltfJson,
    incrementallyLoadTextures: options.incrementallyLoadTextures,
    upAxis: options.upAxis,
    forwardAxis: options.forwardAxis
  };
  const loader = new I3dmLoader_default(loaderOptions);
  const modelOptions = makeModelOptions(
    loader,
    ModelExperimentalType_default.TILE_I3DM,
    options
  );
  const model = new ModelExperimental(modelOptions);
  return model;
};
function updateShowBoundingVolume3(sceneGraph, debugShowBoundingVolume2) {
  const drawCommands = sceneGraph._drawCommands;
  for (let i2 = 0; i2 < drawCommands.length; i2++) {
    drawCommands[i2].debugShowBoundingVolume = debugShowBoundingVolume2;
  }
}
ModelExperimental.prototype.applyColorAndShow = function(style) {
  const hasColorStyle = defined_default(style) && defined_default(style.color);
  const hasShowStyle = defined_default(style) && defined_default(style.show);
  this._color = hasColorStyle ? style.color.evaluateColor(void 0, this._color) : Color_default.clone(Color_default.WHITE, this._color);
  this._show = hasShowStyle ? style.show.evaluate(void 0) : true;
};
ModelExperimental.prototype.applyStyle = function(style) {
  if (defined_default(this.featureTableId) && this.featureTables[this.featureTableId].featuresLength > 0) {
    const featureTable = this.featureTables[this.featureTableId];
    featureTable.applyStyle(style);
  } else {
    this.applyColorAndShow(style);
  }
  this.resetDrawCommands();
};
function makeModelOptions(loader, modelType, options) {
  return {
    loader,
    type: modelType,
    resource: options.resource,
    modelMatrix: options.modelMatrix,
    scale: options.scale,
    minimumPixelSize: options.minimumPixelSize,
    maximumScale: options.maximumScale,
    debugShowBoundingVolume: options.debugShowBoundingVolume,
    debugWireframe: options.debugWireframe,
    cull: options.cull,
    opaquePass: options.opaquePass,
    allowPicking: options.allowPicking,
    customShader: options.customShader,
    content: options.content,
    show: options.show,
    color: options.color,
    colorBlendAmount: options.colorBlendAmount,
    colorBlendMode: options.colorBlendMode,
    featureIdLabel: options.featureIdLabel,
    instanceFeatureIdLabel: options.instanceFeatureIdLabel,
    pointCloudShading: options.pointCloudShading,
    clippingPlanes: options.clippingPlanes,
    lightColor: options.lightColor,
    imageBasedLighting: options.imageBasedLighting,
    backFaceCulling: options.backFaceCulling,
    shadows: options.shadows,
    showCreditsOnScreen: options.showCreditsOnScreen,
    splitDirection: options.splitDirection
  };
}

// node_modules/cesium/Source/Scene/ModelExperimental/ModelExperimental3DTileContent.js
function ModelExperimental3DTileContent(tileset, tile, resource) {
  this._tileset = tileset;
  this._tile = tile;
  this._resource = resource;
  this._model = void 0;
  this._metadata = void 0;
  this._group = void 0;
}
Object.defineProperties(ModelExperimental3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      const model = this._model;
      const featureTables = model.featureTables;
      const featureTableId = model.featureTableId;
      if (defined_default(featureTables) && defined_default(featureTables[featureTableId])) {
        return featureTables[featureTableId].featuresLength;
      }
      return 0;
    }
  },
  pointsLength: {
    get: function() {
      return 0;
    }
  },
  trianglesLength: {
    get: function() {
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      return 0;
    }
  },
  texturesByteLength: {
    get: function() {
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      return 0;
    }
  },
  innerContents: {
    get: function() {
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._model.readyPromise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return this._resource.getUrlComponent(true);
    }
  },
  batchTable: {
    get: function() {
      const model = this._model;
      const featureTables = model.featureTables;
      const featureTableId = model.featureTableId;
      if (defined_default(featureTables) && defined_default(featureTables[featureTableId])) {
        return featureTables[featureTableId];
      }
      return void 0;
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    },
    set: function(value) {
      this._metadata = value;
    }
  },
  group: {
    get: function() {
      return this._group;
    },
    set: function(value) {
      this._group = value;
    }
  }
});
ModelExperimental3DTileContent.prototype.getFeature = function(featureId) {
  const model = this._model;
  const featureTableId = model.featureTableId;
  if (!defined_default(featureTableId)) {
    return void 0;
  }
  const featureTable = model.featureTables[featureTableId];
  return featureTable.getFeature(featureId);
};
ModelExperimental3DTileContent.prototype.hasProperty = function(featureId, name) {
  const model = this._model;
  const featureTableId = model.featureTableId;
  if (!defined_default(featureTableId)) {
    return false;
  }
  const featureTable = model.featureTables[featureTableId];
  return featureTable.hasProperty(featureId, name);
};
ModelExperimental3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
  color = enabled ? color : Color_default.WHITE;
  if (this.featuresLength === 0) {
    this._model.color = color;
  } else if (defined_default(this.batchTable)) {
    this.batchTable.setAllColor(color);
  }
};
ModelExperimental3DTileContent.prototype.applyStyle = function(style) {
  this._model.style = style;
};
ModelExperimental3DTileContent.prototype.update = function(tileset, frameState) {
  const model = this._model;
  const tile = this._tile;
  model.colorBlendAmount = tileset.colorBlendAmount;
  model.colorBlendMode = tileset.colorBlendMode;
  model.modelMatrix = tile.computedTransform;
  model.customShader = tileset.customShader;
  model.pointCloudShading = tileset.pointCloudShading;
  model.featureIdLabel = tileset.featureIdLabel;
  model.instanceFeatureIdLabel = tileset.instanceFeatureIdLabel;
  model.lightColor = tileset.lightColor;
  model.imageBasedLighting = tileset.imageBasedLighting;
  model.backFaceCulling = tileset.backFaceCulling;
  model.shadows = tileset.shadows;
  model.showCreditsOnScreen = tileset.showCreditsOnScreen;
  model.splitDirection = tileset.splitDirection;
  model.debugWireframe = tileset.debugWireframe;
  const tilesetClippingPlanes = tileset.clippingPlanes;
  model.referenceMatrix = tileset.clippingPlanesOriginMatrix;
  if (defined_default(tilesetClippingPlanes) && tile.clippingPlanesDirty) {
    model._clippingPlanes = tilesetClippingPlanes.enabled && tile._isClipped ? tilesetClippingPlanes : void 0;
  }
  if (defined_default(tilesetClippingPlanes) && defined_default(model._clippingPlanes) && model._clippingPlanes !== tilesetClippingPlanes) {
    model._clippingPlanes = tilesetClippingPlanes;
  }
  model.update(frameState);
};
ModelExperimental3DTileContent.prototype.isDestroyed = function() {
  return false;
};
ModelExperimental3DTileContent.prototype.destroy = function() {
  this._model = this._model && this._model.destroy();
  return destroyObject_default(this);
};
ModelExperimental3DTileContent.fromGltf = function(tileset, tile, resource, gltf) {
  const content = new ModelExperimental3DTileContent(tileset, tile, resource);
  const additionalOptions = {
    gltf,
    basePath: resource
  };
  const modelOptions = makeModelOptions2(
    tileset,
    tile,
    content,
    additionalOptions
  );
  content._model = ModelExperimental.fromGltf(modelOptions);
  return content;
};
ModelExperimental3DTileContent.fromB3dm = function(tileset, tile, resource, arrayBuffer, byteOffset) {
  const content = new ModelExperimental3DTileContent(tileset, tile, resource);
  const additionalOptions = {
    arrayBuffer,
    byteOffset,
    resource
  };
  const modelOptions = makeModelOptions2(
    tileset,
    tile,
    content,
    additionalOptions
  );
  content._model = ModelExperimental.fromB3dm(modelOptions);
  return content;
};
ModelExperimental3DTileContent.fromI3dm = function(tileset, tile, resource, arrayBuffer, byteOffset) {
  const content = new ModelExperimental3DTileContent(tileset, tile, resource);
  const additionalOptions = {
    arrayBuffer,
    byteOffset,
    resource
  };
  const modelOptions = makeModelOptions2(
    tileset,
    tile,
    content,
    additionalOptions
  );
  content._model = ModelExperimental.fromI3dm(modelOptions);
  return content;
};
ModelExperimental3DTileContent.fromPnts = function(tileset, tile, resource, arrayBuffer, byteOffset) {
  const content = new ModelExperimental3DTileContent(tileset, tile, resource);
  const additionalOptions = {
    arrayBuffer,
    byteOffset,
    resource
  };
  const modelOptions = makeModelOptions2(
    tileset,
    tile,
    content,
    additionalOptions
  );
  content._model = ModelExperimental.fromPnts(modelOptions);
  return content;
};
function makeModelOptions2(tileset, tile, content, additionalOptions) {
  const mainOptions = {
    cull: false,
    releaseGltfJson: true,
    opaquePass: Pass_default.CESIUM_3D_TILE,
    modelMatrix: tile.computedTransform,
    upAxis: tileset._gltfUpAxis,
    forwardAxis: Axis_default.X,
    incrementallyLoadTextures: false,
    customShader: tileset.customShader,
    content,
    show: tileset.show,
    colorBlendMode: tileset.colorBlendMode,
    colorBlendAmount: tileset.colorBlendAmount,
    lightColor: tileset.lightColor,
    imageBasedLighting: tileset.imageBasedLighting,
    featureIdLabel: tileset.featureIdLabel,
    instanceFeatureIdLabel: tileset.instanceFeatureIdLabel,
    pointCloudShading: tileset.pointCloudShading,
    clippingPlanes: tileset.clippingPlanes,
    backFaceCulling: tileset.backFaceCulling,
    shadows: tileset.shadows,
    showCreditsOnScreen: tileset.showCreditsOnScreen,
    splitDirection: tileset.splitDirection,
    debugWireframe: tileset.debugWireframe
  };
  return combine_default(additionalOptions, mainOptions);
}

// node_modules/cesium/Source/Scene/Cesium3DTileContentFactory.js
var Cesium3DTileContentFactory = {
  b3dm: function(tileset, tile, resource, arrayBuffer, byteOffset) {
    if (tileset.enableModelExperimental) {
      return ModelExperimental3DTileContent.fromB3dm(
        tileset,
        tile,
        resource,
        arrayBuffer,
        byteOffset
      );
    }
    return new Batched3DModel3DTileContent_default(
      tileset,
      tile,
      resource,
      arrayBuffer,
      byteOffset
    );
  },
  pnts: function(tileset, tile, resource, arrayBuffer, byteOffset) {
    if (tileset.enableModelExperimental) {
      return ModelExperimental3DTileContent.fromPnts(
        tileset,
        tile,
        resource,
        arrayBuffer,
        byteOffset
      );
    }
    return new PointCloud3DTileContent_default(
      tileset,
      tile,
      resource,
      arrayBuffer,
      byteOffset
    );
  },
  i3dm: function(tileset, tile, resource, arrayBuffer, byteOffset) {
    if (tileset.enableModelExperimental) {
      return ModelExperimental3DTileContent.fromI3dm(
        tileset,
        tile,
        resource,
        arrayBuffer,
        byteOffset
      );
    }
    return new Instanced3DModel3DTileContent_default(
      tileset,
      tile,
      resource,
      arrayBuffer,
      byteOffset
    );
  },
  cmpt: function(tileset, tile, resource, arrayBuffer, byteOffset) {
    return new Composite3DTileContent_default(
      tileset,
      tile,
      resource,
      arrayBuffer,
      byteOffset,
      Cesium3DTileContentFactory
    );
  },
  externalTileset: function(tileset, tile, resource, json) {
    return new Tileset3DTileContent_default(tileset, tile, resource, json);
  },
  geom: function(tileset, tile, resource, arrayBuffer, byteOffset) {
    return new Geometry3DTileContent_default(
      tileset,
      tile,
      resource,
      arrayBuffer,
      byteOffset
    );
  },
  vctr: function(tileset, tile, resource, arrayBuffer, byteOffset) {
    return new Vector3DTileContent_default(
      tileset,
      tile,
      resource,
      arrayBuffer,
      byteOffset
    );
  },
  subt: function(tileset, tile, resource, arrayBuffer, byteOffset) {
    return new Implicit3DTileContent(
      tileset,
      tile,
      resource,
      void 0,
      arrayBuffer,
      byteOffset
    );
  },
  subtreeJson: function(tileset, tile, resource, json) {
    return new Implicit3DTileContent(tileset, tile, resource, json);
  },
  glb: function(tileset, tile, resource, arrayBuffer, byteOffset) {
    const arrayBufferByteLength = arrayBuffer.byteLength;
    if (arrayBufferByteLength < 12) {
      throw new RuntimeError_default("Invalid glb content");
    }
    const dataView = new DataView(arrayBuffer, byteOffset);
    const byteLength = dataView.getUint32(8, true);
    const glb = new Uint8Array(arrayBuffer, byteOffset, byteLength);
    return ModelExperimental3DTileContent.fromGltf(
      tileset,
      tile,
      resource,
      glb
    );
  },
  gltf: function(tileset, tile, resource, json) {
    return ModelExperimental3DTileContent.fromGltf(
      tileset,
      tile,
      resource,
      json
    );
  }
};
var Cesium3DTileContentFactory_default = Cesium3DTileContentFactory;

// node_modules/cesium/Source/Scene/Cesium3DTileContentState.js
var Cesium3DTileContentState = {
  UNLOADED: 0,
  LOADING: 1,
  PROCESSING: 2,
  READY: 3,
  EXPIRED: 4,
  FAILED: 5
};
var Cesium3DTileContentState_default = Object.freeze(Cesium3DTileContentState);

// node_modules/cesium/Source/Scene/Cesium3DTileContentType.js
var Cesium3DTileContentType = {
  BATCHED_3D_MODEL: "b3dm",
  INSTANCED_3D_MODEL: "i3dm",
  COMPOSITE: "cmpt",
  POINT_CLOUD: "pnts",
  VECTOR: "vctr",
  GEOMETRY: "geom",
  GLTF: "gltf",
  GLTF_BINARY: "glb",
  IMPLICIT_SUBTREE: "subt",
  IMPLICIT_SUBTREE_JSON: "subtreeJson",
  EXTERNAL_TILESET: "externalTileset",
  MULTIPLE_CONTENT: "multipleContent"
};
Cesium3DTileContentType.isBinaryFormat = function(contentType) {
  switch (contentType) {
    case Cesium3DTileContentType.BATCHED_3D_MODEL:
    case Cesium3DTileContentType.INSTANCED_3D_MODEL:
    case Cesium3DTileContentType.COMPOSITE:
    case Cesium3DTileContentType.POINT_CLOUD:
    case Cesium3DTileContentType.VECTOR:
    case Cesium3DTileContentType.GEOMETRY:
    case Cesium3DTileContentType.IMPLICIT_SUBTREE:
    case Cesium3DTileContentType.GLTF_BINARY:
      return true;
    default:
      return false;
  }
};
var Cesium3DTileContentType_default = Object.freeze(Cesium3DTileContentType);

// node_modules/cesium/Source/Scene/Cesium3DTileOptimizationHint.js
var Cesium3DTileOptimizationHint = {
  NOT_COMPUTED: -1,
  USE_OPTIMIZATION: 1,
  SKIP_OPTIMIZATION: 0
};
var Cesium3DTileOptimizationHint_default = Object.freeze(Cesium3DTileOptimizationHint);

// node_modules/cesium/Source/Scene/Cesium3DTilesetMostDetailedTraversal.js
function Cesium3DTilesetMostDetailedTraversal() {
}
var traversal = {
  stack: new ManagedArray_default(),
  stackMaximumLength: 0
};
Cesium3DTilesetMostDetailedTraversal.selectTiles = function(tileset, frameState) {
  tileset._selectedTiles.length = 0;
  tileset._requestedTiles.length = 0;
  tileset._hasMixedContent = false;
  let ready = true;
  const root = tileset.root;
  root.updateVisibility(frameState);
  if (!isVisible(root)) {
    return ready;
  }
  const stack = traversal.stack;
  stack.push(tileset.root);
  while (stack.length > 0) {
    traversal.stackMaximumLength = Math.max(
      traversal.stackMaximumLength,
      stack.length
    );
    const tile = stack.pop();
    const add2 = tile.refine === Cesium3DTileRefine_default.ADD;
    const replace = tile.refine === Cesium3DTileRefine_default.REPLACE;
    const traverse = canTraverse(tileset, tile);
    if (traverse) {
      updateAndPushChildren(tileset, tile, stack, frameState);
    }
    if (add2 || replace && !traverse) {
      loadTile(tileset, tile);
      touchTile(tileset, tile, frameState);
      selectDesiredTile(tileset, tile, frameState);
      if (!hasEmptyContent(tile) && !tile.contentAvailable) {
        ready = false;
      }
    }
    visitTile(tileset);
  }
  traversal.stack.trim(traversal.stackMaximumLength);
  return ready;
};
function isVisible(tile) {
  return tile._visible && tile._inRequestVolume;
}
function hasEmptyContent(tile) {
  return tile.hasEmptyContent || tile.hasTilesetContent || tile.hasImplicitContent;
}
function hasUnloadedContent(tile) {
  return !hasEmptyContent(tile) && tile.contentUnloaded;
}
function canTraverse(tileset, tile) {
  if (tile.children.length === 0) {
    return false;
  }
  if (tile.hasTilesetContent || tile.hasImplicitContent) {
    return !tile.contentExpired;
  }
  if (tile.hasEmptyContent) {
    return true;
  }
  return true;
}
function updateAndPushChildren(tileset, tile, stack, frameState) {
  const children = tile.children;
  const length3 = children.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const child = children[i2];
    child.updateVisibility(frameState);
    if (isVisible(child)) {
      stack.push(child);
    }
  }
}
function loadTile(tileset, tile) {
  if (hasUnloadedContent(tile) || tile.contentExpired) {
    tile._priority = 0;
    tileset._requestedTiles.push(tile);
  }
}
function touchTile(tileset, tile, frameState) {
  if (tile._touchedFrame === frameState.frameNumber) {
    return;
  }
  tileset._cache.touch(tile);
  tile._touchedFrame = frameState.frameNumber;
}
function visitTile(tileset) {
  ++tileset.statistics.visited;
}
function selectDesiredTile(tileset, tile, frameState) {
  if (tile.contentAvailable && tile.contentVisibility(frameState) !== Intersect_default.OUTSIDE) {
    tileset._selectedTiles.push(tile);
  }
}
var Cesium3DTilesetMostDetailedTraversal_default = Cesium3DTilesetMostDetailedTraversal;

// node_modules/cesium/Source/Scene/Cesium3DTilesetTraversal.js
function Cesium3DTilesetTraversal() {
}
function isVisible2(tile) {
  return tile._visible && tile._inRequestVolume;
}
var traversal2 = {
  stack: new ManagedArray_default(),
  stackMaximumLength: 0
};
var emptyTraversal = {
  stack: new ManagedArray_default(),
  stackMaximumLength: 0
};
var descendantTraversal = {
  stack: new ManagedArray_default(),
  stackMaximumLength: 0
};
var selectionTraversal = {
  stack: new ManagedArray_default(),
  stackMaximumLength: 0,
  ancestorStack: new ManagedArray_default(),
  ancestorStackMaximumLength: 0
};
var descendantSelectionDepth = 2;
Cesium3DTilesetTraversal.selectTiles = function(tileset, frameState) {
  tileset._requestedTiles.length = 0;
  if (tileset.debugFreezeFrame) {
    return;
  }
  tileset._selectedTiles.length = 0;
  tileset._selectedTilesToStyle.length = 0;
  tileset._emptyTiles.length = 0;
  tileset._hasMixedContent = false;
  const root = tileset.root;
  updateTile(tileset, root, frameState);
  if (!isVisible2(root)) {
    return;
  }
  if (root.getScreenSpaceError(frameState, true) <= tileset._maximumScreenSpaceError) {
    return;
  }
  if (!skipLevelOfDetail(tileset)) {
    executeBaseTraversal(tileset, root, frameState);
  } else if (tileset.immediatelyLoadDesiredLevelOfDetail) {
    executeSkipTraversal(tileset, root, frameState);
  } else {
    executeBaseAndSkipTraversal(tileset, root, frameState);
  }
  traversal2.stack.trim(traversal2.stackMaximumLength);
  emptyTraversal.stack.trim(emptyTraversal.stackMaximumLength);
  descendantTraversal.stack.trim(descendantTraversal.stackMaximumLength);
  selectionTraversal.stack.trim(selectionTraversal.stackMaximumLength);
  selectionTraversal.ancestorStack.trim(
    selectionTraversal.ancestorStackMaximumLength
  );
  const requestedTiles = tileset._requestedTiles;
  const length3 = requestedTiles.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    requestedTiles[i2].updatePriority();
  }
};
function executeBaseTraversal(tileset, root, frameState) {
  const baseScreenSpaceError = tileset._maximumScreenSpaceError;
  const maximumScreenSpaceError = tileset._maximumScreenSpaceError;
  executeTraversal(
    tileset,
    root,
    baseScreenSpaceError,
    maximumScreenSpaceError,
    frameState
  );
}
function executeSkipTraversal(tileset, root, frameState) {
  const baseScreenSpaceError = Number.MAX_VALUE;
  const maximumScreenSpaceError = tileset._maximumScreenSpaceError;
  executeTraversal(
    tileset,
    root,
    baseScreenSpaceError,
    maximumScreenSpaceError,
    frameState
  );
  traverseAndSelect(tileset, root, frameState);
}
function executeBaseAndSkipTraversal(tileset, root, frameState) {
  const baseScreenSpaceError = Math.max(
    tileset.baseScreenSpaceError,
    tileset.maximumScreenSpaceError
  );
  const maximumScreenSpaceError = tileset.maximumScreenSpaceError;
  executeTraversal(
    tileset,
    root,
    baseScreenSpaceError,
    maximumScreenSpaceError,
    frameState
  );
  traverseAndSelect(tileset, root, frameState);
}
function skipLevelOfDetail(tileset) {
  return tileset._skipLevelOfDetail;
}
function addEmptyTile(tileset, tile) {
  tileset._emptyTiles.push(tile);
}
function selectTile(tileset, tile, frameState) {
  if (tile.contentVisibility(frameState) !== Intersect_default.OUTSIDE) {
    const tileContent = tile.content;
    if (tileContent.featurePropertiesDirty) {
      tileContent.featurePropertiesDirty = false;
      tile.lastStyleTime = 0;
      tileset._selectedTilesToStyle.push(tile);
    } else if (tile._selectedFrame < frameState.frameNumber - 1) {
      tileset._selectedTilesToStyle.push(tile);
    }
    tile._selectedFrame = frameState.frameNumber;
    tileset._selectedTiles.push(tile);
  }
}
function selectDescendants(tileset, root, frameState) {
  const stack = descendantTraversal.stack;
  stack.push(root);
  while (stack.length > 0) {
    descendantTraversal.stackMaximumLength = Math.max(
      descendantTraversal.stackMaximumLength,
      stack.length
    );
    const tile = stack.pop();
    const children = tile.children;
    const childrenLength = children.length;
    for (let i2 = 0; i2 < childrenLength; ++i2) {
      const child = children[i2];
      if (isVisible2(child)) {
        if (child.contentAvailable) {
          updateTile(tileset, child, frameState);
          touchTile2(tileset, child, frameState);
          selectTile(tileset, child, frameState);
        } else if (child._depth - root._depth < descendantSelectionDepth) {
          stack.push(child);
        }
      }
    }
  }
}
function selectDesiredTile2(tileset, tile, frameState) {
  if (!skipLevelOfDetail(tileset)) {
    if (tile.contentAvailable) {
      selectTile(tileset, tile, frameState);
    }
    return;
  }
  const loadedTile = tile.contentAvailable ? tile : tile._ancestorWithContentAvailable;
  if (defined_default(loadedTile)) {
    loadedTile._shouldSelect = true;
  } else {
    selectDescendants(tileset, tile, frameState);
  }
}
function visitTile2(tileset, tile, frameState) {
  ++tileset._statistics.visited;
  tile._visitedFrame = frameState.frameNumber;
}
function touchTile2(tileset, tile, frameState) {
  if (tile._touchedFrame === frameState.frameNumber) {
    return;
  }
  tileset._cache.touch(tile);
  tile._touchedFrame = frameState.frameNumber;
}
function updateMinimumMaximumPriority(tileset, tile) {
  tileset._maximumPriority.distance = Math.max(
    tile._priorityHolder._distanceToCamera,
    tileset._maximumPriority.distance
  );
  tileset._minimumPriority.distance = Math.min(
    tile._priorityHolder._distanceToCamera,
    tileset._minimumPriority.distance
  );
  tileset._maximumPriority.depth = Math.max(
    tile._depth,
    tileset._maximumPriority.depth
  );
  tileset._minimumPriority.depth = Math.min(
    tile._depth,
    tileset._minimumPriority.depth
  );
  tileset._maximumPriority.foveatedFactor = Math.max(
    tile._priorityHolder._foveatedFactor,
    tileset._maximumPriority.foveatedFactor
  );
  tileset._minimumPriority.foveatedFactor = Math.min(
    tile._priorityHolder._foveatedFactor,
    tileset._minimumPriority.foveatedFactor
  );
  tileset._maximumPriority.reverseScreenSpaceError = Math.max(
    tile._priorityReverseScreenSpaceError,
    tileset._maximumPriority.reverseScreenSpaceError
  );
  tileset._minimumPriority.reverseScreenSpaceError = Math.min(
    tile._priorityReverseScreenSpaceError,
    tileset._minimumPriority.reverseScreenSpaceError
  );
}
function isOnScreenLongEnough(tileset, tile, frameState) {
  if (!tileset._cullRequestsWhileMoving) {
    return true;
  }
  const sphere = tile.boundingSphere;
  const diameter = Math.max(sphere.radius * 2, 1);
  const camera = frameState.camera;
  const deltaMagnitude = camera.positionWCDeltaMagnitude !== 0 ? camera.positionWCDeltaMagnitude : camera.positionWCDeltaMagnitudeLastFrame;
  const movementRatio = tileset.cullRequestsWhileMovingMultiplier * deltaMagnitude / diameter;
  return movementRatio < 1;
}
function loadTile2(tileset, tile, frameState) {
  if (tile._requestedFrame === frameState.frameNumber || !hasUnloadedContent2(tile) && !tile.contentExpired) {
    return;
  }
  if (!isOnScreenLongEnough(tileset, tile, frameState)) {
    return;
  }
  const cameraHasNotStoppedMovingLongEnough = frameState.camera.timeSinceMoved < tileset.foveatedTimeDelay;
  if (tile.priorityDeferred && cameraHasNotStoppedMovingLongEnough) {
    return;
  }
  tile._requestedFrame = frameState.frameNumber;
  tileset._requestedTiles.push(tile);
}
function updateVisibility(tileset, tile, frameState) {
  if (tile._updatedVisibilityFrame === tileset._updatedVisibilityFrame) {
    return;
  }
  tile.updateVisibility(frameState);
  tile._updatedVisibilityFrame = tileset._updatedVisibilityFrame;
}
function anyChildrenVisible(tileset, tile, frameState) {
  let anyVisible = false;
  const children = tile.children;
  const length3 = children.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const child = children[i2];
    updateVisibility(tileset, child, frameState);
    anyVisible = anyVisible || isVisible2(child);
  }
  return anyVisible;
}
function meetsScreenSpaceErrorEarly(tileset, tile, frameState) {
  const parent = tile.parent;
  if (!defined_default(parent) || parent.hasTilesetContent || parent.hasImplicitContent || parent.refine !== Cesium3DTileRefine_default.ADD) {
    return false;
  }
  return tile.getScreenSpaceError(frameState, true) <= tileset._maximumScreenSpaceError;
}
function updateTileVisibility(tileset, tile, frameState) {
  updateVisibility(tileset, tile, frameState);
  if (!isVisible2(tile)) {
    return;
  }
  const hasChildren = tile.children.length > 0;
  if ((tile.hasTilesetContent || tile.hasImplicitContent) && hasChildren) {
    const child = tile.children[0];
    updateTileVisibility(tileset, child, frameState);
    tile._visible = child._visible;
    return;
  }
  if (meetsScreenSpaceErrorEarly(tileset, tile, frameState)) {
    tile._visible = false;
    return;
  }
  const replace = tile.refine === Cesium3DTileRefine_default.REPLACE;
  const useOptimization = tile._optimChildrenWithinParent === Cesium3DTileOptimizationHint_default.USE_OPTIMIZATION;
  if (replace && useOptimization && hasChildren) {
    if (!anyChildrenVisible(tileset, tile, frameState)) {
      ++tileset._statistics.numberOfTilesCulledWithChildrenUnion;
      tile._visible = false;
      return;
    }
  }
}
function updateTile(tileset, tile, frameState) {
  updateTileVisibility(tileset, tile, frameState);
  tile.updateExpiration();
  tile._wasMinPriorityChild = false;
  tile._priorityHolder = tile;
  updateMinimumMaximumPriority(tileset, tile);
  tile._shouldSelect = false;
  tile._finalResolution = true;
}
function updateTileAncestorContentLinks(tile, frameState) {
  tile._ancestorWithContent = void 0;
  tile._ancestorWithContentAvailable = void 0;
  const parent = tile.parent;
  if (defined_default(parent)) {
    const hasContent = !hasUnloadedContent2(parent) || parent._requestedFrame === frameState.frameNumber;
    tile._ancestorWithContent = hasContent ? parent : parent._ancestorWithContent;
    tile._ancestorWithContentAvailable = parent.contentAvailable ? parent : parent._ancestorWithContentAvailable;
  }
}
function hasEmptyContent2(tile) {
  return tile.hasEmptyContent || tile.hasTilesetContent || tile.hasImplicitContent;
}
function hasUnloadedContent2(tile) {
  return !hasEmptyContent2(tile) && tile.contentUnloaded;
}
function reachedSkippingThreshold(tileset, tile) {
  const ancestor = tile._ancestorWithContent;
  return !tileset.immediatelyLoadDesiredLevelOfDetail && (tile._priorityProgressiveResolutionScreenSpaceErrorLeaf || defined_default(ancestor) && tile._screenSpaceError < ancestor._screenSpaceError / tileset.skipScreenSpaceErrorFactor && tile._depth > ancestor._depth + tileset.skipLevels);
}
function sortChildrenByDistanceToCamera(a4, b) {
  if (b._distanceToCamera === 0 && a4._distanceToCamera === 0) {
    return b._centerZDepth - a4._centerZDepth;
  }
  return b._distanceToCamera - a4._distanceToCamera;
}
function updateAndPushChildren2(tileset, tile, stack, frameState) {
  let i2;
  const replace = tile.refine === Cesium3DTileRefine_default.REPLACE;
  const children = tile.children;
  const length3 = children.length;
  for (i2 = 0; i2 < length3; ++i2) {
    updateTile(tileset, children[i2], frameState);
  }
  children.sort(sortChildrenByDistanceToCamera);
  const checkRefines = !skipLevelOfDetail(tileset) && replace && !hasEmptyContent2(tile);
  let refines = true;
  let anyChildrenVisible2 = false;
  let minIndex = -1;
  let minimumPriority = Number.MAX_VALUE;
  let child;
  for (i2 = 0; i2 < length3; ++i2) {
    child = children[i2];
    if (isVisible2(child)) {
      stack.push(child);
      if (child._foveatedFactor < minimumPriority) {
        minIndex = i2;
        minimumPriority = child._foveatedFactor;
      }
      anyChildrenVisible2 = true;
    } else if (checkRefines || tileset.loadSiblings) {
      if (child._foveatedFactor < minimumPriority) {
        minIndex = i2;
        minimumPriority = child._foveatedFactor;
      }
      loadTile2(tileset, child, frameState);
      touchTile2(tileset, child, frameState);
    }
    if (checkRefines) {
      let childRefines;
      if (!child._inRequestVolume) {
        childRefines = false;
      } else if (hasEmptyContent2(child)) {
        childRefines = executeEmptyTraversal(tileset, child, frameState);
      } else {
        childRefines = child.contentAvailable;
      }
      refines = refines && childRefines;
    }
  }
  if (!anyChildrenVisible2) {
    refines = false;
  }
  if (minIndex !== -1 && !skipLevelOfDetail(tileset) && replace) {
    const minPriorityChild = children[minIndex];
    minPriorityChild._wasMinPriorityChild = true;
    const priorityHolder = (tile._wasMinPriorityChild || tile === tileset.root) && minimumPriority <= tile._priorityHolder._foveatedFactor ? tile._priorityHolder : tile;
    priorityHolder._foveatedFactor = Math.min(
      minPriorityChild._foveatedFactor,
      priorityHolder._foveatedFactor
    );
    priorityHolder._distanceToCamera = Math.min(
      minPriorityChild._distanceToCamera,
      priorityHolder._distanceToCamera
    );
    for (i2 = 0; i2 < length3; ++i2) {
      child = children[i2];
      child._priorityHolder = priorityHolder;
    }
  }
  return refines;
}
function inBaseTraversal(tileset, tile, baseScreenSpaceError) {
  if (!skipLevelOfDetail(tileset)) {
    return true;
  }
  if (tileset.immediatelyLoadDesiredLevelOfDetail) {
    return false;
  }
  if (!defined_default(tile._ancestorWithContent)) {
    return true;
  }
  if (tile._screenSpaceError === 0) {
    return tile.parent._screenSpaceError > baseScreenSpaceError;
  }
  return tile._screenSpaceError > baseScreenSpaceError;
}
function canTraverse2(tileset, tile) {
  if (tile.children.length === 0) {
    return false;
  }
  if (tile.hasTilesetContent || tile.hasImplicitContent) {
    return !tile.contentExpired;
  }
  return tile._screenSpaceError > tileset._maximumScreenSpaceError;
}
function executeTraversal(tileset, root, baseScreenSpaceError, maximumScreenSpaceError, frameState) {
  const stack = traversal2.stack;
  stack.push(root);
  while (stack.length > 0) {
    traversal2.stackMaximumLength = Math.max(
      traversal2.stackMaximumLength,
      stack.length
    );
    const tile = stack.pop();
    updateTileAncestorContentLinks(tile, frameState);
    const baseTraversal = inBaseTraversal(tileset, tile, baseScreenSpaceError);
    const add2 = tile.refine === Cesium3DTileRefine_default.ADD;
    const replace = tile.refine === Cesium3DTileRefine_default.REPLACE;
    const parent = tile.parent;
    const parentRefines = !defined_default(parent) || parent._refines;
    let refines = false;
    if (canTraverse2(tileset, tile)) {
      refines = updateAndPushChildren2(tileset, tile, stack, frameState) && parentRefines;
    }
    const stoppedRefining = !refines && parentRefines;
    if (hasEmptyContent2(tile)) {
      addEmptyTile(tileset, tile, frameState);
      loadTile2(tileset, tile, frameState);
      if (stoppedRefining) {
        selectDesiredTile2(tileset, tile, frameState);
      }
    } else if (add2) {
      selectDesiredTile2(tileset, tile, frameState);
      loadTile2(tileset, tile, frameState);
    } else if (replace) {
      if (baseTraversal) {
        loadTile2(tileset, tile, frameState);
        if (stoppedRefining) {
          selectDesiredTile2(tileset, tile, frameState);
        }
      } else if (stoppedRefining) {
        selectDesiredTile2(tileset, tile, frameState);
        loadTile2(tileset, tile, frameState);
      } else if (reachedSkippingThreshold(tileset, tile)) {
        loadTile2(tileset, tile, frameState);
      }
    }
    visitTile2(tileset, tile, frameState);
    touchTile2(tileset, tile, frameState);
    tile._refines = refines;
  }
}
function executeEmptyTraversal(tileset, root, frameState) {
  let allDescendantsLoaded = true;
  const stack = emptyTraversal.stack;
  stack.push(root);
  while (stack.length > 0) {
    emptyTraversal.stackMaximumLength = Math.max(
      emptyTraversal.stackMaximumLength,
      stack.length
    );
    const tile = stack.pop();
    const children = tile.children;
    const childrenLength = children.length;
    const emptyContent = hasEmptyContent2(tile);
    const traverse = emptyContent && canTraverse2(tileset, tile);
    const emptyLeaf = emptyContent && tile.children.length === 0;
    if (!traverse && !tile.contentAvailable && !emptyLeaf) {
      allDescendantsLoaded = false;
    }
    updateTile(tileset, tile, frameState);
    if (!isVisible2(tile)) {
      loadTile2(tileset, tile, frameState);
      touchTile2(tileset, tile, frameState);
    }
    if (traverse) {
      for (let i2 = 0; i2 < childrenLength; ++i2) {
        const child = children[i2];
        stack.push(child);
      }
    }
  }
  return allDescendantsLoaded;
}
function traverseAndSelect(tileset, root, frameState) {
  const stack = selectionTraversal.stack;
  const ancestorStack = selectionTraversal.ancestorStack;
  let lastAncestor;
  stack.push(root);
  while (stack.length > 0 || ancestorStack.length > 0) {
    selectionTraversal.stackMaximumLength = Math.max(
      selectionTraversal.stackMaximumLength,
      stack.length
    );
    selectionTraversal.ancestorStackMaximumLength = Math.max(
      selectionTraversal.ancestorStackMaximumLength,
      ancestorStack.length
    );
    if (ancestorStack.length > 0) {
      const waitingTile = ancestorStack.peek();
      if (waitingTile._stackLength === stack.length) {
        ancestorStack.pop();
        if (waitingTile !== lastAncestor) {
          waitingTile._finalResolution = false;
        }
        selectTile(tileset, waitingTile, frameState);
        continue;
      }
    }
    const tile = stack.pop();
    if (!defined_default(tile)) {
      continue;
    }
    const add2 = tile.refine === Cesium3DTileRefine_default.ADD;
    const shouldSelect = tile._shouldSelect;
    const children = tile.children;
    const childrenLength = children.length;
    const traverse = canTraverse2(tileset, tile);
    if (shouldSelect) {
      if (add2) {
        selectTile(tileset, tile, frameState);
      } else {
        tile._selectionDepth = ancestorStack.length;
        if (tile._selectionDepth > 0) {
          tileset._hasMixedContent = true;
        }
        lastAncestor = tile;
        if (!traverse) {
          selectTile(tileset, tile, frameState);
          continue;
        }
        ancestorStack.push(tile);
        tile._stackLength = stack.length;
      }
    }
    if (traverse) {
      for (let i2 = 0; i2 < childrenLength; ++i2) {
        const child = children[i2];
        if (isVisible2(child)) {
          stack.push(child);
        }
      }
    }
  }
}
var Cesium3DTilesetTraversal_default = Cesium3DTilesetTraversal;

// node_modules/cesium/Source/Scene/Cesium3DTilePass.js
var Cesium3DTilePass = {
  RENDER: 0,
  PICK: 1,
  SHADOW: 2,
  PRELOAD: 3,
  PRELOAD_FLIGHT: 4,
  REQUEST_RENDER_MODE_DEFER_CHECK: 5,
  MOST_DETAILED_PRELOAD: 6,
  MOST_DETAILED_PICK: 7,
  NUMBER_OF_PASSES: 8
};
var passOptions = new Array(Cesium3DTilePass.NUMBER_OF_PASSES);
passOptions[Cesium3DTilePass.RENDER] = Object.freeze({
  traversal: Cesium3DTilesetTraversal_default,
  isRender: true,
  requestTiles: true,
  ignoreCommands: false
});
passOptions[Cesium3DTilePass.PICK] = Object.freeze({
  traversal: Cesium3DTilesetTraversal_default,
  isRender: false,
  requestTiles: false,
  ignoreCommands: false
});
passOptions[Cesium3DTilePass.SHADOW] = Object.freeze({
  traversal: Cesium3DTilesetTraversal_default,
  isRender: false,
  requestTiles: true,
  ignoreCommands: false
});
passOptions[Cesium3DTilePass.PRELOAD] = Object.freeze({
  traversal: Cesium3DTilesetTraversal_default,
  isRender: false,
  requestTiles: true,
  ignoreCommands: true
});
passOptions[Cesium3DTilePass.PRELOAD_FLIGHT] = Object.freeze({
  traversal: Cesium3DTilesetTraversal_default,
  isRender: false,
  requestTiles: true,
  ignoreCommands: true
});
passOptions[Cesium3DTilePass.REQUEST_RENDER_MODE_DEFER_CHECK] = Object.freeze({
  traversal: Cesium3DTilesetTraversal_default,
  isRender: false,
  requestTiles: true,
  ignoreCommands: true
});
passOptions[Cesium3DTilePass.MOST_DETAILED_PRELOAD] = Object.freeze({
  traversal: Cesium3DTilesetMostDetailedTraversal_default,
  isRender: false,
  requestTiles: true,
  ignoreCommands: true
});
passOptions[Cesium3DTilePass.MOST_DETAILED_PICK] = Object.freeze({
  traversal: Cesium3DTilesetMostDetailedTraversal_default,
  isRender: false,
  requestTiles: false,
  ignoreCommands: false
});
Cesium3DTilePass.getPassOptions = function(pass) {
  return passOptions[pass];
};
var Cesium3DTilePass_default = Object.freeze(Cesium3DTilePass);

// node_modules/cesium/Source/Scene/Empty3DTileContent.js
function Empty3DTileContent(tileset, tile) {
  this._tileset = tileset;
  this._tile = tile;
  this.featurePropertiesDirty = false;
}
Object.defineProperties(Empty3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      return 0;
    }
  },
  pointsLength: {
    get: function() {
      return 0;
    }
  },
  trianglesLength: {
    get: function() {
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      return 0;
    }
  },
  texturesByteLength: {
    get: function() {
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      return 0;
    }
  },
  innerContents: {
    get: function() {
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return void 0;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return void 0;
    }
  },
  metadata: {
    get: function() {
      return void 0;
    },
    set: function(value) {
      throw new DeveloperError_default(
        "Empty3DTileContent cannot have content metadata"
      );
    }
  },
  batchTable: {
    get: function() {
      return void 0;
    }
  },
  group: {
    get: function() {
      return void 0;
    },
    set: function(value) {
      throw new DeveloperError_default("Empty3DTileContent cannot have group metadata");
    }
  }
});
Empty3DTileContent.prototype.hasProperty = function(batchId, name) {
  return false;
};
Empty3DTileContent.prototype.getFeature = function(batchId) {
  return void 0;
};
Empty3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
};
Empty3DTileContent.prototype.applyStyle = function(style) {
};
Empty3DTileContent.prototype.update = function(tileset, frameState) {
};
Empty3DTileContent.prototype.isDestroyed = function() {
  return false;
};
Empty3DTileContent.prototype.destroy = function() {
  return destroyObject_default(this);
};
var Empty3DTileContent_default = Empty3DTileContent;

// node_modules/cesium/Source/Scene/ContentMetadata.js
function ContentMetadata(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const content = options.content;
  const metadataClass = options.class;
  Check_default.typeOf.object("options.content", content);
  Check_default.typeOf.object("options.class", metadataClass);
  this._class = metadataClass;
  this._properties = content.properties;
  this._extensions = content.extensions;
  this._extras = content.extras;
}
Object.defineProperties(ContentMetadata.prototype, {
  class: {
    get: function() {
      return this._class;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
ContentMetadata.prototype.hasProperty = function(propertyId) {
  return MetadataEntity_default.hasProperty(propertyId, this._properties, this._class);
};
ContentMetadata.prototype.hasPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.hasPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
ContentMetadata.prototype.getPropertyIds = function(results) {
  return MetadataEntity_default.getPropertyIds(this._properties, this._class, results);
};
ContentMetadata.prototype.getProperty = function(propertyId) {
  return MetadataEntity_default.getProperty(propertyId, this._properties, this._class);
};
ContentMetadata.prototype.setProperty = function(propertyId, value) {
  return MetadataEntity_default.setProperty(
    propertyId,
    value,
    this._properties,
    this._class
  );
};
ContentMetadata.prototype.getPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.getPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
ContentMetadata.prototype.setPropertyBySemantic = function(semantic, value) {
  return MetadataEntity_default.setPropertyBySemantic(
    semantic,
    value,
    this._properties,
    this._class
  );
};

// node_modules/cesium/Source/Scene/findContentMetadata.js
function findContentMetadata(tileset, contentHeader) {
  const metadataJson = hasExtension(contentHeader, "3DTILES_metadata") ? contentHeader.extensions["3DTILES_metadata"] : contentHeader.metadata;
  if (!defined_default(metadataJson)) {
    return void 0;
  }
  const classes = tileset.schema.classes;
  if (defined_default(metadataJson.class)) {
    const contentClass = classes[metadataJson.class];
    return new ContentMetadata({
      content: metadataJson,
      class: contentClass
    });
  }
  return void 0;
}

// node_modules/cesium/Source/Scene/findGroupMetadata.js
function findGroupMetadata(tileset, contentHeader) {
  const metadataExtension = tileset.metadataExtension;
  if (!defined_default(metadataExtension)) {
    return void 0;
  }
  const groups = metadataExtension.groups;
  const group = hasExtension(contentHeader, "3DTILES_metadata") ? contentHeader.extensions["3DTILES_metadata"].group : contentHeader.group;
  if (typeof group === "number") {
    return groups[group];
  }
  const index2 = metadataExtension.groupIds.findIndex(function(id) {
    return id === group;
  });
  return index2 >= 0 ? groups[index2] : void 0;
}

// node_modules/cesium/Source/Scene/TileMetadata.js
function TileMetadata(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const tile = options.tile;
  const metadataClass = options.class;
  Check_default.typeOf.object("options.tile", tile);
  Check_default.typeOf.object("options.class", metadataClass);
  this._class = metadataClass;
  this._properties = tile.properties;
  this._extensions = tile.extensions;
  this._extras = tile.extras;
}
Object.defineProperties(TileMetadata.prototype, {
  class: {
    get: function() {
      return this._class;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
TileMetadata.prototype.hasProperty = function(propertyId) {
  return MetadataEntity_default.hasProperty(propertyId, this._properties, this._class);
};
TileMetadata.prototype.hasPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.hasPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
TileMetadata.prototype.getPropertyIds = function(results) {
  return MetadataEntity_default.getPropertyIds(this._properties, this._class, results);
};
TileMetadata.prototype.getProperty = function(propertyId) {
  return MetadataEntity_default.getProperty(propertyId, this._properties, this._class);
};
TileMetadata.prototype.setProperty = function(propertyId, value) {
  return MetadataEntity_default.setProperty(
    propertyId,
    value,
    this._properties,
    this._class
  );
};
TileMetadata.prototype.getPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.getPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
TileMetadata.prototype.setPropertyBySemantic = function(semantic, value) {
  return MetadataEntity_default.setPropertyBySemantic(
    semantic,
    value,
    this._properties,
    this._class
  );
};

// node_modules/cesium/Source/Scene/findTileMetadata.js
function findTileMetadata(tileset, tileHeader) {
  const metadataJson = hasExtension(tileHeader, "3DTILES_metadata") ? tileHeader.extensions["3DTILES_metadata"] : tileHeader.metadata;
  if (!defined_default(metadataJson)) {
    return void 0;
  }
  const classes = tileset.schema.classes;
  if (defined_default(metadataJson.class)) {
    const tileClass = classes[metadataJson.class];
    return new TileMetadata({
      tile: metadataJson,
      class: tileClass
    });
  }
  return void 0;
}

// node_modules/cesium/Source/Scene/preprocess3DTileContent.js
function preprocess3DTileContent(arrayBuffer) {
  const uint8Array = new Uint8Array(arrayBuffer);
  let contentType = getMagic_default(uint8Array);
  if (contentType === "glTF") {
    contentType = "glb";
  }
  if (Cesium3DTileContentType_default.isBinaryFormat(contentType)) {
    return {
      contentType,
      binaryPayload: uint8Array
    };
  }
  const json = getJsonContent(uint8Array);
  if (defined_default(json.root)) {
    return {
      contentType: Cesium3DTileContentType_default.EXTERNAL_TILESET,
      jsonPayload: json
    };
  }
  if (defined_default(json.asset)) {
    return {
      contentType: Cesium3DTileContentType_default.GLTF,
      jsonPayload: json
    };
  }
  if (defined_default(json.tileAvailability)) {
    return {
      contentType: Cesium3DTileContentType_default.IMPLICIT_SUBTREE_JSON,
      jsonPayload: json
    };
  }
  throw new RuntimeError_default("Invalid tile content.");
}
function getJsonContent(uint8Array) {
  let json;
  try {
    json = getJsonFromTypedArray_default(uint8Array);
  } catch (error) {
    throw new RuntimeError_default("Invalid tile content.");
  }
  return json;
}

// node_modules/cesium/Source/Scene/Multiple3DTileContent.js
function Multiple3DTileContent(tileset, tile, tilesetResource, contentsJson) {
  this._tileset = tileset;
  this._tile = tile;
  this._tilesetResource = tilesetResource;
  this._contents = [];
  const contentHeaders = defined_default(contentsJson.contents) ? contentsJson.contents : contentsJson.content;
  this._innerContentHeaders = contentHeaders;
  this._requestsInFlight = 0;
  this._cancelCount = 0;
  const contentCount = this._innerContentHeaders.length;
  this._arrayFetchPromises = new Array(contentCount);
  this._requests = new Array(contentCount);
  this._innerContentResources = new Array(contentCount);
  this._serverKeys = new Array(contentCount);
  for (let i2 = 0; i2 < contentCount; i2++) {
    const contentResource = tilesetResource.getDerivedResource({
      url: contentHeaders[i2].uri
    });
    const serverKey = RequestScheduler_default.getServerKey(
      contentResource.getUrlComponent()
    );
    this._innerContentResources[i2] = contentResource;
    this._serverKeys[i2] = serverKey;
  }
  this._contentsFetchedPromise = void 0;
  this._readyPromise = defer_default();
}
Object.defineProperties(Multiple3DTileContent.prototype, {
  featurePropertiesDirty: {
    get: function() {
      const contents = this._contents;
      const length3 = contents.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        if (contents[i2].featurePropertiesDirty) {
          return true;
        }
      }
      return false;
    },
    set: function(value) {
      const contents = this._contents;
      const length3 = contents.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        contents[i2].featurePropertiesDirty = value;
      }
    }
  },
  featuresLength: {
    get: function() {
      return 0;
    }
  },
  pointsLength: {
    get: function() {
      return 0;
    }
  },
  trianglesLength: {
    get: function() {
      return 0;
    }
  },
  geometryByteLength: {
    get: function() {
      return 0;
    }
  },
  texturesByteLength: {
    get: function() {
      return 0;
    }
  },
  batchTableByteLength: {
    get: function() {
      return 0;
    }
  },
  innerContents: {
    get: function() {
      return this._contents;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    }
  },
  url: {
    get: function() {
      return void 0;
    }
  },
  metadata: {
    get: function() {
      return void 0;
    },
    set: function() {
      throw new DeveloperError_default("Multiple3DTileContent cannot have metadata");
    }
  },
  batchTable: {
    get: function() {
      return void 0;
    }
  },
  group: {
    get: function() {
      return void 0;
    },
    set: function() {
      throw new DeveloperError_default(
        "Multiple3DTileContent cannot have group metadata"
      );
    }
  },
  innerContentUrls: {
    get: function() {
      return this._innerContentHeaders.map(function(contentHeader) {
        return contentHeader.uri;
      });
    }
  },
  contentsFetchedPromise: {
    get: function() {
      if (defined_default(this._contentsFetchedPromise)) {
        return this._contentsFetchedPromise.promise;
      }
      return void 0;
    }
  }
});
function updatePendingRequests(multipleContents, deltaRequestCount) {
  multipleContents._requestsInFlight += deltaRequestCount;
  multipleContents.tileset.statistics.numberOfPendingRequests += deltaRequestCount;
}
function cancelPendingRequests(multipleContents, originalContentState) {
  multipleContents._cancelCount++;
  multipleContents._tile._contentState = originalContentState;
  multipleContents.tileset.statistics.numberOfPendingRequests -= multipleContents._requestsInFlight;
  multipleContents._requestsInFlight = 0;
  const contentCount = multipleContents._innerContentHeaders.length;
  multipleContents._arrayFetchPromises = new Array(contentCount);
}
Multiple3DTileContent.prototype.requestInnerContents = function() {
  if (!canScheduleAllRequests(this._serverKeys)) {
    return this._serverKeys.length;
  }
  const contentHeaders = this._innerContentHeaders;
  updatePendingRequests(this, contentHeaders.length);
  for (let i2 = 0; i2 < contentHeaders.length; i2++) {
    this._arrayFetchPromises[i2] = requestInnerContent(
      this,
      i2,
      this._cancelCount,
      this._tile._contentState
    );
  }
  if (!defined_default(this._contentsFetchedPromise)) {
    this._contentsFetchedPromise = defer_default();
  }
  createInnerContents(this);
  return 0;
};
function canScheduleAllRequests(serverKeys) {
  const requestCountsByServer = {};
  for (let i2 = 0; i2 < serverKeys.length; i2++) {
    const serverKey = serverKeys[i2];
    if (defined_default(requestCountsByServer[serverKey])) {
      requestCountsByServer[serverKey]++;
    } else {
      requestCountsByServer[serverKey] = 1;
    }
  }
  for (const key in requestCountsByServer) {
    if (requestCountsByServer.hasOwnProperty(key) && !RequestScheduler_default.serverHasOpenSlots(key, requestCountsByServer[key])) {
      return false;
    }
  }
  return RequestScheduler_default.heapHasOpenSlots(serverKeys.length);
}
function requestInnerContent(multipleContents, index2, originalCancelCount, originalContentState) {
  const contentResource = multipleContents._innerContentResources[index2].clone();
  const tile = multipleContents.tile;
  const priorityFunction = function() {
    return tile._priority;
  };
  const serverKey = multipleContents._serverKeys[index2];
  const request = new Request_default({
    throttle: true,
    throttleByServer: true,
    type: RequestType_default.TILES3D,
    priorityFunction,
    serverKey
  });
  contentResource.request = request;
  multipleContents._requests[index2] = request;
  return contentResource.fetchArrayBuffer().then(function(arrayBuffer) {
    if (originalCancelCount < multipleContents._cancelCount) {
      return void 0;
    }
    updatePendingRequests(multipleContents, -1);
    return arrayBuffer;
  }).catch(function(error) {
    if (originalCancelCount < multipleContents._cancelCount) {
      return void 0;
    }
    if (contentResource.request.state === RequestState_default.CANCELLED) {
      cancelPendingRequests(multipleContents, originalContentState);
      return void 0;
    }
    updatePendingRequests(multipleContents, -1);
    handleInnerContentFailed(multipleContents, index2, error);
    return void 0;
  });
}
function createInnerContents(multipleContents) {
  const originalCancelCount = multipleContents._cancelCount;
  Promise.all(multipleContents._arrayFetchPromises).then(function(arrayBuffers) {
    if (originalCancelCount < multipleContents._cancelCount) {
      return void 0;
    }
    return arrayBuffers.map(function(arrayBuffer, i2) {
      if (!defined_default(arrayBuffer)) {
        return void 0;
      }
      try {
        return createInnerContent(multipleContents, arrayBuffer, i2);
      } catch (error) {
        handleInnerContentFailed(multipleContents, i2, error);
        return void 0;
      }
    });
  }).then(function(contents) {
    if (!defined_default(contents)) {
      if (defined_default(multipleContents._contentsFetchedPromise)) {
        multipleContents._contentsFetchedPromise.resolve();
        multipleContents._contentsFetchedPromise = void 0;
      }
      return;
    }
    multipleContents._contents = contents.filter(defined_default);
    awaitReadyPromises(multipleContents);
    if (defined_default(multipleContents._contentsFetchedPromise)) {
      multipleContents._contentsFetchedPromise.resolve();
    }
  }).catch(function(error) {
    if (defined_default(multipleContents._contentsFetchedPromise)) {
      multipleContents._contentsFetchedPromise.reject(error);
    }
  });
}
function createInnerContent(multipleContents, arrayBuffer, index2) {
  const preprocessed = preprocess3DTileContent(arrayBuffer);
  if (preprocessed.contentType === Cesium3DTileContentType_default.EXTERNAL_TILESET) {
    throw new RuntimeError_default(
      "External tilesets are disallowed inside multiple contents"
    );
  }
  multipleContents._disableSkipLevelOfDetail = multipleContents._disableSkipLevelOfDetail || preprocessed.contentType === Cesium3DTileContentType_default.GEOMETRY || preprocessed.contentType === Cesium3DTileContentType_default.VECTOR;
  const tileset = multipleContents._tileset;
  const resource = multipleContents._innerContentResources[index2];
  const tile = multipleContents._tile;
  let content;
  const contentFactory = Cesium3DTileContentFactory_default[preprocessed.contentType];
  if (defined_default(preprocessed.binaryPayload)) {
    content = contentFactory(
      tileset,
      tile,
      resource,
      preprocessed.binaryPayload.buffer,
      0
    );
  } else {
    content = contentFactory(tileset, tile, resource, preprocessed.jsonPayload);
  }
  const contentHeader = multipleContents._innerContentHeaders[index2];
  if (tile.hasImplicitContentMetadata) {
    const subtree = tile.implicitSubtree;
    const coordinates = tile.implicitCoordinates;
    content.metadata = subtree.getContentMetadataView(coordinates, index2);
  } else if (!tile.hasImplicitContent) {
    content.metadata = findContentMetadata(tileset, contentHeader);
  }
  const groupMetadata = findGroupMetadata(tileset, contentHeader);
  if (defined_default(groupMetadata)) {
    content.group = new Cesium3DContentGroup({
      metadata: groupMetadata
    });
  }
  return content;
}
function awaitReadyPromises(multipleContents) {
  const readyPromises = multipleContents._contents.map(function(content) {
    return content.readyPromise;
  });
  Promise.all(readyPromises).then(function() {
    multipleContents._readyPromise.resolve(multipleContents);
  }).catch(function(error) {
    multipleContents._readyPromise.reject(error);
  });
}
function handleInnerContentFailed(multipleContents, index2, error) {
  const tileset = multipleContents._tileset;
  const url2 = multipleContents._innerContentResources[index2].url;
  const message = defined_default(error.message) ? error.message : error.toString();
  if (tileset.tileFailed.numberOfListeners > 0) {
    tileset.tileFailed.raiseEvent({
      url: url2,
      message
    });
  } else {
    console.log(`A content failed to load: ${url2}`);
    console.log(`Error: ${message}`);
  }
}
Multiple3DTileContent.prototype.cancelRequests = function() {
  for (let i2 = 0; i2 < this._requests.length; i2++) {
    const request = this._requests[i2];
    if (defined_default(request)) {
      request.cancel();
    }
  }
};
Multiple3DTileContent.prototype.hasProperty = function(batchId, name) {
  return false;
};
Multiple3DTileContent.prototype.getFeature = function(batchId) {
  return void 0;
};
Multiple3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
  const contents = this._contents;
  const length3 = contents.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    contents[i2].applyDebugSettings(enabled, color);
  }
};
Multiple3DTileContent.prototype.applyStyle = function(style) {
  const contents = this._contents;
  const length3 = contents.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    contents[i2].applyStyle(style);
  }
};
Multiple3DTileContent.prototype.update = function(tileset, frameState) {
  const contents = this._contents;
  const length3 = contents.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    contents[i2].update(tileset, frameState);
  }
};
Multiple3DTileContent.prototype.isDestroyed = function() {
  return false;
};
Multiple3DTileContent.prototype.destroy = function() {
  const contents = this._contents;
  const length3 = contents.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    contents[i2].destroy();
  }
  return destroyObject_default(this);
};

// node_modules/cesium/Source/Scene/TileBoundingRegion.js
function TileBoundingRegion(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.object("options.rectangle", options.rectangle);
  this.rectangle = Rectangle_default.clone(options.rectangle);
  this.minimumHeight = defaultValue_default(options.minimumHeight, 0);
  this.maximumHeight = defaultValue_default(options.maximumHeight, 0);
  this.southwestCornerCartesian = new Cartesian3_default();
  this.northeastCornerCartesian = new Cartesian3_default();
  this.westNormal = new Cartesian3_default();
  this.southNormal = new Cartesian3_default();
  this.eastNormal = new Cartesian3_default();
  this.northNormal = new Cartesian3_default();
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  computeBox(this, options.rectangle, ellipsoid);
  this._orientedBoundingBox = void 0;
  this._boundingSphere = void 0;
  if (defaultValue_default(options.computeBoundingVolumes, true)) {
    this.computeBoundingVolumes(ellipsoid);
  }
}
Object.defineProperties(TileBoundingRegion.prototype, {
  boundingVolume: {
    get: function() {
      return this._orientedBoundingBox;
    }
  },
  boundingSphere: {
    get: function() {
      return this._boundingSphere;
    }
  }
});
TileBoundingRegion.prototype.computeBoundingVolumes = function(ellipsoid) {
  this._orientedBoundingBox = OrientedBoundingBox_default.fromRectangle(
    this.rectangle,
    this.minimumHeight,
    this.maximumHeight,
    ellipsoid
  );
  this._boundingSphere = BoundingSphere_default.fromOrientedBoundingBox(
    this._orientedBoundingBox
  );
};
var cartesian3Scratch7 = new Cartesian3_default();
var cartesian3Scratch23 = new Cartesian3_default();
var cartesian3Scratch32 = new Cartesian3_default();
var eastWestNormalScratch = new Cartesian3_default();
var westernMidpointScratch = new Cartesian3_default();
var easternMidpointScratch = new Cartesian3_default();
var cartographicScratch3 = new Cartographic_default();
var planeScratch = new Plane_default(Cartesian3_default.UNIT_X, 0);
var rayScratch = new Ray_default();
function computeBox(tileBB, rectangle, ellipsoid) {
  ellipsoid.cartographicToCartesian(
    Rectangle_default.southwest(rectangle),
    tileBB.southwestCornerCartesian
  );
  ellipsoid.cartographicToCartesian(
    Rectangle_default.northeast(rectangle),
    tileBB.northeastCornerCartesian
  );
  cartographicScratch3.longitude = rectangle.west;
  cartographicScratch3.latitude = (rectangle.south + rectangle.north) * 0.5;
  cartographicScratch3.height = 0;
  const westernMidpointCartesian = ellipsoid.cartographicToCartesian(
    cartographicScratch3,
    westernMidpointScratch
  );
  const westNormal = Cartesian3_default.cross(
    westernMidpointCartesian,
    Cartesian3_default.UNIT_Z,
    cartesian3Scratch7
  );
  Cartesian3_default.normalize(westNormal, tileBB.westNormal);
  cartographicScratch3.longitude = rectangle.east;
  const easternMidpointCartesian = ellipsoid.cartographicToCartesian(
    cartographicScratch3,
    easternMidpointScratch
  );
  const eastNormal = Cartesian3_default.cross(
    Cartesian3_default.UNIT_Z,
    easternMidpointCartesian,
    cartesian3Scratch7
  );
  Cartesian3_default.normalize(eastNormal, tileBB.eastNormal);
  const westVector = Cartesian3_default.subtract(
    westernMidpointCartesian,
    easternMidpointCartesian,
    cartesian3Scratch7
  );
  const eastWestNormal = Cartesian3_default.normalize(
    westVector,
    eastWestNormalScratch
  );
  const south = rectangle.south;
  let southSurfaceNormal;
  if (south > 0) {
    cartographicScratch3.longitude = (rectangle.west + rectangle.east) * 0.5;
    cartographicScratch3.latitude = south;
    const southCenterCartesian = ellipsoid.cartographicToCartesian(
      cartographicScratch3,
      rayScratch.origin
    );
    Cartesian3_default.clone(eastWestNormal, rayScratch.direction);
    const westPlane = Plane_default.fromPointNormal(
      tileBB.southwestCornerCartesian,
      tileBB.westNormal,
      planeScratch
    );
    IntersectionTests_default.rayPlane(
      rayScratch,
      westPlane,
      tileBB.southwestCornerCartesian
    );
    southSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
      southCenterCartesian,
      cartesian3Scratch23
    );
  } else {
    southSurfaceNormal = ellipsoid.geodeticSurfaceNormalCartographic(
      Rectangle_default.southeast(rectangle),
      cartesian3Scratch23
    );
  }
  const southNormal = Cartesian3_default.cross(
    southSurfaceNormal,
    westVector,
    cartesian3Scratch32
  );
  Cartesian3_default.normalize(southNormal, tileBB.southNormal);
  const north = rectangle.north;
  let northSurfaceNormal;
  if (north < 0) {
    cartographicScratch3.longitude = (rectangle.west + rectangle.east) * 0.5;
    cartographicScratch3.latitude = north;
    const northCenterCartesian = ellipsoid.cartographicToCartesian(
      cartographicScratch3,
      rayScratch.origin
    );
    Cartesian3_default.negate(eastWestNormal, rayScratch.direction);
    const eastPlane = Plane_default.fromPointNormal(
      tileBB.northeastCornerCartesian,
      tileBB.eastNormal,
      planeScratch
    );
    IntersectionTests_default.rayPlane(
      rayScratch,
      eastPlane,
      tileBB.northeastCornerCartesian
    );
    northSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
      northCenterCartesian,
      cartesian3Scratch23
    );
  } else {
    northSurfaceNormal = ellipsoid.geodeticSurfaceNormalCartographic(
      Rectangle_default.northwest(rectangle),
      cartesian3Scratch23
    );
  }
  const northNormal = Cartesian3_default.cross(
    westVector,
    northSurfaceNormal,
    cartesian3Scratch32
  );
  Cartesian3_default.normalize(northNormal, tileBB.northNormal);
}
var southwestCornerScratch = new Cartesian3_default();
var northeastCornerScratch = new Cartesian3_default();
var negativeUnitY = new Cartesian3_default(0, -1, 0);
var negativeUnitZ = new Cartesian3_default(0, 0, -1);
var vectorScratch = new Cartesian3_default();
function distanceToCameraRegion(tileBB, frameState) {
  const camera = frameState.camera;
  const cameraCartesianPosition = camera.positionWC;
  const cameraCartographicPosition = camera.positionCartographic;
  let result = 0;
  if (!Rectangle_default.contains(tileBB.rectangle, cameraCartographicPosition)) {
    let southwestCornerCartesian = tileBB.southwestCornerCartesian;
    let northeastCornerCartesian = tileBB.northeastCornerCartesian;
    let westNormal = tileBB.westNormal;
    let southNormal = tileBB.southNormal;
    let eastNormal = tileBB.eastNormal;
    let northNormal = tileBB.northNormal;
    if (frameState.mode !== SceneMode_default.SCENE3D) {
      southwestCornerCartesian = frameState.mapProjection.project(
        Rectangle_default.southwest(tileBB.rectangle),
        southwestCornerScratch
      );
      southwestCornerCartesian.z = southwestCornerCartesian.y;
      southwestCornerCartesian.y = southwestCornerCartesian.x;
      southwestCornerCartesian.x = 0;
      northeastCornerCartesian = frameState.mapProjection.project(
        Rectangle_default.northeast(tileBB.rectangle),
        northeastCornerScratch
      );
      northeastCornerCartesian.z = northeastCornerCartesian.y;
      northeastCornerCartesian.y = northeastCornerCartesian.x;
      northeastCornerCartesian.x = 0;
      westNormal = negativeUnitY;
      eastNormal = Cartesian3_default.UNIT_Y;
      southNormal = negativeUnitZ;
      northNormal = Cartesian3_default.UNIT_Z;
    }
    const vectorFromSouthwestCorner = Cartesian3_default.subtract(
      cameraCartesianPosition,
      southwestCornerCartesian,
      vectorScratch
    );
    const distanceToWestPlane = Cartesian3_default.dot(
      vectorFromSouthwestCorner,
      westNormal
    );
    const distanceToSouthPlane = Cartesian3_default.dot(
      vectorFromSouthwestCorner,
      southNormal
    );
    const vectorFromNortheastCorner = Cartesian3_default.subtract(
      cameraCartesianPosition,
      northeastCornerCartesian,
      vectorScratch
    );
    const distanceToEastPlane = Cartesian3_default.dot(
      vectorFromNortheastCorner,
      eastNormal
    );
    const distanceToNorthPlane = Cartesian3_default.dot(
      vectorFromNortheastCorner,
      northNormal
    );
    if (distanceToWestPlane > 0) {
      result += distanceToWestPlane * distanceToWestPlane;
    } else if (distanceToEastPlane > 0) {
      result += distanceToEastPlane * distanceToEastPlane;
    }
    if (distanceToSouthPlane > 0) {
      result += distanceToSouthPlane * distanceToSouthPlane;
    } else if (distanceToNorthPlane > 0) {
      result += distanceToNorthPlane * distanceToNorthPlane;
    }
  }
  let cameraHeight;
  let minimumHeight;
  let maximumHeight;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    cameraHeight = cameraCartographicPosition.height;
    minimumHeight = tileBB.minimumHeight;
    maximumHeight = tileBB.maximumHeight;
  } else {
    cameraHeight = cameraCartesianPosition.x;
    minimumHeight = 0;
    maximumHeight = 0;
  }
  if (cameraHeight > maximumHeight) {
    const distanceAboveTop = cameraHeight - maximumHeight;
    result += distanceAboveTop * distanceAboveTop;
  } else if (cameraHeight < minimumHeight) {
    const distanceBelowBottom = minimumHeight - cameraHeight;
    result += distanceBelowBottom * distanceBelowBottom;
  }
  return Math.sqrt(result);
}
TileBoundingRegion.prototype.distanceToCamera = function(frameState) {
  Check_default.defined("frameState", frameState);
  const regionResult = distanceToCameraRegion(this, frameState);
  if (frameState.mode === SceneMode_default.SCENE3D && defined_default(this._orientedBoundingBox)) {
    const obbResult = Math.sqrt(
      this._orientedBoundingBox.distanceSquaredTo(frameState.camera.positionWC)
    );
    return Math.max(regionResult, obbResult);
  }
  return regionResult;
};
TileBoundingRegion.prototype.intersectPlane = function(plane) {
  Check_default.defined("plane", plane);
  return this._orientedBoundingBox.intersectPlane(plane);
};
TileBoundingRegion.prototype.createDebugVolume = function(color) {
  Check_default.defined("color", color);
  const modelMatrix = new Matrix4_default.clone(Matrix4_default.IDENTITY);
  const geometry = new RectangleOutlineGeometry_default({
    rectangle: this.rectangle,
    height: this.minimumHeight,
    extrudedHeight: this.maximumHeight
  });
  const instance = new GeometryInstance_default({
    geometry,
    id: "outline",
    modelMatrix,
    attributes: {
      color: ColorGeometryInstanceAttribute_default.fromColor(color)
    }
  });
  return new Primitive_default({
    geometryInstances: instance,
    appearance: new PerInstanceColorAppearance_default({
      translucent: false,
      flat: true
    }),
    asynchronous: false
  });
};
var TileBoundingRegion_default = TileBoundingRegion;

// node_modules/cesium/Source/Scene/TileBoundingS2Cell.js
var centerCartographicScratch = new Cartographic_default();
function TileBoundingS2Cell(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.string("options.token", options.token);
  const s2Cell = S2Cell_default.fromToken(options.token);
  const minimumHeight = defaultValue_default(options.minimumHeight, 0);
  const maximumHeight = defaultValue_default(options.maximumHeight, 0);
  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this.s2Cell = s2Cell;
  this.minimumHeight = minimumHeight;
  this.maximumHeight = maximumHeight;
  this.ellipsoid = ellipsoid;
  const boundingPlanes = computeBoundingPlanes(
    s2Cell,
    minimumHeight,
    maximumHeight,
    ellipsoid
  );
  this._boundingPlanes = boundingPlanes;
  const vertices = computeVertices(boundingPlanes);
  this._vertices = vertices;
  this._edgeNormals = new Array(6);
  this._edgeNormals[0] = computeEdgeNormals(
    boundingPlanes[0],
    vertices.slice(0, 4)
  );
  let i2;
  for (i2 = 0; i2 < 4; i2++) {
    this._edgeNormals[0][i2] = Cartesian3_default.negate(
      this._edgeNormals[0][i2],
      this._edgeNormals[0][i2]
    );
  }
  this._edgeNormals[1] = computeEdgeNormals(
    boundingPlanes[1],
    vertices.slice(4, 8)
  );
  for (i2 = 0; i2 < 4; i2++) {
    this._edgeNormals[2 + i2] = computeEdgeNormals(boundingPlanes[2 + i2], [
      vertices[i2 % 4],
      vertices[(i2 + 1) % 4],
      vertices[4 + (i2 + 1) % 4],
      vertices[4 + i2]
    ]);
  }
  this._planeVertices = [
    this._vertices.slice(0, 4),
    this._vertices.slice(4, 8)
  ];
  for (i2 = 0; i2 < 4; i2++) {
    this._planeVertices.push([
      this._vertices[i2 % 4],
      this._vertices[(i2 + 1) % 4],
      this._vertices[4 + (i2 + 1) % 4],
      this._vertices[4 + i2]
    ]);
  }
  const center = s2Cell.getCenter();
  centerCartographicScratch = ellipsoid.cartesianToCartographic(
    center,
    centerCartographicScratch
  );
  centerCartographicScratch.height = (maximumHeight + minimumHeight) / 2;
  this.center = ellipsoid.cartographicToCartesian(
    centerCartographicScratch,
    center
  );
  this._boundingSphere = BoundingSphere_default.fromPoints(vertices);
}
var centerGeodeticNormalScratch = new Cartesian3_default();
var topCartographicScratch = new Cartographic_default();
var topScratch = new Cartesian3_default();
var vertexCartographicScratch = new Cartographic_default();
var vertexScratch = new Cartesian3_default();
var vertexGeodeticNormalScratch = new Cartesian3_default();
var sideNormalScratch = new Cartesian3_default();
var sideScratch = new Cartesian3_default();
function computeBoundingPlanes(s2Cell, minimumHeight, maximumHeight, ellipsoid) {
  const planes = new Array(6);
  const centerPoint = s2Cell.getCenter();
  const centerSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
    centerPoint,
    centerGeodeticNormalScratch
  );
  const topCartographic = ellipsoid.cartesianToCartographic(
    centerPoint,
    topCartographicScratch
  );
  topCartographic.height = maximumHeight;
  const top = ellipsoid.cartographicToCartesian(topCartographic, topScratch);
  const topPlane = Plane_default.fromPointNormal(top, centerSurfaceNormal);
  planes[0] = topPlane;
  let maxDistance = 0;
  let i2;
  const vertices = [];
  let vertex, vertexCartographic;
  for (i2 = 0; i2 < 4; i2++) {
    vertex = s2Cell.getVertex(i2);
    vertices[i2] = vertex;
    vertexCartographic = ellipsoid.cartesianToCartographic(
      vertex,
      vertexCartographicScratch
    );
    vertexCartographic.height = minimumHeight;
    const distance2 = Plane_default.getPointDistance(
      topPlane,
      ellipsoid.cartographicToCartesian(vertexCartographic, vertexScratch)
    );
    if (distance2 < maxDistance) {
      maxDistance = distance2;
    }
  }
  const bottomPlane = Plane_default.clone(topPlane);
  bottomPlane.normal = Cartesian3_default.negate(
    bottomPlane.normal,
    bottomPlane.normal
  );
  bottomPlane.distance = bottomPlane.distance * -1 + maxDistance;
  planes[1] = bottomPlane;
  for (i2 = 0; i2 < 4; i2++) {
    vertex = vertices[i2];
    const adjacentVertex = vertices[(i2 + 1) % 4];
    const geodeticNormal = ellipsoid.geodeticSurfaceNormal(
      vertex,
      vertexGeodeticNormalScratch
    );
    const side = Cartesian3_default.subtract(adjacentVertex, vertex, sideScratch);
    let sideNormal = Cartesian3_default.cross(side, geodeticNormal, sideNormalScratch);
    sideNormal = Cartesian3_default.normalize(sideNormal, sideNormal);
    planes[2 + i2] = Plane_default.fromPointNormal(vertex, sideNormal);
  }
  return planes;
}
var n0Scratch = new Cartesian3_default();
var n1Scratch = new Cartesian3_default();
var n2Scratch = new Cartesian3_default();
var x0Scratch = new Cartesian3_default();
var x1Scratch = new Cartesian3_default();
var x2Scratch = new Cartesian3_default();
var t0Scratch = new Cartesian3_default();
var t1Scratch = new Cartesian3_default();
var t2Scratch = new Cartesian3_default();
var f0Scratch = new Cartesian3_default();
var f1Scratch = new Cartesian3_default();
var f2Scratch = new Cartesian3_default();
var sScratch2 = new Cartesian3_default();
var matrixScratch = new Matrix3_default();
function computeIntersection(p0, p1, p2) {
  n0Scratch = p0.normal;
  n1Scratch = p1.normal;
  n2Scratch = p2.normal;
  x0Scratch = Cartesian3_default.multiplyByScalar(p0.normal, -p0.distance, x0Scratch);
  x1Scratch = Cartesian3_default.multiplyByScalar(p1.normal, -p1.distance, x1Scratch);
  x2Scratch = Cartesian3_default.multiplyByScalar(p2.normal, -p2.distance, x2Scratch);
  f0Scratch = Cartesian3_default.multiplyByScalar(
    Cartesian3_default.cross(n1Scratch, n2Scratch, t0Scratch),
    Cartesian3_default.dot(x0Scratch, n0Scratch),
    f0Scratch
  );
  f1Scratch = Cartesian3_default.multiplyByScalar(
    Cartesian3_default.cross(n2Scratch, n0Scratch, t1Scratch),
    Cartesian3_default.dot(x1Scratch, n1Scratch),
    f1Scratch
  );
  f2Scratch = Cartesian3_default.multiplyByScalar(
    Cartesian3_default.cross(n0Scratch, n1Scratch, t2Scratch),
    Cartesian3_default.dot(x2Scratch, n2Scratch),
    f2Scratch
  );
  matrixScratch[0] = n0Scratch.x;
  matrixScratch[1] = n1Scratch.x;
  matrixScratch[2] = n2Scratch.x;
  matrixScratch[3] = n0Scratch.y;
  matrixScratch[4] = n1Scratch.y;
  matrixScratch[5] = n2Scratch.y;
  matrixScratch[6] = n0Scratch.z;
  matrixScratch[7] = n1Scratch.z;
  matrixScratch[8] = n2Scratch.z;
  const determinant = Matrix3_default.determinant(matrixScratch);
  sScratch2 = Cartesian3_default.add(f0Scratch, f1Scratch, sScratch2);
  sScratch2 = Cartesian3_default.add(sScratch2, f2Scratch, sScratch2);
  return new Cartesian3_default(
    sScratch2.x / determinant,
    sScratch2.y / determinant,
    sScratch2.z / determinant
  );
}
function computeVertices(boundingPlanes) {
  const vertices = new Array(8);
  for (let i2 = 0; i2 < 4; i2++) {
    vertices[i2] = computeIntersection(
      boundingPlanes[0],
      boundingPlanes[2 + (i2 + 3) % 4],
      boundingPlanes[2 + i2 % 4]
    );
    vertices[i2 + 4] = computeIntersection(
      boundingPlanes[1],
      boundingPlanes[2 + (i2 + 3) % 4],
      boundingPlanes[2 + i2 % 4]
    );
  }
  return vertices;
}
var edgeScratch = new Cartesian3_default();
var edgeNormalScratch = new Cartesian3_default();
function computeEdgeNormals(plane, vertices) {
  const edgeNormals = [];
  for (let i2 = 0; i2 < 4; i2++) {
    edgeScratch = Cartesian3_default.subtract(
      vertices[(i2 + 1) % 4],
      vertices[i2],
      edgeScratch
    );
    edgeNormalScratch = Cartesian3_default.cross(
      plane.normal,
      edgeScratch,
      edgeNormalScratch
    );
    edgeNormalScratch = Cartesian3_default.normalize(
      edgeNormalScratch,
      edgeNormalScratch
    );
    edgeNormals[i2] = Cartesian3_default.clone(edgeNormalScratch);
  }
  return edgeNormals;
}
Object.defineProperties(TileBoundingS2Cell.prototype, {
  boundingVolume: {
    get: function() {
      return this;
    }
  },
  boundingSphere: {
    get: function() {
      return this._boundingSphere;
    }
  }
});
var facePointScratch = new Cartesian3_default();
TileBoundingS2Cell.prototype.distanceToCamera = function(frameState) {
  Check_default.defined("frameState", frameState);
  const point = frameState.camera.positionWC;
  const selectedPlaneIndices = [];
  const vertices = [];
  let edgeNormals;
  if (Plane_default.getPointDistance(this._boundingPlanes[0], point) > 0) {
    selectedPlaneIndices.push(0);
    vertices.push(this._planeVertices[0]);
    edgeNormals = this._edgeNormals[0];
  } else if (Plane_default.getPointDistance(this._boundingPlanes[1], point) > 0) {
    selectedPlaneIndices.push(1);
    vertices.push(this._planeVertices[1]);
    edgeNormals = this._edgeNormals[1];
  }
  let i2;
  let sidePlaneIndex;
  for (i2 = 0; i2 < 4; i2++) {
    sidePlaneIndex = 2 + i2;
    if (Plane_default.getPointDistance(this._boundingPlanes[sidePlaneIndex], point) > 0) {
      selectedPlaneIndices.push(sidePlaneIndex);
      vertices.push(this._planeVertices[sidePlaneIndex]);
      edgeNormals = this._edgeNormals[sidePlaneIndex];
    }
  }
  if (selectedPlaneIndices.length === 0) {
    return 0;
  }
  let facePoint;
  let selectedPlane;
  if (selectedPlaneIndices.length === 1) {
    selectedPlane = this._boundingPlanes[selectedPlaneIndices[0]];
    facePoint = closestPointPolygon(
      Plane_default.projectPointOntoPlane(selectedPlane, point, facePointScratch),
      vertices[0],
      selectedPlane,
      edgeNormals
    );
    return Cartesian3_default.distance(facePoint, point);
  } else if (selectedPlaneIndices.length === 2) {
    if (selectedPlaneIndices[0] === 0) {
      const edge = [
        this._vertices[4 * selectedPlaneIndices[0] + (selectedPlaneIndices[1] - 2)],
        this._vertices[4 * selectedPlaneIndices[0] + (selectedPlaneIndices[1] - 2 + 1) % 4]
      ];
      facePoint = closestPointLineSegment(point, edge[0], edge[1]);
      return Cartesian3_default.distance(facePoint, point);
    }
    let minimumDistance = Number.MAX_VALUE;
    let distance2;
    for (i2 = 0; i2 < 2; i2++) {
      selectedPlane = this._boundingPlanes[selectedPlaneIndices[i2]];
      facePoint = closestPointPolygon(
        Plane_default.projectPointOntoPlane(selectedPlane, point, facePointScratch),
        vertices[i2],
        selectedPlane,
        this._edgeNormals[selectedPlaneIndices[i2]]
      );
      distance2 = Cartesian3_default.distanceSquared(facePoint, point);
      if (distance2 < minimumDistance) {
        minimumDistance = distance2;
      }
    }
    return Math.sqrt(minimumDistance);
  } else if (selectedPlaneIndices.length > 3) {
    facePoint = closestPointPolygon(
      Plane_default.projectPointOntoPlane(
        this._boundingPlanes[1],
        point,
        facePointScratch
      ),
      this._planeVertices[1],
      this._boundingPlanes[1],
      this._edgeNormals[1]
    );
    return Cartesian3_default.distance(facePoint, point);
  }
  const skip = selectedPlaneIndices[1] === 2 && selectedPlaneIndices[2] === 5 ? 0 : 1;
  if (selectedPlaneIndices[0] === 0) {
    return Cartesian3_default.distance(
      point,
      this._vertices[(selectedPlaneIndices[1] - 2 + skip) % 4]
    );
  }
  return Cartesian3_default.distance(
    point,
    this._vertices[4 + (selectedPlaneIndices[1] - 2 + skip) % 4]
  );
};
var dScratch2 = new Cartesian3_default();
var pL0Scratch = new Cartesian3_default();
function closestPointLineSegment(p2, l0, l1) {
  const d = Cartesian3_default.subtract(l1, l0, dScratch2);
  const pL0 = Cartesian3_default.subtract(p2, l0, pL0Scratch);
  let t = Cartesian3_default.dot(d, pL0);
  if (t <= 0) {
    return l0;
  }
  const dMag = Cartesian3_default.dot(d, d);
  if (t >= dMag) {
    return l1;
  }
  t = t / dMag;
  return new Cartesian3_default(
    (1 - t) * l0.x + t * l1.x,
    (1 - t) * l0.y + t * l1.y,
    (1 - t) * l0.z + t * l1.z
  );
}
var edgePlaneScratch = new Plane_default(Cartesian3_default.UNIT_X, 0);
function closestPointPolygon(p2, vertices, plane, edgeNormals) {
  let minDistance = Number.MAX_VALUE;
  let distance2;
  let closestPoint;
  let closestPointOnEdge;
  for (let i2 = 0; i2 < vertices.length; i2++) {
    const edgePlane = Plane_default.fromPointNormal(
      vertices[i2],
      edgeNormals[i2],
      edgePlaneScratch
    );
    const edgePlaneDistance = Plane_default.getPointDistance(edgePlane, p2);
    if (edgePlaneDistance < 0) {
      continue;
    }
    closestPointOnEdge = closestPointLineSegment(
      p2,
      vertices[i2],
      vertices[(i2 + 1) % 4]
    );
    distance2 = Cartesian3_default.distance(p2, closestPointOnEdge);
    if (distance2 < minDistance) {
      minDistance = distance2;
      closestPoint = closestPointOnEdge;
    }
  }
  if (!defined_default(closestPoint)) {
    return p2;
  }
  return closestPoint;
}
TileBoundingS2Cell.prototype.intersectPlane = function(plane) {
  Check_default.defined("plane", plane);
  let plusCount = 0;
  let negCount = 0;
  for (let i2 = 0; i2 < this._vertices.length; i2++) {
    const distanceToPlane = Cartesian3_default.dot(plane.normal, this._vertices[i2]) + plane.distance;
    if (distanceToPlane < 0) {
      negCount++;
    } else {
      plusCount++;
    }
  }
  if (plusCount === this._vertices.length) {
    return Intersect_default.INSIDE;
  } else if (negCount === this._vertices.length) {
    return Intersect_default.OUTSIDE;
  }
  return Intersect_default.INTERSECTING;
};
TileBoundingS2Cell.prototype.createDebugVolume = function(color) {
  Check_default.defined("color", color);
  const modelMatrix = new Matrix4_default.clone(Matrix4_default.IDENTITY);
  const topPlanePolygon = new CoplanarPolygonOutlineGeometry_default({
    polygonHierarchy: {
      positions: this._planeVertices[0]
    }
  });
  const topPlaneGeometry = CoplanarPolygonOutlineGeometry_default.createGeometry(
    topPlanePolygon
  );
  const topPlaneInstance = new GeometryInstance_default({
    geometry: topPlaneGeometry,
    id: "outline",
    modelMatrix,
    attributes: {
      color: ColorGeometryInstanceAttribute_default.fromColor(color)
    }
  });
  const bottomPlanePolygon = new CoplanarPolygonOutlineGeometry_default({
    polygonHierarchy: {
      positions: this._planeVertices[1]
    }
  });
  const bottomPlaneGeometry = CoplanarPolygonOutlineGeometry_default.createGeometry(
    bottomPlanePolygon
  );
  const bottomPlaneInstance = new GeometryInstance_default({
    geometry: bottomPlaneGeometry,
    id: "outline",
    modelMatrix,
    attributes: {
      color: ColorGeometryInstanceAttribute_default.fromColor(color)
    }
  });
  const sideInstances = [];
  for (let i2 = 0; i2 < 4; i2++) {
    const sidePlanePolygon = new CoplanarPolygonOutlineGeometry_default({
      polygonHierarchy: {
        positions: this._planeVertices[2 + i2]
      }
    });
    const sidePlaneGeometry = CoplanarPolygonOutlineGeometry_default.createGeometry(
      sidePlanePolygon
    );
    sideInstances[i2] = new GeometryInstance_default({
      geometry: sidePlaneGeometry,
      id: "outline",
      modelMatrix,
      attributes: {
        color: ColorGeometryInstanceAttribute_default.fromColor(color)
      }
    });
  }
  return new Primitive_default({
    geometryInstances: [
      sideInstances[0],
      sideInstances[1],
      sideInstances[2],
      sideInstances[3],
      bottomPlaneInstance,
      topPlaneInstance
    ],
    appearance: new PerInstanceColorAppearance_default({
      translucent: false,
      flat: true
    }),
    asynchronous: false
  });
};
var TileBoundingS2Cell_default = TileBoundingS2Cell;

// node_modules/cesium/Source/Scene/TileBoundingSphere.js
function TileBoundingSphere(center, radius) {
  if (radius === 0) {
    radius = Math_default.EPSILON7;
  }
  this._boundingSphere = new BoundingSphere_default(center, radius);
}
Object.defineProperties(TileBoundingSphere.prototype, {
  center: {
    get: function() {
      return this._boundingSphere.center;
    }
  },
  radius: {
    get: function() {
      return this._boundingSphere.radius;
    }
  },
  boundingVolume: {
    get: function() {
      return this._boundingSphere;
    }
  },
  boundingSphere: {
    get: function() {
      return this._boundingSphere;
    }
  }
});
TileBoundingSphere.prototype.distanceToCamera = function(frameState) {
  Check_default.defined("frameState", frameState);
  const boundingSphere = this._boundingSphere;
  return Math.max(
    0,
    Cartesian3_default.distance(boundingSphere.center, frameState.camera.positionWC) - boundingSphere.radius
  );
};
TileBoundingSphere.prototype.intersectPlane = function(plane) {
  Check_default.defined("plane", plane);
  return BoundingSphere_default.intersectPlane(this._boundingSphere, plane);
};
TileBoundingSphere.prototype.update = function(center, radius) {
  Cartesian3_default.clone(center, this._boundingSphere.center);
  this._boundingSphere.radius = radius;
};
TileBoundingSphere.prototype.createDebugVolume = function(color) {
  Check_default.defined("color", color);
  const geometry = new SphereOutlineGeometry_default({
    radius: this.radius
  });
  const modelMatrix = Matrix4_default.fromTranslation(
    this.center,
    new Matrix4_default.clone(Matrix4_default.IDENTITY)
  );
  const instance = new GeometryInstance_default({
    geometry,
    id: "outline",
    modelMatrix,
    attributes: {
      color: ColorGeometryInstanceAttribute_default.fromColor(color)
    }
  });
  return new Primitive_default({
    geometryInstances: instance,
    appearance: new PerInstanceColorAppearance_default({
      translucent: false,
      flat: true
    }),
    asynchronous: false
  });
};
var TileBoundingSphere_default = TileBoundingSphere;

// node_modules/cesium/Source/Scene/TileOrientedBoundingBox.js
var scratchU = new Cartesian3_default();
var scratchV = new Cartesian3_default();
var scratchW2 = new Cartesian3_default();
var scratchCartesian11 = new Cartesian3_default();
function computeMissingVector(a4, b, result) {
  result = Cartesian3_default.cross(a4, b, result);
  const magnitude = Cartesian3_default.magnitude(result);
  return Cartesian3_default.multiplyByScalar(
    result,
    Math_default.EPSILON7 / magnitude,
    result
  );
}
function findOrthogonalVector(a4, result) {
  const temp = Cartesian3_default.normalize(a4, scratchCartesian11);
  const b = Cartesian3_default.equalsEpsilon(
    temp,
    Cartesian3_default.UNIT_X,
    Math_default.EPSILON6
  ) ? Cartesian3_default.UNIT_Y : Cartesian3_default.UNIT_X;
  return computeMissingVector(a4, b, result);
}
function checkHalfAxes(halfAxes) {
  let u3 = Matrix3_default.getColumn(halfAxes, 0, scratchU);
  let v7 = Matrix3_default.getColumn(halfAxes, 1, scratchV);
  let w = Matrix3_default.getColumn(halfAxes, 2, scratchW2);
  const uZero = Cartesian3_default.equals(u3, Cartesian3_default.ZERO);
  const vZero = Cartesian3_default.equals(v7, Cartesian3_default.ZERO);
  const wZero = Cartesian3_default.equals(w, Cartesian3_default.ZERO);
  if (!uZero && !vZero && !wZero) {
    return halfAxes;
  }
  if (uZero && vZero && wZero) {
    halfAxes[0] = Math_default.EPSILON7;
    halfAxes[4] = Math_default.EPSILON7;
    halfAxes[8] = Math_default.EPSILON7;
    return halfAxes;
  }
  if (uZero && !vZero && !wZero) {
    u3 = computeMissingVector(v7, w, u3);
  } else if (!uZero && vZero && !wZero) {
    v7 = computeMissingVector(u3, w, v7);
  } else if (!uZero && !vZero && wZero) {
    w = computeMissingVector(v7, u3, w);
  } else if (!uZero) {
    v7 = findOrthogonalVector(u3, v7);
    w = computeMissingVector(v7, u3, w);
  } else if (!vZero) {
    u3 = findOrthogonalVector(v7, u3);
    w = computeMissingVector(v7, u3, w);
  } else if (!wZero) {
    u3 = findOrthogonalVector(w, u3);
    v7 = computeMissingVector(w, u3, v7);
  }
  Matrix3_default.setColumn(halfAxes, 0, u3, halfAxes);
  Matrix3_default.setColumn(halfAxes, 1, v7, halfAxes);
  Matrix3_default.setColumn(halfAxes, 2, w, halfAxes);
  return halfAxes;
}
function TileOrientedBoundingBox(center, halfAxes) {
  halfAxes = checkHalfAxes(halfAxes);
  this._orientedBoundingBox = new OrientedBoundingBox_default(center, halfAxes);
  this._boundingSphere = BoundingSphere_default.fromOrientedBoundingBox(
    this._orientedBoundingBox
  );
}
Object.defineProperties(TileOrientedBoundingBox.prototype, {
  boundingVolume: {
    get: function() {
      return this._orientedBoundingBox;
    }
  },
  boundingSphere: {
    get: function() {
      return this._boundingSphere;
    }
  }
});
TileOrientedBoundingBox.prototype.distanceToCamera = function(frameState) {
  Check_default.defined("frameState", frameState);
  return Math.sqrt(
    this._orientedBoundingBox.distanceSquaredTo(frameState.camera.positionWC)
  );
};
TileOrientedBoundingBox.prototype.intersectPlane = function(plane) {
  Check_default.defined("plane", plane);
  return this._orientedBoundingBox.intersectPlane(plane);
};
TileOrientedBoundingBox.prototype.update = function(center, halfAxes) {
  Cartesian3_default.clone(center, this._orientedBoundingBox.center);
  halfAxes = checkHalfAxes(halfAxes);
  Matrix3_default.clone(halfAxes, this._orientedBoundingBox.halfAxes);
  BoundingSphere_default.fromOrientedBoundingBox(
    this._orientedBoundingBox,
    this._boundingSphere
  );
};
TileOrientedBoundingBox.prototype.createDebugVolume = function(color) {
  Check_default.defined("color", color);
  const geometry = new BoxOutlineGeometry_default({
    minimum: new Cartesian3_default(-1, -1, -1),
    maximum: new Cartesian3_default(1, 1, 1)
  });
  const modelMatrix = Matrix4_default.fromRotationTranslation(
    this.boundingVolume.halfAxes,
    this.boundingVolume.center
  );
  const instance = new GeometryInstance_default({
    geometry,
    id: "outline",
    modelMatrix,
    attributes: {
      color: ColorGeometryInstanceAttribute_default.fromColor(color)
    }
  });
  return new Primitive_default({
    geometryInstances: instance,
    appearance: new PerInstanceColorAppearance_default({
      translucent: false,
      flat: true
    }),
    asynchronous: false
  });
};
var TileOrientedBoundingBox_default = TileOrientedBoundingBox;

// node_modules/cesium/Source/Scene/Cesium3DTile.js
function Cesium3DTile(tileset, baseResource2, header, parent) {
  this._tileset = tileset;
  this._header = header;
  const hasContentsArray = defined_default(header.contents);
  const hasMultipleContents = hasContentsArray && header.contents.length > 1 || hasExtension(header, "3DTILES_multiple_contents");
  const contentHeader = hasContentsArray && !hasMultipleContents ? header.contents[0] : header.content;
  this.transform = defined_default(header.transform) ? Matrix4_default.unpack(header.transform) : Matrix4_default.clone(Matrix4_default.IDENTITY);
  const parentTransform = defined_default(parent) ? parent.computedTransform : tileset.modelMatrix;
  const computedTransform = Matrix4_default.multiply(
    parentTransform,
    this.transform,
    new Matrix4_default()
  );
  const parentInitialTransform = defined_default(parent) ? parent._initialTransform : Matrix4_default.IDENTITY;
  this._initialTransform = Matrix4_default.multiply(
    parentInitialTransform,
    this.transform,
    new Matrix4_default()
  );
  this.computedTransform = computedTransform;
  this._boundingVolume = this.createBoundingVolume(
    header.boundingVolume,
    computedTransform
  );
  this._boundingVolume2D = void 0;
  let contentBoundingVolume;
  if (defined_default(contentHeader) && defined_default(contentHeader.boundingVolume)) {
    contentBoundingVolume = this.createBoundingVolume(
      contentHeader.boundingVolume,
      computedTransform
    );
  }
  this._contentBoundingVolume = contentBoundingVolume;
  this._contentBoundingVolume2D = void 0;
  let viewerRequestVolume;
  if (defined_default(header.viewerRequestVolume)) {
    viewerRequestVolume = this.createBoundingVolume(
      header.viewerRequestVolume,
      computedTransform
    );
  }
  this._viewerRequestVolume = viewerRequestVolume;
  this.geometricError = header.geometricError;
  this._geometricError = header.geometricError;
  if (!defined_default(this._geometricError)) {
    this._geometricError = defined_default(parent) ? parent.geometricError : tileset._geometricError;
    Cesium3DTile._deprecationWarning(
      "geometricErrorUndefined",
      "Required property geometricError is undefined for this tile. Using parent's geometric error instead."
    );
  }
  this.updateGeometricErrorScale();
  let refine;
  if (defined_default(header.refine)) {
    if (header.refine === "replace" || header.refine === "add") {
      Cesium3DTile._deprecationWarning(
        "lowercase-refine",
        `This tile uses a lowercase refine "${header.refine}". Instead use "${header.refine.toUpperCase()}".`
      );
    }
    refine = header.refine.toUpperCase() === "REPLACE" ? Cesium3DTileRefine_default.REPLACE : Cesium3DTileRefine_default.ADD;
  } else if (defined_default(parent)) {
    refine = parent.refine;
  } else {
    refine = Cesium3DTileRefine_default.REPLACE;
  }
  this.refine = refine;
  this.children = [];
  this.parent = parent;
  let content;
  let hasEmptyContent3 = false;
  let contentState;
  let contentResource;
  let serverKey;
  baseResource2 = Resource_default.createIfNeeded(baseResource2);
  if (hasMultipleContents) {
    contentState = Cesium3DTileContentState_default.UNLOADED;
    contentResource = baseResource2.clone();
  } else if (defined_default(contentHeader)) {
    let contentHeaderUri = contentHeader.uri;
    if (defined_default(contentHeader.url)) {
      Cesium3DTile._deprecationWarning(
        "contentUrl",
        'This tileset JSON uses the "content.url" property which has been deprecated. Use "content.uri" instead.'
      );
      contentHeaderUri = contentHeader.url;
    }
    contentState = Cesium3DTileContentState_default.UNLOADED;
    contentResource = baseResource2.getDerivedResource({
      url: contentHeaderUri
    });
    serverKey = RequestScheduler_default.getServerKey(
      contentResource.getUrlComponent()
    );
  } else {
    content = new Empty3DTileContent_default(tileset, this);
    hasEmptyContent3 = true;
    contentState = Cesium3DTileContentState_default.READY;
  }
  this._content = content;
  this._contentResource = contentResource;
  this._contentState = contentState;
  this._contentReadyToProcessPromise = void 0;
  this._contentReadyPromise = void 0;
  this._expiredContent = void 0;
  this._serverKey = serverKey;
  this.hasEmptyContent = hasEmptyContent3;
  this.hasTilesetContent = false;
  this.hasImplicitContent = false;
  this.hasImplicitContentMetadata = false;
  this.hasMultipleContents = hasMultipleContents;
  this.metadata = findTileMetadata(tileset, header);
  this.cacheNode = void 0;
  const expire = header.expire;
  let expireDuration;
  let expireDate;
  if (defined_default(expire)) {
    expireDuration = expire.duration;
    if (defined_default(expire.date)) {
      expireDate = JulianDate_default.fromIso8601(expire.date);
    }
  }
  this.expireDuration = expireDuration;
  this.expireDate = expireDate;
  this.lastStyleTime = 0;
  this._optimChildrenWithinParent = Cesium3DTileOptimizationHint_default.NOT_COMPUTED;
  this.clippingPlanesDirty = false;
  this.priorityDeferred = false;
  this.implicitTileset = void 0;
  this.implicitCoordinates = void 0;
  this.implicitSubtree = void 0;
  this._distanceToCamera = 0;
  this._centerZDepth = 0;
  this._screenSpaceError = 0;
  this._screenSpaceErrorProgressiveResolution = 0;
  this._visibilityPlaneMask = 0;
  this._visible = false;
  this._inRequestVolume = false;
  this._finalResolution = true;
  this._depth = 0;
  this._stackLength = 0;
  this._selectionDepth = 0;
  this._updatedVisibilityFrame = 0;
  this._touchedFrame = 0;
  this._visitedFrame = 0;
  this._selectedFrame = 0;
  this._requestedFrame = 0;
  this._ancestorWithContent = void 0;
  this._ancestorWithContentAvailable = void 0;
  this._refines = false;
  this._shouldSelect = false;
  this._isClipped = true;
  this._clippingPlanesState = 0;
  this._debugBoundingVolume = void 0;
  this._debugContentBoundingVolume = void 0;
  this._debugViewerRequestVolume = void 0;
  this._debugColor = Color_default.fromRandom({ alpha: 1 });
  this._debugColorizeTiles = false;
  this._priority = 0;
  this._priorityHolder = this;
  this._priorityProgressiveResolution = false;
  this._priorityProgressiveResolutionScreenSpaceErrorLeaf = false;
  this._priorityReverseScreenSpaceError = 0;
  this._foveatedFactor = 0;
  this._wasMinPriorityChild = false;
  this._loadTimestamp = new JulianDate_default();
  this._commandsLength = 0;
  this._color = void 0;
  this._colorDirty = false;
  this._request = void 0;
}
Cesium3DTile._deprecationWarning = deprecationWarning_default;
Object.defineProperties(Cesium3DTile.prototype, {
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  content: {
    get: function() {
      return this._content;
    }
  },
  boundingVolume: {
    get: function() {
      return this._boundingVolume;
    }
  },
  contentBoundingVolume: {
    get: function() {
      return defaultValue_default(this._contentBoundingVolume, this._boundingVolume);
    }
  },
  boundingSphere: {
    get: function() {
      return this._boundingVolume.boundingSphere;
    }
  },
  extras: {
    get: function() {
      return this._header.extras;
    }
  },
  color: {
    get: function() {
      if (!defined_default(this._color)) {
        this._color = new Color_default();
      }
      return Color_default.clone(this._color);
    },
    set: function(value) {
      this._color = Color_default.clone(value, this._color);
      this._colorDirty = true;
    }
  },
  contentAvailable: {
    get: function() {
      return this.contentReady && !this.hasEmptyContent && !this.hasTilesetContent && !this.hasImplicitContent || defined_default(this._expiredContent) && !this.contentFailed;
    }
  },
  contentReady: {
    get: function() {
      return this._contentState === Cesium3DTileContentState_default.READY;
    }
  },
  contentUnloaded: {
    get: function() {
      return this._contentState === Cesium3DTileContentState_default.UNLOADED;
    }
  },
  contentExpired: {
    get: function() {
      return this._contentState === Cesium3DTileContentState_default.EXPIRED;
    }
  },
  contentFailed: {
    get: function() {
      return this._contentState === Cesium3DTileContentState_default.FAILED;
    }
  },
  contentReadyToProcessPromise: {
    get: function() {
      if (defined_default(this._contentReadyToProcessPromise)) {
        return this._contentReadyToProcessPromise.promise;
      }
      return void 0;
    }
  },
  contentReadyPromise: {
    get: function() {
      if (defined_default(this._contentReadyPromise)) {
        return this._contentReadyPromise.promise;
      }
      return void 0;
    }
  },
  commandsLength: {
    get: function() {
      return this._commandsLength;
    }
  }
});
var scratchCartesian18 = new Cartesian3_default();
function isPriorityDeferred(tile, frameState) {
  const tileset = tile._tileset;
  const camera = frameState.camera;
  const boundingSphere = tile.boundingSphere;
  const radius = boundingSphere.radius;
  const scaledCameraDirection = Cartesian3_default.multiplyByScalar(
    camera.directionWC,
    tile._centerZDepth,
    scratchCartesian18
  );
  const closestPointOnLine = Cartesian3_default.add(
    camera.positionWC,
    scaledCameraDirection,
    scratchCartesian18
  );
  const toLine = Cartesian3_default.subtract(
    closestPointOnLine,
    boundingSphere.center,
    scratchCartesian18
  );
  const distanceToCenterLine = Cartesian3_default.magnitude(toLine);
  const notTouchingSphere = distanceToCenterLine > radius;
  if (notTouchingSphere) {
    const toLineNormalized = Cartesian3_default.normalize(toLine, scratchCartesian18);
    const scaledToLine = Cartesian3_default.multiplyByScalar(
      toLineNormalized,
      radius,
      scratchCartesian18
    );
    const closestOnSphere = Cartesian3_default.add(
      boundingSphere.center,
      scaledToLine,
      scratchCartesian18
    );
    const toClosestOnSphere = Cartesian3_default.subtract(
      closestOnSphere,
      camera.positionWC,
      scratchCartesian18
    );
    const toClosestOnSphereNormalize = Cartesian3_default.normalize(
      toClosestOnSphere,
      scratchCartesian18
    );
    tile._foveatedFactor = 1 - Math.abs(Cartesian3_default.dot(camera.directionWC, toClosestOnSphereNormalize));
  } else {
    tile._foveatedFactor = 0;
  }
  const replace = tile.refine === Cesium3DTileRefine_default.REPLACE;
  const skipLevelOfDetail2 = tileset._skipLevelOfDetail;
  if (replace && !skipLevelOfDetail2 || !tileset.foveatedScreenSpaceError || tileset.foveatedConeSize === 1 || tile._priorityProgressiveResolution && replace && skipLevelOfDetail2 || tileset._pass === Cesium3DTilePass_default.PRELOAD_FLIGHT || tileset._pass === Cesium3DTilePass_default.PRELOAD) {
    return false;
  }
  const maximumFovatedFactor = 1 - Math.cos(camera.frustum.fov * 0.5);
  const foveatedConeFactor = tileset.foveatedConeSize * maximumFovatedFactor;
  if (tile._foveatedFactor <= foveatedConeFactor) {
    return false;
  }
  const range2 = maximumFovatedFactor - foveatedConeFactor;
  const normalizedFoveatedFactor = Math_default.clamp(
    (tile._foveatedFactor - foveatedConeFactor) / range2,
    0,
    1
  );
  const sseRelaxation = tileset.foveatedInterpolationCallback(
    tileset.foveatedMinimumScreenSpaceErrorRelaxation,
    tileset.maximumScreenSpaceError,
    normalizedFoveatedFactor
  );
  const sse = tile._screenSpaceError === 0 && defined_default(tile.parent) ? tile.parent._screenSpaceError * 0.5 : tile._screenSpaceError;
  return tileset.maximumScreenSpaceError - sseRelaxation <= sse;
}
var scratchJulianDate2 = new JulianDate_default();
Cesium3DTile.prototype.getScreenSpaceError = function(frameState, useParentGeometricError, progressiveResolutionHeightFraction) {
  const tileset = this._tileset;
  const heightFraction = defaultValue_default(progressiveResolutionHeightFraction, 1);
  const parentGeometricError = defined_default(this.parent) ? this.parent.geometricError : tileset._geometricError;
  const geometricError = useParentGeometricError ? parentGeometricError : this.geometricError;
  if (geometricError === 0) {
    return 0;
  }
  const camera = frameState.camera;
  let frustum = camera.frustum;
  const context = frameState.context;
  const width = context.drawingBufferWidth;
  const height = context.drawingBufferHeight * heightFraction;
  let error;
  if (frameState.mode === SceneMode_default.SCENE2D || frustum instanceof OrthographicFrustum_default) {
    if (defined_default(frustum._offCenterFrustum)) {
      frustum = frustum._offCenterFrustum;
    }
    const pixelSize = Math.max(frustum.top - frustum.bottom, frustum.right - frustum.left) / Math.max(width, height);
    error = geometricError / pixelSize;
  } else {
    const distance2 = Math.max(this._distanceToCamera, Math_default.EPSILON7);
    const sseDenominator = camera.frustum.sseDenominator;
    error = geometricError * height / (distance2 * sseDenominator);
    if (tileset.dynamicScreenSpaceError) {
      const density = tileset._dynamicScreenSpaceErrorComputedDensity;
      const factor2 = tileset.dynamicScreenSpaceErrorFactor;
      const dynamicError = Math_default.fog(distance2, density) * factor2;
      error -= dynamicError;
    }
  }
  error /= frameState.pixelRatio;
  return error;
};
function isPriorityProgressiveResolution(tileset, tile) {
  if (tileset.progressiveResolutionHeightFraction <= 0 || tileset.progressiveResolutionHeightFraction > 0.5) {
    return false;
  }
  let isProgressiveResolutionTile = tile._screenSpaceErrorProgressiveResolution > tileset._maximumScreenSpaceError;
  tile._priorityProgressiveResolutionScreenSpaceErrorLeaf = false;
  const parent = tile.parent;
  const maximumScreenSpaceError = tileset._maximumScreenSpaceError;
  const tilePasses = tile._screenSpaceErrorProgressiveResolution <= maximumScreenSpaceError;
  const parentFails = defined_default(parent) && parent._screenSpaceErrorProgressiveResolution > maximumScreenSpaceError;
  if (tilePasses && parentFails) {
    tile._priorityProgressiveResolutionScreenSpaceErrorLeaf = true;
    isProgressiveResolutionTile = true;
  }
  return isProgressiveResolutionTile;
}
function getPriorityReverseScreenSpaceError(tileset, tile) {
  const parent = tile.parent;
  const useParentScreenSpaceError = defined_default(parent) && (!tileset._skipLevelOfDetail || tile._screenSpaceError === 0 || parent.hasTilesetContent || parent.hasImplicitContent);
  const screenSpaceError2 = useParentScreenSpaceError ? parent._screenSpaceError : tile._screenSpaceError;
  return tileset.root._screenSpaceError - screenSpaceError2;
}
Cesium3DTile.prototype.updateVisibility = function(frameState) {
  const parent = this.parent;
  const tileset = this._tileset;
  const parentTransform = defined_default(parent) ? parent.computedTransform : tileset.modelMatrix;
  const parentVisibilityPlaneMask = defined_default(parent) ? parent._visibilityPlaneMask : CullingVolume_default.MASK_INDETERMINATE;
  this.updateTransform(parentTransform);
  this._distanceToCamera = this.distanceToTile(frameState);
  this._centerZDepth = this.distanceToTileCenter(frameState);
  this._screenSpaceError = this.getScreenSpaceError(frameState, false);
  this._screenSpaceErrorProgressiveResolution = this.getScreenSpaceError(
    frameState,
    false,
    tileset.progressiveResolutionHeightFraction
  );
  this._visibilityPlaneMask = this.visibility(
    frameState,
    parentVisibilityPlaneMask
  );
  this._visible = this._visibilityPlaneMask !== CullingVolume_default.MASK_OUTSIDE;
  this._inRequestVolume = this.insideViewerRequestVolume(frameState);
  this._priorityReverseScreenSpaceError = getPriorityReverseScreenSpaceError(
    tileset,
    this
  );
  this._priorityProgressiveResolution = isPriorityProgressiveResolution(
    tileset,
    this
  );
  this.priorityDeferred = isPriorityDeferred(this, frameState);
};
Cesium3DTile.prototype.updateExpiration = function() {
  if (defined_default(this.expireDate) && this.contentReady && !this.hasEmptyContent && !this.hasMultipleContents) {
    const now = JulianDate_default.now(scratchJulianDate2);
    if (JulianDate_default.lessThan(this.expireDate, now)) {
      this._contentState = Cesium3DTileContentState_default.EXPIRED;
      this._expiredContent = this._content;
    }
  }
};
function updateExpireDate(tile) {
  if (defined_default(tile.expireDuration)) {
    const expireDurationDate = JulianDate_default.now(scratchJulianDate2);
    JulianDate_default.addSeconds(
      expireDurationDate,
      tile.expireDuration,
      expireDurationDate
    );
    if (defined_default(tile.expireDate)) {
      if (JulianDate_default.lessThan(tile.expireDate, expireDurationDate)) {
        JulianDate_default.clone(expireDurationDate, tile.expireDate);
      }
    } else {
      tile.expireDate = JulianDate_default.clone(expireDurationDate);
    }
  }
}
function createPriorityFunction(tile) {
  return function() {
    return tile._priority;
  };
}
Cesium3DTile.prototype.requestContent = function() {
  if (this.hasEmptyContent) {
    return 0;
  }
  if (this.hasMultipleContents) {
    return requestMultipleContents(this);
  }
  return requestSingleContent(this);
};
function requestMultipleContents(tile) {
  let multipleContents = tile._content;
  const tileset = tile._tileset;
  if (!defined_default(multipleContents)) {
    const contentsJson = hasExtension(tile._header, "3DTILES_multiple_contents") ? tile._header.extensions["3DTILES_multiple_contents"] : tile._header;
    multipleContents = new Multiple3DTileContent(
      tileset,
      tile,
      tile._contentResource.clone(),
      contentsJson
    );
    tile._content = multipleContents;
  }
  const backloggedRequestCount = multipleContents.requestInnerContents();
  if (backloggedRequestCount > 0) {
    return backloggedRequestCount;
  }
  tile._contentState = Cesium3DTileContentState_default.LOADING;
  tile._contentReadyToProcessPromise = defer_default();
  tile._contentReadyPromise = defer_default();
  multipleContents.contentsFetchedPromise.then(function() {
    if (tile._contentState !== Cesium3DTileContentState_default.LOADING) {
      return;
    }
    if (tile.isDestroyed()) {
      multipleContentFailed(
        tile,
        tileset,
        "Tile was unloaded while content was loading"
      );
      return;
    }
    tile._contentState = Cesium3DTileContentState_default.PROCESSING;
    tile._contentReadyToProcessPromise.resolve(multipleContents);
    return multipleContents.readyPromise.then(function(content) {
      if (tile.isDestroyed()) {
        multipleContentFailed(
          tile,
          tileset,
          "Tile was unloaded while content was processing"
        );
        return;
      }
      tile._selectedFrame = 0;
      tile.lastStyleTime = 0;
      JulianDate_default.now(tile._loadTimestamp);
      tile._contentState = Cesium3DTileContentState_default.READY;
      tile._contentReadyPromise.resolve(content);
    });
  }).catch(function(error) {
    multipleContentFailed(tile, tileset, error);
  });
  return 0;
}
function multipleContentFailed(tile, tileset, error) {
  if (tile._contentState === Cesium3DTileContentState_default.PROCESSING) {
    --tileset.statistics.numberOfTilesProcessing;
  }
  tile._contentState = Cesium3DTileContentState_default.FAILED;
  tile._contentReadyPromise.reject(error);
  tile._contentReadyToProcessPromise.reject(error);
}
function requestSingleContent(tile) {
  const resource = tile._contentResource.clone();
  const expired = tile.contentExpired;
  if (expired) {
    resource.setQueryParameters({
      expired: tile.expireDate.toString()
    });
  }
  const request = new Request_default({
    throttle: true,
    throttleByServer: true,
    type: RequestType_default.TILES3D,
    priorityFunction: createPriorityFunction(tile),
    serverKey: tile._serverKey
  });
  tile._request = request;
  resource.request = request;
  const promise = resource.fetchArrayBuffer();
  if (!defined_default(promise)) {
    return 1;
  }
  const previousState = tile._contentState;
  const tileset = tile._tileset;
  tile._contentState = Cesium3DTileContentState_default.LOADING;
  tile._contentReadyToProcessPromise = defer_default();
  tile._contentReadyPromise = defer_default();
  ++tileset.statistics.numberOfPendingRequests;
  promise.then(function(arrayBuffer) {
    if (tile.isDestroyed()) {
      singleContentFailed(tile, tileset);
      return;
    }
    const content = makeContent(tile, arrayBuffer);
    if (expired) {
      tile.expireDate = void 0;
    }
    tile._content = content;
    tile._contentState = Cesium3DTileContentState_default.PROCESSING;
    tile._contentReadyToProcessPromise.resolve(content);
    --tileset.statistics.numberOfPendingRequests;
    return content.readyPromise.then(function(content2) {
      if (tile.isDestroyed()) {
        singleContentFailed(tile, tileset);
        return;
      }
      updateExpireDate(tile);
      tile._selectedFrame = 0;
      tile.lastStyleTime = 0;
      JulianDate_default.now(tile._loadTimestamp);
      tile._contentState = Cesium3DTileContentState_default.READY;
      tile._contentReadyPromise.resolve(content2);
    });
  }).catch(function(error) {
    if (request.state === RequestState_default.CANCELLED) {
      tile._contentState = previousState;
      --tileset.statistics.numberOfPendingRequests;
      ++tileset.statistics.numberOfAttemptedRequests;
      return;
    }
    singleContentFailed(tile, tileset, error);
  });
  return 0;
}
function singleContentFailed(tile, tileset, error) {
  if (tile._contentState === Cesium3DTileContentState_default.PROCESSING) {
    --tileset.statistics.numberOfTilesProcessing;
  } else {
    --tileset.statistics.numberOfPendingRequests;
  }
  tile._contentState = Cesium3DTileContentState_default.FAILED;
  tile._contentReadyPromise.reject(error);
  tile._contentReadyToProcessPromise.reject(error);
}
function makeContent(tile, arrayBuffer) {
  const preprocessed = preprocess3DTileContent(arrayBuffer);
  const tileset = tile._tileset;
  tileset._disableSkipLevelOfDetail = tileset._disableSkipLevelOfDetail || preprocessed.contentType === Cesium3DTileContentType_default.GEOMETRY || preprocessed.contentType === Cesium3DTileContentType_default.VECTOR;
  if (preprocessed.contentType === Cesium3DTileContentType_default.IMPLICIT_SUBTREE || preprocessed.contentType === Cesium3DTileContentType_default.IMPLICIT_SUBTREE_JSON) {
    tile.hasImplicitContent = true;
  }
  if (preprocessed.contentType === Cesium3DTileContentType_default.EXTERNAL_TILESET) {
    tile.hasTilesetContent = true;
  }
  let content;
  const contentFactory = Cesium3DTileContentFactory_default[preprocessed.contentType];
  if (defined_default(preprocessed.binaryPayload)) {
    content = contentFactory(
      tileset,
      tile,
      tile._contentResource,
      preprocessed.binaryPayload.buffer,
      0
    );
  } else {
    content = contentFactory(
      tileset,
      tile,
      tile._contentResource,
      preprocessed.jsonPayload
    );
  }
  const contentHeader = defined_default(tile._header.contents) ? tile._header.contents[0] : tile._header.content;
  if (tile.hasImplicitContentMetadata) {
    const subtree = tile.implicitSubtree;
    const coordinates = tile.implicitCoordinates;
    content.metadata = subtree.getContentMetadataView(coordinates, 0);
  } else if (!tile.hasImplicitContent) {
    content.metadata = findContentMetadata(tileset, contentHeader);
  }
  const groupMetadata = findGroupMetadata(tileset, contentHeader);
  if (defined_default(groupMetadata)) {
    content.group = new Cesium3DContentGroup({
      metadata: groupMetadata
    });
  }
  return content;
}
Cesium3DTile.prototype.cancelRequests = function() {
  if (this.hasMultipleContents) {
    this._content.cancelRequests();
  } else {
    this._request.cancel();
  }
};
Cesium3DTile.prototype.unloadContent = function() {
  if (this.hasEmptyContent || this.hasTilesetContent || this.hasImplicitContent) {
    return;
  }
  this._content = this._content && this._content.destroy();
  this._contentState = Cesium3DTileContentState_default.UNLOADED;
  this._contentReadyToProcessPromise = void 0;
  this._contentReadyPromise = void 0;
  this.lastStyleTime = 0;
  this.clippingPlanesDirty = this._clippingPlanesState === 0;
  this._clippingPlanesState = 0;
  this._debugColorizeTiles = false;
  this._debugBoundingVolume = this._debugBoundingVolume && this._debugBoundingVolume.destroy();
  this._debugContentBoundingVolume = this._debugContentBoundingVolume && this._debugContentBoundingVolume.destroy();
  this._debugViewerRequestVolume = this._debugViewerRequestVolume && this._debugViewerRequestVolume.destroy();
};
var scratchProjectedBoundingSphere = new BoundingSphere_default();
function getBoundingVolume(tile, frameState) {
  if (frameState.mode !== SceneMode_default.SCENE3D && !defined_default(tile._boundingVolume2D)) {
    const boundingSphere = tile._boundingVolume.boundingSphere;
    const sphere = BoundingSphere_default.projectTo2D(
      boundingSphere,
      frameState.mapProjection,
      scratchProjectedBoundingSphere
    );
    tile._boundingVolume2D = new TileBoundingSphere_default(
      sphere.center,
      sphere.radius
    );
  }
  return frameState.mode !== SceneMode_default.SCENE3D ? tile._boundingVolume2D : tile._boundingVolume;
}
function getContentBoundingVolume2(tile, frameState) {
  if (frameState.mode !== SceneMode_default.SCENE3D && !defined_default(tile._contentBoundingVolume2D)) {
    const boundingSphere = tile._contentBoundingVolume.boundingSphere;
    const sphere = BoundingSphere_default.projectTo2D(
      boundingSphere,
      frameState.mapProjection,
      scratchProjectedBoundingSphere
    );
    tile._contentBoundingVolume2D = new TileBoundingSphere_default(
      sphere.center,
      sphere.radius
    );
  }
  return frameState.mode !== SceneMode_default.SCENE3D ? tile._contentBoundingVolume2D : tile._contentBoundingVolume;
}
Cesium3DTile.prototype.visibility = function(frameState, parentVisibilityPlaneMask) {
  const cullingVolume = frameState.cullingVolume;
  const boundingVolume = getBoundingVolume(this, frameState);
  const tileset = this._tileset;
  const clippingPlanes = tileset.clippingPlanes;
  if (defined_default(clippingPlanes) && clippingPlanes.enabled) {
    const intersection = clippingPlanes.computeIntersectionWithBoundingVolume(
      boundingVolume,
      tileset.clippingPlanesOriginMatrix
    );
    this._isClipped = intersection !== Intersect_default.INSIDE;
    if (intersection === Intersect_default.OUTSIDE) {
      return CullingVolume_default.MASK_OUTSIDE;
    }
  }
  return cullingVolume.computeVisibilityWithPlaneMask(
    boundingVolume,
    parentVisibilityPlaneMask
  );
};
Cesium3DTile.prototype.contentVisibility = function(frameState) {
  if (!defined_default(this._contentBoundingVolume)) {
    return Intersect_default.INSIDE;
  }
  if (this._visibilityPlaneMask === CullingVolume_default.MASK_INSIDE) {
    return Intersect_default.INSIDE;
  }
  const cullingVolume = frameState.cullingVolume;
  const boundingVolume = getContentBoundingVolume2(this, frameState);
  const tileset = this._tileset;
  const clippingPlanes = tileset.clippingPlanes;
  if (defined_default(clippingPlanes) && clippingPlanes.enabled) {
    const intersection = clippingPlanes.computeIntersectionWithBoundingVolume(
      boundingVolume,
      tileset.clippingPlanesOriginMatrix
    );
    this._isClipped = intersection !== Intersect_default.INSIDE;
    if (intersection === Intersect_default.OUTSIDE) {
      return Intersect_default.OUTSIDE;
    }
  }
  return cullingVolume.computeVisibility(boundingVolume);
};
Cesium3DTile.prototype.distanceToTile = function(frameState) {
  const boundingVolume = getBoundingVolume(this, frameState);
  return boundingVolume.distanceToCamera(frameState);
};
var scratchToTileCenter = new Cartesian3_default();
Cesium3DTile.prototype.distanceToTileCenter = function(frameState) {
  const tileBoundingVolume = getBoundingVolume(this, frameState);
  const boundingVolume = tileBoundingVolume.boundingVolume;
  const toCenter = Cartesian3_default.subtract(
    boundingVolume.center,
    frameState.camera.positionWC,
    scratchToTileCenter
  );
  return Cartesian3_default.dot(frameState.camera.directionWC, toCenter);
};
Cesium3DTile.prototype.insideViewerRequestVolume = function(frameState) {
  const viewerRequestVolume = this._viewerRequestVolume;
  return !defined_default(viewerRequestVolume) || viewerRequestVolume.distanceToCamera(frameState) === 0;
};
var scratchMatrix4 = new Matrix3_default();
var scratchScale4 = new Cartesian3_default();
var scratchHalfAxes2 = new Matrix3_default();
var scratchCenter5 = new Cartesian3_default();
var scratchRectangle4 = new Rectangle_default();
var scratchOrientedBoundingBox = new OrientedBoundingBox_default();
var scratchTransform = new Matrix4_default();
function createBox(box, transform4, result) {
  let center = Cartesian3_default.fromElements(box[0], box[1], box[2], scratchCenter5);
  let halfAxes = Matrix3_default.fromArray(box, 3, scratchHalfAxes2);
  center = Matrix4_default.multiplyByPoint(transform4, center, center);
  const rotationScale = Matrix4_default.getMatrix3(transform4, scratchMatrix4);
  halfAxes = Matrix3_default.multiply(rotationScale, halfAxes, halfAxes);
  if (defined_default(result)) {
    result.update(center, halfAxes);
    return result;
  }
  return new TileOrientedBoundingBox_default(center, halfAxes);
}
function createBoxFromTransformedRegion(region, transform4, initialTransform, result) {
  const rectangle = Rectangle_default.unpack(region, 0, scratchRectangle4);
  const minimumHeight = region[4];
  const maximumHeight = region[5];
  const orientedBoundingBox = OrientedBoundingBox_default.fromRectangle(
    rectangle,
    minimumHeight,
    maximumHeight,
    Ellipsoid_default.WGS84,
    scratchOrientedBoundingBox
  );
  let center = orientedBoundingBox.center;
  let halfAxes = orientedBoundingBox.halfAxes;
  transform4 = Matrix4_default.multiplyTransformation(
    transform4,
    Matrix4_default.inverseTransformation(initialTransform, scratchTransform),
    scratchTransform
  );
  center = Matrix4_default.multiplyByPoint(transform4, center, center);
  const rotationScale = Matrix4_default.getMatrix3(transform4, scratchMatrix4);
  halfAxes = Matrix3_default.multiply(rotationScale, halfAxes, halfAxes);
  if (defined_default(result) && result instanceof TileOrientedBoundingBox_default) {
    result.update(center, halfAxes);
    return result;
  }
  return new TileOrientedBoundingBox_default(center, halfAxes);
}
function createRegion(region, transform4, initialTransform, result) {
  if (!Matrix4_default.equalsEpsilon(transform4, initialTransform, Math_default.EPSILON8)) {
    return createBoxFromTransformedRegion(
      region,
      transform4,
      initialTransform,
      result
    );
  }
  if (defined_default(result)) {
    return result;
  }
  const rectangleRegion = Rectangle_default.unpack(region, 0, scratchRectangle4);
  return new TileBoundingRegion_default({
    rectangle: rectangleRegion,
    minimumHeight: region[4],
    maximumHeight: region[5]
  });
}
function createSphere(sphere, transform4, result) {
  let center = Cartesian3_default.fromElements(
    sphere[0],
    sphere[1],
    sphere[2],
    scratchCenter5
  );
  let radius = sphere[3];
  center = Matrix4_default.multiplyByPoint(transform4, center, center);
  const scale = Matrix4_default.getScale(transform4, scratchScale4);
  const uniformScale = Cartesian3_default.maximumComponent(scale);
  radius *= uniformScale;
  if (defined_default(result)) {
    result.update(center, radius);
    return result;
  }
  return new TileBoundingSphere_default(center, radius);
}
Cesium3DTile.prototype.createBoundingVolume = function(boundingVolumeHeader, transform4, result) {
  if (!defined_default(boundingVolumeHeader)) {
    throw new RuntimeError_default("boundingVolume must be defined");
  }
  if (hasExtension(boundingVolumeHeader, "3DTILES_bounding_volume_S2")) {
    return new TileBoundingS2Cell_default(
      boundingVolumeHeader.extensions["3DTILES_bounding_volume_S2"]
    );
  }
  if (defined_default(boundingVolumeHeader.box)) {
    return createBox(boundingVolumeHeader.box, transform4, result);
  }
  if (defined_default(boundingVolumeHeader.region)) {
    return createRegion(
      boundingVolumeHeader.region,
      transform4,
      this._initialTransform,
      result
    );
  }
  if (defined_default(boundingVolumeHeader.sphere)) {
    return createSphere(boundingVolumeHeader.sphere, transform4, result);
  }
  throw new RuntimeError_default(
    "boundingVolume must contain a sphere, region, or box"
  );
};
Cesium3DTile.prototype.updateTransform = function(parentTransform) {
  parentTransform = defaultValue_default(parentTransform, Matrix4_default.IDENTITY);
  const computedTransform = Matrix4_default.multiply(
    parentTransform,
    this.transform,
    scratchTransform
  );
  const transformChanged = !Matrix4_default.equals(
    computedTransform,
    this.computedTransform
  );
  if (!transformChanged) {
    return;
  }
  Matrix4_default.clone(computedTransform, this.computedTransform);
  const header = this._header;
  const content = this._header.content;
  this._boundingVolume = this.createBoundingVolume(
    header.boundingVolume,
    this.computedTransform,
    this._boundingVolume
  );
  if (defined_default(this._contentBoundingVolume)) {
    this._contentBoundingVolume = this.createBoundingVolume(
      content.boundingVolume,
      this.computedTransform,
      this._contentBoundingVolume
    );
  }
  if (defined_default(this._viewerRequestVolume)) {
    this._viewerRequestVolume = this.createBoundingVolume(
      header.viewerRequestVolume,
      this.computedTransform,
      this._viewerRequestVolume
    );
  }
  this.updateGeometricErrorScale();
  this._debugBoundingVolume = this._debugBoundingVolume && this._debugBoundingVolume.destroy();
  this._debugContentBoundingVolume = this._debugContentBoundingVolume && this._debugContentBoundingVolume.destroy();
  this._debugViewerRequestVolume = this._debugViewerRequestVolume && this._debugViewerRequestVolume.destroy();
};
Cesium3DTile.prototype.updateGeometricErrorScale = function() {
  const scale = Matrix4_default.getScale(this.computedTransform, scratchScale4);
  const uniformScale = Cartesian3_default.maximumComponent(scale);
  this.geometricError = this._geometricError * uniformScale;
};
function applyDebugSettings(tile, tileset, frameState, passOptions2) {
  if (!passOptions2.isRender) {
    return;
  }
  const hasContentBoundingVolume = defined_default(tile._header.content) && defined_default(tile._header.content.boundingVolume);
  const empty = tile.hasEmptyContent || tile.hasTilesetContent || tile.hasImplicitContent;
  const showVolume = tileset.debugShowBoundingVolume || tileset.debugShowContentBoundingVolume && !hasContentBoundingVolume;
  if (showVolume) {
    let color;
    if (!tile._finalResolution) {
      color = Color_default.YELLOW;
    } else if (empty) {
      color = Color_default.DARKGRAY;
    } else {
      color = Color_default.WHITE;
    }
    if (!defined_default(tile._debugBoundingVolume)) {
      tile._debugBoundingVolume = tile._boundingVolume.createDebugVolume(color);
    }
    tile._debugBoundingVolume.update(frameState);
    const attributes = tile._debugBoundingVolume.getGeometryInstanceAttributes(
      "outline"
    );
    attributes.color = ColorGeometryInstanceAttribute_default.toValue(
      color,
      attributes.color
    );
  } else if (!showVolume && defined_default(tile._debugBoundingVolume)) {
    tile._debugBoundingVolume = tile._debugBoundingVolume.destroy();
  }
  if (tileset.debugShowContentBoundingVolume && hasContentBoundingVolume) {
    if (!defined_default(tile._debugContentBoundingVolume)) {
      tile._debugContentBoundingVolume = tile._contentBoundingVolume.createDebugVolume(
        Color_default.BLUE
      );
    }
    tile._debugContentBoundingVolume.update(frameState);
  } else if (!tileset.debugShowContentBoundingVolume && defined_default(tile._debugContentBoundingVolume)) {
    tile._debugContentBoundingVolume = tile._debugContentBoundingVolume.destroy();
  }
  if (tileset.debugShowViewerRequestVolume && defined_default(tile._viewerRequestVolume)) {
    if (!defined_default(tile._debugViewerRequestVolume)) {
      tile._debugViewerRequestVolume = tile._viewerRequestVolume.createDebugVolume(
        Color_default.YELLOW
      );
    }
    tile._debugViewerRequestVolume.update(frameState);
  } else if (!tileset.debugShowViewerRequestVolume && defined_default(tile._debugViewerRequestVolume)) {
    tile._debugViewerRequestVolume = tile._debugViewerRequestVolume.destroy();
  }
  const debugColorizeTilesOn = tileset.debugColorizeTiles && !tile._debugColorizeTiles || defined_default(tileset._heatmap.tilePropertyName);
  const debugColorizeTilesOff = !tileset.debugColorizeTiles && tile._debugColorizeTiles;
  if (debugColorizeTilesOn) {
    tileset._heatmap.colorize(tile, frameState);
    tile._debugColorizeTiles = true;
    tile.color = tile._debugColor;
  } else if (debugColorizeTilesOff) {
    tile._debugColorizeTiles = false;
    tile.color = Color_default.WHITE;
  }
  if (tile._colorDirty) {
    tile._colorDirty = false;
    tile._content.applyDebugSettings(true, tile._color);
  }
  if (debugColorizeTilesOff) {
    tileset.makeStyleDirty();
  }
}
function updateContent(tile, tileset, frameState) {
  const content = tile._content;
  const expiredContent = tile._expiredContent;
  if (!tile.hasMultipleContents && defined_default(expiredContent)) {
    if (!tile.contentReady) {
      expiredContent.update(tileset, frameState);
      return;
    }
    tile._expiredContent.destroy();
    tile._expiredContent = void 0;
  }
  content.update(tileset, frameState);
}
function updateClippingPlanes2(tile, tileset) {
  const clippingPlanes = tileset.clippingPlanes;
  let currentClippingPlanesState = 0;
  if (defined_default(clippingPlanes) && tile._isClipped && clippingPlanes.enabled) {
    currentClippingPlanesState = clippingPlanes.clippingPlanesState;
  }
  if (currentClippingPlanesState !== tile._clippingPlanesState) {
    tile._clippingPlanesState = currentClippingPlanesState;
    tile.clippingPlanesDirty = true;
  }
}
Cesium3DTile.prototype.update = function(tileset, frameState, passOptions2) {
  const commandStart = frameState.commandList.length;
  updateClippingPlanes2(this, tileset);
  applyDebugSettings(this, tileset, frameState, passOptions2);
  updateContent(this, tileset, frameState);
  const commandEnd = frameState.commandList.length;
  const commandsLength = commandEnd - commandStart;
  this._commandsLength = commandsLength;
  for (let i2 = 0; i2 < commandsLength; ++i2) {
    const command = frameState.commandList[commandStart + i2];
    const translucent = command.pass === Pass_default.TRANSLUCENT;
    command.depthForTranslucentClassification = translucent;
  }
  this.clippingPlanesDirty = false;
};
var scratchCommandList = [];
Cesium3DTile.prototype.process = function(tileset, frameState) {
  const savedCommandList = frameState.commandList;
  frameState.commandList = scratchCommandList;
  this._content.update(tileset, frameState);
  scratchCommandList.length = 0;
  frameState.commandList = savedCommandList;
};
function isolateDigits(normalizedValue, numberOfDigits, leftShift) {
  const scaled = normalizedValue * Math.pow(10, numberOfDigits);
  const integer = parseInt(scaled);
  return integer * Math.pow(10, leftShift);
}
function priorityNormalizeAndClamp(value, minimum, maximum) {
  return Math.max(
    Math_default.normalize(value, minimum, maximum) - Math_default.EPSILON7,
    0
  );
}
Cesium3DTile.prototype.updatePriority = function() {
  const tileset = this.tileset;
  const preferLeaves = tileset.preferLeaves;
  const minimumPriority = tileset._minimumPriority;
  const maximumPriority = tileset._maximumPriority;
  const digitsForANumber = 4;
  const digitsForABoolean = 1;
  const preferredSortingLeftShift = 0;
  const preferredSortingDigitsCount = digitsForANumber;
  const foveatedLeftShift = preferredSortingLeftShift + preferredSortingDigitsCount;
  const foveatedDigitsCount = digitsForANumber;
  const preloadProgressiveResolutionLeftShift = foveatedLeftShift + foveatedDigitsCount;
  const preloadProgressiveResolutionDigitsCount = digitsForABoolean;
  const preloadProgressiveResolutionScale = Math.pow(
    10,
    preloadProgressiveResolutionLeftShift
  );
  const foveatedDeferLeftShift = preloadProgressiveResolutionLeftShift + preloadProgressiveResolutionDigitsCount;
  const foveatedDeferDigitsCount = digitsForABoolean;
  const foveatedDeferScale = Math.pow(10, foveatedDeferLeftShift);
  const preloadFlightLeftShift = foveatedDeferLeftShift + foveatedDeferDigitsCount;
  const preloadFlightScale = Math.pow(10, preloadFlightLeftShift);
  let depthDigits = priorityNormalizeAndClamp(
    this._depth,
    minimumPriority.depth,
    maximumPriority.depth
  );
  depthDigits = preferLeaves ? 1 - depthDigits : depthDigits;
  const useDistance = !tileset._skipLevelOfDetail && this.refine === Cesium3DTileRefine_default.REPLACE;
  const normalizedPreferredSorting = useDistance ? priorityNormalizeAndClamp(
    this._priorityHolder._distanceToCamera,
    minimumPriority.distance,
    maximumPriority.distance
  ) : priorityNormalizeAndClamp(
    this._priorityReverseScreenSpaceError,
    minimumPriority.reverseScreenSpaceError,
    maximumPriority.reverseScreenSpaceError
  );
  const preferredSortingDigits = isolateDigits(
    normalizedPreferredSorting,
    preferredSortingDigitsCount,
    preferredSortingLeftShift
  );
  const preloadProgressiveResolutionDigits = this._priorityProgressiveResolution ? 0 : preloadProgressiveResolutionScale;
  const normalizedFoveatedFactor = priorityNormalizeAndClamp(
    this._priorityHolder._foveatedFactor,
    minimumPriority.foveatedFactor,
    maximumPriority.foveatedFactor
  );
  const foveatedDigits = isolateDigits(
    normalizedFoveatedFactor,
    foveatedDigitsCount,
    foveatedLeftShift
  );
  const foveatedDeferDigits = this.priorityDeferred ? foveatedDeferScale : 0;
  const preloadFlightDigits = tileset._pass === Cesium3DTilePass_default.PRELOAD_FLIGHT ? 0 : preloadFlightScale;
  this._priority = depthDigits + preferredSortingDigits + preloadProgressiveResolutionDigits + foveatedDigits + foveatedDeferDigits + preloadFlightDigits;
};
Cesium3DTile.prototype.isDestroyed = function() {
  return false;
};
Cesium3DTile.prototype.destroy = function() {
  this._content = this._content && this._content.destroy();
  this._expiredContent = this._expiredContent && !this._expiredContent.isDestroyed() && this._expiredContent.destroy();
  this._debugBoundingVolume = this._debugBoundingVolume && this._debugBoundingVolume.destroy();
  this._debugContentBoundingVolume = this._debugContentBoundingVolume && this._debugContentBoundingVolume.destroy();
  this._debugViewerRequestVolume = this._debugViewerRequestVolume && this._debugViewerRequestVolume.destroy();
  return destroyObject_default(this);
};
var Cesium3DTile_default = Cesium3DTile;

// node_modules/cesium/Source/Scene/GroupMetadata.js
function GroupMetadata(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const id = options.id;
  const group = options.group;
  const metadataClass = options.class;
  Check_default.typeOf.object("options.group", group);
  Check_default.typeOf.object("options.class", metadataClass);
  const properties = defined_default(group.properties) ? group.properties : {};
  this._class = metadataClass;
  this._properties = properties;
  this._id = id;
  this._extras = group.extras;
  this._extensions = group.extensions;
}
Object.defineProperties(GroupMetadata.prototype, {
  class: {
    get: function() {
      return this._class;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
GroupMetadata.prototype.hasProperty = function(propertyId) {
  return MetadataEntity_default.hasProperty(propertyId, this._properties, this._class);
};
GroupMetadata.prototype.hasPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.hasPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
GroupMetadata.prototype.getPropertyIds = function(results) {
  return MetadataEntity_default.getPropertyIds(this._properties, this._class, results);
};
GroupMetadata.prototype.getProperty = function(propertyId) {
  return MetadataEntity_default.getProperty(propertyId, this._properties, this._class);
};
GroupMetadata.prototype.setProperty = function(propertyId, value) {
  return MetadataEntity_default.setProperty(
    propertyId,
    value,
    this._properties,
    this._class
  );
};
GroupMetadata.prototype.getPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.getPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
GroupMetadata.prototype.setPropertyBySemantic = function(semantic, value) {
  return MetadataEntity_default.setPropertyBySemantic(
    semantic,
    value,
    this._properties,
    this._class
  );
};
var GroupMetadata_default = GroupMetadata;

// node_modules/cesium/Source/Scene/TilesetMetadata.js
function TilesetMetadata(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const tileset = options.tileset;
  const metadataClass = options.class;
  Check_default.typeOf.object("options.tileset", tileset);
  Check_default.typeOf.object("options.class", metadataClass);
  const properties = defined_default(tileset.properties) ? tileset.properties : {};
  this._class = metadataClass;
  this._properties = properties;
  this._extras = tileset.extras;
  this._extensions = tileset.extensions;
}
Object.defineProperties(TilesetMetadata.prototype, {
  class: {
    get: function() {
      return this._class;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
TilesetMetadata.prototype.hasProperty = function(propertyId) {
  return MetadataEntity_default.hasProperty(propertyId, this._properties, this._class);
};
TilesetMetadata.prototype.hasPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.hasPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
TilesetMetadata.prototype.getPropertyIds = function(results) {
  return MetadataEntity_default.getPropertyIds(this._properties, this._class, results);
};
TilesetMetadata.prototype.getProperty = function(propertyId) {
  return MetadataEntity_default.getProperty(propertyId, this._properties, this._class);
};
TilesetMetadata.prototype.setProperty = function(propertyId, value) {
  return MetadataEntity_default.setProperty(
    propertyId,
    value,
    this._properties,
    this._class
  );
};
TilesetMetadata.prototype.getPropertyBySemantic = function(semantic) {
  return MetadataEntity_default.getPropertyBySemantic(
    semantic,
    this._properties,
    this._class
  );
};
TilesetMetadata.prototype.setPropertyBySemantic = function(semantic, value) {
  return MetadataEntity_default.setPropertyBySemantic(
    semantic,
    value,
    this._properties,
    this._class
  );
};
var TilesetMetadata_default = TilesetMetadata;

// node_modules/cesium/Source/Scene/Cesium3DTilesetMetadata.js
function Cesium3DTilesetMetadata(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const metadataJson = options.metadataJson;
  const schema = options.schema;
  Check_default.typeOf.object("options.metadataJson", metadataJson);
  Check_default.typeOf.object("options.schema", schema);
  const metadata = defaultValue_default(metadataJson.metadata, metadataJson.tileset);
  let tileset;
  if (defined_default(metadata)) {
    tileset = new TilesetMetadata_default({
      tileset: metadata,
      class: schema.classes[metadata.class]
    });
  }
  let groupIds = [];
  const groups = [];
  const groupsJson = metadataJson.groups;
  if (Array.isArray(groupsJson)) {
    const length3 = groupsJson.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const group = groupsJson[i2];
      groups.push(
        new GroupMetadata_default({
          group,
          class: schema.classes[group.class]
        })
      );
    }
  } else if (defined_default(groupsJson)) {
    groupIds = Object.keys(groupsJson).sort();
    const length3 = groupIds.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const groupId = groupIds[i2];
      if (groupsJson.hasOwnProperty(groupId)) {
        const group = groupsJson[groupId];
        groups.push(
          new GroupMetadata_default({
            id: groupId,
            group: groupsJson[groupId],
            class: schema.classes[group.class]
          })
        );
      }
    }
  }
  this._schema = schema;
  this._groups = groups;
  this._groupIds = groupIds;
  this._tileset = tileset;
  this._statistics = metadataJson.statistics;
  this._extras = metadataJson.extras;
  this._extensions = metadataJson.extensions;
}
Object.defineProperties(Cesium3DTilesetMetadata.prototype, {
  schema: {
    get: function() {
      return this._schema;
    }
  },
  groups: {
    get: function() {
      return this._groups;
    }
  },
  groupIds: {
    get: function() {
      return this._groupIds;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    }
  },
  statistics: {
    get: function() {
      return this._statistics;
    }
  },
  extras: {
    get: function() {
      return this._extras;
    }
  },
  extensions: {
    get: function() {
      return this._extensions;
    }
  }
});
var Cesium3DTilesetMetadata_default = Cesium3DTilesetMetadata;

// node_modules/cesium/Source/Scene/Cesium3DTileOptimizations.js
var Cesium3DTileOptimizations = {};
var scratchAxis = new Cartesian3_default();
Cesium3DTileOptimizations.checkChildrenWithinParent = function(tile) {
  Check_default.typeOf.object("tile", tile);
  const children = tile.children;
  const length3 = children.length;
  const boundingVolume = tile.boundingVolume;
  if (boundingVolume instanceof TileOrientedBoundingBox_default || boundingVolume instanceof TileBoundingRegion_default) {
    const orientedBoundingBox = boundingVolume._orientedBoundingBox;
    tile._optimChildrenWithinParent = Cesium3DTileOptimizationHint_default.USE_OPTIMIZATION;
    for (let i2 = 0; i2 < length3; ++i2) {
      const child = children[i2];
      const childBoundingVolume = child.boundingVolume;
      if (!(childBoundingVolume instanceof TileOrientedBoundingBox_default || childBoundingVolume instanceof TileBoundingRegion_default)) {
        tile._optimChildrenWithinParent = Cesium3DTileOptimizationHint_default.SKIP_OPTIMIZATION;
        break;
      }
      const childOrientedBoundingBox = childBoundingVolume._orientedBoundingBox;
      const axis = Cartesian3_default.subtract(
        childOrientedBoundingBox.center,
        orientedBoundingBox.center,
        scratchAxis
      );
      const axisLength = Cartesian3_default.magnitude(axis);
      Cartesian3_default.divideByScalar(axis, axisLength, axis);
      const proj1 = Math.abs(orientedBoundingBox.halfAxes[0] * axis.x) + Math.abs(orientedBoundingBox.halfAxes[1] * axis.y) + Math.abs(orientedBoundingBox.halfAxes[2] * axis.z) + Math.abs(orientedBoundingBox.halfAxes[3] * axis.x) + Math.abs(orientedBoundingBox.halfAxes[4] * axis.y) + Math.abs(orientedBoundingBox.halfAxes[5] * axis.z) + Math.abs(orientedBoundingBox.halfAxes[6] * axis.x) + Math.abs(orientedBoundingBox.halfAxes[7] * axis.y) + Math.abs(orientedBoundingBox.halfAxes[8] * axis.z);
      const proj2 = Math.abs(childOrientedBoundingBox.halfAxes[0] * axis.x) + Math.abs(childOrientedBoundingBox.halfAxes[1] * axis.y) + Math.abs(childOrientedBoundingBox.halfAxes[2] * axis.z) + Math.abs(childOrientedBoundingBox.halfAxes[3] * axis.x) + Math.abs(childOrientedBoundingBox.halfAxes[4] * axis.y) + Math.abs(childOrientedBoundingBox.halfAxes[5] * axis.z) + Math.abs(childOrientedBoundingBox.halfAxes[6] * axis.x) + Math.abs(childOrientedBoundingBox.halfAxes[7] * axis.y) + Math.abs(childOrientedBoundingBox.halfAxes[8] * axis.z);
      if (proj1 <= proj2 + axisLength) {
        tile._optimChildrenWithinParent = Cesium3DTileOptimizationHint_default.SKIP_OPTIMIZATION;
        break;
      }
    }
  }
  return tile._optimChildrenWithinParent === Cesium3DTileOptimizationHint_default.USE_OPTIMIZATION;
};
var Cesium3DTileOptimizations_default = Cesium3DTileOptimizations;

// node_modules/cesium/Source/Scene/Cesium3DTilesetCache.js
function Cesium3DTilesetCache() {
  this._list = new DoublyLinkedList_default();
  this._sentinel = this._list.add();
  this._trimTiles = false;
}
Cesium3DTilesetCache.prototype.reset = function() {
  this._list.splice(this._list.tail, this._sentinel);
};
Cesium3DTilesetCache.prototype.touch = function(tile) {
  const node = tile.cacheNode;
  if (defined_default(node)) {
    this._list.splice(this._sentinel, node);
  }
};
Cesium3DTilesetCache.prototype.add = function(tile) {
  if (!defined_default(tile.cacheNode)) {
    tile.cacheNode = this._list.add(tile);
  }
};
Cesium3DTilesetCache.prototype.unloadTile = function(tileset, tile, unloadCallback) {
  const node = tile.cacheNode;
  if (!defined_default(node)) {
    return;
  }
  this._list.remove(node);
  tile.cacheNode = void 0;
  unloadCallback(tileset, tile);
};
Cesium3DTilesetCache.prototype.unloadTiles = function(tileset, unloadCallback) {
  const trimTiles = this._trimTiles;
  this._trimTiles = false;
  const list = this._list;
  const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;
  const sentinel = this._sentinel;
  let node = list.head;
  while (node !== sentinel && (tileset.totalMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)) {
    const tile = node.item;
    node = node.next;
    this.unloadTile(tileset, tile, unloadCallback);
  }
};
Cesium3DTilesetCache.prototype.trim = function() {
  this._trimTiles = true;
};
var Cesium3DTilesetCache_default = Cesium3DTilesetCache;

// node_modules/cesium/Source/Scene/Cesium3DTilesetHeatmap.js
function Cesium3DTilesetHeatmap(tilePropertyName) {
  this.tilePropertyName = tilePropertyName;
  this._minimum = Number.MAX_VALUE;
  this._maximum = -Number.MAX_VALUE;
  this._previousMinimum = Number.MAX_VALUE;
  this._previousMaximum = -Number.MAX_VALUE;
  this._referenceMinimum = {};
  this._referenceMaximum = {};
}
function getHeatmapValue(tileValue, tilePropertyName) {
  let value;
  if (tilePropertyName === "_loadTimestamp") {
    value = JulianDate_default.toDate(tileValue).getTime();
  } else {
    value = tileValue;
  }
  return value;
}
Cesium3DTilesetHeatmap.prototype.setReferenceMinimumMaximum = function(minimum, maximum, tilePropertyName) {
  this._referenceMinimum[tilePropertyName] = getHeatmapValue(
    minimum,
    tilePropertyName
  );
  this._referenceMaximum[tilePropertyName] = getHeatmapValue(
    maximum,
    tilePropertyName
  );
};
function getHeatmapValueAndUpdateMinimumMaximum(heatmap, tile) {
  const tilePropertyName = heatmap.tilePropertyName;
  if (defined_default(tilePropertyName)) {
    const heatmapValue = getHeatmapValue(
      tile[tilePropertyName],
      tilePropertyName
    );
    if (!defined_default(heatmapValue)) {
      heatmap.tilePropertyName = void 0;
      return heatmapValue;
    }
    heatmap._maximum = Math.max(heatmapValue, heatmap._maximum);
    heatmap._minimum = Math.min(heatmapValue, heatmap._minimum);
    return heatmapValue;
  }
}
var heatmapColors = [
  new Color_default(0.1, 0.1, 0.1, 1),
  new Color_default(0.153, 0.278, 0.878, 1),
  new Color_default(0.827, 0.231, 0.49, 1),
  new Color_default(0.827, 0.188, 0.22, 1),
  new Color_default(1, 0.592, 0.259, 1),
  new Color_default(1, 0.843, 0, 1)
];
Cesium3DTilesetHeatmap.prototype.colorize = function(tile, frameState) {
  const tilePropertyName = this.tilePropertyName;
  if (!defined_default(tilePropertyName) || !tile.contentAvailable || tile._selectedFrame !== frameState.frameNumber) {
    return;
  }
  const heatmapValue = getHeatmapValueAndUpdateMinimumMaximum(this, tile);
  const minimum = this._previousMinimum;
  const maximum = this._previousMaximum;
  if (minimum === Number.MAX_VALUE || maximum === -Number.MAX_VALUE) {
    return;
  }
  const shiftedMax = maximum - minimum + Math_default.EPSILON7;
  const shiftedValue = Math_default.clamp(
    heatmapValue - minimum,
    0,
    shiftedMax
  );
  const zeroToOne = shiftedValue / shiftedMax;
  const lastIndex = heatmapColors.length - 1;
  const colorPosition = zeroToOne * lastIndex;
  const colorPositionFloor = Math.floor(colorPosition);
  const colorPositionCeil = Math.ceil(colorPosition);
  const t = colorPosition - colorPositionFloor;
  const colorZero = heatmapColors[colorPositionFloor];
  const colorOne = heatmapColors[colorPositionCeil];
  const finalColor = Color_default.clone(Color_default.WHITE);
  finalColor.red = Math_default.lerp(colorZero.red, colorOne.red, t);
  finalColor.green = Math_default.lerp(colorZero.green, colorOne.green, t);
  finalColor.blue = Math_default.lerp(colorZero.blue, colorOne.blue, t);
  tile._debugColor = finalColor;
};
Cesium3DTilesetHeatmap.prototype.resetMinimumMaximum = function() {
  const tilePropertyName = this.tilePropertyName;
  if (defined_default(tilePropertyName)) {
    const referenceMinimum = this._referenceMinimum[tilePropertyName];
    const referenceMaximum = this._referenceMaximum[tilePropertyName];
    const useReference = defined_default(referenceMinimum) && defined_default(referenceMaximum);
    this._previousMinimum = useReference ? referenceMinimum : this._minimum;
    this._previousMaximum = useReference ? referenceMaximum : this._maximum;
    this._minimum = Number.MAX_VALUE;
    this._maximum = -Number.MAX_VALUE;
  }
};
var Cesium3DTilesetHeatmap_default = Cesium3DTilesetHeatmap;

// node_modules/cesium/Source/Scene/Cesium3DTilesetStatistics.js
function Cesium3DTilesetStatistics() {
  this.selected = 0;
  this.visited = 0;
  this.numberOfCommands = 0;
  this.numberOfAttemptedRequests = 0;
  this.numberOfPendingRequests = 0;
  this.numberOfTilesProcessing = 0;
  this.numberOfTilesWithContentReady = 0;
  this.numberOfTilesTotal = 0;
  this.numberOfLoadedTilesTotal = 0;
  this.numberOfFeaturesSelected = 0;
  this.numberOfFeaturesLoaded = 0;
  this.numberOfPointsSelected = 0;
  this.numberOfPointsLoaded = 0;
  this.numberOfTrianglesSelected = 0;
  this.numberOfTilesStyled = 0;
  this.numberOfFeaturesStyled = 0;
  this.numberOfTilesCulledWithChildrenUnion = 0;
  this.geometryByteLength = 0;
  this.texturesByteLength = 0;
  this.batchTableByteLength = 0;
}
Cesium3DTilesetStatistics.prototype.clear = function() {
  this.selected = 0;
  this.visited = 0;
  this.numberOfCommands = 0;
  this.numberOfAttemptedRequests = 0;
  this.numberOfFeaturesSelected = 0;
  this.numberOfPointsSelected = 0;
  this.numberOfTrianglesSelected = 0;
  this.numberOfTilesStyled = 0;
  this.numberOfFeaturesStyled = 0;
  this.numberOfTilesCulledWithChildrenUnion = 0;
};
function updatePointAndFeatureCounts(statistics2, content, decrement, load5) {
  const contents = content.innerContents;
  const pointsLength = content.pointsLength;
  const trianglesLength = content.trianglesLength;
  const featuresLength = content.featuresLength;
  const geometryByteLength = content.geometryByteLength;
  const texturesByteLength = content.texturesByteLength;
  const batchTableByteLength = content.batchTableByteLength;
  if (load5) {
    statistics2.numberOfFeaturesLoaded += decrement ? -featuresLength : featuresLength;
    statistics2.numberOfPointsLoaded += decrement ? -pointsLength : pointsLength;
    statistics2.geometryByteLength += decrement ? -geometryByteLength : geometryByteLength;
    statistics2.texturesByteLength += decrement ? -texturesByteLength : texturesByteLength;
    statistics2.batchTableByteLength += decrement ? -batchTableByteLength : batchTableByteLength;
  } else {
    statistics2.numberOfFeaturesSelected += decrement ? -featuresLength : featuresLength;
    statistics2.numberOfPointsSelected += decrement ? -pointsLength : pointsLength;
    statistics2.numberOfTrianglesSelected += decrement ? -trianglesLength : trianglesLength;
  }
  if (defined_default(contents)) {
    const length3 = contents.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      updatePointAndFeatureCounts(statistics2, contents[i2], decrement, load5);
    }
  }
}
Cesium3DTilesetStatistics.prototype.incrementSelectionCounts = function(content) {
  updatePointAndFeatureCounts(this, content, false, false);
};
Cesium3DTilesetStatistics.prototype.incrementLoadCounts = function(content) {
  updatePointAndFeatureCounts(this, content, false, true);
};
Cesium3DTilesetStatistics.prototype.decrementLoadCounts = function(content) {
  updatePointAndFeatureCounts(this, content, true, true);
};
Cesium3DTilesetStatistics.clone = function(statistics2, result) {
  result.selected = statistics2.selected;
  result.visited = statistics2.visited;
  result.numberOfCommands = statistics2.numberOfCommands;
  result.selected = statistics2.selected;
  result.numberOfAttemptedRequests = statistics2.numberOfAttemptedRequests;
  result.numberOfPendingRequests = statistics2.numberOfPendingRequests;
  result.numberOfTilesProcessing = statistics2.numberOfTilesProcessing;
  result.numberOfTilesWithContentReady = statistics2.numberOfTilesWithContentReady;
  result.numberOfTilesTotal = statistics2.numberOfTilesTotal;
  result.numberOfFeaturesSelected = statistics2.numberOfFeaturesSelected;
  result.numberOfFeaturesLoaded = statistics2.numberOfFeaturesLoaded;
  result.numberOfPointsSelected = statistics2.numberOfPointsSelected;
  result.numberOfPointsLoaded = statistics2.numberOfPointsLoaded;
  result.numberOfTrianglesSelected = statistics2.numberOfTrianglesSelected;
  result.numberOfTilesStyled = statistics2.numberOfTilesStyled;
  result.numberOfFeaturesStyled = statistics2.numberOfFeaturesStyled;
  result.numberOfTilesCulledWithChildrenUnion = statistics2.numberOfTilesCulledWithChildrenUnion;
  result.geometryByteLength = statistics2.geometryByteLength;
  result.texturesByteLength = statistics2.texturesByteLength;
  result.batchTableByteLength = statistics2.batchTableByteLength;
};
var Cesium3DTilesetStatistics_default = Cesium3DTilesetStatistics;

// node_modules/cesium/Source/Scene/Cesium3DTileStyleEngine.js
function Cesium3DTileStyleEngine() {
  this._style = void 0;
  this._styleDirty = false;
  this._lastStyleTime = 0;
}
Object.defineProperties(Cesium3DTileStyleEngine.prototype, {
  style: {
    get: function() {
      return this._style;
    },
    set: function(value) {
      if (value === this._style) {
        return;
      }
      this._style = value;
      this._styleDirty = true;
    }
  }
});
Cesium3DTileStyleEngine.prototype.makeDirty = function() {
  this._styleDirty = true;
};
Cesium3DTileStyleEngine.prototype.resetDirty = function() {
  this._styleDirty = false;
};
Cesium3DTileStyleEngine.prototype.applyStyle = function(tileset) {
  if (!tileset.ready) {
    return;
  }
  if (defined_default(this._style) && !this._style.ready) {
    return;
  }
  const styleDirty = this._styleDirty;
  if (styleDirty) {
    ++this._lastStyleTime;
  }
  const lastStyleTime = this._lastStyleTime;
  const statistics2 = tileset._statistics;
  const tiles = styleDirty ? tileset._selectedTiles : tileset._selectedTilesToStyle;
  const length3 = tiles.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const tile = tiles[i2];
    if (tile.lastStyleTime !== lastStyleTime) {
      const content = tile.content;
      tile.lastStyleTime = lastStyleTime;
      content.applyStyle(this._style);
      statistics2.numberOfFeaturesStyled += content.featuresLength;
      ++statistics2.numberOfTilesStyled;
    }
  }
};
var Cesium3DTileStyleEngine_default = Cesium3DTileStyleEngine;

// node_modules/cesium/Source/Scene/ImplicitTileset.js
function ImplicitTileset(baseResource2, tileJson, metadataSchema) {
  const implicitTiling = hasExtension(tileJson, "3DTILES_implicit_tiling") ? tileJson.extensions["3DTILES_implicit_tiling"] : tileJson.implicitTiling;
  Check_default.typeOf.object("implicitTiling", implicitTiling);
  this.baseResource = baseResource2;
  this.geometricError = tileJson.geometricError;
  this.metadataSchema = metadataSchema;
  const boundingVolume = tileJson.boundingVolume;
  if (!defined_default(boundingVolume.box) && !defined_default(boundingVolume.region) && !hasExtension(boundingVolume, "3DTILES_bounding_volume_S2")) {
    throw new RuntimeError_default(
      "Only box, region and 3DTILES_bounding_volume_S2 are supported for implicit tiling"
    );
  }
  this.boundingVolume = boundingVolume;
  this.refine = tileJson.refine;
  this.subtreeUriTemplate = new Resource_default({ url: implicitTiling.subtrees.uri });
  this.contentUriTemplates = [];
  this.contentHeaders = [];
  const contentHeaders = gatherContentHeaders(tileJson);
  for (let i2 = 0; i2 < contentHeaders.length; i2++) {
    const contentHeader = contentHeaders[i2];
    this.contentHeaders.push(clone_default(contentHeader, true));
    const contentResource = new Resource_default({ url: contentHeader.uri });
    this.contentUriTemplates.push(contentResource);
  }
  this.contentCount = this.contentHeaders.length;
  this.tileHeader = makeTileHeaderTemplate(tileJson);
  this.subdivisionScheme = ImplicitSubdivisionScheme_default[implicitTiling.subdivisionScheme];
  this.branchingFactor = ImplicitSubdivisionScheme_default.getBranchingFactor(
    this.subdivisionScheme
  );
  this.subtreeLevels = implicitTiling.subtreeLevels;
  if (defined_default(implicitTiling.availableLevels)) {
    this.availableLevels = implicitTiling.availableLevels;
  } else {
    this.availableLevels = implicitTiling.maximumLevel + 1;
  }
}
function gatherContentHeaders(tileJson) {
  if (hasExtension(tileJson, "3DTILES_multiple_contents")) {
    const extension = tileJson.extensions["3DTILES_multiple_contents"];
    return defined_default(extension.contents) ? extension.contents : extension.content;
  }
  if (defined_default(tileJson.contents)) {
    return tileJson.contents;
  }
  if (defined_default(tileJson.content)) {
    return [tileJson.content];
  }
  return [];
}
function makeTileHeaderTemplate(tileJson) {
  const template = clone_default(tileJson, true);
  if (defined_default(template.extensions)) {
    delete template.extensions["3DTILES_implicit_tiling"];
    delete template.extensions["3DTILES_multiple_contents"];
    if (Object.keys(template.extensions).length === 0) {
      delete template.extensions;
    }
  }
  delete template.implicitTiling;
  delete template.contents;
  delete template.content;
  return template;
}

// node_modules/cesium/Source/Scene/ImplicitTileCoordinates.js
function ImplicitTileCoordinates(options) {
  Check_default.typeOf.string("options.subdivisionScheme", options.subdivisionScheme);
  Check_default.typeOf.number("options.subtreeLevels", options.subtreeLevels);
  Check_default.typeOf.number("options.level", options.level);
  Check_default.typeOf.number("options.x", options.x);
  Check_default.typeOf.number("options.y", options.y);
  if (options.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    Check_default.typeOf.number("options.z", options.z);
  }
  if (options.level < 0) {
    throw new DeveloperError_default("level must be non-negative");
  }
  if (options.x < 0) {
    throw new DeveloperError_default("x must be non-negative");
  }
  if (options.y < 0) {
    throw new DeveloperError_default("y must be non-negative");
  }
  if (options.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    if (options.z < 0) {
      throw new DeveloperError_default("z must be non-negative");
    }
  }
  const dimensionAtLevel = 1 << options.level;
  if (options.x >= dimensionAtLevel) {
    throw new DeveloperError_default("x is out of range");
  }
  if (options.y >= dimensionAtLevel) {
    throw new DeveloperError_default("y is out of range");
  }
  if (options.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    if (options.z >= dimensionAtLevel) {
      throw new DeveloperError_default("z is out of range");
    }
  }
  this.subdivisionScheme = options.subdivisionScheme;
  this.subtreeLevels = options.subtreeLevels;
  this.level = options.level;
  this.x = options.x;
  this.y = options.y;
  this.z = void 0;
  if (options.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    this.z = options.z;
  }
}
Object.defineProperties(ImplicitTileCoordinates.prototype, {
  childIndex: {
    get: function() {
      let childIndex = 0;
      childIndex |= this.x & 1;
      childIndex |= (this.y & 1) << 1;
      if (this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
        childIndex |= (this.z & 1) << 2;
      }
      return childIndex;
    }
  },
  mortonIndex: {
    get: function() {
      if (this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
        return MortonOrder_default.encode3D(this.x, this.y, this.z);
      }
      return MortonOrder_default.encode2D(this.x, this.y);
    }
  },
  tileIndex: {
    get: function() {
      const levelOffset = this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE ? ((1 << 3 * this.level) - 1) / 7 : ((1 << 2 * this.level) - 1) / 3;
      const mortonIndex = this.mortonIndex;
      return levelOffset + mortonIndex;
    }
  }
});
function checkMatchingSubtreeShape(a4, b) {
  if (a4.subdivisionScheme !== b.subdivisionScheme) {
    throw new DeveloperError_default("coordinates must have same subdivisionScheme");
  }
  if (a4.subtreeLevels !== b.subtreeLevels) {
    throw new DeveloperError_default("coordinates must have same subtreeLevels");
  }
}
ImplicitTileCoordinates.prototype.getDescendantCoordinates = function(offsetCoordinates) {
  Check_default.typeOf.object("offsetCoordinates", offsetCoordinates);
  checkMatchingSubtreeShape(this, offsetCoordinates);
  const descendantLevel = this.level + offsetCoordinates.level;
  const descendantX = (this.x << offsetCoordinates.level) + offsetCoordinates.x;
  const descendantY = (this.y << offsetCoordinates.level) + offsetCoordinates.y;
  if (this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    const descendantZ = (this.z << offsetCoordinates.level) + offsetCoordinates.z;
    return new ImplicitTileCoordinates({
      subdivisionScheme: this.subdivisionScheme,
      subtreeLevels: this.subtreeLevels,
      level: descendantLevel,
      x: descendantX,
      y: descendantY,
      z: descendantZ
    });
  }
  return new ImplicitTileCoordinates({
    subdivisionScheme: this.subdivisionScheme,
    subtreeLevels: this.subtreeLevels,
    level: descendantLevel,
    x: descendantX,
    y: descendantY
  });
};
ImplicitTileCoordinates.prototype.getAncestorCoordinates = function(offsetLevels) {
  Check_default.typeOf.number("offsetLevels", offsetLevels);
  if (offsetLevels < 0) {
    throw new DeveloperError_default("offsetLevels must be non-negative");
  }
  if (offsetLevels > this.level) {
    throw new DeveloperError_default("ancestor cannot be above the tileset root");
  }
  const divisor = 1 << offsetLevels;
  const ancestorLevel = this.level - offsetLevels;
  const ancestorX = Math.floor(this.x / divisor);
  const ancestorY = Math.floor(this.y / divisor);
  if (this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    const ancestorZ = Math.floor(this.z / divisor);
    return new ImplicitTileCoordinates({
      subdivisionScheme: this.subdivisionScheme,
      subtreeLevels: this.subtreeLevels,
      level: ancestorLevel,
      x: ancestorX,
      y: ancestorY,
      z: ancestorZ
    });
  }
  return new ImplicitTileCoordinates({
    subdivisionScheme: this.subdivisionScheme,
    subtreeLevels: this.subtreeLevels,
    level: ancestorLevel,
    x: ancestorX,
    y: ancestorY
  });
};
ImplicitTileCoordinates.prototype.getOffsetCoordinates = function(descendantCoordinates) {
  Check_default.typeOf.object("descendantCoordinates", descendantCoordinates);
  if (!this.isEqual(descendantCoordinates) && !this.isAncestor(descendantCoordinates)) {
    throw new DeveloperError_default("this is not an ancestor of descendant");
  }
  checkMatchingSubtreeShape(this, descendantCoordinates);
  const offsetLevel = descendantCoordinates.level - this.level;
  const dimensionAtOffsetLevel = 1 << offsetLevel;
  const offsetX = descendantCoordinates.x % dimensionAtOffsetLevel;
  const offsetY = descendantCoordinates.y % dimensionAtOffsetLevel;
  if (this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    const offsetZ = descendantCoordinates.z % dimensionAtOffsetLevel;
    return new ImplicitTileCoordinates({
      subdivisionScheme: this.subdivisionScheme,
      subtreeLevels: this.subtreeLevels,
      level: offsetLevel,
      x: offsetX,
      y: offsetY,
      z: offsetZ
    });
  }
  return new ImplicitTileCoordinates({
    subdivisionScheme: this.subdivisionScheme,
    subtreeLevels: this.subtreeLevels,
    level: offsetLevel,
    x: offsetX,
    y: offsetY
  });
};
ImplicitTileCoordinates.prototype.getChildCoordinates = function(childIndex) {
  Check_default.typeOf.number("childIndex", childIndex);
  const branchingFactor = ImplicitSubdivisionScheme_default.getBranchingFactor(
    this.subdivisionScheme
  );
  if (childIndex < 0 || branchingFactor <= childIndex) {
    throw new DeveloperError_default(
      `childIndex must be at least 0 and less than ${branchingFactor}`
    );
  }
  const level = this.level + 1;
  const x = 2 * this.x + childIndex % 2;
  const y = 2 * this.y + Math.floor(childIndex / 2) % 2;
  if (this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    const z = 2 * this.z + Math.floor(childIndex / 4) % 2;
    return new ImplicitTileCoordinates({
      subdivisionScheme: this.subdivisionScheme,
      subtreeLevels: this.subtreeLevels,
      level,
      x,
      y,
      z
    });
  }
  return new ImplicitTileCoordinates({
    subdivisionScheme: this.subdivisionScheme,
    subtreeLevels: this.subtreeLevels,
    level,
    x,
    y
  });
};
ImplicitTileCoordinates.prototype.getSubtreeCoordinates = function() {
  return this.getAncestorCoordinates(this.level % this.subtreeLevels);
};
ImplicitTileCoordinates.prototype.getParentSubtreeCoordinates = function() {
  return this.getAncestorCoordinates(
    this.level % this.subtreeLevels + this.subtreeLevels
  );
};
ImplicitTileCoordinates.prototype.isAncestor = function(descendantCoordinates) {
  Check_default.typeOf.object("descendantCoordinates", descendantCoordinates);
  checkMatchingSubtreeShape(this, descendantCoordinates);
  const levelDifference = descendantCoordinates.level - this.level;
  if (levelDifference <= 0) {
    return false;
  }
  const ancestorX = descendantCoordinates.x >> levelDifference;
  const ancestorY = descendantCoordinates.y >> levelDifference;
  const isAncestorX = this.x === ancestorX;
  const isAncestorY = this.y === ancestorY;
  if (this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    const ancestorZ = descendantCoordinates.z >> levelDifference;
    const isAncestorZ = this.z === ancestorZ;
    return isAncestorX && isAncestorY && isAncestorZ;
  }
  return isAncestorX && isAncestorY;
};
ImplicitTileCoordinates.prototype.isEqual = function(otherCoordinates) {
  Check_default.typeOf.object("otherCoordinates", otherCoordinates);
  return this.subdivisionScheme === otherCoordinates.subdivisionScheme && this.subtreeLevels === otherCoordinates.subtreeLevels && this.level === otherCoordinates.level && this.x === otherCoordinates.x && this.y === otherCoordinates.y && (this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE ? this.z === otherCoordinates.z : true);
};
ImplicitTileCoordinates.prototype.isImplicitTilesetRoot = function() {
  return this.level === 0;
};
ImplicitTileCoordinates.prototype.isSubtreeRoot = function() {
  return this.level % this.subtreeLevels === 0;
};
ImplicitTileCoordinates.prototype.isBottomOfSubtree = function() {
  return this.level % this.subtreeLevels === this.subtreeLevels - 1;
};
ImplicitTileCoordinates.prototype.getTemplateValues = function() {
  const values = {
    level: this.level,
    x: this.x,
    y: this.y
  };
  if (this.subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    values.z = this.z;
  }
  return values;
};
var scratchCoordinatesArray = [0, 0, 0];
ImplicitTileCoordinates.fromMortonIndex = function(subdivisionScheme, subtreeLevels, level, mortonIndex) {
  let coordinatesArray;
  if (subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    coordinatesArray = MortonOrder_default.decode3D(
      mortonIndex,
      scratchCoordinatesArray
    );
    return new ImplicitTileCoordinates({
      subdivisionScheme,
      subtreeLevels,
      level,
      x: coordinatesArray[0],
      y: coordinatesArray[1],
      z: coordinatesArray[2]
    });
  }
  coordinatesArray = MortonOrder_default.decode2D(mortonIndex, scratchCoordinatesArray);
  return new ImplicitTileCoordinates({
    subdivisionScheme,
    subtreeLevels,
    level,
    x: coordinatesArray[0],
    y: coordinatesArray[1]
  });
};
ImplicitTileCoordinates.fromTileIndex = function(subdivisionScheme, subtreeLevels, tileIndex) {
  let level;
  let levelOffset;
  let mortonIndex;
  if (subdivisionScheme === ImplicitSubdivisionScheme_default.OCTREE) {
    level = Math.floor(Math_default.log2(7 * tileIndex + 1) / 3);
    levelOffset = ((1 << 3 * level) - 1) / 7;
    mortonIndex = tileIndex - levelOffset;
  } else {
    level = Math.floor(Math_default.log2(3 * tileIndex + 1) / 2);
    levelOffset = ((1 << 2 * level) - 1) / 3;
    mortonIndex = tileIndex - levelOffset;
  }
  return ImplicitTileCoordinates.fromMortonIndex(
    subdivisionScheme,
    subtreeLevels,
    level,
    mortonIndex
  );
};

// node_modules/cesium/Source/Scene/Cesium3DTileset.js
function Cesium3DTileset(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.url", options.url);
  this._url = void 0;
  this._basePath = void 0;
  this._root = void 0;
  this._resource = void 0;
  this._asset = void 0;
  this._properties = void 0;
  this._geometricError = void 0;
  this._extensionsUsed = void 0;
  this._extensions = void 0;
  this._gltfUpAxis = void 0;
  this._cache = new Cesium3DTilesetCache_default();
  this._processingQueue = [];
  this._selectedTiles = [];
  this._emptyTiles = [];
  this._requestedTiles = [];
  this._selectedTilesToStyle = [];
  this._loadTimestamp = void 0;
  this._timeSinceLoad = 0;
  this._updatedVisibilityFrame = 0;
  this._updatedModelMatrixFrame = 0;
  this._modelMatrixChanged = false;
  this._previousModelMatrix = void 0;
  this._extras = void 0;
  this._credits = void 0;
  this._showCreditsOnScreen = defaultValue_default(options.showCreditsOnScreen, false);
  this._cullWithChildrenBounds = defaultValue_default(
    options.cullWithChildrenBounds,
    true
  );
  this._allTilesAdditive = true;
  this._hasMixedContent = false;
  this._stencilClearCommand = void 0;
  this._backfaceCommands = new ManagedArray_default();
  this._maximumScreenSpaceError = defaultValue_default(
    options.maximumScreenSpaceError,
    16
  );
  this._maximumMemoryUsage = defaultValue_default(options.maximumMemoryUsage, 512);
  this._styleEngine = new Cesium3DTileStyleEngine_default();
  this._modelMatrix = defined_default(options.modelMatrix) ? Matrix4_default.clone(options.modelMatrix) : Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._statistics = new Cesium3DTilesetStatistics_default();
  this._statisticsLast = new Cesium3DTilesetStatistics_default();
  this._statisticsPerPass = new Array(Cesium3DTilePass_default.NUMBER_OF_PASSES);
  for (let i2 = 0; i2 < Cesium3DTilePass_default.NUMBER_OF_PASSES; ++i2) {
    this._statisticsPerPass[i2] = new Cesium3DTilesetStatistics_default();
  }
  this._requestedTilesInFlight = [];
  this._maximumPriority = {
    foveatedFactor: -Number.MAX_VALUE,
    depth: -Number.MAX_VALUE,
    distance: -Number.MAX_VALUE,
    reverseScreenSpaceError: -Number.MAX_VALUE
  };
  this._minimumPriority = {
    foveatedFactor: Number.MAX_VALUE,
    depth: Number.MAX_VALUE,
    distance: Number.MAX_VALUE,
    reverseScreenSpaceError: Number.MAX_VALUE
  };
  this._heatmap = new Cesium3DTilesetHeatmap_default(
    options.debugHeatmapTilePropertyName
  );
  this.cullRequestsWhileMoving = defaultValue_default(
    options.cullRequestsWhileMoving,
    true
  );
  this._cullRequestsWhileMoving = false;
  this.cullRequestsWhileMovingMultiplier = defaultValue_default(
    options.cullRequestsWhileMovingMultiplier,
    60
  );
  this.progressiveResolutionHeightFraction = Math_default.clamp(
    defaultValue_default(options.progressiveResolutionHeightFraction, 0.3),
    0,
    0.5
  );
  this.preferLeaves = defaultValue_default(options.preferLeaves, false);
  this._tilesLoaded = false;
  this._initialTilesLoaded = false;
  this._tileDebugLabels = void 0;
  this._readyPromise = defer_default();
  this._classificationType = options.classificationType;
  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  this._initialClippingPlanesOriginMatrix = Matrix4_default.IDENTITY;
  this._clippingPlanesOriginMatrix = void 0;
  this._clippingPlanesOriginMatrixDirty = true;
  this._vectorClassificationOnly = defaultValue_default(
    options.vectorClassificationOnly,
    false
  );
  this._vectorKeepDecodedPositions = defaultValue_default(
    options.vectorKeepDecodedPositions,
    false
  );
  this.preloadWhenHidden = defaultValue_default(options.preloadWhenHidden, false);
  this.preloadFlightDestinations = defaultValue_default(
    options.preloadFlightDestinations,
    true
  );
  this._pass = void 0;
  this.dynamicScreenSpaceError = defaultValue_default(
    options.dynamicScreenSpaceError,
    false
  );
  this.foveatedScreenSpaceError = defaultValue_default(
    options.foveatedScreenSpaceError,
    true
  );
  this._foveatedConeSize = defaultValue_default(options.foveatedConeSize, 0.1);
  this._foveatedMinimumScreenSpaceErrorRelaxation = defaultValue_default(
    options.foveatedMinimumScreenSpaceErrorRelaxation,
    0
  );
  this.foveatedInterpolationCallback = defaultValue_default(
    options.foveatedInterpolationCallback,
    Math_default.lerp
  );
  this.foveatedTimeDelay = defaultValue_default(options.foveatedTimeDelay, 0.2);
  this.dynamicScreenSpaceErrorDensity = 278e-5;
  this.dynamicScreenSpaceErrorFactor = 4;
  this.dynamicScreenSpaceErrorHeightFalloff = 0.25;
  this._dynamicScreenSpaceErrorComputedDensity = 0;
  this.shadows = defaultValue_default(options.shadows, ShadowMode_default.ENABLED);
  this.show = defaultValue_default(options.show, true);
  this.colorBlendMode = Cesium3DTileColorBlendMode_default.HIGHLIGHT;
  this.colorBlendAmount = 0.5;
  this._pointCloudShading = new PointCloudShading_default(options.pointCloudShading);
  this._pointCloudEyeDomeLighting = new PointCloudEyeDomeLighting_default2();
  this.loadProgress = new Event_default();
  this.allTilesLoaded = new Event_default();
  this.initialTilesLoaded = new Event_default();
  this.tileLoad = new Event_default();
  this.tileUnload = new Event_default();
  this.tileFailed = new Event_default();
  this.tileVisible = new Event_default();
  this.skipLevelOfDetail = defaultValue_default(options.skipLevelOfDetail, false);
  this._skipLevelOfDetail = this.skipLevelOfDetail;
  this._disableSkipLevelOfDetail = false;
  this.baseScreenSpaceError = defaultValue_default(options.baseScreenSpaceError, 1024);
  this.skipScreenSpaceErrorFactor = defaultValue_default(
    options.skipScreenSpaceErrorFactor,
    16
  );
  this.skipLevels = defaultValue_default(options.skipLevels, 1);
  this.immediatelyLoadDesiredLevelOfDetail = defaultValue_default(
    options.immediatelyLoadDesiredLevelOfDetail,
    false
  );
  this.loadSiblings = defaultValue_default(options.loadSiblings, false);
  this._clippingPlanes = void 0;
  this.clippingPlanes = options.clippingPlanes;
  const hasIndividualIBLParameters = defined_default(options.imageBasedLightingFactor) || defined_default(options.luminanceAtZenith) || defined_default(options.sphericalHarmonicCoefficients) || defined_default(options.specularEnvironmentMaps);
  if (defined_default(options.imageBasedLighting)) {
    this._imageBasedLighting = options.imageBasedLighting;
    this._shouldDestroyImageBasedLighting = false;
  } else if (hasIndividualIBLParameters) {
    deprecationWarning_default(
      "ImageBasedLightingConstructor",
      "Individual image-based lighting parameters were deprecated in Cesium 1.92. They will be removed in version 1.94. Use options.imageBasedLighting instead."
    );
    this._imageBasedLighting = new ImageBasedLighting({
      imageBasedLightingFactor: options.imageBasedLightingFactor,
      luminanceAtZenith: options.luminanceAtZenith,
      sphericalHarmonicCoefficients: options.sphericalHarmonicCoefficients,
      specularEnvironmentMaps: options.specularEnvironmentMaps
    });
    this._shouldDestroyImageBasedLighting = true;
  } else {
    this._imageBasedLighting = new ImageBasedLighting();
    this._shouldDestroyImageBasedLighting = true;
  }
  this.lightColor = options.lightColor;
  this.backFaceCulling = defaultValue_default(options.backFaceCulling, true);
  this.showOutline = defaultValue_default(options.showOutline, true);
  this.splitDirection = defaultValue_default(
    options.splitDirection,
    SplitDirection_default.NONE
  );
  this.debugFreezeFrame = defaultValue_default(options.debugFreezeFrame, false);
  this.debugColorizeTiles = defaultValue_default(options.debugColorizeTiles, false);
  this.debugWireframe = defaultValue_default(options.debugWireframe, false);
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this.debugShowContentBoundingVolume = defaultValue_default(
    options.debugShowContentBoundingVolume,
    false
  );
  this.debugShowViewerRequestVolume = defaultValue_default(
    options.debugShowViewerRequestVolume,
    false
  );
  this._tileDebugLabels = void 0;
  this.debugPickedTileLabelOnly = false;
  this.debugPickedTile = void 0;
  this.debugPickPosition = void 0;
  this.debugShowGeometricError = defaultValue_default(
    options.debugShowGeometricError,
    false
  );
  this.debugShowRenderingStatistics = defaultValue_default(
    options.debugShowRenderingStatistics,
    false
  );
  this.debugShowMemoryUsage = defaultValue_default(options.debugShowMemoryUsage, false);
  this.debugShowUrl = defaultValue_default(options.debugShowUrl, false);
  this.examineVectorLinesFunction = void 0;
  this._metadataExtension = void 0;
  this._customShader = options.customShader;
  this.enableModelExperimental = defaultValue_default(
    options.enableModelExperimental,
    ExperimentalFeatures_default.enableModelExperimental
  );
  let featureIdLabel = defaultValue_default(options.featureIdLabel, "featureId_0");
  if (typeof featureIdLabel === "number") {
    featureIdLabel = `featureId_${featureIdLabel}`;
  }
  this._featureIdLabel = featureIdLabel;
  let instanceFeatureIdLabel = defaultValue_default(
    options.instanceFeatureIdLabel,
    "instanceFeatureId_0"
  );
  if (typeof instanceFeatureIdLabel === "number") {
    instanceFeatureIdLabel = `instanceFeatureId_${instanceFeatureIdLabel}`;
  }
  this._instanceFeatureIdLabel = instanceFeatureIdLabel;
  this._schemaLoader = void 0;
  const that = this;
  let resource;
  Promise.resolve(options.url).then(function(url2) {
    let basePath;
    resource = Resource_default.createIfNeeded(url2);
    that._resource = resource;
    that._credits = resource.credits;
    if (resource.extension === "json") {
      basePath = resource.getBaseUri(true);
    } else if (resource.isDataUri) {
      basePath = "";
    }
    that._url = resource.url;
    that._basePath = basePath;
    return Cesium3DTileset.loadJson(resource);
  }).then(function(tilesetJson) {
    return processMetadataExtension(that, tilesetJson);
  }).then(function(tilesetJson) {
    that._root = that.loadTileset(resource, tilesetJson);
    const gltfUpAxis = defined_default(tilesetJson.asset.gltfUpAxis) ? Axis_default.fromName(tilesetJson.asset.gltfUpAxis) : Axis_default.Y;
    const asset = tilesetJson.asset;
    that._asset = asset;
    that._properties = tilesetJson.properties;
    that._geometricError = tilesetJson.geometricError;
    that._extensionsUsed = tilesetJson.extensionsUsed;
    that._extensions = tilesetJson.extensions;
    that._gltfUpAxis = gltfUpAxis;
    that._extras = tilesetJson.extras;
    const extras = asset.extras;
    if (defined_default(extras) && defined_default(extras.cesium) && defined_default(extras.cesium.credits)) {
      const extraCredits = extras.cesium.credits;
      let credits = that._credits;
      if (!defined_default(credits)) {
        credits = [];
        that._credits = credits;
      }
      for (let i2 = 0; i2 < extraCredits.length; ++i2) {
        const credit = extraCredits[i2];
        credits.push(new Credit_default(credit.html, that._showCreditsOnScreen));
      }
    }
    const boundingVolume = that._root.createBoundingVolume(
      tilesetJson.root.boundingVolume,
      Matrix4_default.IDENTITY
    );
    const clippingPlanesOrigin = boundingVolume.boundingSphere.center;
    const originCartographic = that._ellipsoid.cartesianToCartographic(
      clippingPlanesOrigin
    );
    if (defined_default(originCartographic) && originCartographic.height > ApproximateTerrainHeights_default._defaultMinTerrainHeight) {
      that._initialClippingPlanesOriginMatrix = Transforms_default.eastNorthUpToFixedFrame(
        clippingPlanesOrigin
      );
    }
    that._clippingPlanesOriginMatrix = Matrix4_default.clone(
      that._initialClippingPlanesOriginMatrix
    );
    that._readyPromise.resolve(that);
  }).catch(function(error) {
    that._readyPromise.reject(error);
  });
}
Object.defineProperties(Cesium3DTileset.prototype, {
  isCesium3DTileset: {
    get: function() {
      return true;
    }
  },
  asset: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "The tileset is not loaded.  Use Cesium3DTileset.readyPromise or wait for Cesium3DTileset.ready to be true."
        );
      }
      return this._asset;
    }
  },
  extensions: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "The tileset is not loaded.  Use Cesium3DTileset.readyPromise or wait for Cesium3DTileset.ready to be true."
        );
      }
      return this._extensions;
    }
  },
  clippingPlanes: {
    get: function() {
      return this._clippingPlanes;
    },
    set: function(value) {
      ClippingPlaneCollection_default.setOwner(value, this, "_clippingPlanes");
    }
  },
  properties: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "The tileset is not loaded.  Use Cesium3DTileset.readyPromise or wait for Cesium3DTileset.ready to be true."
        );
      }
      return this._properties;
    }
  },
  ready: {
    get: function() {
      return defined_default(this._root);
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  tilesLoaded: {
    get: function() {
      return this._tilesLoaded;
    }
  },
  resource: {
    get: function() {
      return this._resource;
    }
  },
  basePath: {
    get: function() {
      deprecationWarning_default(
        "Cesium3DTileset.basePath",
        "Cesium3DTileset.basePath has been deprecated. All tiles are relative to the url of the tileset JSON file that contains them. Use the url property instead."
      );
      return this._basePath;
    }
  },
  style: {
    get: function() {
      return this._styleEngine.style;
    },
    set: function(value) {
      this._styleEngine.style = value;
    }
  },
  customShader: {
    get: function() {
      return this._customShader;
    },
    set: function(value) {
      this._customShader = value;
    }
  },
  metadataExtension: {
    get: function() {
      return this._metadataExtension;
    }
  },
  metadata: {
    get: function() {
      if (defined_default(this._metadataExtension)) {
        return this._metadataExtension.tileset;
      }
      return void 0;
    }
  },
  schema: {
    get: function() {
      if (defined_default(this._metadataExtension)) {
        return this._metadataExtension.schema;
      }
      return void 0;
    }
  },
  maximumScreenSpaceError: {
    get: function() {
      return this._maximumScreenSpaceError;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals(
        "maximumScreenSpaceError",
        value,
        0
      );
      this._maximumScreenSpaceError = value;
    }
  },
  maximumMemoryUsage: {
    get: function() {
      return this._maximumMemoryUsage;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._maximumMemoryUsage = value;
    }
  },
  pointCloudShading: {
    get: function() {
      return this._pointCloudShading;
    },
    set: function(value) {
      Check_default.defined("pointCloudShading", value);
      this._pointCloudShading = value;
    }
  },
  root: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "The tileset is not loaded.  Use Cesium3DTileset.readyPromise or wait for Cesium3DTileset.ready to be true."
        );
      }
      return this._root;
    }
  },
  boundingSphere: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "The tileset is not loaded.  Use Cesium3DTileset.readyPromise or wait for Cesium3DTileset.ready to be true."
        );
      }
      this._root.updateTransform(this._modelMatrix);
      return this._root.boundingSphere;
    }
  },
  modelMatrix: {
    get: function() {
      return this._modelMatrix;
    },
    set: function(value) {
      this._modelMatrix = Matrix4_default.clone(value, this._modelMatrix);
    }
  },
  timeSinceLoad: {
    get: function() {
      return this._timeSinceLoad;
    }
  },
  totalMemoryUsageInBytes: {
    get: function() {
      const statistics2 = this._statistics;
      return statistics2.texturesByteLength + statistics2.geometryByteLength + statistics2.batchTableByteLength;
    }
  },
  clippingPlanesOriginMatrix: {
    get: function() {
      if (!defined_default(this._clippingPlanesOriginMatrix)) {
        return Matrix4_default.IDENTITY;
      }
      if (this._clippingPlanesOriginMatrixDirty) {
        Matrix4_default.multiply(
          this.root.computedTransform,
          this._initialClippingPlanesOriginMatrix,
          this._clippingPlanesOriginMatrix
        );
        this._clippingPlanesOriginMatrixDirty = false;
      }
      return this._clippingPlanesOriginMatrix;
    }
  },
  styleEngine: {
    get: function() {
      return this._styleEngine;
    }
  },
  statistics: {
    get: function() {
      return this._statistics;
    }
  },
  classificationType: {
    get: function() {
      return this._classificationType;
    }
  },
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  },
  foveatedConeSize: {
    get: function() {
      return this._foveatedConeSize;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("foveatedConeSize", value, 0);
      Check_default.typeOf.number.lessThanOrEquals("foveatedConeSize", value, 1);
      this._foveatedConeSize = value;
    }
  },
  foveatedMinimumScreenSpaceErrorRelaxation: {
    get: function() {
      return this._foveatedMinimumScreenSpaceErrorRelaxation;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals(
        "foveatedMinimumScreenSpaceErrorRelaxation",
        value,
        0
      );
      Check_default.typeOf.number.lessThanOrEquals(
        "foveatedMinimumScreenSpaceErrorRelaxation",
        value,
        this.maximumScreenSpaceError
      );
      this._foveatedMinimumScreenSpaceErrorRelaxation = value;
    }
  },
  extras: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "The tileset is not loaded.  Use Cesium3DTileset.readyPromise or wait for Cesium3DTileset.ready to be true."
        );
      }
      return this._extras;
    }
  },
  imageBasedLighting: {
    get: function() {
      return this._imageBasedLighting;
    },
    set: function(value) {
      Check_default.typeOf.object("imageBasedLighting", this._imageBasedLighting);
      if (value !== this._imageBasedLighting) {
        if (this._shouldDestroyImageBasedLighting && !this._imageBasedLighting.isDestroyed()) {
          this._imageBasedLighting.destroy();
        }
        this._imageBasedLighting = value;
        this._shouldDestroyImageBasedLighting = false;
      }
    }
  },
  imageBasedLightingFactor: {
    get: function() {
      return this._imageBasedLighting.imageBasedLightingFactor;
    },
    set: function(value) {
      this._imageBasedLighting.imageBasedLightingFactor = value;
    }
  },
  luminanceAtZenith: {
    get: function() {
      return this._imageBasedLighting.luminanceAtZenith;
    },
    set: function(value) {
      this._imageBasedLighting.luminanceAtZenith = value;
    }
  },
  sphericalHarmonicCoefficients: {
    get: function() {
      return this._imageBasedLighting.sphericalHarmonicCoefficients;
    },
    set: function(value) {
      this._imageBasedLighting.sphericalHarmonicCoefficients = value;
    }
  },
  specularEnvironmentMaps: {
    get: function() {
      return this._imageBasedLighting.specularEnvironmentMaps;
    },
    set: function(value) {
      this._imageBasedLighting.specularEnvironmentMaps = value;
    }
  },
  vectorClassificationOnly: {
    get: function() {
      return this._vectorClassificationOnly;
    }
  },
  vectorKeepDecodedPositions: {
    get: function() {
      return this._vectorKeepDecodedPositions;
    }
  },
  showCreditsOnScreen: {
    get: function() {
      return this._showCreditsOnScreen;
    },
    set: function(value) {
      this._showCreditsOnScreen = value;
    }
  },
  featureIdLabel: {
    get: function() {
      return this._featureIdLabel;
    },
    set: function(value) {
      if (typeof value === "number") {
        value = `featureId_${value}`;
      }
      Check_default.typeOf.string("value", value);
      this._featureIdLabel = value;
    }
  },
  instanceFeatureIdLabel: {
    get: function() {
      return this._instanceFeatureIdLabel;
    },
    set: function(value) {
      if (typeof value === "number") {
        value = `instanceFeatureId_${value}`;
      }
      Check_default.typeOf.string("value", value);
      this._instanceFeatureIdLabel = value;
    }
  }
});
Cesium3DTileset.loadJson = function(tilesetUrl) {
  const resource = Resource_default.createIfNeeded(tilesetUrl);
  return resource.fetchJson();
};
Cesium3DTileset.prototype.makeStyleDirty = function() {
  this._styleEngine.makeDirty();
};
Cesium3DTileset.prototype.loadTileset = function(resource, tilesetJson, parentTile) {
  const asset = tilesetJson.asset;
  if (!defined_default(asset)) {
    throw new RuntimeError_default("Tileset must have an asset property.");
  }
  if (asset.version !== "0.0" && asset.version !== "1.0" && asset.version !== "1.1") {
    throw new RuntimeError_default(
      "The tileset must be 3D Tiles version 0.0, 1.0, or 1.1"
    );
  }
  if (defined_default(tilesetJson.extensionsRequired)) {
    Cesium3DTileset.checkSupportedExtensions(tilesetJson.extensionsRequired);
  }
  const statistics2 = this._statistics;
  const tilesetVersion = asset.tilesetVersion;
  if (defined_default(tilesetVersion)) {
    this._basePath += `?v=${tilesetVersion}`;
    resource = resource.clone();
    resource.setQueryParameters({ v: tilesetVersion });
  }
  const rootTile = makeTile2(this, resource, tilesetJson.root, parentTile);
  if (defined_default(parentTile)) {
    parentTile.children.push(rootTile);
    rootTile._depth = parentTile._depth + 1;
  }
  const stack = [];
  stack.push(rootTile);
  while (stack.length > 0) {
    const tile = stack.pop();
    ++statistics2.numberOfTilesTotal;
    this._allTilesAdditive = this._allTilesAdditive && tile.refine === Cesium3DTileRefine_default.ADD;
    const children = tile._header.children;
    if (defined_default(children)) {
      const length3 = children.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        const childHeader = children[i2];
        const childTile = makeTile2(this, resource, childHeader, tile);
        tile.children.push(childTile);
        childTile._depth = tile._depth + 1;
        stack.push(childTile);
      }
    }
    if (this._cullWithChildrenBounds) {
      Cesium3DTileOptimizations_default.checkChildrenWithinParent(tile);
    }
  }
  return rootTile;
};
function makeTile2(tileset, baseResource2, tileHeader, parentTile) {
  const hasImplicitTiling = defined_default(tileHeader.implicitTiling) || hasExtension(tileHeader, "3DTILES_implicit_tiling");
  if (hasImplicitTiling) {
    const metadataSchema = tileset.schema;
    const implicitTileset = new ImplicitTileset(
      baseResource2,
      tileHeader,
      metadataSchema
    );
    const rootCoordinates = new ImplicitTileCoordinates({
      subdivisionScheme: implicitTileset.subdivisionScheme,
      subtreeLevels: implicitTileset.subtreeLevels,
      level: 0,
      x: 0,
      y: 0,
      z: 0
    });
    const contentUri = implicitTileset.subtreeUriTemplate.getDerivedResource({
      templateValues: rootCoordinates.getTemplateValues()
    }).url;
    const deepCopy = true;
    const tileJson = clone_default(tileHeader, deepCopy);
    tileJson.contents = [
      {
        uri: contentUri
      }
    ];
    delete tileJson.content;
    delete tileJson.extensions;
    const tile = new Cesium3DTile_default(tileset, baseResource2, tileJson, parentTile);
    tile.implicitTileset = implicitTileset;
    tile.implicitCoordinates = rootCoordinates;
    return tile;
  }
  return new Cesium3DTile_default(tileset, baseResource2, tileHeader, parentTile);
}
function processMetadataExtension(tileset, tilesetJson) {
  const metadataJson = hasExtension(tilesetJson, "3DTILES_metadata") ? tilesetJson.extensions["3DTILES_metadata"] : tilesetJson;
  let schemaLoader;
  if (defined_default(metadataJson.schemaUri)) {
    const resource = tileset._resource.getDerivedResource({
      url: metadataJson.schemaUri
    });
    schemaLoader = ResourceCache_default.loadSchema({
      resource
    });
  } else if (defined_default(metadataJson.schema)) {
    schemaLoader = ResourceCache_default.loadSchema({
      schema: metadataJson.schema
    });
  } else {
    return Promise.resolve(tilesetJson);
  }
  tileset._schemaLoader = schemaLoader;
  return schemaLoader.promise.then(function(schemaLoader2) {
    tileset._metadataExtension = new Cesium3DTilesetMetadata_default({
      schema: schemaLoader2.schema,
      metadataJson
    });
    return tilesetJson;
  });
}
var scratchPositionNormal = new Cartesian3_default();
var scratchCartographic9 = new Cartographic_default();
var scratchMatrix5 = new Matrix4_default();
var scratchCenter6 = new Cartesian3_default();
var scratchPosition13 = new Cartesian3_default();
var scratchDirection = new Cartesian3_default();
function updateDynamicScreenSpaceError(tileset, frameState) {
  let up;
  let direction2;
  let height;
  let minimumHeight;
  let maximumHeight;
  const camera = frameState.camera;
  const root = tileset._root;
  const tileBoundingVolume = root.contentBoundingVolume;
  if (tileBoundingVolume instanceof TileBoundingRegion_default) {
    up = Cartesian3_default.normalize(camera.positionWC, scratchPositionNormal);
    direction2 = camera.directionWC;
    height = camera.positionCartographic.height;
    minimumHeight = tileBoundingVolume.minimumHeight;
    maximumHeight = tileBoundingVolume.maximumHeight;
  } else {
    const transformLocal = Matrix4_default.inverseTransformation(
      root.computedTransform,
      scratchMatrix5
    );
    const ellipsoid = frameState.mapProjection.ellipsoid;
    const boundingVolume = tileBoundingVolume.boundingVolume;
    const centerLocal = Matrix4_default.multiplyByPoint(
      transformLocal,
      boundingVolume.center,
      scratchCenter6
    );
    if (Cartesian3_default.magnitude(centerLocal) > ellipsoid.minimumRadius) {
      const centerCartographic = Cartographic_default.fromCartesian(
        centerLocal,
        ellipsoid,
        scratchCartographic9
      );
      up = Cartesian3_default.normalize(camera.positionWC, scratchPositionNormal);
      direction2 = camera.directionWC;
      height = camera.positionCartographic.height;
      minimumHeight = 0;
      maximumHeight = centerCartographic.height * 2;
    } else {
      const positionLocal = Matrix4_default.multiplyByPoint(
        transformLocal,
        camera.positionWC,
        scratchPosition13
      );
      up = Cartesian3_default.UNIT_Z;
      direction2 = Matrix4_default.multiplyByPointAsVector(
        transformLocal,
        camera.directionWC,
        scratchDirection
      );
      direction2 = Cartesian3_default.normalize(direction2, direction2);
      height = positionLocal.z;
      if (tileBoundingVolume instanceof TileOrientedBoundingBox_default) {
        const boxHeight = root._header.boundingVolume.box[11];
        minimumHeight = centerLocal.z - boxHeight;
        maximumHeight = centerLocal.z + boxHeight;
      } else if (tileBoundingVolume instanceof TileBoundingSphere_default) {
        const radius = boundingVolume.radius;
        minimumHeight = centerLocal.z - radius;
        maximumHeight = centerLocal.z + radius;
      }
    }
  }
  const heightFalloff = tileset.dynamicScreenSpaceErrorHeightFalloff;
  const heightClose = minimumHeight + (maximumHeight - minimumHeight) * heightFalloff;
  const heightFar = maximumHeight;
  const t = Math_default.clamp(
    (height - heightClose) / (heightFar - heightClose),
    0,
    1
  );
  const dot2 = Math.abs(Cartesian3_default.dot(direction2, up));
  let horizonFactor = 1 - dot2;
  horizonFactor = horizonFactor * (1 - t);
  let density = tileset.dynamicScreenSpaceErrorDensity;
  density *= horizonFactor;
  tileset._dynamicScreenSpaceErrorComputedDensity = density;
}
function requestContent(tileset, tile) {
  if (tile.hasEmptyContent) {
    return;
  }
  const statistics2 = tileset._statistics;
  const expired = tile.contentExpired;
  const attemptedRequests = tile.requestContent();
  if (attemptedRequests > 0) {
    statistics2.numberOfAttemptedRequests += attemptedRequests;
    return;
  }
  if (expired) {
    if (tile.hasTilesetContent || tile.hasImplicitContent) {
      destroySubtree(tileset, tile);
    } else {
      statistics2.decrementLoadCounts(tile.content);
      --statistics2.numberOfTilesWithContentReady;
    }
  }
  tileset._requestedTilesInFlight.push(tile);
  tile.contentReadyToProcessPromise.then(addToProcessingQueue(tileset, tile));
  tile.contentReadyPromise.then(handleTileSuccess(tileset, tile)).catch(handleTileFailure(tileset, tile));
}
function sortRequestByPriority(a4, b) {
  return a4._priority - b._priority;
}
Cesium3DTileset.prototype.postPassesUpdate = function(frameState) {
  if (!this.ready) {
    return;
  }
  cancelOutOfViewRequests(this, frameState);
  raiseLoadProgressEvent(this, frameState);
  this._cache.unloadTiles(this, unloadTile);
  this._styleEngine.resetDirty();
};
Cesium3DTileset.prototype.prePassesUpdate = function(frameState) {
  if (!this.ready) {
    return;
  }
  processTiles(this, frameState);
  const clippingPlanes = this._clippingPlanes;
  this._clippingPlanesOriginMatrixDirty = true;
  if (defined_default(clippingPlanes) && clippingPlanes.enabled) {
    clippingPlanes.update(frameState);
  }
  if (!defined_default(this._loadTimestamp)) {
    this._loadTimestamp = JulianDate_default.clone(frameState.time);
  }
  this._timeSinceLoad = Math.max(
    JulianDate_default.secondsDifference(frameState.time, this._loadTimestamp) * 1e3,
    0
  );
  this._skipLevelOfDetail = this.skipLevelOfDetail && !defined_default(this._classificationType) && !this._disableSkipLevelOfDetail && !this._allTilesAdditive;
  if (this.dynamicScreenSpaceError) {
    updateDynamicScreenSpaceError(this, frameState);
  }
  if (frameState.newFrame) {
    this._cache.reset();
  }
};
function cancelOutOfViewRequests(tileset, frameState) {
  const requestedTilesInFlight = tileset._requestedTilesInFlight;
  let removeCount = 0;
  const length3 = requestedTilesInFlight.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const tile = requestedTilesInFlight[i2];
    const outOfView = frameState.frameNumber - tile._touchedFrame >= 1;
    if (tile._contentState !== Cesium3DTileContentState_default.LOADING) {
      ++removeCount;
      continue;
    } else if (outOfView) {
      tile.cancelRequests();
      ++removeCount;
      continue;
    }
    if (removeCount > 0) {
      requestedTilesInFlight[i2 - removeCount] = tile;
    }
  }
  requestedTilesInFlight.length -= removeCount;
}
function requestTiles(tileset, isAsync) {
  const requestedTiles = tileset._requestedTiles;
  const length3 = requestedTiles.length;
  requestedTiles.sort(sortRequestByPriority);
  for (let i2 = 0; i2 < length3; ++i2) {
    requestContent(tileset, requestedTiles[i2]);
  }
}
function addToProcessingQueue(tileset, tile) {
  return function() {
    tileset._processingQueue.push(tile);
    ++tileset._statistics.numberOfTilesProcessing;
  };
}
function handleTileFailure(tileset, tile) {
  return function(error) {
    const url2 = tile._contentResource.url;
    const message = defined_default(error.message) ? error.message : error.toString();
    if (tileset.tileFailed.numberOfListeners > 0) {
      tileset.tileFailed.raiseEvent({
        url: url2,
        message
      });
    } else {
      console.log(`A 3D tile failed to load: ${url2}`);
      console.log(`Error: ${message}`);
    }
  };
}
function handleTileSuccess(tileset, tile) {
  return function() {
    --tileset._statistics.numberOfTilesProcessing;
    if (!tile.hasTilesetContent && !tile.hasImplicitContent) {
      tileset._statistics.incrementLoadCounts(tile.content);
      ++tileset._statistics.numberOfTilesWithContentReady;
      ++tileset._statistics.numberOfLoadedTilesTotal;
      tileset._cache.add(tile);
    }
    tileset.tileLoad.raiseEvent(tile);
  };
}
function filterProcessingQueue(tileset) {
  const tiles = tileset._processingQueue;
  const length3 = tiles.length;
  let removeCount = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const tile = tiles[i2];
    if (tile._contentState !== Cesium3DTileContentState_default.PROCESSING) {
      ++removeCount;
      continue;
    }
    if (removeCount > 0) {
      tiles[i2 - removeCount] = tile;
    }
  }
  tiles.length -= removeCount;
}
function processTiles(tileset, frameState) {
  filterProcessingQueue(tileset);
  const tiles = tileset._processingQueue;
  const length3 = tiles.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    tiles[i2].process(tileset, frameState);
  }
}
var scratchCartesian19 = new Cartesian3_default();
var stringOptions = {
  maximumFractionDigits: 3
};
function formatMemoryString(memorySizeInBytes) {
  const memoryInMegabytes = memorySizeInBytes / 1048576;
  if (memoryInMegabytes < 1) {
    return memoryInMegabytes.toLocaleString(void 0, stringOptions);
  }
  return Math.round(memoryInMegabytes).toLocaleString();
}
function computeTileLabelPosition(tile) {
  const boundingVolume = tile.boundingVolume.boundingVolume;
  const halfAxes = boundingVolume.halfAxes;
  const radius = boundingVolume.radius;
  let position = Cartesian3_default.clone(boundingVolume.center, scratchCartesian19);
  if (defined_default(halfAxes)) {
    position.x += 0.75 * (halfAxes[0] + halfAxes[3] + halfAxes[6]);
    position.y += 0.75 * (halfAxes[1] + halfAxes[4] + halfAxes[7]);
    position.z += 0.75 * (halfAxes[2] + halfAxes[5] + halfAxes[8]);
  } else if (defined_default(radius)) {
    let normal2 = Cartesian3_default.normalize(boundingVolume.center, scratchCartesian19);
    normal2 = Cartesian3_default.multiplyByScalar(
      normal2,
      0.75 * radius,
      scratchCartesian19
    );
    position = Cartesian3_default.add(normal2, boundingVolume.center, scratchCartesian19);
  }
  return position;
}
function addTileDebugLabel(tile, tileset, position) {
  let labelString = "";
  let attributes = 0;
  if (tileset.debugShowGeometricError) {
    labelString += `
Geometric error: ${tile.geometricError}`;
    attributes++;
  }
  if (tileset.debugShowRenderingStatistics) {
    labelString += `
Commands: ${tile.commandsLength}`;
    attributes++;
    const numberOfPoints = tile.content.pointsLength;
    if (numberOfPoints > 0) {
      labelString += `
Points: ${tile.content.pointsLength}`;
      attributes++;
    }
    const numberOfTriangles = tile.content.trianglesLength;
    if (numberOfTriangles > 0) {
      labelString += `
Triangles: ${tile.content.trianglesLength}`;
      attributes++;
    }
    labelString += `
Features: ${tile.content.featuresLength}`;
    attributes++;
  }
  if (tileset.debugShowMemoryUsage) {
    labelString += `
Texture Memory: ${formatMemoryString(
      tile.content.texturesByteLength
    )}`;
    labelString += `
Geometry Memory: ${formatMemoryString(
      tile.content.geometryByteLength
    )}`;
    attributes += 2;
  }
  if (tileset.debugShowUrl) {
    if (tile.hasMultipleContents) {
      labelString += "\nUrls:";
      const urls = tile.content.innerContentUrls;
      for (let i2 = 0; i2 < urls.length; i2++) {
        labelString += `
- ${urls[i2]}`;
      }
      attributes += urls.length;
    } else {
      labelString += `
Url: ${tile._header.content.uri}`;
      attributes++;
    }
  }
  const newLabel = {
    text: labelString.substring(1),
    position,
    font: `${19 - attributes}px sans-serif`,
    showBackground: true,
    disableDepthTestDistance: Number.POSITIVE_INFINITY
  };
  return tileset._tileDebugLabels.add(newLabel);
}
function updateTileDebugLabels(tileset, frameState) {
  let i2;
  let tile;
  const selectedTiles = tileset._selectedTiles;
  const selectedLength = selectedTiles.length;
  const emptyTiles = tileset._emptyTiles;
  const emptyLength = emptyTiles.length;
  tileset._tileDebugLabels.removeAll();
  if (tileset.debugPickedTileLabelOnly) {
    if (defined_default(tileset.debugPickedTile)) {
      const position = defined_default(tileset.debugPickPosition) ? tileset.debugPickPosition : computeTileLabelPosition(tileset.debugPickedTile);
      const label = addTileDebugLabel(
        tileset.debugPickedTile,
        tileset,
        position
      );
      label.pixelOffset = new Cartesian2_default(15, -15);
    }
  } else {
    for (i2 = 0; i2 < selectedLength; ++i2) {
      tile = selectedTiles[i2];
      addTileDebugLabel(tile, tileset, computeTileLabelPosition(tile));
    }
    for (i2 = 0; i2 < emptyLength; ++i2) {
      tile = emptyTiles[i2];
      if (tile.hasTilesetContent || tile.hasImplicitContent) {
        addTileDebugLabel(tile, tileset, computeTileLabelPosition(tile));
      }
    }
  }
  tileset._tileDebugLabels.update(frameState);
}
function updateTiles(tileset, frameState, passOptions2) {
  tileset._styleEngine.applyStyle(tileset);
  const isRender = passOptions2.isRender;
  const statistics2 = tileset._statistics;
  const commandList = frameState.commandList;
  const numberOfInitialCommands = commandList.length;
  const selectedTiles = tileset._selectedTiles;
  const selectedLength = selectedTiles.length;
  const emptyTiles = tileset._emptyTiles;
  const emptyLength = emptyTiles.length;
  const tileVisible = tileset.tileVisible;
  let i2;
  let tile;
  const bivariateVisibilityTest = tileset._skipLevelOfDetail && tileset._hasMixedContent && frameState.context.stencilBuffer && selectedLength > 0;
  tileset._backfaceCommands.length = 0;
  if (bivariateVisibilityTest) {
    if (!defined_default(tileset._stencilClearCommand)) {
      tileset._stencilClearCommand = new ClearCommand_default({
        stencil: 0,
        pass: Pass_default.CESIUM_3D_TILE,
        renderState: RenderState_default.fromCache({
          stencilMask: StencilConstants_default.SKIP_LOD_MASK
        })
      });
    }
    commandList.push(tileset._stencilClearCommand);
  }
  const lengthBeforeUpdate = commandList.length;
  for (i2 = 0; i2 < selectedLength; ++i2) {
    tile = selectedTiles[i2];
    if (isRender) {
      tileVisible.raiseEvent(tile);
    }
    tile.update(tileset, frameState, passOptions2);
    statistics2.incrementSelectionCounts(tile.content);
    ++statistics2.selected;
  }
  for (i2 = 0; i2 < emptyLength; ++i2) {
    tile = emptyTiles[i2];
    tile.update(tileset, frameState, passOptions2);
  }
  let addedCommandsLength = commandList.length - lengthBeforeUpdate;
  tileset._backfaceCommands.trim();
  if (bivariateVisibilityTest) {
    const backfaceCommands = tileset._backfaceCommands.values;
    const backfaceCommandsLength = backfaceCommands.length;
    commandList.length += backfaceCommandsLength;
    for (i2 = addedCommandsLength - 1; i2 >= 0; --i2) {
      commandList[lengthBeforeUpdate + backfaceCommandsLength + i2] = commandList[lengthBeforeUpdate + i2];
    }
    for (i2 = 0; i2 < backfaceCommandsLength; ++i2) {
      commandList[lengthBeforeUpdate + i2] = backfaceCommands[i2];
    }
  }
  addedCommandsLength = commandList.length - numberOfInitialCommands;
  statistics2.numberOfCommands = addedCommandsLength;
  if (isRender && tileset.pointCloudShading.attenuation && tileset.pointCloudShading.eyeDomeLighting && addedCommandsLength > 0) {
    tileset._pointCloudEyeDomeLighting.update(
      frameState,
      numberOfInitialCommands,
      tileset.pointCloudShading,
      tileset.boundingSphere
    );
  }
  if (isRender) {
    if (tileset.debugShowGeometricError || tileset.debugShowRenderingStatistics || tileset.debugShowMemoryUsage || tileset.debugShowUrl) {
      if (!defined_default(tileset._tileDebugLabels)) {
        tileset._tileDebugLabels = new LabelCollection_default();
      }
      updateTileDebugLabels(tileset, frameState);
    } else {
      tileset._tileDebugLabels = tileset._tileDebugLabels && tileset._tileDebugLabels.destroy();
    }
  }
}
var scratchStack2 = [];
function destroySubtree(tileset, tile) {
  const root = tile;
  const stack = scratchStack2;
  stack.push(tile);
  while (stack.length > 0) {
    tile = stack.pop();
    const children = tile.children;
    const length3 = children.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      stack.push(children[i2]);
    }
    if (tile !== root) {
      destroyTile(tileset, tile);
      --tileset._statistics.numberOfTilesTotal;
    }
  }
  root.children = [];
}
function unloadTile(tileset, tile) {
  tileset.tileUnload.raiseEvent(tile);
  tileset._statistics.decrementLoadCounts(tile.content);
  --tileset._statistics.numberOfTilesWithContentReady;
  tile.unloadContent();
}
function destroyTile(tileset, tile) {
  tileset._cache.unloadTile(tileset, tile, unloadTile);
  tile.destroy();
}
Cesium3DTileset.prototype.trimLoadedTiles = function() {
  this._cache.trim();
};
function raiseLoadProgressEvent(tileset, frameState) {
  const statistics2 = tileset._statistics;
  const statisticsLast = tileset._statisticsLast;
  const numberOfPendingRequests = statistics2.numberOfPendingRequests;
  const numberOfTilesProcessing = statistics2.numberOfTilesProcessing;
  const lastNumberOfPendingRequest = statisticsLast.numberOfPendingRequests;
  const lastNumberOfTilesProcessing = statisticsLast.numberOfTilesProcessing;
  Cesium3DTilesetStatistics_default.clone(statistics2, statisticsLast);
  const progressChanged = numberOfPendingRequests !== lastNumberOfPendingRequest || numberOfTilesProcessing !== lastNumberOfTilesProcessing;
  if (progressChanged) {
    frameState.afterRender.push(function() {
      tileset.loadProgress.raiseEvent(
        numberOfPendingRequests,
        numberOfTilesProcessing
      );
    });
  }
  tileset._tilesLoaded = statistics2.numberOfPendingRequests === 0 && statistics2.numberOfTilesProcessing === 0 && statistics2.numberOfAttemptedRequests === 0;
  if (progressChanged && tileset._tilesLoaded) {
    frameState.afterRender.push(function() {
      tileset.allTilesLoaded.raiseEvent();
    });
    if (!tileset._initialTilesLoaded) {
      tileset._initialTilesLoaded = true;
      frameState.afterRender.push(function() {
        tileset.initialTilesLoaded.raiseEvent();
      });
    }
  }
}
function resetMinimumMaximum(tileset) {
  tileset._heatmap.resetMinimumMaximum();
  tileset._minimumPriority.depth = Number.MAX_VALUE;
  tileset._maximumPriority.depth = -Number.MAX_VALUE;
  tileset._minimumPriority.foveatedFactor = Number.MAX_VALUE;
  tileset._maximumPriority.foveatedFactor = -Number.MAX_VALUE;
  tileset._minimumPriority.distance = Number.MAX_VALUE;
  tileset._maximumPriority.distance = -Number.MAX_VALUE;
  tileset._minimumPriority.reverseScreenSpaceError = Number.MAX_VALUE;
  tileset._maximumPriority.reverseScreenSpaceError = -Number.MAX_VALUE;
}
function detectModelMatrixChanged(tileset, frameState) {
  if (frameState.frameNumber !== tileset._updatedModelMatrixFrame || !defined_default(tileset._previousModelMatrix)) {
    tileset._updatedModelMatrixFrame = frameState.frameNumber;
    tileset._modelMatrixChanged = !Matrix4_default.equals(
      tileset.modelMatrix,
      tileset._previousModelMatrix
    );
    if (tileset._modelMatrixChanged) {
      tileset._previousModelMatrix = Matrix4_default.clone(
        tileset.modelMatrix,
        tileset._previousModelMatrix
      );
    }
  }
}
function update5(tileset, frameState, passStatistics, passOptions2) {
  if (frameState.mode === SceneMode_default.MORPHING) {
    return false;
  }
  if (!tileset.ready) {
    return false;
  }
  const statistics2 = tileset._statistics;
  statistics2.clear();
  const isRender = passOptions2.isRender;
  ++tileset._updatedVisibilityFrame;
  resetMinimumMaximum(tileset);
  detectModelMatrixChanged(tileset, frameState);
  tileset._cullRequestsWhileMoving = tileset.cullRequestsWhileMoving && !tileset._modelMatrixChanged;
  const ready = passOptions2.traversal.selectTiles(tileset, frameState);
  if (passOptions2.requestTiles) {
    requestTiles(tileset);
  }
  updateTiles(tileset, frameState, passOptions2);
  Cesium3DTilesetStatistics_default.clone(statistics2, passStatistics);
  if (isRender) {
    const credits = tileset._credits;
    if (defined_default(credits) && statistics2.selected !== 0) {
      const length3 = credits.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        const credit = credits[i2];
        credit.showOnScreen = tileset._showCreditsOnScreen;
        frameState.creditDisplay.addCredit(credit);
      }
    }
  }
  return ready;
}
Cesium3DTileset.prototype.update = function(frameState) {
  this.updateForPass(frameState, frameState.tilesetPassState);
};
Cesium3DTileset.prototype.updateForPass = function(frameState, tilesetPassState) {
  Check_default.typeOf.object("frameState", frameState);
  Check_default.typeOf.object("tilesetPassState", tilesetPassState);
  const pass = tilesetPassState.pass;
  if (pass === Cesium3DTilePass_default.PRELOAD && (!this.preloadWhenHidden || this.show) || pass === Cesium3DTilePass_default.PRELOAD_FLIGHT && (!this.preloadFlightDestinations || !this.show && !this.preloadWhenHidden) || pass === Cesium3DTilePass_default.REQUEST_RENDER_MODE_DEFER_CHECK && (!this._cullRequestsWhileMoving && this.foveatedTimeDelay <= 0 || !this.show)) {
    return;
  }
  const originalCommandList = frameState.commandList;
  const originalCamera = frameState.camera;
  const originalCullingVolume = frameState.cullingVolume;
  tilesetPassState.ready = false;
  const passOptions2 = Cesium3DTilePass_default.getPassOptions(pass);
  const ignoreCommands = passOptions2.ignoreCommands;
  const commandList = defaultValue_default(
    tilesetPassState.commandList,
    originalCommandList
  );
  const commandStart = commandList.length;
  frameState.commandList = commandList;
  frameState.camera = defaultValue_default(tilesetPassState.camera, originalCamera);
  frameState.cullingVolume = defaultValue_default(
    tilesetPassState.cullingVolume,
    originalCullingVolume
  );
  const passStatistics = this._statisticsPerPass[pass];
  if (this.show || ignoreCommands) {
    this._pass = pass;
    tilesetPassState.ready = update5(
      this,
      frameState,
      passStatistics,
      passOptions2
    );
  }
  if (ignoreCommands) {
    commandList.length = commandStart;
  }
  frameState.commandList = originalCommandList;
  frameState.camera = originalCamera;
  frameState.cullingVolume = originalCullingVolume;
};
Cesium3DTileset.prototype.hasExtension = function(extensionName) {
  if (!defined_default(this._extensionsUsed)) {
    return false;
  }
  return this._extensionsUsed.indexOf(extensionName) > -1;
};
Cesium3DTileset.prototype.isDestroyed = function() {
  return false;
};
Cesium3DTileset.prototype.destroy = function() {
  this._tileDebugLabels = this._tileDebugLabels && this._tileDebugLabels.destroy();
  this._clippingPlanes = this._clippingPlanes && this._clippingPlanes.destroy();
  if (defined_default(this._schemaLoader)) {
    ResourceCache_default.unload(this._schemaLoader);
  }
  if (defined_default(this._root)) {
    const stack = scratchStack2;
    stack.push(this._root);
    while (stack.length > 0) {
      const tile = stack.pop();
      tile.destroy();
      const children = tile.children;
      const length3 = children.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        stack.push(children[i2]);
      }
    }
  }
  this._root = void 0;
  if (this._shouldDestroyImageBasedLighting && !this._imageBasedLighting.isDestroyed()) {
    this._imageBasedLighting.destroy();
  }
  this._imageBasedLighting = void 0;
  return destroyObject_default(this);
};
Cesium3DTileset.supportedExtensions = {
  "3DTILES_metadata": true,
  "3DTILES_implicit_tiling": true,
  "3DTILES_content_gltf": true,
  "3DTILES_multiple_contents": true,
  "3DTILES_bounding_volume_S2": true,
  "3DTILES_batch_table_hierarchy": true,
  "3DTILES_draco_point_compression": true
};
Cesium3DTileset.checkSupportedExtensions = function(extensionsRequired) {
  for (let i2 = 0; i2 < extensionsRequired.length; i2++) {
    if (!Cesium3DTileset.supportedExtensions[extensionsRequired[i2]]) {
      throw new RuntimeError_default(
        `Unsupported 3D Tiles Extension: ${extensionsRequired[i2]}`
      );
    }
  }
};
var Cesium3DTileset_default = Cesium3DTileset;

// node_modules/cesium/Source/DataSources/Cesium3DTilesetVisualizer.js
var modelMatrixScratch = new Matrix4_default();
function Cesium3DTilesetVisualizer(scene, entityCollection) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  if (!defined_default(entityCollection)) {
    throw new DeveloperError_default("entityCollection is required.");
  }
  entityCollection.collectionChanged.addEventListener(
    Cesium3DTilesetVisualizer.prototype._onCollectionChanged,
    this
  );
  this._scene = scene;
  this._primitives = scene.primitives;
  this._entityCollection = entityCollection;
  this._tilesetHash = {};
  this._entitiesToVisualize = new AssociativeArray_default();
  this._onCollectionChanged(entityCollection, entityCollection.values, [], []);
}
Cesium3DTilesetVisualizer.prototype.update = function(time) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  const entities = this._entitiesToVisualize.values;
  const tilesetHash = this._tilesetHash;
  const primitives = this._primitives;
  for (let i2 = 0, len = entities.length; i2 < len; i2++) {
    const entity = entities[i2];
    const tilesetGraphics = entity._tileset;
    let resource;
    let tilesetData = tilesetHash[entity.id];
    const show = entity.isShowing && entity.isAvailable(time) && Property_default.getValueOrDefault(tilesetGraphics._show, time, true);
    let modelMatrix;
    if (show) {
      modelMatrix = entity.computeModelMatrix(time, modelMatrixScratch);
      resource = Resource_default.createIfNeeded(
        Property_default.getValueOrUndefined(tilesetGraphics._uri, time)
      );
    }
    if (!show) {
      if (defined_default(tilesetData)) {
        tilesetData.tilesetPrimitive.show = false;
      }
      continue;
    }
    let tileset = defined_default(tilesetData) ? tilesetData.tilesetPrimitive : void 0;
    if (!defined_default(tileset) || resource.url !== tilesetData.url) {
      if (defined_default(tileset)) {
        primitives.removeAndDestroy(tileset);
        delete tilesetHash[entity.id];
      }
      tileset = new Cesium3DTileset_default({
        url: resource
      });
      tileset.id = entity;
      primitives.add(tileset);
      tilesetData = {
        tilesetPrimitive: tileset,
        url: resource.url,
        loadFail: false
      };
      tilesetHash[entity.id] = tilesetData;
      checkLoad(tileset, entity, tilesetHash);
    }
    tileset.show = true;
    if (defined_default(modelMatrix)) {
      tileset.modelMatrix = modelMatrix;
    }
    tileset.maximumScreenSpaceError = Property_default.getValueOrDefault(
      tilesetGraphics.maximumScreenSpaceError,
      time,
      tileset.maximumScreenSpaceError
    );
  }
  return true;
};
Cesium3DTilesetVisualizer.prototype.isDestroyed = function() {
  return false;
};
Cesium3DTilesetVisualizer.prototype.destroy = function() {
  this._entityCollection.collectionChanged.removeEventListener(
    Cesium3DTilesetVisualizer.prototype._onCollectionChanged,
    this
  );
  const entities = this._entitiesToVisualize.values;
  const tilesetHash = this._tilesetHash;
  const primitives = this._primitives;
  for (let i2 = entities.length - 1; i2 > -1; i2--) {
    removeTileset(this, entities[i2], tilesetHash, primitives);
  }
  return destroyObject_default(this);
};
Cesium3DTilesetVisualizer.prototype.getBoundingSphere = function(entity, result) {
  if (!defined_default(entity)) {
    throw new DeveloperError_default("entity is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const tilesetData = this._tilesetHash[entity.id];
  if (!defined_default(tilesetData) || tilesetData.loadFail) {
    return BoundingSphereState_default.FAILED;
  }
  const primitive = tilesetData.tilesetPrimitive;
  if (!defined_default(primitive) || !primitive.show) {
    return BoundingSphereState_default.FAILED;
  }
  if (!primitive.ready) {
    return BoundingSphereState_default.PENDING;
  }
  BoundingSphere_default.clone(primitive.boundingSphere, result);
  return BoundingSphereState_default.DONE;
};
Cesium3DTilesetVisualizer.prototype._onCollectionChanged = function(entityCollection, added, removed, changed) {
  let i2;
  let entity;
  const entities = this._entitiesToVisualize;
  const tilesetHash = this._tilesetHash;
  const primitives = this._primitives;
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    if (defined_default(entity._tileset)) {
      entities.set(entity.id, entity);
    }
  }
  for (i2 = changed.length - 1; i2 > -1; i2--) {
    entity = changed[i2];
    if (defined_default(entity._tileset)) {
      entities.set(entity.id, entity);
    } else {
      removeTileset(this, entity, tilesetHash, primitives);
      entities.remove(entity.id);
    }
  }
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    removeTileset(this, entity, tilesetHash, primitives);
    entities.remove(entity.id);
  }
};
function removeTileset(visualizer, entity, tilesetHash, primitives) {
  const tilesetData = tilesetHash[entity.id];
  if (defined_default(tilesetData)) {
    primitives.removeAndDestroy(tilesetData.tilesetPrimitive);
    delete tilesetHash[entity.id];
  }
}
function checkLoad(primitive, entity, tilesetHash) {
  primitive.readyPromise.catch(function(error) {
    console.error(error);
    tilesetHash[entity.id].loadFail = true;
  });
}
var Cesium3DTilesetVisualizer_default = Cesium3DTilesetVisualizer;

// node_modules/cesium/Source/DataSources/CheckerboardMaterialProperty.js
var defaultEvenColor = Color_default.WHITE;
var defaultOddColor = Color_default.BLACK;
var defaultRepeat2 = new Cartesian2_default(2, 2);
function CheckerboardMaterialProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._definitionChanged = new Event_default();
  this._evenColor = void 0;
  this._evenColorSubscription = void 0;
  this._oddColor = void 0;
  this._oddColorSubscription = void 0;
  this._repeat = void 0;
  this._repeatSubscription = void 0;
  this.evenColor = options.evenColor;
  this.oddColor = options.oddColor;
  this.repeat = options.repeat;
}
Object.defineProperties(CheckerboardMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._evenColor) && Property_default.isConstant(this._oddColor) && Property_default.isConstant(this._repeat);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  evenColor: createPropertyDescriptor_default("evenColor"),
  oddColor: createPropertyDescriptor_default("oddColor"),
  repeat: createPropertyDescriptor_default("repeat")
});
CheckerboardMaterialProperty.prototype.getType = function(time) {
  return "Checkerboard";
};
CheckerboardMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = {};
  }
  result.lightColor = Property_default.getValueOrClonedDefault(
    this._evenColor,
    time,
    defaultEvenColor,
    result.lightColor
  );
  result.darkColor = Property_default.getValueOrClonedDefault(
    this._oddColor,
    time,
    defaultOddColor,
    result.darkColor
  );
  result.repeat = Property_default.getValueOrDefault(this._repeat, time, defaultRepeat2);
  return result;
};
CheckerboardMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof CheckerboardMaterialProperty && Property_default.equals(this._evenColor, other._evenColor) && Property_default.equals(this._oddColor, other._oddColor) && Property_default.equals(this._repeat, other._repeat);
};
var CheckerboardMaterialProperty_default = CheckerboardMaterialProperty;

// node_modules/cesium/Source/DataSources/EntityCollection.js
var entityOptionsScratch = {
  id: void 0
};
function fireChangedEvent(collection) {
  if (collection._firing) {
    collection._refire = true;
    return;
  }
  if (collection._suspendCount === 0) {
    const added = collection._addedEntities;
    const removed = collection._removedEntities;
    const changed = collection._changedEntities;
    if (changed.length !== 0 || added.length !== 0 || removed.length !== 0) {
      collection._firing = true;
      do {
        collection._refire = false;
        const addedArray = added.values.slice(0);
        const removedArray = removed.values.slice(0);
        const changedArray = changed.values.slice(0);
        added.removeAll();
        removed.removeAll();
        changed.removeAll();
        collection._collectionChanged.raiseEvent(
          collection,
          addedArray,
          removedArray,
          changedArray
        );
      } while (collection._refire);
      collection._firing = false;
    }
  }
}
function EntityCollection(owner) {
  this._owner = owner;
  this._entities = new AssociativeArray_default();
  this._addedEntities = new AssociativeArray_default();
  this._removedEntities = new AssociativeArray_default();
  this._changedEntities = new AssociativeArray_default();
  this._suspendCount = 0;
  this._collectionChanged = new Event_default();
  this._id = createGuid_default();
  this._show = true;
  this._firing = false;
  this._refire = false;
}
EntityCollection.prototype.suspendEvents = function() {
  this._suspendCount++;
};
EntityCollection.prototype.resumeEvents = function() {
  if (this._suspendCount === 0) {
    throw new DeveloperError_default(
      "resumeEvents can not be called before suspendEvents."
    );
  }
  this._suspendCount--;
  fireChangedEvent(this);
};
Object.defineProperties(EntityCollection.prototype, {
  collectionChanged: {
    get: function() {
      return this._collectionChanged;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  values: {
    get: function() {
      return this._entities.values;
    }
  },
  show: {
    get: function() {
      return this._show;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (value === this._show) {
        return;
      }
      this.suspendEvents();
      let i2;
      const oldShows = [];
      const entities = this._entities.values;
      const entitiesLength = entities.length;
      for (i2 = 0; i2 < entitiesLength; i2++) {
        oldShows.push(entities[i2].isShowing);
      }
      this._show = value;
      for (i2 = 0; i2 < entitiesLength; i2++) {
        const oldShow = oldShows[i2];
        const entity = entities[i2];
        if (oldShow !== entity.isShowing) {
          entity.definitionChanged.raiseEvent(
            entity,
            "isShowing",
            entity.isShowing,
            oldShow
          );
        }
      }
      this.resumeEvents();
    }
  },
  owner: {
    get: function() {
      return this._owner;
    }
  }
});
EntityCollection.prototype.computeAvailability = function() {
  let startTime = Iso8601_default.MAXIMUM_VALUE;
  let stopTime = Iso8601_default.MINIMUM_VALUE;
  const entities = this._entities.values;
  for (let i2 = 0, len = entities.length; i2 < len; i2++) {
    const entity = entities[i2];
    const availability = entity.availability;
    if (defined_default(availability)) {
      const start = availability.start;
      const stop2 = availability.stop;
      if (JulianDate_default.lessThan(start, startTime) && !start.equals(Iso8601_default.MINIMUM_VALUE)) {
        startTime = start;
      }
      if (JulianDate_default.greaterThan(stop2, stopTime) && !stop2.equals(Iso8601_default.MAXIMUM_VALUE)) {
        stopTime = stop2;
      }
    }
  }
  if (Iso8601_default.MAXIMUM_VALUE.equals(startTime)) {
    startTime = Iso8601_default.MINIMUM_VALUE;
  }
  if (Iso8601_default.MINIMUM_VALUE.equals(stopTime)) {
    stopTime = Iso8601_default.MAXIMUM_VALUE;
  }
  return new TimeInterval_default({
    start: startTime,
    stop: stopTime
  });
};
EntityCollection.prototype.add = function(entity) {
  if (!defined_default(entity)) {
    throw new DeveloperError_default("entity is required.");
  }
  if (!(entity instanceof Entity_default)) {
    entity = new Entity_default(entity);
  }
  const id = entity.id;
  const entities = this._entities;
  if (entities.contains(id)) {
    throw new RuntimeError_default(
      `An entity with id ${id} already exists in this collection.`
    );
  }
  entity.entityCollection = this;
  entities.set(id, entity);
  if (!this._removedEntities.remove(id)) {
    this._addedEntities.set(id, entity);
  }
  entity.definitionChanged.addEventListener(
    EntityCollection.prototype._onEntityDefinitionChanged,
    this
  );
  fireChangedEvent(this);
  return entity;
};
EntityCollection.prototype.remove = function(entity) {
  if (!defined_default(entity)) {
    return false;
  }
  return this.removeById(entity.id);
};
EntityCollection.prototype.contains = function(entity) {
  if (!defined_default(entity)) {
    throw new DeveloperError_default("entity is required");
  }
  return this._entities.get(entity.id) === entity;
};
EntityCollection.prototype.removeById = function(id) {
  if (!defined_default(id)) {
    return false;
  }
  const entities = this._entities;
  const entity = entities.get(id);
  if (!this._entities.remove(id)) {
    return false;
  }
  if (!this._addedEntities.remove(id)) {
    this._removedEntities.set(id, entity);
    this._changedEntities.remove(id);
  }
  this._entities.remove(id);
  entity.definitionChanged.removeEventListener(
    EntityCollection.prototype._onEntityDefinitionChanged,
    this
  );
  fireChangedEvent(this);
  return true;
};
EntityCollection.prototype.removeAll = function() {
  const entities = this._entities;
  const entitiesLength = entities.length;
  const array = entities.values;
  const addedEntities = this._addedEntities;
  const removed = this._removedEntities;
  for (let i2 = 0; i2 < entitiesLength; i2++) {
    const existingItem = array[i2];
    const existingItemId = existingItem.id;
    const addedItem = addedEntities.get(existingItemId);
    if (!defined_default(addedItem)) {
      existingItem.definitionChanged.removeEventListener(
        EntityCollection.prototype._onEntityDefinitionChanged,
        this
      );
      removed.set(existingItemId, existingItem);
    }
  }
  entities.removeAll();
  addedEntities.removeAll();
  this._changedEntities.removeAll();
  fireChangedEvent(this);
};
EntityCollection.prototype.getById = function(id) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required.");
  }
  return this._entities.get(id);
};
EntityCollection.prototype.getOrCreateEntity = function(id) {
  if (!defined_default(id)) {
    throw new DeveloperError_default("id is required.");
  }
  let entity = this._entities.get(id);
  if (!defined_default(entity)) {
    entityOptionsScratch.id = id;
    entity = new Entity_default(entityOptionsScratch);
    this.add(entity);
  }
  return entity;
};
EntityCollection.prototype._onEntityDefinitionChanged = function(entity) {
  const id = entity.id;
  if (!this._addedEntities.contains(id)) {
    this._changedEntities.set(id, entity);
  }
  fireChangedEvent(this);
};
var EntityCollection_default = EntityCollection;

// node_modules/cesium/Source/DataSources/CompositeEntityCollection.js
var entityOptionsScratch2 = {
  id: void 0
};
var entityIdScratch = new Array(2);
function clean(entity) {
  const propertyNames = entity.propertyNames;
  const propertyNamesLength = propertyNames.length;
  for (let i2 = 0; i2 < propertyNamesLength; i2++) {
    entity[propertyNames[i2]] = void 0;
  }
  entity._name = void 0;
  entity._availability = void 0;
}
function subscribeToEntity(that, eventHash, collectionId, entity) {
  entityIdScratch[0] = collectionId;
  entityIdScratch[1] = entity.id;
  eventHash[JSON.stringify(entityIdScratch)] = entity.definitionChanged.addEventListener(
    CompositeEntityCollection.prototype._onDefinitionChanged,
    that
  );
}
function unsubscribeFromEntity(that, eventHash, collectionId, entity) {
  entityIdScratch[0] = collectionId;
  entityIdScratch[1] = entity.id;
  const id = JSON.stringify(entityIdScratch);
  eventHash[id]();
  eventHash[id] = void 0;
}
function recomposite(that) {
  that._shouldRecomposite = true;
  if (that._suspendCount !== 0) {
    return;
  }
  const collections = that._collections;
  const collectionsLength = collections.length;
  const collectionsCopy = that._collectionsCopy;
  const collectionsCopyLength = collectionsCopy.length;
  let i2;
  let entity;
  let entities;
  let iEntities;
  let collection;
  const composite = that._composite;
  const newEntities = new EntityCollection_default(that);
  const eventHash = that._eventHash;
  let collectionId;
  for (i2 = 0; i2 < collectionsCopyLength; i2++) {
    collection = collectionsCopy[i2];
    collection.collectionChanged.removeEventListener(
      CompositeEntityCollection.prototype._onCollectionChanged,
      that
    );
    entities = collection.values;
    collectionId = collection.id;
    for (iEntities = entities.length - 1; iEntities > -1; iEntities--) {
      entity = entities[iEntities];
      unsubscribeFromEntity(that, eventHash, collectionId, entity);
    }
  }
  for (i2 = collectionsLength - 1; i2 >= 0; i2--) {
    collection = collections[i2];
    collection.collectionChanged.addEventListener(
      CompositeEntityCollection.prototype._onCollectionChanged,
      that
    );
    entities = collection.values;
    collectionId = collection.id;
    for (iEntities = entities.length - 1; iEntities > -1; iEntities--) {
      entity = entities[iEntities];
      subscribeToEntity(that, eventHash, collectionId, entity);
      let compositeEntity = newEntities.getById(entity.id);
      if (!defined_default(compositeEntity)) {
        compositeEntity = composite.getById(entity.id);
        if (!defined_default(compositeEntity)) {
          entityOptionsScratch2.id = entity.id;
          compositeEntity = new Entity_default(entityOptionsScratch2);
        } else {
          clean(compositeEntity);
        }
        newEntities.add(compositeEntity);
      }
      compositeEntity.merge(entity);
    }
  }
  that._collectionsCopy = collections.slice(0);
  composite.suspendEvents();
  composite.removeAll();
  const newEntitiesArray = newEntities.values;
  for (i2 = 0; i2 < newEntitiesArray.length; i2++) {
    composite.add(newEntitiesArray[i2]);
  }
  composite.resumeEvents();
}
function CompositeEntityCollection(collections, owner) {
  this._owner = owner;
  this._composite = new EntityCollection_default(this);
  this._suspendCount = 0;
  this._collections = defined_default(collections) ? collections.slice() : [];
  this._collectionsCopy = [];
  this._id = createGuid_default();
  this._eventHash = {};
  recomposite(this);
  this._shouldRecomposite = false;
}
Object.defineProperties(CompositeEntityCollection.prototype, {
  collectionChanged: {
    get: function() {
      return this._composite._collectionChanged;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  values: {
    get: function() {
      return this._composite.values;
    }
  },
  owner: {
    get: function() {
      return this._owner;
    }
  }
});
CompositeEntityCollection.prototype.addCollection = function(collection, index2) {
  const hasIndex = defined_default(index2);
  if (!defined_default(collection)) {
    throw new DeveloperError_default("collection is required.");
  }
  if (hasIndex) {
    if (index2 < 0) {
      throw new DeveloperError_default("index must be greater than or equal to zero.");
    } else if (index2 > this._collections.length) {
      throw new DeveloperError_default(
        "index must be less than or equal to the number of collections."
      );
    }
  }
  if (!hasIndex) {
    index2 = this._collections.length;
    this._collections.push(collection);
  } else {
    this._collections.splice(index2, 0, collection);
  }
  recomposite(this);
};
CompositeEntityCollection.prototype.removeCollection = function(collection) {
  const index2 = this._collections.indexOf(collection);
  if (index2 !== -1) {
    this._collections.splice(index2, 1);
    recomposite(this);
    return true;
  }
  return false;
};
CompositeEntityCollection.prototype.removeAllCollections = function() {
  this._collections.length = 0;
  recomposite(this);
};
CompositeEntityCollection.prototype.containsCollection = function(collection) {
  return this._collections.indexOf(collection) !== -1;
};
CompositeEntityCollection.prototype.contains = function(entity) {
  return this._composite.contains(entity);
};
CompositeEntityCollection.prototype.indexOfCollection = function(collection) {
  return this._collections.indexOf(collection);
};
CompositeEntityCollection.prototype.getCollection = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.", "index");
  }
  return this._collections[index2];
};
CompositeEntityCollection.prototype.getCollectionsLength = function() {
  return this._collections.length;
};
function getCollectionIndex(collections, collection) {
  if (!defined_default(collection)) {
    throw new DeveloperError_default("collection is required.");
  }
  const index2 = collections.indexOf(collection);
  if (index2 === -1) {
    throw new DeveloperError_default("collection is not in this composite.");
  }
  return index2;
}
function swapCollections(composite, i2, j) {
  const arr = composite._collections;
  i2 = Math_default.clamp(i2, 0, arr.length - 1);
  j = Math_default.clamp(j, 0, arr.length - 1);
  if (i2 === j) {
    return;
  }
  const temp = arr[i2];
  arr[i2] = arr[j];
  arr[j] = temp;
  recomposite(composite);
}
CompositeEntityCollection.prototype.raiseCollection = function(collection) {
  const index2 = getCollectionIndex(this._collections, collection);
  swapCollections(this, index2, index2 + 1);
};
CompositeEntityCollection.prototype.lowerCollection = function(collection) {
  const index2 = getCollectionIndex(this._collections, collection);
  swapCollections(this, index2, index2 - 1);
};
CompositeEntityCollection.prototype.raiseCollectionToTop = function(collection) {
  const index2 = getCollectionIndex(this._collections, collection);
  if (index2 === this._collections.length - 1) {
    return;
  }
  this._collections.splice(index2, 1);
  this._collections.push(collection);
  recomposite(this);
};
CompositeEntityCollection.prototype.lowerCollectionToBottom = function(collection) {
  const index2 = getCollectionIndex(this._collections, collection);
  if (index2 === 0) {
    return;
  }
  this._collections.splice(index2, 1);
  this._collections.splice(0, 0, collection);
  recomposite(this);
};
CompositeEntityCollection.prototype.suspendEvents = function() {
  this._suspendCount++;
  this._composite.suspendEvents();
};
CompositeEntityCollection.prototype.resumeEvents = function() {
  if (this._suspendCount === 0) {
    throw new DeveloperError_default(
      "resumeEvents can not be called before suspendEvents."
    );
  }
  this._suspendCount--;
  if (this._shouldRecomposite && this._suspendCount === 0) {
    recomposite(this);
    this._shouldRecomposite = false;
  }
  this._composite.resumeEvents();
};
CompositeEntityCollection.prototype.computeAvailability = function() {
  return this._composite.computeAvailability();
};
CompositeEntityCollection.prototype.getById = function(id) {
  return this._composite.getById(id);
};
CompositeEntityCollection.prototype._onCollectionChanged = function(collection, added, removed) {
  const collections = this._collectionsCopy;
  const collectionsLength = collections.length;
  const composite = this._composite;
  composite.suspendEvents();
  let i2;
  let q;
  let entity;
  let compositeEntity;
  const removedLength = removed.length;
  const eventHash = this._eventHash;
  const collectionId = collection.id;
  for (i2 = 0; i2 < removedLength; i2++) {
    const removedEntity = removed[i2];
    unsubscribeFromEntity(this, eventHash, collectionId, removedEntity);
    const removedId = removedEntity.id;
    for (q = collectionsLength - 1; q >= 0; q--) {
      entity = collections[q].getById(removedId);
      if (defined_default(entity)) {
        if (!defined_default(compositeEntity)) {
          compositeEntity = composite.getById(removedId);
          clean(compositeEntity);
        }
        compositeEntity.merge(entity);
      }
    }
    if (!defined_default(compositeEntity)) {
      composite.removeById(removedId);
    }
    compositeEntity = void 0;
  }
  const addedLength = added.length;
  for (i2 = 0; i2 < addedLength; i2++) {
    const addedEntity = added[i2];
    subscribeToEntity(this, eventHash, collectionId, addedEntity);
    const addedId = addedEntity.id;
    for (q = collectionsLength - 1; q >= 0; q--) {
      entity = collections[q].getById(addedId);
      if (defined_default(entity)) {
        if (!defined_default(compositeEntity)) {
          compositeEntity = composite.getById(addedId);
          if (!defined_default(compositeEntity)) {
            entityOptionsScratch2.id = addedId;
            compositeEntity = new Entity_default(entityOptionsScratch2);
            composite.add(compositeEntity);
          } else {
            clean(compositeEntity);
          }
        }
        compositeEntity.merge(entity);
      }
    }
    compositeEntity = void 0;
  }
  composite.resumeEvents();
};
CompositeEntityCollection.prototype._onDefinitionChanged = function(entity, propertyName, newValue, oldValue2) {
  const collections = this._collections;
  const composite = this._composite;
  const collectionsLength = collections.length;
  const id = entity.id;
  const compositeEntity = composite.getById(id);
  let compositeProperty = compositeEntity[propertyName];
  const newProperty = !defined_default(compositeProperty);
  let firstTime = true;
  for (let q = collectionsLength - 1; q >= 0; q--) {
    const innerEntity = collections[q].getById(entity.id);
    if (defined_default(innerEntity)) {
      const property = innerEntity[propertyName];
      if (defined_default(property)) {
        if (firstTime) {
          firstTime = false;
          if (defined_default(property.merge) && defined_default(property.clone)) {
            compositeProperty = property.clone(compositeProperty);
          } else {
            compositeProperty = property;
            break;
          }
        }
        compositeProperty.merge(property);
      }
    }
  }
  if (newProperty && compositeEntity.propertyNames.indexOf(propertyName) === -1) {
    compositeEntity.addProperty(propertyName);
  }
  compositeEntity[propertyName] = compositeProperty;
};
var CompositeEntityCollection_default = CompositeEntityCollection;

// node_modules/cesium/Source/DataSources/CompositeProperty.js
function subscribeAll(property, eventHelper, definitionChanged, intervals) {
  function callback() {
    definitionChanged.raiseEvent(property);
  }
  const items = [];
  eventHelper.removeAll();
  const length3 = intervals.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const interval = intervals.get(i2);
    if (defined_default(interval.data) && items.indexOf(interval.data) === -1) {
      eventHelper.add(interval.data.definitionChanged, callback);
    }
  }
}
function CompositeProperty() {
  this._eventHelper = new EventHelper_default();
  this._definitionChanged = new Event_default();
  this._intervals = new TimeIntervalCollection_default();
  this._intervals.changedEvent.addEventListener(
    CompositeProperty.prototype._intervalsChanged,
    this
  );
}
Object.defineProperties(CompositeProperty.prototype, {
  isConstant: {
    get: function() {
      return this._intervals.isEmpty;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  intervals: {
    get: function() {
      return this._intervals;
    }
  }
});
CompositeProperty.prototype.getValue = function(time, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required");
  }
  const innerProperty = this._intervals.findDataForIntervalContainingDate(time);
  if (defined_default(innerProperty)) {
    return innerProperty.getValue(time, result);
  }
  return void 0;
};
CompositeProperty.prototype.equals = function(other) {
  return this === other || other instanceof CompositeProperty && this._intervals.equals(other._intervals, Property_default.equals);
};
CompositeProperty.prototype._intervalsChanged = function() {
  subscribeAll(
    this,
    this._eventHelper,
    this._definitionChanged,
    this._intervals
  );
  this._definitionChanged.raiseEvent(this);
};
var CompositeProperty_default = CompositeProperty;

// node_modules/cesium/Source/DataSources/CompositeMaterialProperty.js
function CompositeMaterialProperty() {
  this._definitionChanged = new Event_default();
  this._composite = new CompositeProperty_default();
  this._composite.definitionChanged.addEventListener(
    CompositeMaterialProperty.prototype._raiseDefinitionChanged,
    this
  );
}
Object.defineProperties(CompositeMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return this._composite.isConstant;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  intervals: {
    get: function() {
      return this._composite._intervals;
    }
  }
});
CompositeMaterialProperty.prototype.getType = function(time) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required");
  }
  const innerProperty = this._composite._intervals.findDataForIntervalContainingDate(
    time
  );
  if (defined_default(innerProperty)) {
    return innerProperty.getType(time);
  }
  return void 0;
};
CompositeMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required");
  }
  const innerProperty = this._composite._intervals.findDataForIntervalContainingDate(
    time
  );
  if (defined_default(innerProperty)) {
    return innerProperty.getValue(time, result);
  }
  return void 0;
};
CompositeMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof CompositeMaterialProperty && this._composite.equals(other._composite, Property_default.equals);
};
CompositeMaterialProperty.prototype._raiseDefinitionChanged = function() {
  this._definitionChanged.raiseEvent(this);
};
var CompositeMaterialProperty_default = CompositeMaterialProperty;

// node_modules/cesium/Source/DataSources/CompositePositionProperty.js
function CompositePositionProperty(referenceFrame) {
  this._referenceFrame = defaultValue_default(referenceFrame, ReferenceFrame_default.FIXED);
  this._definitionChanged = new Event_default();
  this._composite = new CompositeProperty_default();
  this._composite.definitionChanged.addEventListener(
    CompositePositionProperty.prototype._raiseDefinitionChanged,
    this
  );
}
Object.defineProperties(CompositePositionProperty.prototype, {
  isConstant: {
    get: function() {
      return this._composite.isConstant;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  intervals: {
    get: function() {
      return this._composite.intervals;
    }
  },
  referenceFrame: {
    get: function() {
      return this._referenceFrame;
    },
    set: function(value) {
      this._referenceFrame = value;
    }
  }
});
CompositePositionProperty.prototype.getValue = function(time, result) {
  return this.getValueInReferenceFrame(time, ReferenceFrame_default.FIXED, result);
};
CompositePositionProperty.prototype.getValueInReferenceFrame = function(time, referenceFrame, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  if (!defined_default(referenceFrame)) {
    throw new DeveloperError_default("referenceFrame is required.");
  }
  const innerProperty = this._composite._intervals.findDataForIntervalContainingDate(
    time
  );
  if (defined_default(innerProperty)) {
    return innerProperty.getValueInReferenceFrame(time, referenceFrame, result);
  }
  return void 0;
};
CompositePositionProperty.prototype.equals = function(other) {
  return this === other || other instanceof CompositePositionProperty && this._referenceFrame === other._referenceFrame && this._composite.equals(other._composite, Property_default.equals);
};
CompositePositionProperty.prototype._raiseDefinitionChanged = function() {
  this._definitionChanged.raiseEvent(this);
};
var CompositePositionProperty_default = CompositePositionProperty;

// node_modules/cesium/Source/DataSources/GroundGeometryUpdater.js
var defaultZIndex = new ConstantProperty_default(0);
function GroundGeometryUpdater(options) {
  GeometryUpdater_default.call(this, options);
  this._zIndex = 0;
  this._terrainOffsetProperty = void 0;
}
if (defined_default(Object.create)) {
  GroundGeometryUpdater.prototype = Object.create(GeometryUpdater_default.prototype);
  GroundGeometryUpdater.prototype.constructor = GroundGeometryUpdater;
}
Object.defineProperties(GroundGeometryUpdater.prototype, {
  zIndex: {
    get: function() {
      return this._zIndex;
    }
  },
  terrainOffsetProperty: {
    get: function() {
      return this._terrainOffsetProperty;
    }
  }
});
GroundGeometryUpdater.prototype._isOnTerrain = function(entity, geometry) {
  return this._fillEnabled && !defined_default(geometry.height) && !defined_default(geometry.extrudedHeight) && GroundPrimitive_default.isSupported(this._scene);
};
GroundGeometryUpdater.prototype._getIsClosed = function(options) {
  const height = options.height;
  const extrudedHeight = options.extrudedHeight;
  return height === 0 || defined_default(extrudedHeight) && extrudedHeight !== height;
};
GroundGeometryUpdater.prototype._computeCenter = DeveloperError_default.throwInstantiationError;
GroundGeometryUpdater.prototype._onEntityPropertyChanged = function(entity, propertyName, newValue, oldValue2) {
  GeometryUpdater_default.prototype._onEntityPropertyChanged.call(
    this,
    entity,
    propertyName,
    newValue,
    oldValue2
  );
  if (this._observedPropertyNames.indexOf(propertyName) === -1) {
    return;
  }
  const geometry = this._entity[this._geometryPropertyName];
  if (!defined_default(geometry)) {
    return;
  }
  if (defined_default(geometry.zIndex) && (defined_default(geometry.height) || defined_default(geometry.extrudedHeight))) {
    oneTimeWarning_default(oneTimeWarning_default.geometryZIndex);
  }
  this._zIndex = defaultValue_default(geometry.zIndex, defaultZIndex);
  if (defined_default(this._terrainOffsetProperty)) {
    this._terrainOffsetProperty.destroy();
    this._terrainOffsetProperty = void 0;
  }
  const heightReferenceProperty = geometry.heightReference;
  const extrudedHeightReferenceProperty = geometry.extrudedHeightReference;
  if (defined_default(heightReferenceProperty) || defined_default(extrudedHeightReferenceProperty)) {
    const centerPosition = new CallbackProperty_default(
      this._computeCenter.bind(this),
      !this._dynamic
    );
    this._terrainOffsetProperty = new TerrainOffsetProperty_default(
      this._scene,
      centerPosition,
      heightReferenceProperty,
      extrudedHeightReferenceProperty
    );
  }
};
GroundGeometryUpdater.prototype.destroy = function() {
  if (defined_default(this._terrainOffsetProperty)) {
    this._terrainOffsetProperty.destroy();
    this._terrainOffsetProperty = void 0;
  }
  GeometryUpdater_default.prototype.destroy.call(this);
};
GroundGeometryUpdater.getGeometryHeight = function(height, heightReference) {
  Check_default.defined("heightReference", heightReference);
  if (!defined_default(height)) {
    if (heightReference !== HeightReference_default.NONE) {
      oneTimeWarning_default(oneTimeWarning_default.geometryHeightReference);
    }
    return;
  }
  if (heightReference !== HeightReference_default.CLAMP_TO_GROUND) {
    return height;
  }
  return 0;
};
GroundGeometryUpdater.getGeometryExtrudedHeight = function(extrudedHeight, extrudedHeightReference) {
  Check_default.defined("extrudedHeightReference", extrudedHeightReference);
  if (!defined_default(extrudedHeight)) {
    if (extrudedHeightReference !== HeightReference_default.NONE) {
      oneTimeWarning_default(oneTimeWarning_default.geometryExtrudedHeightReference);
    }
    return;
  }
  if (extrudedHeightReference !== HeightReference_default.CLAMP_TO_GROUND) {
    return extrudedHeight;
  }
  return GroundGeometryUpdater.CLAMP_TO_GROUND;
};
GroundGeometryUpdater.CLAMP_TO_GROUND = "clamp";
GroundGeometryUpdater.computeGeometryOffsetAttribute = function(height, heightReference, extrudedHeight, extrudedHeightReference) {
  if (!defined_default(height) || !defined_default(heightReference)) {
    heightReference = HeightReference_default.NONE;
  }
  if (!defined_default(extrudedHeight) || !defined_default(extrudedHeightReference)) {
    extrudedHeightReference = HeightReference_default.NONE;
  }
  let n2 = 0;
  if (heightReference !== HeightReference_default.NONE) {
    n2++;
  }
  if (extrudedHeightReference === HeightReference_default.RELATIVE_TO_GROUND) {
    n2++;
  }
  if (n2 === 2) {
    return GeometryOffsetAttribute_default.ALL;
  }
  if (n2 === 1) {
    return GeometryOffsetAttribute_default.TOP;
  }
  return void 0;
};
var GroundGeometryUpdater_default = GroundGeometryUpdater;

// node_modules/cesium/Source/DataSources/CorridorGeometryUpdater.js
var scratchColor12 = new Color_default();
var defaultOffset2 = Cartesian3_default.ZERO;
var offsetScratch5 = new Cartesian3_default();
var scratchRectangle5 = new Rectangle_default();
function CorridorGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.positions = void 0;
  this.width = void 0;
  this.cornerType = void 0;
  this.height = void 0;
  this.extrudedHeight = void 0;
  this.granularity = void 0;
  this.offsetAttribute = void 0;
}
function CorridorGeometryUpdater(entity, scene) {
  GroundGeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new CorridorGeometryOptions(entity),
    geometryPropertyName: "corridor",
    observedPropertyNames: ["availability", "corridor"]
  });
  this._onEntityPropertyChanged(entity, "corridor", entity.corridor, void 0);
}
if (defined_default(Object.create)) {
  CorridorGeometryUpdater.prototype = Object.create(
    GroundGeometryUpdater_default.prototype
  );
  CorridorGeometryUpdater.prototype.constructor = CorridorGeometryUpdater;
}
CorridorGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
    ),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      this._distanceDisplayConditionProperty.getValue(time)
    ),
    offset: void 0,
    color: void 0
  };
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor12);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    attributes.color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
  }
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset2,
        offsetScratch5
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new CorridorGeometry_default(this._options),
    attributes
  });
};
CorridorGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._outlineEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent an outlined geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor12
  );
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
    ),
    color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      this._distanceDisplayConditionProperty.getValue(time)
    ),
    offset: void 0
  };
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset2,
        offsetScratch5
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new CorridorOutlineGeometry_default(this._options),
    attributes
  });
};
CorridorGeometryUpdater.prototype._computeCenter = function(time, result) {
  const positions = Property_default.getValueOrUndefined(
    this._entity.corridor.positions,
    time
  );
  if (!defined_default(positions) || positions.length === 0) {
    return;
  }
  return Cartesian3_default.clone(
    positions[Math.floor(positions.length / 2)],
    result
  );
};
CorridorGeometryUpdater.prototype._isHidden = function(entity, corridor) {
  return !defined_default(corridor.positions) || !defined_default(corridor.width) || GeometryUpdater_default.prototype._isHidden.call(this, entity, corridor);
};
CorridorGeometryUpdater.prototype._isDynamic = function(entity, corridor) {
  return !corridor.positions.isConstant || !Property_default.isConstant(corridor.height) || !Property_default.isConstant(corridor.extrudedHeight) || !Property_default.isConstant(corridor.granularity) || !Property_default.isConstant(corridor.width) || !Property_default.isConstant(corridor.outlineWidth) || !Property_default.isConstant(corridor.cornerType) || !Property_default.isConstant(corridor.zIndex) || this._onTerrain && !Property_default.isConstant(this._materialProperty) && !(this._materialProperty instanceof ColorMaterialProperty_default);
};
CorridorGeometryUpdater.prototype._setStaticOptions = function(entity, corridor) {
  let heightValue = Property_default.getValueOrUndefined(
    corridor.height,
    Iso8601_default.MINIMUM_VALUE
  );
  const heightReferenceValue = Property_default.getValueOrDefault(
    corridor.heightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  let extrudedHeightValue = Property_default.getValueOrUndefined(
    corridor.extrudedHeight,
    Iso8601_default.MINIMUM_VALUE
  );
  const extrudedHeightReferenceValue = Property_default.getValueOrDefault(
    corridor.extrudedHeightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  if (defined_default(extrudedHeightValue) && !defined_default(heightValue)) {
    heightValue = 0;
  }
  const options = this._options;
  options.vertexFormat = this._materialProperty instanceof ColorMaterialProperty_default ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  options.positions = corridor.positions.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.positions
  );
  options.width = corridor.width.getValue(Iso8601_default.MINIMUM_VALUE);
  options.granularity = Property_default.getValueOrUndefined(
    corridor.granularity,
    Iso8601_default.MINIMUM_VALUE
  );
  options.cornerType = Property_default.getValueOrUndefined(
    corridor.cornerType,
    Iso8601_default.MINIMUM_VALUE
  );
  options.offsetAttribute = GroundGeometryUpdater_default.computeGeometryOffsetAttribute(
    heightValue,
    heightReferenceValue,
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  options.height = GroundGeometryUpdater_default.getGeometryHeight(
    heightValue,
    heightReferenceValue
  );
  extrudedHeightValue = GroundGeometryUpdater_default.getGeometryExtrudedHeight(
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  if (extrudedHeightValue === GroundGeometryUpdater_default.CLAMP_TO_GROUND) {
    extrudedHeightValue = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
      CorridorGeometry_default.computeRectangle(options, scratchRectangle5)
    ).minimumTerrainHeight;
  }
  options.extrudedHeight = extrudedHeightValue;
};
CorridorGeometryUpdater.DynamicGeometryUpdater = DynamicCorridorGeometryUpdater;
function DynamicCorridorGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
}
if (defined_default(Object.create)) {
  DynamicCorridorGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DynamicCorridorGeometryUpdater.prototype.constructor = DynamicCorridorGeometryUpdater;
}
DynamicCorridorGeometryUpdater.prototype._isHidden = function(entity, corridor, time) {
  const options = this._options;
  return !defined_default(options.positions) || !defined_default(options.width) || DynamicGeometryUpdater_default.prototype._isHidden.call(
    this,
    entity,
    corridor,
    time
  );
};
DynamicCorridorGeometryUpdater.prototype._setOptions = function(entity, corridor, time) {
  const options = this._options;
  let heightValue = Property_default.getValueOrUndefined(corridor.height, time);
  const heightReferenceValue = Property_default.getValueOrDefault(
    corridor.heightReference,
    time,
    HeightReference_default.NONE
  );
  let extrudedHeightValue = Property_default.getValueOrUndefined(
    corridor.extrudedHeight,
    time
  );
  const extrudedHeightReferenceValue = Property_default.getValueOrDefault(
    corridor.extrudedHeightReference,
    time,
    HeightReference_default.NONE
  );
  if (defined_default(extrudedHeightValue) && !defined_default(heightValue)) {
    heightValue = 0;
  }
  options.positions = Property_default.getValueOrUndefined(corridor.positions, time);
  options.width = Property_default.getValueOrUndefined(corridor.width, time);
  options.granularity = Property_default.getValueOrUndefined(
    corridor.granularity,
    time
  );
  options.cornerType = Property_default.getValueOrUndefined(corridor.cornerType, time);
  options.offsetAttribute = GroundGeometryUpdater_default.computeGeometryOffsetAttribute(
    heightValue,
    heightReferenceValue,
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  options.height = GroundGeometryUpdater_default.getGeometryHeight(
    heightValue,
    heightReferenceValue
  );
  extrudedHeightValue = GroundGeometryUpdater_default.getGeometryExtrudedHeight(
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  if (extrudedHeightValue === GroundGeometryUpdater_default.CLAMP_TO_GROUND) {
    extrudedHeightValue = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
      CorridorGeometry_default.computeRectangle(options, scratchRectangle5)
    ).minimumTerrainHeight;
  }
  options.extrudedHeight = extrudedHeightValue;
};
var CorridorGeometryUpdater_default = CorridorGeometryUpdater;

// node_modules/cesium/Source/DataSources/DataSource.js
function DataSource() {
  DeveloperError_default.throwInstantiationError();
}
Object.defineProperties(DataSource.prototype, {
  name: {
    get: DeveloperError_default.throwInstantiationError
  },
  clock: {
    get: DeveloperError_default.throwInstantiationError
  },
  entities: {
    get: DeveloperError_default.throwInstantiationError
  },
  isLoading: {
    get: DeveloperError_default.throwInstantiationError
  },
  changedEvent: {
    get: DeveloperError_default.throwInstantiationError
  },
  errorEvent: {
    get: DeveloperError_default.throwInstantiationError
  },
  loadingEvent: {
    get: DeveloperError_default.throwInstantiationError
  },
  show: {
    get: DeveloperError_default.throwInstantiationError
  },
  clustering: {
    get: DeveloperError_default.throwInstantiationError
  }
});
DataSource.prototype.update = function(time) {
  DeveloperError_default.throwInstantiationError();
};
DataSource.setLoading = function(dataSource, isLoading) {
  if (dataSource._isLoading !== isLoading) {
    if (isLoading) {
      dataSource._entityCollection.suspendEvents();
    } else {
      dataSource._entityCollection.resumeEvents();
    }
    dataSource._isLoading = isLoading;
    dataSource._loading.raiseEvent(dataSource, isLoading);
  }
};
var DataSource_default = DataSource;

// node_modules/cesium/Source/Scene/PointPrimitive.js
function PointPrimitive(options, pointPrimitiveCollection) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (defined_default(options.disableDepthTestDistance) && options.disableDepthTestDistance < 0) {
    throw new DeveloperError_default(
      "disableDepthTestDistance must be greater than or equal to 0.0."
    );
  }
  let translucencyByDistance = options.translucencyByDistance;
  let scaleByDistance = options.scaleByDistance;
  let distanceDisplayCondition = options.distanceDisplayCondition;
  if (defined_default(translucencyByDistance)) {
    if (translucencyByDistance.far <= translucencyByDistance.near) {
      throw new DeveloperError_default(
        "translucencyByDistance.far must be greater than translucencyByDistance.near."
      );
    }
    translucencyByDistance = NearFarScalar_default.clone(translucencyByDistance);
  }
  if (defined_default(scaleByDistance)) {
    if (scaleByDistance.far <= scaleByDistance.near) {
      throw new DeveloperError_default(
        "scaleByDistance.far must be greater than scaleByDistance.near."
      );
    }
    scaleByDistance = NearFarScalar_default.clone(scaleByDistance);
  }
  if (defined_default(distanceDisplayCondition)) {
    if (distanceDisplayCondition.far <= distanceDisplayCondition.near) {
      throw new DeveloperError_default(
        "distanceDisplayCondition.far must be greater than distanceDisplayCondition.near."
      );
    }
    distanceDisplayCondition = DistanceDisplayCondition_default.clone(
      distanceDisplayCondition
    );
  }
  this._show = defaultValue_default(options.show, true);
  this._position = Cartesian3_default.clone(
    defaultValue_default(options.position, Cartesian3_default.ZERO)
  );
  this._actualPosition = Cartesian3_default.clone(this._position);
  this._color = Color_default.clone(defaultValue_default(options.color, Color_default.WHITE));
  this._outlineColor = Color_default.clone(
    defaultValue_default(options.outlineColor, Color_default.TRANSPARENT)
  );
  this._outlineWidth = defaultValue_default(options.outlineWidth, 0);
  this._pixelSize = defaultValue_default(options.pixelSize, 10);
  this._scaleByDistance = scaleByDistance;
  this._translucencyByDistance = translucencyByDistance;
  this._distanceDisplayCondition = distanceDisplayCondition;
  this._disableDepthTestDistance = defaultValue_default(
    options.disableDepthTestDistance,
    0
  );
  this._id = options.id;
  this._collection = defaultValue_default(options.collection, pointPrimitiveCollection);
  this._clusterShow = true;
  this._pickId = void 0;
  this._pointPrimitiveCollection = pointPrimitiveCollection;
  this._dirty = false;
  this._index = -1;
}
var SHOW_INDEX5 = PointPrimitive.SHOW_INDEX = 0;
var POSITION_INDEX5 = PointPrimitive.POSITION_INDEX = 1;
var COLOR_INDEX3 = PointPrimitive.COLOR_INDEX = 2;
var OUTLINE_COLOR_INDEX = PointPrimitive.OUTLINE_COLOR_INDEX = 3;
var OUTLINE_WIDTH_INDEX = PointPrimitive.OUTLINE_WIDTH_INDEX = 4;
var PIXEL_SIZE_INDEX = PointPrimitive.PIXEL_SIZE_INDEX = 5;
var SCALE_BY_DISTANCE_INDEX3 = PointPrimitive.SCALE_BY_DISTANCE_INDEX = 6;
var TRANSLUCENCY_BY_DISTANCE_INDEX3 = PointPrimitive.TRANSLUCENCY_BY_DISTANCE_INDEX = 7;
var DISTANCE_DISPLAY_CONDITION_INDEX2 = PointPrimitive.DISTANCE_DISPLAY_CONDITION_INDEX = 8;
var DISABLE_DEPTH_DISTANCE_INDEX = PointPrimitive.DISABLE_DEPTH_DISTANCE_INDEX = 9;
PointPrimitive.NUMBER_OF_PROPERTIES = 10;
function makeDirty3(pointPrimitive, propertyChanged) {
  const pointPrimitiveCollection = pointPrimitive._pointPrimitiveCollection;
  if (defined_default(pointPrimitiveCollection)) {
    pointPrimitiveCollection._updatePointPrimitive(
      pointPrimitive,
      propertyChanged
    );
    pointPrimitive._dirty = true;
  }
}
Object.defineProperties(PointPrimitive.prototype, {
  show: {
    get: function() {
      return this._show;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._show !== value) {
        this._show = value;
        makeDirty3(this, SHOW_INDEX5);
      }
    }
  },
  position: {
    get: function() {
      return this._position;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const position = this._position;
      if (!Cartesian3_default.equals(position, value)) {
        Cartesian3_default.clone(value, position);
        Cartesian3_default.clone(value, this._actualPosition);
        makeDirty3(this, POSITION_INDEX5);
      }
    }
  },
  scaleByDistance: {
    get: function() {
      return this._scaleByDistance;
    },
    set: function(value) {
      if (defined_default(value) && value.far <= value.near) {
        throw new DeveloperError_default(
          "far distance must be greater than near distance."
        );
      }
      const scaleByDistance = this._scaleByDistance;
      if (!NearFarScalar_default.equals(scaleByDistance, value)) {
        this._scaleByDistance = NearFarScalar_default.clone(value, scaleByDistance);
        makeDirty3(this, SCALE_BY_DISTANCE_INDEX3);
      }
    }
  },
  translucencyByDistance: {
    get: function() {
      return this._translucencyByDistance;
    },
    set: function(value) {
      if (defined_default(value) && value.far <= value.near) {
        throw new DeveloperError_default(
          "far distance must be greater than near distance."
        );
      }
      const translucencyByDistance = this._translucencyByDistance;
      if (!NearFarScalar_default.equals(translucencyByDistance, value)) {
        this._translucencyByDistance = NearFarScalar_default.clone(
          value,
          translucencyByDistance
        );
        makeDirty3(this, TRANSLUCENCY_BY_DISTANCE_INDEX3);
      }
    }
  },
  pixelSize: {
    get: function() {
      return this._pixelSize;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._pixelSize !== value) {
        this._pixelSize = value;
        makeDirty3(this, PIXEL_SIZE_INDEX);
      }
    }
  },
  color: {
    get: function() {
      return this._color;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const color = this._color;
      if (!Color_default.equals(color, value)) {
        Color_default.clone(value, color);
        makeDirty3(this, COLOR_INDEX3);
      }
    }
  },
  outlineColor: {
    get: function() {
      return this._outlineColor;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      const outlineColor = this._outlineColor;
      if (!Color_default.equals(outlineColor, value)) {
        Color_default.clone(value, outlineColor);
        makeDirty3(this, OUTLINE_COLOR_INDEX);
      }
    }
  },
  outlineWidth: {
    get: function() {
      return this._outlineWidth;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._outlineWidth !== value) {
        this._outlineWidth = value;
        makeDirty3(this, OUTLINE_WIDTH_INDEX);
      }
    }
  },
  distanceDisplayCondition: {
    get: function() {
      return this._distanceDisplayCondition;
    },
    set: function(value) {
      if (defined_default(value) && value.far <= value.near) {
        throw new DeveloperError_default("far must be greater than near");
      }
      if (!DistanceDisplayCondition_default.equals(this._distanceDisplayCondition, value)) {
        this._distanceDisplayCondition = DistanceDisplayCondition_default.clone(
          value,
          this._distanceDisplayCondition
        );
        makeDirty3(this, DISTANCE_DISPLAY_CONDITION_INDEX2);
      }
    }
  },
  disableDepthTestDistance: {
    get: function() {
      return this._disableDepthTestDistance;
    },
    set: function(value) {
      if (this._disableDepthTestDistance !== value) {
        if (!defined_default(value) || value < 0) {
          throw new DeveloperError_default(
            "disableDepthTestDistance must be greater than or equal to 0.0."
          );
        }
        this._disableDepthTestDistance = value;
        makeDirty3(this, DISABLE_DEPTH_DISTANCE_INDEX);
      }
    }
  },
  id: {
    get: function() {
      return this._id;
    },
    set: function(value) {
      this._id = value;
      if (defined_default(this._pickId)) {
        this._pickId.object.id = value;
      }
    }
  },
  pickId: {
    get: function() {
      return this._pickId;
    }
  },
  clusterShow: {
    get: function() {
      return this._clusterShow;
    },
    set: function(value) {
      if (this._clusterShow !== value) {
        this._clusterShow = value;
        makeDirty3(this, SHOW_INDEX5);
      }
    }
  }
});
PointPrimitive.prototype.getPickId = function(context) {
  if (!defined_default(this._pickId)) {
    this._pickId = context.createPickId({
      primitive: this,
      collection: this._collection,
      id: this._id
    });
  }
  return this._pickId;
};
PointPrimitive.prototype._getActualPosition = function() {
  return this._actualPosition;
};
PointPrimitive.prototype._setActualPosition = function(value) {
  Cartesian3_default.clone(value, this._actualPosition);
  makeDirty3(this, POSITION_INDEX5);
};
var tempCartesian32 = new Cartesian4_default();
PointPrimitive._computeActualPosition = function(position, frameState, modelMatrix) {
  if (frameState.mode === SceneMode_default.SCENE3D) {
    return position;
  }
  Matrix4_default.multiplyByPoint(modelMatrix, position, tempCartesian32);
  return SceneTransforms_default.computeActualWgs84Position(frameState, tempCartesian32);
};
var scratchCartesian45 = new Cartesian4_default();
PointPrimitive._computeScreenSpacePosition = function(modelMatrix, position, scene, result) {
  const positionWorld = Matrix4_default.multiplyByVector(
    modelMatrix,
    Cartesian4_default.fromElements(
      position.x,
      position.y,
      position.z,
      1,
      scratchCartesian45
    ),
    scratchCartesian45
  );
  const positionWC2 = SceneTransforms_default.wgs84ToWindowCoordinates(
    scene,
    positionWorld,
    result
  );
  return positionWC2;
};
PointPrimitive.prototype.computeScreenSpacePosition = function(scene, result) {
  const pointPrimitiveCollection = this._pointPrimitiveCollection;
  if (!defined_default(result)) {
    result = new Cartesian2_default();
  }
  if (!defined_default(pointPrimitiveCollection)) {
    throw new DeveloperError_default("PointPrimitive must be in a collection.");
  }
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  const modelMatrix = pointPrimitiveCollection.modelMatrix;
  const windowCoordinates = PointPrimitive._computeScreenSpacePosition(
    modelMatrix,
    this._actualPosition,
    scene,
    result
  );
  if (!defined_default(windowCoordinates)) {
    return void 0;
  }
  windowCoordinates.y = scene.canvas.clientHeight - windowCoordinates.y;
  return windowCoordinates;
};
PointPrimitive.getScreenSpaceBoundingBox = function(point, screenSpacePosition, result) {
  const size = point.pixelSize;
  const halfSize = size * 0.5;
  const x = screenSpacePosition.x - halfSize;
  const y = screenSpacePosition.y - halfSize;
  const width = size;
  const height = size;
  if (!defined_default(result)) {
    result = new BoundingRectangle_default();
  }
  result.x = x;
  result.y = y;
  result.width = width;
  result.height = height;
  return result;
};
PointPrimitive.prototype.equals = function(other) {
  return this === other || defined_default(other) && this._id === other._id && Cartesian3_default.equals(this._position, other._position) && Color_default.equals(this._color, other._color) && this._pixelSize === other._pixelSize && this._outlineWidth === other._outlineWidth && this._show === other._show && Color_default.equals(this._outlineColor, other._outlineColor) && NearFarScalar_default.equals(this._scaleByDistance, other._scaleByDistance) && NearFarScalar_default.equals(
    this._translucencyByDistance,
    other._translucencyByDistance
  ) && DistanceDisplayCondition_default.equals(
    this._distanceDisplayCondition,
    other._distanceDisplayCondition
  ) && this._disableDepthTestDistance === other._disableDepthTestDistance;
};
PointPrimitive.prototype._destroy = function() {
  this._pickId = this._pickId && this._pickId.destroy();
  this._pointPrimitiveCollection = void 0;
};
var PointPrimitive_default = PointPrimitive;

// node_modules/cesium/Source/Shaders/PointPrimitiveCollectionFS.js
var PointPrimitiveCollectionFS_default = "varying vec4 v_color;\nvarying vec4 v_outlineColor;\nvarying float v_innerPercent;\nvarying float v_pixelDistance;\nvarying vec4 v_pickColor;\n\nvoid main()\n{\n    // The distance in UV space from this fragment to the center of the point, at most 0.5.\n    float distanceToCenter = length(gl_PointCoord - vec2(0.5));\n    // The max distance stops one pixel shy of the edge to leave space for anti-aliasing.\n    float maxDistance = max(0.0, 0.5 - v_pixelDistance);\n    float wholeAlpha = 1.0 - smoothstep(maxDistance, 0.5, distanceToCenter);\n    float innerAlpha = 1.0 - smoothstep(maxDistance * v_innerPercent, 0.5 * v_innerPercent, distanceToCenter);\n\n    vec4 color = mix(v_outlineColor, v_color, innerAlpha);\n    color.a *= wholeAlpha;\n\n// Fully transparent parts of the billboard are not pickable.\n#if !defined(OPAQUE) && !defined(TRANSLUCENT)\n    if (color.a < 0.005)   // matches 0/255 and 1/255\n    {\n        discard;\n    }\n#else\n// The billboard is rendered twice. The opaque pass discards translucent fragments\n// and the translucent pass discards opaque fragments.\n#ifdef OPAQUE\n    if (color.a < 0.995)   // matches < 254/255\n    {\n        discard;\n    }\n#else\n    if (color.a >= 0.995)  // matches 254/255 and 255/255\n    {\n        discard;\n    }\n#endif\n#endif\n\n    gl_FragColor = czm_gammaCorrect(color);\n    czm_writeLogDepth();\n}\n";

// node_modules/cesium/Source/Shaders/PointPrimitiveCollectionVS.js
var PointPrimitiveCollectionVS_default = `uniform float u_maxTotalPointSize;

attribute vec4 positionHighAndSize;
attribute vec4 positionLowAndOutline;
attribute vec4 compressedAttribute0;                       // color, outlineColor, pick color
attribute vec4 compressedAttribute1;                       // show, translucency by distance, some free space
attribute vec4 scaleByDistance;                            // near, nearScale, far, farScale
attribute vec3 distanceDisplayConditionAndDisableDepth;    // near, far, disableDepthTestDistance

varying vec4 v_color;
varying vec4 v_outlineColor;
varying float v_innerPercent;
varying float v_pixelDistance;
varying vec4 v_pickColor;

const float SHIFT_LEFT8 = 256.0;
const float SHIFT_RIGHT8 = 1.0 / 256.0;

void main()
{
    // Modifying this shader may also require modifications to PointPrimitive._computeScreenSpacePosition

    // unpack attributes
    vec3 positionHigh = positionHighAndSize.xyz;
    vec3 positionLow = positionLowAndOutline.xyz;
    float outlineWidthBothSides = 2.0 * positionLowAndOutline.w;
    float totalSize = positionHighAndSize.w + outlineWidthBothSides;
    float outlinePercent = outlineWidthBothSides / totalSize;
    // Scale in response to browser-zoom.
    totalSize *= czm_pixelRatio;
    // Add padding for anti-aliasing on both sides.
    totalSize += 3.0;

    float temp = compressedAttribute1.x * SHIFT_RIGHT8;
    float show = floor(temp);

#ifdef EYE_DISTANCE_TRANSLUCENCY
    vec4 translucencyByDistance;
    translucencyByDistance.x = compressedAttribute1.z;
    translucencyByDistance.z = compressedAttribute1.w;

    translucencyByDistance.y = ((temp - floor(temp)) * SHIFT_LEFT8) / 255.0;

    temp = compressedAttribute1.y * SHIFT_RIGHT8;
    translucencyByDistance.w = ((temp - floor(temp)) * SHIFT_LEFT8) / 255.0;
#endif

    ///////////////////////////////////////////////////////////////////////////

    vec4 color;
    vec4 outlineColor;
    vec4 pickColor;

    // compressedAttribute0.z => pickColor.rgb

    temp = compressedAttribute0.z * SHIFT_RIGHT8;
    pickColor.b = (temp - floor(temp)) * SHIFT_LEFT8;
    temp = floor(temp) * SHIFT_RIGHT8;
    pickColor.g = (temp - floor(temp)) * SHIFT_LEFT8;
    pickColor.r = floor(temp);

    // compressedAttribute0.x => color.rgb

    temp = compressedAttribute0.x * SHIFT_RIGHT8;
    color.b = (temp - floor(temp)) * SHIFT_LEFT8;
    temp = floor(temp) * SHIFT_RIGHT8;
    color.g = (temp - floor(temp)) * SHIFT_LEFT8;
    color.r = floor(temp);

    // compressedAttribute0.y => outlineColor.rgb

    temp = compressedAttribute0.y * SHIFT_RIGHT8;
    outlineColor.b = (temp - floor(temp)) * SHIFT_LEFT8;
    temp = floor(temp) * SHIFT_RIGHT8;
    outlineColor.g = (temp - floor(temp)) * SHIFT_LEFT8;
    outlineColor.r = floor(temp);

    // compressedAttribute0.w => color.a, outlineColor.a, pickColor.a

    temp = compressedAttribute0.w * SHIFT_RIGHT8;
    pickColor.a = (temp - floor(temp)) * SHIFT_LEFT8;
    pickColor = pickColor / 255.0;

    temp = floor(temp) * SHIFT_RIGHT8;
    outlineColor.a = (temp - floor(temp)) * SHIFT_LEFT8;
    outlineColor /= 255.0;
    color.a = floor(temp);
    color /= 255.0;

    ///////////////////////////////////////////////////////////////////////////

    vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);
    vec4 positionEC = czm_modelViewRelativeToEye * p;

    ///////////////////////////////////////////////////////////////////////////

#if defined(EYE_DISTANCE_SCALING) || defined(EYE_DISTANCE_TRANSLUCENCY) || defined(DISTANCE_DISPLAY_CONDITION) || defined(DISABLE_DEPTH_DISTANCE)
    float lengthSq;
    if (czm_sceneMode == czm_sceneMode2D)
    {
        // 2D camera distance is a special case
        // treat all billboards as flattened to the z=0.0 plane
        lengthSq = czm_eyeHeight2D.y;
    }
    else
    {
        lengthSq = dot(positionEC.xyz, positionEC.xyz);
    }
#endif

#ifdef EYE_DISTANCE_SCALING
    totalSize *= czm_nearFarScalar(scaleByDistance, lengthSq);
#endif
    // Clamp to max point size.
    totalSize = min(totalSize, u_maxTotalPointSize);
    // If size is too small, push vertex behind near plane for clipping.
    // Note that context.minimumAliasedPointSize "will be at most 1.0".
    if (totalSize < 1.0)
    {
        positionEC.xyz = vec3(0.0);
        totalSize = 1.0;
    }

    float translucency = 1.0;
#ifdef EYE_DISTANCE_TRANSLUCENCY
    translucency = czm_nearFarScalar(translucencyByDistance, lengthSq);
    // push vertex behind near plane for clipping
    if (translucency < 0.004)
    {
        positionEC.xyz = vec3(0.0);
    }
#endif

#ifdef DISTANCE_DISPLAY_CONDITION
    float nearSq = distanceDisplayConditionAndDisableDepth.x;
    float farSq = distanceDisplayConditionAndDisableDepth.y;
    if (lengthSq < nearSq || lengthSq > farSq) {
        // push vertex behind camera to force it to be clipped
        positionEC.xyz = vec3(0.0, 0.0, 1.0);
    }
#endif

    gl_Position = czm_projection * positionEC;
    czm_vertexLogDepth();

#ifdef DISABLE_DEPTH_DISTANCE
    float disableDepthTestDistance = distanceDisplayConditionAndDisableDepth.z;
    if (disableDepthTestDistance == 0.0 && czm_minimumDisableDepthTestDistance != 0.0)
    {
        disableDepthTestDistance = czm_minimumDisableDepthTestDistance;
    }

    if (disableDepthTestDistance != 0.0)
    {
        // Don't try to "multiply both sides" by w.  Greater/less-than comparisons won't work for negative values of w.
        float zclip = gl_Position.z / gl_Position.w;
        bool clipped = (zclip < -1.0 || zclip > 1.0);
        if (!clipped && (disableDepthTestDistance < 0.0 || (lengthSq > 0.0 && lengthSq < disableDepthTestDistance)))
        {
            // Position z on the near plane.
            gl_Position.z = -gl_Position.w;
#ifdef LOG_DEPTH
            czm_vertexLogDepth(vec4(czm_currentFrustum.x));
#endif
        }
    }
#endif

    v_color = color;
    v_color.a *= translucency * show;
    v_outlineColor = outlineColor;
    v_outlineColor.a *= translucency * show;

    v_innerPercent = 1.0 - outlinePercent;
    v_pixelDistance = 2.0 / totalSize;
    gl_PointSize = totalSize * show;
    gl_Position *= show;

    v_pickColor = pickColor;
}
`;

// node_modules/cesium/Source/Scene/PointPrimitiveCollection.js
var SHOW_INDEX6 = PointPrimitive_default.SHOW_INDEX;
var POSITION_INDEX6 = PointPrimitive_default.POSITION_INDEX;
var COLOR_INDEX4 = PointPrimitive_default.COLOR_INDEX;
var OUTLINE_COLOR_INDEX2 = PointPrimitive_default.OUTLINE_COLOR_INDEX;
var OUTLINE_WIDTH_INDEX2 = PointPrimitive_default.OUTLINE_WIDTH_INDEX;
var PIXEL_SIZE_INDEX2 = PointPrimitive_default.PIXEL_SIZE_INDEX;
var SCALE_BY_DISTANCE_INDEX4 = PointPrimitive_default.SCALE_BY_DISTANCE_INDEX;
var TRANSLUCENCY_BY_DISTANCE_INDEX4 = PointPrimitive_default.TRANSLUCENCY_BY_DISTANCE_INDEX;
var DISTANCE_DISPLAY_CONDITION_INDEX3 = PointPrimitive_default.DISTANCE_DISPLAY_CONDITION_INDEX;
var DISABLE_DEPTH_DISTANCE_INDEX2 = PointPrimitive_default.DISABLE_DEPTH_DISTANCE_INDEX;
var NUMBER_OF_PROPERTIES4 = PointPrimitive_default.NUMBER_OF_PROPERTIES;
var attributeLocations5 = {
  positionHighAndSize: 0,
  positionLowAndOutline: 1,
  compressedAttribute0: 2,
  compressedAttribute1: 3,
  scaleByDistance: 4,
  distanceDisplayConditionAndDisableDepth: 5
};
function PointPrimitiveCollection(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._sp = void 0;
  this._spTranslucent = void 0;
  this._rsOpaque = void 0;
  this._rsTranslucent = void 0;
  this._vaf = void 0;
  this._pointPrimitives = [];
  this._pointPrimitivesToUpdate = [];
  this._pointPrimitivesToUpdateIndex = 0;
  this._pointPrimitivesRemoved = false;
  this._createVertexArray = false;
  this._shaderScaleByDistance = false;
  this._compiledShaderScaleByDistance = false;
  this._shaderTranslucencyByDistance = false;
  this._compiledShaderTranslucencyByDistance = false;
  this._shaderDistanceDisplayCondition = false;
  this._compiledShaderDistanceDisplayCondition = false;
  this._shaderDisableDepthDistance = false;
  this._compiledShaderDisableDepthDistance = false;
  this._propertiesChanged = new Uint32Array(NUMBER_OF_PROPERTIES4);
  this._maxPixelSize = 1;
  this._baseVolume = new BoundingSphere_default();
  this._baseVolumeWC = new BoundingSphere_default();
  this._baseVolume2D = new BoundingSphere_default();
  this._boundingVolume = new BoundingSphere_default();
  this._boundingVolumeDirty = false;
  this._colorCommands = [];
  this.show = defaultValue_default(options.show, true);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._modelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this.blendOption = defaultValue_default(
    options.blendOption,
    BlendOption_default.OPAQUE_AND_TRANSLUCENT
  );
  this._blendOption = void 0;
  this._mode = SceneMode_default.SCENE3D;
  this._maxTotalPointSize = 1;
  this._buffersUsage = [
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW,
    BufferUsage_default.STATIC_DRAW
  ];
  const that = this;
  this._uniforms = {
    u_maxTotalPointSize: function() {
      return that._maxTotalPointSize;
    }
  };
}
Object.defineProperties(PointPrimitiveCollection.prototype, {
  length: {
    get: function() {
      removePointPrimitives(this);
      return this._pointPrimitives.length;
    }
  }
});
function destroyPointPrimitives(pointPrimitives) {
  const length3 = pointPrimitives.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (pointPrimitives[i2]) {
      pointPrimitives[i2]._destroy();
    }
  }
}
PointPrimitiveCollection.prototype.add = function(options) {
  const p2 = new PointPrimitive_default(options, this);
  p2._index = this._pointPrimitives.length;
  this._pointPrimitives.push(p2);
  this._createVertexArray = true;
  return p2;
};
PointPrimitiveCollection.prototype.remove = function(pointPrimitive) {
  if (this.contains(pointPrimitive)) {
    this._pointPrimitives[pointPrimitive._index] = null;
    this._pointPrimitivesRemoved = true;
    this._createVertexArray = true;
    pointPrimitive._destroy();
    return true;
  }
  return false;
};
PointPrimitiveCollection.prototype.removeAll = function() {
  destroyPointPrimitives(this._pointPrimitives);
  this._pointPrimitives = [];
  this._pointPrimitivesToUpdate = [];
  this._pointPrimitivesToUpdateIndex = 0;
  this._pointPrimitivesRemoved = false;
  this._createVertexArray = true;
};
function removePointPrimitives(pointPrimitiveCollection) {
  if (pointPrimitiveCollection._pointPrimitivesRemoved) {
    pointPrimitiveCollection._pointPrimitivesRemoved = false;
    const newPointPrimitives = [];
    const pointPrimitives = pointPrimitiveCollection._pointPrimitives;
    const length3 = pointPrimitives.length;
    for (let i2 = 0, j = 0; i2 < length3; ++i2) {
      const pointPrimitive = pointPrimitives[i2];
      if (pointPrimitive) {
        pointPrimitive._index = j++;
        newPointPrimitives.push(pointPrimitive);
      }
    }
    pointPrimitiveCollection._pointPrimitives = newPointPrimitives;
  }
}
PointPrimitiveCollection.prototype._updatePointPrimitive = function(pointPrimitive, propertyChanged) {
  if (!pointPrimitive._dirty) {
    this._pointPrimitivesToUpdate[this._pointPrimitivesToUpdateIndex++] = pointPrimitive;
  }
  ++this._propertiesChanged[propertyChanged];
};
PointPrimitiveCollection.prototype.contains = function(pointPrimitive) {
  return defined_default(pointPrimitive) && pointPrimitive._pointPrimitiveCollection === this;
};
PointPrimitiveCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.");
  }
  removePointPrimitives(this);
  return this._pointPrimitives[index2];
};
PointPrimitiveCollection.prototype.computeNewBuffersUsage = function() {
  const buffersUsage = this._buffersUsage;
  let usageChanged = false;
  const properties = this._propertiesChanged;
  for (let k = 0; k < NUMBER_OF_PROPERTIES4; ++k) {
    const newUsage = properties[k] === 0 ? BufferUsage_default.STATIC_DRAW : BufferUsage_default.STREAM_DRAW;
    usageChanged = usageChanged || buffersUsage[k] !== newUsage;
    buffersUsage[k] = newUsage;
  }
  return usageChanged;
};
function createVAF2(context, numberOfPointPrimitives, buffersUsage) {
  return new VertexArrayFacade_default(
    context,
    [
      {
        index: attributeLocations5.positionHighAndSize,
        componentsPerAttribute: 4,
        componentDatatype: ComponentDatatype_default.FLOAT,
        usage: buffersUsage[POSITION_INDEX6]
      },
      {
        index: attributeLocations5.positionLowAndShow,
        componentsPerAttribute: 4,
        componentDatatype: ComponentDatatype_default.FLOAT,
        usage: buffersUsage[POSITION_INDEX6]
      },
      {
        index: attributeLocations5.compressedAttribute0,
        componentsPerAttribute: 4,
        componentDatatype: ComponentDatatype_default.FLOAT,
        usage: buffersUsage[COLOR_INDEX4]
      },
      {
        index: attributeLocations5.compressedAttribute1,
        componentsPerAttribute: 4,
        componentDatatype: ComponentDatatype_default.FLOAT,
        usage: buffersUsage[TRANSLUCENCY_BY_DISTANCE_INDEX4]
      },
      {
        index: attributeLocations5.scaleByDistance,
        componentsPerAttribute: 4,
        componentDatatype: ComponentDatatype_default.FLOAT,
        usage: buffersUsage[SCALE_BY_DISTANCE_INDEX4]
      },
      {
        index: attributeLocations5.distanceDisplayConditionAndDisableDepth,
        componentsPerAttribute: 3,
        componentDatatype: ComponentDatatype_default.FLOAT,
        usage: buffersUsage[DISTANCE_DISPLAY_CONDITION_INDEX3]
      }
    ],
    numberOfPointPrimitives
  );
}
var writePositionScratch2 = new EncodedCartesian3_default();
function writePositionSizeAndOutline(pointPrimitiveCollection, context, vafWriters, pointPrimitive) {
  const i2 = pointPrimitive._index;
  const position = pointPrimitive._getActualPosition();
  if (pointPrimitiveCollection._mode === SceneMode_default.SCENE3D) {
    BoundingSphere_default.expand(
      pointPrimitiveCollection._baseVolume,
      position,
      pointPrimitiveCollection._baseVolume
    );
    pointPrimitiveCollection._boundingVolumeDirty = true;
  }
  EncodedCartesian3_default.fromCartesian(position, writePositionScratch2);
  const pixelSize = pointPrimitive.pixelSize;
  const outlineWidth = pointPrimitive.outlineWidth;
  pointPrimitiveCollection._maxPixelSize = Math.max(
    pointPrimitiveCollection._maxPixelSize,
    pixelSize + outlineWidth
  );
  const positionHighWriter = vafWriters[attributeLocations5.positionHighAndSize];
  const high = writePositionScratch2.high;
  positionHighWriter(i2, high.x, high.y, high.z, pixelSize);
  const positionLowWriter = vafWriters[attributeLocations5.positionLowAndOutline];
  const low = writePositionScratch2.low;
  positionLowWriter(i2, low.x, low.y, low.z, outlineWidth);
}
var LEFT_SHIFT162 = 65536;
var LEFT_SHIFT82 = 256;
function writeCompressedAttrib02(pointPrimitiveCollection, context, vafWriters, pointPrimitive) {
  const i2 = pointPrimitive._index;
  const color = pointPrimitive.color;
  const pickColor = pointPrimitive.getPickId(context).color;
  const outlineColor = pointPrimitive.outlineColor;
  let red = Color_default.floatToByte(color.red);
  let green = Color_default.floatToByte(color.green);
  let blue = Color_default.floatToByte(color.blue);
  const compressed0 = red * LEFT_SHIFT162 + green * LEFT_SHIFT82 + blue;
  red = Color_default.floatToByte(outlineColor.red);
  green = Color_default.floatToByte(outlineColor.green);
  blue = Color_default.floatToByte(outlineColor.blue);
  const compressed1 = red * LEFT_SHIFT162 + green * LEFT_SHIFT82 + blue;
  red = Color_default.floatToByte(pickColor.red);
  green = Color_default.floatToByte(pickColor.green);
  blue = Color_default.floatToByte(pickColor.blue);
  const compressed2 = red * LEFT_SHIFT162 + green * LEFT_SHIFT82 + blue;
  const compressed3 = Color_default.floatToByte(color.alpha) * LEFT_SHIFT162 + Color_default.floatToByte(outlineColor.alpha) * LEFT_SHIFT82 + Color_default.floatToByte(pickColor.alpha);
  const writer = vafWriters[attributeLocations5.compressedAttribute0];
  writer(i2, compressed0, compressed1, compressed2, compressed3);
}
function writeCompressedAttrib12(pointPrimitiveCollection, context, vafWriters, pointPrimitive) {
  const i2 = pointPrimitive._index;
  let near = 0;
  let nearValue = 1;
  let far = 1;
  let farValue = 1;
  const translucency = pointPrimitive.translucencyByDistance;
  if (defined_default(translucency)) {
    near = translucency.near;
    nearValue = translucency.nearValue;
    far = translucency.far;
    farValue = translucency.farValue;
    if (nearValue !== 1 || farValue !== 1) {
      pointPrimitiveCollection._shaderTranslucencyByDistance = true;
    }
  }
  let show = pointPrimitive.show && pointPrimitive.clusterShow;
  if (pointPrimitive.color.alpha === 0 && pointPrimitive.outlineColor.alpha === 0) {
    show = false;
  }
  nearValue = Math_default.clamp(nearValue, 0, 1);
  nearValue = nearValue === 1 ? 255 : nearValue * 255 | 0;
  const compressed0 = (show ? 1 : 0) * LEFT_SHIFT82 + nearValue;
  farValue = Math_default.clamp(farValue, 0, 1);
  farValue = farValue === 1 ? 255 : farValue * 255 | 0;
  const compressed1 = farValue;
  const writer = vafWriters[attributeLocations5.compressedAttribute1];
  writer(i2, compressed0, compressed1, near, far);
}
function writeScaleByDistance2(pointPrimitiveCollection, context, vafWriters, pointPrimitive) {
  const i2 = pointPrimitive._index;
  const writer = vafWriters[attributeLocations5.scaleByDistance];
  let near = 0;
  let nearValue = 1;
  let far = 1;
  let farValue = 1;
  const scale = pointPrimitive.scaleByDistance;
  if (defined_default(scale)) {
    near = scale.near;
    nearValue = scale.nearValue;
    far = scale.far;
    farValue = scale.farValue;
    if (nearValue !== 1 || farValue !== 1) {
      pointPrimitiveCollection._shaderScaleByDistance = true;
    }
  }
  writer(i2, near, nearValue, far, farValue);
}
function writeDistanceDisplayConditionAndDepthDisable(pointPrimitiveCollection, context, vafWriters, pointPrimitive) {
  const i2 = pointPrimitive._index;
  const writer = vafWriters[attributeLocations5.distanceDisplayConditionAndDisableDepth];
  let near = 0;
  let far = Number.MAX_VALUE;
  const distanceDisplayCondition = pointPrimitive.distanceDisplayCondition;
  if (defined_default(distanceDisplayCondition)) {
    near = distanceDisplayCondition.near;
    far = distanceDisplayCondition.far;
    near *= near;
    far *= far;
    pointPrimitiveCollection._shaderDistanceDisplayCondition = true;
  }
  let disableDepthTestDistance = pointPrimitive.disableDepthTestDistance;
  disableDepthTestDistance *= disableDepthTestDistance;
  if (disableDepthTestDistance > 0) {
    pointPrimitiveCollection._shaderDisableDepthDistance = true;
    if (disableDepthTestDistance === Number.POSITIVE_INFINITY) {
      disableDepthTestDistance = -1;
    }
  }
  writer(i2, near, far, disableDepthTestDistance);
}
function writePointPrimitive(pointPrimitiveCollection, context, vafWriters, pointPrimitive) {
  writePositionSizeAndOutline(
    pointPrimitiveCollection,
    context,
    vafWriters,
    pointPrimitive
  );
  writeCompressedAttrib02(
    pointPrimitiveCollection,
    context,
    vafWriters,
    pointPrimitive
  );
  writeCompressedAttrib12(
    pointPrimitiveCollection,
    context,
    vafWriters,
    pointPrimitive
  );
  writeScaleByDistance2(
    pointPrimitiveCollection,
    context,
    vafWriters,
    pointPrimitive
  );
  writeDistanceDisplayConditionAndDepthDisable(
    pointPrimitiveCollection,
    context,
    vafWriters,
    pointPrimitive
  );
}
function recomputeActualPositions2(pointPrimitiveCollection, pointPrimitives, length3, frameState, modelMatrix, recomputeBoundingVolume) {
  let boundingVolume;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    boundingVolume = pointPrimitiveCollection._baseVolume;
    pointPrimitiveCollection._boundingVolumeDirty = true;
  } else {
    boundingVolume = pointPrimitiveCollection._baseVolume2D;
  }
  const positions = [];
  for (let i2 = 0; i2 < length3; ++i2) {
    const pointPrimitive = pointPrimitives[i2];
    const position = pointPrimitive.position;
    const actualPosition = PointPrimitive_default._computeActualPosition(
      position,
      frameState,
      modelMatrix
    );
    if (defined_default(actualPosition)) {
      pointPrimitive._setActualPosition(actualPosition);
      if (recomputeBoundingVolume) {
        positions.push(actualPosition);
      } else {
        BoundingSphere_default.expand(boundingVolume, actualPosition, boundingVolume);
      }
    }
  }
  if (recomputeBoundingVolume) {
    BoundingSphere_default.fromPoints(positions, boundingVolume);
  }
}
function updateMode3(pointPrimitiveCollection, frameState) {
  const mode2 = frameState.mode;
  const pointPrimitives = pointPrimitiveCollection._pointPrimitives;
  const pointPrimitivesToUpdate = pointPrimitiveCollection._pointPrimitivesToUpdate;
  const modelMatrix = pointPrimitiveCollection._modelMatrix;
  if (pointPrimitiveCollection._createVertexArray || pointPrimitiveCollection._mode !== mode2 || mode2 !== SceneMode_default.SCENE3D && !Matrix4_default.equals(modelMatrix, pointPrimitiveCollection.modelMatrix)) {
    pointPrimitiveCollection._mode = mode2;
    Matrix4_default.clone(pointPrimitiveCollection.modelMatrix, modelMatrix);
    pointPrimitiveCollection._createVertexArray = true;
    if (mode2 === SceneMode_default.SCENE3D || mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.COLUMBUS_VIEW) {
      recomputeActualPositions2(
        pointPrimitiveCollection,
        pointPrimitives,
        pointPrimitives.length,
        frameState,
        modelMatrix,
        true
      );
    }
  } else if (mode2 === SceneMode_default.MORPHING) {
    recomputeActualPositions2(
      pointPrimitiveCollection,
      pointPrimitives,
      pointPrimitives.length,
      frameState,
      modelMatrix,
      true
    );
  } else if (mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.COLUMBUS_VIEW) {
    recomputeActualPositions2(
      pointPrimitiveCollection,
      pointPrimitivesToUpdate,
      pointPrimitiveCollection._pointPrimitivesToUpdateIndex,
      frameState,
      modelMatrix,
      false
    );
  }
}
function updateBoundingVolume2(collection, frameState, boundingVolume) {
  const pixelSize = frameState.camera.getPixelSize(
    boundingVolume,
    frameState.context.drawingBufferWidth,
    frameState.context.drawingBufferHeight
  );
  const size = pixelSize * collection._maxPixelSize;
  boundingVolume.radius += size;
}
var scratchWriterArray2 = [];
PointPrimitiveCollection.prototype.update = function(frameState) {
  removePointPrimitives(this);
  if (!this.show) {
    return;
  }
  this._maxTotalPointSize = ContextLimits_default.maximumAliasedPointSize;
  updateMode3(this, frameState);
  const pointPrimitives = this._pointPrimitives;
  const pointPrimitivesLength = pointPrimitives.length;
  const pointPrimitivesToUpdate = this._pointPrimitivesToUpdate;
  const pointPrimitivesToUpdateLength = this._pointPrimitivesToUpdateIndex;
  const properties = this._propertiesChanged;
  const createVertexArray8 = this._createVertexArray;
  let vafWriters;
  const context = frameState.context;
  const pass = frameState.passes;
  const picking = pass.pick;
  if (createVertexArray8 || !picking && this.computeNewBuffersUsage()) {
    this._createVertexArray = false;
    for (let k = 0; k < NUMBER_OF_PROPERTIES4; ++k) {
      properties[k] = 0;
    }
    this._vaf = this._vaf && this._vaf.destroy();
    if (pointPrimitivesLength > 0) {
      this._vaf = createVAF2(context, pointPrimitivesLength, this._buffersUsage);
      vafWriters = this._vaf.writers;
      for (let i2 = 0; i2 < pointPrimitivesLength; ++i2) {
        const pointPrimitive = this._pointPrimitives[i2];
        pointPrimitive._dirty = false;
        writePointPrimitive(this, context, vafWriters, pointPrimitive);
      }
      this._vaf.commit();
    }
    this._pointPrimitivesToUpdateIndex = 0;
  } else if (pointPrimitivesToUpdateLength > 0) {
    const writers = scratchWriterArray2;
    writers.length = 0;
    if (properties[POSITION_INDEX6] || properties[OUTLINE_WIDTH_INDEX2] || properties[PIXEL_SIZE_INDEX2]) {
      writers.push(writePositionSizeAndOutline);
    }
    if (properties[COLOR_INDEX4] || properties[OUTLINE_COLOR_INDEX2]) {
      writers.push(writeCompressedAttrib02);
    }
    if (properties[SHOW_INDEX6] || properties[TRANSLUCENCY_BY_DISTANCE_INDEX4]) {
      writers.push(writeCompressedAttrib12);
    }
    if (properties[SCALE_BY_DISTANCE_INDEX4]) {
      writers.push(writeScaleByDistance2);
    }
    if (properties[DISTANCE_DISPLAY_CONDITION_INDEX3] || properties[DISABLE_DEPTH_DISTANCE_INDEX2]) {
      writers.push(writeDistanceDisplayConditionAndDepthDisable);
    }
    const numWriters = writers.length;
    vafWriters = this._vaf.writers;
    if (pointPrimitivesToUpdateLength / pointPrimitivesLength > 0.1) {
      for (let m = 0; m < pointPrimitivesToUpdateLength; ++m) {
        const b = pointPrimitivesToUpdate[m];
        b._dirty = false;
        for (let n2 = 0; n2 < numWriters; ++n2) {
          writers[n2](this, context, vafWriters, b);
        }
      }
      this._vaf.commit();
    } else {
      for (let h = 0; h < pointPrimitivesToUpdateLength; ++h) {
        const bb = pointPrimitivesToUpdate[h];
        bb._dirty = false;
        for (let o2 = 0; o2 < numWriters; ++o2) {
          writers[o2](this, context, vafWriters, bb);
        }
        this._vaf.subCommit(bb._index, 1);
      }
      this._vaf.endSubCommits();
    }
    this._pointPrimitivesToUpdateIndex = 0;
  }
  if (pointPrimitivesToUpdateLength > pointPrimitivesLength * 1.5) {
    pointPrimitivesToUpdate.length = pointPrimitivesLength;
  }
  if (!defined_default(this._vaf) || !defined_default(this._vaf.va)) {
    return;
  }
  if (this._boundingVolumeDirty) {
    this._boundingVolumeDirty = false;
    BoundingSphere_default.transform(
      this._baseVolume,
      this.modelMatrix,
      this._baseVolumeWC
    );
  }
  let boundingVolume;
  let modelMatrix = Matrix4_default.IDENTITY;
  if (frameState.mode === SceneMode_default.SCENE3D) {
    modelMatrix = this.modelMatrix;
    boundingVolume = BoundingSphere_default.clone(
      this._baseVolumeWC,
      this._boundingVolume
    );
  } else {
    boundingVolume = BoundingSphere_default.clone(
      this._baseVolume2D,
      this._boundingVolume
    );
  }
  updateBoundingVolume2(this, frameState, boundingVolume);
  const blendOptionChanged = this._blendOption !== this.blendOption;
  this._blendOption = this.blendOption;
  if (blendOptionChanged) {
    if (this._blendOption === BlendOption_default.OPAQUE || this._blendOption === BlendOption_default.OPAQUE_AND_TRANSLUCENT) {
      this._rsOpaque = RenderState_default.fromCache({
        depthTest: {
          enabled: true,
          func: WebGLConstants_default.LEQUAL
        },
        depthMask: true
      });
    } else {
      this._rsOpaque = void 0;
    }
    if (this._blendOption === BlendOption_default.TRANSLUCENT || this._blendOption === BlendOption_default.OPAQUE_AND_TRANSLUCENT) {
      this._rsTranslucent = RenderState_default.fromCache({
        depthTest: {
          enabled: true,
          func: WebGLConstants_default.LEQUAL
        },
        depthMask: false,
        blending: BlendingState_default.ALPHA_BLEND
      });
    } else {
      this._rsTranslucent = void 0;
    }
  }
  this._shaderDisableDepthDistance = this._shaderDisableDepthDistance || frameState.minimumDisableDepthTestDistance !== 0;
  let vs;
  let fs;
  if (blendOptionChanged || this._shaderScaleByDistance && !this._compiledShaderScaleByDistance || this._shaderTranslucencyByDistance && !this._compiledShaderTranslucencyByDistance || this._shaderDistanceDisplayCondition && !this._compiledShaderDistanceDisplayCondition || this._shaderDisableDepthDistance !== this._compiledShaderDisableDepthDistance) {
    vs = new ShaderSource_default({
      sources: [PointPrimitiveCollectionVS_default]
    });
    if (this._shaderScaleByDistance) {
      vs.defines.push("EYE_DISTANCE_SCALING");
    }
    if (this._shaderTranslucencyByDistance) {
      vs.defines.push("EYE_DISTANCE_TRANSLUCENCY");
    }
    if (this._shaderDistanceDisplayCondition) {
      vs.defines.push("DISTANCE_DISPLAY_CONDITION");
    }
    if (this._shaderDisableDepthDistance) {
      vs.defines.push("DISABLE_DEPTH_DISTANCE");
    }
    if (this._blendOption === BlendOption_default.OPAQUE_AND_TRANSLUCENT) {
      fs = new ShaderSource_default({
        defines: ["OPAQUE"],
        sources: [PointPrimitiveCollectionFS_default]
      });
      this._sp = ShaderProgram_default.replaceCache({
        context,
        shaderProgram: this._sp,
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations5
      });
      fs = new ShaderSource_default({
        defines: ["TRANSLUCENT"],
        sources: [PointPrimitiveCollectionFS_default]
      });
      this._spTranslucent = ShaderProgram_default.replaceCache({
        context,
        shaderProgram: this._spTranslucent,
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations5
      });
    }
    if (this._blendOption === BlendOption_default.OPAQUE) {
      fs = new ShaderSource_default({
        sources: [PointPrimitiveCollectionFS_default]
      });
      this._sp = ShaderProgram_default.replaceCache({
        context,
        shaderProgram: this._sp,
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations5
      });
    }
    if (this._blendOption === BlendOption_default.TRANSLUCENT) {
      fs = new ShaderSource_default({
        sources: [PointPrimitiveCollectionFS_default]
      });
      this._spTranslucent = ShaderProgram_default.replaceCache({
        context,
        shaderProgram: this._spTranslucent,
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations5
      });
    }
    this._compiledShaderScaleByDistance = this._shaderScaleByDistance;
    this._compiledShaderTranslucencyByDistance = this._shaderTranslucencyByDistance;
    this._compiledShaderDistanceDisplayCondition = this._shaderDistanceDisplayCondition;
    this._compiledShaderDisableDepthDistance = this._shaderDisableDepthDistance;
  }
  let va;
  let vaLength;
  let command;
  let j;
  const commandList = frameState.commandList;
  if (pass.render || picking) {
    const colorList = this._colorCommands;
    const opaque = this._blendOption === BlendOption_default.OPAQUE;
    const opaqueAndTranslucent = this._blendOption === BlendOption_default.OPAQUE_AND_TRANSLUCENT;
    va = this._vaf.va;
    vaLength = va.length;
    colorList.length = vaLength;
    const totalLength = opaqueAndTranslucent ? vaLength * 2 : vaLength;
    for (j = 0; j < totalLength; ++j) {
      const opaqueCommand = opaque || opaqueAndTranslucent && j % 2 === 0;
      command = colorList[j];
      if (!defined_default(command)) {
        command = colorList[j] = new DrawCommand_default();
      }
      command.primitiveType = PrimitiveType_default.POINTS;
      command.pass = opaqueCommand || !opaqueAndTranslucent ? Pass_default.OPAQUE : Pass_default.TRANSLUCENT;
      command.owner = this;
      const index2 = opaqueAndTranslucent ? Math.floor(j / 2) : j;
      command.boundingVolume = boundingVolume;
      command.modelMatrix = modelMatrix;
      command.shaderProgram = opaqueCommand ? this._sp : this._spTranslucent;
      command.uniformMap = this._uniforms;
      command.vertexArray = va[index2].va;
      command.renderState = opaqueCommand ? this._rsOpaque : this._rsTranslucent;
      command.debugShowBoundingVolume = this.debugShowBoundingVolume;
      command.pickId = "v_pickColor";
      commandList.push(command);
    }
  }
};
PointPrimitiveCollection.prototype.isDestroyed = function() {
  return false;
};
PointPrimitiveCollection.prototype.destroy = function() {
  this._sp = this._sp && this._sp.destroy();
  this._spTranslucent = this._spTranslucent && this._spTranslucent.destroy();
  this._spPick = this._spPick && this._spPick.destroy();
  this._vaf = this._vaf && this._vaf.destroy();
  destroyPointPrimitives(this._pointPrimitives);
  return destroyObject_default(this);
};
var PointPrimitiveCollection_default = PointPrimitiveCollection;

// node_modules/cesium/Source/ThirdParty/kdbush.js
function sortKD(ids, coords, nodeSize, left, right, depth) {
  if (right - left <= nodeSize)
    return;
  const m = left + right >> 1;
  select(ids, coords, m, left, right, depth % 2);
  sortKD(ids, coords, nodeSize, left, m - 1, depth + 1);
  sortKD(ids, coords, nodeSize, m + 1, right, depth + 1);
}
function select(ids, coords, k, left, right, inc) {
  while (right > left) {
    if (right - left > 600) {
      const n2 = right - left + 1;
      const m = k - left + 1;
      const z = Math.log(n2);
      const s2 = 0.5 * Math.exp(2 * z / 3);
      const sd = 0.5 * Math.sqrt(z * s2 * (n2 - s2) / n2) * (m - n2 / 2 < 0 ? -1 : 1);
      const newLeft = Math.max(left, Math.floor(k - m * s2 / n2 + sd));
      const newRight = Math.min(right, Math.floor(k + (n2 - m) * s2 / n2 + sd));
      select(ids, coords, k, newLeft, newRight, inc);
    }
    const t = coords[2 * k + inc];
    let i2 = left;
    let j = right;
    swapItem(ids, coords, left, k);
    if (coords[2 * right + inc] > t)
      swapItem(ids, coords, left, right);
    while (i2 < j) {
      swapItem(ids, coords, i2, j);
      i2++;
      j--;
      while (coords[2 * i2 + inc] < t)
        i2++;
      while (coords[2 * j + inc] > t)
        j--;
    }
    if (coords[2 * left + inc] === t)
      swapItem(ids, coords, left, j);
    else {
      j++;
      swapItem(ids, coords, j, right);
    }
    if (j <= k)
      left = j + 1;
    if (k <= j)
      right = j - 1;
  }
}
function swapItem(ids, coords, i2, j) {
  swap4(ids, i2, j);
  swap4(coords, 2 * i2, 2 * j);
  swap4(coords, 2 * i2 + 1, 2 * j + 1);
}
function swap4(arr, i2, j) {
  const tmp2 = arr[i2];
  arr[i2] = arr[j];
  arr[j] = tmp2;
}
function range(ids, coords, minX, minY, maxX, maxY, nodeSize) {
  const stack = [0, ids.length - 1, 0];
  const result = [];
  let x, y;
  while (stack.length) {
    const axis = stack.pop();
    const right = stack.pop();
    const left = stack.pop();
    if (right - left <= nodeSize) {
      for (let i2 = left; i2 <= right; i2++) {
        x = coords[2 * i2];
        y = coords[2 * i2 + 1];
        if (x >= minX && x <= maxX && y >= minY && y <= maxY)
          result.push(ids[i2]);
      }
      continue;
    }
    const m = Math.floor((left + right) / 2);
    x = coords[2 * m];
    y = coords[2 * m + 1];
    if (x >= minX && x <= maxX && y >= minY && y <= maxY)
      result.push(ids[m]);
    const nextAxis = (axis + 1) % 2;
    if (axis === 0 ? minX <= x : minY <= y) {
      stack.push(left);
      stack.push(m - 1);
      stack.push(nextAxis);
    }
    if (axis === 0 ? maxX >= x : maxY >= y) {
      stack.push(m + 1);
      stack.push(right);
      stack.push(nextAxis);
    }
  }
  return result;
}
function within(ids, coords, qx, qy, r2, nodeSize) {
  const stack = [0, ids.length - 1, 0];
  const result = [];
  const r22 = r2 * r2;
  while (stack.length) {
    const axis = stack.pop();
    const right = stack.pop();
    const left = stack.pop();
    if (right - left <= nodeSize) {
      for (let i2 = left; i2 <= right; i2++) {
        if (sqDist(coords[2 * i2], coords[2 * i2 + 1], qx, qy) <= r22)
          result.push(ids[i2]);
      }
      continue;
    }
    const m = Math.floor((left + right) / 2);
    const x = coords[2 * m];
    const y = coords[2 * m + 1];
    if (sqDist(x, y, qx, qy) <= r22)
      result.push(ids[m]);
    const nextAxis = (axis + 1) % 2;
    if (axis === 0 ? qx - r2 <= x : qy - r2 <= y) {
      stack.push(left);
      stack.push(m - 1);
      stack.push(nextAxis);
    }
    if (axis === 0 ? qx + r2 >= x : qy + r2 >= y) {
      stack.push(m + 1);
      stack.push(right);
      stack.push(nextAxis);
    }
  }
  return result;
}
function sqDist(ax, ay, bx, by) {
  const dx = ax - bx;
  const dy = ay - by;
  return dx * dx + dy * dy;
}
var defaultGetX = (p2) => p2[0];
var defaultGetY = (p2) => p2[1];
var KDBush = class {
  constructor(points, getX2 = defaultGetX, getY2 = defaultGetY, nodeSize = 64, ArrayType = Float64Array) {
    this.nodeSize = nodeSize;
    this.points = points;
    const IndexArrayType = points.length < 65536 ? Uint16Array : Uint32Array;
    const ids = this.ids = new IndexArrayType(points.length);
    const coords = this.coords = new ArrayType(points.length * 2);
    for (let i2 = 0; i2 < points.length; i2++) {
      ids[i2] = i2;
      coords[2 * i2] = getX2(points[i2]);
      coords[2 * i2 + 1] = getY2(points[i2]);
    }
    sortKD(ids, coords, nodeSize, 0, ids.length - 1, 0);
  }
  range(minX, minY, maxX, maxY) {
    return range(this.ids, this.coords, minX, minY, maxX, maxY, this.nodeSize);
  }
  within(x, y, r2) {
    return within(this.ids, this.coords, x, y, r2, this.nodeSize);
  }
};

// node_modules/cesium/Source/DataSources/EntityCluster.js
function EntityCluster(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._enabled = defaultValue_default(options.enabled, false);
  this._pixelRange = defaultValue_default(options.pixelRange, 80);
  this._minimumClusterSize = defaultValue_default(options.minimumClusterSize, 2);
  this._clusterBillboards = defaultValue_default(options.clusterBillboards, true);
  this._clusterLabels = defaultValue_default(options.clusterLabels, true);
  this._clusterPoints = defaultValue_default(options.clusterPoints, true);
  this._labelCollection = void 0;
  this._billboardCollection = void 0;
  this._pointCollection = void 0;
  this._clusterBillboardCollection = void 0;
  this._clusterLabelCollection = void 0;
  this._clusterPointCollection = void 0;
  this._collectionIndicesByEntity = {};
  this._unusedLabelIndices = [];
  this._unusedBillboardIndices = [];
  this._unusedPointIndices = [];
  this._previousClusters = [];
  this._previousHeight = void 0;
  this._enabledDirty = false;
  this._clusterDirty = false;
  this._cluster = void 0;
  this._removeEventListener = void 0;
  this._clusterEvent = new Event_default();
  this.show = defaultValue_default(options.show, true);
}
function getX(point) {
  return point.coord.x;
}
function getY(point) {
  return point.coord.y;
}
function expandBoundingBox(bbox2, pixelRange) {
  bbox2.x -= pixelRange;
  bbox2.y -= pixelRange;
  bbox2.width += pixelRange * 2;
  bbox2.height += pixelRange * 2;
}
var labelBoundingBoxScratch = new BoundingRectangle_default();
function getBoundingBox(item, coord, pixelRange, entityCluster, result) {
  if (defined_default(item._labelCollection) && entityCluster._clusterLabels) {
    result = Label_default.getScreenSpaceBoundingBox(item, coord, result);
  } else if (defined_default(item._billboardCollection) && entityCluster._clusterBillboards) {
    result = Billboard_default.getScreenSpaceBoundingBox(item, coord, result);
  } else if (defined_default(item._pointPrimitiveCollection) && entityCluster._clusterPoints) {
    result = PointPrimitive_default.getScreenSpaceBoundingBox(item, coord, result);
  }
  expandBoundingBox(result, pixelRange);
  if (entityCluster._clusterLabels && !defined_default(item._labelCollection) && defined_default(item.id) && hasLabelIndex(entityCluster, item.id.id) && defined_default(item.id._label)) {
    const labelIndex = entityCluster._collectionIndicesByEntity[item.id.id].labelIndex;
    const label = entityCluster._labelCollection.get(labelIndex);
    const labelBBox = Label_default.getScreenSpaceBoundingBox(
      label,
      coord,
      labelBoundingBoxScratch
    );
    expandBoundingBox(labelBBox, pixelRange);
    result = BoundingRectangle_default.union(result, labelBBox, result);
  }
  return result;
}
function addNonClusteredItem(item, entityCluster) {
  item.clusterShow = true;
  if (!defined_default(item._labelCollection) && defined_default(item.id) && hasLabelIndex(entityCluster, item.id.id) && defined_default(item.id._label)) {
    const labelIndex = entityCluster._collectionIndicesByEntity[item.id.id].labelIndex;
    const label = entityCluster._labelCollection.get(labelIndex);
    label.clusterShow = true;
  }
}
function addCluster(position, numPoints, ids, entityCluster) {
  const cluster = {
    billboard: entityCluster._clusterBillboardCollection.add(),
    label: entityCluster._clusterLabelCollection.add(),
    point: entityCluster._clusterPointCollection.add()
  };
  cluster.billboard.show = false;
  cluster.point.show = false;
  cluster.label.show = true;
  cluster.label.text = numPoints.toLocaleString();
  cluster.label.id = ids;
  cluster.billboard.position = cluster.label.position = cluster.point.position = position;
  entityCluster._clusterEvent.raiseEvent(ids, cluster);
}
function hasLabelIndex(entityCluster, entityId) {
  return defined_default(entityCluster) && defined_default(entityCluster._collectionIndicesByEntity[entityId]) && defined_default(entityCluster._collectionIndicesByEntity[entityId].labelIndex);
}
function getScreenSpacePositions(collection, points, scene, occluder, entityCluster) {
  if (!defined_default(collection)) {
    return;
  }
  const length3 = collection.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const item = collection.get(i2);
    item.clusterShow = false;
    if (!item.show || entityCluster._scene.mode === SceneMode_default.SCENE3D && !occluder.isPointVisible(item.position)) {
      continue;
    }
    const canClusterLabels = entityCluster._clusterLabels && defined_default(item._labelCollection);
    const canClusterBillboards = entityCluster._clusterBillboards && defined_default(item.id._billboard);
    const canClusterPoints = entityCluster._clusterPoints && defined_default(item.id._point);
    if (canClusterLabels && (canClusterPoints || canClusterBillboards)) {
      continue;
    }
    const coord = item.computeScreenSpacePosition(scene);
    if (!defined_default(coord)) {
      continue;
    }
    points.push({
      index: i2,
      collection,
      clustered: false,
      coord
    });
  }
}
var pointBoundinRectangleScratch = new BoundingRectangle_default();
var totalBoundingRectangleScratch = new BoundingRectangle_default();
var neighborBoundingRectangleScratch = new BoundingRectangle_default();
function createDeclutterCallback(entityCluster) {
  return function(amount) {
    if (defined_default(amount) && amount < 0.05 || !entityCluster.enabled) {
      return;
    }
    const scene = entityCluster._scene;
    const labelCollection = entityCluster._labelCollection;
    const billboardCollection = entityCluster._billboardCollection;
    const pointCollection = entityCluster._pointCollection;
    if (!defined_default(labelCollection) && !defined_default(billboardCollection) && !defined_default(pointCollection) || !entityCluster._clusterBillboards && !entityCluster._clusterLabels && !entityCluster._clusterPoints) {
      return;
    }
    let clusteredLabelCollection = entityCluster._clusterLabelCollection;
    let clusteredBillboardCollection = entityCluster._clusterBillboardCollection;
    let clusteredPointCollection = entityCluster._clusterPointCollection;
    if (defined_default(clusteredLabelCollection)) {
      clusteredLabelCollection.removeAll();
    } else {
      clusteredLabelCollection = entityCluster._clusterLabelCollection = new LabelCollection_default(
        {
          scene
        }
      );
    }
    if (defined_default(clusteredBillboardCollection)) {
      clusteredBillboardCollection.removeAll();
    } else {
      clusteredBillboardCollection = entityCluster._clusterBillboardCollection = new BillboardCollection_default(
        {
          scene
        }
      );
    }
    if (defined_default(clusteredPointCollection)) {
      clusteredPointCollection.removeAll();
    } else {
      clusteredPointCollection = entityCluster._clusterPointCollection = new PointPrimitiveCollection_default();
    }
    const pixelRange = entityCluster._pixelRange;
    const minimumClusterSize = entityCluster._minimumClusterSize;
    const clusters = entityCluster._previousClusters;
    const newClusters = [];
    const previousHeight = entityCluster._previousHeight;
    const currentHeight = scene.camera.positionCartographic.height;
    const ellipsoid = scene.mapProjection.ellipsoid;
    const cameraPosition = scene.camera.positionWC;
    const occluder = new EllipsoidalOccluder_default(ellipsoid, cameraPosition);
    const points = [];
    if (entityCluster._clusterLabels) {
      getScreenSpacePositions(
        labelCollection,
        points,
        scene,
        occluder,
        entityCluster
      );
    }
    if (entityCluster._clusterBillboards) {
      getScreenSpacePositions(
        billboardCollection,
        points,
        scene,
        occluder,
        entityCluster
      );
    }
    if (entityCluster._clusterPoints) {
      getScreenSpacePositions(
        pointCollection,
        points,
        scene,
        occluder,
        entityCluster
      );
    }
    let i2;
    let j;
    let length3;
    let bbox2;
    let neighbors2;
    let neighborLength;
    let neighborIndex;
    let neighborPoint;
    let ids;
    let numPoints;
    let collection;
    let collectionIndex;
    const index2 = new KDBush(points, getX, getY, 64, Int32Array);
    if (currentHeight < previousHeight) {
      length3 = clusters.length;
      for (i2 = 0; i2 < length3; ++i2) {
        const cluster = clusters[i2];
        if (!occluder.isPointVisible(cluster.position)) {
          continue;
        }
        const coord = Billboard_default._computeScreenSpacePosition(
          Matrix4_default.IDENTITY,
          cluster.position,
          Cartesian3_default.ZERO,
          Cartesian2_default.ZERO,
          scene
        );
        if (!defined_default(coord)) {
          continue;
        }
        const factor2 = 1 - currentHeight / previousHeight;
        let width = cluster.width = cluster.width * factor2;
        let height = cluster.height = cluster.height * factor2;
        width = Math.max(width, cluster.minimumWidth);
        height = Math.max(height, cluster.minimumHeight);
        const minX = coord.x - width * 0.5;
        const minY = coord.y - height * 0.5;
        const maxX = coord.x + width;
        const maxY = coord.y + height;
        neighbors2 = index2.range(minX, minY, maxX, maxY);
        neighborLength = neighbors2.length;
        numPoints = 0;
        ids = [];
        for (j = 0; j < neighborLength; ++j) {
          neighborIndex = neighbors2[j];
          neighborPoint = points[neighborIndex];
          if (!neighborPoint.clustered) {
            ++numPoints;
            collection = neighborPoint.collection;
            collectionIndex = neighborPoint.index;
            ids.push(collection.get(collectionIndex).id);
          }
        }
        if (numPoints >= minimumClusterSize) {
          addCluster(cluster.position, numPoints, ids, entityCluster);
          newClusters.push(cluster);
          for (j = 0; j < neighborLength; ++j) {
            points[neighbors2[j]].clustered = true;
          }
        }
      }
    }
    length3 = points.length;
    for (i2 = 0; i2 < length3; ++i2) {
      const point = points[i2];
      if (point.clustered) {
        continue;
      }
      point.clustered = true;
      collection = point.collection;
      collectionIndex = point.index;
      const item = collection.get(collectionIndex);
      bbox2 = getBoundingBox(
        item,
        point.coord,
        pixelRange,
        entityCluster,
        pointBoundinRectangleScratch
      );
      const totalBBox = BoundingRectangle_default.clone(
        bbox2,
        totalBoundingRectangleScratch
      );
      neighbors2 = index2.range(
        bbox2.x,
        bbox2.y,
        bbox2.x + bbox2.width,
        bbox2.y + bbox2.height
      );
      neighborLength = neighbors2.length;
      const clusterPosition = Cartesian3_default.clone(item.position);
      numPoints = 1;
      ids = [item.id];
      for (j = 0; j < neighborLength; ++j) {
        neighborIndex = neighbors2[j];
        neighborPoint = points[neighborIndex];
        if (!neighborPoint.clustered) {
          const neighborItem = neighborPoint.collection.get(
            neighborPoint.index
          );
          const neighborBBox = getBoundingBox(
            neighborItem,
            neighborPoint.coord,
            pixelRange,
            entityCluster,
            neighborBoundingRectangleScratch
          );
          Cartesian3_default.add(
            neighborItem.position,
            clusterPosition,
            clusterPosition
          );
          BoundingRectangle_default.union(totalBBox, neighborBBox, totalBBox);
          ++numPoints;
          ids.push(neighborItem.id);
        }
      }
      if (numPoints >= minimumClusterSize) {
        const position = Cartesian3_default.multiplyByScalar(
          clusterPosition,
          1 / numPoints,
          clusterPosition
        );
        addCluster(position, numPoints, ids, entityCluster);
        newClusters.push({
          position,
          width: totalBBox.width,
          height: totalBBox.height,
          minimumWidth: bbox2.width,
          minimumHeight: bbox2.height
        });
        for (j = 0; j < neighborLength; ++j) {
          points[neighbors2[j]].clustered = true;
        }
      } else {
        addNonClusteredItem(item, entityCluster);
      }
    }
    if (clusteredLabelCollection.length === 0) {
      clusteredLabelCollection.destroy();
      entityCluster._clusterLabelCollection = void 0;
    }
    if (clusteredBillboardCollection.length === 0) {
      clusteredBillboardCollection.destroy();
      entityCluster._clusterBillboardCollection = void 0;
    }
    if (clusteredPointCollection.length === 0) {
      clusteredPointCollection.destroy();
      entityCluster._clusterPointCollection = void 0;
    }
    entityCluster._previousClusters = newClusters;
    entityCluster._previousHeight = currentHeight;
  };
}
EntityCluster.prototype._initialize = function(scene) {
  this._scene = scene;
  const cluster = createDeclutterCallback(this);
  this._cluster = cluster;
  this._removeEventListener = scene.camera.changed.addEventListener(cluster);
};
Object.defineProperties(EntityCluster.prototype, {
  enabled: {
    get: function() {
      return this._enabled;
    },
    set: function(value) {
      this._enabledDirty = value !== this._enabled;
      this._enabled = value;
    }
  },
  pixelRange: {
    get: function() {
      return this._pixelRange;
    },
    set: function(value) {
      this._clusterDirty = this._clusterDirty || value !== this._pixelRange;
      this._pixelRange = value;
    }
  },
  minimumClusterSize: {
    get: function() {
      return this._minimumClusterSize;
    },
    set: function(value) {
      this._clusterDirty = this._clusterDirty || value !== this._minimumClusterSize;
      this._minimumClusterSize = value;
    }
  },
  clusterEvent: {
    get: function() {
      return this._clusterEvent;
    }
  },
  clusterBillboards: {
    get: function() {
      return this._clusterBillboards;
    },
    set: function(value) {
      this._clusterDirty = this._clusterDirty || value !== this._clusterBillboards;
      this._clusterBillboards = value;
    }
  },
  clusterLabels: {
    get: function() {
      return this._clusterLabels;
    },
    set: function(value) {
      this._clusterDirty = this._clusterDirty || value !== this._clusterLabels;
      this._clusterLabels = value;
    }
  },
  clusterPoints: {
    get: function() {
      return this._clusterPoints;
    },
    set: function(value) {
      this._clusterDirty = this._clusterDirty || value !== this._clusterPoints;
      this._clusterPoints = value;
    }
  }
});
function createGetEntity(collectionProperty, CollectionConstructor, unusedIndicesProperty, entityIndexProperty) {
  return function(entity) {
    let collection = this[collectionProperty];
    if (!defined_default(this._collectionIndicesByEntity)) {
      this._collectionIndicesByEntity = {};
    }
    let entityIndices = this._collectionIndicesByEntity[entity.id];
    if (!defined_default(entityIndices)) {
      entityIndices = this._collectionIndicesByEntity[entity.id] = {
        billboardIndex: void 0,
        labelIndex: void 0,
        pointIndex: void 0
      };
    }
    if (defined_default(collection) && defined_default(entityIndices[entityIndexProperty])) {
      return collection.get(entityIndices[entityIndexProperty]);
    }
    if (!defined_default(collection)) {
      collection = this[collectionProperty] = new CollectionConstructor({
        scene: this._scene
      });
    }
    let index2;
    let entityItem;
    const unusedIndices = this[unusedIndicesProperty];
    if (unusedIndices.length > 0) {
      index2 = unusedIndices.pop();
      entityItem = collection.get(index2);
    } else {
      entityItem = collection.add();
      index2 = collection.length - 1;
    }
    entityIndices[entityIndexProperty] = index2;
    const that = this;
    Promise.resolve().then(function() {
      that._clusterDirty = true;
    });
    return entityItem;
  };
}
function removeEntityIndicesIfUnused(entityCluster, entityId) {
  const indices2 = entityCluster._collectionIndicesByEntity[entityId];
  if (!defined_default(indices2.billboardIndex) && !defined_default(indices2.labelIndex) && !defined_default(indices2.pointIndex)) {
    delete entityCluster._collectionIndicesByEntity[entityId];
  }
}
EntityCluster.prototype.getLabel = createGetEntity(
  "_labelCollection",
  LabelCollection_default,
  "_unusedLabelIndices",
  "labelIndex"
);
EntityCluster.prototype.removeLabel = function(entity) {
  const entityIndices = this._collectionIndicesByEntity && this._collectionIndicesByEntity[entity.id];
  if (!defined_default(this._labelCollection) || !defined_default(entityIndices) || !defined_default(entityIndices.labelIndex)) {
    return;
  }
  const index2 = entityIndices.labelIndex;
  entityIndices.labelIndex = void 0;
  removeEntityIndicesIfUnused(this, entity.id);
  const label = this._labelCollection.get(index2);
  label.show = false;
  label.text = "";
  label.id = void 0;
  this._unusedLabelIndices.push(index2);
  this._clusterDirty = true;
};
EntityCluster.prototype.getBillboard = createGetEntity(
  "_billboardCollection",
  BillboardCollection_default,
  "_unusedBillboardIndices",
  "billboardIndex"
);
EntityCluster.prototype.removeBillboard = function(entity) {
  const entityIndices = this._collectionIndicesByEntity && this._collectionIndicesByEntity[entity.id];
  if (!defined_default(this._billboardCollection) || !defined_default(entityIndices) || !defined_default(entityIndices.billboardIndex)) {
    return;
  }
  const index2 = entityIndices.billboardIndex;
  entityIndices.billboardIndex = void 0;
  removeEntityIndicesIfUnused(this, entity.id);
  const billboard = this._billboardCollection.get(index2);
  billboard.id = void 0;
  billboard.show = false;
  billboard.image = void 0;
  this._unusedBillboardIndices.push(index2);
  this._clusterDirty = true;
};
EntityCluster.prototype.getPoint = createGetEntity(
  "_pointCollection",
  PointPrimitiveCollection_default,
  "_unusedPointIndices",
  "pointIndex"
);
EntityCluster.prototype.removePoint = function(entity) {
  const entityIndices = this._collectionIndicesByEntity && this._collectionIndicesByEntity[entity.id];
  if (!defined_default(this._pointCollection) || !defined_default(entityIndices) || !defined_default(entityIndices.pointIndex)) {
    return;
  }
  const index2 = entityIndices.pointIndex;
  entityIndices.pointIndex = void 0;
  removeEntityIndicesIfUnused(this, entity.id);
  const point = this._pointCollection.get(index2);
  point.show = false;
  point.id = void 0;
  this._unusedPointIndices.push(index2);
  this._clusterDirty = true;
};
function disableCollectionClustering(collection) {
  if (!defined_default(collection)) {
    return;
  }
  const length3 = collection.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    collection.get(i2).clusterShow = true;
  }
}
function updateEnable(entityCluster) {
  if (entityCluster.enabled) {
    return;
  }
  if (defined_default(entityCluster._clusterLabelCollection)) {
    entityCluster._clusterLabelCollection.destroy();
  }
  if (defined_default(entityCluster._clusterBillboardCollection)) {
    entityCluster._clusterBillboardCollection.destroy();
  }
  if (defined_default(entityCluster._clusterPointCollection)) {
    entityCluster._clusterPointCollection.destroy();
  }
  entityCluster._clusterLabelCollection = void 0;
  entityCluster._clusterBillboardCollection = void 0;
  entityCluster._clusterPointCollection = void 0;
  disableCollectionClustering(entityCluster._labelCollection);
  disableCollectionClustering(entityCluster._billboardCollection);
  disableCollectionClustering(entityCluster._pointCollection);
}
EntityCluster.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  let commandList;
  if (defined_default(this._labelCollection) && this._labelCollection.length > 0 && this._labelCollection.get(0)._glyphs.length === 0) {
    commandList = frameState.commandList;
    frameState.commandList = [];
    this._labelCollection.update(frameState);
    frameState.commandList = commandList;
  }
  if (defined_default(this._billboardCollection) && this._billboardCollection.length > 0 && !defined_default(this._billboardCollection.get(0).width)) {
    commandList = frameState.commandList;
    frameState.commandList = [];
    this._billboardCollection.update(frameState);
    frameState.commandList = commandList;
  }
  if (this._enabledDirty) {
    this._enabledDirty = false;
    updateEnable(this);
    this._clusterDirty = true;
  }
  if (this._clusterDirty) {
    this._clusterDirty = false;
    this._cluster();
  }
  if (defined_default(this._clusterLabelCollection)) {
    this._clusterLabelCollection.update(frameState);
  }
  if (defined_default(this._clusterBillboardCollection)) {
    this._clusterBillboardCollection.update(frameState);
  }
  if (defined_default(this._clusterPointCollection)) {
    this._clusterPointCollection.update(frameState);
  }
  if (defined_default(this._labelCollection)) {
    this._labelCollection.update(frameState);
  }
  if (defined_default(this._billboardCollection)) {
    this._billboardCollection.update(frameState);
  }
  if (defined_default(this._pointCollection)) {
    this._pointCollection.update(frameState);
  }
};
EntityCluster.prototype.destroy = function() {
  this._labelCollection = this._labelCollection && this._labelCollection.destroy();
  this._billboardCollection = this._billboardCollection && this._billboardCollection.destroy();
  this._pointCollection = this._pointCollection && this._pointCollection.destroy();
  this._clusterLabelCollection = this._clusterLabelCollection && this._clusterLabelCollection.destroy();
  this._clusterBillboardCollection = this._clusterBillboardCollection && this._clusterBillboardCollection.destroy();
  this._clusterPointCollection = this._clusterPointCollection && this._clusterPointCollection.destroy();
  if (defined_default(this._removeEventListener)) {
    this._removeEventListener();
    this._removeEventListener = void 0;
  }
  this._labelCollection = void 0;
  this._billboardCollection = void 0;
  this._pointCollection = void 0;
  this._clusterBillboardCollection = void 0;
  this._clusterLabelCollection = void 0;
  this._clusterPointCollection = void 0;
  this._collectionIndicesByEntity = void 0;
  this._unusedLabelIndices = [];
  this._unusedBillboardIndices = [];
  this._unusedPointIndices = [];
  this._previousClusters = [];
  this._previousHeight = void 0;
  this._enabledDirty = false;
  this._pixelRangeDirty = false;
  this._minimumClusterSizeDirty = false;
  return void 0;
};
var EntityCluster_default = EntityCluster;

// node_modules/cesium/Source/DataSources/CustomDataSource.js
function CustomDataSource(name) {
  this._name = name;
  this._clock = void 0;
  this._changed = new Event_default();
  this._error = new Event_default();
  this._isLoading = false;
  this._loading = new Event_default();
  this._entityCollection = new EntityCollection_default(this);
  this._entityCluster = new EntityCluster_default();
}
Object.defineProperties(CustomDataSource.prototype, {
  name: {
    get: function() {
      return this._name;
    },
    set: function(value) {
      if (this._name !== value) {
        this._name = value;
        this._changed.raiseEvent(this);
      }
    }
  },
  clock: {
    get: function() {
      return this._clock;
    },
    set: function(value) {
      if (this._clock !== value) {
        this._clock = value;
        this._changed.raiseEvent(this);
      }
    }
  },
  entities: {
    get: function() {
      return this._entityCollection;
    }
  },
  isLoading: {
    get: function() {
      return this._isLoading;
    },
    set: function(value) {
      DataSource_default.setLoading(this, value);
    }
  },
  changedEvent: {
    get: function() {
      return this._changed;
    }
  },
  errorEvent: {
    get: function() {
      return this._error;
    }
  },
  loadingEvent: {
    get: function() {
      return this._loading;
    }
  },
  show: {
    get: function() {
      return this._entityCollection.show;
    },
    set: function(value) {
      this._entityCollection.show = value;
    }
  },
  clustering: {
    get: function() {
      return this._entityCluster;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value must be defined.");
      }
      this._entityCluster = value;
    }
  }
});
CustomDataSource.prototype.update = function(time) {
  return true;
};
var CustomDataSource_default = CustomDataSource;

// node_modules/cesium/Source/DataSources/CylinderGeometryUpdater.js
var defaultOffset3 = Cartesian3_default.ZERO;
var offsetScratch6 = new Cartesian3_default();
var positionScratch9 = new Cartesian3_default();
var scratchColor13 = new Color_default();
function CylinderGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.length = void 0;
  this.topRadius = void 0;
  this.bottomRadius = void 0;
  this.slices = void 0;
  this.numberOfVerticalLines = void 0;
  this.offsetAttribute = void 0;
}
function CylinderGeometryUpdater(entity, scene) {
  GeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new CylinderGeometryOptions(entity),
    geometryPropertyName: "cylinder",
    observedPropertyNames: [
      "availability",
      "position",
      "orientation",
      "cylinder"
    ]
  });
  this._onEntityPropertyChanged(entity, "cylinder", entity.cylinder, void 0);
}
if (defined_default(Object.create)) {
  CylinderGeometryUpdater.prototype = Object.create(GeometryUpdater_default.prototype);
  CylinderGeometryUpdater.prototype.constructor = CylinderGeometryUpdater;
}
Object.defineProperties(CylinderGeometryUpdater.prototype, {
  terrainOffsetProperty: {
    get: function() {
      return this._terrainOffsetProperty;
    }
  }
});
CylinderGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const show = new ShowGeometryInstanceAttribute_default(
    isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
    distanceDisplayCondition
  );
  const attributes = {
    show,
    distanceDisplayCondition: distanceDisplayConditionAttribute,
    color: void 0,
    offset: void 0
  };
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor13);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    attributes.color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
  }
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset3,
        offsetScratch6
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new CylinderGeometry_default(this._options),
    modelMatrix: entity.computeModelMatrixForHeightReference(
      time,
      entity.cylinder.heightReference,
      this._options.length * 0.5,
      this._scene.mapProjection.ellipsoid
    ),
    attributes
  });
};
CylinderGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._outlineEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent an outlined geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor13
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
    ),
    color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      distanceDisplayCondition
    ),
    offset: void 0
  };
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset3,
        offsetScratch6
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new CylinderOutlineGeometry_default(this._options),
    modelMatrix: entity.computeModelMatrixForHeightReference(
      time,
      entity.cylinder.heightReference,
      this._options.length * 0.5,
      this._scene.mapProjection.ellipsoid
    ),
    attributes
  });
};
CylinderGeometryUpdater.prototype._computeCenter = function(time, result) {
  return Property_default.getValueOrUndefined(this._entity.position, time, result);
};
CylinderGeometryUpdater.prototype._isHidden = function(entity, cylinder) {
  return !defined_default(entity.position) || !defined_default(cylinder.length) || !defined_default(cylinder.topRadius) || !defined_default(cylinder.bottomRadius) || GeometryUpdater_default.prototype._isHidden.call(this, entity, cylinder);
};
CylinderGeometryUpdater.prototype._isDynamic = function(entity, cylinder) {
  return !entity.position.isConstant || !Property_default.isConstant(entity.orientation) || !cylinder.length.isConstant || !cylinder.topRadius.isConstant || !cylinder.bottomRadius.isConstant || !Property_default.isConstant(cylinder.slices) || !Property_default.isConstant(cylinder.outlineWidth) || !Property_default.isConstant(cylinder.numberOfVerticalLines);
};
CylinderGeometryUpdater.prototype._setStaticOptions = function(entity, cylinder) {
  const heightReference = Property_default.getValueOrDefault(
    cylinder.heightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  const options = this._options;
  options.vertexFormat = this._materialProperty instanceof ColorMaterialProperty_default ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  options.length = cylinder.length.getValue(Iso8601_default.MINIMUM_VALUE);
  options.topRadius = cylinder.topRadius.getValue(Iso8601_default.MINIMUM_VALUE);
  options.bottomRadius = cylinder.bottomRadius.getValue(Iso8601_default.MINIMUM_VALUE);
  options.slices = Property_default.getValueOrUndefined(
    cylinder.slices,
    Iso8601_default.MINIMUM_VALUE
  );
  options.numberOfVerticalLines = Property_default.getValueOrUndefined(
    cylinder.numberOfVerticalLines,
    Iso8601_default.MINIMUM_VALUE
  );
  options.offsetAttribute = heightReference !== HeightReference_default.NONE ? GeometryOffsetAttribute_default.ALL : void 0;
};
CylinderGeometryUpdater.prototype._onEntityPropertyChanged = heightReferenceOnEntityPropertyChanged_default;
CylinderGeometryUpdater.DynamicGeometryUpdater = DynamicCylinderGeometryUpdater;
function DynamicCylinderGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
}
if (defined_default(Object.create)) {
  DynamicCylinderGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DynamicCylinderGeometryUpdater.prototype.constructor = DynamicCylinderGeometryUpdater;
}
DynamicCylinderGeometryUpdater.prototype._isHidden = function(entity, cylinder, time) {
  const options = this._options;
  const position = Property_default.getValueOrUndefined(
    entity.position,
    time,
    positionScratch9
  );
  return !defined_default(position) || !defined_default(options.length) || !defined_default(options.topRadius) || !defined_default(options.bottomRadius) || DynamicGeometryUpdater_default.prototype._isHidden.call(
    this,
    entity,
    cylinder,
    time
  );
};
DynamicCylinderGeometryUpdater.prototype._setOptions = function(entity, cylinder, time) {
  const heightReference = Property_default.getValueOrDefault(
    cylinder.heightReference,
    time,
    HeightReference_default.NONE
  );
  const options = this._options;
  options.length = Property_default.getValueOrUndefined(cylinder.length, time);
  options.topRadius = Property_default.getValueOrUndefined(cylinder.topRadius, time);
  options.bottomRadius = Property_default.getValueOrUndefined(
    cylinder.bottomRadius,
    time
  );
  options.slices = Property_default.getValueOrUndefined(cylinder.slices, time);
  options.numberOfVerticalLines = Property_default.getValueOrUndefined(
    cylinder.numberOfVerticalLines,
    time
  );
  options.offsetAttribute = heightReference !== HeightReference_default.NONE ? GeometryOffsetAttribute_default.ALL : void 0;
};
var CylinderGeometryUpdater_default = CylinderGeometryUpdater;

// node_modules/cesium/Source/DataSources/DataSourceClock.js
function DataSourceClock() {
  this._definitionChanged = new Event_default();
  this._startTime = void 0;
  this._stopTime = void 0;
  this._currentTime = void 0;
  this._clockRange = void 0;
  this._clockStep = void 0;
  this._multiplier = void 0;
}
Object.defineProperties(DataSourceClock.prototype, {
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  startTime: createRawPropertyDescriptor_default("startTime"),
  stopTime: createRawPropertyDescriptor_default("stopTime"),
  currentTime: createRawPropertyDescriptor_default("currentTime"),
  clockRange: createRawPropertyDescriptor_default("clockRange"),
  clockStep: createRawPropertyDescriptor_default("clockStep"),
  multiplier: createRawPropertyDescriptor_default("multiplier")
});
DataSourceClock.prototype.clone = function(result) {
  if (!defined_default(result)) {
    result = new DataSourceClock();
  }
  result.startTime = this.startTime;
  result.stopTime = this.stopTime;
  result.currentTime = this.currentTime;
  result.clockRange = this.clockRange;
  result.clockStep = this.clockStep;
  result.multiplier = this.multiplier;
  return result;
};
DataSourceClock.prototype.equals = function(other) {
  return this === other || defined_default(other) && JulianDate_default.equals(this.startTime, other.startTime) && JulianDate_default.equals(this.stopTime, other.stopTime) && JulianDate_default.equals(this.currentTime, other.currentTime) && this.clockRange === other.clockRange && this.clockStep === other.clockStep && this.multiplier === other.multiplier;
};
DataSourceClock.prototype.merge = function(source) {
  if (!defined_default(source)) {
    throw new DeveloperError_default("source is required.");
  }
  this.startTime = defaultValue_default(this.startTime, source.startTime);
  this.stopTime = defaultValue_default(this.stopTime, source.stopTime);
  this.currentTime = defaultValue_default(this.currentTime, source.currentTime);
  this.clockRange = defaultValue_default(this.clockRange, source.clockRange);
  this.clockStep = defaultValue_default(this.clockStep, source.clockStep);
  this.multiplier = defaultValue_default(this.multiplier, source.multiplier);
};
DataSourceClock.prototype.getValue = function(result) {
  if (!defined_default(result)) {
    result = new Clock_default();
  }
  result.startTime = defaultValue_default(this.startTime, result.startTime);
  result.stopTime = defaultValue_default(this.stopTime, result.stopTime);
  result.currentTime = defaultValue_default(this.currentTime, result.currentTime);
  result.clockRange = defaultValue_default(this.clockRange, result.clockRange);
  result.multiplier = defaultValue_default(this.multiplier, result.multiplier);
  result.clockStep = defaultValue_default(this.clockStep, result.clockStep);
  return result;
};
var DataSourceClock_default = DataSourceClock;

// node_modules/cesium/Source/DataSources/GridMaterialProperty.js
var defaultColor3 = Color_default.WHITE;
var defaultCellAlpha = 0.1;
var defaultLineCount = new Cartesian2_default(8, 8);
var defaultLineOffset = new Cartesian2_default(0, 0);
var defaultLineThickness = new Cartesian2_default(1, 1);
function GridMaterialProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._definitionChanged = new Event_default();
  this._color = void 0;
  this._colorSubscription = void 0;
  this._cellAlpha = void 0;
  this._cellAlphaSubscription = void 0;
  this._lineCount = void 0;
  this._lineCountSubscription = void 0;
  this._lineThickness = void 0;
  this._lineThicknessSubscription = void 0;
  this._lineOffset = void 0;
  this._lineOffsetSubscription = void 0;
  this.color = options.color;
  this.cellAlpha = options.cellAlpha;
  this.lineCount = options.lineCount;
  this.lineThickness = options.lineThickness;
  this.lineOffset = options.lineOffset;
}
Object.defineProperties(GridMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._color) && Property_default.isConstant(this._cellAlpha) && Property_default.isConstant(this._lineCount) && Property_default.isConstant(this._lineThickness) && Property_default.isConstant(this._lineOffset);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  color: createPropertyDescriptor_default("color"),
  cellAlpha: createPropertyDescriptor_default("cellAlpha"),
  lineCount: createPropertyDescriptor_default("lineCount"),
  lineThickness: createPropertyDescriptor_default("lineThickness"),
  lineOffset: createPropertyDescriptor_default("lineOffset")
});
GridMaterialProperty.prototype.getType = function(time) {
  return "Grid";
};
GridMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = {};
  }
  result.color = Property_default.getValueOrClonedDefault(
    this._color,
    time,
    defaultColor3,
    result.color
  );
  result.cellAlpha = Property_default.getValueOrDefault(
    this._cellAlpha,
    time,
    defaultCellAlpha
  );
  result.lineCount = Property_default.getValueOrClonedDefault(
    this._lineCount,
    time,
    defaultLineCount,
    result.lineCount
  );
  result.lineThickness = Property_default.getValueOrClonedDefault(
    this._lineThickness,
    time,
    defaultLineThickness,
    result.lineThickness
  );
  result.lineOffset = Property_default.getValueOrClonedDefault(
    this._lineOffset,
    time,
    defaultLineOffset,
    result.lineOffset
  );
  return result;
};
GridMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof GridMaterialProperty && Property_default.equals(this._color, other._color) && Property_default.equals(this._cellAlpha, other._cellAlpha) && Property_default.equals(this._lineCount, other._lineCount) && Property_default.equals(this._lineThickness, other._lineThickness) && Property_default.equals(this._lineOffset, other._lineOffset);
};
var GridMaterialProperty_default = GridMaterialProperty;

// node_modules/cesium/Source/DataSources/PolylineArrowMaterialProperty.js
function PolylineArrowMaterialProperty(color) {
  this._definitionChanged = new Event_default();
  this._color = void 0;
  this._colorSubscription = void 0;
  this.color = color;
}
Object.defineProperties(PolylineArrowMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._color);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  color: createPropertyDescriptor_default("color")
});
PolylineArrowMaterialProperty.prototype.getType = function(time) {
  return "PolylineArrow";
};
PolylineArrowMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = {};
  }
  result.color = Property_default.getValueOrClonedDefault(
    this._color,
    time,
    Color_default.WHITE,
    result.color
  );
  return result;
};
PolylineArrowMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof PolylineArrowMaterialProperty && Property_default.equals(this._color, other._color);
};
var PolylineArrowMaterialProperty_default = PolylineArrowMaterialProperty;

// node_modules/cesium/Source/DataSources/PolylineDashMaterialProperty.js
var defaultColor4 = Color_default.WHITE;
var defaultGapColor = Color_default.TRANSPARENT;
var defaultDashLength = 16;
var defaultDashPattern = 255;
function PolylineDashMaterialProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._definitionChanged = new Event_default();
  this._color = void 0;
  this._colorSubscription = void 0;
  this._gapColor = void 0;
  this._gapColorSubscription = void 0;
  this._dashLength = void 0;
  this._dashLengthSubscription = void 0;
  this._dashPattern = void 0;
  this._dashPatternSubscription = void 0;
  this.color = options.color;
  this.gapColor = options.gapColor;
  this.dashLength = options.dashLength;
  this.dashPattern = options.dashPattern;
}
Object.defineProperties(PolylineDashMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._color) && Property_default.isConstant(this._gapColor) && Property_default.isConstant(this._dashLength) && Property_default.isConstant(this._dashPattern);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  color: createPropertyDescriptor_default("color"),
  gapColor: createPropertyDescriptor_default("gapColor"),
  dashLength: createPropertyDescriptor_default("dashLength"),
  dashPattern: createPropertyDescriptor_default("dashPattern")
});
PolylineDashMaterialProperty.prototype.getType = function(time) {
  return "PolylineDash";
};
PolylineDashMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = {};
  }
  result.color = Property_default.getValueOrClonedDefault(
    this._color,
    time,
    defaultColor4,
    result.color
  );
  result.gapColor = Property_default.getValueOrClonedDefault(
    this._gapColor,
    time,
    defaultGapColor,
    result.gapColor
  );
  result.dashLength = Property_default.getValueOrDefault(
    this._dashLength,
    time,
    defaultDashLength,
    result.dashLength
  );
  result.dashPattern = Property_default.getValueOrDefault(
    this._dashPattern,
    time,
    defaultDashPattern,
    result.dashPattern
  );
  return result;
};
PolylineDashMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof PolylineDashMaterialProperty && Property_default.equals(this._color, other._color) && Property_default.equals(this._gapColor, other._gapColor) && Property_default.equals(this._dashLength, other._dashLength) && Property_default.equals(this._dashPattern, other._dashPattern);
};
var PolylineDashMaterialProperty_default = PolylineDashMaterialProperty;

// node_modules/cesium/Source/DataSources/PolylineGlowMaterialProperty.js
var defaultColor5 = Color_default.WHITE;
var defaultGlowPower = 0.25;
var defaultTaperPower = 1;
function PolylineGlowMaterialProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._definitionChanged = new Event_default();
  this._color = void 0;
  this._colorSubscription = void 0;
  this._glowPower = void 0;
  this._glowPowerSubscription = void 0;
  this._taperPower = void 0;
  this._taperPowerSubscription = void 0;
  this.color = options.color;
  this.glowPower = options.glowPower;
  this.taperPower = options.taperPower;
}
Object.defineProperties(PolylineGlowMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._color) && Property_default.isConstant(this._glow);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  color: createPropertyDescriptor_default("color"),
  glowPower: createPropertyDescriptor_default("glowPower"),
  taperPower: createPropertyDescriptor_default("taperPower")
});
PolylineGlowMaterialProperty.prototype.getType = function(time) {
  return "PolylineGlow";
};
PolylineGlowMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = {};
  }
  result.color = Property_default.getValueOrClonedDefault(
    this._color,
    time,
    defaultColor5,
    result.color
  );
  result.glowPower = Property_default.getValueOrDefault(
    this._glowPower,
    time,
    defaultGlowPower,
    result.glowPower
  );
  result.taperPower = Property_default.getValueOrDefault(
    this._taperPower,
    time,
    defaultTaperPower,
    result.taperPower
  );
  return result;
};
PolylineGlowMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof PolylineGlowMaterialProperty && Property_default.equals(this._color, other._color) && Property_default.equals(this._glowPower, other._glowPower) && Property_default.equals(this._taperPower, other._taperPower);
};
var PolylineGlowMaterialProperty_default = PolylineGlowMaterialProperty;

// node_modules/cesium/Source/DataSources/PolylineOutlineMaterialProperty.js
var defaultColor6 = Color_default.WHITE;
var defaultOutlineColor2 = Color_default.BLACK;
var defaultOutlineWidth = 1;
function PolylineOutlineMaterialProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._definitionChanged = new Event_default();
  this._color = void 0;
  this._colorSubscription = void 0;
  this._outlineColor = void 0;
  this._outlineColorSubscription = void 0;
  this._outlineWidth = void 0;
  this._outlineWidthSubscription = void 0;
  this.color = options.color;
  this.outlineColor = options.outlineColor;
  this.outlineWidth = options.outlineWidth;
}
Object.defineProperties(PolylineOutlineMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._color) && Property_default.isConstant(this._outlineColor) && Property_default.isConstant(this._outlineWidth);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  color: createPropertyDescriptor_default("color"),
  outlineColor: createPropertyDescriptor_default("outlineColor"),
  outlineWidth: createPropertyDescriptor_default("outlineWidth")
});
PolylineOutlineMaterialProperty.prototype.getType = function(time) {
  return "PolylineOutline";
};
PolylineOutlineMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = {};
  }
  result.color = Property_default.getValueOrClonedDefault(
    this._color,
    time,
    defaultColor6,
    result.color
  );
  result.outlineColor = Property_default.getValueOrClonedDefault(
    this._outlineColor,
    time,
    defaultOutlineColor2,
    result.outlineColor
  );
  result.outlineWidth = Property_default.getValueOrDefault(
    this._outlineWidth,
    time,
    defaultOutlineWidth
  );
  return result;
};
PolylineOutlineMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof PolylineOutlineMaterialProperty && Property_default.equals(this._color, other._color) && Property_default.equals(this._outlineColor, other._outlineColor) && Property_default.equals(this._outlineWidth, other._outlineWidth);
};
var PolylineOutlineMaterialProperty_default = PolylineOutlineMaterialProperty;

// node_modules/cesium/Source/DataSources/PositionPropertyArray.js
function PositionPropertyArray(value, referenceFrame) {
  this._value = void 0;
  this._definitionChanged = new Event_default();
  this._eventHelper = new EventHelper_default();
  this._referenceFrame = defaultValue_default(referenceFrame, ReferenceFrame_default.FIXED);
  this.setValue(value);
}
Object.defineProperties(PositionPropertyArray.prototype, {
  isConstant: {
    get: function() {
      const value = this._value;
      if (!defined_default(value)) {
        return true;
      }
      const length3 = value.length;
      for (let i2 = 0; i2 < length3; i2++) {
        if (!Property_default.isConstant(value[i2])) {
          return false;
        }
      }
      return true;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  referenceFrame: {
    get: function() {
      return this._referenceFrame;
    }
  }
});
PositionPropertyArray.prototype.getValue = function(time, result) {
  return this.getValueInReferenceFrame(time, ReferenceFrame_default.FIXED, result);
};
PositionPropertyArray.prototype.getValueInReferenceFrame = function(time, referenceFrame, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  if (!defined_default(referenceFrame)) {
    throw new DeveloperError_default("referenceFrame is required.");
  }
  const value = this._value;
  if (!defined_default(value)) {
    return void 0;
  }
  const length3 = value.length;
  if (!defined_default(result)) {
    result = new Array(length3);
  }
  let i2 = 0;
  let x = 0;
  while (i2 < length3) {
    const property = value[i2];
    const itemValue = property.getValueInReferenceFrame(
      time,
      referenceFrame,
      result[i2]
    );
    if (defined_default(itemValue)) {
      result[x] = itemValue;
      x++;
    }
    i2++;
  }
  result.length = x;
  return result;
};
PositionPropertyArray.prototype.setValue = function(value) {
  const eventHelper = this._eventHelper;
  eventHelper.removeAll();
  if (defined_default(value)) {
    this._value = value.slice();
    const length3 = value.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const property = value[i2];
      if (defined_default(property)) {
        eventHelper.add(
          property.definitionChanged,
          PositionPropertyArray.prototype._raiseDefinitionChanged,
          this
        );
      }
    }
  } else {
    this._value = void 0;
  }
  this._definitionChanged.raiseEvent(this);
};
PositionPropertyArray.prototype.equals = function(other) {
  return this === other || other instanceof PositionPropertyArray && this._referenceFrame === other._referenceFrame && Property_default.arrayEquals(this._value, other._value);
};
PositionPropertyArray.prototype._raiseDefinitionChanged = function() {
  this._definitionChanged.raiseEvent(this);
};
var PositionPropertyArray_default = PositionPropertyArray;

// node_modules/cesium/Source/DataSources/PropertyArray.js
function PropertyArray(value) {
  this._value = void 0;
  this._definitionChanged = new Event_default();
  this._eventHelper = new EventHelper_default();
  this.setValue(value);
}
Object.defineProperties(PropertyArray.prototype, {
  isConstant: {
    get: function() {
      const value = this._value;
      if (!defined_default(value)) {
        return true;
      }
      const length3 = value.length;
      for (let i2 = 0; i2 < length3; i2++) {
        if (!Property_default.isConstant(value[i2])) {
          return false;
        }
      }
      return true;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  }
});
PropertyArray.prototype.getValue = function(time, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  const value = this._value;
  if (!defined_default(value)) {
    return void 0;
  }
  const length3 = value.length;
  if (!defined_default(result)) {
    result = new Array(length3);
  }
  let i2 = 0;
  let x = 0;
  while (i2 < length3) {
    const property = this._value[i2];
    const itemValue = property.getValue(time, result[i2]);
    if (defined_default(itemValue)) {
      result[x] = itemValue;
      x++;
    }
    i2++;
  }
  result.length = x;
  return result;
};
PropertyArray.prototype.setValue = function(value) {
  const eventHelper = this._eventHelper;
  eventHelper.removeAll();
  if (defined_default(value)) {
    this._value = value.slice();
    const length3 = value.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const property = value[i2];
      if (defined_default(property)) {
        eventHelper.add(
          property.definitionChanged,
          PropertyArray.prototype._raiseDefinitionChanged,
          this
        );
      }
    }
  } else {
    this._value = void 0;
  }
  this._definitionChanged.raiseEvent(this);
};
PropertyArray.prototype.equals = function(other) {
  return this === other || other instanceof PropertyArray && Property_default.arrayEquals(this._value, other._value);
};
PropertyArray.prototype._raiseDefinitionChanged = function() {
  this._definitionChanged.raiseEvent(this);
};
var PropertyArray_default = PropertyArray;

// node_modules/cesium/Source/DataSources/ReferenceProperty.js
function resolve(that) {
  let targetProperty = that._targetProperty;
  if (!defined_default(targetProperty)) {
    let targetEntity = that._targetEntity;
    if (!defined_default(targetEntity)) {
      targetEntity = that._targetCollection.getById(that._targetId);
      if (!defined_default(targetEntity)) {
        that._targetEntity = that._targetProperty = void 0;
        return;
      }
      targetEntity.definitionChanged.addEventListener(
        ReferenceProperty.prototype._onTargetEntityDefinitionChanged,
        that
      );
      that._targetEntity = targetEntity;
    }
    const targetPropertyNames = that._targetPropertyNames;
    targetProperty = that._targetEntity;
    for (let i2 = 0, len = targetPropertyNames.length; i2 < len && defined_default(targetProperty); ++i2) {
      targetProperty = targetProperty[targetPropertyNames[i2]];
    }
    that._targetProperty = targetProperty;
  }
  return targetProperty;
}
function ReferenceProperty(targetCollection, targetId, targetPropertyNames) {
  if (!defined_default(targetCollection)) {
    throw new DeveloperError_default("targetCollection is required.");
  }
  if (!defined_default(targetId) || targetId === "") {
    throw new DeveloperError_default("targetId is required.");
  }
  if (!defined_default(targetPropertyNames) || targetPropertyNames.length === 0) {
    throw new DeveloperError_default("targetPropertyNames is required.");
  }
  for (let i2 = 0; i2 < targetPropertyNames.length; i2++) {
    const item = targetPropertyNames[i2];
    if (!defined_default(item) || item === "") {
      throw new DeveloperError_default("reference contains invalid properties.");
    }
  }
  this._targetCollection = targetCollection;
  this._targetId = targetId;
  this._targetPropertyNames = targetPropertyNames;
  this._targetProperty = void 0;
  this._targetEntity = void 0;
  this._definitionChanged = new Event_default();
  targetCollection.collectionChanged.addEventListener(
    ReferenceProperty.prototype._onCollectionChanged,
    this
  );
}
Object.defineProperties(ReferenceProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(resolve(this));
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  referenceFrame: {
    get: function() {
      const target = resolve(this);
      return defined_default(target) ? target.referenceFrame : void 0;
    }
  },
  targetId: {
    get: function() {
      return this._targetId;
    }
  },
  targetCollection: {
    get: function() {
      return this._targetCollection;
    }
  },
  targetPropertyNames: {
    get: function() {
      return this._targetPropertyNames;
    }
  },
  resolvedProperty: {
    get: function() {
      return resolve(this);
    }
  }
});
ReferenceProperty.fromString = function(targetCollection, referenceString) {
  if (!defined_default(targetCollection)) {
    throw new DeveloperError_default("targetCollection is required.");
  }
  if (!defined_default(referenceString)) {
    throw new DeveloperError_default("referenceString is required.");
  }
  let identifier;
  const values = [];
  let inIdentifier = true;
  let isEscaped = false;
  let token = "";
  for (let i2 = 0; i2 < referenceString.length; ++i2) {
    const c14 = referenceString.charAt(i2);
    if (isEscaped) {
      token += c14;
      isEscaped = false;
    } else if (c14 === "\\") {
      isEscaped = true;
    } else if (inIdentifier && c14 === "#") {
      identifier = token;
      inIdentifier = false;
      token = "";
    } else if (!inIdentifier && c14 === ".") {
      values.push(token);
      token = "";
    } else {
      token += c14;
    }
  }
  values.push(token);
  return new ReferenceProperty(targetCollection, identifier, values);
};
ReferenceProperty.prototype.getValue = function(time, result) {
  const target = resolve(this);
  return defined_default(target) ? target.getValue(time, result) : void 0;
};
ReferenceProperty.prototype.getValueInReferenceFrame = function(time, referenceFrame, result) {
  const target = resolve(this);
  return defined_default(target) ? target.getValueInReferenceFrame(time, referenceFrame, result) : void 0;
};
ReferenceProperty.prototype.getType = function(time) {
  const target = resolve(this);
  return defined_default(target) ? target.getType(time) : void 0;
};
ReferenceProperty.prototype.equals = function(other) {
  if (this === other) {
    return true;
  }
  const names = this._targetPropertyNames;
  const otherNames = other._targetPropertyNames;
  if (this._targetCollection !== other._targetCollection || this._targetId !== other._targetId || names.length !== otherNames.length) {
    return false;
  }
  const length3 = this._targetPropertyNames.length;
  for (let i2 = 0; i2 < length3; i2++) {
    if (names[i2] !== otherNames[i2]) {
      return false;
    }
  }
  return true;
};
ReferenceProperty.prototype._onTargetEntityDefinitionChanged = function(targetEntity, name, value, oldValue2) {
  if (defined_default(this._targetProperty) && this._targetPropertyNames[0] === name) {
    this._targetProperty = void 0;
    this._definitionChanged.raiseEvent(this);
  }
};
ReferenceProperty.prototype._onCollectionChanged = function(collection, added, removed) {
  let targetEntity = this._targetEntity;
  if (defined_default(targetEntity) && removed.indexOf(targetEntity) !== -1) {
    targetEntity.definitionChanged.removeEventListener(
      ReferenceProperty.prototype._onTargetEntityDefinitionChanged,
      this
    );
    this._targetEntity = this._targetProperty = void 0;
  } else if (!defined_default(targetEntity)) {
    targetEntity = resolve(this);
    if (defined_default(targetEntity)) {
      this._definitionChanged.raiseEvent(this);
    }
  }
};
var ReferenceProperty_default = ReferenceProperty;

// node_modules/cesium/Source/DataSources/Rotation.js
var Rotation = {
  packedLength: 1,
  pack: function(value, array, startingIndex) {
    if (!defined_default(value)) {
      throw new DeveloperError_default("value is required");
    }
    if (!defined_default(array)) {
      throw new DeveloperError_default("array is required");
    }
    startingIndex = defaultValue_default(startingIndex, 0);
    array[startingIndex] = value;
    return array;
  },
  unpack: function(array, startingIndex, result) {
    if (!defined_default(array)) {
      throw new DeveloperError_default("array is required");
    }
    startingIndex = defaultValue_default(startingIndex, 0);
    return array[startingIndex];
  },
  convertPackedArrayForInterpolation: function(packedArray, startingIndex, lastIndex, result) {
    if (!defined_default(packedArray)) {
      throw new DeveloperError_default("packedArray is required");
    }
    if (!defined_default(result)) {
      result = [];
    }
    startingIndex = defaultValue_default(startingIndex, 0);
    lastIndex = defaultValue_default(lastIndex, packedArray.length);
    let previousValue;
    for (let i2 = 0, len = lastIndex - startingIndex + 1; i2 < len; i2++) {
      const value = packedArray[startingIndex + i2];
      if (i2 === 0 || Math.abs(previousValue - value) < Math.PI) {
        result[i2] = value;
      } else {
        result[i2] = value - Math_default.TWO_PI;
      }
      previousValue = value;
    }
  },
  unpackInterpolationResult: function(array, sourceArray, firstIndex, lastIndex, result) {
    if (!defined_default(array)) {
      throw new DeveloperError_default("array is required");
    }
    if (!defined_default(sourceArray)) {
      throw new DeveloperError_default("sourceArray is required");
    }
    result = array[0];
    if (result < 0) {
      return result + Math_default.TWO_PI;
    }
    return result;
  }
};
var Rotation_default = Rotation;

// node_modules/cesium/Source/DataSources/SampledProperty.js
var PackableNumber = {
  packedLength: 1,
  pack: function(value, array, startingIndex) {
    startingIndex = defaultValue_default(startingIndex, 0);
    array[startingIndex] = value;
  },
  unpack: function(array, startingIndex, result) {
    startingIndex = defaultValue_default(startingIndex, 0);
    return array[startingIndex];
  }
};
function arrayInsert(array, startIndex, items) {
  let i2;
  const arrayLength = array.length;
  const itemsLength = items.length;
  const newLength = arrayLength + itemsLength;
  array.length = newLength;
  if (arrayLength !== startIndex) {
    let q = arrayLength - 1;
    for (i2 = newLength - 1; i2 >= startIndex; i2--) {
      array[i2] = array[q--];
    }
  }
  for (i2 = 0; i2 < itemsLength; i2++) {
    array[startIndex++] = items[i2];
  }
}
function convertDate(date, epoch2) {
  if (date instanceof JulianDate_default) {
    return date;
  }
  if (typeof date === "string") {
    return JulianDate_default.fromIso8601(date);
  }
  return JulianDate_default.addSeconds(epoch2, date, new JulianDate_default());
}
var timesSpliceArgs = [];
var valuesSpliceArgs = [];
function mergeNewSamples(epoch2, times, values, newData, packedLength) {
  let newDataIndex = 0;
  let i2;
  let prevItem;
  let timesInsertionPoint;
  let valuesInsertionPoint;
  let currentTime;
  let nextTime;
  while (newDataIndex < newData.length) {
    currentTime = convertDate(newData[newDataIndex], epoch2);
    timesInsertionPoint = binarySearch_default(times, currentTime, JulianDate_default.compare);
    let timesSpliceArgsCount = 0;
    let valuesSpliceArgsCount = 0;
    if (timesInsertionPoint < 0) {
      timesInsertionPoint = ~timesInsertionPoint;
      valuesInsertionPoint = timesInsertionPoint * packedLength;
      prevItem = void 0;
      nextTime = times[timesInsertionPoint];
      while (newDataIndex < newData.length) {
        currentTime = convertDate(newData[newDataIndex], epoch2);
        if (defined_default(prevItem) && JulianDate_default.compare(prevItem, currentTime) >= 0 || defined_default(nextTime) && JulianDate_default.compare(currentTime, nextTime) >= 0) {
          break;
        }
        timesSpliceArgs[timesSpliceArgsCount++] = currentTime;
        newDataIndex = newDataIndex + 1;
        for (i2 = 0; i2 < packedLength; i2++) {
          valuesSpliceArgs[valuesSpliceArgsCount++] = newData[newDataIndex];
          newDataIndex = newDataIndex + 1;
        }
        prevItem = currentTime;
      }
      if (timesSpliceArgsCount > 0) {
        valuesSpliceArgs.length = valuesSpliceArgsCount;
        arrayInsert(values, valuesInsertionPoint, valuesSpliceArgs);
        timesSpliceArgs.length = timesSpliceArgsCount;
        arrayInsert(times, timesInsertionPoint, timesSpliceArgs);
      }
    } else {
      for (i2 = 0; i2 < packedLength; i2++) {
        newDataIndex++;
        values[timesInsertionPoint * packedLength + i2] = newData[newDataIndex];
      }
      newDataIndex++;
    }
  }
}
function SampledProperty(type, derivativeTypes) {
  Check_default.defined("type", type);
  let innerType = type;
  if (innerType === Number) {
    innerType = PackableNumber;
  }
  let packedLength = innerType.packedLength;
  let packedInterpolationLength = defaultValue_default(
    innerType.packedInterpolationLength,
    packedLength
  );
  let inputOrder = 0;
  let innerDerivativeTypes;
  if (defined_default(derivativeTypes)) {
    const length3 = derivativeTypes.length;
    innerDerivativeTypes = new Array(length3);
    for (let i2 = 0; i2 < length3; i2++) {
      let derivativeType = derivativeTypes[i2];
      if (derivativeType === Number) {
        derivativeType = PackableNumber;
      }
      const derivativePackedLength = derivativeType.packedLength;
      packedLength += derivativePackedLength;
      packedInterpolationLength += defaultValue_default(
        derivativeType.packedInterpolationLength,
        derivativePackedLength
      );
      innerDerivativeTypes[i2] = derivativeType;
    }
    inputOrder = length3;
  }
  this._type = type;
  this._innerType = innerType;
  this._interpolationDegree = 1;
  this._interpolationAlgorithm = LinearApproximation_default;
  this._numberOfPoints = 0;
  this._times = [];
  this._values = [];
  this._xTable = [];
  this._yTable = [];
  this._packedLength = packedLength;
  this._packedInterpolationLength = packedInterpolationLength;
  this._updateTableLength = true;
  this._interpolationResult = new Array(packedInterpolationLength);
  this._definitionChanged = new Event_default();
  this._derivativeTypes = derivativeTypes;
  this._innerDerivativeTypes = innerDerivativeTypes;
  this._inputOrder = inputOrder;
  this._forwardExtrapolationType = ExtrapolationType_default.NONE;
  this._forwardExtrapolationDuration = 0;
  this._backwardExtrapolationType = ExtrapolationType_default.NONE;
  this._backwardExtrapolationDuration = 0;
}
Object.defineProperties(SampledProperty.prototype, {
  isConstant: {
    get: function() {
      return this._values.length === 0;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  type: {
    get: function() {
      return this._type;
    }
  },
  derivativeTypes: {
    get: function() {
      return this._derivativeTypes;
    }
  },
  interpolationDegree: {
    get: function() {
      return this._interpolationDegree;
    }
  },
  interpolationAlgorithm: {
    get: function() {
      return this._interpolationAlgorithm;
    }
  },
  forwardExtrapolationType: {
    get: function() {
      return this._forwardExtrapolationType;
    },
    set: function(value) {
      if (this._forwardExtrapolationType !== value) {
        this._forwardExtrapolationType = value;
        this._definitionChanged.raiseEvent(this);
      }
    }
  },
  forwardExtrapolationDuration: {
    get: function() {
      return this._forwardExtrapolationDuration;
    },
    set: function(value) {
      if (this._forwardExtrapolationDuration !== value) {
        this._forwardExtrapolationDuration = value;
        this._definitionChanged.raiseEvent(this);
      }
    }
  },
  backwardExtrapolationType: {
    get: function() {
      return this._backwardExtrapolationType;
    },
    set: function(value) {
      if (this._backwardExtrapolationType !== value) {
        this._backwardExtrapolationType = value;
        this._definitionChanged.raiseEvent(this);
      }
    }
  },
  backwardExtrapolationDuration: {
    get: function() {
      return this._backwardExtrapolationDuration;
    },
    set: function(value) {
      if (this._backwardExtrapolationDuration !== value) {
        this._backwardExtrapolationDuration = value;
        this._definitionChanged.raiseEvent(this);
      }
    }
  }
});
SampledProperty.prototype.getValue = function(time, result) {
  Check_default.defined("time", time);
  const times = this._times;
  const timesLength = times.length;
  if (timesLength === 0) {
    return void 0;
  }
  let timeout;
  const innerType = this._innerType;
  const values = this._values;
  let index2 = binarySearch_default(times, time, JulianDate_default.compare);
  if (index2 < 0) {
    index2 = ~index2;
    if (index2 === 0) {
      const startTime = times[index2];
      timeout = this._backwardExtrapolationDuration;
      if (this._backwardExtrapolationType === ExtrapolationType_default.NONE || timeout !== 0 && JulianDate_default.secondsDifference(startTime, time) > timeout) {
        return void 0;
      }
      if (this._backwardExtrapolationType === ExtrapolationType_default.HOLD) {
        return innerType.unpack(values, 0, result);
      }
    }
    if (index2 >= timesLength) {
      index2 = timesLength - 1;
      const endTime = times[index2];
      timeout = this._forwardExtrapolationDuration;
      if (this._forwardExtrapolationType === ExtrapolationType_default.NONE || timeout !== 0 && JulianDate_default.secondsDifference(time, endTime) > timeout) {
        return void 0;
      }
      if (this._forwardExtrapolationType === ExtrapolationType_default.HOLD) {
        index2 = timesLength - 1;
        return innerType.unpack(values, index2 * innerType.packedLength, result);
      }
    }
    const xTable = this._xTable;
    const yTable = this._yTable;
    const interpolationAlgorithm = this._interpolationAlgorithm;
    const packedInterpolationLength = this._packedInterpolationLength;
    const inputOrder = this._inputOrder;
    if (this._updateTableLength) {
      this._updateTableLength = false;
      const numberOfPoints = Math.min(
        interpolationAlgorithm.getRequiredDataPoints(
          this._interpolationDegree,
          inputOrder
        ),
        timesLength
      );
      if (numberOfPoints !== this._numberOfPoints) {
        this._numberOfPoints = numberOfPoints;
        xTable.length = numberOfPoints;
        yTable.length = numberOfPoints * packedInterpolationLength;
      }
    }
    const degree = this._numberOfPoints - 1;
    if (degree < 1) {
      return void 0;
    }
    let firstIndex = 0;
    let lastIndex = timesLength - 1;
    const pointsInCollection = lastIndex - firstIndex + 1;
    if (pointsInCollection >= degree + 1) {
      let computedFirstIndex = index2 - (degree / 2 | 0) - 1;
      if (computedFirstIndex < firstIndex) {
        computedFirstIndex = firstIndex;
      }
      let computedLastIndex = computedFirstIndex + degree;
      if (computedLastIndex > lastIndex) {
        computedLastIndex = lastIndex;
        computedFirstIndex = computedLastIndex - degree;
        if (computedFirstIndex < firstIndex) {
          computedFirstIndex = firstIndex;
        }
      }
      firstIndex = computedFirstIndex;
      lastIndex = computedLastIndex;
    }
    const length3 = lastIndex - firstIndex + 1;
    for (let i2 = 0; i2 < length3; ++i2) {
      xTable[i2] = JulianDate_default.secondsDifference(
        times[firstIndex + i2],
        times[lastIndex]
      );
    }
    if (!defined_default(innerType.convertPackedArrayForInterpolation)) {
      let destinationIndex = 0;
      const packedLength = this._packedLength;
      let sourceIndex = firstIndex * packedLength;
      const stop2 = (lastIndex + 1) * packedLength;
      while (sourceIndex < stop2) {
        yTable[destinationIndex] = values[sourceIndex];
        sourceIndex++;
        destinationIndex++;
      }
    } else {
      innerType.convertPackedArrayForInterpolation(
        values,
        firstIndex,
        lastIndex,
        yTable
      );
    }
    const x = JulianDate_default.secondsDifference(time, times[lastIndex]);
    let interpolationResult;
    if (inputOrder === 0 || !defined_default(interpolationAlgorithm.interpolate)) {
      interpolationResult = interpolationAlgorithm.interpolateOrderZero(
        x,
        xTable,
        yTable,
        packedInterpolationLength,
        this._interpolationResult
      );
    } else {
      const yStride = Math.floor(packedInterpolationLength / (inputOrder + 1));
      interpolationResult = interpolationAlgorithm.interpolate(
        x,
        xTable,
        yTable,
        yStride,
        inputOrder,
        inputOrder,
        this._interpolationResult
      );
    }
    if (!defined_default(innerType.unpackInterpolationResult)) {
      return innerType.unpack(interpolationResult, 0, result);
    }
    return innerType.unpackInterpolationResult(
      interpolationResult,
      values,
      firstIndex,
      lastIndex,
      result
    );
  }
  return innerType.unpack(values, index2 * this._packedLength, result);
};
SampledProperty.prototype.setInterpolationOptions = function(options) {
  if (!defined_default(options)) {
    return;
  }
  let valuesChanged = false;
  const interpolationAlgorithm = options.interpolationAlgorithm;
  const interpolationDegree = options.interpolationDegree;
  if (defined_default(interpolationAlgorithm) && this._interpolationAlgorithm !== interpolationAlgorithm) {
    this._interpolationAlgorithm = interpolationAlgorithm;
    valuesChanged = true;
  }
  if (defined_default(interpolationDegree) && this._interpolationDegree !== interpolationDegree) {
    this._interpolationDegree = interpolationDegree;
    valuesChanged = true;
  }
  if (valuesChanged) {
    this._updateTableLength = true;
    this._definitionChanged.raiseEvent(this);
  }
};
SampledProperty.prototype.addSample = function(time, value, derivatives) {
  const innerDerivativeTypes = this._innerDerivativeTypes;
  const hasDerivatives = defined_default(innerDerivativeTypes);
  Check_default.defined("time", time);
  Check_default.defined("value", value);
  if (hasDerivatives) {
    Check_default.defined("derivatives", derivatives);
  }
  const innerType = this._innerType;
  const data = [];
  data.push(time);
  innerType.pack(value, data, data.length);
  if (hasDerivatives) {
    const derivativesLength = innerDerivativeTypes.length;
    for (let x = 0; x < derivativesLength; x++) {
      innerDerivativeTypes[x].pack(derivatives[x], data, data.length);
    }
  }
  mergeNewSamples(
    void 0,
    this._times,
    this._values,
    data,
    this._packedLength
  );
  this._updateTableLength = true;
  this._definitionChanged.raiseEvent(this);
};
SampledProperty.prototype.addSamples = function(times, values, derivativeValues) {
  const innerDerivativeTypes = this._innerDerivativeTypes;
  const hasDerivatives = defined_default(innerDerivativeTypes);
  Check_default.defined("times", times);
  Check_default.defined("values", values);
  if (times.length !== values.length) {
    throw new DeveloperError_default("times and values must be the same length.");
  }
  if (hasDerivatives && (!defined_default(derivativeValues) || derivativeValues.length !== times.length)) {
    throw new DeveloperError_default(
      "times and derivativeValues must be the same length."
    );
  }
  const innerType = this._innerType;
  const length3 = times.length;
  const data = [];
  for (let i2 = 0; i2 < length3; i2++) {
    data.push(times[i2]);
    innerType.pack(values[i2], data, data.length);
    if (hasDerivatives) {
      const derivatives = derivativeValues[i2];
      const derivativesLength = innerDerivativeTypes.length;
      for (let x = 0; x < derivativesLength; x++) {
        innerDerivativeTypes[x].pack(derivatives[x], data, data.length);
      }
    }
  }
  mergeNewSamples(
    void 0,
    this._times,
    this._values,
    data,
    this._packedLength
  );
  this._updateTableLength = true;
  this._definitionChanged.raiseEvent(this);
};
SampledProperty.prototype.addSamplesPackedArray = function(packedSamples, epoch2) {
  Check_default.defined("packedSamples", packedSamples);
  mergeNewSamples(
    epoch2,
    this._times,
    this._values,
    packedSamples,
    this._packedLength
  );
  this._updateTableLength = true;
  this._definitionChanged.raiseEvent(this);
};
SampledProperty.prototype.removeSample = function(time) {
  Check_default.defined("time", time);
  const index2 = binarySearch_default(this._times, time, JulianDate_default.compare);
  if (index2 < 0) {
    return false;
  }
  removeSamples(this, index2, 1);
  return true;
};
function removeSamples(property, startIndex, numberToRemove) {
  const packedLength = property._packedLength;
  property._times.splice(startIndex, numberToRemove);
  property._values.splice(
    startIndex * packedLength,
    numberToRemove * packedLength
  );
  property._updateTableLength = true;
  property._definitionChanged.raiseEvent(property);
}
SampledProperty.prototype.removeSamples = function(timeInterval) {
  Check_default.defined("timeInterval", timeInterval);
  const times = this._times;
  let startIndex = binarySearch_default(times, timeInterval.start, JulianDate_default.compare);
  if (startIndex < 0) {
    startIndex = ~startIndex;
  } else if (!timeInterval.isStartIncluded) {
    ++startIndex;
  }
  let stopIndex = binarySearch_default(times, timeInterval.stop, JulianDate_default.compare);
  if (stopIndex < 0) {
    stopIndex = ~stopIndex;
  } else if (timeInterval.isStopIncluded) {
    ++stopIndex;
  }
  removeSamples(this, startIndex, stopIndex - startIndex);
};
SampledProperty.prototype.equals = function(other) {
  if (this === other) {
    return true;
  }
  if (!defined_default(other)) {
    return false;
  }
  if (this._type !== other._type || this._interpolationDegree !== other._interpolationDegree || this._interpolationAlgorithm !== other._interpolationAlgorithm) {
    return false;
  }
  const derivativeTypes = this._derivativeTypes;
  const hasDerivatives = defined_default(derivativeTypes);
  const otherDerivativeTypes = other._derivativeTypes;
  const otherHasDerivatives = defined_default(otherDerivativeTypes);
  if (hasDerivatives !== otherHasDerivatives) {
    return false;
  }
  let i2;
  let length3;
  if (hasDerivatives) {
    length3 = derivativeTypes.length;
    if (length3 !== otherDerivativeTypes.length) {
      return false;
    }
    for (i2 = 0; i2 < length3; i2++) {
      if (derivativeTypes[i2] !== otherDerivativeTypes[i2]) {
        return false;
      }
    }
  }
  const times = this._times;
  const otherTimes = other._times;
  length3 = times.length;
  if (length3 !== otherTimes.length) {
    return false;
  }
  for (i2 = 0; i2 < length3; i2++) {
    if (!JulianDate_default.equals(times[i2], otherTimes[i2])) {
      return false;
    }
  }
  const values = this._values;
  const otherValues = other._values;
  length3 = values.length;
  for (i2 = 0; i2 < length3; i2++) {
    if (values[i2] !== otherValues[i2]) {
      return false;
    }
  }
  return true;
};
SampledProperty._mergeNewSamples = mergeNewSamples;
var SampledProperty_default = SampledProperty;

// node_modules/cesium/Source/DataSources/SampledPositionProperty.js
function SampledPositionProperty(referenceFrame, numberOfDerivatives) {
  numberOfDerivatives = defaultValue_default(numberOfDerivatives, 0);
  let derivativeTypes;
  if (numberOfDerivatives > 0) {
    derivativeTypes = new Array(numberOfDerivatives);
    for (let i2 = 0; i2 < numberOfDerivatives; i2++) {
      derivativeTypes[i2] = Cartesian3_default;
    }
  }
  this._numberOfDerivatives = numberOfDerivatives;
  this._property = new SampledProperty_default(Cartesian3_default, derivativeTypes);
  this._definitionChanged = new Event_default();
  this._referenceFrame = defaultValue_default(referenceFrame, ReferenceFrame_default.FIXED);
  this._property._definitionChanged.addEventListener(function() {
    this._definitionChanged.raiseEvent(this);
  }, this);
}
Object.defineProperties(SampledPositionProperty.prototype, {
  isConstant: {
    get: function() {
      return this._property.isConstant;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  referenceFrame: {
    get: function() {
      return this._referenceFrame;
    }
  },
  interpolationDegree: {
    get: function() {
      return this._property.interpolationDegree;
    }
  },
  interpolationAlgorithm: {
    get: function() {
      return this._property.interpolationAlgorithm;
    }
  },
  numberOfDerivatives: {
    get: function() {
      return this._numberOfDerivatives;
    }
  },
  forwardExtrapolationType: {
    get: function() {
      return this._property.forwardExtrapolationType;
    },
    set: function(value) {
      this._property.forwardExtrapolationType = value;
    }
  },
  forwardExtrapolationDuration: {
    get: function() {
      return this._property.forwardExtrapolationDuration;
    },
    set: function(value) {
      this._property.forwardExtrapolationDuration = value;
    }
  },
  backwardExtrapolationType: {
    get: function() {
      return this._property.backwardExtrapolationType;
    },
    set: function(value) {
      this._property.backwardExtrapolationType = value;
    }
  },
  backwardExtrapolationDuration: {
    get: function() {
      return this._property.backwardExtrapolationDuration;
    },
    set: function(value) {
      this._property.backwardExtrapolationDuration = value;
    }
  }
});
SampledPositionProperty.prototype.getValue = function(time, result) {
  return this.getValueInReferenceFrame(time, ReferenceFrame_default.FIXED, result);
};
SampledPositionProperty.prototype.getValueInReferenceFrame = function(time, referenceFrame, result) {
  Check_default.defined("time", time);
  Check_default.defined("referenceFrame", referenceFrame);
  result = this._property.getValue(time, result);
  if (defined_default(result)) {
    return PositionProperty_default.convertToReferenceFrame(
      time,
      result,
      this._referenceFrame,
      referenceFrame,
      result
    );
  }
  return void 0;
};
SampledPositionProperty.prototype.setInterpolationOptions = function(options) {
  this._property.setInterpolationOptions(options);
};
SampledPositionProperty.prototype.addSample = function(time, position, derivatives) {
  const numberOfDerivatives = this._numberOfDerivatives;
  if (numberOfDerivatives > 0 && (!defined_default(derivatives) || derivatives.length !== numberOfDerivatives)) {
    throw new DeveloperError_default(
      "derivatives length must be equal to the number of derivatives."
    );
  }
  this._property.addSample(time, position, derivatives);
};
SampledPositionProperty.prototype.addSamples = function(times, positions, derivatives) {
  this._property.addSamples(times, positions, derivatives);
};
SampledPositionProperty.prototype.addSamplesPackedArray = function(packedSamples, epoch2) {
  this._property.addSamplesPackedArray(packedSamples, epoch2);
};
SampledPositionProperty.prototype.removeSample = function(time) {
  return this._property.removeSample(time);
};
SampledPositionProperty.prototype.removeSamples = function(timeInterval) {
  this._property.removeSamples(timeInterval);
};
SampledPositionProperty.prototype.equals = function(other) {
  return this === other || other instanceof SampledPositionProperty && Property_default.equals(this._property, other._property) && this._referenceFrame === other._referenceFrame;
};
var SampledPositionProperty_default = SampledPositionProperty;

// node_modules/cesium/Source/DataSources/StripeOrientation.js
var StripeOrientation = {
  HORIZONTAL: 0,
  VERTICAL: 1
};
var StripeOrientation_default = Object.freeze(StripeOrientation);

// node_modules/cesium/Source/DataSources/StripeMaterialProperty.js
var defaultOrientation = StripeOrientation_default.HORIZONTAL;
var defaultEvenColor2 = Color_default.WHITE;
var defaultOddColor2 = Color_default.BLACK;
var defaultOffset4 = 0;
var defaultRepeat3 = 1;
function StripeMaterialProperty(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._definitionChanged = new Event_default();
  this._orientation = void 0;
  this._orientationSubscription = void 0;
  this._evenColor = void 0;
  this._evenColorSubscription = void 0;
  this._oddColor = void 0;
  this._oddColorSubscription = void 0;
  this._offset = void 0;
  this._offsetSubscription = void 0;
  this._repeat = void 0;
  this._repeatSubscription = void 0;
  this.orientation = options.orientation;
  this.evenColor = options.evenColor;
  this.oddColor = options.oddColor;
  this.offset = options.offset;
  this.repeat = options.repeat;
}
Object.defineProperties(StripeMaterialProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._orientation) && Property_default.isConstant(this._evenColor) && Property_default.isConstant(this._oddColor) && Property_default.isConstant(this._offset) && Property_default.isConstant(this._repeat);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  orientation: createPropertyDescriptor_default("orientation"),
  evenColor: createPropertyDescriptor_default("evenColor"),
  oddColor: createPropertyDescriptor_default("oddColor"),
  offset: createPropertyDescriptor_default("offset"),
  repeat: createPropertyDescriptor_default("repeat")
});
StripeMaterialProperty.prototype.getType = function(time) {
  return "Stripe";
};
StripeMaterialProperty.prototype.getValue = function(time, result) {
  if (!defined_default(result)) {
    result = {};
  }
  result.horizontal = Property_default.getValueOrDefault(this._orientation, time, defaultOrientation) === StripeOrientation_default.HORIZONTAL;
  result.evenColor = Property_default.getValueOrClonedDefault(
    this._evenColor,
    time,
    defaultEvenColor2,
    result.evenColor
  );
  result.oddColor = Property_default.getValueOrClonedDefault(
    this._oddColor,
    time,
    defaultOddColor2,
    result.oddColor
  );
  result.offset = Property_default.getValueOrDefault(this._offset, time, defaultOffset4);
  result.repeat = Property_default.getValueOrDefault(this._repeat, time, defaultRepeat3);
  return result;
};
StripeMaterialProperty.prototype.equals = function(other) {
  return this === other || other instanceof StripeMaterialProperty && Property_default.equals(this._orientation, other._orientation) && Property_default.equals(this._evenColor, other._evenColor) && Property_default.equals(this._oddColor, other._oddColor) && Property_default.equals(this._offset, other._offset) && Property_default.equals(this._repeat, other._repeat);
};
var StripeMaterialProperty_default = StripeMaterialProperty;

// node_modules/cesium/Source/DataSources/TimeIntervalCollectionPositionProperty.js
function TimeIntervalCollectionPositionProperty(referenceFrame) {
  this._definitionChanged = new Event_default();
  this._intervals = new TimeIntervalCollection_default();
  this._intervals.changedEvent.addEventListener(
    TimeIntervalCollectionPositionProperty.prototype._intervalsChanged,
    this
  );
  this._referenceFrame = defaultValue_default(referenceFrame, ReferenceFrame_default.FIXED);
}
Object.defineProperties(TimeIntervalCollectionPositionProperty.prototype, {
  isConstant: {
    get: function() {
      return this._intervals.isEmpty;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  intervals: {
    get: function() {
      return this._intervals;
    }
  },
  referenceFrame: {
    get: function() {
      return this._referenceFrame;
    }
  }
});
TimeIntervalCollectionPositionProperty.prototype.getValue = function(time, result) {
  return this.getValueInReferenceFrame(time, ReferenceFrame_default.FIXED, result);
};
TimeIntervalCollectionPositionProperty.prototype.getValueInReferenceFrame = function(time, referenceFrame, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  if (!defined_default(referenceFrame)) {
    throw new DeveloperError_default("referenceFrame is required.");
  }
  const position = this._intervals.findDataForIntervalContainingDate(time);
  if (defined_default(position)) {
    return PositionProperty_default.convertToReferenceFrame(
      time,
      position,
      this._referenceFrame,
      referenceFrame,
      result
    );
  }
  return void 0;
};
TimeIntervalCollectionPositionProperty.prototype.equals = function(other) {
  return this === other || other instanceof TimeIntervalCollectionPositionProperty && this._intervals.equals(other._intervals, Property_default.equals) && this._referenceFrame === other._referenceFrame;
};
TimeIntervalCollectionPositionProperty.prototype._intervalsChanged = function() {
  this._definitionChanged.raiseEvent(this);
};
var TimeIntervalCollectionPositionProperty_default = TimeIntervalCollectionPositionProperty;

// node_modules/cesium/Source/DataSources/TimeIntervalCollectionProperty.js
function TimeIntervalCollectionProperty() {
  this._definitionChanged = new Event_default();
  this._intervals = new TimeIntervalCollection_default();
  this._intervals.changedEvent.addEventListener(
    TimeIntervalCollectionProperty.prototype._intervalsChanged,
    this
  );
}
Object.defineProperties(TimeIntervalCollectionProperty.prototype, {
  isConstant: {
    get: function() {
      return this._intervals.isEmpty;
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  intervals: {
    get: function() {
      return this._intervals;
    }
  }
});
TimeIntervalCollectionProperty.prototype.getValue = function(time, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required");
  }
  const value = this._intervals.findDataForIntervalContainingDate(time);
  if (defined_default(value) && typeof value.clone === "function") {
    return value.clone(result);
  }
  return value;
};
TimeIntervalCollectionProperty.prototype.equals = function(other) {
  return this === other || other instanceof TimeIntervalCollectionProperty && this._intervals.equals(other._intervals, Property_default.equals);
};
TimeIntervalCollectionProperty.prototype._intervalsChanged = function() {
  this._definitionChanged.raiseEvent(this);
};
var TimeIntervalCollectionProperty_default = TimeIntervalCollectionProperty;

// node_modules/cesium/Source/DataSources/VelocityVectorProperty.js
function VelocityVectorProperty(position, normalize2) {
  this._position = void 0;
  this._subscription = void 0;
  this._definitionChanged = new Event_default();
  this._normalize = defaultValue_default(normalize2, true);
  this.position = position;
}
Object.defineProperties(VelocityVectorProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._position);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  position: {
    get: function() {
      return this._position;
    },
    set: function(value) {
      const oldValue2 = this._position;
      if (oldValue2 !== value) {
        if (defined_default(oldValue2)) {
          this._subscription();
        }
        this._position = value;
        if (defined_default(value)) {
          this._subscription = value._definitionChanged.addEventListener(
            function() {
              this._definitionChanged.raiseEvent(this);
            },
            this
          );
        }
        this._definitionChanged.raiseEvent(this);
      }
    }
  },
  normalize: {
    get: function() {
      return this._normalize;
    },
    set: function(value) {
      if (this._normalize === value) {
        return;
      }
      this._normalize = value;
      this._definitionChanged.raiseEvent(this);
    }
  }
});
var position1Scratch = new Cartesian3_default();
var position2Scratch = new Cartesian3_default();
var timeScratch = new JulianDate_default();
var step = 1 / 60;
VelocityVectorProperty.prototype.getValue = function(time, result) {
  return this._getValue(time, result);
};
VelocityVectorProperty.prototype._getValue = function(time, velocityResult, positionResult) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required");
  }
  if (!defined_default(velocityResult)) {
    velocityResult = new Cartesian3_default();
  }
  const property = this._position;
  if (Property_default.isConstant(property)) {
    return this._normalize ? void 0 : Cartesian3_default.clone(Cartesian3_default.ZERO, velocityResult);
  }
  let position1 = property.getValue(time, position1Scratch);
  let position2 = property.getValue(
    JulianDate_default.addSeconds(time, step, timeScratch),
    position2Scratch
  );
  if (!defined_default(position1)) {
    return void 0;
  }
  if (!defined_default(position2)) {
    position2 = position1;
    position1 = property.getValue(
      JulianDate_default.addSeconds(time, -step, timeScratch),
      position2Scratch
    );
    if (!defined_default(position1)) {
      return void 0;
    }
  }
  if (Cartesian3_default.equals(position1, position2)) {
    return this._normalize ? void 0 : Cartesian3_default.clone(Cartesian3_default.ZERO, velocityResult);
  }
  if (defined_default(positionResult)) {
    position1.clone(positionResult);
  }
  const velocity = Cartesian3_default.subtract(position2, position1, velocityResult);
  if (this._normalize) {
    return Cartesian3_default.normalize(velocity, velocityResult);
  }
  return Cartesian3_default.divideByScalar(velocity, step, velocityResult);
};
VelocityVectorProperty.prototype.equals = function(other) {
  return this === other || other instanceof VelocityVectorProperty && Property_default.equals(this._position, other._position);
};
var VelocityVectorProperty_default = VelocityVectorProperty;

// node_modules/cesium/Source/DataSources/VelocityOrientationProperty.js
function VelocityOrientationProperty(position, ellipsoid) {
  this._velocityVectorProperty = new VelocityVectorProperty_default(position, true);
  this._subscription = void 0;
  this._ellipsoid = void 0;
  this._definitionChanged = new Event_default();
  this.ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  const that = this;
  this._velocityVectorProperty.definitionChanged.addEventListener(function() {
    that._definitionChanged.raiseEvent(that);
  });
}
Object.defineProperties(VelocityOrientationProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._velocityVectorProperty);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  position: {
    get: function() {
      return this._velocityVectorProperty.position;
    },
    set: function(value) {
      this._velocityVectorProperty.position = value;
    }
  },
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    },
    set: function(value) {
      const oldValue2 = this._ellipsoid;
      if (oldValue2 !== value) {
        this._ellipsoid = value;
        this._definitionChanged.raiseEvent(this);
      }
    }
  }
});
var positionScratch10 = new Cartesian3_default();
var velocityScratch = new Cartesian3_default();
var rotationScratch2 = new Matrix3_default();
VelocityOrientationProperty.prototype.getValue = function(time, result) {
  const velocity = this._velocityVectorProperty._getValue(
    time,
    velocityScratch,
    positionScratch10
  );
  if (!defined_default(velocity)) {
    return void 0;
  }
  Transforms_default.rotationMatrixFromPositionVelocity(
    positionScratch10,
    velocity,
    this._ellipsoid,
    rotationScratch2
  );
  return Quaternion_default.fromRotationMatrix(rotationScratch2, result);
};
VelocityOrientationProperty.prototype.equals = function(other) {
  return this === other || other instanceof VelocityOrientationProperty && Property_default.equals(
    this._velocityVectorProperty,
    other._velocityVectorProperty
  ) && (this._ellipsoid === other._ellipsoid || this._ellipsoid.equals(other._ellipsoid));
};
var VelocityOrientationProperty_default = VelocityOrientationProperty;

// node_modules/cesium/Source/DataSources/CzmlDataSource.js
function UnitCartesian3() {
}
UnitCartesian3.packedLength = Cartesian3_default.packedLength;
UnitCartesian3.unpack = Cartesian3_default.unpack;
UnitCartesian3.pack = Cartesian3_default.pack;
var currentId;
function createReferenceProperty(entityCollection, referenceString) {
  if (referenceString[0] === "#") {
    referenceString = currentId + referenceString;
  }
  return ReferenceProperty_default.fromString(entityCollection, referenceString);
}
function createSpecializedProperty(type, entityCollection, packetData) {
  if (defined_default(packetData.reference)) {
    return createReferenceProperty(entityCollection, packetData.reference);
  }
  if (defined_default(packetData.velocityReference)) {
    const referenceProperty = createReferenceProperty(
      entityCollection,
      packetData.velocityReference
    );
    switch (type) {
      case Cartesian3_default:
      case UnitCartesian3:
        return new VelocityVectorProperty_default(
          referenceProperty,
          type === UnitCartesian3
        );
      case Quaternion_default:
        return new VelocityOrientationProperty_default(referenceProperty);
    }
  }
  throw new RuntimeError_default(`${JSON.stringify(packetData)} is not valid CZML.`);
}
function createAdapterProperty(property, adapterFunction) {
  return new CallbackProperty_default(function(time, result) {
    return adapterFunction(property.getValue(time, result));
  }, property.isConstant);
}
var scratchCartesian20 = new Cartesian3_default();
var scratchSpherical = new Spherical_default();
var scratchCartographic10 = new Cartographic_default();
var scratchTimeInterval = new TimeInterval_default();
var scratchQuaternion = new Quaternion_default();
function unwrapColorInterval(czmlInterval) {
  let rgbaf = czmlInterval.rgbaf;
  if (defined_default(rgbaf)) {
    return rgbaf;
  }
  const rgba = czmlInterval.rgba;
  if (!defined_default(rgba)) {
    return void 0;
  }
  const length3 = rgba.length;
  if (length3 === Color_default.packedLength) {
    return [
      Color_default.byteToFloat(rgba[0]),
      Color_default.byteToFloat(rgba[1]),
      Color_default.byteToFloat(rgba[2]),
      Color_default.byteToFloat(rgba[3])
    ];
  }
  rgbaf = new Array(length3);
  for (let i2 = 0; i2 < length3; i2 += 5) {
    rgbaf[i2] = rgba[i2];
    rgbaf[i2 + 1] = Color_default.byteToFloat(rgba[i2 + 1]);
    rgbaf[i2 + 2] = Color_default.byteToFloat(rgba[i2 + 2]);
    rgbaf[i2 + 3] = Color_default.byteToFloat(rgba[i2 + 3]);
    rgbaf[i2 + 4] = Color_default.byteToFloat(rgba[i2 + 4]);
  }
  return rgbaf;
}
function unwrapUriInterval(czmlInterval, sourceUri) {
  const uri = defaultValue_default(czmlInterval.uri, czmlInterval);
  if (defined_default(sourceUri)) {
    return sourceUri.getDerivedResource({
      url: uri
    });
  }
  return Resource_default.createIfNeeded(uri);
}
function unwrapRectangleInterval(czmlInterval) {
  let wsen = czmlInterval.wsen;
  if (defined_default(wsen)) {
    return wsen;
  }
  const wsenDegrees = czmlInterval.wsenDegrees;
  if (!defined_default(wsenDegrees)) {
    return void 0;
  }
  const length3 = wsenDegrees.length;
  if (length3 === Rectangle_default.packedLength) {
    return [
      Math_default.toRadians(wsenDegrees[0]),
      Math_default.toRadians(wsenDegrees[1]),
      Math_default.toRadians(wsenDegrees[2]),
      Math_default.toRadians(wsenDegrees[3])
    ];
  }
  wsen = new Array(length3);
  for (let i2 = 0; i2 < length3; i2 += 5) {
    wsen[i2] = wsenDegrees[i2];
    wsen[i2 + 1] = Math_default.toRadians(wsenDegrees[i2 + 1]);
    wsen[i2 + 2] = Math_default.toRadians(wsenDegrees[i2 + 2]);
    wsen[i2 + 3] = Math_default.toRadians(wsenDegrees[i2 + 3]);
    wsen[i2 + 4] = Math_default.toRadians(wsenDegrees[i2 + 4]);
  }
  return wsen;
}
function convertUnitSphericalToCartesian(unitSpherical) {
  const length3 = unitSpherical.length;
  scratchSpherical.magnitude = 1;
  if (length3 === 2) {
    scratchSpherical.clock = unitSpherical[0];
    scratchSpherical.cone = unitSpherical[1];
    Cartesian3_default.fromSpherical(scratchSpherical, scratchCartesian20);
    return [scratchCartesian20.x, scratchCartesian20.y, scratchCartesian20.z];
  }
  const result = new Array(length3 / 3 * 4);
  for (let i2 = 0, j = 0; i2 < length3; i2 += 3, j += 4) {
    result[j] = unitSpherical[i2];
    scratchSpherical.clock = unitSpherical[i2 + 1];
    scratchSpherical.cone = unitSpherical[i2 + 2];
    Cartesian3_default.fromSpherical(scratchSpherical, scratchCartesian20);
    result[j + 1] = scratchCartesian20.x;
    result[j + 2] = scratchCartesian20.y;
    result[j + 3] = scratchCartesian20.z;
  }
  return result;
}
function convertSphericalToCartesian(spherical) {
  const length3 = spherical.length;
  if (length3 === 3) {
    scratchSpherical.clock = spherical[0];
    scratchSpherical.cone = spherical[1];
    scratchSpherical.magnitude = spherical[2];
    Cartesian3_default.fromSpherical(scratchSpherical, scratchCartesian20);
    return [scratchCartesian20.x, scratchCartesian20.y, scratchCartesian20.z];
  }
  const result = new Array(length3);
  for (let i2 = 0; i2 < length3; i2 += 4) {
    result[i2] = spherical[i2];
    scratchSpherical.clock = spherical[i2 + 1];
    scratchSpherical.cone = spherical[i2 + 2];
    scratchSpherical.magnitude = spherical[i2 + 3];
    Cartesian3_default.fromSpherical(scratchSpherical, scratchCartesian20);
    result[i2 + 1] = scratchCartesian20.x;
    result[i2 + 2] = scratchCartesian20.y;
    result[i2 + 3] = scratchCartesian20.z;
  }
  return result;
}
function convertCartographicRadiansToCartesian(cartographicRadians) {
  const length3 = cartographicRadians.length;
  if (length3 === 3) {
    scratchCartographic10.longitude = cartographicRadians[0];
    scratchCartographic10.latitude = cartographicRadians[1];
    scratchCartographic10.height = cartographicRadians[2];
    Ellipsoid_default.WGS84.cartographicToCartesian(
      scratchCartographic10,
      scratchCartesian20
    );
    return [scratchCartesian20.x, scratchCartesian20.y, scratchCartesian20.z];
  }
  const result = new Array(length3);
  for (let i2 = 0; i2 < length3; i2 += 4) {
    result[i2] = cartographicRadians[i2];
    scratchCartographic10.longitude = cartographicRadians[i2 + 1];
    scratchCartographic10.latitude = cartographicRadians[i2 + 2];
    scratchCartographic10.height = cartographicRadians[i2 + 3];
    Ellipsoid_default.WGS84.cartographicToCartesian(
      scratchCartographic10,
      scratchCartesian20
    );
    result[i2 + 1] = scratchCartesian20.x;
    result[i2 + 2] = scratchCartesian20.y;
    result[i2 + 3] = scratchCartesian20.z;
  }
  return result;
}
function convertCartographicDegreesToCartesian(cartographicDegrees) {
  const length3 = cartographicDegrees.length;
  if (length3 === 3) {
    scratchCartographic10.longitude = Math_default.toRadians(
      cartographicDegrees[0]
    );
    scratchCartographic10.latitude = Math_default.toRadians(cartographicDegrees[1]);
    scratchCartographic10.height = cartographicDegrees[2];
    Ellipsoid_default.WGS84.cartographicToCartesian(
      scratchCartographic10,
      scratchCartesian20
    );
    return [scratchCartesian20.x, scratchCartesian20.y, scratchCartesian20.z];
  }
  const result = new Array(length3);
  for (let i2 = 0; i2 < length3; i2 += 4) {
    result[i2] = cartographicDegrees[i2];
    scratchCartographic10.longitude = Math_default.toRadians(
      cartographicDegrees[i2 + 1]
    );
    scratchCartographic10.latitude = Math_default.toRadians(
      cartographicDegrees[i2 + 2]
    );
    scratchCartographic10.height = cartographicDegrees[i2 + 3];
    Ellipsoid_default.WGS84.cartographicToCartesian(
      scratchCartographic10,
      scratchCartesian20
    );
    result[i2 + 1] = scratchCartesian20.x;
    result[i2 + 2] = scratchCartesian20.y;
    result[i2 + 3] = scratchCartesian20.z;
  }
  return result;
}
function unwrapCartesianInterval(czmlInterval) {
  const cartesian11 = czmlInterval.cartesian;
  if (defined_default(cartesian11)) {
    return cartesian11;
  }
  const cartesianVelocity = czmlInterval.cartesianVelocity;
  if (defined_default(cartesianVelocity)) {
    return cartesianVelocity;
  }
  const unitCartesian = czmlInterval.unitCartesian;
  if (defined_default(unitCartesian)) {
    return unitCartesian;
  }
  const unitSpherical = czmlInterval.unitSpherical;
  if (defined_default(unitSpherical)) {
    return convertUnitSphericalToCartesian(unitSpherical);
  }
  const spherical = czmlInterval.spherical;
  if (defined_default(spherical)) {
    return convertSphericalToCartesian(spherical);
  }
  const cartographicRadians = czmlInterval.cartographicRadians;
  if (defined_default(cartographicRadians)) {
    return convertCartographicRadiansToCartesian(cartographicRadians);
  }
  const cartographicDegrees = czmlInterval.cartographicDegrees;
  if (defined_default(cartographicDegrees)) {
    return convertCartographicDegreesToCartesian(cartographicDegrees);
  }
  throw new RuntimeError_default(
    `${JSON.stringify(czmlInterval)} is not a valid CZML interval.`
  );
}
function normalizePackedCartesianArray(array, startingIndex) {
  Cartesian3_default.unpack(array, startingIndex, scratchCartesian20);
  Cartesian3_default.normalize(scratchCartesian20, scratchCartesian20);
  Cartesian3_default.pack(scratchCartesian20, array, startingIndex);
}
function unwrapUnitCartesianInterval(czmlInterval) {
  const cartesian11 = unwrapCartesianInterval(czmlInterval);
  if (cartesian11.length === 3) {
    normalizePackedCartesianArray(cartesian11, 0);
    return cartesian11;
  }
  for (let i2 = 1; i2 < cartesian11.length; i2 += 4) {
    normalizePackedCartesianArray(cartesian11, i2);
  }
  return cartesian11;
}
function normalizePackedQuaternionArray(array, startingIndex) {
  Quaternion_default.unpack(array, startingIndex, scratchQuaternion);
  Quaternion_default.normalize(scratchQuaternion, scratchQuaternion);
  Quaternion_default.pack(scratchQuaternion, array, startingIndex);
}
function unwrapQuaternionInterval(czmlInterval) {
  const unitQuaternion = czmlInterval.unitQuaternion;
  if (defined_default(unitQuaternion)) {
    if (unitQuaternion.length === 4) {
      normalizePackedQuaternionArray(unitQuaternion, 0);
      return unitQuaternion;
    }
    for (let i2 = 1; i2 < unitQuaternion.length; i2 += 5) {
      normalizePackedQuaternionArray(unitQuaternion, i2);
    }
  }
  return unitQuaternion;
}
function getPropertyType(czmlInterval) {
  if (typeof czmlInterval === "boolean") {
    return Boolean;
  } else if (typeof czmlInterval === "number") {
    return Number;
  } else if (typeof czmlInterval === "string") {
    return String;
  } else if (czmlInterval.hasOwnProperty("array")) {
    return Array;
  } else if (czmlInterval.hasOwnProperty("boolean")) {
    return Boolean;
  } else if (czmlInterval.hasOwnProperty("boundingRectangle")) {
    return BoundingRectangle_default;
  } else if (czmlInterval.hasOwnProperty("cartesian2")) {
    return Cartesian2_default;
  } else if (czmlInterval.hasOwnProperty("cartesian") || czmlInterval.hasOwnProperty("spherical") || czmlInterval.hasOwnProperty("cartographicRadians") || czmlInterval.hasOwnProperty("cartographicDegrees")) {
    return Cartesian3_default;
  } else if (czmlInterval.hasOwnProperty("unitCartesian") || czmlInterval.hasOwnProperty("unitSpherical")) {
    return UnitCartesian3;
  } else if (czmlInterval.hasOwnProperty("rgba") || czmlInterval.hasOwnProperty("rgbaf")) {
    return Color_default;
  } else if (czmlInterval.hasOwnProperty("arcType")) {
    return ArcType_default;
  } else if (czmlInterval.hasOwnProperty("classificationType")) {
    return ClassificationType_default;
  } else if (czmlInterval.hasOwnProperty("colorBlendMode")) {
    return ColorBlendMode_default;
  } else if (czmlInterval.hasOwnProperty("cornerType")) {
    return CornerType_default;
  } else if (czmlInterval.hasOwnProperty("heightReference")) {
    return HeightReference_default;
  } else if (czmlInterval.hasOwnProperty("horizontalOrigin")) {
    return HorizontalOrigin_default;
  } else if (czmlInterval.hasOwnProperty("date")) {
    return JulianDate_default;
  } else if (czmlInterval.hasOwnProperty("labelStyle")) {
    return LabelStyle_default;
  } else if (czmlInterval.hasOwnProperty("number")) {
    return Number;
  } else if (czmlInterval.hasOwnProperty("nearFarScalar")) {
    return NearFarScalar_default;
  } else if (czmlInterval.hasOwnProperty("distanceDisplayCondition")) {
    return DistanceDisplayCondition_default;
  } else if (czmlInterval.hasOwnProperty("object") || czmlInterval.hasOwnProperty("value")) {
    return Object;
  } else if (czmlInterval.hasOwnProperty("unitQuaternion")) {
    return Quaternion_default;
  } else if (czmlInterval.hasOwnProperty("shadowMode")) {
    return ShadowMode_default;
  } else if (czmlInterval.hasOwnProperty("string")) {
    return String;
  } else if (czmlInterval.hasOwnProperty("stripeOrientation")) {
    return StripeOrientation_default;
  } else if (czmlInterval.hasOwnProperty("wsen") || czmlInterval.hasOwnProperty("wsenDegrees")) {
    return Rectangle_default;
  } else if (czmlInterval.hasOwnProperty("uri")) {
    return URI;
  } else if (czmlInterval.hasOwnProperty("verticalOrigin")) {
    return VerticalOrigin_default;
  }
  return Object;
}
function unwrapInterval(type, czmlInterval, sourceUri) {
  switch (type) {
    case ArcType_default:
      return ArcType_default[defaultValue_default(czmlInterval.arcType, czmlInterval)];
    case Array:
      return czmlInterval.array;
    case Boolean:
      return defaultValue_default(czmlInterval["boolean"], czmlInterval);
    case BoundingRectangle_default:
      return czmlInterval.boundingRectangle;
    case Cartesian2_default:
      return czmlInterval.cartesian2;
    case Cartesian3_default:
      return unwrapCartesianInterval(czmlInterval);
    case UnitCartesian3:
      return unwrapUnitCartesianInterval(czmlInterval);
    case Color_default:
      return unwrapColorInterval(czmlInterval);
    case ClassificationType_default:
      return ClassificationType_default[defaultValue_default(czmlInterval.classificationType, czmlInterval)];
    case ColorBlendMode_default:
      return ColorBlendMode_default[defaultValue_default(czmlInterval.colorBlendMode, czmlInterval)];
    case CornerType_default:
      return CornerType_default[defaultValue_default(czmlInterval.cornerType, czmlInterval)];
    case HeightReference_default:
      return HeightReference_default[defaultValue_default(czmlInterval.heightReference, czmlInterval)];
    case HorizontalOrigin_default:
      return HorizontalOrigin_default[defaultValue_default(czmlInterval.horizontalOrigin, czmlInterval)];
    case Image:
      return unwrapUriInterval(czmlInterval, sourceUri);
    case JulianDate_default:
      return JulianDate_default.fromIso8601(
        defaultValue_default(czmlInterval.date, czmlInterval)
      );
    case LabelStyle_default:
      return LabelStyle_default[defaultValue_default(czmlInterval.labelStyle, czmlInterval)];
    case Number:
      return defaultValue_default(czmlInterval.number, czmlInterval);
    case NearFarScalar_default:
      return czmlInterval.nearFarScalar;
    case DistanceDisplayCondition_default:
      return czmlInterval.distanceDisplayCondition;
    case Object:
      return defaultValue_default(
        defaultValue_default(czmlInterval.object, czmlInterval.value),
        czmlInterval
      );
    case Quaternion_default:
      return unwrapQuaternionInterval(czmlInterval);
    case Rotation_default:
      return defaultValue_default(czmlInterval.number, czmlInterval);
    case ShadowMode_default:
      return ShadowMode_default[defaultValue_default(
        defaultValue_default(czmlInterval.shadowMode, czmlInterval.shadows),
        czmlInterval
      )];
    case String:
      return defaultValue_default(czmlInterval.string, czmlInterval);
    case StripeOrientation_default:
      return StripeOrientation_default[defaultValue_default(czmlInterval.stripeOrientation, czmlInterval)];
    case Rectangle_default:
      return unwrapRectangleInterval(czmlInterval);
    case URI:
      return unwrapUriInterval(czmlInterval, sourceUri);
    case VerticalOrigin_default:
      return VerticalOrigin_default[defaultValue_default(czmlInterval.verticalOrigin, czmlInterval)];
    default:
      throw new RuntimeError_default(type);
  }
}
var interpolators = {
  HERMITE: HermitePolynomialApproximation_default,
  LAGRANGE: LagrangePolynomialApproximation_default,
  LINEAR: LinearApproximation_default
};
function updateInterpolationSettings(packetData, property) {
  const interpolationAlgorithm = packetData.interpolationAlgorithm;
  const interpolationDegree = packetData.interpolationDegree;
  if (defined_default(interpolationAlgorithm) || defined_default(interpolationDegree)) {
    property.setInterpolationOptions({
      interpolationAlgorithm: interpolators[interpolationAlgorithm],
      interpolationDegree
    });
  }
  const forwardExtrapolationType = packetData.forwardExtrapolationType;
  if (defined_default(forwardExtrapolationType)) {
    property.forwardExtrapolationType = ExtrapolationType_default[forwardExtrapolationType];
  }
  const forwardExtrapolationDuration = packetData.forwardExtrapolationDuration;
  if (defined_default(forwardExtrapolationDuration)) {
    property.forwardExtrapolationDuration = forwardExtrapolationDuration;
  }
  const backwardExtrapolationType = packetData.backwardExtrapolationType;
  if (defined_default(backwardExtrapolationType)) {
    property.backwardExtrapolationType = ExtrapolationType_default[backwardExtrapolationType];
  }
  const backwardExtrapolationDuration = packetData.backwardExtrapolationDuration;
  if (defined_default(backwardExtrapolationDuration)) {
    property.backwardExtrapolationDuration = backwardExtrapolationDuration;
  }
}
var iso8601Scratch = {
  iso8601: void 0
};
function intervalFromString(intervalString) {
  if (!defined_default(intervalString)) {
    return void 0;
  }
  iso8601Scratch.iso8601 = intervalString;
  return TimeInterval_default.fromIso8601(iso8601Scratch);
}
function wrapPropertyInInfiniteInterval(property) {
  const interval = Iso8601_default.MAXIMUM_INTERVAL.clone();
  interval.data = property;
  return interval;
}
function convertPropertyToComposite(property) {
  const composite = new CompositeProperty_default();
  composite.intervals.addInterval(wrapPropertyInInfiniteInterval(property));
  return composite;
}
function convertPositionPropertyToComposite(property) {
  const composite = new CompositePositionProperty_default(property.referenceFrame);
  composite.intervals.addInterval(wrapPropertyInInfiniteInterval(property));
  return composite;
}
function processProperty(type, object2, propertyName, packetData, constrainedInterval, sourceUri, entityCollection) {
  let combinedInterval = intervalFromString(packetData.interval);
  if (defined_default(constrainedInterval)) {
    if (defined_default(combinedInterval)) {
      combinedInterval = TimeInterval_default.intersect(
        combinedInterval,
        constrainedInterval,
        scratchTimeInterval
      );
    } else {
      combinedInterval = constrainedInterval;
    }
  }
  let packedLength;
  let unwrappedInterval;
  let unwrappedIntervalLength;
  const isValue = !defined_default(packetData.reference) && !defined_default(packetData.velocityReference);
  const hasInterval = defined_default(combinedInterval) && !combinedInterval.equals(Iso8601_default.MAXIMUM_INTERVAL);
  if (packetData.delete === true) {
    if (!hasInterval) {
      object2[propertyName] = void 0;
      return;
    }
    return removePropertyData(object2[propertyName], combinedInterval);
  }
  let isSampled = false;
  if (isValue) {
    unwrappedInterval = unwrapInterval(type, packetData, sourceUri);
    if (!defined_default(unwrappedInterval)) {
      return;
    }
    packedLength = defaultValue_default(type.packedLength, 1);
    unwrappedIntervalLength = defaultValue_default(unwrappedInterval.length, 1);
    isSampled = !defined_default(packetData.array) && typeof unwrappedInterval !== "string" && unwrappedIntervalLength > packedLength && type !== Object;
  }
  const needsUnpacking = typeof type.unpack === "function" && type !== Rotation_default;
  if (!isSampled && !hasInterval) {
    if (isValue) {
      object2[propertyName] = new ConstantProperty_default(
        needsUnpacking ? type.unpack(unwrappedInterval, 0) : unwrappedInterval
      );
    } else {
      object2[propertyName] = createSpecializedProperty(
        type,
        entityCollection,
        packetData
      );
    }
    return;
  }
  let property = object2[propertyName];
  let epoch2;
  const packetEpoch = packetData.epoch;
  if (defined_default(packetEpoch)) {
    epoch2 = JulianDate_default.fromIso8601(packetEpoch);
  }
  if (isSampled && !hasInterval) {
    if (!(property instanceof SampledProperty_default)) {
      object2[propertyName] = property = new SampledProperty_default(type);
    }
    property.addSamplesPackedArray(unwrappedInterval, epoch2);
    updateInterpolationSettings(packetData, property);
    return;
  }
  let interval;
  if (!isSampled && hasInterval) {
    combinedInterval = combinedInterval.clone();
    if (isValue) {
      combinedInterval.data = needsUnpacking ? type.unpack(unwrappedInterval, 0) : unwrappedInterval;
    } else {
      combinedInterval.data = createSpecializedProperty(
        type,
        entityCollection,
        packetData
      );
    }
    if (!defined_default(property)) {
      object2[propertyName] = property = isValue ? new TimeIntervalCollectionProperty_default() : new CompositeProperty_default();
    }
    if (isValue && property instanceof TimeIntervalCollectionProperty_default) {
      property.intervals.addInterval(combinedInterval);
    } else if (property instanceof CompositeProperty_default) {
      if (isValue) {
        combinedInterval.data = new ConstantProperty_default(combinedInterval.data);
      }
      property.intervals.addInterval(combinedInterval);
    } else {
      object2[propertyName] = property = convertPropertyToComposite(property);
      if (isValue) {
        combinedInterval.data = new ConstantProperty_default(combinedInterval.data);
      }
      property.intervals.addInterval(combinedInterval);
    }
    return;
  }
  if (!defined_default(property)) {
    object2[propertyName] = property = new CompositeProperty_default();
  }
  if (!(property instanceof CompositeProperty_default)) {
    object2[propertyName] = property = convertPropertyToComposite(property);
  }
  const intervals = property.intervals;
  interval = intervals.findInterval(combinedInterval);
  if (!defined_default(interval) || !(interval.data instanceof SampledProperty_default)) {
    interval = combinedInterval.clone();
    interval.data = new SampledProperty_default(type);
    intervals.addInterval(interval);
  }
  interval.data.addSamplesPackedArray(unwrappedInterval, epoch2);
  updateInterpolationSettings(packetData, interval.data);
}
function removePropertyData(property, interval) {
  if (property instanceof SampledProperty_default) {
    property.removeSamples(interval);
    return;
  } else if (property instanceof TimeIntervalCollectionProperty_default) {
    property.intervals.removeInterval(interval);
    return;
  } else if (property instanceof CompositeProperty_default) {
    const intervals = property.intervals;
    for (let i2 = 0; i2 < intervals.length; ++i2) {
      const intersection = TimeInterval_default.intersect(
        intervals.get(i2),
        interval,
        scratchTimeInterval
      );
      if (!intersection.isEmpty) {
        removePropertyData(intersection.data, interval);
      }
    }
    intervals.removeInterval(interval);
    return;
  }
}
function processPacketData(type, object2, propertyName, packetData, interval, sourceUri, entityCollection) {
  if (!defined_default(packetData)) {
    return;
  }
  if (Array.isArray(packetData)) {
    for (let i2 = 0, len = packetData.length; i2 < len; ++i2) {
      processProperty(
        type,
        object2,
        propertyName,
        packetData[i2],
        interval,
        sourceUri,
        entityCollection
      );
    }
  } else {
    processProperty(
      type,
      object2,
      propertyName,
      packetData,
      interval,
      sourceUri,
      entityCollection
    );
  }
}
function processPositionProperty(object2, propertyName, packetData, constrainedInterval, sourceUri, entityCollection) {
  let combinedInterval = intervalFromString(packetData.interval);
  if (defined_default(constrainedInterval)) {
    if (defined_default(combinedInterval)) {
      combinedInterval = TimeInterval_default.intersect(
        combinedInterval,
        constrainedInterval,
        scratchTimeInterval
      );
    } else {
      combinedInterval = constrainedInterval;
    }
  }
  const numberOfDerivatives = defined_default(packetData.cartesianVelocity) ? 1 : 0;
  const packedLength = Cartesian3_default.packedLength * (numberOfDerivatives + 1);
  let unwrappedInterval;
  let unwrappedIntervalLength;
  const isValue = !defined_default(packetData.reference);
  const hasInterval = defined_default(combinedInterval) && !combinedInterval.equals(Iso8601_default.MAXIMUM_INTERVAL);
  if (packetData.delete === true) {
    if (!hasInterval) {
      object2[propertyName] = void 0;
      return;
    }
    return removePositionPropertyData(object2[propertyName], combinedInterval);
  }
  let referenceFrame;
  let isSampled = false;
  if (isValue) {
    if (defined_default(packetData.referenceFrame)) {
      referenceFrame = ReferenceFrame_default[packetData.referenceFrame];
    }
    referenceFrame = defaultValue_default(referenceFrame, ReferenceFrame_default.FIXED);
    unwrappedInterval = unwrapCartesianInterval(packetData);
    unwrappedIntervalLength = defaultValue_default(unwrappedInterval.length, 1);
    isSampled = unwrappedIntervalLength > packedLength;
  }
  if (!isSampled && !hasInterval) {
    if (isValue) {
      object2[propertyName] = new ConstantPositionProperty_default(
        Cartesian3_default.unpack(unwrappedInterval),
        referenceFrame
      );
    } else {
      object2[propertyName] = createReferenceProperty(
        entityCollection,
        packetData.reference
      );
    }
    return;
  }
  let property = object2[propertyName];
  let epoch2;
  const packetEpoch = packetData.epoch;
  if (defined_default(packetEpoch)) {
    epoch2 = JulianDate_default.fromIso8601(packetEpoch);
  }
  if (isSampled && !hasInterval) {
    if (!(property instanceof SampledPositionProperty_default) || defined_default(referenceFrame) && property.referenceFrame !== referenceFrame) {
      object2[propertyName] = property = new SampledPositionProperty_default(
        referenceFrame,
        numberOfDerivatives
      );
    }
    property.addSamplesPackedArray(unwrappedInterval, epoch2);
    updateInterpolationSettings(packetData, property);
    return;
  }
  let interval;
  if (!isSampled && hasInterval) {
    combinedInterval = combinedInterval.clone();
    if (isValue) {
      combinedInterval.data = Cartesian3_default.unpack(unwrappedInterval);
    } else {
      combinedInterval.data = createReferenceProperty(
        entityCollection,
        packetData.reference
      );
    }
    if (!defined_default(property)) {
      if (isValue) {
        property = new TimeIntervalCollectionPositionProperty_default(referenceFrame);
      } else {
        property = new CompositePositionProperty_default(referenceFrame);
      }
      object2[propertyName] = property;
    }
    if (isValue && property instanceof TimeIntervalCollectionPositionProperty_default && defined_default(referenceFrame) && property.referenceFrame === referenceFrame) {
      property.intervals.addInterval(combinedInterval);
    } else if (property instanceof CompositePositionProperty_default) {
      if (isValue) {
        combinedInterval.data = new ConstantPositionProperty_default(
          combinedInterval.data,
          referenceFrame
        );
      }
      property.intervals.addInterval(combinedInterval);
    } else {
      object2[propertyName] = property = convertPositionPropertyToComposite(
        property
      );
      if (isValue) {
        combinedInterval.data = new ConstantPositionProperty_default(
          combinedInterval.data,
          referenceFrame
        );
      }
      property.intervals.addInterval(combinedInterval);
    }
    return;
  }
  if (!defined_default(property)) {
    object2[propertyName] = property = new CompositePositionProperty_default(
      referenceFrame
    );
  } else if (!(property instanceof CompositePositionProperty_default)) {
    object2[propertyName] = property = convertPositionPropertyToComposite(
      property
    );
  }
  const intervals = property.intervals;
  interval = intervals.findInterval(combinedInterval);
  if (!defined_default(interval) || !(interval.data instanceof SampledPositionProperty_default) || defined_default(referenceFrame) && interval.data.referenceFrame !== referenceFrame) {
    interval = combinedInterval.clone();
    interval.data = new SampledPositionProperty_default(
      referenceFrame,
      numberOfDerivatives
    );
    intervals.addInterval(interval);
  }
  interval.data.addSamplesPackedArray(unwrappedInterval, epoch2);
  updateInterpolationSettings(packetData, interval.data);
}
function removePositionPropertyData(property, interval) {
  if (property instanceof SampledPositionProperty_default) {
    property.removeSamples(interval);
    return;
  } else if (property instanceof TimeIntervalCollectionPositionProperty_default) {
    property.intervals.removeInterval(interval);
    return;
  } else if (property instanceof CompositePositionProperty_default) {
    const intervals = property.intervals;
    for (let i2 = 0; i2 < intervals.length; ++i2) {
      const intersection = TimeInterval_default.intersect(
        intervals.get(i2),
        interval,
        scratchTimeInterval
      );
      if (!intersection.isEmpty) {
        removePositionPropertyData(intersection.data, interval);
      }
    }
    intervals.removeInterval(interval);
    return;
  }
}
function processPositionPacketData(object2, propertyName, packetData, interval, sourceUri, entityCollection) {
  if (!defined_default(packetData)) {
    return;
  }
  if (Array.isArray(packetData)) {
    for (let i2 = 0, len = packetData.length; i2 < len; ++i2) {
      processPositionProperty(
        object2,
        propertyName,
        packetData[i2],
        interval,
        sourceUri,
        entityCollection
      );
    }
  } else {
    processPositionProperty(
      object2,
      propertyName,
      packetData,
      interval,
      sourceUri,
      entityCollection
    );
  }
}
function processShapePacketData(object2, propertyName, packetData, entityCollection) {
  if (defined_default(packetData.references)) {
    processReferencesArrayPacketData(
      object2,
      propertyName,
      packetData.references,
      packetData.interval,
      entityCollection,
      PropertyArray_default,
      CompositeProperty_default
    );
  } else {
    if (defined_default(packetData.cartesian2)) {
      packetData.array = Cartesian2_default.unpackArray(packetData.cartesian2);
    } else if (defined_default(packetData.cartesian)) {
      packetData.array = Cartesian2_default.unpackArray(packetData.cartesian);
    }
    if (defined_default(packetData.array)) {
      processPacketData(
        Array,
        object2,
        propertyName,
        packetData,
        void 0,
        void 0,
        entityCollection
      );
    }
  }
}
function processMaterialProperty(object2, propertyName, packetData, constrainedInterval, sourceUri, entityCollection) {
  let combinedInterval = intervalFromString(packetData.interval);
  if (defined_default(constrainedInterval)) {
    if (defined_default(combinedInterval)) {
      combinedInterval = TimeInterval_default.intersect(
        combinedInterval,
        constrainedInterval,
        scratchTimeInterval
      );
    } else {
      combinedInterval = constrainedInterval;
    }
  }
  let property = object2[propertyName];
  let existingMaterial;
  let existingInterval;
  if (defined_default(combinedInterval)) {
    if (!(property instanceof CompositeMaterialProperty_default)) {
      property = new CompositeMaterialProperty_default();
      object2[propertyName] = property;
    }
    const thisIntervals = property.intervals;
    existingInterval = thisIntervals.findInterval({
      start: combinedInterval.start,
      stop: combinedInterval.stop
    });
    if (defined_default(existingInterval)) {
      existingMaterial = existingInterval.data;
    } else {
      existingInterval = combinedInterval.clone();
      thisIntervals.addInterval(existingInterval);
    }
  } else {
    existingMaterial = property;
  }
  let materialData;
  if (defined_default(packetData.solidColor)) {
    if (!(existingMaterial instanceof ColorMaterialProperty_default)) {
      existingMaterial = new ColorMaterialProperty_default();
    }
    materialData = packetData.solidColor;
    processPacketData(
      Color_default,
      existingMaterial,
      "color",
      materialData.color,
      void 0,
      void 0,
      entityCollection
    );
  } else if (defined_default(packetData.grid)) {
    if (!(existingMaterial instanceof GridMaterialProperty_default)) {
      existingMaterial = new GridMaterialProperty_default();
    }
    materialData = packetData.grid;
    processPacketData(
      Color_default,
      existingMaterial,
      "color",
      materialData.color,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Number,
      existingMaterial,
      "cellAlpha",
      materialData.cellAlpha,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Cartesian2_default,
      existingMaterial,
      "lineCount",
      materialData.lineCount,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Cartesian2_default,
      existingMaterial,
      "lineThickness",
      materialData.lineThickness,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Cartesian2_default,
      existingMaterial,
      "lineOffset",
      materialData.lineOffset,
      void 0,
      sourceUri,
      entityCollection
    );
  } else if (defined_default(packetData.image)) {
    if (!(existingMaterial instanceof ImageMaterialProperty_default)) {
      existingMaterial = new ImageMaterialProperty_default();
    }
    materialData = packetData.image;
    processPacketData(
      Image,
      existingMaterial,
      "image",
      materialData.image,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Cartesian2_default,
      existingMaterial,
      "repeat",
      materialData.repeat,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Color_default,
      existingMaterial,
      "color",
      materialData.color,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Boolean,
      existingMaterial,
      "transparent",
      materialData.transparent,
      void 0,
      sourceUri,
      entityCollection
    );
  } else if (defined_default(packetData.stripe)) {
    if (!(existingMaterial instanceof StripeMaterialProperty_default)) {
      existingMaterial = new StripeMaterialProperty_default();
    }
    materialData = packetData.stripe;
    processPacketData(
      StripeOrientation_default,
      existingMaterial,
      "orientation",
      materialData.orientation,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Color_default,
      existingMaterial,
      "evenColor",
      materialData.evenColor,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Color_default,
      existingMaterial,
      "oddColor",
      materialData.oddColor,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Number,
      existingMaterial,
      "offset",
      materialData.offset,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Number,
      existingMaterial,
      "repeat",
      materialData.repeat,
      void 0,
      sourceUri,
      entityCollection
    );
  } else if (defined_default(packetData.polylineOutline)) {
    if (!(existingMaterial instanceof PolylineOutlineMaterialProperty_default)) {
      existingMaterial = new PolylineOutlineMaterialProperty_default();
    }
    materialData = packetData.polylineOutline;
    processPacketData(
      Color_default,
      existingMaterial,
      "color",
      materialData.color,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Color_default,
      existingMaterial,
      "outlineColor",
      materialData.outlineColor,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Number,
      existingMaterial,
      "outlineWidth",
      materialData.outlineWidth,
      void 0,
      sourceUri,
      entityCollection
    );
  } else if (defined_default(packetData.polylineGlow)) {
    if (!(existingMaterial instanceof PolylineGlowMaterialProperty_default)) {
      existingMaterial = new PolylineGlowMaterialProperty_default();
    }
    materialData = packetData.polylineGlow;
    processPacketData(
      Color_default,
      existingMaterial,
      "color",
      materialData.color,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Number,
      existingMaterial,
      "glowPower",
      materialData.glowPower,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Number,
      existingMaterial,
      "taperPower",
      materialData.taperPower,
      void 0,
      sourceUri,
      entityCollection
    );
  } else if (defined_default(packetData.polylineArrow)) {
    if (!(existingMaterial instanceof PolylineArrowMaterialProperty_default)) {
      existingMaterial = new PolylineArrowMaterialProperty_default();
    }
    materialData = packetData.polylineArrow;
    processPacketData(
      Color_default,
      existingMaterial,
      "color",
      materialData.color,
      void 0,
      void 0,
      entityCollection
    );
  } else if (defined_default(packetData.polylineDash)) {
    if (!(existingMaterial instanceof PolylineDashMaterialProperty_default)) {
      existingMaterial = new PolylineDashMaterialProperty_default();
    }
    materialData = packetData.polylineDash;
    processPacketData(
      Color_default,
      existingMaterial,
      "color",
      materialData.color,
      void 0,
      void 0,
      entityCollection
    );
    processPacketData(
      Color_default,
      existingMaterial,
      "gapColor",
      materialData.gapColor,
      void 0,
      void 0,
      entityCollection
    );
    processPacketData(
      Number,
      existingMaterial,
      "dashLength",
      materialData.dashLength,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Number,
      existingMaterial,
      "dashPattern",
      materialData.dashPattern,
      void 0,
      sourceUri,
      entityCollection
    );
  } else if (defined_default(packetData.checkerboard)) {
    if (!(existingMaterial instanceof CheckerboardMaterialProperty_default)) {
      existingMaterial = new CheckerboardMaterialProperty_default();
    }
    materialData = packetData.checkerboard;
    processPacketData(
      Color_default,
      existingMaterial,
      "evenColor",
      materialData.evenColor,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Color_default,
      existingMaterial,
      "oddColor",
      materialData.oddColor,
      void 0,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Cartesian2_default,
      existingMaterial,
      "repeat",
      materialData.repeat,
      void 0,
      sourceUri,
      entityCollection
    );
  }
  if (defined_default(existingInterval)) {
    existingInterval.data = existingMaterial;
  } else {
    object2[propertyName] = existingMaterial;
  }
}
function processMaterialPacketData(object2, propertyName, packetData, interval, sourceUri, entityCollection) {
  if (!defined_default(packetData)) {
    return;
  }
  if (Array.isArray(packetData)) {
    for (let i2 = 0, len = packetData.length; i2 < len; ++i2) {
      processMaterialProperty(
        object2,
        propertyName,
        packetData[i2],
        interval,
        sourceUri,
        entityCollection
      );
    }
  } else {
    processMaterialProperty(
      object2,
      propertyName,
      packetData,
      interval,
      sourceUri,
      entityCollection
    );
  }
}
function processName(entity, packet, entityCollection, sourceUri) {
  const nameData = packet.name;
  if (defined_default(nameData)) {
    entity.name = packet.name;
  }
}
function processDescription(entity, packet, entityCollection, sourceUri) {
  const descriptionData = packet.description;
  if (defined_default(descriptionData)) {
    processPacketData(
      String,
      entity,
      "description",
      descriptionData,
      void 0,
      sourceUri,
      entityCollection
    );
  }
}
function processPosition(entity, packet, entityCollection, sourceUri) {
  const positionData = packet.position;
  if (defined_default(positionData)) {
    processPositionPacketData(
      entity,
      "position",
      positionData,
      void 0,
      sourceUri,
      entityCollection
    );
  }
}
function processViewFrom(entity, packet, entityCollection, sourceUri) {
  const viewFromData = packet.viewFrom;
  if (defined_default(viewFromData)) {
    processPacketData(
      Cartesian3_default,
      entity,
      "viewFrom",
      viewFromData,
      void 0,
      sourceUri,
      entityCollection
    );
  }
}
function processOrientation(entity, packet, entityCollection, sourceUri) {
  const orientationData = packet.orientation;
  if (defined_default(orientationData)) {
    processPacketData(
      Quaternion_default,
      entity,
      "orientation",
      orientationData,
      void 0,
      sourceUri,
      entityCollection
    );
  }
}
function processProperties(entity, packet, entityCollection, sourceUri) {
  const propertiesData = packet.properties;
  if (defined_default(propertiesData)) {
    if (!defined_default(entity.properties)) {
      entity.properties = new PropertyBag_default();
    }
    for (const key in propertiesData) {
      if (propertiesData.hasOwnProperty(key)) {
        if (!entity.properties.hasProperty(key)) {
          entity.properties.addProperty(key);
        }
        const propertyData = propertiesData[key];
        if (Array.isArray(propertyData)) {
          for (let i2 = 0, len = propertyData.length; i2 < len; ++i2) {
            processProperty(
              getPropertyType(propertyData[i2]),
              entity.properties,
              key,
              propertyData[i2],
              void 0,
              sourceUri,
              entityCollection
            );
          }
        } else {
          processProperty(
            getPropertyType(propertyData),
            entity.properties,
            key,
            propertyData,
            void 0,
            sourceUri,
            entityCollection
          );
        }
      }
    }
  }
}
function processReferencesArrayPacketData(object2, propertyName, references, interval, entityCollection, PropertyArrayType, CompositePropertyArrayType) {
  const properties = references.map(function(reference) {
    return createReferenceProperty(entityCollection, reference);
  });
  if (defined_default(interval)) {
    interval = intervalFromString(interval);
    let property = object2[propertyName];
    if (!(property instanceof CompositePropertyArrayType)) {
      const composite = new CompositePropertyArrayType();
      composite.intervals.addInterval(wrapPropertyInInfiniteInterval(property));
      object2[propertyName] = property = composite;
    }
    interval.data = new PropertyArrayType(properties);
    property.intervals.addInterval(interval);
  } else {
    object2[propertyName] = new PropertyArrayType(properties);
  }
}
function processArrayPacketData(object2, propertyName, packetData, entityCollection) {
  const references = packetData.references;
  if (defined_default(references)) {
    processReferencesArrayPacketData(
      object2,
      propertyName,
      references,
      packetData.interval,
      entityCollection,
      PropertyArray_default,
      CompositeProperty_default
    );
  } else {
    processPacketData(
      Array,
      object2,
      propertyName,
      packetData,
      void 0,
      void 0,
      entityCollection
    );
  }
}
function processArray(object2, propertyName, packetData, entityCollection) {
  if (!defined_default(packetData)) {
    return;
  }
  if (Array.isArray(packetData)) {
    for (let i2 = 0, length3 = packetData.length; i2 < length3; ++i2) {
      processArrayPacketData(
        object2,
        propertyName,
        packetData[i2],
        entityCollection
      );
    }
  } else {
    processArrayPacketData(object2, propertyName, packetData, entityCollection);
  }
}
function processPositionArrayPacketData(object2, propertyName, packetData, entityCollection) {
  const references = packetData.references;
  if (defined_default(references)) {
    processReferencesArrayPacketData(
      object2,
      propertyName,
      references,
      packetData.interval,
      entityCollection,
      PositionPropertyArray_default,
      CompositePositionProperty_default
    );
  } else {
    if (defined_default(packetData.cartesian)) {
      packetData.array = Cartesian3_default.unpackArray(packetData.cartesian);
    } else if (defined_default(packetData.cartographicRadians)) {
      packetData.array = Cartesian3_default.fromRadiansArrayHeights(
        packetData.cartographicRadians
      );
    } else if (defined_default(packetData.cartographicDegrees)) {
      packetData.array = Cartesian3_default.fromDegreesArrayHeights(
        packetData.cartographicDegrees
      );
    }
    if (defined_default(packetData.array)) {
      processPacketData(
        Array,
        object2,
        propertyName,
        packetData,
        void 0,
        void 0,
        entityCollection
      );
    }
  }
}
function processPositionArray(object2, propertyName, packetData, entityCollection) {
  if (!defined_default(packetData)) {
    return;
  }
  if (Array.isArray(packetData)) {
    for (let i2 = 0, length3 = packetData.length; i2 < length3; ++i2) {
      processPositionArrayPacketData(
        object2,
        propertyName,
        packetData[i2],
        entityCollection
      );
    }
  } else {
    processPositionArrayPacketData(
      object2,
      propertyName,
      packetData,
      entityCollection
    );
  }
}
function unpackCartesianArray(array) {
  return Cartesian3_default.unpackArray(array);
}
function unpackCartographicRadiansArray(array) {
  return Cartesian3_default.fromRadiansArrayHeights(array);
}
function unpackCartographicDegreesArray(array) {
  return Cartesian3_default.fromDegreesArrayHeights(array);
}
function processPositionArrayOfArraysPacketData(object2, propertyName, packetData, entityCollection) {
  const references = packetData.references;
  if (defined_default(references)) {
    const properties = references.map(function(referenceArray) {
      const tempObj = {};
      processReferencesArrayPacketData(
        tempObj,
        "positions",
        referenceArray,
        packetData.interval,
        entityCollection,
        PositionPropertyArray_default,
        CompositePositionProperty_default
      );
      return tempObj.positions;
    });
    object2[propertyName] = new PositionPropertyArray_default(properties);
  } else {
    if (defined_default(packetData.cartesian)) {
      packetData.array = packetData.cartesian.map(unpackCartesianArray);
    } else if (defined_default(packetData.cartographicRadians)) {
      packetData.array = packetData.cartographicRadians.map(
        unpackCartographicRadiansArray
      );
    } else if (defined_default(packetData.cartographicDegrees)) {
      packetData.array = packetData.cartographicDegrees.map(
        unpackCartographicDegreesArray
      );
    }
    if (defined_default(packetData.array)) {
      processPacketData(
        Array,
        object2,
        propertyName,
        packetData,
        void 0,
        void 0,
        entityCollection
      );
    }
  }
}
function processPositionArrayOfArrays(object2, propertyName, packetData, entityCollection) {
  if (!defined_default(packetData)) {
    return;
  }
  if (Array.isArray(packetData)) {
    for (let i2 = 0, length3 = packetData.length; i2 < length3; ++i2) {
      processPositionArrayOfArraysPacketData(
        object2,
        propertyName,
        packetData[i2],
        entityCollection
      );
    }
  } else {
    processPositionArrayOfArraysPacketData(
      object2,
      propertyName,
      packetData,
      entityCollection
    );
  }
}
function processShape(object2, propertyName, packetData, entityCollection) {
  if (!defined_default(packetData)) {
    return;
  }
  if (Array.isArray(packetData)) {
    for (let i2 = 0, length3 = packetData.length; i2 < length3; i2++) {
      processShapePacketData(
        object2,
        propertyName,
        packetData[i2],
        entityCollection
      );
    }
  } else {
    processShapePacketData(object2, propertyName, packetData, entityCollection);
  }
}
function processAvailability(entity, packet, entityCollection, sourceUri) {
  const packetData = packet.availability;
  if (!defined_default(packetData)) {
    return;
  }
  let intervals;
  if (Array.isArray(packetData)) {
    for (let i2 = 0, len = packetData.length; i2 < len; ++i2) {
      if (!defined_default(intervals)) {
        intervals = new TimeIntervalCollection_default();
      }
      intervals.addInterval(intervalFromString(packetData[i2]));
    }
  } else {
    intervals = new TimeIntervalCollection_default();
    intervals.addInterval(intervalFromString(packetData));
  }
  entity.availability = intervals;
}
function processAlignedAxis(billboard, packetData, interval, sourceUri, entityCollection) {
  if (!defined_default(packetData)) {
    return;
  }
  processPacketData(
    UnitCartesian3,
    billboard,
    "alignedAxis",
    packetData,
    interval,
    sourceUri,
    entityCollection
  );
}
function processBillboard(entity, packet, entityCollection, sourceUri) {
  const billboardData = packet.billboard;
  if (!defined_default(billboardData)) {
    return;
  }
  const interval = intervalFromString(billboardData.interval);
  let billboard = entity.billboard;
  if (!defined_default(billboard)) {
    entity.billboard = billboard = new BillboardGraphics_default();
  }
  processPacketData(
    Boolean,
    billboard,
    "show",
    billboardData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Image,
    billboard,
    "image",
    billboardData.image,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    billboard,
    "scale",
    billboardData.scale,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Cartesian2_default,
    billboard,
    "pixelOffset",
    billboardData.pixelOffset,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Cartesian3_default,
    billboard,
    "eyeOffset",
    billboardData.eyeOffset,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HorizontalOrigin_default,
    billboard,
    "horizontalOrigin",
    billboardData.horizontalOrigin,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    VerticalOrigin_default,
    billboard,
    "verticalOrigin",
    billboardData.verticalOrigin,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    billboard,
    "heightReference",
    billboardData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    billboard,
    "color",
    billboardData.color,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Rotation_default,
    billboard,
    "rotation",
    billboardData.rotation,
    interval,
    sourceUri,
    entityCollection
  );
  processAlignedAxis(
    billboard,
    billboardData.alignedAxis,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    billboard,
    "sizeInMeters",
    billboardData.sizeInMeters,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    billboard,
    "width",
    billboardData.width,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    billboard,
    "height",
    billboardData.height,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    NearFarScalar_default,
    billboard,
    "scaleByDistance",
    billboardData.scaleByDistance,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    NearFarScalar_default,
    billboard,
    "translucencyByDistance",
    billboardData.translucencyByDistance,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    NearFarScalar_default,
    billboard,
    "pixelOffsetScaleByDistance",
    billboardData.pixelOffsetScaleByDistance,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    BoundingRectangle_default,
    billboard,
    "imageSubRegion",
    billboardData.imageSubRegion,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    billboard,
    "distanceDisplayCondition",
    billboardData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    billboard,
    "disableDepthTestDistance",
    billboardData.disableDepthTestDistance,
    interval,
    sourceUri,
    entityCollection
  );
}
function processBox(entity, packet, entityCollection, sourceUri) {
  const boxData = packet.box;
  if (!defined_default(boxData)) {
    return;
  }
  const interval = intervalFromString(boxData.interval);
  let box = entity.box;
  if (!defined_default(box)) {
    entity.box = box = new BoxGraphics_default();
  }
  processPacketData(
    Boolean,
    box,
    "show",
    boxData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Cartesian3_default,
    box,
    "dimensions",
    boxData.dimensions,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    box,
    "heightReference",
    boxData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    box,
    "fill",
    boxData.fill,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    box,
    "material",
    boxData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    box,
    "outline",
    boxData.outline,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    box,
    "outlineColor",
    boxData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    box,
    "outlineWidth",
    boxData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    box,
    "shadows",
    boxData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    box,
    "distanceDisplayCondition",
    boxData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
}
function processCorridor(entity, packet, entityCollection, sourceUri) {
  const corridorData = packet.corridor;
  if (!defined_default(corridorData)) {
    return;
  }
  const interval = intervalFromString(corridorData.interval);
  let corridor = entity.corridor;
  if (!defined_default(corridor)) {
    entity.corridor = corridor = new CorridorGraphics_default();
  }
  processPacketData(
    Boolean,
    corridor,
    "show",
    corridorData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPositionArray(
    corridor,
    "positions",
    corridorData.positions,
    entityCollection
  );
  processPacketData(
    Number,
    corridor,
    "width",
    corridorData.width,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    corridor,
    "height",
    corridorData.height,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    corridor,
    "heightReference",
    corridorData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    corridor,
    "extrudedHeight",
    corridorData.extrudedHeight,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    corridor,
    "extrudedHeightReference",
    corridorData.extrudedHeightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    CornerType_default,
    corridor,
    "cornerType",
    corridorData.cornerType,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    corridor,
    "granularity",
    corridorData.granularity,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    corridor,
    "fill",
    corridorData.fill,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    corridor,
    "material",
    corridorData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    corridor,
    "outline",
    corridorData.outline,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    corridor,
    "outlineColor",
    corridorData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    corridor,
    "outlineWidth",
    corridorData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    corridor,
    "shadows",
    corridorData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    corridor,
    "distanceDisplayCondition",
    corridorData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ClassificationType_default,
    corridor,
    "classificationType",
    corridorData.classificationType,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    corridor,
    "zIndex",
    corridorData.zIndex,
    interval,
    sourceUri,
    entityCollection
  );
}
function processCylinder(entity, packet, entityCollection, sourceUri) {
  const cylinderData = packet.cylinder;
  if (!defined_default(cylinderData)) {
    return;
  }
  const interval = intervalFromString(cylinderData.interval);
  let cylinder = entity.cylinder;
  if (!defined_default(cylinder)) {
    entity.cylinder = cylinder = new CylinderGraphics_default();
  }
  processPacketData(
    Boolean,
    cylinder,
    "show",
    cylinderData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    cylinder,
    "length",
    cylinderData.length,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    cylinder,
    "topRadius",
    cylinderData.topRadius,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    cylinder,
    "bottomRadius",
    cylinderData.bottomRadius,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    cylinder,
    "heightReference",
    cylinderData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    cylinder,
    "fill",
    cylinderData.fill,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    cylinder,
    "material",
    cylinderData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    cylinder,
    "outline",
    cylinderData.outline,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    cylinder,
    "outlineColor",
    cylinderData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    cylinder,
    "outlineWidth",
    cylinderData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    cylinder,
    "numberOfVerticalLines",
    cylinderData.numberOfVerticalLines,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    cylinder,
    "slices",
    cylinderData.slices,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    cylinder,
    "shadows",
    cylinderData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    cylinder,
    "distanceDisplayCondition",
    cylinderData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
}
function processDocument(packet, dataSource) {
  const version = packet.version;
  if (defined_default(version)) {
    if (typeof version === "string") {
      const tokens = version.split(".");
      if (tokens.length === 2) {
        if (tokens[0] !== "1") {
          throw new RuntimeError_default("Cesium only supports CZML version 1.");
        }
        dataSource._version = version;
      }
    }
  }
  if (!defined_default(dataSource._version)) {
    throw new RuntimeError_default(
      "CZML version information invalid.  It is expected to be a property on the document object in the <Major>.<Minor> version format."
    );
  }
  const documentPacket = dataSource._documentPacket;
  if (defined_default(packet.name)) {
    documentPacket.name = packet.name;
  }
  const clockPacket = packet.clock;
  if (defined_default(clockPacket)) {
    const clock = documentPacket.clock;
    if (!defined_default(clock)) {
      documentPacket.clock = {
        interval: clockPacket.interval,
        currentTime: clockPacket.currentTime,
        range: clockPacket.range,
        step: clockPacket.step,
        multiplier: clockPacket.multiplier
      };
    } else {
      clock.interval = defaultValue_default(clockPacket.interval, clock.interval);
      clock.currentTime = defaultValue_default(
        clockPacket.currentTime,
        clock.currentTime
      );
      clock.range = defaultValue_default(clockPacket.range, clock.range);
      clock.step = defaultValue_default(clockPacket.step, clock.step);
      clock.multiplier = defaultValue_default(clockPacket.multiplier, clock.multiplier);
    }
  }
}
function processEllipse(entity, packet, entityCollection, sourceUri) {
  const ellipseData = packet.ellipse;
  if (!defined_default(ellipseData)) {
    return;
  }
  const interval = intervalFromString(ellipseData.interval);
  let ellipse = entity.ellipse;
  if (!defined_default(ellipse)) {
    entity.ellipse = ellipse = new EllipseGraphics_default();
  }
  processPacketData(
    Boolean,
    ellipse,
    "show",
    ellipseData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipse,
    "semiMajorAxis",
    ellipseData.semiMajorAxis,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipse,
    "semiMinorAxis",
    ellipseData.semiMinorAxis,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipse,
    "height",
    ellipseData.height,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    ellipse,
    "heightReference",
    ellipseData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipse,
    "extrudedHeight",
    ellipseData.extrudedHeight,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    ellipse,
    "extrudedHeightReference",
    ellipseData.extrudedHeightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Rotation_default,
    ellipse,
    "rotation",
    ellipseData.rotation,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Rotation_default,
    ellipse,
    "stRotation",
    ellipseData.stRotation,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipse,
    "granularity",
    ellipseData.granularity,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    ellipse,
    "fill",
    ellipseData.fill,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    ellipse,
    "material",
    ellipseData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    ellipse,
    "outline",
    ellipseData.outline,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    ellipse,
    "outlineColor",
    ellipseData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipse,
    "outlineWidth",
    ellipseData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipse,
    "numberOfVerticalLines",
    ellipseData.numberOfVerticalLines,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    ellipse,
    "shadows",
    ellipseData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    ellipse,
    "distanceDisplayCondition",
    ellipseData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ClassificationType_default,
    ellipse,
    "classificationType",
    ellipseData.classificationType,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipse,
    "zIndex",
    ellipseData.zIndex,
    interval,
    sourceUri,
    entityCollection
  );
}
function processEllipsoid(entity, packet, entityCollection, sourceUri) {
  const ellipsoidData = packet.ellipsoid;
  if (!defined_default(ellipsoidData)) {
    return;
  }
  const interval = intervalFromString(ellipsoidData.interval);
  let ellipsoid = entity.ellipsoid;
  if (!defined_default(ellipsoid)) {
    entity.ellipsoid = ellipsoid = new EllipsoidGraphics_default();
  }
  processPacketData(
    Boolean,
    ellipsoid,
    "show",
    ellipsoidData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Cartesian3_default,
    ellipsoid,
    "radii",
    ellipsoidData.radii,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Cartesian3_default,
    ellipsoid,
    "innerRadii",
    ellipsoidData.innerRadii,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipsoid,
    "minimumClock",
    ellipsoidData.minimumClock,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipsoid,
    "maximumClock",
    ellipsoidData.maximumClock,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipsoid,
    "minimumCone",
    ellipsoidData.minimumCone,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipsoid,
    "maximumCone",
    ellipsoidData.maximumCone,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    ellipsoid,
    "heightReference",
    ellipsoidData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    ellipsoid,
    "fill",
    ellipsoidData.fill,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    ellipsoid,
    "material",
    ellipsoidData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    ellipsoid,
    "outline",
    ellipsoidData.outline,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    ellipsoid,
    "outlineColor",
    ellipsoidData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipsoid,
    "outlineWidth",
    ellipsoidData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipsoid,
    "stackPartitions",
    ellipsoidData.stackPartitions,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipsoid,
    "slicePartitions",
    ellipsoidData.slicePartitions,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    ellipsoid,
    "subdivisions",
    ellipsoidData.subdivisions,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    ellipsoid,
    "shadows",
    ellipsoidData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    ellipsoid,
    "distanceDisplayCondition",
    ellipsoidData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
}
function processLabel(entity, packet, entityCollection, sourceUri) {
  const labelData = packet.label;
  if (!defined_default(labelData)) {
    return;
  }
  const interval = intervalFromString(labelData.interval);
  let label = entity.label;
  if (!defined_default(label)) {
    entity.label = label = new LabelGraphics_default();
  }
  processPacketData(
    Boolean,
    label,
    "show",
    labelData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    String,
    label,
    "text",
    labelData.text,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    String,
    label,
    "font",
    labelData.font,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    LabelStyle_default,
    label,
    "style",
    labelData.style,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    label,
    "scale",
    labelData.scale,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    label,
    "showBackground",
    labelData.showBackground,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    label,
    "backgroundColor",
    labelData.backgroundColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Cartesian2_default,
    label,
    "backgroundPadding",
    labelData.backgroundPadding,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Cartesian2_default,
    label,
    "pixelOffset",
    labelData.pixelOffset,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Cartesian3_default,
    label,
    "eyeOffset",
    labelData.eyeOffset,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HorizontalOrigin_default,
    label,
    "horizontalOrigin",
    labelData.horizontalOrigin,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    VerticalOrigin_default,
    label,
    "verticalOrigin",
    labelData.verticalOrigin,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    label,
    "heightReference",
    labelData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    label,
    "fillColor",
    labelData.fillColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    label,
    "outlineColor",
    labelData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    label,
    "outlineWidth",
    labelData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    NearFarScalar_default,
    label,
    "translucencyByDistance",
    labelData.translucencyByDistance,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    NearFarScalar_default,
    label,
    "pixelOffsetScaleByDistance",
    labelData.pixelOffsetScaleByDistance,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    NearFarScalar_default,
    label,
    "scaleByDistance",
    labelData.scaleByDistance,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    label,
    "distanceDisplayCondition",
    labelData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    label,
    "disableDepthTestDistance",
    labelData.disableDepthTestDistance,
    interval,
    sourceUri,
    entityCollection
  );
}
function processModel(entity, packet, entityCollection, sourceUri) {
  const modelData = packet.model;
  if (!defined_default(modelData)) {
    return;
  }
  const interval = intervalFromString(modelData.interval);
  let model = entity.model;
  if (!defined_default(model)) {
    entity.model = model = new ModelGraphics_default();
  }
  processPacketData(
    Boolean,
    model,
    "show",
    modelData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    URI,
    model,
    "uri",
    modelData.gltf,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    model,
    "scale",
    modelData.scale,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    model,
    "minimumPixelSize",
    modelData.minimumPixelSize,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    model,
    "maximumScale",
    modelData.maximumScale,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    model,
    "incrementallyLoadTextures",
    modelData.incrementallyLoadTextures,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    model,
    "runAnimations",
    modelData.runAnimations,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    model,
    "clampAnimations",
    modelData.clampAnimations,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    model,
    "shadows",
    modelData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    model,
    "heightReference",
    modelData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    model,
    "silhouetteColor",
    modelData.silhouetteColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    model,
    "silhouetteSize",
    modelData.silhouetteSize,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    model,
    "color",
    modelData.color,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ColorBlendMode_default,
    model,
    "colorBlendMode",
    modelData.colorBlendMode,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    model,
    "colorBlendAmount",
    modelData.colorBlendAmount,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    model,
    "distanceDisplayCondition",
    modelData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
  let i2, len;
  const nodeTransformationsData = modelData.nodeTransformations;
  if (defined_default(nodeTransformationsData)) {
    if (Array.isArray(nodeTransformationsData)) {
      for (i2 = 0, len = nodeTransformationsData.length; i2 < len; ++i2) {
        processNodeTransformations(
          model,
          nodeTransformationsData[i2],
          interval,
          sourceUri,
          entityCollection
        );
      }
    } else {
      processNodeTransformations(
        model,
        nodeTransformationsData,
        interval,
        sourceUri,
        entityCollection
      );
    }
  }
  const articulationsData = modelData.articulations;
  if (defined_default(articulationsData)) {
    if (Array.isArray(articulationsData)) {
      for (i2 = 0, len = articulationsData.length; i2 < len; ++i2) {
        processArticulations(
          model,
          articulationsData[i2],
          interval,
          sourceUri,
          entityCollection
        );
      }
    } else {
      processArticulations(
        model,
        articulationsData,
        interval,
        sourceUri,
        entityCollection
      );
    }
  }
}
function processNodeTransformations(model, nodeTransformationsData, constrainedInterval, sourceUri, entityCollection) {
  let combinedInterval = intervalFromString(nodeTransformationsData.interval);
  if (defined_default(constrainedInterval)) {
    if (defined_default(combinedInterval)) {
      combinedInterval = TimeInterval_default.intersect(
        combinedInterval,
        constrainedInterval,
        scratchTimeInterval
      );
    } else {
      combinedInterval = constrainedInterval;
    }
  }
  let nodeTransformations = model.nodeTransformations;
  const nodeNames = Object.keys(nodeTransformationsData);
  for (let i2 = 0, len = nodeNames.length; i2 < len; ++i2) {
    const nodeName = nodeNames[i2];
    if (nodeName === "interval") {
      continue;
    }
    const nodeTransformationData = nodeTransformationsData[nodeName];
    if (!defined_default(nodeTransformationData)) {
      continue;
    }
    if (!defined_default(nodeTransformations)) {
      model.nodeTransformations = nodeTransformations = new PropertyBag_default();
    }
    if (!nodeTransformations.hasProperty(nodeName)) {
      nodeTransformations.addProperty(nodeName);
    }
    let nodeTransformation = nodeTransformations[nodeName];
    if (!defined_default(nodeTransformation)) {
      nodeTransformations[nodeName] = nodeTransformation = new NodeTransformationProperty_default();
    }
    processPacketData(
      Cartesian3_default,
      nodeTransformation,
      "translation",
      nodeTransformationData.translation,
      combinedInterval,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Quaternion_default,
      nodeTransformation,
      "rotation",
      nodeTransformationData.rotation,
      combinedInterval,
      sourceUri,
      entityCollection
    );
    processPacketData(
      Cartesian3_default,
      nodeTransformation,
      "scale",
      nodeTransformationData.scale,
      combinedInterval,
      sourceUri,
      entityCollection
    );
  }
}
function processArticulations(model, articulationsData, constrainedInterval, sourceUri, entityCollection) {
  let combinedInterval = intervalFromString(articulationsData.interval);
  if (defined_default(constrainedInterval)) {
    if (defined_default(combinedInterval)) {
      combinedInterval = TimeInterval_default.intersect(
        combinedInterval,
        constrainedInterval,
        scratchTimeInterval
      );
    } else {
      combinedInterval = constrainedInterval;
    }
  }
  let articulations = model.articulations;
  const keys = Object.keys(articulationsData);
  for (let i2 = 0, len = keys.length; i2 < len; ++i2) {
    const key = keys[i2];
    if (key === "interval") {
      continue;
    }
    const articulationStageData = articulationsData[key];
    if (!defined_default(articulationStageData)) {
      continue;
    }
    if (!defined_default(articulations)) {
      model.articulations = articulations = new PropertyBag_default();
    }
    if (!articulations.hasProperty(key)) {
      articulations.addProperty(key);
    }
    processPacketData(
      Number,
      articulations,
      key,
      articulationStageData,
      combinedInterval,
      sourceUri,
      entityCollection
    );
  }
}
function processPath(entity, packet, entityCollection, sourceUri) {
  const pathData = packet.path;
  if (!defined_default(pathData)) {
    return;
  }
  const interval = intervalFromString(pathData.interval);
  let path = entity.path;
  if (!defined_default(path)) {
    entity.path = path = new PathGraphics_default();
  }
  processPacketData(
    Boolean,
    path,
    "show",
    pathData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    path,
    "leadTime",
    pathData.leadTime,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    path,
    "trailTime",
    pathData.trailTime,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    path,
    "width",
    pathData.width,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    path,
    "resolution",
    pathData.resolution,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    path,
    "material",
    pathData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    path,
    "distanceDisplayCondition",
    pathData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
}
function processPoint(entity, packet, entityCollection, sourceUri) {
  const pointData = packet.point;
  if (!defined_default(pointData)) {
    return;
  }
  const interval = intervalFromString(pointData.interval);
  let point = entity.point;
  if (!defined_default(point)) {
    entity.point = point = new PointGraphics_default();
  }
  processPacketData(
    Boolean,
    point,
    "show",
    pointData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    point,
    "pixelSize",
    pointData.pixelSize,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    point,
    "heightReference",
    pointData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    point,
    "color",
    pointData.color,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    point,
    "outlineColor",
    pointData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    point,
    "outlineWidth",
    pointData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    NearFarScalar_default,
    point,
    "scaleByDistance",
    pointData.scaleByDistance,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    NearFarScalar_default,
    point,
    "translucencyByDistance",
    pointData.translucencyByDistance,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    point,
    "distanceDisplayCondition",
    pointData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    point,
    "disableDepthTestDistance",
    pointData.disableDepthTestDistance,
    interval,
    sourceUri,
    entityCollection
  );
}
function PolygonHierarchyProperty(polygon) {
  this.polygon = polygon;
  this._definitionChanged = new Event_default();
}
Object.defineProperties(PolygonHierarchyProperty.prototype, {
  isConstant: {
    get: function() {
      const positions = this.polygon._positions;
      const holes = this.polygon._holes;
      return (!defined_default(positions) || positions.isConstant) && (!defined_default(holes) || holes.isConstant);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  }
});
PolygonHierarchyProperty.prototype.getValue = function(time, result) {
  let positions;
  if (defined_default(this.polygon._positions)) {
    positions = this.polygon._positions.getValue(time);
  }
  let holes;
  if (defined_default(this.polygon._holes)) {
    holes = this.polygon._holes.getValue(time);
    if (defined_default(holes)) {
      holes = holes.map(function(holePositions) {
        return new PolygonHierarchy_default(holePositions);
      });
    }
  }
  if (!defined_default(result)) {
    return new PolygonHierarchy_default(positions, holes);
  }
  result.positions = positions;
  result.holes = holes;
  return result;
};
PolygonHierarchyProperty.prototype.equals = function(other) {
  return this === other || other instanceof PolygonHierarchyProperty && Property_default.equals(this.polygon._positions, other.polygon._positions) && Property_default.equals(this.polygon._holes, other.polygon._holes);
};
function processPolygon(entity, packet, entityCollection, sourceUri) {
  const polygonData = packet.polygon;
  if (!defined_default(polygonData)) {
    return;
  }
  const interval = intervalFromString(polygonData.interval);
  let polygon = entity.polygon;
  if (!defined_default(polygon)) {
    entity.polygon = polygon = new PolygonGraphics_default();
  }
  processPacketData(
    Boolean,
    polygon,
    "show",
    polygonData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPositionArray(
    polygon,
    "_positions",
    polygonData.positions,
    entityCollection
  );
  processPositionArrayOfArrays(
    polygon,
    "_holes",
    polygonData.holes,
    entityCollection
  );
  if (defined_default(polygon._positions) || defined_default(polygon._holes)) {
    polygon.hierarchy = new PolygonHierarchyProperty(polygon);
  }
  processPacketData(
    Number,
    polygon,
    "height",
    polygonData.height,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    polygon,
    "heightReference",
    polygonData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    polygon,
    "extrudedHeight",
    polygonData.extrudedHeight,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    polygon,
    "extrudedHeightReference",
    polygonData.extrudedHeightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Rotation_default,
    polygon,
    "stRotation",
    polygonData.stRotation,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    polygon,
    "granularity",
    polygonData.granularity,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    polygon,
    "fill",
    polygonData.fill,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    polygon,
    "material",
    polygonData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    polygon,
    "outline",
    polygonData.outline,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    polygon,
    "outlineColor",
    polygonData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    polygon,
    "outlineWidth",
    polygonData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    polygon,
    "perPositionHeight",
    polygonData.perPositionHeight,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    polygon,
    "closeTop",
    polygonData.closeTop,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    polygon,
    "closeBottom",
    polygonData.closeBottom,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ArcType_default,
    polygon,
    "arcType",
    polygonData.arcType,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    polygon,
    "shadows",
    polygonData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    polygon,
    "distanceDisplayCondition",
    polygonData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ClassificationType_default,
    polygon,
    "classificationType",
    polygonData.classificationType,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    polygon,
    "zIndex",
    polygonData.zIndex,
    interval,
    sourceUri,
    entityCollection
  );
}
function adaptFollowSurfaceToArcType(followSurface) {
  return followSurface ? ArcType_default.GEODESIC : ArcType_default.NONE;
}
function processPolyline(entity, packet, entityCollection, sourceUri) {
  const polylineData = packet.polyline;
  if (!defined_default(polylineData)) {
    return;
  }
  const interval = intervalFromString(polylineData.interval);
  let polyline = entity.polyline;
  if (!defined_default(polyline)) {
    entity.polyline = polyline = new PolylineGraphics_default();
  }
  processPacketData(
    Boolean,
    polyline,
    "show",
    polylineData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPositionArray(
    polyline,
    "positions",
    polylineData.positions,
    entityCollection
  );
  processPacketData(
    Number,
    polyline,
    "width",
    polylineData.width,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    polyline,
    "granularity",
    polylineData.granularity,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    polyline,
    "material",
    polylineData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    polyline,
    "depthFailMaterial",
    polylineData.depthFailMaterial,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ArcType_default,
    polyline,
    "arcType",
    polylineData.arcType,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    polyline,
    "clampToGround",
    polylineData.clampToGround,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    polyline,
    "shadows",
    polylineData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    polyline,
    "distanceDisplayCondition",
    polylineData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ClassificationType_default,
    polyline,
    "classificationType",
    polylineData.classificationType,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    polyline,
    "zIndex",
    polylineData.zIndex,
    interval,
    sourceUri,
    entityCollection
  );
  if (defined_default(polylineData.followSurface) && !defined_default(polylineData.arcType)) {
    const tempObj = {};
    processPacketData(
      Boolean,
      tempObj,
      "followSurface",
      polylineData.followSurface,
      interval,
      sourceUri,
      entityCollection
    );
    polyline.arcType = createAdapterProperty(
      tempObj.followSurface,
      adaptFollowSurfaceToArcType
    );
  }
}
function processPolylineVolume(entity, packet, entityCollection, sourceUri) {
  const polylineVolumeData = packet.polylineVolume;
  if (!defined_default(polylineVolumeData)) {
    return;
  }
  const interval = intervalFromString(polylineVolumeData.interval);
  let polylineVolume = entity.polylineVolume;
  if (!defined_default(polylineVolume)) {
    entity.polylineVolume = polylineVolume = new PolylineVolumeGraphics_default();
  }
  processPositionArray(
    polylineVolume,
    "positions",
    polylineVolumeData.positions,
    entityCollection
  );
  processShape(
    polylineVolume,
    "shape",
    polylineVolumeData.shape,
    entityCollection
  );
  processPacketData(
    Boolean,
    polylineVolume,
    "show",
    polylineVolumeData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    CornerType_default,
    polylineVolume,
    "cornerType",
    polylineVolumeData.cornerType,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    polylineVolume,
    "fill",
    polylineVolumeData.fill,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    polylineVolume,
    "material",
    polylineVolumeData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    polylineVolume,
    "outline",
    polylineVolumeData.outline,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    polylineVolume,
    "outlineColor",
    polylineVolumeData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    polylineVolume,
    "outlineWidth",
    polylineVolumeData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    polylineVolume,
    "granularity",
    polylineVolumeData.granularity,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    polylineVolume,
    "shadows",
    polylineVolumeData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    polylineVolume,
    "distanceDisplayCondition",
    polylineVolumeData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
}
function processRectangle(entity, packet, entityCollection, sourceUri) {
  const rectangleData = packet.rectangle;
  if (!defined_default(rectangleData)) {
    return;
  }
  const interval = intervalFromString(rectangleData.interval);
  let rectangle = entity.rectangle;
  if (!defined_default(rectangle)) {
    entity.rectangle = rectangle = new RectangleGraphics_default();
  }
  processPacketData(
    Boolean,
    rectangle,
    "show",
    rectangleData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Rectangle_default,
    rectangle,
    "coordinates",
    rectangleData.coordinates,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    rectangle,
    "height",
    rectangleData.height,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    rectangle,
    "heightReference",
    rectangleData.heightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    rectangle,
    "extrudedHeight",
    rectangleData.extrudedHeight,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    HeightReference_default,
    rectangle,
    "extrudedHeightReference",
    rectangleData.extrudedHeightReference,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Rotation_default,
    rectangle,
    "rotation",
    rectangleData.rotation,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Rotation_default,
    rectangle,
    "stRotation",
    rectangleData.stRotation,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    rectangle,
    "granularity",
    rectangleData.granularity,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    rectangle,
    "fill",
    rectangleData.fill,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    rectangle,
    "material",
    rectangleData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    rectangle,
    "outline",
    rectangleData.outline,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    rectangle,
    "outlineColor",
    rectangleData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    rectangle,
    "outlineWidth",
    rectangleData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    rectangle,
    "shadows",
    rectangleData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    rectangle,
    "distanceDisplayCondition",
    rectangleData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ClassificationType_default,
    rectangle,
    "classificationType",
    rectangleData.classificationType,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    rectangle,
    "zIndex",
    rectangleData.zIndex,
    interval,
    sourceUri,
    entityCollection
  );
}
function processTileset(entity, packet, entityCollection, sourceUri) {
  const tilesetData = packet.tileset;
  if (!defined_default(tilesetData)) {
    return;
  }
  const interval = intervalFromString(tilesetData.interval);
  let tileset = entity.tileset;
  if (!defined_default(tileset)) {
    entity.tileset = tileset = new Cesium3DTilesetGraphics_default();
  }
  processPacketData(
    Boolean,
    tileset,
    "show",
    tilesetData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    URI,
    tileset,
    "uri",
    tilesetData.uri,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    tileset,
    "maximumScreenSpaceError",
    tilesetData.maximumScreenSpaceError,
    interval,
    sourceUri,
    entityCollection
  );
}
function processWall(entity, packet, entityCollection, sourceUri) {
  const wallData = packet.wall;
  if (!defined_default(wallData)) {
    return;
  }
  const interval = intervalFromString(wallData.interval);
  let wall = entity.wall;
  if (!defined_default(wall)) {
    entity.wall = wall = new WallGraphics_default();
  }
  processPacketData(
    Boolean,
    wall,
    "show",
    wallData.show,
    interval,
    sourceUri,
    entityCollection
  );
  processPositionArray(wall, "positions", wallData.positions, entityCollection);
  processArray(
    wall,
    "minimumHeights",
    wallData.minimumHeights,
    entityCollection
  );
  processArray(
    wall,
    "maximumHeights",
    wallData.maximumHeights,
    entityCollection
  );
  processPacketData(
    Number,
    wall,
    "granularity",
    wallData.granularity,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    wall,
    "fill",
    wallData.fill,
    interval,
    sourceUri,
    entityCollection
  );
  processMaterialPacketData(
    wall,
    "material",
    wallData.material,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Boolean,
    wall,
    "outline",
    wallData.outline,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Color_default,
    wall,
    "outlineColor",
    wallData.outlineColor,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    Number,
    wall,
    "outlineWidth",
    wallData.outlineWidth,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    ShadowMode_default,
    wall,
    "shadows",
    wallData.shadows,
    interval,
    sourceUri,
    entityCollection
  );
  processPacketData(
    DistanceDisplayCondition_default,
    wall,
    "distanceDisplayCondition",
    wallData.distanceDisplayCondition,
    interval,
    sourceUri,
    entityCollection
  );
}
function processCzmlPacket(packet, entityCollection, updaterFunctions, sourceUri, dataSource) {
  let objectId = packet.id;
  if (!defined_default(objectId)) {
    objectId = createGuid_default();
  }
  currentId = objectId;
  if (!defined_default(dataSource._version) && objectId !== "document") {
    throw new RuntimeError_default(
      "The first CZML packet is required to be the document object."
    );
  }
  if (packet["delete"] === true) {
    entityCollection.removeById(objectId);
  } else if (objectId === "document") {
    processDocument(packet, dataSource);
  } else {
    const entity = entityCollection.getOrCreateEntity(objectId);
    const parentId = packet.parent;
    if (defined_default(parentId)) {
      entity.parent = entityCollection.getOrCreateEntity(parentId);
    }
    for (let i2 = updaterFunctions.length - 1; i2 > -1; i2--) {
      updaterFunctions[i2](entity, packet, entityCollection, sourceUri);
    }
  }
  currentId = void 0;
}
function updateClock(dataSource) {
  let clock;
  const clockPacket = dataSource._documentPacket.clock;
  if (!defined_default(clockPacket)) {
    if (!defined_default(dataSource._clock)) {
      const availability = dataSource._entityCollection.computeAvailability();
      if (!availability.start.equals(Iso8601_default.MINIMUM_VALUE)) {
        const startTime = availability.start;
        const stopTime = availability.stop;
        const totalSeconds = JulianDate_default.secondsDifference(stopTime, startTime);
        const multiplier = Math.round(totalSeconds / 120);
        clock = new DataSourceClock_default();
        clock.startTime = JulianDate_default.clone(startTime);
        clock.stopTime = JulianDate_default.clone(stopTime);
        clock.clockRange = ClockRange_default.LOOP_STOP;
        clock.multiplier = multiplier;
        clock.currentTime = JulianDate_default.clone(startTime);
        clock.clockStep = ClockStep_default.SYSTEM_CLOCK_MULTIPLIER;
        dataSource._clock = clock;
        return true;
      }
    }
    return false;
  }
  if (defined_default(dataSource._clock)) {
    clock = dataSource._clock.clone();
  } else {
    clock = new DataSourceClock_default();
    clock.startTime = Iso8601_default.MINIMUM_VALUE.clone();
    clock.stopTime = Iso8601_default.MAXIMUM_VALUE.clone();
    clock.currentTime = Iso8601_default.MINIMUM_VALUE.clone();
    clock.clockRange = ClockRange_default.LOOP_STOP;
    clock.clockStep = ClockStep_default.SYSTEM_CLOCK_MULTIPLIER;
    clock.multiplier = 1;
  }
  const interval = intervalFromString(clockPacket.interval);
  if (defined_default(interval)) {
    clock.startTime = interval.start;
    clock.stopTime = interval.stop;
  }
  if (defined_default(clockPacket.currentTime)) {
    clock.currentTime = JulianDate_default.fromIso8601(clockPacket.currentTime);
  }
  if (defined_default(clockPacket.range)) {
    clock.clockRange = defaultValue_default(
      ClockRange_default[clockPacket.range],
      ClockRange_default.LOOP_STOP
    );
  }
  if (defined_default(clockPacket.step)) {
    clock.clockStep = defaultValue_default(
      ClockStep_default[clockPacket.step],
      ClockStep_default.SYSTEM_CLOCK_MULTIPLIER
    );
  }
  if (defined_default(clockPacket.multiplier)) {
    clock.multiplier = clockPacket.multiplier;
  }
  if (!clock.equals(dataSource._clock)) {
    dataSource._clock = clock.clone(dataSource._clock);
    return true;
  }
  return false;
}
function load(dataSource, czml, options, clear2) {
  if (!defined_default(czml)) {
    throw new DeveloperError_default("czml is required.");
  }
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let promise = czml;
  let sourceUri = options.sourceUri;
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  dataSource._credit = credit;
  if (typeof czml === "string" || czml instanceof Resource_default) {
    czml = Resource_default.createIfNeeded(czml);
    promise = czml.fetchJson();
    sourceUri = defaultValue_default(sourceUri, czml.clone());
    const resourceCredits = dataSource._resourceCredits;
    const credits = czml.credits;
    if (defined_default(credits)) {
      const length3 = credits.length;
      for (let i2 = 0; i2 < length3; i2++) {
        resourceCredits.push(credits[i2]);
      }
    }
  }
  sourceUri = Resource_default.createIfNeeded(sourceUri);
  DataSource_default.setLoading(dataSource, true);
  return Promise.resolve(promise).then(function(czml2) {
    return loadCzml(dataSource, czml2, sourceUri, clear2);
  }).catch(function(error) {
    DataSource_default.setLoading(dataSource, false);
    dataSource._error.raiseEvent(dataSource, error);
    console.log(error);
    return Promise.reject(error);
  });
}
function loadCzml(dataSource, czml, sourceUri, clear2) {
  DataSource_default.setLoading(dataSource, true);
  const entityCollection = dataSource._entityCollection;
  if (clear2) {
    dataSource._version = void 0;
    dataSource._documentPacket = new DocumentPacket();
    entityCollection.removeAll();
  }
  CzmlDataSource._processCzml(
    czml,
    entityCollection,
    sourceUri,
    void 0,
    dataSource
  );
  let raiseChangedEvent = updateClock(dataSource);
  const documentPacket = dataSource._documentPacket;
  if (defined_default(documentPacket.name) && dataSource._name !== documentPacket.name) {
    dataSource._name = documentPacket.name;
    raiseChangedEvent = true;
  } else if (!defined_default(dataSource._name) && defined_default(sourceUri)) {
    dataSource._name = getFilenameFromUri_default(sourceUri.getUrlComponent());
    raiseChangedEvent = true;
  }
  DataSource_default.setLoading(dataSource, false);
  if (raiseChangedEvent) {
    dataSource._changed.raiseEvent(dataSource);
  }
  return dataSource;
}
function DocumentPacket() {
  this.name = void 0;
  this.clock = void 0;
}
function CzmlDataSource(name) {
  this._name = name;
  this._changed = new Event_default();
  this._error = new Event_default();
  this._isLoading = false;
  this._loading = new Event_default();
  this._clock = void 0;
  this._documentPacket = new DocumentPacket();
  this._version = void 0;
  this._entityCollection = new EntityCollection_default(this);
  this._entityCluster = new EntityCluster_default();
  this._credit = void 0;
  this._resourceCredits = [];
}
CzmlDataSource.load = function(czml, options) {
  return new CzmlDataSource().load(czml, options);
};
Object.defineProperties(CzmlDataSource.prototype, {
  name: {
    get: function() {
      return this._name;
    }
  },
  clock: {
    get: function() {
      return this._clock;
    }
  },
  entities: {
    get: function() {
      return this._entityCollection;
    }
  },
  isLoading: {
    get: function() {
      return this._isLoading;
    }
  },
  changedEvent: {
    get: function() {
      return this._changed;
    }
  },
  errorEvent: {
    get: function() {
      return this._error;
    }
  },
  loadingEvent: {
    get: function() {
      return this._loading;
    }
  },
  show: {
    get: function() {
      return this._entityCollection.show;
    },
    set: function(value) {
      this._entityCollection.show = value;
    }
  },
  clustering: {
    get: function() {
      return this._entityCluster;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value must be defined.");
      }
      this._entityCluster = value;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  }
});
CzmlDataSource.updaters = [
  processBillboard,
  processBox,
  processCorridor,
  processCylinder,
  processEllipse,
  processEllipsoid,
  processLabel,
  processModel,
  processName,
  processDescription,
  processPath,
  processPoint,
  processPolygon,
  processPolyline,
  processPolylineVolume,
  processProperties,
  processRectangle,
  processPosition,
  processTileset,
  processViewFrom,
  processWall,
  processOrientation,
  processAvailability
];
CzmlDataSource.prototype.process = function(czml, options) {
  return load(this, czml, options, false);
};
CzmlDataSource.prototype.load = function(czml, options) {
  return load(this, czml, options, true);
};
CzmlDataSource.prototype.update = function(time) {
  return true;
};
CzmlDataSource.processPacketData = processPacketData;
CzmlDataSource.processPositionPacketData = processPositionPacketData;
CzmlDataSource.processMaterialPacketData = processMaterialPacketData;
CzmlDataSource._processCzml = function(czml, entityCollection, sourceUri, updaterFunctions, dataSource) {
  updaterFunctions = defaultValue_default(updaterFunctions, CzmlDataSource.updaters);
  if (Array.isArray(czml)) {
    for (let i2 = 0, len = czml.length; i2 < len; ++i2) {
      processCzmlPacket(
        czml[i2],
        entityCollection,
        updaterFunctions,
        sourceUri,
        dataSource
      );
    }
  } else {
    processCzmlPacket(
      czml,
      entityCollection,
      updaterFunctions,
      sourceUri,
      dataSource
    );
  }
};
var CzmlDataSource_default = CzmlDataSource;

// node_modules/cesium/Source/DataSources/DataSourceCollection.js
function DataSourceCollection() {
  this._dataSources = [];
  this._dataSourceAdded = new Event_default();
  this._dataSourceRemoved = new Event_default();
  this._dataSourceMoved = new Event_default();
}
Object.defineProperties(DataSourceCollection.prototype, {
  length: {
    get: function() {
      return this._dataSources.length;
    }
  },
  dataSourceAdded: {
    get: function() {
      return this._dataSourceAdded;
    }
  },
  dataSourceRemoved: {
    get: function() {
      return this._dataSourceRemoved;
    }
  },
  dataSourceMoved: {
    get: function() {
      return this._dataSourceMoved;
    }
  }
});
DataSourceCollection.prototype.add = function(dataSource) {
  if (!defined_default(dataSource)) {
    throw new DeveloperError_default("dataSource is required.");
  }
  const that = this;
  const dataSources = this._dataSources;
  return Promise.resolve(dataSource).then(function(value) {
    if (dataSources === that._dataSources) {
      that._dataSources.push(value);
      that._dataSourceAdded.raiseEvent(that, value);
    }
    return value;
  });
};
DataSourceCollection.prototype.remove = function(dataSource, destroy2) {
  destroy2 = defaultValue_default(destroy2, false);
  const index2 = this._dataSources.indexOf(dataSource);
  if (index2 !== -1) {
    this._dataSources.splice(index2, 1);
    this._dataSourceRemoved.raiseEvent(this, dataSource);
    if (destroy2 && typeof dataSource.destroy === "function") {
      dataSource.destroy();
    }
    return true;
  }
  return false;
};
DataSourceCollection.prototype.removeAll = function(destroy2) {
  destroy2 = defaultValue_default(destroy2, false);
  const dataSources = this._dataSources;
  for (let i2 = 0, len = dataSources.length; i2 < len; ++i2) {
    const dataSource = dataSources[i2];
    this._dataSourceRemoved.raiseEvent(this, dataSource);
    if (destroy2 && typeof dataSource.destroy === "function") {
      dataSource.destroy();
    }
  }
  this._dataSources = [];
};
DataSourceCollection.prototype.contains = function(dataSource) {
  return this.indexOf(dataSource) !== -1;
};
DataSourceCollection.prototype.indexOf = function(dataSource) {
  return this._dataSources.indexOf(dataSource);
};
DataSourceCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.");
  }
  return this._dataSources[index2];
};
DataSourceCollection.prototype.getByName = function(name) {
  if (!defined_default(name)) {
    throw new DeveloperError_default("name is required.");
  }
  return this._dataSources.filter(function(dataSource) {
    return dataSource.name === name;
  });
};
function getIndex2(dataSources, dataSource) {
  if (!defined_default(dataSource)) {
    throw new DeveloperError_default("dataSource is required.");
  }
  const index2 = dataSources.indexOf(dataSource);
  if (index2 === -1) {
    throw new DeveloperError_default("dataSource is not in this collection.");
  }
  return index2;
}
function swapDataSources(collection, i2, j) {
  const arr = collection._dataSources;
  const length3 = arr.length - 1;
  i2 = Math_default.clamp(i2, 0, length3);
  j = Math_default.clamp(j, 0, length3);
  if (i2 === j) {
    return;
  }
  const temp = arr[i2];
  arr[i2] = arr[j];
  arr[j] = temp;
  collection.dataSourceMoved.raiseEvent(temp, j, i2);
}
DataSourceCollection.prototype.raise = function(dataSource) {
  const index2 = getIndex2(this._dataSources, dataSource);
  swapDataSources(this, index2, index2 + 1);
};
DataSourceCollection.prototype.lower = function(dataSource) {
  const index2 = getIndex2(this._dataSources, dataSource);
  swapDataSources(this, index2, index2 - 1);
};
DataSourceCollection.prototype.raiseToTop = function(dataSource) {
  const index2 = getIndex2(this._dataSources, dataSource);
  if (index2 === this._dataSources.length - 1) {
    return;
  }
  this._dataSources.splice(index2, 1);
  this._dataSources.push(dataSource);
  this.dataSourceMoved.raiseEvent(
    dataSource,
    this._dataSources.length - 1,
    index2
  );
};
DataSourceCollection.prototype.lowerToBottom = function(dataSource) {
  const index2 = getIndex2(this._dataSources, dataSource);
  if (index2 === 0) {
    return;
  }
  this._dataSources.splice(index2, 1);
  this._dataSources.splice(0, 0, dataSource);
  this.dataSourceMoved.raiseEvent(dataSource, 0, index2);
};
DataSourceCollection.prototype.isDestroyed = function() {
  return false;
};
DataSourceCollection.prototype.destroy = function() {
  this.removeAll(true);
  return destroyObject_default(this);
};
var DataSourceCollection_default = DataSourceCollection;

// node_modules/cesium/Source/Scene/PrimitiveCollection.js
function PrimitiveCollection(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._primitives = [];
  this._guid = createGuid_default();
  this._zIndex = void 0;
  this.show = defaultValue_default(options.show, true);
  this.destroyPrimitives = defaultValue_default(options.destroyPrimitives, true);
}
Object.defineProperties(PrimitiveCollection.prototype, {
  length: {
    get: function() {
      return this._primitives.length;
    }
  }
});
PrimitiveCollection.prototype.add = function(primitive, index2) {
  const hasIndex = defined_default(index2);
  if (!defined_default(primitive)) {
    throw new DeveloperError_default("primitive is required.");
  }
  if (hasIndex) {
    if (index2 < 0) {
      throw new DeveloperError_default("index must be greater than or equal to zero.");
    } else if (index2 > this._primitives.length) {
      throw new DeveloperError_default(
        "index must be less than or equal to the number of primitives."
      );
    }
  }
  const external = primitive._external = primitive._external || {};
  const composites = external._composites = external._composites || {};
  composites[this._guid] = {
    collection: this
  };
  if (!hasIndex) {
    this._primitives.push(primitive);
  } else {
    this._primitives.splice(index2, 0, primitive);
  }
  return primitive;
};
PrimitiveCollection.prototype.remove = function(primitive) {
  if (this.contains(primitive)) {
    const index2 = this._primitives.indexOf(primitive);
    if (index2 !== -1) {
      this._primitives.splice(index2, 1);
      delete primitive._external._composites[this._guid];
      if (this.destroyPrimitives) {
        primitive.destroy();
      }
      return true;
    }
  }
  return false;
};
PrimitiveCollection.prototype.removeAndDestroy = function(primitive) {
  const removed = this.remove(primitive);
  if (removed && !this.destroyPrimitives) {
    primitive.destroy();
  }
  return removed;
};
PrimitiveCollection.prototype.removeAll = function() {
  const primitives = this._primitives;
  const length3 = primitives.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    delete primitives[i2]._external._composites[this._guid];
    if (this.destroyPrimitives) {
      primitives[i2].destroy();
    }
  }
  this._primitives = [];
};
PrimitiveCollection.prototype.contains = function(primitive) {
  return !!(defined_default(primitive) && primitive._external && primitive._external._composites && primitive._external._composites[this._guid]);
};
function getPrimitiveIndex(compositePrimitive, primitive) {
  if (!compositePrimitive.contains(primitive)) {
    throw new DeveloperError_default("primitive is not in this collection.");
  }
  return compositePrimitive._primitives.indexOf(primitive);
}
PrimitiveCollection.prototype.raise = function(primitive) {
  if (defined_default(primitive)) {
    const index2 = getPrimitiveIndex(this, primitive);
    const primitives = this._primitives;
    if (index2 !== primitives.length - 1) {
      const p2 = primitives[index2];
      primitives[index2] = primitives[index2 + 1];
      primitives[index2 + 1] = p2;
    }
  }
};
PrimitiveCollection.prototype.raiseToTop = function(primitive) {
  if (defined_default(primitive)) {
    const index2 = getPrimitiveIndex(this, primitive);
    const primitives = this._primitives;
    if (index2 !== primitives.length - 1) {
      primitives.splice(index2, 1);
      primitives.push(primitive);
    }
  }
};
PrimitiveCollection.prototype.lower = function(primitive) {
  if (defined_default(primitive)) {
    const index2 = getPrimitiveIndex(this, primitive);
    const primitives = this._primitives;
    if (index2 !== 0) {
      const p2 = primitives[index2];
      primitives[index2] = primitives[index2 - 1];
      primitives[index2 - 1] = p2;
    }
  }
};
PrimitiveCollection.prototype.lowerToBottom = function(primitive) {
  if (defined_default(primitive)) {
    const index2 = getPrimitiveIndex(this, primitive);
    const primitives = this._primitives;
    if (index2 !== 0) {
      primitives.splice(index2, 1);
      primitives.unshift(primitive);
    }
  }
};
PrimitiveCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.");
  }
  return this._primitives[index2];
};
PrimitiveCollection.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  const primitives = this._primitives;
  for (let i2 = 0; i2 < primitives.length; ++i2) {
    primitives[i2].update(frameState);
  }
};
PrimitiveCollection.prototype.prePassesUpdate = function(frameState) {
  const primitives = this._primitives;
  for (let i2 = 0; i2 < primitives.length; ++i2) {
    const primitive = primitives[i2];
    if (defined_default(primitive.prePassesUpdate)) {
      primitive.prePassesUpdate(frameState);
    }
  }
};
PrimitiveCollection.prototype.updateForPass = function(frameState, passState) {
  const primitives = this._primitives;
  for (let i2 = 0; i2 < primitives.length; ++i2) {
    const primitive = primitives[i2];
    if (defined_default(primitive.updateForPass)) {
      primitive.updateForPass(frameState, passState);
    }
  }
};
PrimitiveCollection.prototype.postPassesUpdate = function(frameState) {
  const primitives = this._primitives;
  for (let i2 = 0; i2 < primitives.length; ++i2) {
    const primitive = primitives[i2];
    if (defined_default(primitive.postPassesUpdate)) {
      primitive.postPassesUpdate(frameState);
    }
  }
};
PrimitiveCollection.prototype.isDestroyed = function() {
  return false;
};
PrimitiveCollection.prototype.destroy = function() {
  this.removeAll();
  return destroyObject_default(this);
};
var PrimitiveCollection_default = PrimitiveCollection;

// node_modules/cesium/Source/Scene/OrderedGroundPrimitiveCollection.js
function OrderedGroundPrimitiveCollection() {
  this._length = 0;
  this._collections = {};
  this._collectionsArray = [];
  this.show = true;
}
Object.defineProperties(OrderedGroundPrimitiveCollection.prototype, {
  length: {
    get: function() {
      return this._length;
    }
  }
});
OrderedGroundPrimitiveCollection.prototype.add = function(primitive, zIndex) {
  Check_default.defined("primitive", primitive);
  if (defined_default(zIndex)) {
    Check_default.typeOf.number("zIndex", zIndex);
  }
  zIndex = defaultValue_default(zIndex, 0);
  let collection = this._collections[zIndex];
  if (!defined_default(collection)) {
    collection = new PrimitiveCollection_default({ destroyPrimitives: false });
    collection._zIndex = zIndex;
    this._collections[zIndex] = collection;
    const array = this._collectionsArray;
    let i2 = 0;
    while (i2 < array.length && array[i2]._zIndex < zIndex) {
      i2++;
    }
    array.splice(i2, 0, collection);
  }
  collection.add(primitive);
  this._length++;
  primitive._zIndex = zIndex;
  return primitive;
};
OrderedGroundPrimitiveCollection.prototype.set = function(primitive, zIndex) {
  Check_default.defined("primitive", primitive);
  Check_default.typeOf.number("zIndex", zIndex);
  if (zIndex === primitive._zIndex) {
    return primitive;
  }
  this.remove(primitive, true);
  this.add(primitive, zIndex);
  return primitive;
};
OrderedGroundPrimitiveCollection.prototype.remove = function(primitive, doNotDestroy) {
  if (this.contains(primitive)) {
    const index2 = primitive._zIndex;
    const collection = this._collections[index2];
    let result;
    if (doNotDestroy) {
      result = collection.remove(primitive);
    } else {
      result = collection.removeAndDestroy(primitive);
    }
    if (result) {
      this._length--;
    }
    if (collection.length === 0) {
      this._collectionsArray.splice(
        this._collectionsArray.indexOf(collection),
        1
      );
      this._collections[index2] = void 0;
      collection.destroy();
    }
    return result;
  }
  return false;
};
OrderedGroundPrimitiveCollection.prototype.removeAll = function() {
  const collections = this._collectionsArray;
  for (let i2 = 0; i2 < collections.length; i2++) {
    const collection = collections[i2];
    collection.destroyPrimitives = true;
    collection.destroy();
  }
  this._collections = {};
  this._collectionsArray = [];
  this._length = 0;
};
OrderedGroundPrimitiveCollection.prototype.contains = function(primitive) {
  if (!defined_default(primitive)) {
    return false;
  }
  const collection = this._collections[primitive._zIndex];
  return defined_default(collection) && collection.contains(primitive);
};
OrderedGroundPrimitiveCollection.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  const collections = this._collectionsArray;
  for (let i2 = 0; i2 < collections.length; i2++) {
    collections[i2].update(frameState);
  }
};
OrderedGroundPrimitiveCollection.prototype.isDestroyed = function() {
  return false;
};
OrderedGroundPrimitiveCollection.prototype.destroy = function() {
  this.removeAll();
  return destroyObject_default(this);
};
var OrderedGroundPrimitiveCollection_default = OrderedGroundPrimitiveCollection;

// node_modules/cesium/Source/DataSources/DynamicGeometryBatch.js
function DynamicGeometryBatch(primitives, orderedGroundPrimitives) {
  this._primitives = primitives;
  this._orderedGroundPrimitives = orderedGroundPrimitives;
  this._dynamicUpdaters = new AssociativeArray_default();
}
DynamicGeometryBatch.prototype.add = function(time, updater) {
  this._dynamicUpdaters.set(
    updater.id,
    updater.createDynamicUpdater(
      this._primitives,
      this._orderedGroundPrimitives
    )
  );
};
DynamicGeometryBatch.prototype.remove = function(updater) {
  const id = updater.id;
  const dynamicUpdater = this._dynamicUpdaters.get(id);
  if (defined_default(dynamicUpdater)) {
    this._dynamicUpdaters.remove(id);
    dynamicUpdater.destroy();
  }
};
DynamicGeometryBatch.prototype.update = function(time) {
  const geometries = this._dynamicUpdaters.values;
  for (let i2 = 0, len = geometries.length; i2 < len; i2++) {
    geometries[i2].update(time);
  }
  return true;
};
DynamicGeometryBatch.prototype.removeAllPrimitives = function() {
  const geometries = this._dynamicUpdaters.values;
  for (let i2 = 0, len = geometries.length; i2 < len; i2++) {
    geometries[i2].destroy();
  }
  this._dynamicUpdaters.removeAll();
};
DynamicGeometryBatch.prototype.getBoundingSphere = function(updater, result) {
  updater = this._dynamicUpdaters.get(updater.id);
  if (defined_default(updater) && defined_default(updater.getBoundingSphere)) {
    return updater.getBoundingSphere(result);
  }
  return BoundingSphereState_default.FAILED;
};
var DynamicGeometryBatch_default = DynamicGeometryBatch;

// node_modules/cesium/Source/DataSources/EllipseGeometryUpdater.js
var scratchColor14 = new Color_default();
var defaultOffset5 = Cartesian3_default.ZERO;
var offsetScratch7 = new Cartesian3_default();
var scratchRectangle6 = new Rectangle_default();
function EllipseGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.center = void 0;
  this.semiMajorAxis = void 0;
  this.semiMinorAxis = void 0;
  this.rotation = void 0;
  this.height = void 0;
  this.extrudedHeight = void 0;
  this.granularity = void 0;
  this.stRotation = void 0;
  this.numberOfVerticalLines = void 0;
  this.offsetAttribute = void 0;
}
function EllipseGeometryUpdater(entity, scene) {
  GroundGeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new EllipseGeometryOptions(entity),
    geometryPropertyName: "ellipse",
    observedPropertyNames: ["availability", "position", "ellipse"]
  });
  this._onEntityPropertyChanged(entity, "ellipse", entity.ellipse, void 0);
}
if (defined_default(Object.create)) {
  EllipseGeometryUpdater.prototype = Object.create(
    GroundGeometryUpdater_default.prototype
  );
  EllipseGeometryUpdater.prototype.constructor = EllipseGeometryUpdater;
}
EllipseGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
    ),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      this._distanceDisplayConditionProperty.getValue(time)
    ),
    offset: void 0,
    color: void 0
  };
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor14);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    attributes.color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
  }
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset5,
        offsetScratch7
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new EllipseGeometry_default(this._options),
    attributes
  });
};
EllipseGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._outlineEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent an outlined geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor14
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
    ),
    color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      distanceDisplayCondition
    ),
    offset: void 0
  };
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset5,
        offsetScratch7
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new EllipseOutlineGeometry_default(this._options),
    attributes
  });
};
EllipseGeometryUpdater.prototype._computeCenter = function(time, result) {
  return Property_default.getValueOrUndefined(this._entity.position, time, result);
};
EllipseGeometryUpdater.prototype._isHidden = function(entity, ellipse) {
  const position = entity.position;
  return !defined_default(position) || !defined_default(ellipse.semiMajorAxis) || !defined_default(ellipse.semiMinorAxis) || GeometryUpdater_default.prototype._isHidden.call(this, entity, ellipse);
};
EllipseGeometryUpdater.prototype._isDynamic = function(entity, ellipse) {
  return !entity.position.isConstant || !ellipse.semiMajorAxis.isConstant || !ellipse.semiMinorAxis.isConstant || !Property_default.isConstant(ellipse.rotation) || !Property_default.isConstant(ellipse.height) || !Property_default.isConstant(ellipse.extrudedHeight) || !Property_default.isConstant(ellipse.granularity) || !Property_default.isConstant(ellipse.stRotation) || !Property_default.isConstant(ellipse.outlineWidth) || !Property_default.isConstant(ellipse.numberOfVerticalLines) || !Property_default.isConstant(ellipse.zIndex) || this._onTerrain && !Property_default.isConstant(this._materialProperty) && !(this._materialProperty instanceof ColorMaterialProperty_default);
};
EllipseGeometryUpdater.prototype._setStaticOptions = function(entity, ellipse) {
  let heightValue = Property_default.getValueOrUndefined(
    ellipse.height,
    Iso8601_default.MINIMUM_VALUE
  );
  const heightReferenceValue = Property_default.getValueOrDefault(
    ellipse.heightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  let extrudedHeightValue = Property_default.getValueOrUndefined(
    ellipse.extrudedHeight,
    Iso8601_default.MINIMUM_VALUE
  );
  const extrudedHeightReferenceValue = Property_default.getValueOrDefault(
    ellipse.extrudedHeightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  if (defined_default(extrudedHeightValue) && !defined_default(heightValue)) {
    heightValue = 0;
  }
  const options = this._options;
  options.vertexFormat = this._materialProperty instanceof ColorMaterialProperty_default ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  options.center = entity.position.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.center
  );
  options.semiMajorAxis = ellipse.semiMajorAxis.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.semiMajorAxis
  );
  options.semiMinorAxis = ellipse.semiMinorAxis.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.semiMinorAxis
  );
  options.rotation = Property_default.getValueOrUndefined(
    ellipse.rotation,
    Iso8601_default.MINIMUM_VALUE
  );
  options.granularity = Property_default.getValueOrUndefined(
    ellipse.granularity,
    Iso8601_default.MINIMUM_VALUE
  );
  options.stRotation = Property_default.getValueOrUndefined(
    ellipse.stRotation,
    Iso8601_default.MINIMUM_VALUE
  );
  options.numberOfVerticalLines = Property_default.getValueOrUndefined(
    ellipse.numberOfVerticalLines,
    Iso8601_default.MINIMUM_VALUE
  );
  options.offsetAttribute = GroundGeometryUpdater_default.computeGeometryOffsetAttribute(
    heightValue,
    heightReferenceValue,
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  options.height = GroundGeometryUpdater_default.getGeometryHeight(
    heightValue,
    heightReferenceValue
  );
  extrudedHeightValue = GroundGeometryUpdater_default.getGeometryExtrudedHeight(
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  if (extrudedHeightValue === GroundGeometryUpdater_default.CLAMP_TO_GROUND) {
    extrudedHeightValue = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
      EllipseGeometry_default.computeRectangle(options, scratchRectangle6)
    ).minimumTerrainHeight;
  }
  options.extrudedHeight = extrudedHeightValue;
};
EllipseGeometryUpdater.DynamicGeometryUpdater = DynamicEllipseGeometryUpdater;
function DynamicEllipseGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
}
if (defined_default(Object.create)) {
  DynamicEllipseGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DynamicEllipseGeometryUpdater.prototype.constructor = DynamicEllipseGeometryUpdater;
}
DynamicEllipseGeometryUpdater.prototype._isHidden = function(entity, ellipse, time) {
  const options = this._options;
  return !defined_default(options.center) || !defined_default(options.semiMajorAxis) || !defined_default(options.semiMinorAxis) || DynamicGeometryUpdater_default.prototype._isHidden.call(this, entity, ellipse, time);
};
DynamicEllipseGeometryUpdater.prototype._setOptions = function(entity, ellipse, time) {
  const options = this._options;
  let heightValue = Property_default.getValueOrUndefined(ellipse.height, time);
  const heightReferenceValue = Property_default.getValueOrDefault(
    ellipse.heightReference,
    time,
    HeightReference_default.NONE
  );
  let extrudedHeightValue = Property_default.getValueOrUndefined(
    ellipse.extrudedHeight,
    time
  );
  const extrudedHeightReferenceValue = Property_default.getValueOrDefault(
    ellipse.extrudedHeightReference,
    time,
    HeightReference_default.NONE
  );
  if (defined_default(extrudedHeightValue) && !defined_default(heightValue)) {
    heightValue = 0;
  }
  options.center = Property_default.getValueOrUndefined(
    entity.position,
    time,
    options.center
  );
  options.semiMajorAxis = Property_default.getValueOrUndefined(
    ellipse.semiMajorAxis,
    time
  );
  options.semiMinorAxis = Property_default.getValueOrUndefined(
    ellipse.semiMinorAxis,
    time
  );
  options.rotation = Property_default.getValueOrUndefined(ellipse.rotation, time);
  options.granularity = Property_default.getValueOrUndefined(ellipse.granularity, time);
  options.stRotation = Property_default.getValueOrUndefined(ellipse.stRotation, time);
  options.numberOfVerticalLines = Property_default.getValueOrUndefined(
    ellipse.numberOfVerticalLines,
    time
  );
  options.offsetAttribute = GroundGeometryUpdater_default.computeGeometryOffsetAttribute(
    heightValue,
    heightReferenceValue,
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  options.height = GroundGeometryUpdater_default.getGeometryHeight(
    heightValue,
    heightReferenceValue
  );
  extrudedHeightValue = GroundGeometryUpdater_default.getGeometryExtrudedHeight(
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  if (extrudedHeightValue === GroundGeometryUpdater_default.CLAMP_TO_GROUND) {
    extrudedHeightValue = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
      EllipseGeometry_default.computeRectangle(options, scratchRectangle6)
    ).minimumTerrainHeight;
  }
  options.extrudedHeight = extrudedHeightValue;
};
var EllipseGeometryUpdater_default = EllipseGeometryUpdater;

// node_modules/cesium/Source/DataSources/EllipsoidGeometryUpdater.js
var defaultMaterial2 = new ColorMaterialProperty_default(Color_default.WHITE);
var defaultOffset6 = Cartesian3_default.ZERO;
var offsetScratch8 = new Cartesian3_default();
var radiiScratch = new Cartesian3_default();
var innerRadiiScratch = new Cartesian3_default();
var scratchColor15 = new Color_default();
var unitSphere = new Cartesian3_default(1, 1, 1);
function EllipsoidGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.radii = void 0;
  this.innerRadii = void 0;
  this.minimumClock = void 0;
  this.maximumClock = void 0;
  this.minimumCone = void 0;
  this.maximumCone = void 0;
  this.stackPartitions = void 0;
  this.slicePartitions = void 0;
  this.subdivisions = void 0;
  this.offsetAttribute = void 0;
}
function EllipsoidGeometryUpdater(entity, scene) {
  GeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new EllipsoidGeometryOptions(entity),
    geometryPropertyName: "ellipsoid",
    observedPropertyNames: [
      "availability",
      "position",
      "orientation",
      "ellipsoid"
    ]
  });
  this._onEntityPropertyChanged(
    entity,
    "ellipsoid",
    entity.ellipsoid,
    void 0
  );
}
if (defined_default(Object.create)) {
  EllipsoidGeometryUpdater.prototype = Object.create(GeometryUpdater_default.prototype);
  EllipsoidGeometryUpdater.prototype.constructor = EllipsoidGeometryUpdater;
}
Object.defineProperties(EllipsoidGeometryUpdater.prototype, {
  terrainOffsetProperty: {
    get: function() {
      return this._terrainOffsetProperty;
    }
  }
});
EllipsoidGeometryUpdater.prototype.createFillGeometryInstance = function(time, skipModelMatrix, modelMatrixResult) {
  Check_default.defined("time", time);
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  let color;
  const show = new ShowGeometryInstanceAttribute_default(
    isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
    distanceDisplayCondition
  );
  const attributes = {
    show,
    distanceDisplayCondition: distanceDisplayConditionAttribute,
    color: void 0,
    offset: void 0
  };
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor15);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
    attributes.color = color;
  }
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset6,
        offsetScratch8
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new EllipsoidGeometry_default(this._options),
    modelMatrix: skipModelMatrix ? void 0 : entity.computeModelMatrixForHeightReference(
      time,
      entity.ellipsoid.heightReference,
      this._options.radii.z * 0.5,
      this._scene.mapProjection.ellipsoid,
      modelMatrixResult
    ),
    attributes
  });
};
EllipsoidGeometryUpdater.prototype.createOutlineGeometryInstance = function(time, skipModelMatrix, modelMatrixResult) {
  Check_default.defined("time", time);
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor15
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
    ),
    color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      distanceDisplayCondition
    ),
    offset: void 0
  };
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset6,
        offsetScratch8
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new EllipsoidOutlineGeometry_default(this._options),
    modelMatrix: skipModelMatrix ? void 0 : entity.computeModelMatrixForHeightReference(
      time,
      entity.ellipsoid.heightReference,
      this._options.radii.z * 0.5,
      this._scene.mapProjection.ellipsoid,
      modelMatrixResult
    ),
    attributes
  });
};
EllipsoidGeometryUpdater.prototype._computeCenter = function(time, result) {
  return Property_default.getValueOrUndefined(this._entity.position, time, result);
};
EllipsoidGeometryUpdater.prototype._isHidden = function(entity, ellipsoid) {
  return !defined_default(entity.position) || !defined_default(ellipsoid.radii) || GeometryUpdater_default.prototype._isHidden.call(this, entity, ellipsoid);
};
EllipsoidGeometryUpdater.prototype._isDynamic = function(entity, ellipsoid) {
  return !entity.position.isConstant || !Property_default.isConstant(entity.orientation) || !ellipsoid.radii.isConstant || !Property_default.isConstant(ellipsoid.innerRadii) || !Property_default.isConstant(ellipsoid.stackPartitions) || !Property_default.isConstant(ellipsoid.slicePartitions) || !Property_default.isConstant(ellipsoid.outlineWidth) || !Property_default.isConstant(ellipsoid.minimumClock) || !Property_default.isConstant(ellipsoid.maximumClock) || !Property_default.isConstant(ellipsoid.minimumCone) || !Property_default.isConstant(ellipsoid.maximumCone) || !Property_default.isConstant(ellipsoid.subdivisions);
};
EllipsoidGeometryUpdater.prototype._setStaticOptions = function(entity, ellipsoid) {
  const heightReference = Property_default.getValueOrDefault(
    ellipsoid.heightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  const options = this._options;
  options.vertexFormat = this._materialProperty instanceof ColorMaterialProperty_default ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  options.radii = ellipsoid.radii.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.radii
  );
  options.innerRadii = Property_default.getValueOrUndefined(
    ellipsoid.innerRadii,
    options.radii
  );
  options.minimumClock = Property_default.getValueOrUndefined(
    ellipsoid.minimumClock,
    Iso8601_default.MINIMUM_VALUE
  );
  options.maximumClock = Property_default.getValueOrUndefined(
    ellipsoid.maximumClock,
    Iso8601_default.MINIMUM_VALUE
  );
  options.minimumCone = Property_default.getValueOrUndefined(
    ellipsoid.minimumCone,
    Iso8601_default.MINIMUM_VALUE
  );
  options.maximumCone = Property_default.getValueOrUndefined(
    ellipsoid.maximumCone,
    Iso8601_default.MINIMUM_VALUE
  );
  options.stackPartitions = Property_default.getValueOrUndefined(
    ellipsoid.stackPartitions,
    Iso8601_default.MINIMUM_VALUE
  );
  options.slicePartitions = Property_default.getValueOrUndefined(
    ellipsoid.slicePartitions,
    Iso8601_default.MINIMUM_VALUE
  );
  options.subdivisions = Property_default.getValueOrUndefined(
    ellipsoid.subdivisions,
    Iso8601_default.MINIMUM_VALUE
  );
  options.offsetAttribute = heightReference !== HeightReference_default.NONE ? GeometryOffsetAttribute_default.ALL : void 0;
};
EllipsoidGeometryUpdater.prototype._onEntityPropertyChanged = heightReferenceOnEntityPropertyChanged_default;
EllipsoidGeometryUpdater.DynamicGeometryUpdater = DynamicEllipsoidGeometryUpdater;
function DynamicEllipsoidGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
  this._scene = geometryUpdater._scene;
  this._modelMatrix = new Matrix4_default();
  this._attributes = void 0;
  this._outlineAttributes = void 0;
  this._lastSceneMode = void 0;
  this._lastShow = void 0;
  this._lastOutlineShow = void 0;
  this._lastOutlineWidth = void 0;
  this._lastOutlineColor = void 0;
  this._lastOffset = new Cartesian3_default();
  this._material = {};
}
if (defined_default(Object.create)) {
  DynamicEllipsoidGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DynamicEllipsoidGeometryUpdater.prototype.constructor = DynamicEllipsoidGeometryUpdater;
}
DynamicEllipsoidGeometryUpdater.prototype.update = function(time) {
  Check_default.defined("time", time);
  const entity = this._entity;
  const ellipsoid = entity.ellipsoid;
  if (!entity.isShowing || !entity.isAvailable(time) || !Property_default.getValueOrDefault(ellipsoid.show, time, true)) {
    if (defined_default(this._primitive)) {
      this._primitive.show = false;
    }
    if (defined_default(this._outlinePrimitive)) {
      this._outlinePrimitive.show = false;
    }
    return;
  }
  const radii = Property_default.getValueOrUndefined(
    ellipsoid.radii,
    time,
    radiiScratch
  );
  let modelMatrix = defined_default(radii) ? entity.computeModelMatrixForHeightReference(
    time,
    ellipsoid.heightReference,
    radii.z * 0.5,
    this._scene.mapProjection.ellipsoid,
    this._modelMatrix
  ) : void 0;
  if (!defined_default(modelMatrix) || !defined_default(radii)) {
    if (defined_default(this._primitive)) {
      this._primitive.show = false;
    }
    if (defined_default(this._outlinePrimitive)) {
      this._outlinePrimitive.show = false;
    }
    return;
  }
  const showFill = Property_default.getValueOrDefault(ellipsoid.fill, time, true);
  const showOutline = Property_default.getValueOrDefault(
    ellipsoid.outline,
    time,
    false
  );
  const outlineColor = Property_default.getValueOrClonedDefault(
    ellipsoid.outlineColor,
    time,
    Color_default.BLACK,
    scratchColor15
  );
  const material = MaterialProperty_default.getValue(
    time,
    defaultValue_default(ellipsoid.material, defaultMaterial2),
    this._material
  );
  const innerRadii = Property_default.getValueOrUndefined(
    ellipsoid.innerRadii,
    time,
    innerRadiiScratch
  );
  const minimumClock = Property_default.getValueOrUndefined(
    ellipsoid.minimumClock,
    time
  );
  const maximumClock = Property_default.getValueOrUndefined(
    ellipsoid.maximumClock,
    time
  );
  const minimumCone = Property_default.getValueOrUndefined(ellipsoid.minimumCone, time);
  const maximumCone = Property_default.getValueOrUndefined(ellipsoid.maximumCone, time);
  const stackPartitions = Property_default.getValueOrUndefined(
    ellipsoid.stackPartitions,
    time
  );
  const slicePartitions = Property_default.getValueOrUndefined(
    ellipsoid.slicePartitions,
    time
  );
  const subdivisions = Property_default.getValueOrUndefined(
    ellipsoid.subdivisions,
    time
  );
  const outlineWidth = Property_default.getValueOrDefault(
    ellipsoid.outlineWidth,
    time,
    1
  );
  const heightReference = Property_default.getValueOrDefault(
    ellipsoid.heightReference,
    time,
    HeightReference_default.NONE
  );
  const offsetAttribute = heightReference !== HeightReference_default.NONE ? GeometryOffsetAttribute_default.ALL : void 0;
  const sceneMode = this._scene.mode;
  const in3D = sceneMode === SceneMode_default.SCENE3D && heightReference === HeightReference_default.NONE;
  const options = this._options;
  const shadows = this._geometryUpdater.shadowsProperty.getValue(time);
  const distanceDisplayConditionProperty = this._geometryUpdater.distanceDisplayConditionProperty;
  const distanceDisplayCondition = distanceDisplayConditionProperty.getValue(
    time
  );
  const offset2 = Property_default.getValueOrDefault(
    this._geometryUpdater.terrainOffsetProperty,
    time,
    defaultOffset6,
    offsetScratch8
  );
  const rebuildPrimitives = !in3D || this._lastSceneMode !== sceneMode || !defined_default(this._primitive) || options.stackPartitions !== stackPartitions || options.slicePartitions !== slicePartitions || defined_default(innerRadii) && !Cartesian3_default.equals(options.innerRadii !== innerRadii) || options.minimumClock !== minimumClock || options.maximumClock !== maximumClock || options.minimumCone !== minimumCone || options.maximumCone !== maximumCone || options.subdivisions !== subdivisions || this._lastOutlineWidth !== outlineWidth || options.offsetAttribute !== offsetAttribute;
  if (rebuildPrimitives) {
    const primitives = this._primitives;
    primitives.removeAndDestroy(this._primitive);
    primitives.removeAndDestroy(this._outlinePrimitive);
    this._primitive = void 0;
    this._outlinePrimitive = void 0;
    this._lastSceneMode = sceneMode;
    this._lastOutlineWidth = outlineWidth;
    options.stackPartitions = stackPartitions;
    options.slicePartitions = slicePartitions;
    options.subdivisions = subdivisions;
    options.offsetAttribute = offsetAttribute;
    options.radii = Cartesian3_default.clone(in3D ? unitSphere : radii, options.radii);
    if (defined_default(innerRadii)) {
      if (in3D) {
        const mag = Cartesian3_default.magnitude(radii);
        options.innerRadii = Cartesian3_default.fromElements(
          innerRadii.x / mag,
          innerRadii.y / mag,
          innerRadii.z / mag,
          options.innerRadii
        );
      } else {
        options.innerRadii = Cartesian3_default.clone(innerRadii, options.innerRadii);
      }
    } else {
      options.innerRadii = void 0;
    }
    options.minimumClock = minimumClock;
    options.maximumClock = maximumClock;
    options.minimumCone = minimumCone;
    options.maximumCone = maximumCone;
    const appearance = new MaterialAppearance_default({
      material,
      translucent: material.isTranslucent(),
      closed: true
    });
    options.vertexFormat = appearance.vertexFormat;
    const fillInstance = this._geometryUpdater.createFillGeometryInstance(
      time,
      in3D,
      this._modelMatrix
    );
    this._primitive = primitives.add(
      new Primitive_default({
        geometryInstances: fillInstance,
        appearance,
        asynchronous: false,
        shadows
      })
    );
    const outlineInstance = this._geometryUpdater.createOutlineGeometryInstance(
      time,
      in3D,
      this._modelMatrix
    );
    this._outlinePrimitive = primitives.add(
      new Primitive_default({
        geometryInstances: outlineInstance,
        appearance: new PerInstanceColorAppearance_default({
          flat: true,
          translucent: outlineInstance.attributes.color.value[3] !== 255,
          renderState: {
            lineWidth: this._geometryUpdater._scene.clampLineWidth(
              outlineWidth
            )
          }
        }),
        asynchronous: false,
        shadows
      })
    );
    this._lastShow = showFill;
    this._lastOutlineShow = showOutline;
    this._lastOutlineColor = Color_default.clone(outlineColor, this._lastOutlineColor);
    this._lastDistanceDisplayCondition = distanceDisplayCondition;
    this._lastOffset = Cartesian3_default.clone(offset2, this._lastOffset);
  } else if (this._primitive.ready) {
    const primitive = this._primitive;
    const outlinePrimitive = this._outlinePrimitive;
    primitive.show = true;
    outlinePrimitive.show = true;
    primitive.appearance.material = material;
    let attributes = this._attributes;
    if (!defined_default(attributes)) {
      attributes = primitive.getGeometryInstanceAttributes(entity);
      this._attributes = attributes;
    }
    if (showFill !== this._lastShow) {
      attributes.show = ShowGeometryInstanceAttribute_default.toValue(
        showFill,
        attributes.show
      );
      this._lastShow = showFill;
    }
    let outlineAttributes = this._outlineAttributes;
    if (!defined_default(outlineAttributes)) {
      outlineAttributes = outlinePrimitive.getGeometryInstanceAttributes(
        entity
      );
      this._outlineAttributes = outlineAttributes;
    }
    if (showOutline !== this._lastOutlineShow) {
      outlineAttributes.show = ShowGeometryInstanceAttribute_default.toValue(
        showOutline,
        outlineAttributes.show
      );
      this._lastOutlineShow = showOutline;
    }
    if (!Color_default.equals(outlineColor, this._lastOutlineColor)) {
      outlineAttributes.color = ColorGeometryInstanceAttribute_default.toValue(
        outlineColor,
        outlineAttributes.color
      );
      Color_default.clone(outlineColor, this._lastOutlineColor);
    }
    if (!DistanceDisplayCondition_default.equals(
      distanceDisplayCondition,
      this._lastDistanceDisplayCondition
    )) {
      attributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute_default.toValue(
        distanceDisplayCondition,
        attributes.distanceDisplayCondition
      );
      outlineAttributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute_default.toValue(
        distanceDisplayCondition,
        outlineAttributes.distanceDisplayCondition
      );
      DistanceDisplayCondition_default.clone(
        distanceDisplayCondition,
        this._lastDistanceDisplayCondition
      );
    }
    if (!Cartesian3_default.equals(offset2, this._lastOffset)) {
      attributes.offset = OffsetGeometryInstanceAttribute_default.toValue(
        offset2,
        attributes.offset
      );
      outlineAttributes.offset = OffsetGeometryInstanceAttribute_default.toValue(
        offset2,
        attributes.offset
      );
      Cartesian3_default.clone(offset2, this._lastOffset);
    }
  }
  if (in3D) {
    radii.x = Math.max(radii.x, 1e-3);
    radii.y = Math.max(radii.y, 1e-3);
    radii.z = Math.max(radii.z, 1e-3);
    modelMatrix = Matrix4_default.multiplyByScale(modelMatrix, radii, modelMatrix);
    this._primitive.modelMatrix = modelMatrix;
    this._outlinePrimitive.modelMatrix = modelMatrix;
  }
};
var EllipsoidGeometryUpdater_default = EllipsoidGeometryUpdater;

// node_modules/cesium/Source/DataSources/PlaneGeometryUpdater.js
var positionScratch11 = new Cartesian3_default();
var scratchColor16 = new Color_default();
function PlaneGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.plane = void 0;
  this.dimensions = void 0;
}
function PlaneGeometryUpdater(entity, scene) {
  GeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new PlaneGeometryOptions(entity),
    geometryPropertyName: "plane",
    observedPropertyNames: ["availability", "position", "orientation", "plane"]
  });
  this._onEntityPropertyChanged(entity, "plane", entity.plane, void 0);
}
if (defined_default(Object.create)) {
  PlaneGeometryUpdater.prototype = Object.create(GeometryUpdater_default.prototype);
  PlaneGeometryUpdater.prototype.constructor = PlaneGeometryUpdater;
}
PlaneGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  let attributes;
  let color;
  const show = new ShowGeometryInstanceAttribute_default(
    isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
    distanceDisplayCondition
  );
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor16);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
    attributes = {
      show,
      distanceDisplayCondition: distanceDisplayConditionAttribute,
      color
    };
  } else {
    attributes = {
      show,
      distanceDisplayCondition: distanceDisplayConditionAttribute
    };
  }
  const planeGraphics = entity.plane;
  const options = this._options;
  let modelMatrix = entity.computeModelMatrix(time);
  const plane = Property_default.getValueOrDefault(
    planeGraphics.plane,
    time,
    options.plane
  );
  const dimensions = Property_default.getValueOrUndefined(
    planeGraphics.dimensions,
    time,
    options.dimensions
  );
  options.plane = plane;
  options.dimensions = dimensions;
  modelMatrix = createPrimitiveMatrix(
    plane,
    dimensions,
    modelMatrix,
    modelMatrix
  );
  return new GeometryInstance_default({
    id: entity,
    geometry: new PlaneGeometry_default(this._options),
    modelMatrix,
    attributes
  });
};
PlaneGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._outlineEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent an outlined geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor16
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const planeGraphics = entity.plane;
  const options = this._options;
  let modelMatrix = entity.computeModelMatrix(time);
  const plane = Property_default.getValueOrDefault(
    planeGraphics.plane,
    time,
    options.plane
  );
  const dimensions = Property_default.getValueOrUndefined(
    planeGraphics.dimensions,
    time,
    options.dimensions
  );
  options.plane = plane;
  options.dimensions = dimensions;
  modelMatrix = createPrimitiveMatrix(
    plane,
    dimensions,
    modelMatrix,
    modelMatrix
  );
  return new GeometryInstance_default({
    id: entity,
    geometry: new PlaneOutlineGeometry_default(),
    modelMatrix,
    attributes: {
      show: new ShowGeometryInstanceAttribute_default(
        isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
      ),
      color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
      distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
        distanceDisplayCondition
      )
    }
  });
};
PlaneGeometryUpdater.prototype._isHidden = function(entity, plane) {
  return !defined_default(plane.plane) || !defined_default(plane.dimensions) || !defined_default(entity.position) || GeometryUpdater_default.prototype._isHidden.call(this, entity, plane);
};
PlaneGeometryUpdater.prototype._getIsClosed = function(options) {
  return false;
};
PlaneGeometryUpdater.prototype._isDynamic = function(entity, plane) {
  return !entity.position.isConstant || !Property_default.isConstant(entity.orientation) || !plane.plane.isConstant || !plane.dimensions.isConstant || !Property_default.isConstant(plane.outlineWidth);
};
PlaneGeometryUpdater.prototype._setStaticOptions = function(entity, plane) {
  const isColorMaterial = this._materialProperty instanceof ColorMaterialProperty_default;
  const options = this._options;
  options.vertexFormat = isColorMaterial ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  options.plane = plane.plane.getValue(Iso8601_default.MINIMUM_VALUE, options.plane);
  options.dimensions = plane.dimensions.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.dimensions
  );
};
PlaneGeometryUpdater.DynamicGeometryUpdater = DynamicPlaneGeometryUpdater;
function DynamicPlaneGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
}
if (defined_default(Object.create)) {
  DynamicPlaneGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DynamicPlaneGeometryUpdater.prototype.constructor = DynamicPlaneGeometryUpdater;
}
DynamicPlaneGeometryUpdater.prototype._isHidden = function(entity, plane, time) {
  const options = this._options;
  const position = Property_default.getValueOrUndefined(
    entity.position,
    time,
    positionScratch11
  );
  return !defined_default(position) || !defined_default(options.plane) || !defined_default(options.dimensions) || DynamicGeometryUpdater_default.prototype._isHidden.call(this, entity, plane, time);
};
DynamicPlaneGeometryUpdater.prototype._setOptions = function(entity, plane, time) {
  const options = this._options;
  options.plane = Property_default.getValueOrDefault(plane.plane, time, options.plane);
  options.dimensions = Property_default.getValueOrUndefined(
    plane.dimensions,
    time,
    options.dimensions
  );
};
var scratchAxis2 = new Cartesian3_default();
var scratchUp = new Cartesian3_default();
var scratchTranslation = new Cartesian3_default();
var scratchScale5 = new Cartesian3_default();
var scratchRotation2 = new Matrix3_default();
var scratchRotationScale2 = new Matrix3_default();
var scratchLocalTransform = new Matrix4_default();
function createPrimitiveMatrix(plane, dimensions, transform4, result) {
  const normal2 = plane.normal;
  const distance2 = plane.distance;
  const translation3 = Cartesian3_default.multiplyByScalar(
    normal2,
    -distance2,
    scratchTranslation
  );
  let up = Cartesian3_default.clone(Cartesian3_default.UNIT_Z, scratchUp);
  if (Math_default.equalsEpsilon(
    Math.abs(Cartesian3_default.dot(up, normal2)),
    1,
    Math_default.EPSILON8
  )) {
    up = Cartesian3_default.clone(Cartesian3_default.UNIT_Y, up);
  }
  const left = Cartesian3_default.cross(up, normal2, scratchAxis2);
  up = Cartesian3_default.cross(normal2, left, up);
  Cartesian3_default.normalize(left, left);
  Cartesian3_default.normalize(up, up);
  const rotationMatrix = scratchRotation2;
  Matrix3_default.setColumn(rotationMatrix, 0, left, rotationMatrix);
  Matrix3_default.setColumn(rotationMatrix, 1, up, rotationMatrix);
  Matrix3_default.setColumn(rotationMatrix, 2, normal2, rotationMatrix);
  const scale = Cartesian3_default.fromElements(
    dimensions.x,
    dimensions.y,
    1,
    scratchScale5
  );
  const rotationScaleMatrix = Matrix3_default.multiplyByScale(
    rotationMatrix,
    scale,
    scratchRotationScale2
  );
  const localTransform = Matrix4_default.fromRotationTranslation(
    rotationScaleMatrix,
    translation3,
    scratchLocalTransform
  );
  return Matrix4_default.multiplyTransformation(transform4, localTransform, result);
}
PlaneGeometryUpdater.createPrimitiveMatrix = createPrimitiveMatrix;
var PlaneGeometryUpdater_default = PlaneGeometryUpdater;

// node_modules/cesium/Source/DataSources/PolygonGeometryUpdater.js
var heightAndPerPositionHeightWarning = "Entity polygons cannot have both height and perPositionHeight.  height will be ignored";
var heightReferenceAndPerPositionHeightWarning = "heightReference is not supported for entity polygons with perPositionHeight. heightReference will be ignored";
var scratchColor17 = new Color_default();
var defaultOffset7 = Cartesian3_default.ZERO;
var offsetScratch9 = new Cartesian3_default();
var scratchRectangle7 = new Rectangle_default();
var scratch2DPositions = [];
var cart2Scratch = new Cartesian2_default();
function PolygonGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.polygonHierarchy = void 0;
  this.perPositionHeight = void 0;
  this.closeTop = void 0;
  this.closeBottom = void 0;
  this.height = void 0;
  this.extrudedHeight = void 0;
  this.granularity = void 0;
  this.stRotation = void 0;
  this.offsetAttribute = void 0;
  this.arcType = void 0;
}
function PolygonGeometryUpdater(entity, scene) {
  GroundGeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new PolygonGeometryOptions(entity),
    geometryPropertyName: "polygon",
    observedPropertyNames: ["availability", "polygon"]
  });
  this._onEntityPropertyChanged(entity, "polygon", entity.polygon, void 0);
}
if (defined_default(Object.create)) {
  PolygonGeometryUpdater.prototype = Object.create(
    GroundGeometryUpdater_default.prototype
  );
  PolygonGeometryUpdater.prototype.constructor = PolygonGeometryUpdater;
}
PolygonGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const options = this._options;
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
    ),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      this._distanceDisplayConditionProperty.getValue(time)
    ),
    offset: void 0,
    color: void 0
  };
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor17);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    attributes.color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
  }
  if (defined_default(options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset7,
        offsetScratch9
      )
    );
  }
  let geometry;
  if (options.perPositionHeight && !defined_default(options.extrudedHeight)) {
    geometry = new CoplanarPolygonGeometry_default(options);
  } else {
    geometry = new PolygonGeometry_default(options);
  }
  return new GeometryInstance_default({
    id: entity,
    geometry,
    attributes
  });
};
PolygonGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._outlineEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent an outlined geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const options = this._options;
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor17
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
    ),
    color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      distanceDisplayCondition
    ),
    offset: void 0
  };
  if (defined_default(options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset7,
        offsetScratch9
      )
    );
  }
  let geometry;
  if (options.perPositionHeight && !defined_default(options.extrudedHeight)) {
    geometry = new CoplanarPolygonOutlineGeometry_default(options);
  } else {
    geometry = new PolygonOutlineGeometry_default(options);
  }
  return new GeometryInstance_default({
    id: entity,
    geometry,
    attributes
  });
};
PolygonGeometryUpdater.prototype._computeCenter = function(time, result) {
  const hierarchy = Property_default.getValueOrUndefined(
    this._entity.polygon.hierarchy,
    time
  );
  if (!defined_default(hierarchy)) {
    return;
  }
  const positions = hierarchy.positions;
  if (positions.length === 0) {
    return;
  }
  const ellipsoid = this._scene.mapProjection.ellipsoid;
  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
  const positions2D = tangentPlane.projectPointsOntoPlane(
    positions,
    scratch2DPositions
  );
  const length3 = positions2D.length;
  let area2 = 0;
  let j = length3 - 1;
  let centroid2D = new Cartesian2_default();
  for (let i2 = 0; i2 < length3; j = i2++) {
    const p1 = positions2D[i2];
    const p2 = positions2D[j];
    const f2 = p1.x * p2.y - p2.x * p1.y;
    let sum = Cartesian2_default.add(p1, p2, cart2Scratch);
    sum = Cartesian2_default.multiplyByScalar(sum, f2, sum);
    centroid2D = Cartesian2_default.add(centroid2D, sum, centroid2D);
    area2 += f2;
  }
  const a4 = 1 / (area2 * 3);
  centroid2D = Cartesian2_default.multiplyByScalar(centroid2D, a4, centroid2D);
  return tangentPlane.projectPointOntoEllipsoid(centroid2D, result);
};
PolygonGeometryUpdater.prototype._isHidden = function(entity, polygon) {
  return !defined_default(polygon.hierarchy) || GeometryUpdater_default.prototype._isHidden.call(this, entity, polygon);
};
PolygonGeometryUpdater.prototype._isOnTerrain = function(entity, polygon) {
  const onTerrain = GroundGeometryUpdater_default.prototype._isOnTerrain.call(
    this,
    entity,
    polygon
  );
  const perPositionHeightProperty = polygon.perPositionHeight;
  const perPositionHeightEnabled = defined_default(perPositionHeightProperty) && (perPositionHeightProperty.isConstant ? perPositionHeightProperty.getValue(Iso8601_default.MINIMUM_VALUE) : true);
  return onTerrain && !perPositionHeightEnabled;
};
PolygonGeometryUpdater.prototype._isDynamic = function(entity, polygon) {
  return !polygon.hierarchy.isConstant || !Property_default.isConstant(polygon.height) || !Property_default.isConstant(polygon.extrudedHeight) || !Property_default.isConstant(polygon.granularity) || !Property_default.isConstant(polygon.stRotation) || !Property_default.isConstant(polygon.outlineWidth) || !Property_default.isConstant(polygon.perPositionHeight) || !Property_default.isConstant(polygon.closeTop) || !Property_default.isConstant(polygon.closeBottom) || !Property_default.isConstant(polygon.zIndex) || !Property_default.isConstant(polygon.arcType) || this._onTerrain && !Property_default.isConstant(this._materialProperty) && !(this._materialProperty instanceof ColorMaterialProperty_default);
};
PolygonGeometryUpdater.prototype._setStaticOptions = function(entity, polygon) {
  const isColorMaterial = this._materialProperty instanceof ColorMaterialProperty_default;
  const options = this._options;
  options.vertexFormat = isColorMaterial ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  const hierarchyValue = polygon.hierarchy.getValue(Iso8601_default.MINIMUM_VALUE);
  let heightValue = Property_default.getValueOrUndefined(
    polygon.height,
    Iso8601_default.MINIMUM_VALUE
  );
  const heightReferenceValue = Property_default.getValueOrDefault(
    polygon.heightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  let extrudedHeightValue = Property_default.getValueOrUndefined(
    polygon.extrudedHeight,
    Iso8601_default.MINIMUM_VALUE
  );
  const extrudedHeightReferenceValue = Property_default.getValueOrDefault(
    polygon.extrudedHeightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  const perPositionHeightValue = Property_default.getValueOrDefault(
    polygon.perPositionHeight,
    Iso8601_default.MINIMUM_VALUE,
    false
  );
  heightValue = GroundGeometryUpdater_default.getGeometryHeight(
    heightValue,
    heightReferenceValue
  );
  let offsetAttribute;
  if (perPositionHeightValue) {
    if (defined_default(heightValue)) {
      heightValue = void 0;
      oneTimeWarning_default(heightAndPerPositionHeightWarning);
    }
    if (heightReferenceValue !== HeightReference_default.NONE && perPositionHeightValue) {
      heightValue = void 0;
      oneTimeWarning_default(heightReferenceAndPerPositionHeightWarning);
    }
  } else {
    if (defined_default(extrudedHeightValue) && !defined_default(heightValue)) {
      heightValue = 0;
    }
    offsetAttribute = GroundGeometryUpdater_default.computeGeometryOffsetAttribute(
      heightValue,
      heightReferenceValue,
      extrudedHeightValue,
      extrudedHeightReferenceValue
    );
  }
  options.polygonHierarchy = hierarchyValue;
  options.granularity = Property_default.getValueOrUndefined(
    polygon.granularity,
    Iso8601_default.MINIMUM_VALUE
  );
  options.stRotation = Property_default.getValueOrUndefined(
    polygon.stRotation,
    Iso8601_default.MINIMUM_VALUE
  );
  options.perPositionHeight = perPositionHeightValue;
  options.closeTop = Property_default.getValueOrDefault(
    polygon.closeTop,
    Iso8601_default.MINIMUM_VALUE,
    true
  );
  options.closeBottom = Property_default.getValueOrDefault(
    polygon.closeBottom,
    Iso8601_default.MINIMUM_VALUE,
    true
  );
  options.offsetAttribute = offsetAttribute;
  options.height = heightValue;
  options.arcType = Property_default.getValueOrDefault(
    polygon.arcType,
    Iso8601_default.MINIMUM_VALUE,
    ArcType_default.GEODESIC
  );
  extrudedHeightValue = GroundGeometryUpdater_default.getGeometryExtrudedHeight(
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  if (extrudedHeightValue === GroundGeometryUpdater_default.CLAMP_TO_GROUND) {
    extrudedHeightValue = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
      PolygonGeometry_default.computeRectangle(options, scratchRectangle7)
    ).minimumTerrainHeight;
  }
  options.extrudedHeight = extrudedHeightValue;
};
PolygonGeometryUpdater.prototype._getIsClosed = function(options) {
  const height = options.height;
  const extrudedHeight = options.extrudedHeight;
  const isExtruded = defined_default(extrudedHeight) && extrudedHeight !== height;
  return !options.perPositionHeight && (!isExtruded && height === 0 || isExtruded && options.closeTop && options.closeBottom);
};
PolygonGeometryUpdater.DynamicGeometryUpdater = DyanmicPolygonGeometryUpdater;
function DyanmicPolygonGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
}
if (defined_default(Object.create)) {
  DyanmicPolygonGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DyanmicPolygonGeometryUpdater.prototype.constructor = DyanmicPolygonGeometryUpdater;
}
DyanmicPolygonGeometryUpdater.prototype._isHidden = function(entity, polygon, time) {
  return !defined_default(this._options.polygonHierarchy) || DynamicGeometryUpdater_default.prototype._isHidden.call(this, entity, polygon, time);
};
DyanmicPolygonGeometryUpdater.prototype._setOptions = function(entity, polygon, time) {
  const options = this._options;
  options.polygonHierarchy = Property_default.getValueOrUndefined(
    polygon.hierarchy,
    time
  );
  let heightValue = Property_default.getValueOrUndefined(polygon.height, time);
  const heightReferenceValue = Property_default.getValueOrDefault(
    polygon.heightReference,
    time,
    HeightReference_default.NONE
  );
  const extrudedHeightReferenceValue = Property_default.getValueOrDefault(
    polygon.extrudedHeightReference,
    time,
    HeightReference_default.NONE
  );
  let extrudedHeightValue = Property_default.getValueOrUndefined(
    polygon.extrudedHeight,
    time
  );
  const perPositionHeightValue = Property_default.getValueOrUndefined(
    polygon.perPositionHeight,
    time
  );
  heightValue = GroundGeometryUpdater_default.getGeometryHeight(
    heightValue,
    extrudedHeightReferenceValue
  );
  let offsetAttribute;
  if (perPositionHeightValue) {
    if (defined_default(heightValue)) {
      heightValue = void 0;
      oneTimeWarning_default(heightAndPerPositionHeightWarning);
    }
    if (heightReferenceValue !== HeightReference_default.NONE && perPositionHeightValue) {
      heightValue = void 0;
      oneTimeWarning_default(heightReferenceAndPerPositionHeightWarning);
    }
  } else {
    if (defined_default(extrudedHeightValue) && !defined_default(heightValue)) {
      heightValue = 0;
    }
    offsetAttribute = GroundGeometryUpdater_default.computeGeometryOffsetAttribute(
      heightValue,
      heightReferenceValue,
      extrudedHeightValue,
      extrudedHeightReferenceValue
    );
  }
  options.granularity = Property_default.getValueOrUndefined(polygon.granularity, time);
  options.stRotation = Property_default.getValueOrUndefined(polygon.stRotation, time);
  options.perPositionHeight = Property_default.getValueOrUndefined(
    polygon.perPositionHeight,
    time
  );
  options.closeTop = Property_default.getValueOrDefault(polygon.closeTop, time, true);
  options.closeBottom = Property_default.getValueOrDefault(
    polygon.closeBottom,
    time,
    true
  );
  options.offsetAttribute = offsetAttribute;
  options.height = heightValue;
  options.arcType = Property_default.getValueOrDefault(
    polygon.arcType,
    time,
    ArcType_default.GEODESIC
  );
  extrudedHeightValue = GroundGeometryUpdater_default.getGeometryExtrudedHeight(
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  if (extrudedHeightValue === GroundGeometryUpdater_default.CLAMP_TO_GROUND) {
    extrudedHeightValue = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
      PolygonGeometry_default.computeRectangle(options, scratchRectangle7)
    ).minimumTerrainHeight;
  }
  options.extrudedHeight = extrudedHeightValue;
};
var PolygonGeometryUpdater_default = PolygonGeometryUpdater;

// node_modules/cesium/Source/DataSources/PolylineVolumeGeometryUpdater.js
var scratchColor18 = new Color_default();
function PolylineVolumeGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.polylinePositions = void 0;
  this.shapePositions = void 0;
  this.cornerType = void 0;
  this.granularity = void 0;
}
function PolylineVolumeGeometryUpdater(entity, scene) {
  GeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new PolylineVolumeGeometryOptions(entity),
    geometryPropertyName: "polylineVolume",
    observedPropertyNames: ["availability", "polylineVolume"]
  });
  this._onEntityPropertyChanged(
    entity,
    "polylineVolume",
    entity.polylineVolume,
    void 0
  );
}
if (defined_default(Object.create)) {
  PolylineVolumeGeometryUpdater.prototype = Object.create(
    GeometryUpdater_default.prototype
  );
  PolylineVolumeGeometryUpdater.prototype.constructor = PolylineVolumeGeometryUpdater;
}
PolylineVolumeGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  let attributes;
  let color;
  const show = new ShowGeometryInstanceAttribute_default(
    isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
    distanceDisplayCondition
  );
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor18);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
    attributes = {
      show,
      distanceDisplayCondition: distanceDisplayConditionAttribute,
      color
    };
  } else {
    attributes = {
      show,
      distanceDisplayCondition: distanceDisplayConditionAttribute
    };
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new PolylineVolumeGeometry_default(this._options),
    attributes
  });
};
PolylineVolumeGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._outlineEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent an outlined geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor18
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  return new GeometryInstance_default({
    id: entity,
    geometry: new PolylineVolumeOutlineGeometry_default(this._options),
    attributes: {
      show: new ShowGeometryInstanceAttribute_default(
        isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
      ),
      color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
      distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
        distanceDisplayCondition
      )
    }
  });
};
PolylineVolumeGeometryUpdater.prototype._isHidden = function(entity, polylineVolume) {
  return !defined_default(polylineVolume.positions) || !defined_default(polylineVolume.shape) || GeometryUpdater_default.prototype._isHidden.call(this, entity, polylineVolume);
};
PolylineVolumeGeometryUpdater.prototype._isDynamic = function(entity, polylineVolume) {
  return !polylineVolume.positions.isConstant || !polylineVolume.shape.isConstant || !Property_default.isConstant(polylineVolume.granularity) || !Property_default.isConstant(polylineVolume.outlineWidth) || !Property_default.isConstant(polylineVolume.cornerType);
};
PolylineVolumeGeometryUpdater.prototype._setStaticOptions = function(entity, polylineVolume) {
  const granularity = polylineVolume.granularity;
  const cornerType = polylineVolume.cornerType;
  const options = this._options;
  const isColorMaterial = this._materialProperty instanceof ColorMaterialProperty_default;
  options.vertexFormat = isColorMaterial ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  options.polylinePositions = polylineVolume.positions.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.polylinePositions
  );
  options.shapePositions = polylineVolume.shape.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.shape
  );
  options.granularity = defined_default(granularity) ? granularity.getValue(Iso8601_default.MINIMUM_VALUE) : void 0;
  options.cornerType = defined_default(cornerType) ? cornerType.getValue(Iso8601_default.MINIMUM_VALUE) : void 0;
};
PolylineVolumeGeometryUpdater.DynamicGeometryUpdater = DynamicPolylineVolumeGeometryUpdater;
function DynamicPolylineVolumeGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
}
if (defined_default(Object.create)) {
  DynamicPolylineVolumeGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DynamicPolylineVolumeGeometryUpdater.prototype.constructor = DynamicPolylineVolumeGeometryUpdater;
}
DynamicPolylineVolumeGeometryUpdater.prototype._isHidden = function(entity, polylineVolume, time) {
  const options = this._options;
  return !defined_default(options.polylinePositions) || !defined_default(options.shapePositions) || DynamicGeometryUpdater_default.prototype._isHidden.call(
    this,
    entity,
    polylineVolume,
    time
  );
};
DynamicPolylineVolumeGeometryUpdater.prototype._setOptions = function(entity, polylineVolume, time) {
  const options = this._options;
  options.polylinePositions = Property_default.getValueOrUndefined(
    polylineVolume.positions,
    time,
    options.polylinePositions
  );
  options.shapePositions = Property_default.getValueOrUndefined(
    polylineVolume.shape,
    time
  );
  options.granularity = Property_default.getValueOrUndefined(
    polylineVolume.granularity,
    time
  );
  options.cornerType = Property_default.getValueOrUndefined(
    polylineVolume.cornerType,
    time
  );
};
var PolylineVolumeGeometryUpdater_default = PolylineVolumeGeometryUpdater;

// node_modules/cesium/Source/DataSources/RectangleGeometryUpdater.js
var scratchColor19 = new Color_default();
var defaultOffset8 = Cartesian3_default.ZERO;
var offsetScratch10 = new Cartesian3_default();
var scratchRectangle8 = new Rectangle_default();
var scratchCenterRect = new Rectangle_default();
var scratchCarto3 = new Cartographic_default();
function RectangleGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.rectangle = void 0;
  this.height = void 0;
  this.extrudedHeight = void 0;
  this.granularity = void 0;
  this.stRotation = void 0;
  this.rotation = void 0;
  this.offsetAttribute = void 0;
}
function RectangleGeometryUpdater(entity, scene) {
  GroundGeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new RectangleGeometryOptions(entity),
    geometryPropertyName: "rectangle",
    observedPropertyNames: ["availability", "rectangle"]
  });
  this._onEntityPropertyChanged(
    entity,
    "rectangle",
    entity.rectangle,
    void 0
  );
}
if (defined_default(Object.create)) {
  RectangleGeometryUpdater.prototype = Object.create(
    GroundGeometryUpdater_default.prototype
  );
  RectangleGeometryUpdater.prototype.constructor = RectangleGeometryUpdater;
}
RectangleGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
    ),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      this._distanceDisplayConditionProperty.getValue(time)
    ),
    offset: void 0,
    color: void 0
  };
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor19);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    attributes.color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
  }
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset8,
        offsetScratch10
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new RectangleGeometry_default(this._options),
    attributes
  });
};
RectangleGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._outlineEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent an outlined geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor19
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const attributes = {
    show: new ShowGeometryInstanceAttribute_default(
      isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
    ),
    color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
      distanceDisplayCondition
    ),
    offset: void 0
  };
  if (defined_default(this._options.offsetAttribute)) {
    attributes.offset = OffsetGeometryInstanceAttribute_default.fromCartesian3(
      Property_default.getValueOrDefault(
        this._terrainOffsetProperty,
        time,
        defaultOffset8,
        offsetScratch10
      )
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new RectangleOutlineGeometry_default(this._options),
    attributes
  });
};
RectangleGeometryUpdater.prototype._computeCenter = function(time, result) {
  const rect = Property_default.getValueOrUndefined(
    this._entity.rectangle.coordinates,
    time,
    scratchCenterRect
  );
  if (!defined_default(rect)) {
    return;
  }
  const center = Rectangle_default.center(rect, scratchCarto3);
  return Cartographic_default.toCartesian(center, Ellipsoid_default.WGS84, result);
};
RectangleGeometryUpdater.prototype._isHidden = function(entity, rectangle) {
  return !defined_default(rectangle.coordinates) || GeometryUpdater_default.prototype._isHidden.call(this, entity, rectangle);
};
RectangleGeometryUpdater.prototype._isDynamic = function(entity, rectangle) {
  return !rectangle.coordinates.isConstant || !Property_default.isConstant(rectangle.height) || !Property_default.isConstant(rectangle.extrudedHeight) || !Property_default.isConstant(rectangle.granularity) || !Property_default.isConstant(rectangle.stRotation) || !Property_default.isConstant(rectangle.rotation) || !Property_default.isConstant(rectangle.outlineWidth) || !Property_default.isConstant(rectangle.zIndex) || this._onTerrain && !Property_default.isConstant(this._materialProperty) && !(this._materialProperty instanceof ColorMaterialProperty_default);
};
RectangleGeometryUpdater.prototype._setStaticOptions = function(entity, rectangle) {
  const isColorMaterial = this._materialProperty instanceof ColorMaterialProperty_default;
  let heightValue = Property_default.getValueOrUndefined(
    rectangle.height,
    Iso8601_default.MINIMUM_VALUE
  );
  const heightReferenceValue = Property_default.getValueOrDefault(
    rectangle.heightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  let extrudedHeightValue = Property_default.getValueOrUndefined(
    rectangle.extrudedHeight,
    Iso8601_default.MINIMUM_VALUE
  );
  const extrudedHeightReferenceValue = Property_default.getValueOrDefault(
    rectangle.extrudedHeightReference,
    Iso8601_default.MINIMUM_VALUE,
    HeightReference_default.NONE
  );
  if (defined_default(extrudedHeightValue) && !defined_default(heightValue)) {
    heightValue = 0;
  }
  const options = this._options;
  options.vertexFormat = isColorMaterial ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  options.rectangle = rectangle.coordinates.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.rectangle
  );
  options.granularity = Property_default.getValueOrUndefined(
    rectangle.granularity,
    Iso8601_default.MINIMUM_VALUE
  );
  options.stRotation = Property_default.getValueOrUndefined(
    rectangle.stRotation,
    Iso8601_default.MINIMUM_VALUE
  );
  options.rotation = Property_default.getValueOrUndefined(
    rectangle.rotation,
    Iso8601_default.MINIMUM_VALUE
  );
  options.offsetAttribute = GroundGeometryUpdater_default.computeGeometryOffsetAttribute(
    heightValue,
    heightReferenceValue,
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  options.height = GroundGeometryUpdater_default.getGeometryHeight(
    heightValue,
    heightReferenceValue
  );
  extrudedHeightValue = GroundGeometryUpdater_default.getGeometryExtrudedHeight(
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  if (extrudedHeightValue === GroundGeometryUpdater_default.CLAMP_TO_GROUND) {
    extrudedHeightValue = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
      RectangleGeometry_default.computeRectangle(options, scratchRectangle8)
    ).minimumTerrainHeight;
  }
  options.extrudedHeight = extrudedHeightValue;
};
RectangleGeometryUpdater.DynamicGeometryUpdater = DynamicRectangleGeometryUpdater;
function DynamicRectangleGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
}
if (defined_default(Object.create)) {
  DynamicRectangleGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DynamicRectangleGeometryUpdater.prototype.constructor = DynamicRectangleGeometryUpdater;
}
DynamicRectangleGeometryUpdater.prototype._isHidden = function(entity, rectangle, time) {
  return !defined_default(this._options.rectangle) || DynamicGeometryUpdater_default.prototype._isHidden.call(
    this,
    entity,
    rectangle,
    time
  );
};
DynamicRectangleGeometryUpdater.prototype._setOptions = function(entity, rectangle, time) {
  const options = this._options;
  let heightValue = Property_default.getValueOrUndefined(rectangle.height, time);
  const heightReferenceValue = Property_default.getValueOrDefault(
    rectangle.heightReference,
    time,
    HeightReference_default.NONE
  );
  let extrudedHeightValue = Property_default.getValueOrUndefined(
    rectangle.extrudedHeight,
    time
  );
  const extrudedHeightReferenceValue = Property_default.getValueOrDefault(
    rectangle.extrudedHeightReference,
    time,
    HeightReference_default.NONE
  );
  if (defined_default(extrudedHeightValue) && !defined_default(heightValue)) {
    heightValue = 0;
  }
  options.rectangle = Property_default.getValueOrUndefined(
    rectangle.coordinates,
    time,
    options.rectangle
  );
  options.granularity = Property_default.getValueOrUndefined(
    rectangle.granularity,
    time
  );
  options.stRotation = Property_default.getValueOrUndefined(rectangle.stRotation, time);
  options.rotation = Property_default.getValueOrUndefined(rectangle.rotation, time);
  options.offsetAttribute = GroundGeometryUpdater_default.computeGeometryOffsetAttribute(
    heightValue,
    heightReferenceValue,
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  options.height = GroundGeometryUpdater_default.getGeometryHeight(
    heightValue,
    heightReferenceValue
  );
  extrudedHeightValue = GroundGeometryUpdater_default.getGeometryExtrudedHeight(
    extrudedHeightValue,
    extrudedHeightReferenceValue
  );
  if (extrudedHeightValue === GroundGeometryUpdater_default.CLAMP_TO_GROUND) {
    extrudedHeightValue = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
      RectangleGeometry_default.computeRectangle(options, scratchRectangle8)
    ).minimumTerrainHeight;
  }
  options.extrudedHeight = extrudedHeightValue;
};
var RectangleGeometryUpdater_default = RectangleGeometryUpdater;

// node_modules/cesium/Source/DataSources/StaticGeometryColorBatch.js
var colorScratch3 = new Color_default();
var distanceDisplayConditionScratch2 = new DistanceDisplayCondition_default();
var defaultDistanceDisplayCondition2 = new DistanceDisplayCondition_default();
var defaultOffset9 = Cartesian3_default.ZERO;
var offsetScratch11 = new Cartesian3_default();
function Batch(primitives, translucent, appearanceType, depthFailAppearanceType, depthFailMaterialProperty, closed, shadows) {
  this.translucent = translucent;
  this.appearanceType = appearanceType;
  this.depthFailAppearanceType = depthFailAppearanceType;
  this.depthFailMaterialProperty = depthFailMaterialProperty;
  this.depthFailMaterial = void 0;
  this.closed = closed;
  this.shadows = shadows;
  this.primitives = primitives;
  this.createPrimitive = false;
  this.waitingOnCreate = false;
  this.primitive = void 0;
  this.oldPrimitive = void 0;
  this.geometry = new AssociativeArray_default();
  this.updaters = new AssociativeArray_default();
  this.updatersWithAttributes = new AssociativeArray_default();
  this.attributes = new AssociativeArray_default();
  this.subscriptions = new AssociativeArray_default();
  this.showsUpdated = new AssociativeArray_default();
  this.itemsToRemove = [];
  this.invalidated = false;
  let removeMaterialSubscription;
  if (defined_default(depthFailMaterialProperty)) {
    removeMaterialSubscription = depthFailMaterialProperty.definitionChanged.addEventListener(
      Batch.prototype.onMaterialChanged,
      this
    );
  }
  this.removeMaterialSubscription = removeMaterialSubscription;
}
Batch.prototype.onMaterialChanged = function() {
  this.invalidated = true;
};
Batch.prototype.isMaterial = function(updater) {
  const material = this.depthFailMaterialProperty;
  const updaterMaterial = updater.depthFailMaterialProperty;
  if (updaterMaterial === material) {
    return true;
  }
  if (defined_default(material)) {
    return material.equals(updaterMaterial);
  }
  return false;
};
Batch.prototype.add = function(updater, instance) {
  const id = updater.id;
  this.createPrimitive = true;
  this.geometry.set(id, instance);
  this.updaters.set(id, updater);
  if (!updater.hasConstantFill || !updater.fillMaterialProperty.isConstant || !Property_default.isConstant(updater.distanceDisplayConditionProperty) || !Property_default.isConstant(updater.terrainOffsetProperty)) {
    this.updatersWithAttributes.set(id, updater);
  } else {
    const that = this;
    this.subscriptions.set(
      id,
      updater.entity.definitionChanged.addEventListener(function(entity, propertyName, newValue, oldValue2) {
        if (propertyName === "isShowing") {
          that.showsUpdated.set(updater.id, updater);
        }
      })
    );
  }
};
Batch.prototype.remove = function(updater) {
  const id = updater.id;
  this.createPrimitive = this.geometry.remove(id) || this.createPrimitive;
  if (this.updaters.remove(id)) {
    this.updatersWithAttributes.remove(id);
    const unsubscribe2 = this.subscriptions.get(id);
    if (defined_default(unsubscribe2)) {
      unsubscribe2();
      this.subscriptions.remove(id);
      this.showsUpdated.remove(id);
    }
    return true;
  }
  return false;
};
Batch.prototype.update = function(time) {
  let isUpdated = true;
  let removedCount = 0;
  let primitive = this.primitive;
  const primitives = this.primitives;
  let i2;
  if (this.createPrimitive) {
    const geometries = this.geometry.values;
    const geometriesLength = geometries.length;
    if (geometriesLength > 0) {
      if (defined_default(primitive)) {
        if (!defined_default(this.oldPrimitive)) {
          this.oldPrimitive = primitive;
        } else {
          primitives.remove(primitive);
        }
      }
      let depthFailAppearance;
      if (defined_default(this.depthFailAppearanceType)) {
        if (defined_default(this.depthFailMaterialProperty)) {
          this.depthFailMaterial = MaterialProperty_default.getValue(
            time,
            this.depthFailMaterialProperty,
            this.depthFailMaterial
          );
        }
        depthFailAppearance = new this.depthFailAppearanceType({
          material: this.depthFailMaterial,
          translucent: this.translucent,
          closed: this.closed
        });
      }
      primitive = new Primitive_default({
        show: false,
        asynchronous: true,
        geometryInstances: geometries.slice(),
        appearance: new this.appearanceType({
          translucent: this.translucent,
          closed: this.closed
        }),
        depthFailAppearance,
        shadows: this.shadows
      });
      primitives.add(primitive);
      isUpdated = false;
    } else {
      if (defined_default(primitive)) {
        primitives.remove(primitive);
        primitive = void 0;
      }
      const oldPrimitive = this.oldPrimitive;
      if (defined_default(oldPrimitive)) {
        primitives.remove(oldPrimitive);
        this.oldPrimitive = void 0;
      }
    }
    this.attributes.removeAll();
    this.primitive = primitive;
    this.createPrimitive = false;
    this.waitingOnCreate = true;
  } else if (defined_default(primitive) && primitive.ready) {
    primitive.show = true;
    if (defined_default(this.oldPrimitive)) {
      primitives.remove(this.oldPrimitive);
      this.oldPrimitive = void 0;
    }
    if (defined_default(this.depthFailAppearanceType) && !(this.depthFailMaterialProperty instanceof ColorMaterialProperty_default)) {
      this.depthFailMaterial = MaterialProperty_default.getValue(
        time,
        this.depthFailMaterialProperty,
        this.depthFailMaterial
      );
      this.primitive.depthFailAppearance.material = this.depthFailMaterial;
    }
    const updatersWithAttributes = this.updatersWithAttributes.values;
    const length3 = updatersWithAttributes.length;
    const waitingOnCreate = this.waitingOnCreate;
    for (i2 = 0; i2 < length3; i2++) {
      const updater = updatersWithAttributes[i2];
      const instance = this.geometry.get(updater.id);
      let attributes = this.attributes.get(instance.id.id);
      if (!defined_default(attributes)) {
        attributes = primitive.getGeometryInstanceAttributes(instance.id);
        this.attributes.set(instance.id.id, attributes);
      }
      if (!updater.fillMaterialProperty.isConstant || waitingOnCreate) {
        const colorProperty = updater.fillMaterialProperty.color;
        const resultColor = Property_default.getValueOrDefault(
          colorProperty,
          time,
          Color_default.WHITE,
          colorScratch3
        );
        if (!Color_default.equals(attributes._lastColor, resultColor)) {
          attributes._lastColor = Color_default.clone(
            resultColor,
            attributes._lastColor
          );
          attributes.color = ColorGeometryInstanceAttribute_default.toValue(
            resultColor,
            attributes.color
          );
          if (this.translucent && attributes.color[3] === 255 || !this.translucent && attributes.color[3] !== 255) {
            this.itemsToRemove[removedCount++] = updater;
          }
        }
      }
      if (defined_default(this.depthFailAppearanceType) && updater.depthFailMaterialProperty instanceof ColorMaterialProperty_default && (!updater.depthFailMaterialProperty.isConstant || waitingOnCreate)) {
        const depthFailColorProperty = updater.depthFailMaterialProperty.color;
        const depthColor = Property_default.getValueOrDefault(
          depthFailColorProperty,
          time,
          Color_default.WHITE,
          colorScratch3
        );
        if (!Color_default.equals(attributes._lastDepthFailColor, depthColor)) {
          attributes._lastDepthFailColor = Color_default.clone(
            depthColor,
            attributes._lastDepthFailColor
          );
          attributes.depthFailColor = ColorGeometryInstanceAttribute_default.toValue(
            depthColor,
            attributes.depthFailColor
          );
        }
      }
      const show = updater.entity.isShowing && (updater.hasConstantFill || updater.isFilled(time));
      const currentShow = attributes.show[0] === 1;
      if (show !== currentShow) {
        attributes.show = ShowGeometryInstanceAttribute_default.toValue(
          show,
          attributes.show
        );
      }
      const distanceDisplayConditionProperty = updater.distanceDisplayConditionProperty;
      if (!Property_default.isConstant(distanceDisplayConditionProperty)) {
        const distanceDisplayCondition = Property_default.getValueOrDefault(
          distanceDisplayConditionProperty,
          time,
          defaultDistanceDisplayCondition2,
          distanceDisplayConditionScratch2
        );
        if (!DistanceDisplayCondition_default.equals(
          distanceDisplayCondition,
          attributes._lastDistanceDisplayCondition
        )) {
          attributes._lastDistanceDisplayCondition = DistanceDisplayCondition_default.clone(
            distanceDisplayCondition,
            attributes._lastDistanceDisplayCondition
          );
          attributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute_default.toValue(
            distanceDisplayCondition,
            attributes.distanceDisplayCondition
          );
        }
      }
      const offsetProperty = updater.terrainOffsetProperty;
      if (!Property_default.isConstant(offsetProperty)) {
        const offset2 = Property_default.getValueOrDefault(
          offsetProperty,
          time,
          defaultOffset9,
          offsetScratch11
        );
        if (!Cartesian3_default.equals(offset2, attributes._lastOffset)) {
          attributes._lastOffset = Cartesian3_default.clone(
            offset2,
            attributes._lastOffset
          );
          attributes.offset = OffsetGeometryInstanceAttribute_default.toValue(
            offset2,
            attributes.offset
          );
        }
      }
    }
    this.updateShows(primitive);
    this.waitingOnCreate = false;
  } else if (defined_default(primitive) && !primitive.ready) {
    isUpdated = false;
  }
  this.itemsToRemove.length = removedCount;
  return isUpdated;
};
Batch.prototype.updateShows = function(primitive) {
  const showsUpdated = this.showsUpdated.values;
  const length3 = showsUpdated.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const updater = showsUpdated[i2];
    const instance = this.geometry.get(updater.id);
    let attributes = this.attributes.get(instance.id.id);
    if (!defined_default(attributes)) {
      attributes = primitive.getGeometryInstanceAttributes(instance.id);
      this.attributes.set(instance.id.id, attributes);
    }
    const show = updater.entity.isShowing;
    const currentShow = attributes.show[0] === 1;
    if (show !== currentShow) {
      attributes.show = ShowGeometryInstanceAttribute_default.toValue(
        show,
        attributes.show
      );
      instance.attributes.show.value[0] = attributes.show[0];
    }
  }
  this.showsUpdated.removeAll();
};
Batch.prototype.contains = function(updater) {
  return this.updaters.contains(updater.id);
};
Batch.prototype.getBoundingSphere = function(updater, result) {
  const primitive = this.primitive;
  if (!primitive.ready) {
    return BoundingSphereState_default.PENDING;
  }
  const attributes = primitive.getGeometryInstanceAttributes(updater.entity);
  if (!defined_default(attributes) || !defined_default(attributes.boundingSphere) || defined_default(attributes.show) && attributes.show[0] === 0) {
    return BoundingSphereState_default.FAILED;
  }
  attributes.boundingSphere.clone(result);
  return BoundingSphereState_default.DONE;
};
Batch.prototype.destroy = function() {
  const primitive = this.primitive;
  const primitives = this.primitives;
  if (defined_default(primitive)) {
    primitives.remove(primitive);
  }
  const oldPrimitive = this.oldPrimitive;
  if (defined_default(oldPrimitive)) {
    primitives.remove(oldPrimitive);
  }
  if (defined_default(this.removeMaterialSubscription)) {
    this.removeMaterialSubscription();
  }
};
function StaticGeometryColorBatch(primitives, appearanceType, depthFailAppearanceType, closed, shadows) {
  this._solidItems = [];
  this._translucentItems = [];
  this._primitives = primitives;
  this._appearanceType = appearanceType;
  this._depthFailAppearanceType = depthFailAppearanceType;
  this._closed = closed;
  this._shadows = shadows;
}
StaticGeometryColorBatch.prototype.add = function(time, updater) {
  let items;
  let translucent;
  const instance = updater.createFillGeometryInstance(time);
  if (instance.attributes.color.value[3] === 255) {
    items = this._solidItems;
    translucent = false;
  } else {
    items = this._translucentItems;
    translucent = true;
  }
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const item = items[i2];
    if (item.isMaterial(updater)) {
      item.add(updater, instance);
      return;
    }
  }
  const batch = new Batch(
    this._primitives,
    translucent,
    this._appearanceType,
    this._depthFailAppearanceType,
    updater.depthFailMaterialProperty,
    this._closed,
    this._shadows
  );
  batch.add(updater, instance);
  items.push(batch);
};
function removeItem(items, updater) {
  const length3 = items.length;
  for (let i2 = length3 - 1; i2 >= 0; i2--) {
    const item = items[i2];
    if (item.remove(updater)) {
      if (item.updaters.length === 0) {
        items.splice(i2, 1);
        item.destroy();
      }
      return true;
    }
  }
  return false;
}
StaticGeometryColorBatch.prototype.remove = function(updater) {
  if (!removeItem(this._solidItems, updater)) {
    removeItem(this._translucentItems, updater);
  }
};
function moveItems(batch, items, time) {
  let itemsMoved = false;
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const item = items[i2];
    const itemsToRemove = item.itemsToRemove;
    const itemsToMoveLength = itemsToRemove.length;
    if (itemsToMoveLength > 0) {
      for (i2 = 0; i2 < itemsToMoveLength; i2++) {
        const updater = itemsToRemove[i2];
        item.remove(updater);
        batch.add(time, updater);
        itemsMoved = true;
      }
    }
  }
  return itemsMoved;
}
function updateItems(batch, items, time, isUpdated) {
  let length3 = items.length;
  let i2;
  for (i2 = length3 - 1; i2 >= 0; i2--) {
    const item = items[i2];
    if (item.invalidated) {
      items.splice(i2, 1);
      const updaters = item.updaters.values;
      const updatersLength = updaters.length;
      for (let h = 0; h < updatersLength; h++) {
        batch.add(time, updaters[h]);
      }
      item.destroy();
    }
  }
  length3 = items.length;
  for (i2 = 0; i2 < length3; ++i2) {
    isUpdated = items[i2].update(time) && isUpdated;
  }
  return isUpdated;
}
StaticGeometryColorBatch.prototype.update = function(time) {
  let isUpdated = updateItems(this, this._solidItems, time, true);
  isUpdated = updateItems(this, this._translucentItems, time, isUpdated) && isUpdated;
  const solidsMoved = moveItems(this, this._solidItems, time);
  const translucentsMoved = moveItems(this, this._translucentItems, time);
  if (solidsMoved || translucentsMoved) {
    isUpdated = updateItems(this, this._solidItems, time, isUpdated) && isUpdated;
    isUpdated = updateItems(this, this._translucentItems, time, isUpdated) && isUpdated;
  }
  return isUpdated;
};
function getBoundingSphere(items, updater, result) {
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const item = items[i2];
    if (item.contains(updater)) {
      return item.getBoundingSphere(updater, result);
    }
  }
  return BoundingSphereState_default.FAILED;
}
StaticGeometryColorBatch.prototype.getBoundingSphere = function(updater, result) {
  const boundingSphere = getBoundingSphere(this._solidItems, updater, result);
  if (boundingSphere === BoundingSphereState_default.FAILED) {
    return getBoundingSphere(this._translucentItems, updater, result);
  }
  return boundingSphere;
};
function removeAllPrimitives(items) {
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    items[i2].destroy();
  }
  items.length = 0;
}
StaticGeometryColorBatch.prototype.removeAllPrimitives = function() {
  removeAllPrimitives(this._solidItems);
  removeAllPrimitives(this._translucentItems);
};
var StaticGeometryColorBatch_default = StaticGeometryColorBatch;

// node_modules/cesium/Source/DataSources/StaticGeometryPerMaterialBatch.js
var distanceDisplayConditionScratch3 = new DistanceDisplayCondition_default();
var defaultDistanceDisplayCondition3 = new DistanceDisplayCondition_default();
var defaultOffset10 = Cartesian3_default.ZERO;
var offsetScratch12 = new Cartesian3_default();
function Batch2(primitives, appearanceType, materialProperty, depthFailAppearanceType, depthFailMaterialProperty, closed, shadows) {
  this.primitives = primitives;
  this.appearanceType = appearanceType;
  this.materialProperty = materialProperty;
  this.depthFailAppearanceType = depthFailAppearanceType;
  this.depthFailMaterialProperty = depthFailMaterialProperty;
  this.closed = closed;
  this.shadows = shadows;
  this.updaters = new AssociativeArray_default();
  this.createPrimitive = true;
  this.primitive = void 0;
  this.oldPrimitive = void 0;
  this.geometry = new AssociativeArray_default();
  this.material = void 0;
  this.depthFailMaterial = void 0;
  this.updatersWithAttributes = new AssociativeArray_default();
  this.attributes = new AssociativeArray_default();
  this.invalidated = false;
  this.removeMaterialSubscription = materialProperty.definitionChanged.addEventListener(
    Batch2.prototype.onMaterialChanged,
    this
  );
  this.subscriptions = new AssociativeArray_default();
  this.showsUpdated = new AssociativeArray_default();
}
Batch2.prototype.onMaterialChanged = function() {
  this.invalidated = true;
};
Batch2.prototype.isMaterial = function(updater) {
  const material = this.materialProperty;
  const updaterMaterial = updater.fillMaterialProperty;
  const depthFailMaterial = this.depthFailMaterialProperty;
  const updaterDepthFailMaterial = updater.depthFailMaterialProperty;
  if (updaterMaterial === material && updaterDepthFailMaterial === depthFailMaterial) {
    return true;
  }
  let equals2 = defined_default(material) && material.equals(updaterMaterial);
  equals2 = (!defined_default(depthFailMaterial) && !defined_default(updaterDepthFailMaterial) || defined_default(depthFailMaterial) && depthFailMaterial.equals(updaterDepthFailMaterial)) && equals2;
  return equals2;
};
Batch2.prototype.add = function(time, updater) {
  const id = updater.id;
  this.updaters.set(id, updater);
  this.geometry.set(id, updater.createFillGeometryInstance(time));
  if (!updater.hasConstantFill || !updater.fillMaterialProperty.isConstant || !Property_default.isConstant(updater.distanceDisplayConditionProperty) || !Property_default.isConstant(updater.terrainOffsetProperty)) {
    this.updatersWithAttributes.set(id, updater);
  } else {
    const that = this;
    this.subscriptions.set(
      id,
      updater.entity.definitionChanged.addEventListener(function(entity, propertyName, newValue, oldValue2) {
        if (propertyName === "isShowing") {
          that.showsUpdated.set(updater.id, updater);
        }
      })
    );
  }
  this.createPrimitive = true;
};
Batch2.prototype.remove = function(updater) {
  const id = updater.id;
  this.createPrimitive = this.geometry.remove(id) || this.createPrimitive;
  if (this.updaters.remove(id)) {
    this.updatersWithAttributes.remove(id);
    const unsubscribe2 = this.subscriptions.get(id);
    if (defined_default(unsubscribe2)) {
      unsubscribe2();
      this.subscriptions.remove(id);
      this.showsUpdated.remove(id);
    }
    return true;
  }
  return false;
};
var colorScratch4 = new Color_default();
Batch2.prototype.update = function(time) {
  let isUpdated = true;
  let primitive = this.primitive;
  const primitives = this.primitives;
  const geometries = this.geometry.values;
  let i2;
  if (this.createPrimitive) {
    const geometriesLength = geometries.length;
    if (geometriesLength > 0) {
      if (defined_default(primitive)) {
        if (!defined_default(this.oldPrimitive)) {
          this.oldPrimitive = primitive;
        } else {
          primitives.remove(primitive);
        }
      }
      this.material = MaterialProperty_default.getValue(
        time,
        this.materialProperty,
        this.material
      );
      let depthFailAppearance;
      if (defined_default(this.depthFailMaterialProperty)) {
        this.depthFailMaterial = MaterialProperty_default.getValue(
          time,
          this.depthFailMaterialProperty,
          this.depthFailMaterial
        );
        depthFailAppearance = new this.depthFailAppearanceType({
          material: this.depthFailMaterial,
          translucent: this.depthFailMaterial.isTranslucent(),
          closed: this.closed
        });
      }
      primitive = new Primitive_default({
        show: false,
        asynchronous: true,
        geometryInstances: geometries.slice(),
        appearance: new this.appearanceType({
          material: this.material,
          translucent: this.material.isTranslucent(),
          closed: this.closed
        }),
        depthFailAppearance,
        shadows: this.shadows
      });
      primitives.add(primitive);
      isUpdated = false;
    } else {
      if (defined_default(primitive)) {
        primitives.remove(primitive);
        primitive = void 0;
      }
      const oldPrimitive = this.oldPrimitive;
      if (defined_default(oldPrimitive)) {
        primitives.remove(oldPrimitive);
        this.oldPrimitive = void 0;
      }
    }
    this.attributes.removeAll();
    this.primitive = primitive;
    this.createPrimitive = false;
  } else if (defined_default(primitive) && primitive.ready) {
    primitive.show = true;
    if (defined_default(this.oldPrimitive)) {
      primitives.remove(this.oldPrimitive);
      this.oldPrimitive = void 0;
    }
    this.material = MaterialProperty_default.getValue(
      time,
      this.materialProperty,
      this.material
    );
    this.primitive.appearance.material = this.material;
    if (defined_default(this.depthFailAppearanceType) && !(this.depthFailMaterialProperty instanceof ColorMaterialProperty_default)) {
      this.depthFailMaterial = MaterialProperty_default.getValue(
        time,
        this.depthFailMaterialProperty,
        this.depthFailMaterial
      );
      this.primitive.depthFailAppearance.material = this.depthFailMaterial;
    }
    const updatersWithAttributes = this.updatersWithAttributes.values;
    const length3 = updatersWithAttributes.length;
    for (i2 = 0; i2 < length3; i2++) {
      const updater = updatersWithAttributes[i2];
      const entity = updater.entity;
      const instance = this.geometry.get(updater.id);
      let attributes = this.attributes.get(instance.id.id);
      if (!defined_default(attributes)) {
        attributes = primitive.getGeometryInstanceAttributes(instance.id);
        this.attributes.set(instance.id.id, attributes);
      }
      if (defined_default(this.depthFailAppearanceType) && this.depthFailMaterialProperty instanceof ColorMaterialProperty_default && !updater.depthFailMaterialProperty.isConstant) {
        const depthFailColorProperty = updater.depthFailMaterialProperty.color;
        const depthFailColor = Property_default.getValueOrDefault(
          depthFailColorProperty,
          time,
          Color_default.WHITE,
          colorScratch4
        );
        if (!Color_default.equals(attributes._lastDepthFailColor, depthFailColor)) {
          attributes._lastDepthFailColor = Color_default.clone(
            depthFailColor,
            attributes._lastDepthFailColor
          );
          attributes.depthFailColor = ColorGeometryInstanceAttribute_default.toValue(
            depthFailColor,
            attributes.depthFailColor
          );
        }
      }
      const show = entity.isShowing && (updater.hasConstantFill || updater.isFilled(time));
      const currentShow = attributes.show[0] === 1;
      if (show !== currentShow) {
        attributes.show = ShowGeometryInstanceAttribute_default.toValue(
          show,
          attributes.show
        );
      }
      const distanceDisplayConditionProperty = updater.distanceDisplayConditionProperty;
      if (!Property_default.isConstant(distanceDisplayConditionProperty)) {
        const distanceDisplayCondition = Property_default.getValueOrDefault(
          distanceDisplayConditionProperty,
          time,
          defaultDistanceDisplayCondition3,
          distanceDisplayConditionScratch3
        );
        if (!DistanceDisplayCondition_default.equals(
          distanceDisplayCondition,
          attributes._lastDistanceDisplayCondition
        )) {
          attributes._lastDistanceDisplayCondition = DistanceDisplayCondition_default.clone(
            distanceDisplayCondition,
            attributes._lastDistanceDisplayCondition
          );
          attributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute_default.toValue(
            distanceDisplayCondition,
            attributes.distanceDisplayCondition
          );
        }
      }
      const offsetProperty = updater.terrainOffsetProperty;
      if (!Property_default.isConstant(offsetProperty)) {
        const offset2 = Property_default.getValueOrDefault(
          offsetProperty,
          time,
          defaultOffset10,
          offsetScratch12
        );
        if (!Cartesian3_default.equals(offset2, attributes._lastOffset)) {
          attributes._lastOffset = Cartesian3_default.clone(
            offset2,
            attributes._lastOffset
          );
          attributes.offset = OffsetGeometryInstanceAttribute_default.toValue(
            offset2,
            attributes.offset
          );
        }
      }
    }
    this.updateShows(primitive);
  } else if (defined_default(primitive) && !primitive.ready) {
    isUpdated = false;
  }
  return isUpdated;
};
Batch2.prototype.updateShows = function(primitive) {
  const showsUpdated = this.showsUpdated.values;
  const length3 = showsUpdated.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const updater = showsUpdated[i2];
    const entity = updater.entity;
    const instance = this.geometry.get(updater.id);
    let attributes = this.attributes.get(instance.id.id);
    if (!defined_default(attributes)) {
      attributes = primitive.getGeometryInstanceAttributes(instance.id);
      this.attributes.set(instance.id.id, attributes);
    }
    const show = entity.isShowing;
    const currentShow = attributes.show[0] === 1;
    if (show !== currentShow) {
      attributes.show = ShowGeometryInstanceAttribute_default.toValue(
        show,
        attributes.show
      );
      instance.attributes.show.value[0] = attributes.show[0];
    }
  }
  this.showsUpdated.removeAll();
};
Batch2.prototype.contains = function(updater) {
  return this.updaters.contains(updater.id);
};
Batch2.prototype.getBoundingSphere = function(updater, result) {
  const primitive = this.primitive;
  if (!primitive.ready) {
    return BoundingSphereState_default.PENDING;
  }
  const attributes = primitive.getGeometryInstanceAttributes(updater.entity);
  if (!defined_default(attributes) || !defined_default(attributes.boundingSphere) || defined_default(attributes.show) && attributes.show[0] === 0) {
    return BoundingSphereState_default.FAILED;
  }
  attributes.boundingSphere.clone(result);
  return BoundingSphereState_default.DONE;
};
Batch2.prototype.destroy = function() {
  const primitive = this.primitive;
  const primitives = this.primitives;
  if (defined_default(primitive)) {
    primitives.remove(primitive);
  }
  const oldPrimitive = this.oldPrimitive;
  if (defined_default(oldPrimitive)) {
    primitives.remove(oldPrimitive);
  }
  this.removeMaterialSubscription();
};
function StaticGeometryPerMaterialBatch(primitives, appearanceType, depthFailAppearanceType, closed, shadows) {
  this._items = [];
  this._primitives = primitives;
  this._appearanceType = appearanceType;
  this._depthFailAppearanceType = depthFailAppearanceType;
  this._closed = closed;
  this._shadows = shadows;
}
StaticGeometryPerMaterialBatch.prototype.add = function(time, updater) {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const item = items[i2];
    if (item.isMaterial(updater)) {
      item.add(time, updater);
      return;
    }
  }
  const batch = new Batch2(
    this._primitives,
    this._appearanceType,
    updater.fillMaterialProperty,
    this._depthFailAppearanceType,
    updater.depthFailMaterialProperty,
    this._closed,
    this._shadows
  );
  batch.add(time, updater);
  items.push(batch);
};
StaticGeometryPerMaterialBatch.prototype.remove = function(updater) {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = length3 - 1; i2 >= 0; i2--) {
    const item = items[i2];
    if (item.remove(updater)) {
      if (item.updaters.length === 0) {
        items.splice(i2, 1);
        item.destroy();
      }
      break;
    }
  }
};
StaticGeometryPerMaterialBatch.prototype.update = function(time) {
  let i2;
  const items = this._items;
  const length3 = items.length;
  for (i2 = length3 - 1; i2 >= 0; i2--) {
    const item = items[i2];
    if (item.invalidated) {
      items.splice(i2, 1);
      const updaters = item.updaters.values;
      const updatersLength = updaters.length;
      for (let h = 0; h < updatersLength; h++) {
        this.add(time, updaters[h]);
      }
      item.destroy();
    }
  }
  let isUpdated = true;
  for (i2 = 0; i2 < items.length; i2++) {
    isUpdated = items[i2].update(time) && isUpdated;
  }
  return isUpdated;
};
StaticGeometryPerMaterialBatch.prototype.getBoundingSphere = function(updater, result) {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const item = items[i2];
    if (item.contains(updater)) {
      return item.getBoundingSphere(updater, result);
    }
  }
  return BoundingSphereState_default.FAILED;
};
StaticGeometryPerMaterialBatch.prototype.removeAllPrimitives = function() {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    items[i2].destroy();
  }
  this._items.length = 0;
};
var StaticGeometryPerMaterialBatch_default = StaticGeometryPerMaterialBatch;

// node_modules/cesium/Source/DataSources/StaticGroundGeometryColorBatch.js
var colorScratch5 = new Color_default();
var distanceDisplayConditionScratch4 = new DistanceDisplayCondition_default();
var defaultDistanceDisplayCondition4 = new DistanceDisplayCondition_default();
function Batch3(primitives, classificationType, color, zIndex) {
  this.primitives = primitives;
  this.zIndex = zIndex;
  this.classificationType = classificationType;
  this.color = color;
  this.createPrimitive = false;
  this.waitingOnCreate = false;
  this.primitive = void 0;
  this.oldPrimitive = void 0;
  this.geometry = new AssociativeArray_default();
  this.updaters = new AssociativeArray_default();
  this.updatersWithAttributes = new AssociativeArray_default();
  this.attributes = new AssociativeArray_default();
  this.subscriptions = new AssociativeArray_default();
  this.showsUpdated = new AssociativeArray_default();
  this.itemsToRemove = [];
  this.isDirty = false;
  this.rectangleCollisionCheck = new RectangleCollisionChecker_default();
}
Batch3.prototype.overlapping = function(rectangle) {
  return this.rectangleCollisionCheck.collides(rectangle);
};
Batch3.prototype.add = function(updater, instance) {
  const id = updater.id;
  this.createPrimitive = true;
  this.geometry.set(id, instance);
  this.updaters.set(id, updater);
  this.rectangleCollisionCheck.insert(id, instance.geometry.rectangle);
  if (!updater.hasConstantFill || !updater.fillMaterialProperty.isConstant || !Property_default.isConstant(updater.distanceDisplayConditionProperty)) {
    this.updatersWithAttributes.set(id, updater);
  } else {
    const that = this;
    this.subscriptions.set(
      id,
      updater.entity.definitionChanged.addEventListener(function(entity, propertyName, newValue, oldValue2) {
        if (propertyName === "isShowing") {
          that.showsUpdated.set(updater.id, updater);
        }
      })
    );
  }
};
Batch3.prototype.remove = function(updater) {
  const id = updater.id;
  const geometryInstance = this.geometry.get(id);
  this.createPrimitive = this.geometry.remove(id) || this.createPrimitive;
  if (this.updaters.remove(id)) {
    this.rectangleCollisionCheck.remove(
      id,
      geometryInstance.geometry.rectangle
    );
    this.updatersWithAttributes.remove(id);
    const unsubscribe2 = this.subscriptions.get(id);
    if (defined_default(unsubscribe2)) {
      unsubscribe2();
      this.subscriptions.remove(id);
      this.showsUpdated.remove(id);
    }
    return true;
  }
  return false;
};
Batch3.prototype.update = function(time) {
  let isUpdated = true;
  const removedCount = 0;
  let primitive = this.primitive;
  const primitives = this.primitives;
  let i2;
  if (this.createPrimitive) {
    const geometries = this.geometry.values;
    const geometriesLength = geometries.length;
    if (geometriesLength > 0) {
      if (defined_default(primitive)) {
        if (!defined_default(this.oldPrimitive)) {
          this.oldPrimitive = primitive;
        } else {
          primitives.remove(primitive);
        }
      }
      primitive = new GroundPrimitive_default({
        show: false,
        asynchronous: true,
        geometryInstances: geometries.slice(),
        classificationType: this.classificationType
      });
      primitives.add(primitive, this.zIndex);
      isUpdated = false;
    } else {
      if (defined_default(primitive)) {
        primitives.remove(primitive);
        primitive = void 0;
      }
      const oldPrimitive = this.oldPrimitive;
      if (defined_default(oldPrimitive)) {
        primitives.remove(oldPrimitive);
        this.oldPrimitive = void 0;
      }
    }
    this.attributes.removeAll();
    this.primitive = primitive;
    this.createPrimitive = false;
    this.waitingOnCreate = true;
  } else if (defined_default(primitive) && primitive.ready) {
    primitive.show = true;
    if (defined_default(this.oldPrimitive)) {
      primitives.remove(this.oldPrimitive);
      this.oldPrimitive = void 0;
    }
    const updatersWithAttributes = this.updatersWithAttributes.values;
    const length3 = updatersWithAttributes.length;
    const waitingOnCreate = this.waitingOnCreate;
    for (i2 = 0; i2 < length3; i2++) {
      const updater = updatersWithAttributes[i2];
      const instance = this.geometry.get(updater.id);
      let attributes = this.attributes.get(instance.id.id);
      if (!defined_default(attributes)) {
        attributes = primitive.getGeometryInstanceAttributes(instance.id);
        this.attributes.set(instance.id.id, attributes);
      }
      if (!updater.fillMaterialProperty.isConstant || waitingOnCreate) {
        const colorProperty = updater.fillMaterialProperty.color;
        const fillColor = Property_default.getValueOrDefault(
          colorProperty,
          time,
          Color_default.WHITE,
          colorScratch5
        );
        if (!Color_default.equals(attributes._lastColor, fillColor)) {
          attributes._lastColor = Color_default.clone(fillColor, attributes._lastColor);
          attributes.color = ColorGeometryInstanceAttribute_default.toValue(
            fillColor,
            attributes.color
          );
        }
      }
      const show = updater.entity.isShowing && (updater.hasConstantFill || updater.isFilled(time));
      const currentShow = attributes.show[0] === 1;
      if (show !== currentShow) {
        attributes.show = ShowGeometryInstanceAttribute_default.toValue(
          show,
          attributes.show
        );
      }
      const distanceDisplayConditionProperty = updater.distanceDisplayConditionProperty;
      if (!Property_default.isConstant(distanceDisplayConditionProperty)) {
        const distanceDisplayCondition = Property_default.getValueOrDefault(
          distanceDisplayConditionProperty,
          time,
          defaultDistanceDisplayCondition4,
          distanceDisplayConditionScratch4
        );
        if (!DistanceDisplayCondition_default.equals(
          distanceDisplayCondition,
          attributes._lastDistanceDisplayCondition
        )) {
          attributes._lastDistanceDisplayCondition = DistanceDisplayCondition_default.clone(
            distanceDisplayCondition,
            attributes._lastDistanceDisplayCondition
          );
          attributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute_default.toValue(
            distanceDisplayCondition,
            attributes.distanceDisplayCondition
          );
        }
      }
    }
    this.updateShows(primitive);
    this.waitingOnCreate = false;
  } else if (defined_default(primitive) && !primitive.ready) {
    isUpdated = false;
  }
  this.itemsToRemove.length = removedCount;
  return isUpdated;
};
Batch3.prototype.updateShows = function(primitive) {
  const showsUpdated = this.showsUpdated.values;
  const length3 = showsUpdated.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const updater = showsUpdated[i2];
    const instance = this.geometry.get(updater.id);
    let attributes = this.attributes.get(instance.id.id);
    if (!defined_default(attributes)) {
      attributes = primitive.getGeometryInstanceAttributes(instance.id);
      this.attributes.set(instance.id.id, attributes);
    }
    const show = updater.entity.isShowing;
    const currentShow = attributes.show[0] === 1;
    if (show !== currentShow) {
      attributes.show = ShowGeometryInstanceAttribute_default.toValue(
        show,
        attributes.show
      );
      instance.attributes.show.value[0] = attributes.show[0];
    }
  }
  this.showsUpdated.removeAll();
};
Batch3.prototype.contains = function(updater) {
  return this.updaters.contains(updater.id);
};
Batch3.prototype.getBoundingSphere = function(updater, result) {
  const primitive = this.primitive;
  if (!primitive.ready) {
    return BoundingSphereState_default.PENDING;
  }
  const bs = primitive.getBoundingSphere(updater.entity);
  if (!defined_default(bs)) {
    return BoundingSphereState_default.FAILED;
  }
  bs.clone(result);
  return BoundingSphereState_default.DONE;
};
Batch3.prototype.removeAllPrimitives = function() {
  const primitives = this.primitives;
  const primitive = this.primitive;
  if (defined_default(primitive)) {
    primitives.remove(primitive);
    this.primitive = void 0;
    this.geometry.removeAll();
    this.updaters.removeAll();
  }
  const oldPrimitive = this.oldPrimitive;
  if (defined_default(oldPrimitive)) {
    primitives.remove(oldPrimitive);
    this.oldPrimitive = void 0;
  }
};
function StaticGroundGeometryColorBatch(primitives, classificationType) {
  this._batches = [];
  this._primitives = primitives;
  this._classificationType = classificationType;
}
StaticGroundGeometryColorBatch.prototype.add = function(time, updater) {
  const instance = updater.createFillGeometryInstance(time);
  const batches = this._batches;
  const zIndex = Property_default.getValueOrDefault(updater.zIndex, 0);
  let batch;
  const length3 = batches.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const item = batches[i2];
    if (item.zIndex === zIndex && !item.overlapping(instance.geometry.rectangle)) {
      batch = item;
      break;
    }
  }
  if (!defined_default(batch)) {
    batch = new Batch3(
      this._primitives,
      this._classificationType,
      instance.attributes.color.value,
      zIndex
    );
    batches.push(batch);
  }
  batch.add(updater, instance);
  return batch;
};
StaticGroundGeometryColorBatch.prototype.remove = function(updater) {
  const batches = this._batches;
  const count = batches.length;
  for (let i2 = 0; i2 < count; ++i2) {
    if (batches[i2].remove(updater)) {
      return;
    }
  }
};
StaticGroundGeometryColorBatch.prototype.update = function(time) {
  let i2;
  let updater;
  let isUpdated = true;
  const batches = this._batches;
  const batchCount = batches.length;
  for (i2 = 0; i2 < batchCount; ++i2) {
    isUpdated = batches[i2].update(time) && isUpdated;
  }
  for (i2 = 0; i2 < batchCount; ++i2) {
    const oldBatch = batches[i2];
    const itemsToRemove = oldBatch.itemsToRemove;
    const itemsToMoveLength = itemsToRemove.length;
    for (let j = 0; j < itemsToMoveLength; j++) {
      updater = itemsToRemove[j];
      oldBatch.remove(updater);
      const newBatch = this.add(time, updater);
      oldBatch.isDirty = true;
      newBatch.isDirty = true;
    }
  }
  for (i2 = batchCount - 1; i2 >= 0; --i2) {
    const batch = batches[i2];
    if (batch.isDirty) {
      isUpdated = batches[i2].update(time) && isUpdated;
      batch.isDirty = false;
    }
    if (batch.geometry.length === 0) {
      batches.splice(i2, 1);
    }
  }
  return isUpdated;
};
StaticGroundGeometryColorBatch.prototype.getBoundingSphere = function(updater, result) {
  const batches = this._batches;
  const batchCount = batches.length;
  for (let i2 = 0; i2 < batchCount; ++i2) {
    const batch = batches[i2];
    if (batch.contains(updater)) {
      return batch.getBoundingSphere(updater, result);
    }
  }
  return BoundingSphereState_default.FAILED;
};
StaticGroundGeometryColorBatch.prototype.removeAllPrimitives = function() {
  const batches = this._batches;
  const batchCount = batches.length;
  for (let i2 = 0; i2 < batchCount; ++i2) {
    batches[i2].removeAllPrimitives();
  }
};
var StaticGroundGeometryColorBatch_default = StaticGroundGeometryColorBatch;

// node_modules/cesium/Source/DataSources/StaticGroundGeometryPerMaterialBatch.js
var distanceDisplayConditionScratch5 = new DistanceDisplayCondition_default();
var defaultDistanceDisplayCondition5 = new DistanceDisplayCondition_default();
function Batch4(primitives, classificationType, appearanceType, materialProperty, usingSphericalTextureCoordinates, zIndex) {
  this.primitives = primitives;
  this.classificationType = classificationType;
  this.appearanceType = appearanceType;
  this.materialProperty = materialProperty;
  this.updaters = new AssociativeArray_default();
  this.createPrimitive = true;
  this.primitive = void 0;
  this.oldPrimitive = void 0;
  this.geometry = new AssociativeArray_default();
  this.material = void 0;
  this.updatersWithAttributes = new AssociativeArray_default();
  this.attributes = new AssociativeArray_default();
  this.invalidated = false;
  this.removeMaterialSubscription = materialProperty.definitionChanged.addEventListener(
    Batch4.prototype.onMaterialChanged,
    this
  );
  this.subscriptions = new AssociativeArray_default();
  this.showsUpdated = new AssociativeArray_default();
  this.usingSphericalTextureCoordinates = usingSphericalTextureCoordinates;
  this.zIndex = zIndex;
  this.rectangleCollisionCheck = new RectangleCollisionChecker_default();
}
Batch4.prototype.onMaterialChanged = function() {
  this.invalidated = true;
};
Batch4.prototype.overlapping = function(rectangle) {
  return this.rectangleCollisionCheck.collides(rectangle);
};
Batch4.prototype.isMaterial = function(updater) {
  const material = this.materialProperty;
  const updaterMaterial = updater.fillMaterialProperty;
  if (updaterMaterial === material || updaterMaterial instanceof ColorMaterialProperty_default && material instanceof ColorMaterialProperty_default) {
    return true;
  }
  return defined_default(material) && material.equals(updaterMaterial);
};
Batch4.prototype.add = function(time, updater, geometryInstance) {
  const id = updater.id;
  this.updaters.set(id, updater);
  this.geometry.set(id, geometryInstance);
  this.rectangleCollisionCheck.insert(id, geometryInstance.geometry.rectangle);
  if (!updater.hasConstantFill || !updater.fillMaterialProperty.isConstant || !Property_default.isConstant(updater.distanceDisplayConditionProperty)) {
    this.updatersWithAttributes.set(id, updater);
  } else {
    const that = this;
    this.subscriptions.set(
      id,
      updater.entity.definitionChanged.addEventListener(function(entity, propertyName, newValue, oldValue2) {
        if (propertyName === "isShowing") {
          that.showsUpdated.set(updater.id, updater);
        }
      })
    );
  }
  this.createPrimitive = true;
};
Batch4.prototype.remove = function(updater) {
  const id = updater.id;
  const geometryInstance = this.geometry.get(id);
  this.createPrimitive = this.geometry.remove(id) || this.createPrimitive;
  if (this.updaters.remove(id)) {
    this.rectangleCollisionCheck.remove(
      id,
      geometryInstance.geometry.rectangle
    );
    this.updatersWithAttributes.remove(id);
    const unsubscribe2 = this.subscriptions.get(id);
    if (defined_default(unsubscribe2)) {
      unsubscribe2();
      this.subscriptions.remove(id);
    }
    return true;
  }
  return false;
};
Batch4.prototype.update = function(time) {
  let isUpdated = true;
  let primitive = this.primitive;
  const primitives = this.primitives;
  const geometries = this.geometry.values;
  let i2;
  if (this.createPrimitive) {
    const geometriesLength = geometries.length;
    if (geometriesLength > 0) {
      if (defined_default(primitive)) {
        if (!defined_default(this.oldPrimitive)) {
          this.oldPrimitive = primitive;
        } else {
          primitives.remove(primitive);
        }
      }
      this.material = MaterialProperty_default.getValue(
        time,
        this.materialProperty,
        this.material
      );
      primitive = new GroundPrimitive_default({
        show: false,
        asynchronous: true,
        geometryInstances: geometries.slice(),
        appearance: new this.appearanceType({
          material: this.material
        }),
        classificationType: this.classificationType
      });
      primitives.add(primitive, this.zIndex);
      isUpdated = false;
    } else {
      if (defined_default(primitive)) {
        primitives.remove(primitive);
        primitive = void 0;
      }
      const oldPrimitive = this.oldPrimitive;
      if (defined_default(oldPrimitive)) {
        primitives.remove(oldPrimitive);
        this.oldPrimitive = void 0;
      }
    }
    this.attributes.removeAll();
    this.primitive = primitive;
    this.createPrimitive = false;
  } else if (defined_default(primitive) && primitive.ready) {
    primitive.show = true;
    if (defined_default(this.oldPrimitive)) {
      primitives.remove(this.oldPrimitive);
      this.oldPrimitive = void 0;
    }
    this.material = MaterialProperty_default.getValue(
      time,
      this.materialProperty,
      this.material
    );
    this.primitive.appearance.material = this.material;
    const updatersWithAttributes = this.updatersWithAttributes.values;
    const length3 = updatersWithAttributes.length;
    for (i2 = 0; i2 < length3; i2++) {
      const updater = updatersWithAttributes[i2];
      const entity = updater.entity;
      const instance = this.geometry.get(updater.id);
      let attributes = this.attributes.get(instance.id.id);
      if (!defined_default(attributes)) {
        attributes = primitive.getGeometryInstanceAttributes(instance.id);
        this.attributes.set(instance.id.id, attributes);
      }
      const show = entity.isShowing && (updater.hasConstantFill || updater.isFilled(time));
      const currentShow = attributes.show[0] === 1;
      if (show !== currentShow) {
        attributes.show = ShowGeometryInstanceAttribute_default.toValue(
          show,
          attributes.show
        );
      }
      const distanceDisplayConditionProperty = updater.distanceDisplayConditionProperty;
      if (!Property_default.isConstant(distanceDisplayConditionProperty)) {
        const distanceDisplayCondition = Property_default.getValueOrDefault(
          distanceDisplayConditionProperty,
          time,
          defaultDistanceDisplayCondition5,
          distanceDisplayConditionScratch5
        );
        if (!DistanceDisplayCondition_default.equals(
          distanceDisplayCondition,
          attributes._lastDistanceDisplayCondition
        )) {
          attributes._lastDistanceDisplayCondition = DistanceDisplayCondition_default.clone(
            distanceDisplayCondition,
            attributes._lastDistanceDisplayCondition
          );
          attributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute_default.toValue(
            distanceDisplayCondition,
            attributes.distanceDisplayCondition
          );
        }
      }
    }
    this.updateShows(primitive);
  } else if (defined_default(primitive) && !primitive.ready) {
    isUpdated = false;
  }
  return isUpdated;
};
Batch4.prototype.updateShows = function(primitive) {
  const showsUpdated = this.showsUpdated.values;
  const length3 = showsUpdated.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const updater = showsUpdated[i2];
    const entity = updater.entity;
    const instance = this.geometry.get(updater.id);
    let attributes = this.attributes.get(instance.id.id);
    if (!defined_default(attributes)) {
      attributes = primitive.getGeometryInstanceAttributes(instance.id);
      this.attributes.set(instance.id.id, attributes);
    }
    const show = entity.isShowing;
    const currentShow = attributes.show[0] === 1;
    if (show !== currentShow) {
      attributes.show = ShowGeometryInstanceAttribute_default.toValue(
        show,
        attributes.show
      );
      instance.attributes.show.value[0] = attributes.show[0];
    }
  }
  this.showsUpdated.removeAll();
};
Batch4.prototype.contains = function(updater) {
  return this.updaters.contains(updater.id);
};
Batch4.prototype.getBoundingSphere = function(updater, result) {
  const primitive = this.primitive;
  if (!primitive.ready) {
    return BoundingSphereState_default.PENDING;
  }
  const attributes = primitive.getGeometryInstanceAttributes(updater.entity);
  if (!defined_default(attributes) || !defined_default(attributes.boundingSphere) || defined_default(attributes.show) && attributes.show[0] === 0) {
    return BoundingSphereState_default.FAILED;
  }
  attributes.boundingSphere.clone(result);
  return BoundingSphereState_default.DONE;
};
Batch4.prototype.destroy = function() {
  const primitive = this.primitive;
  const primitives = this.primitives;
  if (defined_default(primitive)) {
    primitives.remove(primitive);
  }
  const oldPrimitive = this.oldPrimitive;
  if (defined_default(oldPrimitive)) {
    primitives.remove(oldPrimitive);
  }
  this.removeMaterialSubscription();
};
function StaticGroundGeometryPerMaterialBatch(primitives, classificationType, appearanceType) {
  this._items = [];
  this._primitives = primitives;
  this._classificationType = classificationType;
  this._appearanceType = appearanceType;
}
StaticGroundGeometryPerMaterialBatch.prototype.add = function(time, updater) {
  const items = this._items;
  const length3 = items.length;
  const geometryInstance = updater.createFillGeometryInstance(time);
  const usingSphericalTextureCoordinates = ShadowVolumeAppearance_default.shouldUseSphericalCoordinates(
    geometryInstance.geometry.rectangle
  );
  const zIndex = Property_default.getValueOrDefault(updater.zIndex, 0);
  for (let i2 = 0; i2 < length3; ++i2) {
    const item = items[i2];
    if (item.isMaterial(updater) && item.usingSphericalTextureCoordinates === usingSphericalTextureCoordinates && item.zIndex === zIndex && !item.overlapping(geometryInstance.geometry.rectangle)) {
      item.add(time, updater, geometryInstance);
      return;
    }
  }
  const batch = new Batch4(
    this._primitives,
    this._classificationType,
    this._appearanceType,
    updater.fillMaterialProperty,
    usingSphericalTextureCoordinates,
    zIndex
  );
  batch.add(time, updater, geometryInstance);
  items.push(batch);
};
StaticGroundGeometryPerMaterialBatch.prototype.remove = function(updater) {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = length3 - 1; i2 >= 0; i2--) {
    const item = items[i2];
    if (item.remove(updater)) {
      if (item.updaters.length === 0) {
        items.splice(i2, 1);
        item.destroy();
      }
      break;
    }
  }
};
StaticGroundGeometryPerMaterialBatch.prototype.update = function(time) {
  let i2;
  const items = this._items;
  const length3 = items.length;
  for (i2 = length3 - 1; i2 >= 0; i2--) {
    const item = items[i2];
    if (item.invalidated) {
      items.splice(i2, 1);
      const updaters = item.updaters.values;
      const updatersLength = updaters.length;
      for (let h = 0; h < updatersLength; h++) {
        this.add(time, updaters[h]);
      }
      item.destroy();
    }
  }
  let isUpdated = true;
  for (i2 = 0; i2 < items.length; i2++) {
    isUpdated = items[i2].update(time) && isUpdated;
  }
  return isUpdated;
};
StaticGroundGeometryPerMaterialBatch.prototype.getBoundingSphere = function(updater, result) {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const item = items[i2];
    if (item.contains(updater)) {
      return item.getBoundingSphere(updater, result);
    }
  }
  return BoundingSphereState_default.FAILED;
};
StaticGroundGeometryPerMaterialBatch.prototype.removeAllPrimitives = function() {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    items[i2].destroy();
  }
  this._items.length = 0;
};
var StaticGroundGeometryPerMaterialBatch_default = StaticGroundGeometryPerMaterialBatch;

// node_modules/cesium/Source/DataSources/StaticOutlineGeometryBatch.js
var colorScratch6 = new Color_default();
var distanceDisplayConditionScratch6 = new DistanceDisplayCondition_default();
var defaultDistanceDisplayCondition6 = new DistanceDisplayCondition_default();
var defaultOffset11 = Cartesian3_default.ZERO;
var offsetScratch13 = new Cartesian3_default();
function Batch5(primitives, translucent, width, shadows) {
  this.translucent = translucent;
  this.width = width;
  this.shadows = shadows;
  this.primitives = primitives;
  this.createPrimitive = false;
  this.waitingOnCreate = false;
  this.primitive = void 0;
  this.oldPrimitive = void 0;
  this.geometry = new AssociativeArray_default();
  this.updaters = new AssociativeArray_default();
  this.updatersWithAttributes = new AssociativeArray_default();
  this.attributes = new AssociativeArray_default();
  this.itemsToRemove = [];
  this.subscriptions = new AssociativeArray_default();
  this.showsUpdated = new AssociativeArray_default();
}
Batch5.prototype.add = function(updater, instance) {
  const id = updater.id;
  this.createPrimitive = true;
  this.geometry.set(id, instance);
  this.updaters.set(id, updater);
  if (!updater.hasConstantOutline || !updater.outlineColorProperty.isConstant || !Property_default.isConstant(updater.distanceDisplayConditionProperty) || !Property_default.isConstant(updater.terrainOffsetProperty)) {
    this.updatersWithAttributes.set(id, updater);
  } else {
    const that = this;
    this.subscriptions.set(
      id,
      updater.entity.definitionChanged.addEventListener(function(entity, propertyName, newValue, oldValue2) {
        if (propertyName === "isShowing") {
          that.showsUpdated.set(updater.id, updater);
        }
      })
    );
  }
};
Batch5.prototype.remove = function(updater) {
  const id = updater.id;
  this.createPrimitive = this.geometry.remove(id) || this.createPrimitive;
  if (this.updaters.remove(id)) {
    this.updatersWithAttributes.remove(id);
    const unsubscribe2 = this.subscriptions.get(id);
    if (defined_default(unsubscribe2)) {
      unsubscribe2();
      this.subscriptions.remove(id);
      this.showsUpdated.remove(id);
    }
    return true;
  }
  return false;
};
Batch5.prototype.update = function(time) {
  let isUpdated = true;
  let removedCount = 0;
  let primitive = this.primitive;
  const primitives = this.primitives;
  let i2;
  if (this.createPrimitive) {
    const geometries = this.geometry.values;
    const geometriesLength = geometries.length;
    if (geometriesLength > 0) {
      if (defined_default(primitive)) {
        if (!defined_default(this.oldPrimitive)) {
          this.oldPrimitive = primitive;
        } else {
          primitives.remove(primitive);
        }
      }
      primitive = new Primitive_default({
        show: false,
        asynchronous: true,
        geometryInstances: geometries.slice(),
        appearance: new PerInstanceColorAppearance_default({
          flat: true,
          translucent: this.translucent,
          renderState: {
            lineWidth: this.width
          }
        }),
        shadows: this.shadows
      });
      primitives.add(primitive);
      isUpdated = false;
    } else {
      if (defined_default(primitive)) {
        primitives.remove(primitive);
        primitive = void 0;
      }
      const oldPrimitive = this.oldPrimitive;
      if (defined_default(oldPrimitive)) {
        primitives.remove(oldPrimitive);
        this.oldPrimitive = void 0;
      }
    }
    this.attributes.removeAll();
    this.primitive = primitive;
    this.createPrimitive = false;
    this.waitingOnCreate = true;
  } else if (defined_default(primitive) && primitive.ready) {
    primitive.show = true;
    if (defined_default(this.oldPrimitive)) {
      primitives.remove(this.oldPrimitive);
      this.oldPrimitive = void 0;
    }
    const updatersWithAttributes = this.updatersWithAttributes.values;
    const length3 = updatersWithAttributes.length;
    const waitingOnCreate = this.waitingOnCreate;
    for (i2 = 0; i2 < length3; i2++) {
      const updater = updatersWithAttributes[i2];
      const instance = this.geometry.get(updater.id);
      let attributes = this.attributes.get(instance.id.id);
      if (!defined_default(attributes)) {
        attributes = primitive.getGeometryInstanceAttributes(instance.id);
        this.attributes.set(instance.id.id, attributes);
      }
      if (!updater.outlineColorProperty.isConstant || waitingOnCreate) {
        const outlineColorProperty = updater.outlineColorProperty;
        const outlineColor = Property_default.getValueOrDefault(
          outlineColorProperty,
          time,
          Color_default.WHITE,
          colorScratch6
        );
        if (!Color_default.equals(attributes._lastColor, outlineColor)) {
          attributes._lastColor = Color_default.clone(
            outlineColor,
            attributes._lastColor
          );
          attributes.color = ColorGeometryInstanceAttribute_default.toValue(
            outlineColor,
            attributes.color
          );
          if (this.translucent && attributes.color[3] === 255 || !this.translucent && attributes.color[3] !== 255) {
            this.itemsToRemove[removedCount++] = updater;
          }
        }
      }
      const show = updater.entity.isShowing && (updater.hasConstantOutline || updater.isOutlineVisible(time));
      const currentShow = attributes.show[0] === 1;
      if (show !== currentShow) {
        attributes.show = ShowGeometryInstanceAttribute_default.toValue(
          show,
          attributes.show
        );
      }
      const distanceDisplayConditionProperty = updater.distanceDisplayConditionProperty;
      if (!Property_default.isConstant(distanceDisplayConditionProperty)) {
        const distanceDisplayCondition = Property_default.getValueOrDefault(
          distanceDisplayConditionProperty,
          time,
          defaultDistanceDisplayCondition6,
          distanceDisplayConditionScratch6
        );
        if (!DistanceDisplayCondition_default.equals(
          distanceDisplayCondition,
          attributes._lastDistanceDisplayCondition
        )) {
          attributes._lastDistanceDisplayCondition = DistanceDisplayCondition_default.clone(
            distanceDisplayCondition,
            attributes._lastDistanceDisplayCondition
          );
          attributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute_default.toValue(
            distanceDisplayCondition,
            attributes.distanceDisplayCondition
          );
        }
      }
      const offsetProperty = updater.terrainOffsetProperty;
      if (!Property_default.isConstant(offsetProperty)) {
        const offset2 = Property_default.getValueOrDefault(
          offsetProperty,
          time,
          defaultOffset11,
          offsetScratch13
        );
        if (!Cartesian3_default.equals(offset2, attributes._lastOffset)) {
          attributes._lastOffset = Cartesian3_default.clone(
            offset2,
            attributes._lastOffset
          );
          attributes.offset = OffsetGeometryInstanceAttribute_default.toValue(
            offset2,
            attributes.offset
          );
        }
      }
    }
    this.updateShows(primitive);
    this.waitingOnCreate = false;
  } else if (defined_default(primitive) && !primitive.ready) {
    isUpdated = false;
  }
  this.itemsToRemove.length = removedCount;
  return isUpdated;
};
Batch5.prototype.updateShows = function(primitive) {
  const showsUpdated = this.showsUpdated.values;
  const length3 = showsUpdated.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const updater = showsUpdated[i2];
    const instance = this.geometry.get(updater.id);
    let attributes = this.attributes.get(instance.id.id);
    if (!defined_default(attributes)) {
      attributes = primitive.getGeometryInstanceAttributes(instance.id);
      this.attributes.set(instance.id.id, attributes);
    }
    const show = updater.entity.isShowing;
    const currentShow = attributes.show[0] === 1;
    if (show !== currentShow) {
      attributes.show = ShowGeometryInstanceAttribute_default.toValue(
        show,
        attributes.show
      );
      instance.attributes.show.value[0] = attributes.show[0];
    }
  }
  this.showsUpdated.removeAll();
};
Batch5.prototype.contains = function(updater) {
  return this.updaters.contains(updater.id);
};
Batch5.prototype.getBoundingSphere = function(updater, result) {
  const primitive = this.primitive;
  if (!primitive.ready) {
    return BoundingSphereState_default.PENDING;
  }
  const attributes = primitive.getGeometryInstanceAttributes(updater.entity);
  if (!defined_default(attributes) || !defined_default(attributes.boundingSphere) || defined_default(attributes.show) && attributes.show[0] === 0) {
    return BoundingSphereState_default.FAILED;
  }
  attributes.boundingSphere.clone(result);
  return BoundingSphereState_default.DONE;
};
Batch5.prototype.removeAllPrimitives = function() {
  const primitives = this.primitives;
  const primitive = this.primitive;
  if (defined_default(primitive)) {
    primitives.remove(primitive);
    this.primitive = void 0;
    this.geometry.removeAll();
    this.updaters.removeAll();
  }
  const oldPrimitive = this.oldPrimitive;
  if (defined_default(oldPrimitive)) {
    primitives.remove(oldPrimitive);
    this.oldPrimitive = void 0;
  }
};
function StaticOutlineGeometryBatch(primitives, scene, shadows) {
  this._primitives = primitives;
  this._scene = scene;
  this._shadows = shadows;
  this._solidBatches = new AssociativeArray_default();
  this._translucentBatches = new AssociativeArray_default();
}
StaticOutlineGeometryBatch.prototype.add = function(time, updater) {
  const instance = updater.createOutlineGeometryInstance(time);
  const width = this._scene.clampLineWidth(updater.outlineWidth);
  let batches;
  let batch;
  if (instance.attributes.color.value[3] === 255) {
    batches = this._solidBatches;
    batch = batches.get(width);
    if (!defined_default(batch)) {
      batch = new Batch5(this._primitives, false, width, this._shadows);
      batches.set(width, batch);
    }
    batch.add(updater, instance);
  } else {
    batches = this._translucentBatches;
    batch = batches.get(width);
    if (!defined_default(batch)) {
      batch = new Batch5(this._primitives, true, width, this._shadows);
      batches.set(width, batch);
    }
    batch.add(updater, instance);
  }
};
StaticOutlineGeometryBatch.prototype.remove = function(updater) {
  let i2;
  const solidBatches = this._solidBatches.values;
  const solidBatchesLength = solidBatches.length;
  for (i2 = 0; i2 < solidBatchesLength; i2++) {
    if (solidBatches[i2].remove(updater)) {
      return;
    }
  }
  const translucentBatches = this._translucentBatches.values;
  const translucentBatchesLength = translucentBatches.length;
  for (i2 = 0; i2 < translucentBatchesLength; i2++) {
    if (translucentBatches[i2].remove(updater)) {
      return;
    }
  }
};
StaticOutlineGeometryBatch.prototype.update = function(time) {
  let i2;
  let x;
  let updater;
  let batch;
  const solidBatches = this._solidBatches.values;
  const solidBatchesLength = solidBatches.length;
  const translucentBatches = this._translucentBatches.values;
  const translucentBatchesLength = translucentBatches.length;
  let itemsToRemove;
  let isUpdated = true;
  let needUpdate = false;
  do {
    needUpdate = false;
    for (x = 0; x < solidBatchesLength; x++) {
      batch = solidBatches[x];
      isUpdated = batch.update(time);
      itemsToRemove = batch.itemsToRemove;
      const solidsToMoveLength = itemsToRemove.length;
      if (solidsToMoveLength > 0) {
        needUpdate = true;
        for (i2 = 0; i2 < solidsToMoveLength; i2++) {
          updater = itemsToRemove[i2];
          batch.remove(updater);
          this.add(time, updater);
        }
      }
    }
    for (x = 0; x < translucentBatchesLength; x++) {
      batch = translucentBatches[x];
      isUpdated = batch.update(time);
      itemsToRemove = batch.itemsToRemove;
      const translucentToMoveLength = itemsToRemove.length;
      if (translucentToMoveLength > 0) {
        needUpdate = true;
        for (i2 = 0; i2 < translucentToMoveLength; i2++) {
          updater = itemsToRemove[i2];
          batch.remove(updater);
          this.add(time, updater);
        }
      }
    }
  } while (needUpdate);
  return isUpdated;
};
StaticOutlineGeometryBatch.prototype.getBoundingSphere = function(updater, result) {
  let i2;
  const solidBatches = this._solidBatches.values;
  const solidBatchesLength = solidBatches.length;
  for (i2 = 0; i2 < solidBatchesLength; i2++) {
    const solidBatch = solidBatches[i2];
    if (solidBatch.contains(updater)) {
      return solidBatch.getBoundingSphere(updater, result);
    }
  }
  const translucentBatches = this._translucentBatches.values;
  const translucentBatchesLength = translucentBatches.length;
  for (i2 = 0; i2 < translucentBatchesLength; i2++) {
    const translucentBatch = translucentBatches[i2];
    if (translucentBatch.contains(updater)) {
      return translucentBatch.getBoundingSphere(updater, result);
    }
  }
  return BoundingSphereState_default.FAILED;
};
StaticOutlineGeometryBatch.prototype.removeAllPrimitives = function() {
  let i2;
  const solidBatches = this._solidBatches.values;
  const solidBatchesLength = solidBatches.length;
  for (i2 = 0; i2 < solidBatchesLength; i2++) {
    solidBatches[i2].removeAllPrimitives();
  }
  const translucentBatches = this._translucentBatches.values;
  const translucentBatchesLength = translucentBatches.length;
  for (i2 = 0; i2 < translucentBatchesLength; i2++) {
    translucentBatches[i2].removeAllPrimitives();
  }
};
var StaticOutlineGeometryBatch_default = StaticOutlineGeometryBatch;

// node_modules/cesium/Source/DataSources/WallGeometryUpdater.js
var scratchColor20 = new Color_default();
function WallGeometryOptions(entity) {
  this.id = entity;
  this.vertexFormat = void 0;
  this.positions = void 0;
  this.minimumHeights = void 0;
  this.maximumHeights = void 0;
  this.granularity = void 0;
}
function WallGeometryUpdater(entity, scene) {
  GeometryUpdater_default.call(this, {
    entity,
    scene,
    geometryOptions: new WallGeometryOptions(entity),
    geometryPropertyName: "wall",
    observedPropertyNames: ["availability", "wall"]
  });
  this._onEntityPropertyChanged(entity, "wall", entity.wall, void 0);
}
if (defined_default(Object.create)) {
  WallGeometryUpdater.prototype = Object.create(GeometryUpdater_default.prototype);
  WallGeometryUpdater.prototype.constructor = WallGeometryUpdater;
}
WallGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  let attributes;
  let color;
  const show = new ShowGeometryInstanceAttribute_default(
    isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time)
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
    distanceDisplayCondition
  );
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    let currentColor;
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor20);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
    attributes = {
      show,
      distanceDisplayCondition: distanceDisplayConditionAttribute,
      color
    };
  } else {
    attributes = {
      show,
      distanceDisplayCondition: distanceDisplayConditionAttribute
    };
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new WallGeometry_default(this._options),
    attributes
  });
};
WallGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  Check_default.defined("time", time);
  if (!this._outlineEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent an outlined geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const outlineColor = Property_default.getValueOrDefault(
    this._outlineColorProperty,
    time,
    Color_default.BLACK,
    scratchColor20
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  return new GeometryInstance_default({
    id: entity,
    geometry: new WallOutlineGeometry_default(this._options),
    attributes: {
      show: new ShowGeometryInstanceAttribute_default(
        isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)
      ),
      color: ColorGeometryInstanceAttribute_default.fromColor(outlineColor),
      distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
        distanceDisplayCondition
      )
    }
  });
};
WallGeometryUpdater.prototype._isHidden = function(entity, wall) {
  return !defined_default(wall.positions) || GeometryUpdater_default.prototype._isHidden.call(this, entity, wall);
};
WallGeometryUpdater.prototype._getIsClosed = function(options) {
  return false;
};
WallGeometryUpdater.prototype._isDynamic = function(entity, wall) {
  return !wall.positions.isConstant || !Property_default.isConstant(wall.minimumHeights) || !Property_default.isConstant(wall.maximumHeights) || !Property_default.isConstant(wall.outlineWidth) || !Property_default.isConstant(wall.granularity);
};
WallGeometryUpdater.prototype._setStaticOptions = function(entity, wall) {
  const minimumHeights = wall.minimumHeights;
  const maximumHeights = wall.maximumHeights;
  const granularity = wall.granularity;
  const isColorMaterial = this._materialProperty instanceof ColorMaterialProperty_default;
  const options = this._options;
  options.vertexFormat = isColorMaterial ? PerInstanceColorAppearance_default.VERTEX_FORMAT : MaterialAppearance_default.MaterialSupport.TEXTURED.vertexFormat;
  options.positions = wall.positions.getValue(
    Iso8601_default.MINIMUM_VALUE,
    options.positions
  );
  options.minimumHeights = defined_default(minimumHeights) ? minimumHeights.getValue(Iso8601_default.MINIMUM_VALUE, options.minimumHeights) : void 0;
  options.maximumHeights = defined_default(maximumHeights) ? maximumHeights.getValue(Iso8601_default.MINIMUM_VALUE, options.maximumHeights) : void 0;
  options.granularity = defined_default(granularity) ? granularity.getValue(Iso8601_default.MINIMUM_VALUE) : void 0;
};
WallGeometryUpdater.DynamicGeometryUpdater = DynamicWallGeometryUpdater;
function DynamicWallGeometryUpdater(geometryUpdater, primitives, groundPrimitives) {
  DynamicGeometryUpdater_default.call(
    this,
    geometryUpdater,
    primitives,
    groundPrimitives
  );
}
if (defined_default(Object.create)) {
  DynamicWallGeometryUpdater.prototype = Object.create(
    DynamicGeometryUpdater_default.prototype
  );
  DynamicWallGeometryUpdater.prototype.constructor = DynamicWallGeometryUpdater;
}
DynamicWallGeometryUpdater.prototype._isHidden = function(entity, wall, time) {
  return !defined_default(this._options.positions) || DynamicGeometryUpdater_default.prototype._isHidden.call(this, entity, wall, time);
};
DynamicWallGeometryUpdater.prototype._setOptions = function(entity, wall, time) {
  const options = this._options;
  options.positions = Property_default.getValueOrUndefined(
    wall.positions,
    time,
    options.positions
  );
  options.minimumHeights = Property_default.getValueOrUndefined(
    wall.minimumHeights,
    time,
    options.minimumHeights
  );
  options.maximumHeights = Property_default.getValueOrUndefined(
    wall.maximumHeights,
    time,
    options.maximumHeights
  );
  options.granularity = Property_default.getValueOrUndefined(wall.granularity, time);
};
var WallGeometryUpdater_default = WallGeometryUpdater;

// node_modules/cesium/Source/DataSources/GeometryVisualizer.js
var emptyArray = [];
var geometryUpdaters = [
  BoxGeometryUpdater_default,
  CylinderGeometryUpdater_default,
  CorridorGeometryUpdater_default,
  EllipseGeometryUpdater_default,
  EllipsoidGeometryUpdater_default,
  PlaneGeometryUpdater_default,
  PolygonGeometryUpdater_default,
  PolylineVolumeGeometryUpdater_default,
  RectangleGeometryUpdater_default,
  WallGeometryUpdater_default
];
function GeometryUpdaterSet(entity, scene) {
  this.entity = entity;
  this.scene = scene;
  const updaters = new Array(geometryUpdaters.length);
  const geometryChanged = new Event_default();
  function raiseEvent(geometry) {
    geometryChanged.raiseEvent(geometry);
  }
  const eventHelper = new EventHelper_default();
  for (let i2 = 0; i2 < updaters.length; i2++) {
    const updater = new geometryUpdaters[i2](entity, scene);
    eventHelper.add(updater.geometryChanged, raiseEvent);
    updaters[i2] = updater;
  }
  this.updaters = updaters;
  this.geometryChanged = geometryChanged;
  this.eventHelper = eventHelper;
  this._removeEntitySubscription = entity.definitionChanged.addEventListener(
    GeometryUpdaterSet.prototype._onEntityPropertyChanged,
    this
  );
}
GeometryUpdaterSet.prototype._onEntityPropertyChanged = function(entity, propertyName, newValue, oldValue2) {
  const updaters = this.updaters;
  for (let i2 = 0; i2 < updaters.length; i2++) {
    updaters[i2]._onEntityPropertyChanged(
      entity,
      propertyName,
      newValue,
      oldValue2
    );
  }
};
GeometryUpdaterSet.prototype.forEach = function(callback) {
  const updaters = this.updaters;
  for (let i2 = 0; i2 < updaters.length; i2++) {
    callback(updaters[i2]);
  }
};
GeometryUpdaterSet.prototype.destroy = function() {
  this.eventHelper.removeAll();
  const updaters = this.updaters;
  for (let i2 = 0; i2 < updaters.length; i2++) {
    updaters[i2].destroy();
  }
  this._removeEntitySubscription();
  destroyObject_default(this);
};
function GeometryVisualizer(scene, entityCollection, primitives, groundPrimitives) {
  Check_default.defined("scene", scene);
  Check_default.defined("entityCollection", entityCollection);
  primitives = defaultValue_default(primitives, scene.primitives);
  groundPrimitives = defaultValue_default(groundPrimitives, scene.groundPrimitives);
  this._scene = scene;
  this._primitives = primitives;
  this._groundPrimitives = groundPrimitives;
  this._entityCollection = void 0;
  this._addedObjects = new AssociativeArray_default();
  this._removedObjects = new AssociativeArray_default();
  this._changedObjects = new AssociativeArray_default();
  const numberOfShadowModes = ShadowMode_default.NUMBER_OF_SHADOW_MODES;
  this._outlineBatches = new Array(numberOfShadowModes * 2);
  this._closedColorBatches = new Array(numberOfShadowModes * 2);
  this._closedMaterialBatches = new Array(numberOfShadowModes * 2);
  this._openColorBatches = new Array(numberOfShadowModes * 2);
  this._openMaterialBatches = new Array(numberOfShadowModes * 2);
  const supportsMaterialsforEntitiesOnTerrain = Entity_default.supportsMaterialsforEntitiesOnTerrain(
    scene
  );
  this._supportsMaterialsforEntitiesOnTerrain = supportsMaterialsforEntitiesOnTerrain;
  let i2;
  for (i2 = 0; i2 < numberOfShadowModes; ++i2) {
    this._outlineBatches[i2] = new StaticOutlineGeometryBatch_default(
      primitives,
      scene,
      i2,
      false
    );
    this._outlineBatches[numberOfShadowModes + i2] = new StaticOutlineGeometryBatch_default(primitives, scene, i2, true);
    this._closedColorBatches[i2] = new StaticGeometryColorBatch_default(
      primitives,
      PerInstanceColorAppearance_default,
      void 0,
      true,
      i2,
      true
    );
    this._closedColorBatches[numberOfShadowModes + i2] = new StaticGeometryColorBatch_default(
      primitives,
      PerInstanceColorAppearance_default,
      void 0,
      true,
      i2,
      false
    );
    this._closedMaterialBatches[i2] = new StaticGeometryPerMaterialBatch_default(
      primitives,
      MaterialAppearance_default,
      void 0,
      true,
      i2,
      true
    );
    this._closedMaterialBatches[numberOfShadowModes + i2] = new StaticGeometryPerMaterialBatch_default(
      primitives,
      MaterialAppearance_default,
      void 0,
      true,
      i2,
      false
    );
    this._openColorBatches[i2] = new StaticGeometryColorBatch_default(
      primitives,
      PerInstanceColorAppearance_default,
      void 0,
      false,
      i2,
      true
    );
    this._openColorBatches[numberOfShadowModes + i2] = new StaticGeometryColorBatch_default(
      primitives,
      PerInstanceColorAppearance_default,
      void 0,
      false,
      i2,
      false
    );
    this._openMaterialBatches[i2] = new StaticGeometryPerMaterialBatch_default(
      primitives,
      MaterialAppearance_default,
      void 0,
      false,
      i2,
      true
    );
    this._openMaterialBatches[numberOfShadowModes + i2] = new StaticGeometryPerMaterialBatch_default(
      primitives,
      MaterialAppearance_default,
      void 0,
      false,
      i2,
      false
    );
  }
  const numberOfClassificationTypes = ClassificationType_default.NUMBER_OF_CLASSIFICATION_TYPES;
  const groundColorBatches = new Array(numberOfClassificationTypes);
  const groundMaterialBatches = [];
  if (supportsMaterialsforEntitiesOnTerrain) {
    for (i2 = 0; i2 < numberOfClassificationTypes; ++i2) {
      groundMaterialBatches.push(
        new StaticGroundGeometryPerMaterialBatch_default(
          groundPrimitives,
          i2,
          MaterialAppearance_default
        )
      );
      groundColorBatches[i2] = new StaticGroundGeometryColorBatch_default(
        groundPrimitives,
        i2
      );
    }
  } else {
    for (i2 = 0; i2 < numberOfClassificationTypes; ++i2) {
      groundColorBatches[i2] = new StaticGroundGeometryColorBatch_default(
        groundPrimitives,
        i2
      );
    }
  }
  this._groundColorBatches = groundColorBatches;
  this._groundMaterialBatches = groundMaterialBatches;
  this._dynamicBatch = new DynamicGeometryBatch_default(primitives, groundPrimitives);
  this._batches = this._outlineBatches.concat(
    this._closedColorBatches,
    this._closedMaterialBatches,
    this._openColorBatches,
    this._openMaterialBatches,
    this._groundColorBatches,
    this._groundMaterialBatches,
    this._dynamicBatch
  );
  this._subscriptions = new AssociativeArray_default();
  this._updaterSets = new AssociativeArray_default();
  this._entityCollection = entityCollection;
  entityCollection.collectionChanged.addEventListener(
    GeometryVisualizer.prototype._onCollectionChanged,
    this
  );
  this._onCollectionChanged(
    entityCollection,
    entityCollection.values,
    emptyArray
  );
}
GeometryVisualizer.prototype.update = function(time) {
  Check_default.defined("time", time);
  const addedObjects = this._addedObjects;
  const added = addedObjects.values;
  const removedObjects = this._removedObjects;
  const removed = removedObjects.values;
  const changedObjects = this._changedObjects;
  const changed = changedObjects.values;
  let i2;
  let entity;
  let id;
  let updaterSet;
  const that = this;
  for (i2 = changed.length - 1; i2 > -1; i2--) {
    entity = changed[i2];
    id = entity.id;
    updaterSet = this._updaterSets.get(id);
    if (updaterSet.entity === entity) {
      updaterSet.forEach(function(updater) {
        that._removeUpdater(updater);
        that._insertUpdaterIntoBatch(time, updater);
      });
    } else {
      removed.push(entity);
      added.push(entity);
    }
  }
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    id = entity.id;
    updaterSet = this._updaterSets.get(id);
    updaterSet.forEach(this._removeUpdater.bind(this));
    updaterSet.destroy();
    this._updaterSets.remove(id);
    this._subscriptions.get(id)();
    this._subscriptions.remove(id);
  }
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    id = entity.id;
    updaterSet = new GeometryUpdaterSet(entity, this._scene);
    this._updaterSets.set(id, updaterSet);
    updaterSet.forEach(function(updater) {
      that._insertUpdaterIntoBatch(time, updater);
    });
    this._subscriptions.set(
      id,
      updaterSet.geometryChanged.addEventListener(
        GeometryVisualizer._onGeometryChanged,
        this
      )
    );
  }
  addedObjects.removeAll();
  removedObjects.removeAll();
  changedObjects.removeAll();
  let isUpdated = true;
  const batches = this._batches;
  const length3 = batches.length;
  for (i2 = 0; i2 < length3; i2++) {
    isUpdated = batches[i2].update(time) && isUpdated;
  }
  return isUpdated;
};
var getBoundingSphereArrayScratch = [];
var getBoundingSphereBoundingSphereScratch = new BoundingSphere_default();
GeometryVisualizer.prototype.getBoundingSphere = function(entity, result) {
  Check_default.defined("entity", entity);
  Check_default.defined("result", result);
  const boundingSpheres = getBoundingSphereArrayScratch;
  const tmp2 = getBoundingSphereBoundingSphereScratch;
  let count = 0;
  let state = BoundingSphereState_default.DONE;
  const batches = this._batches;
  const batchesLength = batches.length;
  const id = entity.id;
  const updaters = this._updaterSets.get(id).updaters;
  for (let j = 0; j < updaters.length; j++) {
    const updater = updaters[j];
    for (let i2 = 0; i2 < batchesLength; i2++) {
      state = batches[i2].getBoundingSphere(updater, tmp2);
      if (state === BoundingSphereState_default.PENDING) {
        return BoundingSphereState_default.PENDING;
      } else if (state === BoundingSphereState_default.DONE) {
        boundingSpheres[count] = BoundingSphere_default.clone(
          tmp2,
          boundingSpheres[count]
        );
        count++;
      }
    }
  }
  if (count === 0) {
    return BoundingSphereState_default.FAILED;
  }
  boundingSpheres.length = count;
  BoundingSphere_default.fromBoundingSpheres(boundingSpheres, result);
  return BoundingSphereState_default.DONE;
};
GeometryVisualizer.prototype.isDestroyed = function() {
  return false;
};
GeometryVisualizer.prototype.destroy = function() {
  this._entityCollection.collectionChanged.removeEventListener(
    GeometryVisualizer.prototype._onCollectionChanged,
    this
  );
  this._addedObjects.removeAll();
  this._removedObjects.removeAll();
  let i2;
  const batches = this._batches;
  let length3 = batches.length;
  for (i2 = 0; i2 < length3; i2++) {
    batches[i2].removeAllPrimitives();
  }
  const subscriptions = this._subscriptions.values;
  length3 = subscriptions.length;
  for (i2 = 0; i2 < length3; i2++) {
    subscriptions[i2]();
  }
  this._subscriptions.removeAll();
  const updaterSets = this._updaterSets.values;
  length3 = updaterSets.length;
  for (i2 = 0; i2 < length3; i2++) {
    updaterSets[i2].destroy();
  }
  this._updaterSets.removeAll();
  return destroyObject_default(this);
};
GeometryVisualizer.prototype._removeUpdater = function(updater) {
  const batches = this._batches;
  const length3 = batches.length;
  for (let i2 = 0; i2 < length3; i2++) {
    batches[i2].remove(updater);
  }
};
GeometryVisualizer.prototype._insertUpdaterIntoBatch = function(time, updater) {
  if (updater.isDynamic) {
    this._dynamicBatch.add(time, updater);
    return;
  }
  let shadows;
  if (updater.outlineEnabled || updater.fillEnabled) {
    shadows = updater.shadowsProperty.getValue(time);
  }
  const numberOfShadowModes = ShadowMode_default.NUMBER_OF_SHADOW_MODES;
  if (updater.outlineEnabled) {
    if (defined_default(updater.terrainOffsetProperty)) {
      this._outlineBatches[numberOfShadowModes + shadows].add(time, updater);
    } else {
      this._outlineBatches[shadows].add(time, updater);
    }
  }
  if (updater.fillEnabled) {
    if (updater.onTerrain) {
      const classificationType = updater.classificationTypeProperty.getValue(
        time
      );
      if (updater.fillMaterialProperty instanceof ColorMaterialProperty_default) {
        this._groundColorBatches[classificationType].add(time, updater);
      } else {
        this._groundMaterialBatches[classificationType].add(time, updater);
      }
    } else if (updater.isClosed) {
      if (updater.fillMaterialProperty instanceof ColorMaterialProperty_default) {
        if (defined_default(updater.terrainOffsetProperty)) {
          this._closedColorBatches[numberOfShadowModes + shadows].add(
            time,
            updater
          );
        } else {
          this._closedColorBatches[shadows].add(time, updater);
        }
      } else if (defined_default(updater.terrainOffsetProperty)) {
        this._closedMaterialBatches[numberOfShadowModes + shadows].add(
          time,
          updater
        );
      } else {
        this._closedMaterialBatches[shadows].add(time, updater);
      }
    } else if (updater.fillMaterialProperty instanceof ColorMaterialProperty_default) {
      if (defined_default(updater.terrainOffsetProperty)) {
        this._openColorBatches[numberOfShadowModes + shadows].add(
          time,
          updater
        );
      } else {
        this._openColorBatches[shadows].add(time, updater);
      }
    } else if (defined_default(updater.terrainOffsetProperty)) {
      this._openMaterialBatches[numberOfShadowModes + shadows].add(
        time,
        updater
      );
    } else {
      this._openMaterialBatches[shadows].add(time, updater);
    }
  }
};
GeometryVisualizer._onGeometryChanged = function(updater) {
  const removedObjects = this._removedObjects;
  const changedObjects = this._changedObjects;
  const entity = updater.entity;
  const id = entity.id;
  if (!defined_default(removedObjects.get(id)) && !defined_default(changedObjects.get(id))) {
    changedObjects.set(id, entity);
  }
};
GeometryVisualizer.prototype._onCollectionChanged = function(entityCollection, added, removed) {
  const addedObjects = this._addedObjects;
  const removedObjects = this._removedObjects;
  const changedObjects = this._changedObjects;
  let i2;
  let id;
  let entity;
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    id = entity.id;
    if (!addedObjects.remove(id)) {
      removedObjects.set(id, entity);
      changedObjects.remove(id);
    }
  }
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    id = entity.id;
    if (removedObjects.remove(id)) {
      changedObjects.set(id, entity);
    } else {
      addedObjects.set(id, entity);
    }
  }
};
var GeometryVisualizer_default = GeometryVisualizer;

// node_modules/cesium/Source/DataSources/LabelVisualizer.js
var defaultScale4 = 1;
var defaultFont = "30px sans-serif";
var defaultStyle = LabelStyle_default.FILL;
var defaultFillColor = Color_default.WHITE;
var defaultOutlineColor3 = Color_default.BLACK;
var defaultOutlineWidth2 = 1;
var defaultShowBackground = false;
var defaultBackgroundColor2 = new Color_default(0.165, 0.165, 0.165, 0.8);
var defaultBackgroundPadding2 = new Cartesian2_default(7, 5);
var defaultPixelOffset2 = Cartesian2_default.ZERO;
var defaultEyeOffset2 = Cartesian3_default.ZERO;
var defaultHeightReference2 = HeightReference_default.NONE;
var defaultHorizontalOrigin2 = HorizontalOrigin_default.CENTER;
var defaultVerticalOrigin2 = VerticalOrigin_default.CENTER;
var positionScratch12 = new Cartesian3_default();
var fillColorScratch = new Color_default();
var outlineColorScratch = new Color_default();
var backgroundColorScratch = new Color_default();
var backgroundPaddingScratch = new Cartesian2_default();
var eyeOffsetScratch2 = new Cartesian3_default();
var pixelOffsetScratch2 = new Cartesian2_default();
var translucencyByDistanceScratch2 = new NearFarScalar_default();
var pixelOffsetScaleByDistanceScratch2 = new NearFarScalar_default();
var scaleByDistanceScratch2 = new NearFarScalar_default();
var distanceDisplayConditionScratch7 = new DistanceDisplayCondition_default();
function EntityData2(entity) {
  this.entity = entity;
  this.label = void 0;
  this.index = void 0;
}
function LabelVisualizer(entityCluster, entityCollection) {
  if (!defined_default(entityCluster)) {
    throw new DeveloperError_default("entityCluster is required.");
  }
  if (!defined_default(entityCollection)) {
    throw new DeveloperError_default("entityCollection is required.");
  }
  entityCollection.collectionChanged.addEventListener(
    LabelVisualizer.prototype._onCollectionChanged,
    this
  );
  this._cluster = entityCluster;
  this._entityCollection = entityCollection;
  this._items = new AssociativeArray_default();
  this._onCollectionChanged(entityCollection, entityCollection.values, [], []);
}
LabelVisualizer.prototype.update = function(time) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  const items = this._items.values;
  const cluster = this._cluster;
  for (let i2 = 0, len = items.length; i2 < len; i2++) {
    const item = items[i2];
    const entity = item.entity;
    const labelGraphics = entity._label;
    let text2;
    let label = item.label;
    let show = entity.isShowing && entity.isAvailable(time) && Property_default.getValueOrDefault(labelGraphics._show, time, true);
    let position;
    if (show) {
      position = Property_default.getValueOrUndefined(
        entity._position,
        time,
        positionScratch12
      );
      text2 = Property_default.getValueOrUndefined(labelGraphics._text, time);
      show = defined_default(position) && defined_default(text2);
    }
    if (!show) {
      returnPrimitive2(item, entity, cluster);
      continue;
    }
    if (!Property_default.isConstant(entity._position)) {
      cluster._clusterDirty = true;
    }
    let updateClamping2 = false;
    const heightReference = Property_default.getValueOrDefault(
      labelGraphics._heightReference,
      time,
      defaultHeightReference2
    );
    if (!defined_default(label)) {
      label = cluster.getLabel(entity);
      label.id = entity;
      item.label = label;
      updateClamping2 = Cartesian3_default.equals(label.position, position) && label.heightReference === heightReference;
    }
    label.show = true;
    label.position = position;
    label.text = text2;
    label.scale = Property_default.getValueOrDefault(
      labelGraphics._scale,
      time,
      defaultScale4
    );
    label.font = Property_default.getValueOrDefault(
      labelGraphics._font,
      time,
      defaultFont
    );
    label.style = Property_default.getValueOrDefault(
      labelGraphics._style,
      time,
      defaultStyle
    );
    label.fillColor = Property_default.getValueOrDefault(
      labelGraphics._fillColor,
      time,
      defaultFillColor,
      fillColorScratch
    );
    label.outlineColor = Property_default.getValueOrDefault(
      labelGraphics._outlineColor,
      time,
      defaultOutlineColor3,
      outlineColorScratch
    );
    label.outlineWidth = Property_default.getValueOrDefault(
      labelGraphics._outlineWidth,
      time,
      defaultOutlineWidth2
    );
    label.showBackground = Property_default.getValueOrDefault(
      labelGraphics._showBackground,
      time,
      defaultShowBackground
    );
    label.backgroundColor = Property_default.getValueOrDefault(
      labelGraphics._backgroundColor,
      time,
      defaultBackgroundColor2,
      backgroundColorScratch
    );
    label.backgroundPadding = Property_default.getValueOrDefault(
      labelGraphics._backgroundPadding,
      time,
      defaultBackgroundPadding2,
      backgroundPaddingScratch
    );
    label.pixelOffset = Property_default.getValueOrDefault(
      labelGraphics._pixelOffset,
      time,
      defaultPixelOffset2,
      pixelOffsetScratch2
    );
    label.eyeOffset = Property_default.getValueOrDefault(
      labelGraphics._eyeOffset,
      time,
      defaultEyeOffset2,
      eyeOffsetScratch2
    );
    label.heightReference = heightReference;
    label.horizontalOrigin = Property_default.getValueOrDefault(
      labelGraphics._horizontalOrigin,
      time,
      defaultHorizontalOrigin2
    );
    label.verticalOrigin = Property_default.getValueOrDefault(
      labelGraphics._verticalOrigin,
      time,
      defaultVerticalOrigin2
    );
    label.translucencyByDistance = Property_default.getValueOrUndefined(
      labelGraphics._translucencyByDistance,
      time,
      translucencyByDistanceScratch2
    );
    label.pixelOffsetScaleByDistance = Property_default.getValueOrUndefined(
      labelGraphics._pixelOffsetScaleByDistance,
      time,
      pixelOffsetScaleByDistanceScratch2
    );
    label.scaleByDistance = Property_default.getValueOrUndefined(
      labelGraphics._scaleByDistance,
      time,
      scaleByDistanceScratch2
    );
    label.distanceDisplayCondition = Property_default.getValueOrUndefined(
      labelGraphics._distanceDisplayCondition,
      time,
      distanceDisplayConditionScratch7
    );
    label.disableDepthTestDistance = Property_default.getValueOrUndefined(
      labelGraphics._disableDepthTestDistance,
      time
    );
    if (updateClamping2) {
      label._updateClamping();
    }
  }
  return true;
};
LabelVisualizer.prototype.getBoundingSphere = function(entity, result) {
  if (!defined_default(entity)) {
    throw new DeveloperError_default("entity is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const item = this._items.get(entity.id);
  if (!defined_default(item) || !defined_default(item.label)) {
    return BoundingSphereState_default.FAILED;
  }
  const label = item.label;
  result.center = Cartesian3_default.clone(
    defaultValue_default(label._clampedPosition, label.position),
    result.center
  );
  result.radius = 0;
  return BoundingSphereState_default.DONE;
};
LabelVisualizer.prototype.isDestroyed = function() {
  return false;
};
LabelVisualizer.prototype.destroy = function() {
  this._entityCollection.collectionChanged.removeEventListener(
    LabelVisualizer.prototype._onCollectionChanged,
    this
  );
  const entities = this._entityCollection.values;
  for (let i2 = 0; i2 < entities.length; i2++) {
    this._cluster.removeLabel(entities[i2]);
  }
  return destroyObject_default(this);
};
LabelVisualizer.prototype._onCollectionChanged = function(entityCollection, added, removed, changed) {
  let i2;
  let entity;
  const items = this._items;
  const cluster = this._cluster;
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    if (defined_default(entity._label) && defined_default(entity._position)) {
      items.set(entity.id, new EntityData2(entity));
    }
  }
  for (i2 = changed.length - 1; i2 > -1; i2--) {
    entity = changed[i2];
    if (defined_default(entity._label) && defined_default(entity._position)) {
      if (!items.contains(entity.id)) {
        items.set(entity.id, new EntityData2(entity));
      }
    } else {
      returnPrimitive2(items.get(entity.id), entity, cluster);
      items.remove(entity.id);
    }
  }
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    returnPrimitive2(items.get(entity.id), entity, cluster);
    items.remove(entity.id);
  }
};
function returnPrimitive2(item, entity, cluster) {
  if (defined_default(item)) {
    item.label = void 0;
    cluster.removeLabel(entity);
  }
}
var LabelVisualizer_default = LabelVisualizer;

// node_modules/cesium/Source/DataSources/ModelVisualizer.js
var defaultScale5 = 1;
var defaultMinimumPixelSize = 0;
var defaultIncrementallyLoadTextures = true;
var defaultClampAnimations = true;
var defaultShadows2 = ShadowMode_default.ENABLED;
var defaultHeightReference3 = HeightReference_default.NONE;
var defaultSilhouetteColor = Color_default.RED;
var defaultSilhouetteSize = 0;
var defaultColor7 = Color_default.WHITE;
var defaultColorBlendMode = ColorBlendMode_default.HIGHLIGHT;
var defaultColorBlendAmount = 0.5;
var defaultImageBasedLightingFactor = new Cartesian2_default(1, 1);
var modelMatrixScratch2 = new Matrix4_default();
var nodeMatrixScratch = new Matrix4_default();
function ModelVisualizer(scene, entityCollection) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  if (!defined_default(entityCollection)) {
    throw new DeveloperError_default("entityCollection is required.");
  }
  entityCollection.collectionChanged.addEventListener(
    ModelVisualizer.prototype._onCollectionChanged,
    this
  );
  this._scene = scene;
  this._primitives = scene.primitives;
  this._entityCollection = entityCollection;
  this._modelHash = {};
  this._entitiesToVisualize = new AssociativeArray_default();
  this._onCollectionChanged(entityCollection, entityCollection.values, [], []);
}
ModelVisualizer.prototype.update = function(time) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  const entities = this._entitiesToVisualize.values;
  const modelHash = this._modelHash;
  const primitives = this._primitives;
  for (let i2 = 0, len = entities.length; i2 < len; i2++) {
    const entity = entities[i2];
    const modelGraphics = entity._model;
    let resource;
    let modelData = modelHash[entity.id];
    let show = entity.isShowing && entity.isAvailable(time) && Property_default.getValueOrDefault(modelGraphics._show, time, true);
    let modelMatrix;
    if (show) {
      modelMatrix = entity.computeModelMatrix(time, modelMatrixScratch2);
      resource = Resource_default.createIfNeeded(
        Property_default.getValueOrUndefined(modelGraphics._uri, time)
      );
      show = defined_default(modelMatrix) && defined_default(resource);
    }
    if (!show) {
      if (defined_default(modelData)) {
        modelData.modelPrimitive.show = false;
      }
      continue;
    }
    let model = defined_default(modelData) ? modelData.modelPrimitive : void 0;
    if (!defined_default(model) || resource.url !== modelData.url) {
      if (defined_default(model)) {
        primitives.removeAndDestroy(model);
        delete modelHash[entity.id];
      }
      model = Model_default.fromGltf({
        url: resource,
        incrementallyLoadTextures: Property_default.getValueOrDefault(
          modelGraphics._incrementallyLoadTextures,
          time,
          defaultIncrementallyLoadTextures
        ),
        scene: this._scene
      });
      model.id = entity;
      primitives.add(model);
      modelData = {
        modelPrimitive: model,
        url: resource.url,
        animationsRunning: false,
        nodeTransformationsScratch: {},
        articulationsScratch: {},
        loadFail: false
      };
      modelHash[entity.id] = modelData;
      checkModelLoad(model, entity, modelHash);
    }
    model.show = true;
    model.scale = Property_default.getValueOrDefault(
      modelGraphics._scale,
      time,
      defaultScale5
    );
    model.minimumPixelSize = Property_default.getValueOrDefault(
      modelGraphics._minimumPixelSize,
      time,
      defaultMinimumPixelSize
    );
    model.maximumScale = Property_default.getValueOrUndefined(
      modelGraphics._maximumScale,
      time
    );
    model.modelMatrix = Matrix4_default.clone(modelMatrix, model.modelMatrix);
    model.shadows = Property_default.getValueOrDefault(
      modelGraphics._shadows,
      time,
      defaultShadows2
    );
    model.heightReference = Property_default.getValueOrDefault(
      modelGraphics._heightReference,
      time,
      defaultHeightReference3
    );
    model.distanceDisplayCondition = Property_default.getValueOrUndefined(
      modelGraphics._distanceDisplayCondition,
      time
    );
    model.silhouetteColor = Property_default.getValueOrDefault(
      modelGraphics._silhouetteColor,
      time,
      defaultSilhouetteColor,
      model._silhouetteColor
    );
    model.silhouetteSize = Property_default.getValueOrDefault(
      modelGraphics._silhouetteSize,
      time,
      defaultSilhouetteSize
    );
    model.color = Property_default.getValueOrDefault(
      modelGraphics._color,
      time,
      defaultColor7,
      model._color
    );
    model.colorBlendMode = Property_default.getValueOrDefault(
      modelGraphics._colorBlendMode,
      time,
      defaultColorBlendMode
    );
    model.colorBlendAmount = Property_default.getValueOrDefault(
      modelGraphics._colorBlendAmount,
      time,
      defaultColorBlendAmount
    );
    model.clippingPlanes = Property_default.getValueOrUndefined(
      modelGraphics._clippingPlanes,
      time
    );
    model.clampAnimations = Property_default.getValueOrDefault(
      modelGraphics._clampAnimations,
      time,
      defaultClampAnimations
    );
    model.imageBasedLighting.imageBasedLightingFactor = Property_default.getValueOrDefault(
      modelGraphics._imageBasedLightingFactor,
      time,
      defaultImageBasedLightingFactor
    );
    model.lightColor = Property_default.getValueOrUndefined(
      modelGraphics._lightColor,
      time
    );
    if (model.ready) {
      const runAnimations = Property_default.getValueOrDefault(
        modelGraphics._runAnimations,
        time,
        true
      );
      if (modelData.animationsRunning !== runAnimations) {
        if (runAnimations) {
          model.activeAnimations.addAll({
            loop: ModelAnimationLoop_default.REPEAT
          });
        } else {
          model.activeAnimations.removeAll();
        }
        modelData.animationsRunning = runAnimations;
      }
      const nodeTransformations = Property_default.getValueOrUndefined(
        modelGraphics._nodeTransformations,
        time,
        modelData.nodeTransformationsScratch
      );
      if (defined_default(nodeTransformations)) {
        const nodeNames = Object.keys(nodeTransformations);
        for (let nodeIndex = 0, nodeLength = nodeNames.length; nodeIndex < nodeLength; ++nodeIndex) {
          const nodeName = nodeNames[nodeIndex];
          const nodeTransformation = nodeTransformations[nodeName];
          if (!defined_default(nodeTransformation)) {
            continue;
          }
          const modelNode = model.getNode(nodeName);
          if (!defined_default(modelNode)) {
            continue;
          }
          const transformationMatrix = Matrix4_default.fromTranslationRotationScale(
            nodeTransformation,
            nodeMatrixScratch
          );
          modelNode.matrix = Matrix4_default.multiply(
            modelNode.originalMatrix,
            transformationMatrix,
            transformationMatrix
          );
        }
      }
      let anyArticulationUpdated = false;
      const articulations = Property_default.getValueOrUndefined(
        modelGraphics._articulations,
        time,
        modelData.articulationsScratch
      );
      if (defined_default(articulations)) {
        const articulationStageKeys = Object.keys(articulations);
        for (let s2 = 0, numKeys = articulationStageKeys.length; s2 < numKeys; ++s2) {
          const key = articulationStageKeys[s2];
          const articulationStageValue = articulations[key];
          if (!defined_default(articulationStageValue)) {
            continue;
          }
          anyArticulationUpdated = true;
          model.setArticulationStage(key, articulationStageValue);
        }
      }
      if (anyArticulationUpdated) {
        model.applyArticulations();
      }
    }
  }
  return true;
};
ModelVisualizer.prototype.isDestroyed = function() {
  return false;
};
ModelVisualizer.prototype.destroy = function() {
  this._entityCollection.collectionChanged.removeEventListener(
    ModelVisualizer.prototype._onCollectionChanged,
    this
  );
  const entities = this._entitiesToVisualize.values;
  const modelHash = this._modelHash;
  const primitives = this._primitives;
  for (let i2 = entities.length - 1; i2 > -1; i2--) {
    removeModel(this, entities[i2], modelHash, primitives);
  }
  return destroyObject_default(this);
};
ModelVisualizer.prototype.getBoundingSphere = function(entity, result) {
  if (!defined_default(entity)) {
    throw new DeveloperError_default("entity is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const modelData = this._modelHash[entity.id];
  if (!defined_default(modelData) || modelData.loadFail) {
    return BoundingSphereState_default.FAILED;
  }
  const model = modelData.modelPrimitive;
  if (!defined_default(model) || !model.show) {
    return BoundingSphereState_default.FAILED;
  }
  if (!model.ready) {
    return BoundingSphereState_default.PENDING;
  }
  if (model.heightReference === HeightReference_default.NONE) {
    BoundingSphere_default.transform(model.boundingSphere, model.modelMatrix, result);
  } else {
    if (!defined_default(model._clampedModelMatrix)) {
      return BoundingSphereState_default.PENDING;
    }
    BoundingSphere_default.transform(
      model.boundingSphere,
      model._clampedModelMatrix,
      result
    );
  }
  return BoundingSphereState_default.DONE;
};
ModelVisualizer.prototype._onCollectionChanged = function(entityCollection, added, removed, changed) {
  let i2;
  let entity;
  const entities = this._entitiesToVisualize;
  const modelHash = this._modelHash;
  const primitives = this._primitives;
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    if (defined_default(entity._model) && defined_default(entity._position)) {
      entities.set(entity.id, entity);
    }
  }
  for (i2 = changed.length - 1; i2 > -1; i2--) {
    entity = changed[i2];
    if (defined_default(entity._model) && defined_default(entity._position)) {
      clearNodeTransformationsArticulationsScratch(entity, modelHash);
      entities.set(entity.id, entity);
    } else {
      removeModel(this, entity, modelHash, primitives);
      entities.remove(entity.id);
    }
  }
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    removeModel(this, entity, modelHash, primitives);
    entities.remove(entity.id);
  }
};
function removeModel(visualizer, entity, modelHash, primitives) {
  const modelData = modelHash[entity.id];
  if (defined_default(modelData)) {
    primitives.removeAndDestroy(modelData.modelPrimitive);
    delete modelHash[entity.id];
  }
}
function clearNodeTransformationsArticulationsScratch(entity, modelHash) {
  const modelData = modelHash[entity.id];
  if (defined_default(modelData)) {
    modelData.nodeTransformationsScratch = {};
    modelData.articulationsScratch = {};
  }
}
function checkModelLoad(model, entity, modelHash) {
  model.readyPromise.catch(function(error) {
    console.error(error);
    modelHash[entity.id].loadFail = true;
  });
}
var ModelVisualizer_default = ModelVisualizer;

// node_modules/cesium/Source/DataSources/ScaledPositionProperty.js
function ScaledPositionProperty(value) {
  this._definitionChanged = new Event_default();
  this._value = void 0;
  this._removeSubscription = void 0;
  this.setValue(value);
}
Object.defineProperties(ScaledPositionProperty.prototype, {
  isConstant: {
    get: function() {
      return Property_default.isConstant(this._value);
    }
  },
  definitionChanged: {
    get: function() {
      return this._definitionChanged;
    }
  },
  referenceFrame: {
    get: function() {
      return defined_default(this._value) ? this._value.referenceFrame : ReferenceFrame_default.FIXED;
    }
  }
});
ScaledPositionProperty.prototype.getValue = function(time, result) {
  return this.getValueInReferenceFrame(time, ReferenceFrame_default.FIXED, result);
};
ScaledPositionProperty.prototype.setValue = function(value) {
  if (this._value !== value) {
    this._value = value;
    if (defined_default(this._removeSubscription)) {
      this._removeSubscription();
      this._removeSubscription = void 0;
    }
    if (defined_default(value)) {
      this._removeSubscription = value.definitionChanged.addEventListener(
        this._raiseDefinitionChanged,
        this
      );
    }
    this._definitionChanged.raiseEvent(this);
  }
};
ScaledPositionProperty.prototype.getValueInReferenceFrame = function(time, referenceFrame, result) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  if (!defined_default(referenceFrame)) {
    throw new DeveloperError_default("referenceFrame is required.");
  }
  if (!defined_default(this._value)) {
    return void 0;
  }
  result = this._value.getValueInReferenceFrame(time, referenceFrame, result);
  return defined_default(result) ? Ellipsoid_default.WGS84.scaleToGeodeticSurface(result, result) : void 0;
};
ScaledPositionProperty.prototype.equals = function(other) {
  return this === other || other instanceof ScaledPositionProperty && this._value === other._value;
};
ScaledPositionProperty.prototype._raiseDefinitionChanged = function() {
  this._definitionChanged.raiseEvent(this);
};
var ScaledPositionProperty_default = ScaledPositionProperty;

// node_modules/cesium/Source/DataSources/PathVisualizer.js
var defaultResolution = 60;
var defaultWidth = 1;
var scratchTimeInterval2 = new TimeInterval_default();
var subSampleCompositePropertyScratch = new TimeInterval_default();
var subSampleIntervalPropertyScratch = new TimeInterval_default();
function EntityData3(entity) {
  this.entity = entity;
  this.polyline = void 0;
  this.index = void 0;
  this.updater = void 0;
}
function subSampleSampledProperty(property, start, stop2, times, updateTime, referenceFrame, maximumStep, startingIndex, result) {
  let r2 = startingIndex;
  let tmp2;
  tmp2 = property.getValueInReferenceFrame(start, referenceFrame, result[r2]);
  if (defined_default(tmp2)) {
    result[r2++] = tmp2;
  }
  let steppedOnNow = !defined_default(updateTime) || JulianDate_default.lessThanOrEquals(updateTime, start) || JulianDate_default.greaterThanOrEquals(updateTime, stop2);
  let t = 0;
  const len = times.length;
  let current = times[t];
  const loopStop = stop2;
  let sampling = false;
  let sampleStepsToTake;
  let sampleStepsTaken;
  let sampleStepSize;
  while (t < len) {
    if (!steppedOnNow && JulianDate_default.greaterThanOrEquals(current, updateTime)) {
      tmp2 = property.getValueInReferenceFrame(
        updateTime,
        referenceFrame,
        result[r2]
      );
      if (defined_default(tmp2)) {
        result[r2++] = tmp2;
      }
      steppedOnNow = true;
    }
    if (JulianDate_default.greaterThan(current, start) && JulianDate_default.lessThan(current, loopStop) && !current.equals(updateTime)) {
      tmp2 = property.getValueInReferenceFrame(
        current,
        referenceFrame,
        result[r2]
      );
      if (defined_default(tmp2)) {
        result[r2++] = tmp2;
      }
    }
    if (t < len - 1) {
      if (maximumStep > 0 && !sampling) {
        const next = times[t + 1];
        const secondsUntilNext = JulianDate_default.secondsDifference(next, current);
        sampling = secondsUntilNext > maximumStep;
        if (sampling) {
          sampleStepsToTake = Math.ceil(secondsUntilNext / maximumStep);
          sampleStepsTaken = 0;
          sampleStepSize = secondsUntilNext / Math.max(sampleStepsToTake, 2);
          sampleStepsToTake = Math.max(sampleStepsToTake - 1, 1);
        }
      }
      if (sampling && sampleStepsTaken < sampleStepsToTake) {
        current = JulianDate_default.addSeconds(
          current,
          sampleStepSize,
          new JulianDate_default()
        );
        sampleStepsTaken++;
        continue;
      }
    }
    sampling = false;
    t++;
    current = times[t];
  }
  tmp2 = property.getValueInReferenceFrame(stop2, referenceFrame, result[r2]);
  if (defined_default(tmp2)) {
    result[r2++] = tmp2;
  }
  return r2;
}
function subSampleGenericProperty(property, start, stop2, updateTime, referenceFrame, maximumStep, startingIndex, result) {
  let tmp2;
  let i2 = 0;
  let index2 = startingIndex;
  let time = start;
  const stepSize = Math.max(maximumStep, 60);
  let steppedOnNow = !defined_default(updateTime) || JulianDate_default.lessThanOrEquals(updateTime, start) || JulianDate_default.greaterThanOrEquals(updateTime, stop2);
  while (JulianDate_default.lessThan(time, stop2)) {
    if (!steppedOnNow && JulianDate_default.greaterThanOrEquals(time, updateTime)) {
      steppedOnNow = true;
      tmp2 = property.getValueInReferenceFrame(
        updateTime,
        referenceFrame,
        result[index2]
      );
      if (defined_default(tmp2)) {
        result[index2] = tmp2;
        index2++;
      }
    }
    tmp2 = property.getValueInReferenceFrame(
      time,
      referenceFrame,
      result[index2]
    );
    if (defined_default(tmp2)) {
      result[index2] = tmp2;
      index2++;
    }
    i2++;
    time = JulianDate_default.addSeconds(start, stepSize * i2, new JulianDate_default());
  }
  tmp2 = property.getValueInReferenceFrame(stop2, referenceFrame, result[index2]);
  if (defined_default(tmp2)) {
    result[index2] = tmp2;
    index2++;
  }
  return index2;
}
function subSampleIntervalProperty(property, start, stop2, updateTime, referenceFrame, maximumStep, startingIndex, result) {
  subSampleIntervalPropertyScratch.start = start;
  subSampleIntervalPropertyScratch.stop = stop2;
  let index2 = startingIndex;
  const intervals = property.intervals;
  for (let i2 = 0; i2 < intervals.length; i2++) {
    const interval = intervals.get(i2);
    if (!TimeInterval_default.intersect(
      interval,
      subSampleIntervalPropertyScratch,
      scratchTimeInterval2
    ).isEmpty) {
      let time = interval.start;
      if (!interval.isStartIncluded) {
        if (interval.isStopIncluded) {
          time = interval.stop;
        } else {
          time = JulianDate_default.addSeconds(
            interval.start,
            JulianDate_default.secondsDifference(interval.stop, interval.start) / 2,
            new JulianDate_default()
          );
        }
      }
      const tmp2 = property.getValueInReferenceFrame(
        time,
        referenceFrame,
        result[index2]
      );
      if (defined_default(tmp2)) {
        result[index2] = tmp2;
        index2++;
      }
    }
  }
  return index2;
}
function subSampleConstantProperty(property, start, stop2, updateTime, referenceFrame, maximumStep, startingIndex, result) {
  const tmp2 = property.getValueInReferenceFrame(
    start,
    referenceFrame,
    result[startingIndex]
  );
  if (defined_default(tmp2)) {
    result[startingIndex++] = tmp2;
  }
  return startingIndex;
}
function subSampleCompositeProperty(property, start, stop2, updateTime, referenceFrame, maximumStep, startingIndex, result) {
  subSampleCompositePropertyScratch.start = start;
  subSampleCompositePropertyScratch.stop = stop2;
  let index2 = startingIndex;
  const intervals = property.intervals;
  for (let i2 = 0; i2 < intervals.length; i2++) {
    const interval = intervals.get(i2);
    if (!TimeInterval_default.intersect(
      interval,
      subSampleCompositePropertyScratch,
      scratchTimeInterval2
    ).isEmpty) {
      const intervalStart = interval.start;
      const intervalStop = interval.stop;
      let sampleStart = start;
      if (JulianDate_default.greaterThan(intervalStart, sampleStart)) {
        sampleStart = intervalStart;
      }
      let sampleStop = stop2;
      if (JulianDate_default.lessThan(intervalStop, sampleStop)) {
        sampleStop = intervalStop;
      }
      index2 = reallySubSample(
        interval.data,
        sampleStart,
        sampleStop,
        updateTime,
        referenceFrame,
        maximumStep,
        index2,
        result
      );
    }
  }
  return index2;
}
function reallySubSample(property, start, stop2, updateTime, referenceFrame, maximumStep, index2, result) {
  while (property instanceof ReferenceProperty_default) {
    property = property.resolvedProperty;
  }
  if (property instanceof SampledPositionProperty_default) {
    const times = property._property._times;
    index2 = subSampleSampledProperty(
      property,
      start,
      stop2,
      times,
      updateTime,
      referenceFrame,
      maximumStep,
      index2,
      result
    );
  } else if (property instanceof CompositePositionProperty_default) {
    index2 = subSampleCompositeProperty(
      property,
      start,
      stop2,
      updateTime,
      referenceFrame,
      maximumStep,
      index2,
      result
    );
  } else if (property instanceof TimeIntervalCollectionPositionProperty_default) {
    index2 = subSampleIntervalProperty(
      property,
      start,
      stop2,
      updateTime,
      referenceFrame,
      maximumStep,
      index2,
      result
    );
  } else if (property instanceof ConstantPositionProperty_default || property instanceof ScaledPositionProperty_default && Property_default.isConstant(property)) {
    index2 = subSampleConstantProperty(
      property,
      start,
      stop2,
      updateTime,
      referenceFrame,
      maximumStep,
      index2,
      result
    );
  } else {
    index2 = subSampleGenericProperty(
      property,
      start,
      stop2,
      updateTime,
      referenceFrame,
      maximumStep,
      index2,
      result
    );
  }
  return index2;
}
function subSample(property, start, stop2, updateTime, referenceFrame, maximumStep, result) {
  if (!defined_default(result)) {
    result = [];
  }
  const length3 = reallySubSample(
    property,
    start,
    stop2,
    updateTime,
    referenceFrame,
    maximumStep,
    0,
    result
  );
  result.length = length3;
  return result;
}
var toFixedScratch = new Matrix3_default();
function PolylineUpdater(scene, referenceFrame) {
  this._unusedIndexes = [];
  this._polylineCollection = new PolylineCollection_default();
  this._scene = scene;
  this._referenceFrame = referenceFrame;
  scene.primitives.add(this._polylineCollection);
}
PolylineUpdater.prototype.update = function(time) {
  if (this._referenceFrame === ReferenceFrame_default.INERTIAL) {
    let toFixed = Transforms_default.computeIcrfToFixedMatrix(time, toFixedScratch);
    if (!defined_default(toFixed)) {
      toFixed = Transforms_default.computeTemeToPseudoFixedMatrix(time, toFixedScratch);
    }
    Matrix4_default.fromRotationTranslation(
      toFixed,
      Cartesian3_default.ZERO,
      this._polylineCollection.modelMatrix
    );
  }
};
PolylineUpdater.prototype.updateObject = function(time, item) {
  const entity = item.entity;
  const pathGraphics = entity._path;
  const positionProperty = entity._position;
  let sampleStart;
  let sampleStop;
  const showProperty = pathGraphics._show;
  let polyline = item.polyline;
  let show = entity.isShowing && entity.isAvailable(time) && (!defined_default(showProperty) || showProperty.getValue(time));
  if (show) {
    const leadTime = Property_default.getValueOrUndefined(pathGraphics._leadTime, time);
    const trailTime = Property_default.getValueOrUndefined(
      pathGraphics._trailTime,
      time
    );
    const availability = entity._availability;
    const hasAvailability = defined_default(availability);
    const hasLeadTime = defined_default(leadTime);
    const hasTrailTime = defined_default(trailTime);
    show = hasAvailability || hasLeadTime && hasTrailTime;
    if (show) {
      if (hasTrailTime) {
        sampleStart = JulianDate_default.addSeconds(time, -trailTime, new JulianDate_default());
      }
      if (hasLeadTime) {
        sampleStop = JulianDate_default.addSeconds(time, leadTime, new JulianDate_default());
      }
      if (hasAvailability) {
        const start = availability.start;
        const stop2 = availability.stop;
        if (!hasTrailTime || JulianDate_default.greaterThan(start, sampleStart)) {
          sampleStart = start;
        }
        if (!hasLeadTime || JulianDate_default.lessThan(stop2, sampleStop)) {
          sampleStop = stop2;
        }
      }
      show = JulianDate_default.lessThan(sampleStart, sampleStop);
    }
  }
  if (!show) {
    if (defined_default(polyline)) {
      this._unusedIndexes.push(item.index);
      item.polyline = void 0;
      polyline.show = false;
      item.index = void 0;
    }
    return;
  }
  if (!defined_default(polyline)) {
    const unusedIndexes = this._unusedIndexes;
    const length3 = unusedIndexes.length;
    if (length3 > 0) {
      const index2 = unusedIndexes.pop();
      polyline = this._polylineCollection.get(index2);
      item.index = index2;
    } else {
      item.index = this._polylineCollection.length;
      polyline = this._polylineCollection.add();
    }
    polyline.id = entity;
    item.polyline = polyline;
  }
  const resolution = Property_default.getValueOrDefault(
    pathGraphics._resolution,
    time,
    defaultResolution
  );
  polyline.show = true;
  polyline.positions = subSample(
    positionProperty,
    sampleStart,
    sampleStop,
    time,
    this._referenceFrame,
    resolution,
    polyline.positions.slice()
  );
  polyline.material = MaterialProperty_default.getValue(
    time,
    pathGraphics._material,
    polyline.material
  );
  polyline.width = Property_default.getValueOrDefault(
    pathGraphics._width,
    time,
    defaultWidth
  );
  polyline.distanceDisplayCondition = Property_default.getValueOrUndefined(
    pathGraphics._distanceDisplayCondition,
    time,
    polyline.distanceDisplayCondition
  );
};
PolylineUpdater.prototype.removeObject = function(item) {
  const polyline = item.polyline;
  if (defined_default(polyline)) {
    this._unusedIndexes.push(item.index);
    item.polyline = void 0;
    polyline.show = false;
    polyline.id = void 0;
    item.index = void 0;
  }
};
PolylineUpdater.prototype.destroy = function() {
  this._scene.primitives.remove(this._polylineCollection);
  return destroyObject_default(this);
};
function PathVisualizer(scene, entityCollection) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  if (!defined_default(entityCollection)) {
    throw new DeveloperError_default("entityCollection is required.");
  }
  entityCollection.collectionChanged.addEventListener(
    PathVisualizer.prototype._onCollectionChanged,
    this
  );
  this._scene = scene;
  this._updaters = {};
  this._entityCollection = entityCollection;
  this._items = new AssociativeArray_default();
  this._onCollectionChanged(entityCollection, entityCollection.values, [], []);
}
PathVisualizer.prototype.update = function(time) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  const updaters = this._updaters;
  for (const key in updaters) {
    if (updaters.hasOwnProperty(key)) {
      updaters[key].update(time);
    }
  }
  const items = this._items.values;
  if (items.length === 0 && defined_default(this._updaters) && Object.keys(this._updaters).length > 0) {
    for (const u3 in updaters) {
      if (updaters.hasOwnProperty(u3)) {
        updaters[u3].destroy();
      }
    }
    this._updaters = {};
  }
  for (let i2 = 0, len = items.length; i2 < len; i2++) {
    const item = items[i2];
    const entity = item.entity;
    const positionProperty = entity._position;
    const lastUpdater = item.updater;
    let frameToVisualize = ReferenceFrame_default.FIXED;
    if (this._scene.mode === SceneMode_default.SCENE3D) {
      frameToVisualize = positionProperty.referenceFrame;
    }
    let currentUpdater = this._updaters[frameToVisualize];
    if (lastUpdater === currentUpdater && defined_default(currentUpdater)) {
      currentUpdater.updateObject(time, item);
      continue;
    }
    if (defined_default(lastUpdater)) {
      lastUpdater.removeObject(item);
    }
    if (!defined_default(currentUpdater)) {
      currentUpdater = new PolylineUpdater(this._scene, frameToVisualize);
      currentUpdater.update(time);
      this._updaters[frameToVisualize] = currentUpdater;
    }
    item.updater = currentUpdater;
    if (defined_default(currentUpdater)) {
      currentUpdater.updateObject(time, item);
    }
  }
  return true;
};
PathVisualizer.prototype.isDestroyed = function() {
  return false;
};
PathVisualizer.prototype.destroy = function() {
  this._entityCollection.collectionChanged.removeEventListener(
    PathVisualizer.prototype._onCollectionChanged,
    this
  );
  const updaters = this._updaters;
  for (const key in updaters) {
    if (updaters.hasOwnProperty(key)) {
      updaters[key].destroy();
    }
  }
  return destroyObject_default(this);
};
PathVisualizer.prototype._onCollectionChanged = function(entityCollection, added, removed, changed) {
  let i2;
  let entity;
  let item;
  const items = this._items;
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    if (defined_default(entity._path) && defined_default(entity._position)) {
      items.set(entity.id, new EntityData3(entity));
    }
  }
  for (i2 = changed.length - 1; i2 > -1; i2--) {
    entity = changed[i2];
    if (defined_default(entity._path) && defined_default(entity._position)) {
      if (!items.contains(entity.id)) {
        items.set(entity.id, new EntityData3(entity));
      }
    } else {
      item = items.get(entity.id);
      if (defined_default(item)) {
        if (defined_default(item.updater)) {
          item.updater.removeObject(item);
        }
        items.remove(entity.id);
      }
    }
  }
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    item = items.get(entity.id);
    if (defined_default(item)) {
      if (defined_default(item.updater)) {
        item.updater.removeObject(item);
      }
      items.remove(entity.id);
    }
  }
};
PathVisualizer._subSample = subSample;
var PathVisualizer_default = PathVisualizer;

// node_modules/cesium/Source/DataSources/PointVisualizer.js
var defaultColor8 = Color_default.WHITE;
var defaultOutlineColor4 = Color_default.BLACK;
var defaultOutlineWidth3 = 0;
var defaultPixelSize = 1;
var defaultDisableDepthTestDistance = 0;
var colorScratch7 = new Color_default();
var positionScratch13 = new Cartesian3_default();
var outlineColorScratch2 = new Color_default();
var scaleByDistanceScratch3 = new NearFarScalar_default();
var translucencyByDistanceScratch3 = new NearFarScalar_default();
var distanceDisplayConditionScratch8 = new DistanceDisplayCondition_default();
function EntityData4(entity) {
  this.entity = entity;
  this.pointPrimitive = void 0;
  this.billboard = void 0;
  this.color = void 0;
  this.outlineColor = void 0;
  this.pixelSize = void 0;
  this.outlineWidth = void 0;
}
function PointVisualizer(entityCluster, entityCollection) {
  if (!defined_default(entityCluster)) {
    throw new DeveloperError_default("entityCluster is required.");
  }
  if (!defined_default(entityCollection)) {
    throw new DeveloperError_default("entityCollection is required.");
  }
  entityCollection.collectionChanged.addEventListener(
    PointVisualizer.prototype._onCollectionChanged,
    this
  );
  this._cluster = entityCluster;
  this._entityCollection = entityCollection;
  this._items = new AssociativeArray_default();
  this._onCollectionChanged(entityCollection, entityCollection.values, [], []);
}
PointVisualizer.prototype.update = function(time) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  const items = this._items.values;
  const cluster = this._cluster;
  for (let i2 = 0, len = items.length; i2 < len; i2++) {
    const item = items[i2];
    const entity = item.entity;
    const pointGraphics = entity._point;
    let pointPrimitive = item.pointPrimitive;
    let billboard = item.billboard;
    const heightReference = Property_default.getValueOrDefault(
      pointGraphics._heightReference,
      time,
      HeightReference_default.NONE
    );
    let show = entity.isShowing && entity.isAvailable(time) && Property_default.getValueOrDefault(pointGraphics._show, time, true);
    let position;
    if (show) {
      position = Property_default.getValueOrUndefined(
        entity._position,
        time,
        positionScratch13
      );
      show = defined_default(position);
    }
    if (!show) {
      returnPrimitive3(item, entity, cluster);
      continue;
    }
    if (!Property_default.isConstant(entity._position)) {
      cluster._clusterDirty = true;
    }
    let needsRedraw = false;
    let updateClamping2 = false;
    if (heightReference !== HeightReference_default.NONE && !defined_default(billboard)) {
      if (defined_default(pointPrimitive)) {
        returnPrimitive3(item, entity, cluster);
        pointPrimitive = void 0;
      }
      billboard = cluster.getBillboard(entity);
      billboard.id = entity;
      billboard.image = void 0;
      item.billboard = billboard;
      needsRedraw = true;
      updateClamping2 = Cartesian3_default.equals(billboard.position, position) && billboard.heightReference === heightReference;
    } else if (heightReference === HeightReference_default.NONE && !defined_default(pointPrimitive)) {
      if (defined_default(billboard)) {
        returnPrimitive3(item, entity, cluster);
        billboard = void 0;
      }
      pointPrimitive = cluster.getPoint(entity);
      pointPrimitive.id = entity;
      item.pointPrimitive = pointPrimitive;
    }
    if (defined_default(pointPrimitive)) {
      pointPrimitive.show = true;
      pointPrimitive.position = position;
      pointPrimitive.scaleByDistance = Property_default.getValueOrUndefined(
        pointGraphics._scaleByDistance,
        time,
        scaleByDistanceScratch3
      );
      pointPrimitive.translucencyByDistance = Property_default.getValueOrUndefined(
        pointGraphics._translucencyByDistance,
        time,
        translucencyByDistanceScratch3
      );
      pointPrimitive.color = Property_default.getValueOrDefault(
        pointGraphics._color,
        time,
        defaultColor8,
        colorScratch7
      );
      pointPrimitive.outlineColor = Property_default.getValueOrDefault(
        pointGraphics._outlineColor,
        time,
        defaultOutlineColor4,
        outlineColorScratch2
      );
      pointPrimitive.outlineWidth = Property_default.getValueOrDefault(
        pointGraphics._outlineWidth,
        time,
        defaultOutlineWidth3
      );
      pointPrimitive.pixelSize = Property_default.getValueOrDefault(
        pointGraphics._pixelSize,
        time,
        defaultPixelSize
      );
      pointPrimitive.distanceDisplayCondition = Property_default.getValueOrUndefined(
        pointGraphics._distanceDisplayCondition,
        time,
        distanceDisplayConditionScratch8
      );
      pointPrimitive.disableDepthTestDistance = Property_default.getValueOrDefault(
        pointGraphics._disableDepthTestDistance,
        time,
        defaultDisableDepthTestDistance
      );
    } else if (defined_default(billboard)) {
      billboard.show = true;
      billboard.position = position;
      billboard.scaleByDistance = Property_default.getValueOrUndefined(
        pointGraphics._scaleByDistance,
        time,
        scaleByDistanceScratch3
      );
      billboard.translucencyByDistance = Property_default.getValueOrUndefined(
        pointGraphics._translucencyByDistance,
        time,
        translucencyByDistanceScratch3
      );
      billboard.distanceDisplayCondition = Property_default.getValueOrUndefined(
        pointGraphics._distanceDisplayCondition,
        time,
        distanceDisplayConditionScratch8
      );
      billboard.disableDepthTestDistance = Property_default.getValueOrDefault(
        pointGraphics._disableDepthTestDistance,
        time,
        defaultDisableDepthTestDistance
      );
      billboard.heightReference = heightReference;
      const newColor = Property_default.getValueOrDefault(
        pointGraphics._color,
        time,
        defaultColor8,
        colorScratch7
      );
      const newOutlineColor = Property_default.getValueOrDefault(
        pointGraphics._outlineColor,
        time,
        defaultOutlineColor4,
        outlineColorScratch2
      );
      const newOutlineWidth = Math.round(
        Property_default.getValueOrDefault(
          pointGraphics._outlineWidth,
          time,
          defaultOutlineWidth3
        )
      );
      let newPixelSize = Math.max(
        1,
        Math.round(
          Property_default.getValueOrDefault(
            pointGraphics._pixelSize,
            time,
            defaultPixelSize
          )
        )
      );
      if (newOutlineWidth > 0) {
        billboard.scale = 1;
        needsRedraw = needsRedraw || newOutlineWidth !== item.outlineWidth || newPixelSize !== item.pixelSize || !Color_default.equals(newColor, item.color) || !Color_default.equals(newOutlineColor, item.outlineColor);
      } else {
        billboard.scale = newPixelSize / 50;
        newPixelSize = 50;
        needsRedraw = needsRedraw || newOutlineWidth !== item.outlineWidth || !Color_default.equals(newColor, item.color) || !Color_default.equals(newOutlineColor, item.outlineColor);
      }
      if (needsRedraw) {
        item.color = Color_default.clone(newColor, item.color);
        item.outlineColor = Color_default.clone(newOutlineColor, item.outlineColor);
        item.pixelSize = newPixelSize;
        item.outlineWidth = newOutlineWidth;
        const centerAlpha = newColor.alpha;
        const cssColor = newColor.toCssColorString();
        const cssOutlineColor = newOutlineColor.toCssColorString();
        const textureId = JSON.stringify([
          cssColor,
          newPixelSize,
          cssOutlineColor,
          newOutlineWidth
        ]);
        billboard.setImage(
          textureId,
          createBillboardPointCallback_default(
            centerAlpha,
            cssColor,
            cssOutlineColor,
            newOutlineWidth,
            newPixelSize
          )
        );
      }
      if (updateClamping2) {
        billboard._updateClamping();
      }
    }
  }
  return true;
};
PointVisualizer.prototype.getBoundingSphere = function(entity, result) {
  if (!defined_default(entity)) {
    throw new DeveloperError_default("entity is required.");
  }
  if (!defined_default(result)) {
    throw new DeveloperError_default("result is required.");
  }
  const item = this._items.get(entity.id);
  if (!defined_default(item) || !(defined_default(item.pointPrimitive) || defined_default(item.billboard))) {
    return BoundingSphereState_default.FAILED;
  }
  if (defined_default(item.pointPrimitive)) {
    result.center = Cartesian3_default.clone(
      item.pointPrimitive.position,
      result.center
    );
  } else {
    const billboard = item.billboard;
    if (!defined_default(billboard._clampedPosition)) {
      return BoundingSphereState_default.PENDING;
    }
    result.center = Cartesian3_default.clone(billboard._clampedPosition, result.center);
  }
  result.radius = 0;
  return BoundingSphereState_default.DONE;
};
PointVisualizer.prototype.isDestroyed = function() {
  return false;
};
PointVisualizer.prototype.destroy = function() {
  this._entityCollection.collectionChanged.removeEventListener(
    PointVisualizer.prototype._onCollectionChanged,
    this
  );
  const entities = this._entityCollection.values;
  for (let i2 = 0; i2 < entities.length; i2++) {
    this._cluster.removePoint(entities[i2]);
  }
  return destroyObject_default(this);
};
PointVisualizer.prototype._onCollectionChanged = function(entityCollection, added, removed, changed) {
  let i2;
  let entity;
  const items = this._items;
  const cluster = this._cluster;
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    if (defined_default(entity._point) && defined_default(entity._position)) {
      items.set(entity.id, new EntityData4(entity));
    }
  }
  for (i2 = changed.length - 1; i2 > -1; i2--) {
    entity = changed[i2];
    if (defined_default(entity._point) && defined_default(entity._position)) {
      if (!items.contains(entity.id)) {
        items.set(entity.id, new EntityData4(entity));
      }
    } else {
      returnPrimitive3(items.get(entity.id), entity, cluster);
      items.remove(entity.id);
    }
  }
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    returnPrimitive3(items.get(entity.id), entity, cluster);
    items.remove(entity.id);
  }
};
function returnPrimitive3(item, entity, cluster) {
  if (defined_default(item)) {
    const pointPrimitive = item.pointPrimitive;
    if (defined_default(pointPrimitive)) {
      item.pointPrimitive = void 0;
      cluster.removePoint(entity);
      return;
    }
    const billboard = item.billboard;
    if (defined_default(billboard)) {
      item.billboard = void 0;
      cluster.removeBillboard(entity);
    }
  }
}
var PointVisualizer_default = PointVisualizer;

// node_modules/cesium/Source/DataSources/PolylineGeometryUpdater.js
var defaultZIndex2 = new ConstantProperty_default(0);
var polylineCollections = {};
var scratchColor21 = new Color_default();
var defaultMaterial3 = new ColorMaterialProperty_default(Color_default.WHITE);
var defaultShow2 = new ConstantProperty_default(true);
var defaultShadows3 = new ConstantProperty_default(ShadowMode_default.DISABLED);
var defaultDistanceDisplayCondition7 = new ConstantProperty_default(
  new DistanceDisplayCondition_default()
);
var defaultClassificationType2 = new ConstantProperty_default(ClassificationType_default.BOTH);
function GeometryOptions() {
  this.vertexFormat = void 0;
  this.positions = void 0;
  this.width = void 0;
  this.arcType = void 0;
  this.granularity = void 0;
}
function GroundGeometryOptions() {
  this.positions = void 0;
  this.width = void 0;
  this.arcType = void 0;
  this.granularity = void 0;
}
function PolylineGeometryUpdater(entity, scene) {
  if (!defined_default(entity)) {
    throw new DeveloperError_default("entity is required");
  }
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required");
  }
  this._entity = entity;
  this._scene = scene;
  this._entitySubscription = entity.definitionChanged.addEventListener(
    PolylineGeometryUpdater.prototype._onEntityPropertyChanged,
    this
  );
  this._fillEnabled = false;
  this._dynamic = false;
  this._geometryChanged = new Event_default();
  this._showProperty = void 0;
  this._materialProperty = void 0;
  this._shadowsProperty = void 0;
  this._distanceDisplayConditionProperty = void 0;
  this._classificationTypeProperty = void 0;
  this._depthFailMaterialProperty = void 0;
  this._geometryOptions = new GeometryOptions();
  this._groundGeometryOptions = new GroundGeometryOptions();
  this._id = `polyline-${entity.id}`;
  this._clampToGround = false;
  this._supportsPolylinesOnTerrain = Entity_default.supportsPolylinesOnTerrain(scene);
  this._zIndex = 0;
  this._onEntityPropertyChanged(entity, "polyline", entity.polyline, void 0);
}
Object.defineProperties(PolylineGeometryUpdater.prototype, {
  id: {
    get: function() {
      return this._id;
    }
  },
  entity: {
    get: function() {
      return this._entity;
    }
  },
  fillEnabled: {
    get: function() {
      return this._fillEnabled;
    }
  },
  hasConstantFill: {
    get: function() {
      return !this._fillEnabled || !defined_default(this._entity.availability) && Property_default.isConstant(this._showProperty);
    }
  },
  fillMaterialProperty: {
    get: function() {
      return this._materialProperty;
    }
  },
  depthFailMaterialProperty: {
    get: function() {
      return this._depthFailMaterialProperty;
    }
  },
  outlineEnabled: {
    value: false
  },
  hasConstantOutline: {
    value: true
  },
  outlineColorProperty: {
    value: void 0
  },
  shadowsProperty: {
    get: function() {
      return this._shadowsProperty;
    }
  },
  distanceDisplayConditionProperty: {
    get: function() {
      return this._distanceDisplayConditionProperty;
    }
  },
  classificationTypeProperty: {
    get: function() {
      return this._classificationTypeProperty;
    }
  },
  isDynamic: {
    get: function() {
      return this._dynamic;
    }
  },
  isClosed: {
    value: false
  },
  geometryChanged: {
    get: function() {
      return this._geometryChanged;
    }
  },
  arcType: {
    get: function() {
      return this._arcType;
    }
  },
  clampToGround: {
    get: function() {
      return this._clampToGround && this._supportsPolylinesOnTerrain;
    }
  },
  zIndex: {
    get: function() {
      return this._zIndex;
    }
  }
});
PolylineGeometryUpdater.prototype.isOutlineVisible = function(time) {
  return false;
};
PolylineGeometryUpdater.prototype.isFilled = function(time) {
  const entity = this._entity;
  const visible = this._fillEnabled && entity.isAvailable(time) && this._showProperty.getValue(time);
  return defaultValue_default(visible, false);
};
PolylineGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  if (!defined_default(time)) {
    throw new DeveloperError_default("time is required.");
  }
  if (!this._fillEnabled) {
    throw new DeveloperError_default(
      "This instance does not represent a filled geometry."
    );
  }
  const entity = this._entity;
  const isAvailable = entity.isAvailable(time);
  const show = new ShowGeometryInstanceAttribute_default(
    isAvailable && entity.isShowing && this._showProperty.getValue(time)
  );
  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
    time
  );
  const distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute_default.fromDistanceDisplayCondition(
    distanceDisplayCondition
  );
  const attributes = {
    show,
    distanceDisplayCondition: distanceDisplayConditionAttribute
  };
  let currentColor;
  if (this._materialProperty instanceof ColorMaterialProperty_default) {
    if (defined_default(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
      currentColor = this._materialProperty.color.getValue(time, scratchColor21);
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    attributes.color = ColorGeometryInstanceAttribute_default.fromColor(currentColor);
  }
  if (this.clampToGround) {
    return new GeometryInstance_default({
      id: entity,
      geometry: new GroundPolylineGeometry_default(this._groundGeometryOptions),
      attributes
    });
  }
  if (defined_default(this._depthFailMaterialProperty) && this._depthFailMaterialProperty instanceof ColorMaterialProperty_default) {
    if (defined_default(this._depthFailMaterialProperty.color) && (this._depthFailMaterialProperty.color.isConstant || isAvailable)) {
      currentColor = this._depthFailMaterialProperty.color.getValue(
        time,
        scratchColor21
      );
    }
    if (!defined_default(currentColor)) {
      currentColor = Color_default.WHITE;
    }
    attributes.depthFailColor = ColorGeometryInstanceAttribute_default.fromColor(
      currentColor
    );
  }
  return new GeometryInstance_default({
    id: entity,
    geometry: new PolylineGeometry_default(this._geometryOptions),
    attributes
  });
};
PolylineGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  throw new DeveloperError_default(
    "This instance does not represent an outlined geometry."
  );
};
PolylineGeometryUpdater.prototype.isDestroyed = function() {
  return false;
};
PolylineGeometryUpdater.prototype.destroy = function() {
  this._entitySubscription();
  destroyObject_default(this);
};
PolylineGeometryUpdater.prototype._onEntityPropertyChanged = function(entity, propertyName, newValue, oldValue2) {
  if (!(propertyName === "availability" || propertyName === "polyline")) {
    return;
  }
  const polyline = this._entity.polyline;
  if (!defined_default(polyline)) {
    if (this._fillEnabled) {
      this._fillEnabled = false;
      this._geometryChanged.raiseEvent(this);
    }
    return;
  }
  const positionsProperty = polyline.positions;
  const show = polyline.show;
  if (defined_default(show) && show.isConstant && !show.getValue(Iso8601_default.MINIMUM_VALUE) || !defined_default(positionsProperty)) {
    if (this._fillEnabled) {
      this._fillEnabled = false;
      this._geometryChanged.raiseEvent(this);
    }
    return;
  }
  const zIndex = polyline.zIndex;
  const material = defaultValue_default(polyline.material, defaultMaterial3);
  const isColorMaterial = material instanceof ColorMaterialProperty_default;
  this._materialProperty = material;
  this._depthFailMaterialProperty = polyline.depthFailMaterial;
  this._showProperty = defaultValue_default(show, defaultShow2);
  this._shadowsProperty = defaultValue_default(polyline.shadows, defaultShadows3);
  this._distanceDisplayConditionProperty = defaultValue_default(
    polyline.distanceDisplayCondition,
    defaultDistanceDisplayCondition7
  );
  this._classificationTypeProperty = defaultValue_default(
    polyline.classificationType,
    defaultClassificationType2
  );
  this._fillEnabled = true;
  this._zIndex = defaultValue_default(zIndex, defaultZIndex2);
  const width = polyline.width;
  const arcType = polyline.arcType;
  const clampToGround = polyline.clampToGround;
  const granularity = polyline.granularity;
  if (!positionsProperty.isConstant || !Property_default.isConstant(width) || !Property_default.isConstant(arcType) || !Property_default.isConstant(granularity) || !Property_default.isConstant(clampToGround) || !Property_default.isConstant(zIndex)) {
    if (!this._dynamic) {
      this._dynamic = true;
      this._geometryChanged.raiseEvent(this);
    }
  } else {
    const geometryOptions = this._geometryOptions;
    const positions = positionsProperty.getValue(
      Iso8601_default.MINIMUM_VALUE,
      geometryOptions.positions
    );
    if (!defined_default(positions) || positions.length < 2) {
      if (this._fillEnabled) {
        this._fillEnabled = false;
        this._geometryChanged.raiseEvent(this);
      }
      return;
    }
    let vertexFormat;
    if (isColorMaterial && (!defined_default(this._depthFailMaterialProperty) || this._depthFailMaterialProperty instanceof ColorMaterialProperty_default)) {
      vertexFormat = PolylineColorAppearance_default.VERTEX_FORMAT;
    } else {
      vertexFormat = PolylineMaterialAppearance_default.VERTEX_FORMAT;
    }
    geometryOptions.vertexFormat = vertexFormat;
    geometryOptions.positions = positions;
    geometryOptions.width = defined_default(width) ? width.getValue(Iso8601_default.MINIMUM_VALUE) : void 0;
    geometryOptions.arcType = defined_default(arcType) ? arcType.getValue(Iso8601_default.MINIMUM_VALUE) : void 0;
    geometryOptions.granularity = defined_default(granularity) ? granularity.getValue(Iso8601_default.MINIMUM_VALUE) : void 0;
    const groundGeometryOptions = this._groundGeometryOptions;
    groundGeometryOptions.positions = positions;
    groundGeometryOptions.width = geometryOptions.width;
    groundGeometryOptions.arcType = geometryOptions.arcType;
    groundGeometryOptions.granularity = geometryOptions.granularity;
    this._clampToGround = defined_default(clampToGround) ? clampToGround.getValue(Iso8601_default.MINIMUM_VALUE) : false;
    if (!this._clampToGround && defined_default(zIndex)) {
      oneTimeWarning_default(
        "Entity polylines must have clampToGround: true when using zIndex.  zIndex will be ignored."
      );
    }
    this._dynamic = false;
    this._geometryChanged.raiseEvent(this);
  }
};
PolylineGeometryUpdater.prototype.createDynamicUpdater = function(primitives, groundPrimitives) {
  Check_default.defined("primitives", primitives);
  Check_default.defined("groundPrimitives", groundPrimitives);
  if (!this._dynamic) {
    throw new DeveloperError_default(
      "This instance does not represent dynamic geometry."
    );
  }
  return new DynamicGeometryUpdater2(primitives, groundPrimitives, this);
};
var generateCartesianArcOptions = {
  positions: void 0,
  granularity: void 0,
  height: void 0,
  ellipsoid: void 0
};
function DynamicGeometryUpdater2(primitives, groundPrimitives, geometryUpdater) {
  this._line = void 0;
  this._primitives = primitives;
  this._groundPrimitives = groundPrimitives;
  this._groundPolylinePrimitive = void 0;
  this._material = void 0;
  this._geometryUpdater = geometryUpdater;
  this._positions = [];
}
function getLine(dynamicGeometryUpdater) {
  if (defined_default(dynamicGeometryUpdater._line)) {
    return dynamicGeometryUpdater._line;
  }
  const sceneId = dynamicGeometryUpdater._geometryUpdater._scene.id;
  let polylineCollection = polylineCollections[sceneId];
  const primitives = dynamicGeometryUpdater._primitives;
  if (!defined_default(polylineCollection) || polylineCollection.isDestroyed()) {
    polylineCollection = new PolylineCollection_default();
    polylineCollections[sceneId] = polylineCollection;
    primitives.add(polylineCollection);
  } else if (!primitives.contains(polylineCollection)) {
    primitives.add(polylineCollection);
  }
  const line = polylineCollection.add();
  line.id = dynamicGeometryUpdater._geometryUpdater._entity;
  dynamicGeometryUpdater._line = line;
  return line;
}
DynamicGeometryUpdater2.prototype.update = function(time) {
  const geometryUpdater = this._geometryUpdater;
  const entity = geometryUpdater._entity;
  const polyline = entity.polyline;
  const positionsProperty = polyline.positions;
  let positions = Property_default.getValueOrUndefined(
    positionsProperty,
    time,
    this._positions
  );
  geometryUpdater._clampToGround = Property_default.getValueOrDefault(
    polyline._clampToGround,
    time,
    false
  );
  geometryUpdater._groundGeometryOptions.positions = positions;
  geometryUpdater._groundGeometryOptions.width = Property_default.getValueOrDefault(
    polyline._width,
    time,
    1
  );
  geometryUpdater._groundGeometryOptions.arcType = Property_default.getValueOrDefault(
    polyline._arcType,
    time,
    ArcType_default.GEODESIC
  );
  geometryUpdater._groundGeometryOptions.granularity = Property_default.getValueOrDefault(
    polyline._granularity,
    time,
    9999
  );
  const groundPrimitives = this._groundPrimitives;
  if (defined_default(this._groundPolylinePrimitive)) {
    groundPrimitives.remove(this._groundPolylinePrimitive);
    this._groundPolylinePrimitive = void 0;
  }
  if (geometryUpdater.clampToGround) {
    if (!entity.isShowing || !entity.isAvailable(time) || !Property_default.getValueOrDefault(polyline._show, time, true)) {
      return;
    }
    if (!defined_default(positions) || positions.length < 2) {
      return;
    }
    const fillMaterialProperty = geometryUpdater.fillMaterialProperty;
    let appearance;
    if (fillMaterialProperty instanceof ColorMaterialProperty_default) {
      appearance = new PolylineColorAppearance_default();
    } else {
      const material = MaterialProperty_default.getValue(
        time,
        fillMaterialProperty,
        this._material
      );
      appearance = new PolylineMaterialAppearance_default({
        material,
        translucent: material.isTranslucent()
      });
      this._material = material;
    }
    this._groundPolylinePrimitive = groundPrimitives.add(
      new GroundPolylinePrimitive_default({
        geometryInstances: geometryUpdater.createFillGeometryInstance(time),
        appearance,
        classificationType: geometryUpdater.classificationTypeProperty.getValue(
          time
        ),
        asynchronous: false
      }),
      Property_default.getValueOrUndefined(geometryUpdater.zIndex, time)
    );
    if (defined_default(this._line)) {
      this._line.show = false;
    }
    return;
  }
  const line = getLine(this);
  if (!entity.isShowing || !entity.isAvailable(time) || !Property_default.getValueOrDefault(polyline._show, time, true)) {
    line.show = false;
    return;
  }
  if (!defined_default(positions) || positions.length < 2) {
    line.show = false;
    return;
  }
  let arcType = ArcType_default.GEODESIC;
  arcType = Property_default.getValueOrDefault(polyline._arcType, time, arcType);
  const globe = geometryUpdater._scene.globe;
  if (arcType !== ArcType_default.NONE && defined_default(globe)) {
    generateCartesianArcOptions.ellipsoid = globe.ellipsoid;
    generateCartesianArcOptions.positions = positions;
    generateCartesianArcOptions.granularity = Property_default.getValueOrUndefined(
      polyline._granularity,
      time
    );
    generateCartesianArcOptions.height = PolylinePipeline_default.extractHeights(
      positions,
      globe.ellipsoid
    );
    if (arcType === ArcType_default.GEODESIC) {
      positions = PolylinePipeline_default.generateCartesianArc(
        generateCartesianArcOptions
      );
    } else {
      positions = PolylinePipeline_default.generateCartesianRhumbArc(
        generateCartesianArcOptions
      );
    }
  }
  line.show = true;
  line.positions = positions.slice();
  line.material = MaterialProperty_default.getValue(
    time,
    geometryUpdater.fillMaterialProperty,
    line.material
  );
  line.width = Property_default.getValueOrDefault(polyline._width, time, 1);
  line.distanceDisplayCondition = Property_default.getValueOrUndefined(
    polyline._distanceDisplayCondition,
    time,
    line.distanceDisplayCondition
  );
};
DynamicGeometryUpdater2.prototype.getBoundingSphere = function(result) {
  Check_default.defined("result", result);
  if (!this._geometryUpdater.clampToGround) {
    const line = getLine(this);
    if (line.show && line.positions.length > 0) {
      BoundingSphere_default.fromPoints(line.positions, result);
      return BoundingSphereState_default.DONE;
    }
  } else {
    const groundPolylinePrimitive = this._groundPolylinePrimitive;
    if (defined_default(groundPolylinePrimitive) && groundPolylinePrimitive.show && groundPolylinePrimitive.ready) {
      const attributes = groundPolylinePrimitive.getGeometryInstanceAttributes(
        this._geometryUpdater._entity
      );
      if (defined_default(attributes) && defined_default(attributes.boundingSphere)) {
        BoundingSphere_default.clone(attributes.boundingSphere, result);
        return BoundingSphereState_default.DONE;
      }
    }
    if (defined_default(groundPolylinePrimitive) && !groundPolylinePrimitive.ready) {
      return BoundingSphereState_default.PENDING;
    }
    return BoundingSphereState_default.DONE;
  }
  return BoundingSphereState_default.FAILED;
};
DynamicGeometryUpdater2.prototype.isDestroyed = function() {
  return false;
};
DynamicGeometryUpdater2.prototype.destroy = function() {
  const geometryUpdater = this._geometryUpdater;
  const sceneId = geometryUpdater._scene.id;
  const polylineCollection = polylineCollections[sceneId];
  if (defined_default(polylineCollection)) {
    polylineCollection.remove(this._line);
    if (polylineCollection.length === 0) {
      this._primitives.removeAndDestroy(polylineCollection);
      delete polylineCollections[sceneId];
    }
  }
  if (defined_default(this._groundPolylinePrimitive)) {
    this._groundPrimitives.remove(this._groundPolylinePrimitive);
  }
  destroyObject_default(this);
};
var PolylineGeometryUpdater_default = PolylineGeometryUpdater;

// node_modules/cesium/Source/DataSources/StaticGroundPolylinePerMaterialBatch.js
var scratchColor23 = new Color_default();
var distanceDisplayConditionScratch9 = new DistanceDisplayCondition_default();
var defaultDistanceDisplayCondition8 = new DistanceDisplayCondition_default();
function Batch6(orderedGroundPrimitives, classificationType, materialProperty, zIndex, asynchronous) {
  let appearanceType;
  if (materialProperty instanceof ColorMaterialProperty_default) {
    appearanceType = PolylineColorAppearance_default;
  } else {
    appearanceType = PolylineMaterialAppearance_default;
  }
  this.orderedGroundPrimitives = orderedGroundPrimitives;
  this.classificationType = classificationType;
  this.appearanceType = appearanceType;
  this.materialProperty = materialProperty;
  this.updaters = new AssociativeArray_default();
  this.createPrimitive = true;
  this.primitive = void 0;
  this.oldPrimitive = void 0;
  this.geometry = new AssociativeArray_default();
  this.material = void 0;
  this.updatersWithAttributes = new AssociativeArray_default();
  this.attributes = new AssociativeArray_default();
  this.invalidated = false;
  this.removeMaterialSubscription = materialProperty.definitionChanged.addEventListener(
    Batch6.prototype.onMaterialChanged,
    this
  );
  this.subscriptions = new AssociativeArray_default();
  this.showsUpdated = new AssociativeArray_default();
  this.zIndex = zIndex;
  this._asynchronous = asynchronous;
}
Batch6.prototype.onMaterialChanged = function() {
  this.invalidated = true;
};
Batch6.prototype.isMaterial = function(updater) {
  const material = this.materialProperty;
  const updaterMaterial = updater.fillMaterialProperty;
  if (updaterMaterial === material || updaterMaterial instanceof ColorMaterialProperty_default && material instanceof ColorMaterialProperty_default) {
    return true;
  }
  return defined_default(material) && material.equals(updaterMaterial);
};
Batch6.prototype.add = function(time, updater, geometryInstance) {
  const id = updater.id;
  this.updaters.set(id, updater);
  this.geometry.set(id, geometryInstance);
  if (!updater.hasConstantFill || !updater.fillMaterialProperty.isConstant || !Property_default.isConstant(updater.distanceDisplayConditionProperty)) {
    this.updatersWithAttributes.set(id, updater);
  } else {
    const that = this;
    this.subscriptions.set(
      id,
      updater.entity.definitionChanged.addEventListener(function(entity, propertyName, newValue, oldValue2) {
        if (propertyName === "isShowing") {
          that.showsUpdated.set(updater.id, updater);
        }
      })
    );
  }
  this.createPrimitive = true;
};
Batch6.prototype.remove = function(updater) {
  const id = updater.id;
  this.createPrimitive = this.geometry.remove(id) || this.createPrimitive;
  if (this.updaters.remove(id)) {
    this.updatersWithAttributes.remove(id);
    const unsubscribe2 = this.subscriptions.get(id);
    if (defined_default(unsubscribe2)) {
      unsubscribe2();
      this.subscriptions.remove(id);
    }
    return true;
  }
  return false;
};
Batch6.prototype.update = function(time) {
  let isUpdated = true;
  let primitive = this.primitive;
  const orderedGroundPrimitives = this.orderedGroundPrimitives;
  const geometries = this.geometry.values;
  let i2;
  if (this.createPrimitive) {
    const geometriesLength = geometries.length;
    if (geometriesLength > 0) {
      if (defined_default(primitive)) {
        if (!defined_default(this.oldPrimitive)) {
          this.oldPrimitive = primitive;
        } else {
          orderedGroundPrimitives.remove(primitive);
        }
      }
      primitive = new GroundPolylinePrimitive_default({
        show: false,
        asynchronous: this._asynchronous,
        geometryInstances: geometries.slice(),
        appearance: new this.appearanceType(),
        classificationType: this.classificationType
      });
      if (this.appearanceType === PolylineMaterialAppearance_default) {
        this.material = MaterialProperty_default.getValue(
          time,
          this.materialProperty,
          this.material
        );
        primitive.appearance.material = this.material;
      }
      orderedGroundPrimitives.add(primitive, this.zIndex);
      isUpdated = false;
    } else {
      if (defined_default(primitive)) {
        orderedGroundPrimitives.remove(primitive);
        primitive = void 0;
      }
      const oldPrimitive = this.oldPrimitive;
      if (defined_default(oldPrimitive)) {
        orderedGroundPrimitives.remove(oldPrimitive);
        this.oldPrimitive = void 0;
      }
    }
    this.attributes.removeAll();
    this.primitive = primitive;
    this.createPrimitive = false;
  } else if (defined_default(primitive) && primitive.ready) {
    primitive.show = true;
    if (defined_default(this.oldPrimitive)) {
      orderedGroundPrimitives.remove(this.oldPrimitive);
      this.oldPrimitive = void 0;
    }
    if (this.appearanceType === PolylineMaterialAppearance_default) {
      this.material = MaterialProperty_default.getValue(
        time,
        this.materialProperty,
        this.material
      );
      this.primitive.appearance.material = this.material;
    }
    const updatersWithAttributes = this.updatersWithAttributes.values;
    const length3 = updatersWithAttributes.length;
    for (i2 = 0; i2 < length3; i2++) {
      const updater = updatersWithAttributes[i2];
      const entity = updater.entity;
      const instance = this.geometry.get(updater.id);
      let attributes = this.attributes.get(instance.id.id);
      if (!defined_default(attributes)) {
        attributes = primitive.getGeometryInstanceAttributes(instance.id);
        this.attributes.set(instance.id.id, attributes);
      }
      if (!updater.fillMaterialProperty.isConstant) {
        const colorProperty = updater.fillMaterialProperty.color;
        const resultColor = Property_default.getValueOrDefault(
          colorProperty,
          time,
          Color_default.WHITE,
          scratchColor23
        );
        if (!Color_default.equals(attributes._lastColor, resultColor)) {
          attributes._lastColor = Color_default.clone(
            resultColor,
            attributes._lastColor
          );
          attributes.color = ColorGeometryInstanceAttribute_default.toValue(
            resultColor,
            attributes.color
          );
        }
      }
      const show = entity.isShowing && (updater.hasConstantFill || updater.isFilled(time));
      const currentShow = attributes.show[0] === 1;
      if (show !== currentShow) {
        attributes.show = ShowGeometryInstanceAttribute_default.toValue(
          show,
          attributes.show
        );
      }
      const distanceDisplayConditionProperty = updater.distanceDisplayConditionProperty;
      if (!Property_default.isConstant(distanceDisplayConditionProperty)) {
        const distanceDisplayCondition = Property_default.getValueOrDefault(
          distanceDisplayConditionProperty,
          time,
          defaultDistanceDisplayCondition8,
          distanceDisplayConditionScratch9
        );
        if (!DistanceDisplayCondition_default.equals(
          distanceDisplayCondition,
          attributes._lastDistanceDisplayCondition
        )) {
          attributes._lastDistanceDisplayCondition = DistanceDisplayCondition_default.clone(
            distanceDisplayCondition,
            attributes._lastDistanceDisplayCondition
          );
          attributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute_default.toValue(
            distanceDisplayCondition,
            attributes.distanceDisplayCondition
          );
        }
      }
    }
    this.updateShows(primitive);
  } else if (defined_default(primitive) && !primitive.ready) {
    isUpdated = false;
  }
  return isUpdated;
};
Batch6.prototype.updateShows = function(primitive) {
  const showsUpdated = this.showsUpdated.values;
  const length3 = showsUpdated.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const updater = showsUpdated[i2];
    const entity = updater.entity;
    const instance = this.geometry.get(updater.id);
    let attributes = this.attributes.get(instance.id.id);
    if (!defined_default(attributes)) {
      attributes = primitive.getGeometryInstanceAttributes(instance.id);
      this.attributes.set(instance.id.id, attributes);
    }
    const show = entity.isShowing;
    const currentShow = attributes.show[0] === 1;
    if (show !== currentShow) {
      attributes.show = ShowGeometryInstanceAttribute_default.toValue(
        show,
        attributes.show
      );
      instance.attributes.show.value[0] = attributes.show[0];
    }
  }
  this.showsUpdated.removeAll();
};
Batch6.prototype.contains = function(updater) {
  return this.updaters.contains(updater.id);
};
Batch6.prototype.getBoundingSphere = function(updater, result) {
  const primitive = this.primitive;
  if (!primitive.ready) {
    return BoundingSphereState_default.PENDING;
  }
  const attributes = primitive.getGeometryInstanceAttributes(updater.entity);
  if (!defined_default(attributes) || !defined_default(attributes.boundingSphere) || defined_default(attributes.show) && attributes.show[0] === 0) {
    return BoundingSphereState_default.FAILED;
  }
  attributes.boundingSphere.clone(result);
  return BoundingSphereState_default.DONE;
};
Batch6.prototype.destroy = function() {
  const primitive = this.primitive;
  const orderedGroundPrimitives = this.orderedGroundPrimitives;
  if (defined_default(primitive)) {
    orderedGroundPrimitives.remove(primitive);
  }
  const oldPrimitive = this.oldPrimitive;
  if (defined_default(oldPrimitive)) {
    orderedGroundPrimitives.remove(oldPrimitive);
  }
  this.removeMaterialSubscription();
};
function StaticGroundPolylinePerMaterialBatch(orderedGroundPrimitives, classificationType, asynchronous) {
  this._items = [];
  this._orderedGroundPrimitives = orderedGroundPrimitives;
  this._classificationType = classificationType;
  this._asynchronous = defaultValue_default(asynchronous, true);
}
StaticGroundPolylinePerMaterialBatch.prototype.add = function(time, updater) {
  const items = this._items;
  const length3 = items.length;
  const geometryInstance = updater.createFillGeometryInstance(time);
  const zIndex = Property_default.getValueOrDefault(updater.zIndex, 0);
  for (let i2 = 0; i2 < length3; ++i2) {
    const item = items[i2];
    if (item.isMaterial(updater) && item.zIndex === zIndex) {
      item.add(time, updater, geometryInstance);
      return;
    }
  }
  const batch = new Batch6(
    this._orderedGroundPrimitives,
    this._classificationType,
    updater.fillMaterialProperty,
    zIndex,
    this._asynchronous
  );
  batch.add(time, updater, geometryInstance);
  items.push(batch);
};
StaticGroundPolylinePerMaterialBatch.prototype.remove = function(updater) {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = length3 - 1; i2 >= 0; i2--) {
    const item = items[i2];
    if (item.remove(updater)) {
      if (item.updaters.length === 0) {
        items.splice(i2, 1);
        item.destroy();
      }
      break;
    }
  }
};
StaticGroundPolylinePerMaterialBatch.prototype.update = function(time) {
  let i2;
  const items = this._items;
  const length3 = items.length;
  for (i2 = length3 - 1; i2 >= 0; i2--) {
    const item = items[i2];
    if (item.invalidated) {
      items.splice(i2, 1);
      const updaters = item.updaters.values;
      const updatersLength = updaters.length;
      for (let h = 0; h < updatersLength; h++) {
        this.add(time, updaters[h]);
      }
      item.destroy();
    }
  }
  let isUpdated = true;
  for (i2 = 0; i2 < items.length; i2++) {
    isUpdated = items[i2].update(time) && isUpdated;
  }
  return isUpdated;
};
StaticGroundPolylinePerMaterialBatch.prototype.getBoundingSphere = function(updater, result) {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const item = items[i2];
    if (item.contains(updater)) {
      return item.getBoundingSphere(updater, result);
    }
  }
  return BoundingSphereState_default.FAILED;
};
StaticGroundPolylinePerMaterialBatch.prototype.removeAllPrimitives = function() {
  const items = this._items;
  const length3 = items.length;
  for (let i2 = 0; i2 < length3; i2++) {
    items[i2].destroy();
  }
  this._items.length = 0;
};
var StaticGroundPolylinePerMaterialBatch_default = StaticGroundPolylinePerMaterialBatch;

// node_modules/cesium/Source/DataSources/PolylineVisualizer.js
var emptyArray2 = [];
function removeUpdater(that, updater) {
  const batches = that._batches;
  const length3 = batches.length;
  for (let i2 = 0; i2 < length3; i2++) {
    batches[i2].remove(updater);
  }
}
function insertUpdaterIntoBatch(that, time, updater) {
  if (updater.isDynamic) {
    that._dynamicBatch.add(time, updater);
    return;
  }
  if (updater.clampToGround && updater.fillEnabled) {
    const classificationType = updater.classificationTypeProperty.getValue(
      time
    );
    that._groundBatches[classificationType].add(time, updater);
    return;
  }
  let shadows;
  if (updater.fillEnabled) {
    shadows = updater.shadowsProperty.getValue(time);
  }
  let multiplier = 0;
  if (defined_default(updater.depthFailMaterialProperty)) {
    multiplier = updater.depthFailMaterialProperty instanceof ColorMaterialProperty_default ? 1 : 2;
  }
  let index2;
  if (defined_default(shadows)) {
    index2 = shadows + multiplier * ShadowMode_default.NUMBER_OF_SHADOW_MODES;
  }
  if (updater.fillEnabled) {
    if (updater.fillMaterialProperty instanceof ColorMaterialProperty_default) {
      that._colorBatches[index2].add(time, updater);
    } else {
      that._materialBatches[index2].add(time, updater);
    }
  }
}
function PolylineVisualizer(scene, entityCollection, primitives, groundPrimitives) {
  Check_default.defined("scene", scene);
  Check_default.defined("entityCollection", entityCollection);
  groundPrimitives = defaultValue_default(groundPrimitives, scene.groundPrimitives);
  primitives = defaultValue_default(primitives, scene.primitives);
  this._scene = scene;
  this._primitives = primitives;
  this._entityCollection = void 0;
  this._addedObjects = new AssociativeArray_default();
  this._removedObjects = new AssociativeArray_default();
  this._changedObjects = new AssociativeArray_default();
  let i2;
  const numberOfShadowModes = ShadowMode_default.NUMBER_OF_SHADOW_MODES;
  this._colorBatches = new Array(numberOfShadowModes * 3);
  this._materialBatches = new Array(numberOfShadowModes * 3);
  for (i2 = 0; i2 < numberOfShadowModes; ++i2) {
    this._colorBatches[i2] = new StaticGeometryColorBatch_default(
      primitives,
      PolylineColorAppearance_default,
      void 0,
      false,
      i2
    );
    this._materialBatches[i2] = new StaticGeometryPerMaterialBatch_default(
      primitives,
      PolylineMaterialAppearance_default,
      void 0,
      false,
      i2
    );
    this._colorBatches[i2 + numberOfShadowModes] = new StaticGeometryColorBatch_default(
      primitives,
      PolylineColorAppearance_default,
      PolylineColorAppearance_default,
      false,
      i2
    );
    this._materialBatches[i2 + numberOfShadowModes] = new StaticGeometryPerMaterialBatch_default(
      primitives,
      PolylineMaterialAppearance_default,
      PolylineColorAppearance_default,
      false,
      i2
    );
    this._colorBatches[i2 + numberOfShadowModes * 2] = new StaticGeometryColorBatch_default(
      primitives,
      PolylineColorAppearance_default,
      PolylineMaterialAppearance_default,
      false,
      i2
    );
    this._materialBatches[i2 + numberOfShadowModes * 2] = new StaticGeometryPerMaterialBatch_default(
      primitives,
      PolylineMaterialAppearance_default,
      PolylineMaterialAppearance_default,
      false,
      i2
    );
  }
  this._dynamicBatch = new DynamicGeometryBatch_default(primitives, groundPrimitives);
  const numberOfClassificationTypes = ClassificationType_default.NUMBER_OF_CLASSIFICATION_TYPES;
  this._groundBatches = new Array(numberOfClassificationTypes);
  for (i2 = 0; i2 < numberOfClassificationTypes; ++i2) {
    this._groundBatches[i2] = new StaticGroundPolylinePerMaterialBatch_default(
      groundPrimitives,
      i2
    );
  }
  this._batches = this._colorBatches.concat(
    this._materialBatches,
    this._dynamicBatch,
    this._groundBatches
  );
  this._subscriptions = new AssociativeArray_default();
  this._updaters = new AssociativeArray_default();
  this._entityCollection = entityCollection;
  entityCollection.collectionChanged.addEventListener(
    PolylineVisualizer.prototype._onCollectionChanged,
    this
  );
  this._onCollectionChanged(
    entityCollection,
    entityCollection.values,
    emptyArray2
  );
}
PolylineVisualizer.prototype.update = function(time) {
  Check_default.defined("time", time);
  const addedObjects = this._addedObjects;
  const added = addedObjects.values;
  const removedObjects = this._removedObjects;
  const removed = removedObjects.values;
  const changedObjects = this._changedObjects;
  const changed = changedObjects.values;
  let i2;
  let entity;
  let id;
  let updater;
  for (i2 = changed.length - 1; i2 > -1; i2--) {
    entity = changed[i2];
    id = entity.id;
    updater = this._updaters.get(id);
    if (updater.entity === entity) {
      removeUpdater(this, updater);
      insertUpdaterIntoBatch(this, time, updater);
    } else {
      removed.push(entity);
      added.push(entity);
    }
  }
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    id = entity.id;
    updater = this._updaters.get(id);
    removeUpdater(this, updater);
    updater.destroy();
    this._updaters.remove(id);
    this._subscriptions.get(id)();
    this._subscriptions.remove(id);
  }
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    id = entity.id;
    updater = new PolylineGeometryUpdater_default(entity, this._scene);
    this._updaters.set(id, updater);
    insertUpdaterIntoBatch(this, time, updater);
    this._subscriptions.set(
      id,
      updater.geometryChanged.addEventListener(
        PolylineVisualizer._onGeometryChanged,
        this
      )
    );
  }
  addedObjects.removeAll();
  removedObjects.removeAll();
  changedObjects.removeAll();
  let isUpdated = true;
  const batches = this._batches;
  const length3 = batches.length;
  for (i2 = 0; i2 < length3; i2++) {
    isUpdated = batches[i2].update(time) && isUpdated;
  }
  return isUpdated;
};
var getBoundingSphereArrayScratch2 = [];
var getBoundingSphereBoundingSphereScratch2 = new BoundingSphere_default();
PolylineVisualizer.prototype.getBoundingSphere = function(entity, result) {
  Check_default.defined("entity", entity);
  Check_default.defined("result", result);
  const boundingSpheres = getBoundingSphereArrayScratch2;
  const tmp2 = getBoundingSphereBoundingSphereScratch2;
  let count = 0;
  let state = BoundingSphereState_default.DONE;
  const batches = this._batches;
  const batchesLength = batches.length;
  const updater = this._updaters.get(entity.id);
  for (let i2 = 0; i2 < batchesLength; i2++) {
    state = batches[i2].getBoundingSphere(updater, tmp2);
    if (state === BoundingSphereState_default.PENDING) {
      return BoundingSphereState_default.PENDING;
    } else if (state === BoundingSphereState_default.DONE) {
      boundingSpheres[count] = BoundingSphere_default.clone(
        tmp2,
        boundingSpheres[count]
      );
      count++;
    }
  }
  if (count === 0) {
    return BoundingSphereState_default.FAILED;
  }
  boundingSpheres.length = count;
  BoundingSphere_default.fromBoundingSpheres(boundingSpheres, result);
  return BoundingSphereState_default.DONE;
};
PolylineVisualizer.prototype.isDestroyed = function() {
  return false;
};
PolylineVisualizer.prototype.destroy = function() {
  this._entityCollection.collectionChanged.removeEventListener(
    PolylineVisualizer.prototype._onCollectionChanged,
    this
  );
  this._addedObjects.removeAll();
  this._removedObjects.removeAll();
  let i2;
  const batches = this._batches;
  let length3 = batches.length;
  for (i2 = 0; i2 < length3; i2++) {
    batches[i2].removeAllPrimitives();
  }
  const subscriptions = this._subscriptions.values;
  length3 = subscriptions.length;
  for (i2 = 0; i2 < length3; i2++) {
    subscriptions[i2]();
  }
  this._subscriptions.removeAll();
  return destroyObject_default(this);
};
PolylineVisualizer._onGeometryChanged = function(updater) {
  const removedObjects = this._removedObjects;
  const changedObjects = this._changedObjects;
  const entity = updater.entity;
  const id = entity.id;
  if (!defined_default(removedObjects.get(id)) && !defined_default(changedObjects.get(id))) {
    changedObjects.set(id, entity);
  }
};
PolylineVisualizer.prototype._onCollectionChanged = function(entityCollection, added, removed) {
  const addedObjects = this._addedObjects;
  const removedObjects = this._removedObjects;
  const changedObjects = this._changedObjects;
  let i2;
  let id;
  let entity;
  for (i2 = removed.length - 1; i2 > -1; i2--) {
    entity = removed[i2];
    id = entity.id;
    if (!addedObjects.remove(id)) {
      removedObjects.set(id, entity);
      changedObjects.remove(id);
    }
  }
  for (i2 = added.length - 1; i2 > -1; i2--) {
    entity = added[i2];
    id = entity.id;
    if (removedObjects.remove(id)) {
      changedObjects.set(id, entity);
    } else {
      addedObjects.set(id, entity);
    }
  }
};
var PolylineVisualizer_default = PolylineVisualizer;

// node_modules/cesium/Source/DataSources/DataSourceDisplay.js
function DataSourceDisplay(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.object("options.scene", options.scene);
  Check_default.typeOf.object(
    "options.dataSourceCollection",
    options.dataSourceCollection
  );
  GroundPrimitive_default.initializeTerrainHeights();
  GroundPolylinePrimitive_default.initializeTerrainHeights();
  const scene = options.scene;
  const dataSourceCollection = options.dataSourceCollection;
  this._eventHelper = new EventHelper_default();
  this._eventHelper.add(
    dataSourceCollection.dataSourceAdded,
    this._onDataSourceAdded,
    this
  );
  this._eventHelper.add(
    dataSourceCollection.dataSourceRemoved,
    this._onDataSourceRemoved,
    this
  );
  this._eventHelper.add(
    dataSourceCollection.dataSourceMoved,
    this._onDataSourceMoved,
    this
  );
  this._eventHelper.add(scene.postRender, this._postRender, this);
  this._dataSourceCollection = dataSourceCollection;
  this._scene = scene;
  this._visualizersCallback = defaultValue_default(
    options.visualizersCallback,
    DataSourceDisplay.defaultVisualizersCallback
  );
  let primitivesAdded = false;
  const primitives = new PrimitiveCollection_default();
  const groundPrimitives = new PrimitiveCollection_default();
  if (dataSourceCollection.length > 0) {
    scene.primitives.add(primitives);
    scene.groundPrimitives.add(groundPrimitives);
    primitivesAdded = true;
  }
  this._primitives = primitives;
  this._groundPrimitives = groundPrimitives;
  for (let i2 = 0, len = dataSourceCollection.length; i2 < len; i2++) {
    this._onDataSourceAdded(dataSourceCollection, dataSourceCollection.get(i2));
  }
  const defaultDataSource = new CustomDataSource_default();
  this._onDataSourceAdded(void 0, defaultDataSource);
  this._defaultDataSource = defaultDataSource;
  let removeDefaultDataSourceListener;
  let removeDataSourceCollectionListener;
  if (!primitivesAdded) {
    const that = this;
    const addPrimitives = function() {
      scene.primitives.add(primitives);
      scene.groundPrimitives.add(groundPrimitives);
      removeDefaultDataSourceListener();
      removeDataSourceCollectionListener();
      that._removeDefaultDataSourceListener = void 0;
      that._removeDataSourceCollectionListener = void 0;
    };
    removeDefaultDataSourceListener = defaultDataSource.entities.collectionChanged.addEventListener(
      addPrimitives
    );
    removeDataSourceCollectionListener = dataSourceCollection.dataSourceAdded.addEventListener(
      addPrimitives
    );
  }
  this._removeDefaultDataSourceListener = removeDefaultDataSourceListener;
  this._removeDataSourceCollectionListener = removeDataSourceCollectionListener;
  this._ready = false;
}
DataSourceDisplay.defaultVisualizersCallback = function(scene, entityCluster, dataSource) {
  const entities = dataSource.entities;
  return [
    new BillboardVisualizer_default(entityCluster, entities),
    new GeometryVisualizer_default(
      scene,
      entities,
      dataSource._primitives,
      dataSource._groundPrimitives
    ),
    new LabelVisualizer_default(entityCluster, entities),
    new ModelVisualizer_default(scene, entities),
    new Cesium3DTilesetVisualizer_default(scene, entities),
    new PointVisualizer_default(entityCluster, entities),
    new PathVisualizer_default(scene, entities),
    new PolylineVisualizer_default(
      scene,
      entities,
      dataSource._primitives,
      dataSource._groundPrimitives
    )
  ];
};
Object.defineProperties(DataSourceDisplay.prototype, {
  scene: {
    get: function() {
      return this._scene;
    }
  },
  dataSources: {
    get: function() {
      return this._dataSourceCollection;
    }
  },
  defaultDataSource: {
    get: function() {
      return this._defaultDataSource;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  }
});
DataSourceDisplay.prototype.isDestroyed = function() {
  return false;
};
DataSourceDisplay.prototype.destroy = function() {
  this._eventHelper.removeAll();
  const dataSourceCollection = this._dataSourceCollection;
  for (let i2 = 0, length3 = dataSourceCollection.length; i2 < length3; ++i2) {
    this._onDataSourceRemoved(
      this._dataSourceCollection,
      dataSourceCollection.get(i2)
    );
  }
  this._onDataSourceRemoved(void 0, this._defaultDataSource);
  if (defined_default(this._removeDefaultDataSourceListener)) {
    this._removeDefaultDataSourceListener();
    this._removeDataSourceCollectionListener();
  } else {
    this._scene.primitives.remove(this._primitives);
    this._scene.groundPrimitives.remove(this._groundPrimitives);
  }
  return destroyObject_default(this);
};
DataSourceDisplay.prototype.update = function(time) {
  Check_default.defined("time", time);
  if (!ApproximateTerrainHeights_default.initialized) {
    this._ready = false;
    return false;
  }
  let result = true;
  let i2;
  let x;
  let visualizers;
  let vLength;
  const dataSources = this._dataSourceCollection;
  const length3 = dataSources.length;
  for (i2 = 0; i2 < length3; i2++) {
    const dataSource = dataSources.get(i2);
    if (defined_default(dataSource.update)) {
      result = dataSource.update(time) && result;
    }
    visualizers = dataSource._visualizers;
    vLength = visualizers.length;
    for (x = 0; x < vLength; x++) {
      result = visualizers[x].update(time) && result;
    }
  }
  visualizers = this._defaultDataSource._visualizers;
  vLength = visualizers.length;
  for (x = 0; x < vLength; x++) {
    result = visualizers[x].update(time) && result;
  }
  this._ready = result;
  return result;
};
DataSourceDisplay.prototype._postRender = function() {
  const frameState = this._scene.frameState;
  const dataSources = this._dataSourceCollection;
  const length3 = dataSources.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const dataSource = dataSources.get(i2);
    const credit = dataSource.credit;
    if (defined_default(credit)) {
      frameState.creditDisplay.addCredit(credit);
    }
    const credits = dataSource._resourceCredits;
    if (defined_default(credits)) {
      const creditCount = credits.length;
      for (let c14 = 0; c14 < creditCount; c14++) {
        frameState.creditDisplay.addCredit(credits[c14]);
      }
    }
  }
};
var getBoundingSphereArrayScratch3 = [];
var getBoundingSphereBoundingSphereScratch3 = new BoundingSphere_default();
DataSourceDisplay.prototype.getBoundingSphere = function(entity, allowPartial, result) {
  Check_default.defined("entity", entity);
  Check_default.typeOf.bool("allowPartial", allowPartial);
  Check_default.defined("result", result);
  if (!this._ready) {
    return BoundingSphereState_default.PENDING;
  }
  let i2;
  let length3;
  let dataSource = this._defaultDataSource;
  if (!dataSource.entities.contains(entity)) {
    dataSource = void 0;
    const dataSources = this._dataSourceCollection;
    length3 = dataSources.length;
    for (i2 = 0; i2 < length3; i2++) {
      const d = dataSources.get(i2);
      if (d.entities.contains(entity)) {
        dataSource = d;
        break;
      }
    }
  }
  if (!defined_default(dataSource)) {
    return BoundingSphereState_default.FAILED;
  }
  const boundingSpheres = getBoundingSphereArrayScratch3;
  const tmp2 = getBoundingSphereBoundingSphereScratch3;
  let count = 0;
  let state = BoundingSphereState_default.DONE;
  const visualizers = dataSource._visualizers;
  const visualizersLength = visualizers.length;
  for (i2 = 0; i2 < visualizersLength; i2++) {
    const visualizer = visualizers[i2];
    if (defined_default(visualizer.getBoundingSphere)) {
      state = visualizers[i2].getBoundingSphere(entity, tmp2);
      if (!allowPartial && state === BoundingSphereState_default.PENDING) {
        return BoundingSphereState_default.PENDING;
      } else if (state === BoundingSphereState_default.DONE) {
        boundingSpheres[count] = BoundingSphere_default.clone(
          tmp2,
          boundingSpheres[count]
        );
        count++;
      }
    }
  }
  if (count === 0) {
    return BoundingSphereState_default.FAILED;
  }
  boundingSpheres.length = count;
  BoundingSphere_default.fromBoundingSpheres(boundingSpheres, result);
  return BoundingSphereState_default.DONE;
};
DataSourceDisplay.prototype._onDataSourceAdded = function(dataSourceCollection, dataSource) {
  const scene = this._scene;
  const displayPrimitives = this._primitives;
  const displayGroundPrimitives = this._groundPrimitives;
  const primitives = displayPrimitives.add(new PrimitiveCollection_default());
  const groundPrimitives = displayGroundPrimitives.add(
    new OrderedGroundPrimitiveCollection_default()
  );
  dataSource._primitives = primitives;
  dataSource._groundPrimitives = groundPrimitives;
  const entityCluster = dataSource.clustering;
  entityCluster._initialize(scene);
  primitives.add(entityCluster);
  dataSource._visualizers = this._visualizersCallback(
    scene,
    entityCluster,
    dataSource
  );
};
DataSourceDisplay.prototype._onDataSourceRemoved = function(dataSourceCollection, dataSource) {
  const displayPrimitives = this._primitives;
  const displayGroundPrimitives = this._groundPrimitives;
  const primitives = dataSource._primitives;
  const groundPrimitives = dataSource._groundPrimitives;
  const entityCluster = dataSource.clustering;
  primitives.remove(entityCluster);
  const visualizers = dataSource._visualizers;
  const length3 = visualizers.length;
  for (let i2 = 0; i2 < length3; i2++) {
    visualizers[i2].destroy();
  }
  displayPrimitives.remove(primitives);
  displayGroundPrimitives.remove(groundPrimitives);
  dataSource._visualizers = void 0;
};
DataSourceDisplay.prototype._onDataSourceMoved = function(dataSource, newIndex, oldIndex) {
  const displayPrimitives = this._primitives;
  const displayGroundPrimitives = this._groundPrimitives;
  const primitives = dataSource._primitives;
  const groundPrimitives = dataSource._groundPrimitives;
  if (newIndex === oldIndex + 1) {
    displayPrimitives.raise(primitives);
    displayGroundPrimitives.raise(groundPrimitives);
  } else if (newIndex === oldIndex - 1) {
    displayPrimitives.lower(primitives);
    displayGroundPrimitives.lower(groundPrimitives);
  } else if (newIndex === 0) {
    displayPrimitives.lowerToBottom(primitives);
    displayGroundPrimitives.lowerToBottom(groundPrimitives);
    displayPrimitives.raise(primitives);
    displayGroundPrimitives.raise(groundPrimitives);
  } else {
    displayPrimitives.raiseToTop(primitives);
    displayGroundPrimitives.raiseToTop(groundPrimitives);
  }
};
var DataSourceDisplay_default = DataSourceDisplay;

// node_modules/cesium/Source/DataSources/EntityView.js
var updateTransformMatrix3Scratch1 = new Matrix3_default();
var updateTransformMatrix3Scratch2 = new Matrix3_default();
var updateTransformMatrix3Scratch3 = new Matrix3_default();
var updateTransformMatrix4Scratch = new Matrix4_default();
var updateTransformCartesian3Scratch1 = new Cartesian3_default();
var updateTransformCartesian3Scratch2 = new Cartesian3_default();
var updateTransformCartesian3Scratch3 = new Cartesian3_default();
var updateTransformCartesian3Scratch4 = new Cartesian3_default();
var updateTransformCartesian3Scratch5 = new Cartesian3_default();
var updateTransformCartesian3Scratch6 = new Cartesian3_default();
var deltaTime = new JulianDate_default();
var northUpAxisFactor = 1.25;
function updateTransform(that, camera, updateLookAt, saveCamera, positionProperty, time, ellipsoid) {
  const mode2 = that.scene.mode;
  let cartesian11 = positionProperty.getValue(time, that._lastCartesian);
  if (defined_default(cartesian11)) {
    let hasBasis = false;
    let invertVelocity = false;
    let xBasis;
    let yBasis;
    let zBasis;
    if (mode2 === SceneMode_default.SCENE3D) {
      JulianDate_default.addSeconds(time, 1e-3, deltaTime);
      let deltaCartesian = positionProperty.getValue(
        deltaTime,
        updateTransformCartesian3Scratch1
      );
      if (!defined_default(deltaCartesian)) {
        JulianDate_default.addSeconds(time, -1e-3, deltaTime);
        deltaCartesian = positionProperty.getValue(
          deltaTime,
          updateTransformCartesian3Scratch1
        );
        invertVelocity = true;
      }
      if (defined_default(deltaCartesian)) {
        let toInertial = Transforms_default.computeFixedToIcrfMatrix(
          time,
          updateTransformMatrix3Scratch1
        );
        let toInertialDelta = Transforms_default.computeFixedToIcrfMatrix(
          deltaTime,
          updateTransformMatrix3Scratch2
        );
        let toFixed;
        if (!defined_default(toInertial) || !defined_default(toInertialDelta)) {
          toFixed = Transforms_default.computeTemeToPseudoFixedMatrix(
            time,
            updateTransformMatrix3Scratch3
          );
          toInertial = Matrix3_default.transpose(
            toFixed,
            updateTransformMatrix3Scratch1
          );
          toInertialDelta = Transforms_default.computeTemeToPseudoFixedMatrix(
            deltaTime,
            updateTransformMatrix3Scratch2
          );
          Matrix3_default.transpose(toInertialDelta, toInertialDelta);
        } else {
          toFixed = Matrix3_default.transpose(
            toInertial,
            updateTransformMatrix3Scratch3
          );
        }
        const inertialCartesian = Matrix3_default.multiplyByVector(
          toInertial,
          cartesian11,
          updateTransformCartesian3Scratch5
        );
        const inertialDeltaCartesian = Matrix3_default.multiplyByVector(
          toInertialDelta,
          deltaCartesian,
          updateTransformCartesian3Scratch6
        );
        Cartesian3_default.subtract(
          inertialCartesian,
          inertialDeltaCartesian,
          updateTransformCartesian3Scratch4
        );
        const inertialVelocity = Cartesian3_default.magnitude(updateTransformCartesian3Scratch4) * 1e3;
        const mu = Math_default.GRAVITATIONALPARAMETER;
        const semiMajorAxis = -mu / (inertialVelocity * inertialVelocity - 2 * mu / Cartesian3_default.magnitude(inertialCartesian));
        if (semiMajorAxis < 0 || semiMajorAxis > northUpAxisFactor * ellipsoid.maximumRadius) {
          xBasis = updateTransformCartesian3Scratch2;
          Cartesian3_default.normalize(cartesian11, xBasis);
          Cartesian3_default.negate(xBasis, xBasis);
          zBasis = Cartesian3_default.clone(
            Cartesian3_default.UNIT_Z,
            updateTransformCartesian3Scratch3
          );
          yBasis = Cartesian3_default.cross(
            zBasis,
            xBasis,
            updateTransformCartesian3Scratch1
          );
          if (Cartesian3_default.magnitude(yBasis) > Math_default.EPSILON7) {
            Cartesian3_default.normalize(xBasis, xBasis);
            Cartesian3_default.normalize(yBasis, yBasis);
            zBasis = Cartesian3_default.cross(
              xBasis,
              yBasis,
              updateTransformCartesian3Scratch3
            );
            Cartesian3_default.normalize(zBasis, zBasis);
            hasBasis = true;
          }
        } else if (!Cartesian3_default.equalsEpsilon(
          cartesian11,
          deltaCartesian,
          Math_default.EPSILON7
        )) {
          zBasis = updateTransformCartesian3Scratch2;
          Cartesian3_default.normalize(inertialCartesian, zBasis);
          Cartesian3_default.normalize(inertialDeltaCartesian, inertialDeltaCartesian);
          yBasis = Cartesian3_default.cross(
            zBasis,
            inertialDeltaCartesian,
            updateTransformCartesian3Scratch3
          );
          if (invertVelocity) {
            yBasis = Cartesian3_default.multiplyByScalar(yBasis, -1, yBasis);
          }
          if (!Cartesian3_default.equalsEpsilon(
            yBasis,
            Cartesian3_default.ZERO,
            Math_default.EPSILON7
          )) {
            xBasis = Cartesian3_default.cross(
              yBasis,
              zBasis,
              updateTransformCartesian3Scratch1
            );
            Matrix3_default.multiplyByVector(toFixed, xBasis, xBasis);
            Matrix3_default.multiplyByVector(toFixed, yBasis, yBasis);
            Matrix3_default.multiplyByVector(toFixed, zBasis, zBasis);
            Cartesian3_default.normalize(xBasis, xBasis);
            Cartesian3_default.normalize(yBasis, yBasis);
            Cartesian3_default.normalize(zBasis, zBasis);
            hasBasis = true;
          }
        }
      }
    }
    if (defined_default(that.boundingSphere)) {
      cartesian11 = that.boundingSphere.center;
    }
    let position;
    let direction2;
    let up;
    if (saveCamera) {
      position = Cartesian3_default.clone(
        camera.position,
        updateTransformCartesian3Scratch4
      );
      direction2 = Cartesian3_default.clone(
        camera.direction,
        updateTransformCartesian3Scratch5
      );
      up = Cartesian3_default.clone(camera.up, updateTransformCartesian3Scratch6);
    }
    const transform4 = updateTransformMatrix4Scratch;
    if (hasBasis) {
      transform4[0] = xBasis.x;
      transform4[1] = xBasis.y;
      transform4[2] = xBasis.z;
      transform4[3] = 0;
      transform4[4] = yBasis.x;
      transform4[5] = yBasis.y;
      transform4[6] = yBasis.z;
      transform4[7] = 0;
      transform4[8] = zBasis.x;
      transform4[9] = zBasis.y;
      transform4[10] = zBasis.z;
      transform4[11] = 0;
      transform4[12] = cartesian11.x;
      transform4[13] = cartesian11.y;
      transform4[14] = cartesian11.z;
      transform4[15] = 0;
    } else {
      Transforms_default.eastNorthUpToFixedFrame(cartesian11, ellipsoid, transform4);
    }
    camera._setTransform(transform4);
    if (saveCamera) {
      Cartesian3_default.clone(position, camera.position);
      Cartesian3_default.clone(direction2, camera.direction);
      Cartesian3_default.clone(up, camera.up);
      Cartesian3_default.cross(direction2, up, camera.right);
    }
  }
  if (updateLookAt) {
    const offset2 = mode2 === SceneMode_default.SCENE2D || Cartesian3_default.equals(that._offset3D, Cartesian3_default.ZERO) ? void 0 : that._offset3D;
    camera.lookAtTransform(camera.transform, offset2);
  }
}
function EntityView(entity, scene, ellipsoid) {
  Check_default.defined("entity", entity);
  Check_default.defined("scene", scene);
  this.entity = entity;
  this.scene = scene;
  this.ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  this.boundingSphere = void 0;
  this._lastEntity = void 0;
  this._mode = void 0;
  this._lastCartesian = new Cartesian3_default();
  this._defaultOffset3D = void 0;
  this._offset3D = new Cartesian3_default();
}
Object.defineProperties(EntityView, {
  defaultOffset3D: {
    get: function() {
      return this._defaultOffset3D;
    },
    set: function(vector) {
      this._defaultOffset3D = Cartesian3_default.clone(vector, new Cartesian3_default());
    }
  }
});
EntityView.defaultOffset3D = new Cartesian3_default(-14e3, 3500, 3500);
var scratchHeadingPitchRange = new HeadingPitchRange_default();
var scratchCartesian21 = new Cartesian3_default();
EntityView.prototype.update = function(time, boundingSphere) {
  Check_default.defined("time", time);
  const scene = this.scene;
  const ellipsoid = this.ellipsoid;
  const sceneMode = scene.mode;
  if (sceneMode === SceneMode_default.MORPHING) {
    return;
  }
  const entity = this.entity;
  const positionProperty = entity.position;
  if (!defined_default(positionProperty)) {
    return;
  }
  const objectChanged = entity !== this._lastEntity;
  const sceneModeChanged = sceneMode !== this._mode;
  const camera = scene.camera;
  let updateLookAt = objectChanged || sceneModeChanged;
  let saveCamera = true;
  if (objectChanged) {
    const viewFromProperty = entity.viewFrom;
    const hasViewFrom = defined_default(viewFromProperty);
    if (!hasViewFrom && defined_default(boundingSphere)) {
      scratchHeadingPitchRange.pitch = -Math_default.PI_OVER_FOUR;
      scratchHeadingPitchRange.range = 0;
      const position = positionProperty.getValue(time, scratchCartesian21);
      if (defined_default(position)) {
        const factor2 = 2 - 1 / Math.max(
          1,
          Cartesian3_default.magnitude(position) / ellipsoid.maximumRadius
        );
        scratchHeadingPitchRange.pitch *= factor2;
      }
      camera.viewBoundingSphere(boundingSphere, scratchHeadingPitchRange);
      this.boundingSphere = boundingSphere;
      updateLookAt = false;
      saveCamera = false;
    } else if (!hasViewFrom || !defined_default(viewFromProperty.getValue(time, this._offset3D))) {
      Cartesian3_default.clone(EntityView._defaultOffset3D, this._offset3D);
    }
  } else if (!sceneModeChanged && this._mode !== SceneMode_default.SCENE2D) {
    Cartesian3_default.clone(camera.position, this._offset3D);
  }
  this._lastEntity = entity;
  this._mode = sceneMode;
  updateTransform(
    this,
    camera,
    updateLookAt,
    saveCamera,
    positionProperty,
    time,
    ellipsoid
  );
};
var EntityView_default = EntityView;

// node_modules/cesium/Source/ThirdParty/topojson.js
function identity(x) {
  return x;
}
function transform2(transform4) {
  if (transform4 == null)
    return identity;
  var x0, y0, kx = transform4.scale[0], ky = transform4.scale[1], dx = transform4.translate[0], dy = transform4.translate[1];
  return function(input, i2) {
    if (!i2)
      x0 = y0 = 0;
    var j = 2, n2 = input.length, output = new Array(n2);
    output[0] = (x0 += input[0]) * kx + dx;
    output[1] = (y0 += input[1]) * ky + dy;
    while (j < n2)
      output[j] = input[j], ++j;
    return output;
  };
}
function bbox(topology) {
  var t = transform2(topology.transform), key, x0 = Infinity, y0 = x0, x1 = -x0, y1 = -x0;
  function bboxPoint(p2) {
    p2 = t(p2);
    if (p2[0] < x0)
      x0 = p2[0];
    if (p2[0] > x1)
      x1 = p2[0];
    if (p2[1] < y0)
      y0 = p2[1];
    if (p2[1] > y1)
      y1 = p2[1];
  }
  function bboxGeometry(o2) {
    switch (o2.type) {
      case "GeometryCollection":
        o2.geometries.forEach(bboxGeometry);
        break;
      case "Point":
        bboxPoint(o2.coordinates);
        break;
      case "MultiPoint":
        o2.coordinates.forEach(bboxPoint);
        break;
    }
  }
  topology.arcs.forEach(function(arc) {
    var i2 = -1, n2 = arc.length, p2;
    while (++i2 < n2) {
      p2 = t(arc[i2], i2);
      if (p2[0] < x0)
        x0 = p2[0];
      if (p2[0] > x1)
        x1 = p2[0];
      if (p2[1] < y0)
        y0 = p2[1];
      if (p2[1] > y1)
        y1 = p2[1];
    }
  });
  for (key in topology.objects) {
    bboxGeometry(topology.objects[key]);
  }
  return [x0, y0, x1, y1];
}
function reverse(array, n2) {
  var t, j = array.length, i2 = j - n2;
  while (i2 < --j)
    t = array[i2], array[i2++] = array[j], array[j] = t;
}
function feature(topology, o2) {
  if (typeof o2 === "string")
    o2 = topology.objects[o2];
  return o2.type === "GeometryCollection" ? { type: "FeatureCollection", features: o2.geometries.map(function(o3) {
    return feature$1(topology, o3);
  }) } : feature$1(topology, o2);
}
function feature$1(topology, o2) {
  var id = o2.id, bbox2 = o2.bbox, properties = o2.properties == null ? {} : o2.properties, geometry = object(topology, o2);
  return id == null && bbox2 == null ? { type: "Feature", properties, geometry } : bbox2 == null ? { type: "Feature", id, properties, geometry } : { type: "Feature", id, bbox: bbox2, properties, geometry };
}
function object(topology, o2) {
  var transformPoint2 = transform2(topology.transform), arcs = topology.arcs;
  function arc(i2, points) {
    if (points.length)
      points.pop();
    for (var a4 = arcs[i2 < 0 ? ~i2 : i2], k = 0, n2 = a4.length; k < n2; ++k) {
      points.push(transformPoint2(a4[k], k));
    }
    if (i2 < 0)
      reverse(points, n2);
  }
  function point(p2) {
    return transformPoint2(p2);
  }
  function line(arcs2) {
    var points = [];
    for (var i2 = 0, n2 = arcs2.length; i2 < n2; ++i2)
      arc(arcs2[i2], points);
    if (points.length < 2)
      points.push(points[0]);
    return points;
  }
  function ring(arcs2) {
    var points = line(arcs2);
    while (points.length < 4)
      points.push(points[0]);
    return points;
  }
  function polygon(arcs2) {
    return arcs2.map(ring);
  }
  function geometry(o3) {
    var type = o3.type, coordinates;
    switch (type) {
      case "GeometryCollection":
        return { type, geometries: o3.geometries.map(geometry) };
      case "Point":
        coordinates = point(o3.coordinates);
        break;
      case "MultiPoint":
        coordinates = o3.coordinates.map(point);
        break;
      case "LineString":
        coordinates = line(o3.arcs);
        break;
      case "MultiLineString":
        coordinates = o3.arcs.map(line);
        break;
      case "Polygon":
        coordinates = polygon(o3.arcs);
        break;
      case "MultiPolygon":
        coordinates = o3.arcs.map(polygon);
        break;
      default:
        return null;
    }
    return { type, coordinates };
  }
  return geometry(o2);
}
function stitch(topology, arcs) {
  var stitchedArcs = {}, fragmentByStart = {}, fragmentByEnd = {}, fragments = [], emptyIndex = -1;
  arcs.forEach(function(i2, j) {
    var arc = topology.arcs[i2 < 0 ? ~i2 : i2], t;
    if (arc.length < 3 && !arc[1][0] && !arc[1][1]) {
      t = arcs[++emptyIndex], arcs[emptyIndex] = i2, arcs[j] = t;
    }
  });
  arcs.forEach(function(i2) {
    var e2 = ends(i2), start = e2[0], end = e2[1], f2, g;
    if (f2 = fragmentByEnd[start]) {
      delete fragmentByEnd[f2.end];
      f2.push(i2);
      f2.end = end;
      if (g = fragmentByStart[end]) {
        delete fragmentByStart[g.start];
        var fg = g === f2 ? f2 : f2.concat(g);
        fragmentByStart[fg.start = f2.start] = fragmentByEnd[fg.end = g.end] = fg;
      } else {
        fragmentByStart[f2.start] = fragmentByEnd[f2.end] = f2;
      }
    } else if (f2 = fragmentByStart[end]) {
      delete fragmentByStart[f2.start];
      f2.unshift(i2);
      f2.start = start;
      if (g = fragmentByEnd[start]) {
        delete fragmentByEnd[g.end];
        var gf = g === f2 ? f2 : g.concat(f2);
        fragmentByStart[gf.start = g.start] = fragmentByEnd[gf.end = f2.end] = gf;
      } else {
        fragmentByStart[f2.start] = fragmentByEnd[f2.end] = f2;
      }
    } else {
      f2 = [i2];
      fragmentByStart[f2.start = start] = fragmentByEnd[f2.end = end] = f2;
    }
  });
  function ends(i2) {
    var arc = topology.arcs[i2 < 0 ? ~i2 : i2], p0 = arc[0], p1;
    if (topology.transform)
      p1 = [0, 0], arc.forEach(function(dp) {
        p1[0] += dp[0], p1[1] += dp[1];
      });
    else
      p1 = arc[arc.length - 1];
    return i2 < 0 ? [p1, p0] : [p0, p1];
  }
  function flush(fragmentByEnd2, fragmentByStart2) {
    for (var k in fragmentByEnd2) {
      var f2 = fragmentByEnd2[k];
      delete fragmentByStart2[f2.start];
      delete f2.start;
      delete f2.end;
      f2.forEach(function(i2) {
        stitchedArcs[i2 < 0 ? ~i2 : i2] = 1;
      });
      fragments.push(f2);
    }
  }
  flush(fragmentByEnd, fragmentByStart);
  flush(fragmentByStart, fragmentByEnd);
  arcs.forEach(function(i2) {
    if (!stitchedArcs[i2 < 0 ? ~i2 : i2])
      fragments.push([i2]);
  });
  return fragments;
}
function mesh(topology) {
  return object(topology, meshArcs.apply(this, arguments));
}
function meshArcs(topology, object2, filter) {
  var arcs, i2, n2;
  if (arguments.length > 1)
    arcs = extractArcs(topology, object2, filter);
  else
    for (i2 = 0, arcs = new Array(n2 = topology.arcs.length); i2 < n2; ++i2)
      arcs[i2] = i2;
  return { type: "MultiLineString", arcs: stitch(topology, arcs) };
}
function extractArcs(topology, object2, filter) {
  var arcs = [], geomsByArc = [], geom;
  function extract0(i2) {
    var j = i2 < 0 ? ~i2 : i2;
    (geomsByArc[j] || (geomsByArc[j] = [])).push({ i: i2, g: geom });
  }
  function extract1(arcs2) {
    arcs2.forEach(extract0);
  }
  function extract2(arcs2) {
    arcs2.forEach(extract1);
  }
  function extract3(arcs2) {
    arcs2.forEach(extract2);
  }
  function geometry(o2) {
    switch (geom = o2, o2.type) {
      case "GeometryCollection":
        o2.geometries.forEach(geometry);
        break;
      case "LineString":
        extract1(o2.arcs);
        break;
      case "MultiLineString":
      case "Polygon":
        extract2(o2.arcs);
        break;
      case "MultiPolygon":
        extract3(o2.arcs);
        break;
    }
  }
  geometry(object2);
  geomsByArc.forEach(filter == null ? function(geoms) {
    arcs.push(geoms[0].i);
  } : function(geoms) {
    if (filter(geoms[0].g, geoms[geoms.length - 1].g))
      arcs.push(geoms[0].i);
  });
  return arcs;
}
function planarRingArea(ring) {
  var i2 = -1, n2 = ring.length, a4, b = ring[n2 - 1], area2 = 0;
  while (++i2 < n2)
    a4 = b, b = ring[i2], area2 += a4[0] * b[1] - a4[1] * b[0];
  return Math.abs(area2);
}
function merge2(topology) {
  return object(topology, mergeArcs.apply(this, arguments));
}
function mergeArcs(topology, objects) {
  var polygonsByArc = {}, polygons = [], groups = [];
  objects.forEach(geometry);
  function geometry(o2) {
    switch (o2.type) {
      case "GeometryCollection":
        o2.geometries.forEach(geometry);
        break;
      case "Polygon":
        extract(o2.arcs);
        break;
      case "MultiPolygon":
        o2.arcs.forEach(extract);
        break;
    }
  }
  function extract(polygon) {
    polygon.forEach(function(ring) {
      ring.forEach(function(arc) {
        (polygonsByArc[arc = arc < 0 ? ~arc : arc] || (polygonsByArc[arc] = [])).push(polygon);
      });
    });
    polygons.push(polygon);
  }
  function area2(ring) {
    return planarRingArea(object(topology, { type: "Polygon", arcs: [ring] }).coordinates[0]);
  }
  polygons.forEach(function(polygon) {
    if (!polygon._) {
      var group = [], neighbors2 = [polygon];
      polygon._ = 1;
      groups.push(group);
      while (polygon = neighbors2.pop()) {
        group.push(polygon);
        polygon.forEach(function(ring) {
          ring.forEach(function(arc) {
            polygonsByArc[arc < 0 ? ~arc : arc].forEach(function(polygon2) {
              if (!polygon2._) {
                polygon2._ = 1;
                neighbors2.push(polygon2);
              }
            });
          });
        });
      }
    }
  });
  polygons.forEach(function(polygon) {
    delete polygon._;
  });
  return {
    type: "MultiPolygon",
    arcs: groups.map(function(polygons2) {
      var arcs = [], n2;
      polygons2.forEach(function(polygon) {
        polygon.forEach(function(ring) {
          ring.forEach(function(arc) {
            if (polygonsByArc[arc < 0 ? ~arc : arc].length < 2) {
              arcs.push(arc);
            }
          });
        });
      });
      arcs = stitch(topology, arcs);
      if ((n2 = arcs.length) > 1) {
        for (var i2 = 1, k = area2(arcs[0]), ki, t; i2 < n2; ++i2) {
          if ((ki = area2(arcs[i2])) > k) {
            t = arcs[0], arcs[0] = arcs[i2], arcs[i2] = t, k = ki;
          }
        }
      }
      return arcs;
    }).filter(function(arcs) {
      return arcs.length > 0;
    })
  };
}
function bisect(a4, x) {
  var lo = 0, hi = a4.length;
  while (lo < hi) {
    var mid = lo + hi >>> 1;
    if (a4[mid] < x)
      lo = mid + 1;
    else
      hi = mid;
  }
  return lo;
}
function neighbors(objects) {
  var indexesByArc = {}, neighbors2 = objects.map(function() {
    return [];
  });
  function line(arcs, i3) {
    arcs.forEach(function(a4) {
      if (a4 < 0)
        a4 = ~a4;
      var o2 = indexesByArc[a4];
      if (o2)
        o2.push(i3);
      else
        indexesByArc[a4] = [i3];
    });
  }
  function polygon(arcs, i3) {
    arcs.forEach(function(arc) {
      line(arc, i3);
    });
  }
  function geometry(o2, i3) {
    if (o2.type === "GeometryCollection")
      o2.geometries.forEach(function(o3) {
        geometry(o3, i3);
      });
    else if (o2.type in geometryType)
      geometryType[o2.type](o2.arcs, i3);
  }
  var geometryType = {
    LineString: line,
    MultiLineString: polygon,
    Polygon: polygon,
    MultiPolygon: function(arcs, i3) {
      arcs.forEach(function(arc) {
        polygon(arc, i3);
      });
    }
  };
  objects.forEach(geometry);
  for (var i2 in indexesByArc) {
    for (var indexes = indexesByArc[i2], m = indexes.length, j = 0; j < m; ++j) {
      for (var k = j + 1; k < m; ++k) {
        var ij = indexes[j], ik = indexes[k], n2;
        if ((n2 = neighbors2[ij])[i2 = bisect(n2, ik)] !== ik)
          n2.splice(i2, 0, ik);
        if ((n2 = neighbors2[ik])[i2 = bisect(n2, ij)] !== ij)
          n2.splice(i2, 0, ij);
      }
    }
  }
  return neighbors2;
}
function untransform(transform4) {
  if (transform4 == null)
    return identity;
  var x0, y0, kx = transform4.scale[0], ky = transform4.scale[1], dx = transform4.translate[0], dy = transform4.translate[1];
  return function(input, i2) {
    if (!i2)
      x0 = y0 = 0;
    var j = 2, n2 = input.length, output = new Array(n2), x1 = Math.round((input[0] - dx) / kx), y1 = Math.round((input[1] - dy) / ky);
    output[0] = x1 - x0, x0 = x1;
    output[1] = y1 - y0, y0 = y1;
    while (j < n2)
      output[j] = input[j], ++j;
    return output;
  };
}
function quantize(topology, transform4) {
  if (topology.transform)
    throw new Error("already quantized");
  if (!transform4 || !transform4.scale) {
    if (!((n2 = Math.floor(transform4)) >= 2))
      throw new Error("n must be \u22652");
    box = topology.bbox || bbox(topology);
    var x0 = box[0], y0 = box[1], x1 = box[2], y1 = box[3], n2;
    transform4 = { scale: [x1 - x0 ? (x1 - x0) / (n2 - 1) : 1, y1 - y0 ? (y1 - y0) / (n2 - 1) : 1], translate: [x0, y0] };
  } else {
    box = topology.bbox;
  }
  var t = untransform(transform4), box, key, inputs = topology.objects, outputs = {};
  function quantizePoint(point) {
    return t(point);
  }
  function quantizeGeometry(input) {
    var output;
    switch (input.type) {
      case "GeometryCollection":
        output = { type: "GeometryCollection", geometries: input.geometries.map(quantizeGeometry) };
        break;
      case "Point":
        output = { type: "Point", coordinates: quantizePoint(input.coordinates) };
        break;
      case "MultiPoint":
        output = { type: "MultiPoint", coordinates: input.coordinates.map(quantizePoint) };
        break;
      default:
        return input;
    }
    if (input.id != null)
      output.id = input.id;
    if (input.bbox != null)
      output.bbox = input.bbox;
    if (input.properties != null)
      output.properties = input.properties;
    return output;
  }
  function quantizeArc(input) {
    var i2 = 0, j = 1, n3 = input.length, p2, output = new Array(n3);
    output[0] = t(input[0], 0);
    while (++i2 < n3)
      if ((p2 = t(input[i2], i2))[0] || p2[1])
        output[j++] = p2;
    if (j === 1)
      output[j++] = [0, 0];
    output.length = j;
    return output;
  }
  for (key in inputs)
    outputs[key] = quantizeGeometry(inputs[key]);
  return {
    type: "Topology",
    bbox: box,
    transform: transform4,
    objects: outputs,
    arcs: topology.arcs.map(quantizeArc)
  };
}
var index = Object.freeze({
  __proto__: null,
  bbox,
  feature,
  mesh,
  meshArcs,
  merge: merge2,
  mergeArcs,
  neighbors,
  quantize,
  transform: transform2,
  untransform
});

// node_modules/cesium/Source/DataSources/GeoJsonDataSource.js
function defaultCrsFunction(coordinates) {
  return Cartesian3_default.fromDegrees(coordinates[0], coordinates[1], coordinates[2]);
}
var crsNames = {
  "urn:ogc:def:crs:OGC:1.3:CRS84": defaultCrsFunction,
  "EPSG:4326": defaultCrsFunction,
  "urn:ogc:def:crs:EPSG::4326": defaultCrsFunction
};
var crsLinkHrefs = {};
var crsLinkTypes = {};
var defaultMarkerSize = 48;
var defaultMarkerSymbol;
var defaultMarkerColor = Color_default.ROYALBLUE;
var defaultStroke = Color_default.YELLOW;
var defaultStrokeWidth = 2;
var defaultFill2 = Color_default.fromBytes(255, 255, 0, 100);
var defaultClampToGround = false;
var sizes = {
  small: 24,
  medium: 48,
  large: 64
};
var simpleStyleIdentifiers = [
  "title",
  "description",
  "marker-size",
  "marker-symbol",
  "marker-color",
  "stroke",
  "stroke-opacity",
  "stroke-width",
  "fill",
  "fill-opacity"
];
function defaultDescribe(properties, nameProperty) {
  let html2 = "";
  for (const key in properties) {
    if (properties.hasOwnProperty(key)) {
      if (key === nameProperty || simpleStyleIdentifiers.indexOf(key) !== -1) {
        continue;
      }
      const value = properties[key];
      if (defined_default(value)) {
        if (typeof value === "object") {
          html2 += `<tr><th>${key}</th><td>${defaultDescribe(value)}</td></tr>`;
        } else {
          html2 += `<tr><th>${key}</th><td>${value}</td></tr>`;
        }
      }
    }
  }
  if (html2.length > 0) {
    html2 = `<table class="cesium-infoBox-defaultTable"><tbody>${html2}</tbody></table>`;
  }
  return html2;
}
function createDescriptionCallback(describe, properties, nameProperty) {
  let description;
  return function(time, result) {
    if (!defined_default(description)) {
      description = describe(properties, nameProperty);
    }
    return description;
  };
}
function defaultDescribeProperty(properties, nameProperty) {
  return new CallbackProperty_default(
    createDescriptionCallback(defaultDescribe, properties, nameProperty),
    true
  );
}
function createObject(geoJson, entityCollection, describe) {
  let id = geoJson.id;
  if (!defined_default(id) || geoJson.type !== "Feature") {
    id = createGuid_default();
  } else {
    let i2 = 2;
    let finalId = id;
    while (defined_default(entityCollection.getById(finalId))) {
      finalId = `${id}_${i2}`;
      i2++;
    }
    id = finalId;
  }
  const entity = entityCollection.getOrCreateEntity(id);
  const properties = geoJson.properties;
  if (defined_default(properties)) {
    entity.properties = properties;
    let nameProperty;
    const name = properties.title;
    if (defined_default(name)) {
      entity.name = name;
      nameProperty = "title";
    } else {
      let namePropertyPrecedence = Number.MAX_VALUE;
      for (const key in properties) {
        if (properties.hasOwnProperty(key) && properties[key]) {
          const lowerKey = key.toLowerCase();
          if (namePropertyPrecedence > 1 && lowerKey === "title") {
            namePropertyPrecedence = 1;
            nameProperty = key;
            break;
          } else if (namePropertyPrecedence > 2 && lowerKey === "name") {
            namePropertyPrecedence = 2;
            nameProperty = key;
          } else if (namePropertyPrecedence > 3 && /title/i.test(key)) {
            namePropertyPrecedence = 3;
            nameProperty = key;
          } else if (namePropertyPrecedence > 4 && /name/i.test(key)) {
            namePropertyPrecedence = 4;
            nameProperty = key;
          }
        }
      }
      if (defined_default(nameProperty)) {
        entity.name = properties[nameProperty];
      }
    }
    const description = properties.description;
    if (description !== null) {
      entity.description = !defined_default(description) ? describe(properties, nameProperty) : new ConstantProperty_default(description);
    }
  }
  return entity;
}
function coordinatesArrayToCartesianArray(coordinates, crsFunction) {
  const positions = new Array(coordinates.length);
  for (let i2 = 0; i2 < coordinates.length; i2++) {
    positions[i2] = crsFunction(coordinates[i2]);
  }
  return positions;
}
var geoJsonObjectTypes = {
  Feature: processFeature,
  FeatureCollection: processFeatureCollection,
  GeometryCollection: processGeometryCollection,
  LineString: processLineString,
  MultiLineString: processMultiLineString,
  MultiPoint: processMultiPoint,
  MultiPolygon: processMultiPolygon,
  Point: processPoint2,
  Polygon: processPolygon2,
  Topology: processTopology
};
var geometryTypes = {
  GeometryCollection: processGeometryCollection,
  LineString: processLineString,
  MultiLineString: processMultiLineString,
  MultiPoint: processMultiPoint,
  MultiPolygon: processMultiPolygon,
  Point: processPoint2,
  Polygon: processPolygon2,
  Topology: processTopology
};
function processFeature(dataSource, feature2, notUsed, crsFunction, options) {
  if (feature2.geometry === null) {
    createObject(feature2, dataSource._entityCollection, options.describe);
    return;
  }
  if (!defined_default(feature2.geometry)) {
    throw new RuntimeError_default("feature.geometry is required.");
  }
  const geometryType = feature2.geometry.type;
  const geometryHandler = geometryTypes[geometryType];
  if (!defined_default(geometryHandler)) {
    throw new RuntimeError_default(`Unknown geometry type: ${geometryType}`);
  }
  geometryHandler(dataSource, feature2, feature2.geometry, crsFunction, options);
}
function processFeatureCollection(dataSource, featureCollection, notUsed, crsFunction, options) {
  const features = featureCollection.features;
  for (let i2 = 0, len = features.length; i2 < len; i2++) {
    processFeature(dataSource, features[i2], void 0, crsFunction, options);
  }
}
function processGeometryCollection(dataSource, geoJson, geometryCollection, crsFunction, options) {
  const geometries = geometryCollection.geometries;
  for (let i2 = 0, len = geometries.length; i2 < len; i2++) {
    const geometry = geometries[i2];
    const geometryType = geometry.type;
    const geometryHandler = geometryTypes[geometryType];
    if (!defined_default(geometryHandler)) {
      throw new RuntimeError_default(`Unknown geometry type: ${geometryType}`);
    }
    geometryHandler(dataSource, geoJson, geometry, crsFunction, options);
  }
}
function createPoint(dataSource, geoJson, crsFunction, coordinates, options) {
  let symbol = options.markerSymbol;
  let color = options.markerColor;
  let size = options.markerSize;
  const properties = geoJson.properties;
  if (defined_default(properties)) {
    const cssColor = properties["marker-color"];
    if (defined_default(cssColor)) {
      color = Color_default.fromCssColorString(cssColor);
    }
    size = defaultValue_default(sizes[properties["marker-size"]], size);
    const markerSymbol = properties["marker-symbol"];
    if (defined_default(markerSymbol)) {
      symbol = markerSymbol;
    }
  }
  let canvasOrPromise;
  if (defined_default(symbol)) {
    if (symbol.length === 1) {
      canvasOrPromise = dataSource._pinBuilder.fromText(
        symbol.toUpperCase(),
        color,
        size
      );
    } else {
      canvasOrPromise = dataSource._pinBuilder.fromMakiIconId(
        symbol,
        color,
        size
      );
    }
  } else {
    canvasOrPromise = dataSource._pinBuilder.fromColor(color, size);
  }
  const billboard = new BillboardGraphics_default();
  billboard.verticalOrigin = new ConstantProperty_default(VerticalOrigin_default.BOTTOM);
  if (coordinates.length === 2 && options.clampToGround) {
    billboard.heightReference = HeightReference_default.CLAMP_TO_GROUND;
  }
  const entity = createObject(
    geoJson,
    dataSource._entityCollection,
    options.describe
  );
  entity.billboard = billboard;
  entity.position = new ConstantPositionProperty_default(crsFunction(coordinates));
  const promise = Promise.resolve(canvasOrPromise).then(function(image) {
    billboard.image = new ConstantProperty_default(image);
  }).catch(function() {
    billboard.image = new ConstantProperty_default(
      dataSource._pinBuilder.fromColor(color, size)
    );
  });
  dataSource._promises.push(promise);
}
function processPoint2(dataSource, geoJson, geometry, crsFunction, options) {
  createPoint(dataSource, geoJson, crsFunction, geometry.coordinates, options);
}
function processMultiPoint(dataSource, geoJson, geometry, crsFunction, options) {
  const coordinates = geometry.coordinates;
  for (let i2 = 0; i2 < coordinates.length; i2++) {
    createPoint(dataSource, geoJson, crsFunction, coordinates[i2], options);
  }
}
function createLineString(dataSource, geoJson, crsFunction, coordinates, options) {
  let material = options.strokeMaterialProperty;
  let widthProperty = options.strokeWidthProperty;
  const properties = geoJson.properties;
  if (defined_default(properties)) {
    const width = properties["stroke-width"];
    if (defined_default(width)) {
      widthProperty = new ConstantProperty_default(width);
    }
    let color;
    const stroke = properties.stroke;
    if (defined_default(stroke)) {
      color = Color_default.fromCssColorString(stroke);
    }
    const opacity = properties["stroke-opacity"];
    if (defined_default(opacity) && opacity !== 1) {
      if (!defined_default(color)) {
        color = material.color.getValue().clone();
      }
      color.alpha = opacity;
    }
    if (defined_default(color)) {
      material = new ColorMaterialProperty_default(color);
    }
  }
  const entity = createObject(
    geoJson,
    dataSource._entityCollection,
    options.describe
  );
  const polylineGraphics = new PolylineGraphics_default();
  entity.polyline = polylineGraphics;
  polylineGraphics.clampToGround = options.clampToGround;
  polylineGraphics.material = material;
  polylineGraphics.width = widthProperty;
  polylineGraphics.positions = new ConstantProperty_default(
    coordinatesArrayToCartesianArray(coordinates, crsFunction)
  );
  polylineGraphics.arcType = ArcType_default.RHUMB;
}
function processLineString(dataSource, geoJson, geometry, crsFunction, options) {
  createLineString(
    dataSource,
    geoJson,
    crsFunction,
    geometry.coordinates,
    options
  );
}
function processMultiLineString(dataSource, geoJson, geometry, crsFunction, options) {
  const lineStrings = geometry.coordinates;
  for (let i2 = 0; i2 < lineStrings.length; i2++) {
    createLineString(dataSource, geoJson, crsFunction, lineStrings[i2], options);
  }
}
function createPolygon(dataSource, geoJson, crsFunction, coordinates, options) {
  if (coordinates.length === 0 || coordinates[0].length === 0) {
    return;
  }
  let outlineColorProperty = options.strokeMaterialProperty.color;
  let material = options.fillMaterialProperty;
  let widthProperty = options.strokeWidthProperty;
  const properties = geoJson.properties;
  if (defined_default(properties)) {
    const width = properties["stroke-width"];
    if (defined_default(width)) {
      widthProperty = new ConstantProperty_default(width);
    }
    let color;
    const stroke = properties.stroke;
    if (defined_default(stroke)) {
      color = Color_default.fromCssColorString(stroke);
    }
    let opacity = properties["stroke-opacity"];
    if (defined_default(opacity) && opacity !== 1) {
      if (!defined_default(color)) {
        color = outlineColorProperty.getValue().clone();
      }
      color.alpha = opacity;
    }
    if (defined_default(color)) {
      outlineColorProperty = new ConstantProperty_default(color);
    }
    let fillColor;
    const fill = properties.fill;
    const materialColor = material.color.getValue();
    if (defined_default(fill)) {
      fillColor = Color_default.fromCssColorString(fill);
      fillColor.alpha = materialColor.alpha;
    }
    opacity = properties["fill-opacity"];
    if (defined_default(opacity) && opacity !== materialColor.alpha) {
      if (!defined_default(fillColor)) {
        fillColor = materialColor.clone();
      }
      fillColor.alpha = opacity;
    }
    if (defined_default(fillColor)) {
      material = new ColorMaterialProperty_default(fillColor);
    }
  }
  const polygon = new PolygonGraphics_default();
  polygon.outline = new ConstantProperty_default(true);
  polygon.outlineColor = outlineColorProperty;
  polygon.outlineWidth = widthProperty;
  polygon.material = material;
  polygon.arcType = ArcType_default.RHUMB;
  const holes = [];
  for (let i2 = 1, len = coordinates.length; i2 < len; i2++) {
    holes.push(
      new PolygonHierarchy_default(
        coordinatesArrayToCartesianArray(coordinates[i2], crsFunction)
      )
    );
  }
  const positions = coordinates[0];
  polygon.hierarchy = new ConstantProperty_default(
    new PolygonHierarchy_default(
      coordinatesArrayToCartesianArray(positions, crsFunction),
      holes
    )
  );
  if (positions[0].length > 2) {
    polygon.perPositionHeight = new ConstantProperty_default(true);
  } else if (!options.clampToGround) {
    polygon.height = 0;
  }
  const entity = createObject(
    geoJson,
    dataSource._entityCollection,
    options.describe
  );
  entity.polygon = polygon;
}
function processPolygon2(dataSource, geoJson, geometry, crsFunction, options) {
  createPolygon(
    dataSource,
    geoJson,
    crsFunction,
    geometry.coordinates,
    options
  );
}
function processMultiPolygon(dataSource, geoJson, geometry, crsFunction, options) {
  const polygons = geometry.coordinates;
  for (let i2 = 0; i2 < polygons.length; i2++) {
    createPolygon(dataSource, geoJson, crsFunction, polygons[i2], options);
  }
}
function processTopology(dataSource, geoJson, geometry, crsFunction, options) {
  for (const property in geometry.objects) {
    if (geometry.objects.hasOwnProperty(property)) {
      const feature2 = index.feature(geometry, geometry.objects[property]);
      const typeHandler = geoJsonObjectTypes[feature2.type];
      typeHandler(dataSource, feature2, feature2, crsFunction, options);
    }
  }
}
function GeoJsonDataSource(name) {
  this._name = name;
  this._changed = new Event_default();
  this._error = new Event_default();
  this._isLoading = false;
  this._loading = new Event_default();
  this._entityCollection = new EntityCollection_default(this);
  this._promises = [];
  this._pinBuilder = new PinBuilder_default();
  this._entityCluster = new EntityCluster_default();
  this._credit = void 0;
  this._resourceCredits = [];
}
GeoJsonDataSource.load = function(data, options) {
  return new GeoJsonDataSource().load(data, options);
};
Object.defineProperties(GeoJsonDataSource, {
  markerSize: {
    get: function() {
      return defaultMarkerSize;
    },
    set: function(value) {
      defaultMarkerSize = value;
    }
  },
  markerSymbol: {
    get: function() {
      return defaultMarkerSymbol;
    },
    set: function(value) {
      defaultMarkerSymbol = value;
    }
  },
  markerColor: {
    get: function() {
      return defaultMarkerColor;
    },
    set: function(value) {
      defaultMarkerColor = value;
    }
  },
  stroke: {
    get: function() {
      return defaultStroke;
    },
    set: function(value) {
      defaultStroke = value;
    }
  },
  strokeWidth: {
    get: function() {
      return defaultStrokeWidth;
    },
    set: function(value) {
      defaultStrokeWidth = value;
    }
  },
  fill: {
    get: function() {
      return defaultFill2;
    },
    set: function(value) {
      defaultFill2 = value;
    }
  },
  clampToGround: {
    get: function() {
      return defaultClampToGround;
    },
    set: function(value) {
      defaultClampToGround = value;
    }
  },
  crsNames: {
    get: function() {
      return crsNames;
    }
  },
  crsLinkHrefs: {
    get: function() {
      return crsLinkHrefs;
    }
  },
  crsLinkTypes: {
    get: function() {
      return crsLinkTypes;
    }
  }
});
Object.defineProperties(GeoJsonDataSource.prototype, {
  name: {
    get: function() {
      return this._name;
    },
    set: function(value) {
      if (this._name !== value) {
        this._name = value;
        this._changed.raiseEvent(this);
      }
    }
  },
  clock: {
    value: void 0,
    writable: false
  },
  entities: {
    get: function() {
      return this._entityCollection;
    }
  },
  isLoading: {
    get: function() {
      return this._isLoading;
    }
  },
  changedEvent: {
    get: function() {
      return this._changed;
    }
  },
  errorEvent: {
    get: function() {
      return this._error;
    }
  },
  loadingEvent: {
    get: function() {
      return this._loading;
    }
  },
  show: {
    get: function() {
      return this._entityCollection.show;
    },
    set: function(value) {
      this._entityCollection.show = value;
    }
  },
  clustering: {
    get: function() {
      return this._entityCluster;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value must be defined.");
      }
      this._entityCluster = value;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  }
});
GeoJsonDataSource.prototype.load = function(data, options) {
  return preload(this, data, options, true);
};
GeoJsonDataSource.prototype.process = function(data, options) {
  return preload(this, data, options, false);
};
function preload(that, data, options, clear2) {
  if (!defined_default(data)) {
    throw new DeveloperError_default("data is required.");
  }
  DataSource_default.setLoading(that, true);
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  that._credit = credit;
  let promise = data;
  let sourceUri = options.sourceUri;
  if (typeof data === "string" || data instanceof Resource_default) {
    data = Resource_default.createIfNeeded(data);
    promise = data.fetchJson();
    sourceUri = defaultValue_default(sourceUri, data.getUrlComponent());
    const resourceCredits = that._resourceCredits;
    const credits = data.credits;
    if (defined_default(credits)) {
      const length3 = credits.length;
      for (let i2 = 0; i2 < length3; i2++) {
        resourceCredits.push(credits[i2]);
      }
    }
  }
  options = {
    describe: defaultValue_default(options.describe, defaultDescribeProperty),
    markerSize: defaultValue_default(options.markerSize, defaultMarkerSize),
    markerSymbol: defaultValue_default(options.markerSymbol, defaultMarkerSymbol),
    markerColor: defaultValue_default(options.markerColor, defaultMarkerColor),
    strokeWidthProperty: new ConstantProperty_default(
      defaultValue_default(options.strokeWidth, defaultStrokeWidth)
    ),
    strokeMaterialProperty: new ColorMaterialProperty_default(
      defaultValue_default(options.stroke, defaultStroke)
    ),
    fillMaterialProperty: new ColorMaterialProperty_default(
      defaultValue_default(options.fill, defaultFill2)
    ),
    clampToGround: defaultValue_default(options.clampToGround, defaultClampToGround)
  };
  return Promise.resolve(promise).then(function(geoJson) {
    return load2(that, geoJson, options, sourceUri, clear2);
  }).catch(function(error) {
    DataSource_default.setLoading(that, false);
    that._error.raiseEvent(that, error);
    throw error;
  });
}
GeoJsonDataSource.prototype.update = function(time) {
  return true;
};
function load2(that, geoJson, options, sourceUri, clear2) {
  let name;
  if (defined_default(sourceUri)) {
    name = getFilenameFromUri_default(sourceUri);
  }
  if (defined_default(name) && that._name !== name) {
    that._name = name;
    that._changed.raiseEvent(that);
  }
  const typeHandler = geoJsonObjectTypes[geoJson.type];
  if (!defined_default(typeHandler)) {
    throw new RuntimeError_default(`Unsupported GeoJSON object type: ${geoJson.type}`);
  }
  const crs = geoJson.crs;
  let crsFunction = crs !== null ? defaultCrsFunction : null;
  if (defined_default(crs)) {
    if (!defined_default(crs.properties)) {
      throw new RuntimeError_default("crs.properties is undefined.");
    }
    const properties = crs.properties;
    if (crs.type === "name") {
      crsFunction = crsNames[properties.name];
      if (!defined_default(crsFunction)) {
        throw new RuntimeError_default(`Unknown crs name: ${properties.name}`);
      }
    } else if (crs.type === "link") {
      let handler = crsLinkHrefs[properties.href];
      if (!defined_default(handler)) {
        handler = crsLinkTypes[properties.type];
      }
      if (!defined_default(handler)) {
        throw new RuntimeError_default(
          `Unable to resolve crs link: ${JSON.stringify(properties)}`
        );
      }
      crsFunction = handler(properties);
    } else if (crs.type === "EPSG") {
      crsFunction = crsNames[`EPSG:${properties.code}`];
      if (!defined_default(crsFunction)) {
        throw new RuntimeError_default(`Unknown crs EPSG code: ${properties.code}`);
      }
    } else {
      throw new RuntimeError_default(`Unknown crs type: ${crs.type}`);
    }
  }
  return Promise.resolve(crsFunction).then(function(crsFunction2) {
    if (clear2) {
      that._entityCollection.removeAll();
    }
    if (crsFunction2 !== null) {
      typeHandler(that, geoJson, geoJson, crsFunction2, options);
    }
    return Promise.all(that._promises).then(function() {
      that._promises.length = 0;
      DataSource_default.setLoading(that, false);
      return that;
    });
  });
}
var GeoJsonDataSource_default = GeoJsonDataSource;

// node_modules/cesium/Source/ThirdParty/Autolinker.js
function defaults(dest, src2) {
  for (var prop in src2) {
    if (src2.hasOwnProperty(prop) && dest[prop] === void 0) {
      dest[prop] = src2[prop];
    }
  }
  return dest;
}
function ellipsis(str, truncateLen, ellipsisChars) {
  var ellipsisLength;
  if (str.length > truncateLen) {
    if (ellipsisChars == null) {
      ellipsisChars = "&hellip;";
      ellipsisLength = 3;
    } else {
      ellipsisLength = ellipsisChars.length;
    }
    str = str.substring(0, truncateLen - ellipsisLength) + ellipsisChars;
  }
  return str;
}
function indexOf2(arr, element) {
  if (Array.prototype.indexOf) {
    return arr.indexOf(element);
  } else {
    for (var i2 = 0, len = arr.length; i2 < len; i2++) {
      if (arr[i2] === element)
        return i2;
    }
    return -1;
  }
}
function remove2(arr, fn) {
  for (var i2 = arr.length - 1; i2 >= 0; i2--) {
    if (fn(arr[i2]) === true) {
      arr.splice(i2, 1);
    }
  }
}
function splitAndCapture(str, splitRegex) {
  if (!splitRegex.global)
    throw new Error("`splitRegex` must have the 'g' flag set");
  var result = [], lastIdx = 0, match;
  while (match = splitRegex.exec(str)) {
    result.push(str.substring(lastIdx, match.index));
    result.push(match[0]);
    lastIdx = match.index + match[0].length;
  }
  result.push(str.substring(lastIdx));
  return result;
}
function throwUnhandledCaseError(theValue) {
  throw new Error("Unhandled case for value: '".concat(theValue, "'"));
}
var HtmlTag = function() {
  function HtmlTag2(cfg) {
    if (cfg === void 0) {
      cfg = {};
    }
    this.tagName = "";
    this.attrs = {};
    this.innerHTML = "";
    this.whitespaceRegex = /\s+/;
    this.tagName = cfg.tagName || "";
    this.attrs = cfg.attrs || {};
    this.innerHTML = cfg.innerHtml || cfg.innerHTML || "";
  }
  HtmlTag2.prototype.setTagName = function(tagName) {
    this.tagName = tagName;
    return this;
  };
  HtmlTag2.prototype.getTagName = function() {
    return this.tagName || "";
  };
  HtmlTag2.prototype.setAttr = function(attrName, attrValue) {
    var tagAttrs = this.getAttrs();
    tagAttrs[attrName] = attrValue;
    return this;
  };
  HtmlTag2.prototype.getAttr = function(attrName) {
    return this.getAttrs()[attrName];
  };
  HtmlTag2.prototype.setAttrs = function(attrs) {
    Object.assign(this.getAttrs(), attrs);
    return this;
  };
  HtmlTag2.prototype.getAttrs = function() {
    return this.attrs || (this.attrs = {});
  };
  HtmlTag2.prototype.setClass = function(cssClass) {
    return this.setAttr("class", cssClass);
  };
  HtmlTag2.prototype.addClass = function(cssClass) {
    var classAttr = this.getClass(), whitespaceRegex = this.whitespaceRegex, classes = !classAttr ? [] : classAttr.split(whitespaceRegex), newClasses = cssClass.split(whitespaceRegex), newClass;
    while (newClass = newClasses.shift()) {
      if (indexOf2(classes, newClass) === -1) {
        classes.push(newClass);
      }
    }
    this.getAttrs()["class"] = classes.join(" ");
    return this;
  };
  HtmlTag2.prototype.removeClass = function(cssClass) {
    var classAttr = this.getClass(), whitespaceRegex = this.whitespaceRegex, classes = !classAttr ? [] : classAttr.split(whitespaceRegex), removeClasses = cssClass.split(whitespaceRegex), removeClass;
    while (classes.length && (removeClass = removeClasses.shift())) {
      var idx = indexOf2(classes, removeClass);
      if (idx !== -1) {
        classes.splice(idx, 1);
      }
    }
    this.getAttrs()["class"] = classes.join(" ");
    return this;
  };
  HtmlTag2.prototype.getClass = function() {
    return this.getAttrs()["class"] || "";
  };
  HtmlTag2.prototype.hasClass = function(cssClass) {
    return (" " + this.getClass() + " ").indexOf(" " + cssClass + " ") !== -1;
  };
  HtmlTag2.prototype.setInnerHTML = function(html2) {
    this.innerHTML = html2;
    return this;
  };
  HtmlTag2.prototype.setInnerHtml = function(html2) {
    return this.setInnerHTML(html2);
  };
  HtmlTag2.prototype.getInnerHTML = function() {
    return this.innerHTML || "";
  };
  HtmlTag2.prototype.getInnerHtml = function() {
    return this.getInnerHTML();
  };
  HtmlTag2.prototype.toAnchorString = function() {
    var tagName = this.getTagName(), attrsStr = this.buildAttrsStr();
    attrsStr = attrsStr ? " " + attrsStr : "";
    return ["<", tagName, attrsStr, ">", this.getInnerHtml(), "</", tagName, ">"].join("");
  };
  HtmlTag2.prototype.buildAttrsStr = function() {
    if (!this.attrs)
      return "";
    var attrs = this.getAttrs(), attrsArr = [];
    for (var prop in attrs) {
      if (attrs.hasOwnProperty(prop)) {
        attrsArr.push(prop + '="' + attrs[prop] + '"');
      }
    }
    return attrsArr.join(" ");
  };
  return HtmlTag2;
}();
function truncateSmart(url2, truncateLen, ellipsisChars) {
  var ellipsisLengthBeforeParsing;
  var ellipsisLength;
  if (ellipsisChars == null) {
    ellipsisChars = "&hellip;";
    ellipsisLength = 3;
    ellipsisLengthBeforeParsing = 8;
  } else {
    ellipsisLength = ellipsisChars.length;
    ellipsisLengthBeforeParsing = ellipsisChars.length;
  }
  var parse_url = function(url3) {
    var urlObj2 = {};
    var urlSub = url3;
    var match = urlSub.match(/^([a-z]+):\/\//i);
    if (match) {
      urlObj2.scheme = match[1];
      urlSub = urlSub.substr(match[0].length);
    }
    match = urlSub.match(/^(.*?)(?=(\?|#|\/|$))/i);
    if (match) {
      urlObj2.host = match[1];
      urlSub = urlSub.substr(match[0].length);
    }
    match = urlSub.match(/^\/(.*?)(?=(\?|#|$))/i);
    if (match) {
      urlObj2.path = match[1];
      urlSub = urlSub.substr(match[0].length);
    }
    match = urlSub.match(/^\?(.*?)(?=(#|$))/i);
    if (match) {
      urlObj2.query = match[1];
      urlSub = urlSub.substr(match[0].length);
    }
    match = urlSub.match(/^#(.*?)$/i);
    if (match) {
      urlObj2.fragment = match[1];
    }
    return urlObj2;
  };
  var buildUrl = function(urlObj2) {
    var url3 = "";
    if (urlObj2.scheme && urlObj2.host) {
      url3 += urlObj2.scheme + "://";
    }
    if (urlObj2.host) {
      url3 += urlObj2.host;
    }
    if (urlObj2.path) {
      url3 += "/" + urlObj2.path;
    }
    if (urlObj2.query) {
      url3 += "?" + urlObj2.query;
    }
    if (urlObj2.fragment) {
      url3 += "#" + urlObj2.fragment;
    }
    return url3;
  };
  var buildSegment = function(segment, remainingAvailableLength3) {
    var remainingAvailableLengthHalf = remainingAvailableLength3 / 2, startOffset = Math.ceil(remainingAvailableLengthHalf), endOffset = -1 * Math.floor(remainingAvailableLengthHalf), end2 = "";
    if (endOffset < 0) {
      end2 = segment.substr(endOffset);
    }
    return segment.substr(0, startOffset) + ellipsisChars + end2;
  };
  if (url2.length <= truncateLen) {
    return url2;
  }
  var availableLength = truncateLen - ellipsisLength;
  var urlObj = parse_url(url2);
  if (urlObj.query) {
    var matchQuery = urlObj.query.match(/^(.*?)(?=(\?|\#))(.*?)$/i);
    if (matchQuery) {
      urlObj.query = urlObj.query.substr(0, matchQuery[1].length);
      url2 = buildUrl(urlObj);
    }
  }
  if (url2.length <= truncateLen) {
    return url2;
  }
  if (urlObj.host) {
    urlObj.host = urlObj.host.replace(/^www\./, "");
    url2 = buildUrl(urlObj);
  }
  if (url2.length <= truncateLen) {
    return url2;
  }
  var str = "";
  if (urlObj.host) {
    str += urlObj.host;
  }
  if (str.length >= availableLength) {
    if (urlObj.host.length == truncateLen) {
      return (urlObj.host.substr(0, truncateLen - ellipsisLength) + ellipsisChars).substr(0, availableLength + ellipsisLengthBeforeParsing);
    }
    return buildSegment(str, availableLength).substr(0, availableLength + ellipsisLengthBeforeParsing);
  }
  var pathAndQuery = "";
  if (urlObj.path) {
    pathAndQuery += "/" + urlObj.path;
  }
  if (urlObj.query) {
    pathAndQuery += "?" + urlObj.query;
  }
  if (pathAndQuery) {
    if ((str + pathAndQuery).length >= availableLength) {
      if ((str + pathAndQuery).length == truncateLen) {
        return (str + pathAndQuery).substr(0, truncateLen);
      }
      var remainingAvailableLength = availableLength - str.length;
      return (str + buildSegment(pathAndQuery, remainingAvailableLength)).substr(0, availableLength + ellipsisLengthBeforeParsing);
    } else {
      str += pathAndQuery;
    }
  }
  if (urlObj.fragment) {
    var fragment = "#" + urlObj.fragment;
    if ((str + fragment).length >= availableLength) {
      if ((str + fragment).length == truncateLen) {
        return (str + fragment).substr(0, truncateLen);
      }
      var remainingAvailableLength2 = availableLength - str.length;
      return (str + buildSegment(fragment, remainingAvailableLength2)).substr(0, availableLength + ellipsisLengthBeforeParsing);
    } else {
      str += fragment;
    }
  }
  if (urlObj.scheme && urlObj.host) {
    var scheme = urlObj.scheme + "://";
    if ((str + scheme).length < availableLength) {
      return (scheme + str).substr(0, truncateLen);
    }
  }
  if (str.length <= truncateLen) {
    return str;
  }
  var end = "";
  if (availableLength > 0) {
    end = str.substr(-1 * Math.floor(availableLength / 2));
  }
  return (str.substr(0, Math.ceil(availableLength / 2)) + ellipsisChars + end).substr(0, availableLength + ellipsisLengthBeforeParsing);
}
function truncateMiddle(url2, truncateLen, ellipsisChars) {
  if (url2.length <= truncateLen) {
    return url2;
  }
  var ellipsisLengthBeforeParsing;
  var ellipsisLength;
  if (ellipsisChars == null) {
    ellipsisChars = "&hellip;";
    ellipsisLengthBeforeParsing = 8;
    ellipsisLength = 3;
  } else {
    ellipsisLengthBeforeParsing = ellipsisChars.length;
    ellipsisLength = ellipsisChars.length;
  }
  var availableLength = truncateLen - ellipsisLength;
  var end = "";
  if (availableLength > 0) {
    end = url2.substr(-1 * Math.floor(availableLength / 2));
  }
  return (url2.substr(0, Math.ceil(availableLength / 2)) + ellipsisChars + end).substr(0, availableLength + ellipsisLengthBeforeParsing);
}
function truncateEnd(anchorText, truncateLen, ellipsisChars) {
  return ellipsis(anchorText, truncateLen, ellipsisChars);
}
var AnchorTagBuilder = function() {
  function AnchorTagBuilder2(cfg) {
    if (cfg === void 0) {
      cfg = {};
    }
    this.newWindow = false;
    this.truncate = {};
    this.className = "";
    this.newWindow = cfg.newWindow || false;
    this.truncate = cfg.truncate || {};
    this.className = cfg.className || "";
  }
  AnchorTagBuilder2.prototype.build = function(match) {
    return new HtmlTag({
      tagName: "a",
      attrs: this.createAttrs(match),
      innerHtml: this.processAnchorText(match.getAnchorText())
    });
  };
  AnchorTagBuilder2.prototype.createAttrs = function(match) {
    var attrs = {
      "href": match.getAnchorHref()
    };
    var cssClass = this.createCssClass(match);
    if (cssClass) {
      attrs["class"] = cssClass;
    }
    if (this.newWindow) {
      attrs["target"] = "_blank";
      attrs["rel"] = "noopener noreferrer";
    }
    if (this.truncate) {
      if (this.truncate.length && this.truncate.length < match.getAnchorText().length) {
        attrs["title"] = match.getAnchorHref();
      }
    }
    return attrs;
  };
  AnchorTagBuilder2.prototype.createCssClass = function(match) {
    var className = this.className;
    if (!className) {
      return "";
    } else {
      var returnClasses = [className], cssClassSuffixes = match.getCssClassSuffixes();
      for (var i2 = 0, len = cssClassSuffixes.length; i2 < len; i2++) {
        returnClasses.push(className + "-" + cssClassSuffixes[i2]);
      }
      return returnClasses.join(" ");
    }
  };
  AnchorTagBuilder2.prototype.processAnchorText = function(anchorText) {
    anchorText = this.doTruncate(anchorText);
    return anchorText;
  };
  AnchorTagBuilder2.prototype.doTruncate = function(anchorText) {
    var truncate = this.truncate;
    if (!truncate || !truncate.length)
      return anchorText;
    var truncateLength = truncate.length, truncateLocation = truncate.location;
    if (truncateLocation === "smart") {
      return truncateSmart(anchorText, truncateLength);
    } else if (truncateLocation === "middle") {
      return truncateMiddle(anchorText, truncateLength);
    } else {
      return truncateEnd(anchorText, truncateLength);
    }
  };
  return AnchorTagBuilder2;
}();
var Match = function() {
  function Match2(cfg) {
    this.__jsduckDummyDocProp = null;
    this.matchedText = "";
    this.offset = 0;
    this.tagBuilder = cfg.tagBuilder;
    this.matchedText = cfg.matchedText;
    this.offset = cfg.offset;
  }
  Match2.prototype.getMatchedText = function() {
    return this.matchedText;
  };
  Match2.prototype.setOffset = function(offset2) {
    this.offset = offset2;
  };
  Match2.prototype.getOffset = function() {
    return this.offset;
  };
  Match2.prototype.getCssClassSuffixes = function() {
    return [this.getType()];
  };
  Match2.prototype.buildTag = function() {
    return this.tagBuilder.build(this);
  };
  return Match2;
}();
var extendStatics = function(d, b) {
  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
    d2.__proto__ = b2;
  } || function(d2, b2) {
    for (var p2 in b2)
      if (Object.prototype.hasOwnProperty.call(b2, p2))
        d2[p2] = b2[p2];
  };
  return extendStatics(d, b);
};
function __extends(d, b) {
  if (typeof b !== "function" && b !== null)
    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
  extendStatics(d, b);
  function __() {
    this.constructor = d;
  }
  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
  __assign = Object.assign || function __assign2(t) {
    for (var s2, i2 = 1, n2 = arguments.length; i2 < n2; i2++) {
      s2 = arguments[i2];
      for (var p2 in s2)
        if (Object.prototype.hasOwnProperty.call(s2, p2))
          t[p2] = s2[p2];
    }
    return t;
  };
  return __assign.apply(this, arguments);
};
var EmailMatch = function(_super) {
  __extends(EmailMatch2, _super);
  function EmailMatch2(cfg) {
    var _this = _super.call(this, cfg) || this;
    _this.email = "";
    _this.email = cfg.email;
    return _this;
  }
  EmailMatch2.prototype.getType = function() {
    return "email";
  };
  EmailMatch2.prototype.getEmail = function() {
    return this.email;
  };
  EmailMatch2.prototype.getAnchorHref = function() {
    return "mailto:" + this.email;
  };
  EmailMatch2.prototype.getAnchorText = function() {
    return this.email;
  };
  return EmailMatch2;
}(Match);
var HashtagMatch = function(_super) {
  __extends(HashtagMatch2, _super);
  function HashtagMatch2(cfg) {
    var _this = _super.call(this, cfg) || this;
    _this.serviceName = "";
    _this.hashtag = "";
    _this.serviceName = cfg.serviceName;
    _this.hashtag = cfg.hashtag;
    return _this;
  }
  HashtagMatch2.prototype.getType = function() {
    return "hashtag";
  };
  HashtagMatch2.prototype.getServiceName = function() {
    return this.serviceName;
  };
  HashtagMatch2.prototype.getHashtag = function() {
    return this.hashtag;
  };
  HashtagMatch2.prototype.getAnchorHref = function() {
    var serviceName = this.serviceName, hashtag = this.hashtag;
    switch (serviceName) {
      case "twitter":
        return "https://twitter.com/hashtag/" + hashtag;
      case "facebook":
        return "https://www.facebook.com/hashtag/" + hashtag;
      case "instagram":
        return "https://instagram.com/explore/tags/" + hashtag;
      case "tiktok":
        return "https://www.tiktok.com/tag/" + hashtag;
      default:
        throw new Error("Unknown service name to point hashtag to: " + serviceName);
    }
  };
  HashtagMatch2.prototype.getAnchorText = function() {
    return "#" + this.hashtag;
  };
  return HashtagMatch2;
}(Match);
var MentionMatch = function(_super) {
  __extends(MentionMatch2, _super);
  function MentionMatch2(cfg) {
    var _this = _super.call(this, cfg) || this;
    _this.serviceName = "twitter";
    _this.mention = "";
    _this.mention = cfg.mention;
    _this.serviceName = cfg.serviceName;
    return _this;
  }
  MentionMatch2.prototype.getType = function() {
    return "mention";
  };
  MentionMatch2.prototype.getMention = function() {
    return this.mention;
  };
  MentionMatch2.prototype.getServiceName = function() {
    return this.serviceName;
  };
  MentionMatch2.prototype.getAnchorHref = function() {
    switch (this.serviceName) {
      case "twitter":
        return "https://twitter.com/" + this.mention;
      case "instagram":
        return "https://instagram.com/" + this.mention;
      case "soundcloud":
        return "https://soundcloud.com/" + this.mention;
      case "tiktok":
        return "https://www.tiktok.com/@" + this.mention;
      default:
        throw new Error("Unknown service name to point mention to: " + this.serviceName);
    }
  };
  MentionMatch2.prototype.getAnchorText = function() {
    return "@" + this.mention;
  };
  MentionMatch2.prototype.getCssClassSuffixes = function() {
    var cssClassSuffixes = _super.prototype.getCssClassSuffixes.call(this), serviceName = this.getServiceName();
    if (serviceName) {
      cssClassSuffixes.push(serviceName);
    }
    return cssClassSuffixes;
  };
  return MentionMatch2;
}(Match);
var PhoneMatch = function(_super) {
  __extends(PhoneMatch2, _super);
  function PhoneMatch2(cfg) {
    var _this = _super.call(this, cfg) || this;
    _this.number = "";
    _this.plusSign = false;
    _this.number = cfg.number;
    _this.plusSign = cfg.plusSign;
    return _this;
  }
  PhoneMatch2.prototype.getType = function() {
    return "phone";
  };
  PhoneMatch2.prototype.getPhoneNumber = function() {
    return this.number;
  };
  PhoneMatch2.prototype.getNumber = function() {
    return this.getPhoneNumber();
  };
  PhoneMatch2.prototype.getAnchorHref = function() {
    return "tel:" + (this.plusSign ? "+" : "") + this.number;
  };
  PhoneMatch2.prototype.getAnchorText = function() {
    return this.matchedText;
  };
  return PhoneMatch2;
}(Match);
var UrlMatch = function(_super) {
  __extends(UrlMatch2, _super);
  function UrlMatch2(cfg) {
    var _this = _super.call(this, cfg) || this;
    _this.url = "";
    _this.urlMatchType = "scheme";
    _this.protocolUrlMatch = false;
    _this.protocolRelativeMatch = false;
    _this.stripPrefix = { scheme: true, www: true };
    _this.stripTrailingSlash = true;
    _this.decodePercentEncoding = true;
    _this.schemePrefixRegex = /^(https?:\/\/)?/i;
    _this.wwwPrefixRegex = /^(https?:\/\/)?(www\.)?/i;
    _this.protocolRelativeRegex = /^\/\//;
    _this.protocolPrepended = false;
    _this.urlMatchType = cfg.urlMatchType;
    _this.url = cfg.url;
    _this.protocolUrlMatch = cfg.protocolUrlMatch;
    _this.protocolRelativeMatch = cfg.protocolRelativeMatch;
    _this.stripPrefix = cfg.stripPrefix;
    _this.stripTrailingSlash = cfg.stripTrailingSlash;
    _this.decodePercentEncoding = cfg.decodePercentEncoding;
    return _this;
  }
  UrlMatch2.prototype.getType = function() {
    return "url";
  };
  UrlMatch2.prototype.getUrlMatchType = function() {
    return this.urlMatchType;
  };
  UrlMatch2.prototype.getUrl = function() {
    var url2 = this.url;
    if (!this.protocolRelativeMatch && !this.protocolUrlMatch && !this.protocolPrepended) {
      url2 = this.url = "http://" + url2;
      this.protocolPrepended = true;
    }
    return url2;
  };
  UrlMatch2.prototype.getAnchorHref = function() {
    var url2 = this.getUrl();
    return url2.replace(/&amp;/g, "&");
  };
  UrlMatch2.prototype.getAnchorText = function() {
    var anchorText = this.getMatchedText();
    if (this.protocolRelativeMatch) {
      anchorText = this.stripProtocolRelativePrefix(anchorText);
    }
    if (this.stripPrefix.scheme) {
      anchorText = this.stripSchemePrefix(anchorText);
    }
    if (this.stripPrefix.www) {
      anchorText = this.stripWwwPrefix(anchorText);
    }
    if (this.stripTrailingSlash) {
      anchorText = this.removeTrailingSlash(anchorText);
    }
    if (this.decodePercentEncoding) {
      anchorText = this.removePercentEncoding(anchorText);
    }
    return anchorText;
  };
  UrlMatch2.prototype.stripSchemePrefix = function(url2) {
    return url2.replace(this.schemePrefixRegex, "");
  };
  UrlMatch2.prototype.stripWwwPrefix = function(url2) {
    return url2.replace(this.wwwPrefixRegex, "$1");
  };
  UrlMatch2.prototype.stripProtocolRelativePrefix = function(text2) {
    return text2.replace(this.protocolRelativeRegex, "");
  };
  UrlMatch2.prototype.removeTrailingSlash = function(anchorText) {
    if (anchorText.charAt(anchorText.length - 1) === "/") {
      anchorText = anchorText.slice(0, -1);
    }
    return anchorText;
  };
  UrlMatch2.prototype.removePercentEncoding = function(anchorText) {
    var preProcessedEntityAnchorText = anchorText.replace(/%22/gi, "&quot;").replace(/%26/gi, "&amp;").replace(/%27/gi, "&#39;").replace(/%3C/gi, "&lt;").replace(/%3E/gi, "&gt;");
    try {
      return decodeURIComponent(preProcessedEntityAnchorText);
    } catch (e2) {
      return preProcessedEntityAnchorText;
    }
  };
  return UrlMatch2;
}(Match);
var Matcher = function() {
  function Matcher2(cfg) {
    this.__jsduckDummyDocProp = null;
    this.tagBuilder = cfg.tagBuilder;
  }
  return Matcher2;
}();
var letterRe = /[A-Za-z]/;
var digitRe = /[\d]/;
var nonDigitRe = /[\D]/;
var whitespaceRe = /\s/;
var quoteRe = /['"]/;
var controlCharsRe = /[\x00-\x1F\x7F]/;
var alphaCharsStr = /A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC/.source;
var emojiStr = /\u2700-\u27bf\udde6-\uddff\ud800-\udbff\udc00-\udfff\ufe0e\ufe0f\u0300-\u036f\ufe20-\ufe23\u20d0-\u20f0\ud83c\udffb-\udfff\u200d\u3299\u3297\u303d\u3030\u24c2\ud83c\udd70-\udd71\udd7e-\udd7f\udd8e\udd91-\udd9a\udde6-\uddff\ude01-\ude02\ude1a\ude2f\ude32-\ude3a\ude50-\ude51\u203c\u2049\u25aa-\u25ab\u25b6\u25c0\u25fb-\u25fe\u00a9\u00ae\u2122\u2139\udc04\u2600-\u26FF\u2b05\u2b06\u2b07\u2b1b\u2b1c\u2b50\u2b55\u231a\u231b\u2328\u23cf\u23e9-\u23f3\u23f8-\u23fa\udccf\u2935\u2934\u2190-\u21ff/.source;
var marksStr = /\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D4-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F/.source;
var alphaCharsAndMarksStr = alphaCharsStr + emojiStr + marksStr;
var decimalNumbersStr = /0-9\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19/.source;
var alphaNumericCharsStr = alphaCharsAndMarksStr + decimalNumbersStr;
var alphaNumericAndMarksCharsStr = alphaCharsAndMarksStr + decimalNumbersStr;
var ipStr = "(?:[" + decimalNumbersStr + "]{1,3}\\.){3}[" + decimalNumbersStr + "]{1,3}";
var domainLabelStr = "[" + alphaNumericAndMarksCharsStr + "](?:[" + alphaNumericAndMarksCharsStr + "\\-]{0,61}[" + alphaNumericAndMarksCharsStr + "])?";
var getDomainLabelStr = function(group) {
  return "(?=(" + domainLabelStr + "))\\" + group;
};
var getDomainNameStr = function(group) {
  return "(?:" + getDomainLabelStr(group) + "(?:\\." + getDomainLabelStr(group + 1) + "){0,126}|" + ipStr + ")";
};
var domainNameCharRegex = new RegExp("[".concat(alphaNumericAndMarksCharsStr, "]"));
var tldRegex = /(?:xn--vermgensberatung-pwb|xn--vermgensberater-ctb|xn--clchc0ea0b2g2a9gcd|xn--w4r85el8fhu5dnra|northwesternmutual|travelersinsurance|vermögensberatung|xn--3oq18vl8pn36a|xn--5su34j936bgsg|xn--bck1b9a5dre4c|xn--mgbah1a3hjkrd|xn--mgbai9azgqp6j|xn--mgberp4a5d4ar|xn--xkc2dl3a5ee0h|vermögensberater|xn--fzys8d69uvgm|xn--mgba7c0bbn0a|xn--mgbcpq6gpa1a|xn--xkc2al3hye2a|americanexpress|kerryproperties|sandvikcoromant|xn--i1b6b1a6a2e|xn--kcrx77d1x4a|xn--lgbbat1ad8j|xn--mgba3a4f16a|xn--mgbaakc7dvf|xn--mgbc0a9azcg|xn--nqv7fs00ema|afamilycompany|americanfamily|bananarepublic|cancerresearch|cookingchannel|kerrylogistics|weatherchannel|xn--54b7fta0cc|xn--6qq986b3xl|xn--80aqecdr1a|xn--b4w605ferd|xn--fiq228c5hs|xn--h2breg3eve|xn--jlq480n2rg|xn--jlq61u9w7b|xn--mgba3a3ejt|xn--mgbaam7a8h|xn--mgbayh7gpa|xn--mgbbh1a71e|xn--mgbca7dzdo|xn--mgbi4ecexp|xn--mgbx4cd0ab|xn--rvc1e0am3e|international|lifeinsurance|travelchannel|wolterskluwer|xn--cckwcxetd|xn--eckvdtc9d|xn--fpcrj9c3d|xn--fzc2c9e2c|xn--h2brj9c8c|xn--tiq49xqyj|xn--yfro4i67o|xn--ygbi2ammx|construction|lplfinancial|scholarships|versicherung|xn--3e0b707e|xn--45br5cyl|xn--4dbrk0ce|xn--80adxhks|xn--80asehdb|xn--8y0a063a|xn--gckr3f0f|xn--mgb9awbf|xn--mgbab2bd|xn--mgbgu82a|xn--mgbpl2fh|xn--mgbt3dhd|xn--mk1bu44c|xn--ngbc5azd|xn--ngbe9e0a|xn--ogbpf8fl|xn--qcka1pmc|accountants|barclaycard|blackfriday|blockbuster|bridgestone|calvinklein|contractors|creditunion|engineering|enterprises|foodnetwork|investments|kerryhotels|lamborghini|motorcycles|olayangroup|photography|playstation|productions|progressive|redumbrella|williamhill|xn--11b4c3d|xn--1ck2e1b|xn--1qqw23a|xn--2scrj9c|xn--3bst00m|xn--3ds443g|xn--3hcrj9c|xn--42c2d9a|xn--45brj9c|xn--55qw42g|xn--6frz82g|xn--80ao21a|xn--9krt00a|xn--cck2b3b|xn--czr694b|xn--d1acj3b|xn--efvy88h|xn--fct429k|xn--fjq720a|xn--flw351e|xn--g2xx48c|xn--gecrj9c|xn--gk3at1e|xn--h2brj9c|xn--hxt814e|xn--imr513n|xn--j6w193g|xn--jvr189m|xn--kprw13d|xn--kpry57d|xn--mgbbh1a|xn--mgbtx2b|xn--mix891f|xn--nyqy26a|xn--otu796d|xn--pgbs0dh|xn--q9jyb4c|xn--rhqv96g|xn--rovu88b|xn--s9brj9c|xn--ses554g|xn--t60b56a|xn--vuq861b|xn--w4rs40l|xn--xhq521b|xn--zfr164b|சிங்கப்பூர்|accountant|apartments|associates|basketball|bnpparibas|boehringer|capitalone|consulting|creditcard|cuisinella|eurovision|extraspace|foundation|healthcare|immobilien|industries|management|mitsubishi|nextdirect|properties|protection|prudential|realestate|republican|restaurant|schaeffler|swiftcover|tatamotors|technology|university|vlaanderen|volkswagen|xn--30rr7y|xn--3pxu8k|xn--45q11c|xn--4gbrim|xn--55qx5d|xn--5tzm5g|xn--80aswg|xn--90a3ac|xn--9dbq2a|xn--9et52u|xn--c2br7g|xn--cg4bki|xn--czrs0t|xn--czru2d|xn--fiq64b|xn--fiqs8s|xn--fiqz9s|xn--io0a7i|xn--kput3i|xn--mxtq1m|xn--o3cw4h|xn--pssy2u|xn--q7ce6a|xn--unup4y|xn--wgbh1c|xn--wgbl6a|xn--y9a3aq|accenture|alfaromeo|allfinanz|amsterdam|analytics|aquarelle|barcelona|bloomberg|christmas|community|directory|education|equipment|fairwinds|financial|firestone|fresenius|frontdoor|furniture|goldpoint|hisamitsu|homedepot|homegoods|homesense|institute|insurance|kuokgroup|lancaster|landrover|lifestyle|marketing|marshalls|melbourne|microsoft|panasonic|passagens|pramerica|richardli|scjohnson|shangrila|solutions|statebank|statefarm|stockholm|travelers|vacations|xn--90ais|xn--c1avg|xn--d1alf|xn--e1a4c|xn--fhbei|xn--j1aef|xn--j1amh|xn--l1acc|xn--ngbrx|xn--nqv7f|xn--p1acf|xn--qxa6a|xn--tckwe|xn--vhquv|yodobashi|موريتانيا|abudhabi|airforce|allstate|attorney|barclays|barefoot|bargains|baseball|boutique|bradesco|broadway|brussels|budapest|builders|business|capetown|catering|catholic|cipriani|cityeats|cleaning|clinique|clothing|commbank|computer|delivery|deloitte|democrat|diamonds|discount|discover|download|engineer|ericsson|etisalat|exchange|feedback|fidelity|firmdale|football|frontier|goodyear|grainger|graphics|guardian|hdfcbank|helsinki|holdings|hospital|infiniti|ipiranga|istanbul|jpmorgan|lighting|lundbeck|marriott|maserati|mckinsey|memorial|merckmsd|mortgage|observer|partners|pharmacy|pictures|plumbing|property|redstone|reliance|saarland|samsclub|security|services|shopping|showtime|softbank|software|stcgroup|supplies|training|vanguard|ventures|verisign|woodside|xn--90ae|xn--node|xn--p1ai|xn--qxam|yokohama|السعودية|abogado|academy|agakhan|alibaba|android|athleta|auction|audible|auspost|avianca|banamex|bauhaus|bentley|bestbuy|booking|brother|bugatti|capital|caravan|careers|channel|charity|chintai|citadel|clubmed|college|cologne|comcast|company|compare|contact|cooking|corsica|country|coupons|courses|cricket|cruises|dentist|digital|domains|exposed|express|farmers|fashion|ferrari|ferrero|finance|fishing|fitness|flights|florist|flowers|forsale|frogans|fujitsu|gallery|genting|godaddy|grocery|guitars|hamburg|hangout|hitachi|holiday|hosting|hoteles|hotmail|hyundai|ismaili|jewelry|juniper|kitchen|komatsu|lacaixa|lanxess|lasalle|latrobe|leclerc|limited|lincoln|markets|monster|netbank|netflix|network|neustar|okinawa|oldnavy|organic|origins|philips|pioneer|politie|realtor|recipes|rentals|reviews|rexroth|samsung|sandvik|schmidt|schwarz|science|shiksha|singles|staples|storage|support|surgery|systems|temasek|theater|theatre|tickets|tiffany|toshiba|trading|walmart|wanggou|watches|weather|website|wedding|whoswho|windows|winners|xfinity|yamaxun|youtube|zuerich|католик|اتصالات|البحرين|الجزائر|العليان|پاکستان|كاثوليك|இந்தியா|abarth|abbott|abbvie|africa|agency|airbus|airtel|alipay|alsace|alstom|amazon|anquan|aramco|author|bayern|beauty|berlin|bharti|bostik|boston|broker|camera|career|casino|center|chanel|chrome|church|circle|claims|clinic|coffee|comsec|condos|coupon|credit|cruise|dating|datsun|dealer|degree|dental|design|direct|doctor|dunlop|dupont|durban|emerck|energy|estate|events|expert|family|flickr|futbol|gallup|garden|george|giving|global|google|gratis|health|hermes|hiphop|hockey|hotels|hughes|imamat|insure|intuit|jaguar|joburg|juegos|kaufen|kinder|kindle|kosher|lancia|latino|lawyer|lefrak|living|locker|london|luxury|madrid|maison|makeup|market|mattel|mobile|monash|mormon|moscow|museum|mutual|nagoya|natura|nissan|nissay|norton|nowruz|office|olayan|online|oracle|orange|otsuka|pfizer|photos|physio|pictet|quebec|racing|realty|reisen|repair|report|review|rocher|rogers|ryukyu|safety|sakura|sanofi|school|schule|search|secure|select|shouji|soccer|social|stream|studio|supply|suzuki|swatch|sydney|taipei|taobao|target|tattoo|tennis|tienda|tjmaxx|tkmaxx|toyota|travel|unicom|viajes|viking|villas|virgin|vision|voting|voyage|vuelos|walter|webcam|xihuan|yachts|yandex|zappos|москва|онлайн|ابوظبي|ارامكو|الاردن|المغرب|امارات|فلسطين|مليسيا|भारतम्|இலங்கை|ファッション|actor|adult|aetna|amfam|amica|apple|archi|audio|autos|azure|baidu|beats|bible|bingo|black|boats|bosch|build|canon|cards|chase|cheap|cisco|citic|click|cloud|coach|codes|crown|cymru|dabur|dance|deals|delta|drive|dubai|earth|edeka|email|epson|faith|fedex|final|forex|forum|gallo|games|gifts|gives|glade|glass|globo|gmail|green|gripe|group|gucci|guide|homes|honda|horse|house|hyatt|ikano|irish|jetzt|koeln|kyoto|lamer|lease|legal|lexus|lilly|linde|lipsy|lixil|loans|locus|lotte|lotto|macys|mango|media|miami|money|movie|nexus|nikon|ninja|nokia|nowtv|omega|osaka|paris|parts|party|phone|photo|pizza|place|poker|praxi|press|prime|promo|quest|radio|rehab|reise|ricoh|rocks|rodeo|rugby|salon|sener|seven|sharp|shell|shoes|skype|sling|smart|smile|solar|space|sport|stada|store|study|style|sucks|swiss|tatar|tires|tirol|tmall|today|tokyo|tools|toray|total|tours|trade|trust|tunes|tushu|ubank|vegas|video|vodka|volvo|wales|watch|weber|weibo|works|world|xerox|yahoo|ישראל|ایران|بازار|بھارت|سودان|سورية|همراه|भारोत|संगठन|বাংলা|భారత్|ഭാരതം|嘉里大酒店|aarp|able|adac|aero|akdn|ally|amex|arab|army|arpa|arte|asda|asia|audi|auto|baby|band|bank|bbva|beer|best|bike|bing|blog|blue|bofa|bond|book|buzz|cafe|call|camp|care|cars|casa|case|cash|cbre|cern|chat|citi|city|club|cool|coop|cyou|data|date|dclk|deal|dell|desi|diet|dish|docs|duck|dvag|erni|fage|fail|fans|farm|fast|fiat|fido|film|fire|fish|flir|food|ford|free|fund|game|gbiz|gent|ggee|gift|gmbh|gold|golf|goog|guge|guru|hair|haus|hdfc|help|here|hgtv|host|hsbc|icbc|ieee|imdb|immo|info|itau|java|jeep|jobs|jprs|kddi|kiwi|kpmg|kred|land|lego|lgbt|lidl|life|like|limo|link|live|loan|loft|love|ltda|luxe|maif|meet|meme|menu|mini|mint|mobi|moda|moto|name|navy|news|next|nico|nike|ollo|open|page|pars|pccw|pics|ping|pink|play|plus|pohl|porn|post|prod|prof|qpon|raid|read|reit|rent|rest|rich|rmit|room|rsvp|ruhr|safe|sale|sarl|save|saxo|scot|seat|seek|sexy|shaw|shia|shop|show|silk|sina|site|skin|sncf|sohu|song|sony|spot|star|surf|talk|taxi|team|tech|teva|tiaa|tips|town|toys|tube|vana|visa|viva|vivo|vote|voto|wang|weir|wien|wiki|wine|work|xbox|yoga|zara|zero|zone|дети|сайт|بارت|بيتك|ڀارت|تونس|شبكة|عراق|عمان|موقع|भारत|ভারত|ভাৰত|ਭਾਰਤ|ભારત|ଭାରତ|ಭಾರತ|ලංකා|アマゾン|グーグル|クラウド|ポイント|大众汽车|组织机构|電訊盈科|香格里拉|aaa|abb|abc|aco|ads|aeg|afl|aig|anz|aol|app|art|aws|axa|bar|bbc|bbt|bcg|bcn|bet|bid|bio|biz|bms|bmw|bom|boo|bot|box|buy|bzh|cab|cal|cam|car|cat|cba|cbn|cbs|ceo|cfa|cfd|com|cpa|crs|csc|dad|day|dds|dev|dhl|diy|dnp|dog|dot|dtv|dvr|eat|eco|edu|esq|eus|fan|fit|fly|foo|fox|frl|ftr|fun|fyi|gal|gap|gay|gdn|gea|gle|gmo|gmx|goo|gop|got|gov|hbo|hiv|hkt|hot|how|ibm|ice|icu|ifm|inc|ing|ink|int|ist|itv|jcb|jio|jll|jmp|jnj|jot|joy|kfh|kia|kim|kpn|krd|lat|law|lds|llc|llp|lol|lpl|ltd|man|map|mba|med|men|mil|mit|mlb|mls|mma|moe|moi|mom|mov|msd|mtn|mtr|nab|nba|nec|net|new|nfl|ngo|nhk|now|nra|nrw|ntt|nyc|obi|off|one|ong|onl|ooo|org|ott|ovh|pay|pet|phd|pid|pin|pnc|pro|pru|pub|pwc|qvc|red|ren|ril|rio|rip|run|rwe|sap|sas|sbi|sbs|sca|scb|ses|sew|sex|sfr|ski|sky|soy|spa|srl|stc|tab|tax|tci|tdk|tel|thd|tjx|top|trv|tui|tvs|ubs|uno|uol|ups|vet|vig|vin|vip|wed|win|wme|wow|wtc|wtf|xin|xxx|xyz|you|yun|zip|бел|ком|қаз|мкд|мон|орг|рус|срб|укр|հայ|קום|عرب|قطر|كوم|مصر|कॉम|नेट|คอม|ไทย|ລາວ|ストア|セール|みんな|中文网|亚马逊|天主教|我爱你|新加坡|淡马锡|诺基亚|飞利浦|ac|ad|ae|af|ag|ai|al|am|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|bd|be|bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|ck|cl|cm|cn|co|cr|cu|cv|cw|cx|cy|cz|de|dj|dk|dm|do|dz|ec|ee|eg|er|es|et|eu|fi|fj|fk|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|il|im|in|io|iq|ir|is|it|je|jm|jo|jp|ke|kg|kh|ki|km|kn|kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mm|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|no|np|nr|nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|ss|st|su|sv|sx|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|ye|yt|za|zm|zw|ελ|ευ|бг|ею|рф|გე|닷넷|닷컴|삼성|한국|コム|世界|中信|中国|中國|企业|佛山|信息|健康|八卦|公司|公益|台湾|台灣|商城|商店|商标|嘉里|在线|大拿|娱乐|家電|广东|微博|慈善|手机|招聘|政务|政府|新闻|时尚|書籍|机构|游戏|澳門|点看|移动|网址|网店|网站|网络|联通|谷歌|购物|通販|集团|食品|餐厅|香港)/;
var localPartCharRegex = new RegExp("[".concat(alphaNumericAndMarksCharsStr, "!#$%&'*+/=?^_`{|}~-]"));
var strictTldRegex = new RegExp("^".concat(tldRegex.source, "$"));
var EmailMatcher = function(_super) {
  __extends(EmailMatcher2, _super);
  function EmailMatcher2() {
    var _this = _super !== null && _super.apply(this, arguments) || this;
    _this.localPartCharRegex = localPartCharRegex;
    _this.strictTldRegex = strictTldRegex;
    return _this;
  }
  EmailMatcher2.prototype.parseMatches = function(text2) {
    var tagBuilder = this.tagBuilder, localPartCharRegex2 = this.localPartCharRegex, strictTldRegex2 = this.strictTldRegex, matches = [], len = text2.length, noCurrentEmailMatch = new CurrentEmailMatch();
    var mailtoTransitions = {
      "m": "a",
      "a": "i",
      "i": "l",
      "l": "t",
      "t": "o",
      "o": ":"
    };
    var charIdx = 0, state = 0, currentEmailMatch = noCurrentEmailMatch;
    while (charIdx < len) {
      var char = text2.charAt(charIdx);
      switch (state) {
        case 0:
          stateNonEmailAddress(char);
          break;
        case 1:
          stateMailTo(text2.charAt(charIdx - 1), char);
          break;
        case 2:
          stateLocalPart(char);
          break;
        case 3:
          stateLocalPartDot(char);
          break;
        case 4:
          stateAtSign(char);
          break;
        case 5:
          stateDomainChar(char);
          break;
        case 6:
          stateDomainHyphen(char);
          break;
        case 7:
          stateDomainDot(char);
          break;
        default:
          throwUnhandledCaseError(state);
      }
      charIdx++;
    }
    captureMatchIfValidAndReset();
    return matches;
    function stateNonEmailAddress(char2) {
      if (char2 === "m") {
        beginEmailMatch(1);
      } else if (localPartCharRegex2.test(char2)) {
        beginEmailMatch();
      } else
        ;
    }
    function stateMailTo(prevChar, char2) {
      if (prevChar === ":") {
        if (localPartCharRegex2.test(char2)) {
          state = 2;
          currentEmailMatch = new CurrentEmailMatch(__assign(__assign({}, currentEmailMatch), { hasMailtoPrefix: true }));
        } else {
          resetToNonEmailMatchState();
        }
      } else if (mailtoTransitions[prevChar] === char2)
        ;
      else if (localPartCharRegex2.test(char2)) {
        state = 2;
      } else if (char2 === ".") {
        state = 3;
      } else if (char2 === "@") {
        state = 4;
      } else {
        resetToNonEmailMatchState();
      }
    }
    function stateLocalPart(char2) {
      if (char2 === ".") {
        state = 3;
      } else if (char2 === "@") {
        state = 4;
      } else if (localPartCharRegex2.test(char2))
        ;
      else {
        resetToNonEmailMatchState();
      }
    }
    function stateLocalPartDot(char2) {
      if (char2 === ".") {
        resetToNonEmailMatchState();
      } else if (char2 === "@") {
        resetToNonEmailMatchState();
      } else if (localPartCharRegex2.test(char2)) {
        state = 2;
      } else {
        resetToNonEmailMatchState();
      }
    }
    function stateAtSign(char2) {
      if (domainNameCharRegex.test(char2)) {
        state = 5;
      } else {
        resetToNonEmailMatchState();
      }
    }
    function stateDomainChar(char2) {
      if (char2 === ".") {
        state = 7;
      } else if (char2 === "-") {
        state = 6;
      } else if (domainNameCharRegex.test(char2))
        ;
      else {
        captureMatchIfValidAndReset();
      }
    }
    function stateDomainHyphen(char2) {
      if (char2 === "-" || char2 === ".") {
        captureMatchIfValidAndReset();
      } else if (domainNameCharRegex.test(char2)) {
        state = 5;
      } else {
        captureMatchIfValidAndReset();
      }
    }
    function stateDomainDot(char2) {
      if (char2 === "." || char2 === "-") {
        captureMatchIfValidAndReset();
      } else if (domainNameCharRegex.test(char2)) {
        state = 5;
        currentEmailMatch = new CurrentEmailMatch(__assign(__assign({}, currentEmailMatch), { hasDomainDot: true }));
      } else {
        captureMatchIfValidAndReset();
      }
    }
    function beginEmailMatch(newState) {
      if (newState === void 0) {
        newState = 2;
      }
      state = newState;
      currentEmailMatch = new CurrentEmailMatch({ idx: charIdx });
    }
    function resetToNonEmailMatchState() {
      state = 0;
      currentEmailMatch = noCurrentEmailMatch;
    }
    function captureMatchIfValidAndReset() {
      if (currentEmailMatch.hasDomainDot) {
        var matchedText = text2.slice(currentEmailMatch.idx, charIdx);
        if (/[-.]$/.test(matchedText)) {
          matchedText = matchedText.slice(0, -1);
        }
        var emailAddress = currentEmailMatch.hasMailtoPrefix ? matchedText.slice("mailto:".length) : matchedText;
        if (doesEmailHaveValidTld(emailAddress)) {
          matches.push(new EmailMatch({
            tagBuilder,
            matchedText,
            offset: currentEmailMatch.idx,
            email: emailAddress
          }));
        }
      }
      resetToNonEmailMatchState();
      function doesEmailHaveValidTld(emailAddress2) {
        var emailAddressTld = emailAddress2.split(".").pop() || "";
        var emailAddressNormalized = emailAddressTld.toLowerCase();
        var isValidTld = strictTldRegex2.test(emailAddressNormalized);
        return isValidTld;
      }
    }
  };
  return EmailMatcher2;
}(Matcher);
var CurrentEmailMatch = function() {
  function CurrentEmailMatch2(cfg) {
    if (cfg === void 0) {
      cfg = {};
    }
    this.idx = cfg.idx !== void 0 ? cfg.idx : -1;
    this.hasMailtoPrefix = !!cfg.hasMailtoPrefix;
    this.hasDomainDot = !!cfg.hasDomainDot;
  }
  return CurrentEmailMatch2;
}();
var UrlMatchValidator = function() {
  function UrlMatchValidator2() {
  }
  UrlMatchValidator2.isValid = function(urlMatch, protocolUrlMatch) {
    if (protocolUrlMatch && !this.isValidUriScheme(protocolUrlMatch) || this.urlMatchDoesNotHaveProtocolOrDot(urlMatch, protocolUrlMatch) || this.urlMatchDoesNotHaveAtLeastOneWordChar(urlMatch, protocolUrlMatch) && !this.isValidIpAddress(urlMatch) || this.containsMultipleDots(urlMatch)) {
      return false;
    }
    return true;
  };
  UrlMatchValidator2.isValidIpAddress = function(uriSchemeMatch) {
    var newRegex = new RegExp(this.hasFullProtocolRegex.source + this.ipRegex.source);
    var uriScheme = uriSchemeMatch.match(newRegex);
    return uriScheme !== null;
  };
  UrlMatchValidator2.containsMultipleDots = function(urlMatch) {
    var stringBeforeSlash = urlMatch;
    if (this.hasFullProtocolRegex.test(urlMatch)) {
      stringBeforeSlash = urlMatch.split("://")[1];
    }
    return stringBeforeSlash.split("/")[0].indexOf("..") > -1;
  };
  UrlMatchValidator2.isValidUriScheme = function(uriSchemeMatch) {
    var uriSchemeMatchArr = uriSchemeMatch.match(this.uriSchemeRegex), uriScheme = uriSchemeMatchArr && uriSchemeMatchArr[0].toLowerCase();
    return uriScheme !== "javascript:" && uriScheme !== "vbscript:";
  };
  UrlMatchValidator2.urlMatchDoesNotHaveProtocolOrDot = function(urlMatch, protocolUrlMatch) {
    return !!urlMatch && (!protocolUrlMatch || !this.hasFullProtocolRegex.test(protocolUrlMatch)) && urlMatch.indexOf(".") === -1;
  };
  UrlMatchValidator2.urlMatchDoesNotHaveAtLeastOneWordChar = function(urlMatch, protocolUrlMatch) {
    if (urlMatch && protocolUrlMatch) {
      return !this.hasFullProtocolRegex.test(protocolUrlMatch) && !this.hasWordCharAfterProtocolRegex.test(urlMatch);
    } else {
      return false;
    }
  };
  UrlMatchValidator2.hasFullProtocolRegex = /^[A-Za-z][-.+A-Za-z0-9]*:\/\//;
  UrlMatchValidator2.uriSchemeRegex = /^[A-Za-z][-.+A-Za-z0-9]*:/;
  UrlMatchValidator2.hasWordCharAfterProtocolRegex = new RegExp(":[^\\s]*?[" + alphaCharsStr + "]");
  UrlMatchValidator2.ipRegex = /[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?(:[0-9]*)?\/?$/;
  return UrlMatchValidator2;
}();
var matcherRegex$1 = function() {
  var schemeRegex = /(?:[A-Za-z][-.+A-Za-z0-9]{0,63}:(?![A-Za-z][-.+A-Za-z0-9]{0,63}:\/\/)(?!\d+\/?)(?:\/\/)?)/, wwwRegex = /(?:www\.)/, urlSuffixRegex = new RegExp("[/?#](?:[" + alphaNumericAndMarksCharsStr + "\\-+&@#/%=~_()|'$*\\[\\]{}?!:,.;^\u2713]*[" + alphaNumericAndMarksCharsStr + "\\-+&@#/%=~_()|'$*\\[\\]{}\u2713])?");
  return new RegExp([
    "(?:",
    "(",
    schemeRegex.source,
    getDomainNameStr(2),
    ")",
    "|",
    "(",
    "(//)?",
    wwwRegex.source,
    getDomainNameStr(6),
    ")",
    "|",
    "(",
    "(//)?",
    getDomainNameStr(10) + "\\.",
    tldRegex.source,
    "(?![-" + alphaNumericCharsStr + "])",
    ")",
    ")",
    "(?::[0-9]+)?",
    "(?:" + urlSuffixRegex.source + ")?"
  ].join(""), "gi");
}();
var wordCharRegExp = new RegExp("[" + alphaNumericAndMarksCharsStr + "]");
var UrlMatcher = function(_super) {
  __extends(UrlMatcher2, _super);
  function UrlMatcher2(cfg) {
    var _this = _super.call(this, cfg) || this;
    _this.stripPrefix = { scheme: true, www: true };
    _this.stripTrailingSlash = true;
    _this.decodePercentEncoding = true;
    _this.matcherRegex = matcherRegex$1;
    _this.wordCharRegExp = wordCharRegExp;
    _this.stripPrefix = cfg.stripPrefix;
    _this.stripTrailingSlash = cfg.stripTrailingSlash;
    _this.decodePercentEncoding = cfg.decodePercentEncoding;
    return _this;
  }
  UrlMatcher2.prototype.parseMatches = function(text2) {
    var matcherRegex2 = this.matcherRegex, stripPrefix = this.stripPrefix, stripTrailingSlash = this.stripTrailingSlash, decodePercentEncoding = this.decodePercentEncoding, tagBuilder = this.tagBuilder, matches = [], match;
    var _loop_1 = function() {
      var matchStr = match[0], schemeUrlMatch = match[1], wwwUrlMatch = match[4], wwwProtocolRelativeMatch = match[5], tldProtocolRelativeMatch = match[9], offset2 = match.index, protocolRelativeMatch = wwwProtocolRelativeMatch || tldProtocolRelativeMatch, prevChar = text2.charAt(offset2 - 1);
      if (!UrlMatchValidator.isValid(matchStr, schemeUrlMatch)) {
        return "continue";
      }
      if (offset2 > 0 && prevChar === "@") {
        return "continue";
      }
      if (offset2 > 0 && protocolRelativeMatch && this_1.wordCharRegExp.test(prevChar)) {
        return "continue";
      }
      if (/\?$/.test(matchStr)) {
        matchStr = matchStr.substr(0, matchStr.length - 1);
      }
      if (this_1.matchHasUnbalancedClosingParen(matchStr)) {
        matchStr = matchStr.substr(0, matchStr.length - 1);
      } else {
        var pos = this_1.matchHasInvalidCharAfterTld(matchStr, schemeUrlMatch);
        if (pos > -1) {
          matchStr = matchStr.substr(0, pos);
        }
      }
      var foundCommonScheme = ["http://", "https://"].find(function(commonScheme) {
        return !!schemeUrlMatch && schemeUrlMatch.indexOf(commonScheme) !== -1;
      });
      if (foundCommonScheme) {
        var indexOfSchemeStart = matchStr.indexOf(foundCommonScheme);
        matchStr = matchStr.substr(indexOfSchemeStart);
        schemeUrlMatch = schemeUrlMatch.substr(indexOfSchemeStart);
        offset2 = offset2 + indexOfSchemeStart;
      }
      var urlMatchType = schemeUrlMatch ? "scheme" : wwwUrlMatch ? "www" : "tld", protocolUrlMatch = !!schemeUrlMatch;
      matches.push(new UrlMatch({
        tagBuilder,
        matchedText: matchStr,
        offset: offset2,
        urlMatchType,
        url: matchStr,
        protocolUrlMatch,
        protocolRelativeMatch: !!protocolRelativeMatch,
        stripPrefix,
        stripTrailingSlash,
        decodePercentEncoding
      }));
    };
    var this_1 = this;
    while ((match = matcherRegex2.exec(text2)) !== null) {
      _loop_1();
    }
    return matches;
  };
  UrlMatcher2.prototype.matchHasUnbalancedClosingParen = function(matchStr) {
    var endChar = matchStr.charAt(matchStr.length - 1);
    var startChar;
    if (endChar === ")") {
      startChar = "(";
    } else if (endChar === "]") {
      startChar = "[";
    } else if (endChar === "}") {
      startChar = "{";
    } else {
      return false;
    }
    var numOpenBraces = 0;
    for (var i2 = 0, len = matchStr.length - 1; i2 < len; i2++) {
      var char = matchStr.charAt(i2);
      if (char === startChar) {
        numOpenBraces++;
      } else if (char === endChar) {
        numOpenBraces = Math.max(numOpenBraces - 1, 0);
      }
    }
    if (numOpenBraces === 0) {
      return true;
    }
    return false;
  };
  UrlMatcher2.prototype.matchHasInvalidCharAfterTld = function(urlMatch, schemeUrlMatch) {
    if (!urlMatch) {
      return -1;
    }
    var offset2 = 0;
    if (schemeUrlMatch) {
      offset2 = urlMatch.indexOf(":");
      urlMatch = urlMatch.slice(offset2);
    }
    var re = new RegExp("^((.?//)?[-." + alphaNumericAndMarksCharsStr + "]*[-" + alphaNumericAndMarksCharsStr + "]\\.[-" + alphaNumericAndMarksCharsStr + "]+)");
    var res = re.exec(urlMatch);
    if (res === null) {
      return -1;
    }
    offset2 += res[1].length;
    urlMatch = urlMatch.slice(res[1].length);
    if (/^[^-.A-Za-z0-9:\/?#]/.test(urlMatch)) {
      return offset2;
    }
    return -1;
  };
  return UrlMatcher2;
}(Matcher);
var matcherRegex = new RegExp("#[_".concat(alphaNumericAndMarksCharsStr, "]{1,139}(?![_").concat(alphaNumericAndMarksCharsStr, "])"), "g");
var nonWordCharRegex$1 = new RegExp("[^" + alphaNumericAndMarksCharsStr + "]");
var HashtagMatcher = function(_super) {
  __extends(HashtagMatcher2, _super);
  function HashtagMatcher2(cfg) {
    var _this = _super.call(this, cfg) || this;
    _this.serviceName = "twitter";
    _this.matcherRegex = matcherRegex;
    _this.nonWordCharRegex = nonWordCharRegex$1;
    _this.serviceName = cfg.serviceName;
    return _this;
  }
  HashtagMatcher2.prototype.parseMatches = function(text2) {
    var matcherRegex2 = this.matcherRegex, nonWordCharRegex2 = this.nonWordCharRegex, serviceName = this.serviceName, tagBuilder = this.tagBuilder, matches = [], match;
    while ((match = matcherRegex2.exec(text2)) !== null) {
      var offset2 = match.index, prevChar = text2.charAt(offset2 - 1);
      if (offset2 === 0 || nonWordCharRegex2.test(prevChar)) {
        var matchedText = match[0], hashtag = match[0].slice(1);
        matches.push(new HashtagMatch({
          tagBuilder,
          matchedText,
          offset: offset2,
          serviceName,
          hashtag
        }));
      }
    }
    return matches;
  };
  return HashtagMatcher2;
}(Matcher);
var mostPhoneNumbers = /(?:(?:(?:(\+)?\d{1,3}[-\040.]?)?\(?\d{3}\)?[-\040.]?\d{3}[-\040.]?\d{4})|(?:(\+)(?:9[976]\d|8[987530]\d|6[987]\d|5[90]\d|42\d|3[875]\d|2[98654321]\d|9[8543210]|8[6421]|6[6543210]|5[87654321]|4[987654310]|3[9643210]|2[70]|7|1)[-\040.]?(?:\d[-\040.]?){6,12}\d+))([,;]+[0-9]+#?)*/;
var japanesePhoneRe = /(0([1-9]{1}-?[1-9]\d{3}|[1-9]{2}-?\d{3}|[1-9]{2}\d{1}-?\d{2}|[1-9]{2}\d{2}-?\d{1})-?\d{4}|0[789]0-?\d{4}-?\d{4}|050-?\d{4}-?\d{4})/;
var phoneMatcherRegex = new RegExp("".concat(mostPhoneNumbers.source, "|").concat(japanesePhoneRe.source), "g");
var PhoneMatcher = function(_super) {
  __extends(PhoneMatcher2, _super);
  function PhoneMatcher2() {
    var _this = _super !== null && _super.apply(this, arguments) || this;
    _this.matcherRegex = phoneMatcherRegex;
    return _this;
  }
  PhoneMatcher2.prototype.parseMatches = function(text2) {
    var matcherRegex2 = this.matcherRegex, tagBuilder = this.tagBuilder, matches = [], match;
    while ((match = matcherRegex2.exec(text2)) !== null) {
      var matchedText = match[0], cleanNumber = matchedText.replace(/[^0-9,;#]/g, ""), plusSign = !!(match[1] || match[2]), before = match.index == 0 ? "" : text2.substr(match.index - 1, 1), after = text2.substr(match.index + matchedText.length, 1), contextClear = !before.match(/\d/) && !after.match(/\d/);
      if (this.testMatch(match[3]) && this.testMatch(matchedText) && contextClear) {
        matches.push(new PhoneMatch({
          tagBuilder,
          matchedText,
          offset: match.index,
          number: cleanNumber,
          plusSign
        }));
      }
    }
    return matches;
  };
  PhoneMatcher2.prototype.testMatch = function(text2) {
    return nonDigitRe.test(text2);
  };
  return PhoneMatcher2;
}(Matcher);
var twitterRegex = new RegExp("@[_".concat(alphaNumericAndMarksCharsStr, "]{1,50}(?![_").concat(alphaNumericAndMarksCharsStr, "])"), "g");
var instagramRegex = new RegExp("@[_.".concat(alphaNumericAndMarksCharsStr, "]{1,30}(?![_").concat(alphaNumericAndMarksCharsStr, "])"), "g");
var soundcloudRegex = new RegExp("@[-_.".concat(alphaNumericAndMarksCharsStr, "]{1,50}(?![-_").concat(alphaNumericAndMarksCharsStr, "])"), "g");
var tiktokRegex = new RegExp("@[_.".concat(alphaNumericAndMarksCharsStr, "]{1,23}[_").concat(alphaNumericAndMarksCharsStr, "](?![_").concat(alphaNumericAndMarksCharsStr, "])"), "g");
var nonWordCharRegex = new RegExp("[^" + alphaNumericAndMarksCharsStr + "]");
var MentionMatcher = function(_super) {
  __extends(MentionMatcher2, _super);
  function MentionMatcher2(cfg) {
    var _this = _super.call(this, cfg) || this;
    _this.serviceName = "twitter";
    _this.matcherRegexes = {
      "twitter": twitterRegex,
      "instagram": instagramRegex,
      "soundcloud": soundcloudRegex,
      "tiktok": tiktokRegex
    };
    _this.nonWordCharRegex = nonWordCharRegex;
    _this.serviceName = cfg.serviceName;
    return _this;
  }
  MentionMatcher2.prototype.parseMatches = function(text2) {
    var serviceName = this.serviceName, matcherRegex2 = this.matcherRegexes[this.serviceName], nonWordCharRegex2 = this.nonWordCharRegex, tagBuilder = this.tagBuilder, matches = [], match;
    if (!matcherRegex2) {
      return matches;
    }
    while ((match = matcherRegex2.exec(text2)) !== null) {
      var offset2 = match.index, prevChar = text2.charAt(offset2 - 1);
      if (offset2 === 0 || nonWordCharRegex2.test(prevChar)) {
        var matchedText = match[0].replace(/\.+$/g, ""), mention = matchedText.slice(1);
        matches.push(new MentionMatch({
          tagBuilder,
          matchedText,
          offset: offset2,
          serviceName,
          mention
        }));
      }
    }
    return matches;
  };
  return MentionMatcher2;
}(Matcher);
function parseHtml(html2, _a) {
  var onOpenTag = _a.onOpenTag, onCloseTag = _a.onCloseTag, onText = _a.onText, onComment = _a.onComment, onDoctype = _a.onDoctype;
  var noCurrentTag = new CurrentTag();
  var charIdx = 0, len = html2.length, state = 0, currentDataIdx = 0, currentTag = noCurrentTag;
  while (charIdx < len) {
    var char = html2.charAt(charIdx);
    switch (state) {
      case 0:
        stateData(char);
        break;
      case 1:
        stateTagOpen(char);
        break;
      case 2:
        stateEndTagOpen(char);
        break;
      case 3:
        stateTagName(char);
        break;
      case 4:
        stateBeforeAttributeName(char);
        break;
      case 5:
        stateAttributeName(char);
        break;
      case 6:
        stateAfterAttributeName(char);
        break;
      case 7:
        stateBeforeAttributeValue(char);
        break;
      case 8:
        stateAttributeValueDoubleQuoted(char);
        break;
      case 9:
        stateAttributeValueSingleQuoted(char);
        break;
      case 10:
        stateAttributeValueUnquoted(char);
        break;
      case 11:
        stateAfterAttributeValueQuoted(char);
        break;
      case 12:
        stateSelfClosingStartTag(char);
        break;
      case 13:
        stateMarkupDeclarationOpen();
        break;
      case 14:
        stateCommentStart(char);
        break;
      case 15:
        stateCommentStartDash(char);
        break;
      case 16:
        stateComment(char);
        break;
      case 17:
        stateCommentEndDash(char);
        break;
      case 18:
        stateCommentEnd(char);
        break;
      case 19:
        stateCommentEndBang(char);
        break;
      case 20:
        stateDoctype(char);
        break;
      default:
        throwUnhandledCaseError(state);
    }
    charIdx++;
  }
  if (currentDataIdx < charIdx) {
    emitText();
  }
  function stateData(char2) {
    if (char2 === "<") {
      startNewTag();
    }
  }
  function stateTagOpen(char2) {
    if (char2 === "!") {
      state = 13;
    } else if (char2 === "/") {
      state = 2;
      currentTag = new CurrentTag(__assign(__assign({}, currentTag), { isClosing: true }));
    } else if (char2 === "<") {
      startNewTag();
    } else if (letterRe.test(char2)) {
      state = 3;
      currentTag = new CurrentTag(__assign(__assign({}, currentTag), { isOpening: true }));
    } else {
      state = 0;
      currentTag = noCurrentTag;
    }
  }
  function stateTagName(char2) {
    if (whitespaceRe.test(char2)) {
      currentTag = new CurrentTag(__assign(__assign({}, currentTag), { name: captureTagName() }));
      state = 4;
    } else if (char2 === "<") {
      startNewTag();
    } else if (char2 === "/") {
      currentTag = new CurrentTag(__assign(__assign({}, currentTag), { name: captureTagName() }));
      state = 12;
    } else if (char2 === ">") {
      currentTag = new CurrentTag(__assign(__assign({}, currentTag), { name: captureTagName() }));
      emitTagAndPreviousTextNode();
    } else if (!letterRe.test(char2) && !digitRe.test(char2) && char2 !== ":") {
      resetToDataState();
    } else
      ;
  }
  function stateEndTagOpen(char2) {
    if (char2 === ">") {
      resetToDataState();
    } else if (letterRe.test(char2)) {
      state = 3;
    } else {
      resetToDataState();
    }
  }
  function stateBeforeAttributeName(char2) {
    if (whitespaceRe.test(char2))
      ;
    else if (char2 === "/") {
      state = 12;
    } else if (char2 === ">") {
      emitTagAndPreviousTextNode();
    } else if (char2 === "<") {
      startNewTag();
    } else if (char2 === "=" || quoteRe.test(char2) || controlCharsRe.test(char2)) {
      resetToDataState();
    } else {
      state = 5;
    }
  }
  function stateAttributeName(char2) {
    if (whitespaceRe.test(char2)) {
      state = 6;
    } else if (char2 === "/") {
      state = 12;
    } else if (char2 === "=") {
      state = 7;
    } else if (char2 === ">") {
      emitTagAndPreviousTextNode();
    } else if (char2 === "<") {
      startNewTag();
    } else if (quoteRe.test(char2)) {
      resetToDataState();
    } else
      ;
  }
  function stateAfterAttributeName(char2) {
    if (whitespaceRe.test(char2))
      ;
    else if (char2 === "/") {
      state = 12;
    } else if (char2 === "=") {
      state = 7;
    } else if (char2 === ">") {
      emitTagAndPreviousTextNode();
    } else if (char2 === "<") {
      startNewTag();
    } else if (quoteRe.test(char2)) {
      resetToDataState();
    } else {
      state = 5;
    }
  }
  function stateBeforeAttributeValue(char2) {
    if (whitespaceRe.test(char2))
      ;
    else if (char2 === '"') {
      state = 8;
    } else if (char2 === "'") {
      state = 9;
    } else if (/[>=`]/.test(char2)) {
      resetToDataState();
    } else if (char2 === "<") {
      startNewTag();
    } else {
      state = 10;
    }
  }
  function stateAttributeValueDoubleQuoted(char2) {
    if (char2 === '"') {
      state = 11;
    }
  }
  function stateAttributeValueSingleQuoted(char2) {
    if (char2 === "'") {
      state = 11;
    }
  }
  function stateAttributeValueUnquoted(char2) {
    if (whitespaceRe.test(char2)) {
      state = 4;
    } else if (char2 === ">") {
      emitTagAndPreviousTextNode();
    } else if (char2 === "<") {
      startNewTag();
    } else
      ;
  }
  function stateAfterAttributeValueQuoted(char2) {
    if (whitespaceRe.test(char2)) {
      state = 4;
    } else if (char2 === "/") {
      state = 12;
    } else if (char2 === ">") {
      emitTagAndPreviousTextNode();
    } else if (char2 === "<") {
      startNewTag();
    } else {
      state = 4;
      reconsumeCurrentCharacter();
    }
  }
  function stateSelfClosingStartTag(char2) {
    if (char2 === ">") {
      currentTag = new CurrentTag(__assign(__assign({}, currentTag), { isClosing: true }));
      emitTagAndPreviousTextNode();
    } else {
      state = 4;
    }
  }
  function stateMarkupDeclarationOpen(char2) {
    if (html2.substr(charIdx, 2) === "--") {
      charIdx += 2;
      currentTag = new CurrentTag(__assign(__assign({}, currentTag), { type: "comment" }));
      state = 14;
    } else if (html2.substr(charIdx, 7).toUpperCase() === "DOCTYPE") {
      charIdx += 7;
      currentTag = new CurrentTag(__assign(__assign({}, currentTag), { type: "doctype" }));
      state = 20;
    } else {
      resetToDataState();
    }
  }
  function stateCommentStart(char2) {
    if (char2 === "-") {
      state = 15;
    } else if (char2 === ">") {
      resetToDataState();
    } else {
      state = 16;
    }
  }
  function stateCommentStartDash(char2) {
    if (char2 === "-") {
      state = 18;
    } else if (char2 === ">") {
      resetToDataState();
    } else {
      state = 16;
    }
  }
  function stateComment(char2) {
    if (char2 === "-") {
      state = 17;
    }
  }
  function stateCommentEndDash(char2) {
    if (char2 === "-") {
      state = 18;
    } else {
      state = 16;
    }
  }
  function stateCommentEnd(char2) {
    if (char2 === ">") {
      emitTagAndPreviousTextNode();
    } else if (char2 === "!") {
      state = 19;
    } else if (char2 === "-")
      ;
    else {
      state = 16;
    }
  }
  function stateCommentEndBang(char2) {
    if (char2 === "-") {
      state = 17;
    } else if (char2 === ">") {
      emitTagAndPreviousTextNode();
    } else {
      state = 16;
    }
  }
  function stateDoctype(char2) {
    if (char2 === ">") {
      emitTagAndPreviousTextNode();
    } else if (char2 === "<") {
      startNewTag();
    } else
      ;
  }
  function resetToDataState() {
    state = 0;
    currentTag = noCurrentTag;
  }
  function startNewTag() {
    state = 1;
    currentTag = new CurrentTag({ idx: charIdx });
  }
  function emitTagAndPreviousTextNode() {
    var textBeforeTag = html2.slice(currentDataIdx, currentTag.idx);
    if (textBeforeTag) {
      onText(textBeforeTag, currentDataIdx);
    }
    if (currentTag.type === "comment") {
      onComment(currentTag.idx);
    } else if (currentTag.type === "doctype") {
      onDoctype(currentTag.idx);
    } else {
      if (currentTag.isOpening) {
        onOpenTag(currentTag.name, currentTag.idx);
      }
      if (currentTag.isClosing) {
        onCloseTag(currentTag.name, currentTag.idx);
      }
    }
    resetToDataState();
    currentDataIdx = charIdx + 1;
  }
  function emitText() {
    var text2 = html2.slice(currentDataIdx, charIdx);
    onText(text2, currentDataIdx);
    currentDataIdx = charIdx + 1;
  }
  function captureTagName() {
    var startIdx = currentTag.idx + (currentTag.isClosing ? 2 : 1);
    return html2.slice(startIdx, charIdx).toLowerCase();
  }
  function reconsumeCurrentCharacter() {
    charIdx--;
  }
}
var CurrentTag = function() {
  function CurrentTag2(cfg) {
    if (cfg === void 0) {
      cfg = {};
    }
    this.idx = cfg.idx !== void 0 ? cfg.idx : -1;
    this.type = cfg.type || "tag";
    this.name = cfg.name || "";
    this.isOpening = !!cfg.isOpening;
    this.isClosing = !!cfg.isClosing;
  }
  return CurrentTag2;
}();
var Autolinker = function() {
  function Autolinker2(cfg) {
    if (cfg === void 0) {
      cfg = {};
    }
    this.version = Autolinker2.version;
    this.urls = {};
    this.email = true;
    this.phone = true;
    this.hashtag = false;
    this.mention = false;
    this.newWindow = true;
    this.stripPrefix = { scheme: true, www: true };
    this.stripTrailingSlash = true;
    this.decodePercentEncoding = true;
    this.truncate = { length: 0, location: "end" };
    this.className = "";
    this.replaceFn = null;
    this.context = void 0;
    this.sanitizeHtml = false;
    this.matchers = null;
    this.tagBuilder = null;
    this.urls = this.normalizeUrlsCfg(cfg.urls);
    this.email = typeof cfg.email === "boolean" ? cfg.email : this.email;
    this.phone = typeof cfg.phone === "boolean" ? cfg.phone : this.phone;
    this.hashtag = cfg.hashtag || this.hashtag;
    this.mention = cfg.mention || this.mention;
    this.newWindow = typeof cfg.newWindow === "boolean" ? cfg.newWindow : this.newWindow;
    this.stripPrefix = this.normalizeStripPrefixCfg(cfg.stripPrefix);
    this.stripTrailingSlash = typeof cfg.stripTrailingSlash === "boolean" ? cfg.stripTrailingSlash : this.stripTrailingSlash;
    this.decodePercentEncoding = typeof cfg.decodePercentEncoding === "boolean" ? cfg.decodePercentEncoding : this.decodePercentEncoding;
    this.sanitizeHtml = cfg.sanitizeHtml || false;
    var mention = this.mention;
    if (mention !== false && ["twitter", "instagram", "soundcloud", "tiktok"].indexOf(mention) === -1) {
      throw new Error("invalid `mention` cfg '".concat(mention, "' - see docs"));
    }
    var hashtag = this.hashtag;
    if (hashtag !== false && ["twitter", "facebook", "instagram", "tiktok"].indexOf(hashtag) === -1) {
      throw new Error("invalid `hashtag` cfg '".concat(hashtag, "' - see docs"));
    }
    this.truncate = this.normalizeTruncateCfg(cfg.truncate);
    this.className = cfg.className || this.className;
    this.replaceFn = cfg.replaceFn || this.replaceFn;
    this.context = cfg.context || this;
  }
  Autolinker2.link = function(textOrHtml, options) {
    var autolinker3 = new Autolinker2(options);
    return autolinker3.link(textOrHtml);
  };
  Autolinker2.parse = function(textOrHtml, options) {
    var autolinker3 = new Autolinker2(options);
    return autolinker3.parse(textOrHtml);
  };
  Autolinker2.prototype.normalizeUrlsCfg = function(urls) {
    if (urls == null)
      urls = true;
    if (typeof urls === "boolean") {
      return { schemeMatches: urls, wwwMatches: urls, tldMatches: urls };
    } else {
      return {
        schemeMatches: typeof urls.schemeMatches === "boolean" ? urls.schemeMatches : true,
        wwwMatches: typeof urls.wwwMatches === "boolean" ? urls.wwwMatches : true,
        tldMatches: typeof urls.tldMatches === "boolean" ? urls.tldMatches : true
      };
    }
  };
  Autolinker2.prototype.normalizeStripPrefixCfg = function(stripPrefix) {
    if (stripPrefix == null)
      stripPrefix = true;
    if (typeof stripPrefix === "boolean") {
      return { scheme: stripPrefix, www: stripPrefix };
    } else {
      return {
        scheme: typeof stripPrefix.scheme === "boolean" ? stripPrefix.scheme : true,
        www: typeof stripPrefix.www === "boolean" ? stripPrefix.www : true
      };
    }
  };
  Autolinker2.prototype.normalizeTruncateCfg = function(truncate) {
    if (typeof truncate === "number") {
      return { length: truncate, location: "end" };
    } else {
      return defaults(truncate || {}, {
        length: Number.POSITIVE_INFINITY,
        location: "end"
      });
    }
  };
  Autolinker2.prototype.parse = function(textOrHtml) {
    var _this = this;
    var skipTagNames = ["a", "style", "script"], skipTagsStackCount = 0, matches = [];
    parseHtml(textOrHtml, {
      onOpenTag: function(tagName) {
        if (skipTagNames.indexOf(tagName) >= 0) {
          skipTagsStackCount++;
        }
      },
      onText: function(text2, offset2) {
        if (skipTagsStackCount === 0) {
          var htmlCharacterEntitiesRegex = /(&nbsp;|&#160;|&lt;|&#60;|&gt;|&#62;|&quot;|&#34;|&#39;)/gi;
          var textSplit = splitAndCapture(text2, htmlCharacterEntitiesRegex);
          var currentOffset_1 = offset2;
          textSplit.forEach(function(splitText, i2) {
            if (i2 % 2 === 0) {
              var textNodeMatches = _this.parseText(splitText, currentOffset_1);
              matches.push.apply(matches, textNodeMatches);
            }
            currentOffset_1 += splitText.length;
          });
        }
      },
      onCloseTag: function(tagName) {
        if (skipTagNames.indexOf(tagName) >= 0) {
          skipTagsStackCount = Math.max(skipTagsStackCount - 1, 0);
        }
      },
      onComment: function(offset2) {
      },
      onDoctype: function(offset2) {
      }
    });
    matches = this.compactMatches(matches);
    matches = this.removeUnwantedMatches(matches);
    return matches;
  };
  Autolinker2.prototype.compactMatches = function(matches) {
    matches.sort(function(a4, b) {
      return a4.getOffset() - b.getOffset();
    });
    var i2 = 0;
    while (i2 < matches.length - 1) {
      var match = matches[i2], offset2 = match.getOffset(), matchedTextLength = match.getMatchedText().length, endIdx = offset2 + matchedTextLength;
      if (i2 + 1 < matches.length) {
        if (matches[i2 + 1].getOffset() === offset2) {
          var removeIdx = matches[i2 + 1].getMatchedText().length > matchedTextLength ? i2 : i2 + 1;
          matches.splice(removeIdx, 1);
          continue;
        }
        if (matches[i2 + 1].getOffset() < endIdx) {
          matches.splice(i2 + 1, 1);
          continue;
        }
      }
      i2++;
    }
    return matches;
  };
  Autolinker2.prototype.removeUnwantedMatches = function(matches) {
    if (!this.hashtag)
      remove2(matches, function(match) {
        return match.getType() === "hashtag";
      });
    if (!this.email)
      remove2(matches, function(match) {
        return match.getType() === "email";
      });
    if (!this.phone)
      remove2(matches, function(match) {
        return match.getType() === "phone";
      });
    if (!this.mention)
      remove2(matches, function(match) {
        return match.getType() === "mention";
      });
    if (!this.urls.schemeMatches) {
      remove2(matches, function(m) {
        return m.getType() === "url" && m.getUrlMatchType() === "scheme";
      });
    }
    if (!this.urls.wwwMatches) {
      remove2(matches, function(m) {
        return m.getType() === "url" && m.getUrlMatchType() === "www";
      });
    }
    if (!this.urls.tldMatches) {
      remove2(matches, function(m) {
        return m.getType() === "url" && m.getUrlMatchType() === "tld";
      });
    }
    return matches;
  };
  Autolinker2.prototype.parseText = function(text2, offset2) {
    if (offset2 === void 0) {
      offset2 = 0;
    }
    offset2 = offset2 || 0;
    var matchers = this.getMatchers(), matches = [];
    for (var i2 = 0, numMatchers = matchers.length; i2 < numMatchers; i2++) {
      var textMatches = matchers[i2].parseMatches(text2);
      for (var j = 0, numTextMatches = textMatches.length; j < numTextMatches; j++) {
        textMatches[j].setOffset(offset2 + textMatches[j].getOffset());
      }
      matches.push.apply(matches, textMatches);
    }
    return matches;
  };
  Autolinker2.prototype.link = function(textOrHtml) {
    if (!textOrHtml) {
      return "";
    }
    if (this.sanitizeHtml) {
      textOrHtml = textOrHtml.replace(/</g, "&lt;").replace(/>/g, "&gt;");
    }
    var matches = this.parse(textOrHtml), newHtml = [], lastIndex = 0;
    for (var i2 = 0, len = matches.length; i2 < len; i2++) {
      var match = matches[i2];
      newHtml.push(textOrHtml.substring(lastIndex, match.getOffset()));
      newHtml.push(this.createMatchReturnVal(match));
      lastIndex = match.getOffset() + match.getMatchedText().length;
    }
    newHtml.push(textOrHtml.substring(lastIndex));
    return newHtml.join("");
  };
  Autolinker2.prototype.createMatchReturnVal = function(match) {
    var replaceFnResult;
    if (this.replaceFn) {
      replaceFnResult = this.replaceFn.call(this.context, match);
    }
    if (typeof replaceFnResult === "string") {
      return replaceFnResult;
    } else if (replaceFnResult === false) {
      return match.getMatchedText();
    } else if (replaceFnResult instanceof HtmlTag) {
      return replaceFnResult.toAnchorString();
    } else {
      var anchorTag = match.buildTag();
      return anchorTag.toAnchorString();
    }
  };
  Autolinker2.prototype.getMatchers = function() {
    if (!this.matchers) {
      var tagBuilder = this.getTagBuilder();
      var matchers = [
        new HashtagMatcher({ tagBuilder, serviceName: this.hashtag }),
        new EmailMatcher({ tagBuilder }),
        new PhoneMatcher({ tagBuilder }),
        new MentionMatcher({ tagBuilder, serviceName: this.mention }),
        new UrlMatcher({ tagBuilder, stripPrefix: this.stripPrefix, stripTrailingSlash: this.stripTrailingSlash, decodePercentEncoding: this.decodePercentEncoding })
      ];
      return this.matchers = matchers;
    } else {
      return this.matchers;
    }
  };
  Autolinker2.prototype.getTagBuilder = function() {
    var tagBuilder = this.tagBuilder;
    if (!tagBuilder) {
      tagBuilder = this.tagBuilder = new AnchorTagBuilder({
        newWindow: this.newWindow,
        truncate: this.truncate,
        className: this.className
      });
    }
    return tagBuilder;
  };
  Autolinker2.version = "3.15.0";
  Autolinker2.AnchorTagBuilder = AnchorTagBuilder;
  Autolinker2.HtmlTag = HtmlTag;
  Autolinker2.matcher = {
    Email: EmailMatcher,
    Hashtag: HashtagMatcher,
    Matcher,
    Mention: MentionMatcher,
    Phone: PhoneMatcher,
    Url: UrlMatcher
  };
  Autolinker2.match = {
    Email: EmailMatch,
    Hashtag: HashtagMatch,
    Match,
    Mention: MentionMatch,
    Phone: PhoneMatch,
    Url: UrlMatch
  };
  return Autolinker2;
}();

// node_modules/cesium/Source/DataSources/GpxDataSource.js
var parser;
if (typeof DOMParser !== "undefined") {
  parser = new DOMParser();
}
var autolinker = new Autolinker({
  stripPrefix: false,
  email: false,
  replaceFn: function(linker, match) {
    if (!match.protocolUrlMatch) {
      return false;
    }
  }
});
var BILLBOARD_SIZE = 32;
var BILLBOARD_NEAR_DISTANCE = 2414016;
var BILLBOARD_NEAR_RATIO = 1;
var BILLBOARD_FAR_DISTANCE = 16093e3;
var BILLBOARD_FAR_RATIO = 0.1;
var gpxNamespaces = [null, void 0, "http://www.topografix.com/GPX/1/1"];
var namespaces = {
  gpx: gpxNamespaces
};
function readBlobAsText(blob) {
  const deferred = defer_default();
  const reader = new FileReader();
  reader.addEventListener("load", function() {
    deferred.resolve(reader.result);
  });
  reader.addEventListener("error", function() {
    deferred.reject(reader.error);
  });
  reader.readAsText(blob);
  return deferred.promise;
}
function getOrCreateEntity(node, entityCollection) {
  let id = queryStringAttribute(node, "id");
  id = defined_default(id) ? id : createGuid_default();
  const entity = entityCollection.getOrCreateEntity(id);
  return entity;
}
function readCoordinateFromNode(node) {
  const longitude = queryNumericAttribute(node, "lon");
  const latitude = queryNumericAttribute(node, "lat");
  const elevation = queryNumericValue(node, "ele", namespaces.gpx);
  return Cartesian3_default.fromDegrees(longitude, latitude, elevation);
}
function queryNumericAttribute(node, attributeName) {
  if (!defined_default(node)) {
    return void 0;
  }
  const value = node.getAttribute(attributeName);
  if (value !== null) {
    const result = parseFloat(value);
    return !isNaN(result) ? result : void 0;
  }
  return void 0;
}
function queryStringAttribute(node, attributeName) {
  if (!defined_default(node)) {
    return void 0;
  }
  const value = node.getAttribute(attributeName);
  return value !== null ? value : void 0;
}
function queryFirstNode(node, tagName, namespace) {
  if (!defined_default(node)) {
    return void 0;
  }
  const childNodes = node.childNodes;
  const length3 = childNodes.length;
  for (let q = 0; q < length3; q++) {
    const child = childNodes[q];
    if (child.localName === tagName && namespace.indexOf(child.namespaceURI) !== -1) {
      return child;
    }
  }
  return void 0;
}
function queryNodes(node, tagName, namespace) {
  if (!defined_default(node)) {
    return void 0;
  }
  const result = [];
  const childNodes = node.getElementsByTagName(tagName);
  const length3 = childNodes.length;
  for (let q = 0; q < length3; q++) {
    const child = childNodes[q];
    if (child.localName === tagName && namespace.indexOf(child.namespaceURI) !== -1) {
      result.push(child);
    }
  }
  return result;
}
function queryNumericValue(node, tagName, namespace) {
  const resultNode = queryFirstNode(node, tagName, namespace);
  if (defined_default(resultNode)) {
    const result = parseFloat(resultNode.textContent);
    return !isNaN(result) ? result : void 0;
  }
  return void 0;
}
function queryStringValue(node, tagName, namespace) {
  const result = queryFirstNode(node, tagName, namespace);
  if (defined_default(result)) {
    return result.textContent.trim();
  }
  return void 0;
}
function createDefaultBillboard(image) {
  const billboard = new BillboardGraphics_default();
  billboard.width = BILLBOARD_SIZE;
  billboard.height = BILLBOARD_SIZE;
  billboard.scaleByDistance = new NearFarScalar_default(
    BILLBOARD_NEAR_DISTANCE,
    BILLBOARD_NEAR_RATIO,
    BILLBOARD_FAR_DISTANCE,
    BILLBOARD_FAR_RATIO
  );
  billboard.pixelOffsetScaleByDistance = new NearFarScalar_default(
    BILLBOARD_NEAR_DISTANCE,
    BILLBOARD_NEAR_RATIO,
    BILLBOARD_FAR_DISTANCE,
    BILLBOARD_FAR_RATIO
  );
  billboard.verticalOrigin = new ConstantProperty_default(VerticalOrigin_default.BOTTOM);
  billboard.image = image;
  return billboard;
}
function createDefaultLabel() {
  const label = new LabelGraphics_default();
  label.translucencyByDistance = new NearFarScalar_default(3e6, 1, 5e6, 0);
  label.pixelOffset = new Cartesian2_default(17, 0);
  label.horizontalOrigin = HorizontalOrigin_default.LEFT;
  label.font = "16px sans-serif";
  label.style = LabelStyle_default.FILL_AND_OUTLINE;
  return label;
}
function createDefaultPolyline(color) {
  const polyline = new PolylineGraphics_default();
  polyline.width = 4;
  polyline.material = new PolylineOutlineMaterialProperty_default();
  polyline.material.color = defined_default(color) ? color : Color_default.RED;
  polyline.material.outlineWidth = 2;
  polyline.material.outlineColor = Color_default.BLACK;
  return polyline;
}
var descriptiveInfoTypes = {
  time: {
    text: "Time",
    tag: "time"
  },
  comment: {
    text: "Comment",
    tag: "cmt"
  },
  description: {
    text: "Description",
    tag: "desc"
  },
  source: {
    text: "Source",
    tag: "src"
  },
  number: {
    text: "GPS track/route number",
    tag: "number"
  },
  type: {
    text: "Type",
    tag: "type"
  }
};
var scratchDiv;
if (typeof document !== "undefined") {
  scratchDiv = document.createElement("div");
}
function processDescription2(node, entity) {
  let i2;
  let text2 = "";
  const infoTypeNames = Object.keys(descriptiveInfoTypes);
  const length3 = infoTypeNames.length;
  for (i2 = 0; i2 < length3; i2++) {
    const infoTypeName = infoTypeNames[i2];
    const infoType = descriptiveInfoTypes[infoTypeName];
    infoType.value = defaultValue_default(
      queryStringValue(node, infoType.tag, namespaces.gpx),
      ""
    );
    if (defined_default(infoType.value) && infoType.value !== "") {
      text2 = `${text2}<p>${infoType.text}: ${infoType.value}</p>`;
    }
  }
  if (!defined_default(text2) || text2 === "") {
    return;
  }
  text2 = autolinker.link(text2);
  scratchDiv.innerHTML = text2;
  const links = scratchDiv.querySelectorAll("a");
  for (i2 = 0; i2 < links.length; i2++) {
    links[i2].setAttribute("target", "_blank");
  }
  const background = Color_default.WHITE;
  const foreground = Color_default.BLACK;
  let tmp2 = '<div class="cesium-infoBox-description-lighter" style="';
  tmp2 += "overflow:auto;";
  tmp2 += "word-wrap:break-word;";
  tmp2 += `background-color:${background.toCssColorString()};`;
  tmp2 += `color:${foreground.toCssColorString()};`;
  tmp2 += '">';
  tmp2 += `${scratchDiv.innerHTML}</div>`;
  scratchDiv.innerHTML = "";
  return tmp2;
}
function processWpt(dataSource, geometryNode, entityCollection, options) {
  const position = readCoordinateFromNode(geometryNode);
  const entity = getOrCreateEntity(geometryNode, entityCollection);
  entity.position = position;
  const image = defined_default(options.waypointImage) ? options.waypointImage : dataSource._pinBuilder.fromMakiIconId(
    "marker",
    Color_default.RED,
    BILLBOARD_SIZE
  );
  entity.billboard = createDefaultBillboard(image);
  const name = queryStringValue(geometryNode, "name", namespaces.gpx);
  entity.name = name;
  entity.label = createDefaultLabel();
  entity.label.text = name;
  entity.description = processDescription2(geometryNode, entity);
  if (options.clampToGround) {
    entity.billboard.heightReference = HeightReference_default.CLAMP_TO_GROUND;
    entity.label.heightReference = HeightReference_default.CLAMP_TO_GROUND;
  }
}
function processRte(dataSource, geometryNode, entityCollection, options) {
  const entity = getOrCreateEntity(geometryNode, entityCollection);
  entity.description = processDescription2(geometryNode, entity);
  const routePoints = queryNodes(geometryNode, "rtept", namespaces.gpx);
  const coordinateTuples = new Array(routePoints.length);
  for (let i2 = 0; i2 < routePoints.length; i2++) {
    processWpt(dataSource, routePoints[i2], entityCollection, options);
    coordinateTuples[i2] = readCoordinateFromNode(routePoints[i2]);
  }
  entity.polyline = createDefaultPolyline(options.routeColor);
  if (options.clampToGround) {
    entity.polyline.clampToGround = true;
  }
  entity.polyline.positions = coordinateTuples;
}
function processTrk(dataSource, geometryNode, entityCollection, options) {
  const entity = getOrCreateEntity(geometryNode, entityCollection);
  entity.description = processDescription2(geometryNode, entity);
  const trackSegs = queryNodes(geometryNode, "trkseg", namespaces.gpx);
  let positions = [];
  let times = [];
  let trackSegInfo;
  let isTimeDynamic = true;
  const property = new SampledPositionProperty_default();
  for (let i2 = 0; i2 < trackSegs.length; i2++) {
    trackSegInfo = processTrkSeg(trackSegs[i2]);
    positions = positions.concat(trackSegInfo.positions);
    if (trackSegInfo.times.length > 0) {
      times = times.concat(trackSegInfo.times);
      property.addSamples(times, positions);
      isTimeDynamic = isTimeDynamic && true;
    } else {
      isTimeDynamic = false;
    }
  }
  if (isTimeDynamic) {
    const image = defined_default(options.waypointImage) ? options.waypointImage : dataSource._pinBuilder.fromMakiIconId(
      "marker",
      Color_default.RED,
      BILLBOARD_SIZE
    );
    entity.billboard = createDefaultBillboard(image);
    entity.position = property;
    if (options.clampToGround) {
      entity.billboard.heightReference = HeightReference_default.CLAMP_TO_GROUND;
    }
    entity.availability = new TimeIntervalCollection_default();
    entity.availability.addInterval(
      new TimeInterval_default({
        start: times[0],
        stop: times[times.length - 1]
      })
    );
  }
  entity.polyline = createDefaultPolyline(options.trackColor);
  entity.polyline.positions = positions;
  if (options.clampToGround) {
    entity.polyline.clampToGround = true;
  }
}
function processTrkSeg(node) {
  const result = {
    positions: [],
    times: []
  };
  const trackPoints = queryNodes(node, "trkpt", namespaces.gpx);
  let time;
  for (let i2 = 0; i2 < trackPoints.length; i2++) {
    const position = readCoordinateFromNode(trackPoints[i2]);
    result.positions.push(position);
    time = queryStringValue(trackPoints[i2], "time", namespaces.gpx);
    if (defined_default(time)) {
      result.times.push(JulianDate_default.fromIso8601(time));
    }
  }
  return result;
}
function processMetadata(node) {
  const metadataNode = queryFirstNode(node, "metadata", namespaces.gpx);
  if (defined_default(metadataNode)) {
    const metadata = {
      name: queryStringValue(metadataNode, "name", namespaces.gpx),
      desc: queryStringValue(metadataNode, "desc", namespaces.gpx),
      author: getPerson(metadataNode),
      copyright: getCopyright(metadataNode),
      link: getLink(metadataNode),
      time: queryStringValue(metadataNode, "time", namespaces.gpx),
      keywords: queryStringValue(metadataNode, "keywords", namespaces.gpx),
      bounds: getBounds(metadataNode)
    };
    if (defined_default(metadata.name) || defined_default(metadata.desc) || defined_default(metadata.author) || defined_default(metadata.copyright) || defined_default(metadata.link) || defined_default(metadata.time) || defined_default(metadata.keywords) || defined_default(metadata.bounds)) {
      return metadata;
    }
  }
  return void 0;
}
function getPerson(node) {
  const personNode = queryFirstNode(node, "author", namespaces.gpx);
  if (defined_default(personNode)) {
    const person = {
      name: queryStringValue(personNode, "name", namespaces.gpx),
      email: getEmail(personNode),
      link: getLink(personNode)
    };
    if (defined_default(person.name) || defined_default(person.email) || defined_default(person.link)) {
      return person;
    }
  }
  return void 0;
}
function getEmail(node) {
  const emailNode = queryFirstNode(node, "email", namespaces.gpx);
  if (defined_default(emailNode)) {
    const id = queryStringValue(emailNode, "id", namespaces.gpx);
    const domain = queryStringValue(emailNode, "domain", namespaces.gpx);
    return `${id}@${domain}`;
  }
  return void 0;
}
function getLink(node) {
  const linkNode = queryFirstNode(node, "link", namespaces.gpx);
  if (defined_default(linkNode)) {
    const link = {
      href: queryStringAttribute(linkNode, "href"),
      text: queryStringValue(linkNode, "text", namespaces.gpx),
      mimeType: queryStringValue(linkNode, "type", namespaces.gpx)
    };
    if (defined_default(link.href) || defined_default(link.text) || defined_default(link.mimeType)) {
      return link;
    }
  }
  return void 0;
}
function getCopyright(node) {
  const copyrightNode = queryFirstNode(node, "copyright", namespaces.gpx);
  if (defined_default(copyrightNode)) {
    const copyright = {
      author: queryStringAttribute(copyrightNode, "author"),
      year: queryStringValue(copyrightNode, "year", namespaces.gpx),
      license: queryStringValue(copyrightNode, "license", namespaces.gpx)
    };
    if (defined_default(copyright.author) || defined_default(copyright.year) || defined_default(copyright.license)) {
      return copyright;
    }
  }
  return void 0;
}
function getBounds(node) {
  const boundsNode = queryFirstNode(node, "bounds", namespaces.gpx);
  if (defined_default(boundsNode)) {
    const bounds = {
      minLat: queryNumericValue(boundsNode, "minlat", namespaces.gpx),
      maxLat: queryNumericValue(boundsNode, "maxlat", namespaces.gpx),
      minLon: queryNumericValue(boundsNode, "minlon", namespaces.gpx),
      maxLon: queryNumericValue(boundsNode, "maxlon", namespaces.gpx)
    };
    if (defined_default(bounds.minLat) || defined_default(bounds.maxLat) || defined_default(bounds.minLon) || defined_default(bounds.maxLon)) {
      return bounds;
    }
  }
  return void 0;
}
var complexTypes = {
  wpt: processWpt,
  rte: processRte,
  trk: processTrk
};
function processGpx(dataSource, node, entityCollection, options) {
  const complexTypeNames = Object.keys(complexTypes);
  const complexTypeNamesLength = complexTypeNames.length;
  for (let i2 = 0; i2 < complexTypeNamesLength; i2++) {
    const typeName = complexTypeNames[i2];
    const processComplexTypeNode = complexTypes[typeName];
    const childNodes = node.childNodes;
    const length3 = childNodes.length;
    for (let q = 0; q < length3; q++) {
      const child = childNodes[q];
      if (child.localName === typeName && namespaces.gpx.indexOf(child.namespaceURI) !== -1) {
        processComplexTypeNode(dataSource, child, entityCollection, options);
      }
    }
  }
}
function loadGpx(dataSource, gpx, options) {
  const entityCollection = dataSource._entityCollection;
  entityCollection.removeAll();
  const element = gpx.documentElement;
  const version = queryStringAttribute(element, "version");
  const creator = queryStringAttribute(element, "creator");
  let name;
  const metadata = processMetadata(element);
  if (defined_default(metadata)) {
    name = metadata.name;
  }
  if (element.localName === "gpx") {
    processGpx(dataSource, element, entityCollection, options);
  } else {
    console.log(`GPX - Unsupported node: ${element.localName}`);
  }
  let clock;
  const availability = entityCollection.computeAvailability();
  let start = availability.start;
  let stop2 = availability.stop;
  const isMinStart = JulianDate_default.equals(start, Iso8601_default.MINIMUM_VALUE);
  const isMaxStop = JulianDate_default.equals(stop2, Iso8601_default.MAXIMUM_VALUE);
  if (!isMinStart || !isMaxStop) {
    let date;
    if (isMinStart) {
      date = new Date();
      date.setHours(0, 0, 0, 0);
      start = JulianDate_default.fromDate(date);
    }
    if (isMaxStop) {
      date = new Date();
      date.setHours(24, 0, 0, 0);
      stop2 = JulianDate_default.fromDate(date);
    }
    clock = new DataSourceClock_default();
    clock.startTime = start;
    clock.stopTime = stop2;
    clock.currentTime = JulianDate_default.clone(start);
    clock.clockRange = ClockRange_default.LOOP_STOP;
    clock.clockStep = ClockStep_default.SYSTEM_CLOCK_MULTIPLIER;
    clock.multiplier = Math.round(
      Math.min(
        Math.max(JulianDate_default.secondsDifference(stop2, start) / 60, 1),
        31556900
      )
    );
  }
  let changed = false;
  if (dataSource._name !== name) {
    dataSource._name = name;
    changed = true;
  }
  if (dataSource._creator !== creator) {
    dataSource._creator = creator;
    changed = true;
  }
  if (metadataChanged(dataSource._metadata, metadata)) {
    dataSource._metadata = metadata;
    changed = true;
  }
  if (dataSource._version !== version) {
    dataSource._version = version;
    changed = true;
  }
  if (clock !== dataSource._clock) {
    changed = true;
    dataSource._clock = clock;
  }
  if (changed) {
    dataSource._changed.raiseEvent(dataSource);
  }
  DataSource_default.setLoading(dataSource, false);
  return dataSource;
}
function metadataChanged(old, current) {
  if (!defined_default(old) && !defined_default(current)) {
    return false;
  } else if (defined_default(old) && defined_default(current)) {
    if (old.name !== current.name || old.dec !== current.desc || old.src !== current.src || old.author !== current.author || old.copyright !== current.copyright || old.link !== current.link || old.time !== current.time || old.bounds !== current.bounds) {
      return true;
    }
    return false;
  }
  return true;
}
function load3(dataSource, entityCollection, data, options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let promise = data;
  if (typeof data === "string" || data instanceof Resource_default) {
    data = Resource_default.createIfNeeded(data);
    promise = data.fetchBlob();
    const resourceCredits = dataSource._resourceCredits;
    const credits = data.credits;
    if (defined_default(credits)) {
      const length3 = credits.length;
      for (let i2 = 0; i2 < length3; i2++) {
        resourceCredits.push(credits[i2]);
      }
    }
  }
  return Promise.resolve(promise).then(function(dataToLoad) {
    if (dataToLoad instanceof Blob) {
      return readBlobAsText(dataToLoad).then(function(text2) {
        let gpx;
        let error;
        try {
          gpx = parser.parseFromString(text2, "application/xml");
        } catch (e2) {
          error = e2.toString();
        }
        if (defined_default(error) || gpx.body || gpx.documentElement.tagName === "parsererror") {
          let msg = defined_default(error) ? error : gpx.documentElement.firstChild.nodeValue;
          if (!msg) {
            msg = gpx.body.innerText;
          }
          throw new RuntimeError_default(msg);
        }
        return loadGpx(dataSource, gpx, options);
      });
    }
    return loadGpx(dataSource, dataToLoad, options);
  }).catch(function(error) {
    dataSource._error.raiseEvent(dataSource, error);
    console.log(error);
    return Promise.reject(error);
  });
}
function GpxDataSource() {
  this._changed = new Event_default();
  this._error = new Event_default();
  this._loading = new Event_default();
  this._clock = void 0;
  this._entityCollection = new EntityCollection_default();
  this._entityCluster = new EntityCluster_default();
  this._name = void 0;
  this._version = void 0;
  this._creator = void 0;
  this._metadata = void 0;
  this._isLoading = false;
  this._pinBuilder = new PinBuilder_default();
}
GpxDataSource.load = function(data, options) {
  return new GpxDataSource().load(data, options);
};
Object.defineProperties(GpxDataSource.prototype, {
  name: {
    get: function() {
      return this._name;
    }
  },
  version: {
    get: function() {
      return this._version;
    }
  },
  creator: {
    get: function() {
      return this._creator;
    }
  },
  metadata: {
    get: function() {
      return this._metadata;
    }
  },
  clock: {
    get: function() {
      return this._clock;
    }
  },
  entities: {
    get: function() {
      return this._entityCollection;
    }
  },
  isLoading: {
    get: function() {
      return this._isLoading;
    }
  },
  changedEvent: {
    get: function() {
      return this._changed;
    }
  },
  errorEvent: {
    get: function() {
      return this._error;
    }
  },
  loadingEvent: {
    get: function() {
      return this._loading;
    }
  },
  show: {
    get: function() {
      return this._entityCollection.show;
    },
    set: function(value) {
      this._entityCollection.show = value;
    }
  },
  clustering: {
    get: function() {
      return this._entityCluster;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value must be defined.");
      }
      this._entityCluster = value;
    }
  }
});
GpxDataSource.prototype.update = function(time) {
  return true;
};
GpxDataSource.prototype.load = function(data, options) {
  if (!defined_default(data)) {
    throw new DeveloperError_default("data is required.");
  }
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  DataSource_default.setLoading(this, true);
  const oldName = this._name;
  const that = this;
  return load3(this, this._entityCollection, data, options).then(function() {
    let clock;
    const availability = that._entityCollection.computeAvailability();
    let start = availability.start;
    let stop2 = availability.stop;
    const isMinStart = JulianDate_default.equals(start, Iso8601_default.MINIMUM_VALUE);
    const isMaxStop = JulianDate_default.equals(stop2, Iso8601_default.MAXIMUM_VALUE);
    if (!isMinStart || !isMaxStop) {
      let date;
      if (isMinStart) {
        date = new Date();
        date.setHours(0, 0, 0, 0);
        start = JulianDate_default.fromDate(date);
      }
      if (isMaxStop) {
        date = new Date();
        date.setHours(24, 0, 0, 0);
        stop2 = JulianDate_default.fromDate(date);
      }
      clock = new DataSourceClock_default();
      clock.startTime = start;
      clock.stopTime = stop2;
      clock.currentTime = JulianDate_default.clone(start);
      clock.clockRange = ClockRange_default.LOOP_STOP;
      clock.clockStep = ClockStep_default.SYSTEM_CLOCK_MULTIPLIER;
      clock.multiplier = Math.round(
        Math.min(
          Math.max(JulianDate_default.secondsDifference(stop2, start) / 60, 1),
          31556900
        )
      );
    }
    let changed = false;
    if (clock !== that._clock) {
      that._clock = clock;
      changed = true;
    }
    if (oldName !== that._name) {
      changed = true;
    }
    if (changed) {
      that._changed.raiseEvent(that);
    }
    DataSource_default.setLoading(that, false);
    return that;
  }).catch(function(error) {
    DataSource_default.setLoading(that, false);
    that._error.raiseEvent(that, error);
    console.log(error);
    return Promise.reject(error);
  });
};
var GpxDataSource_default = GpxDataSource;

// node_modules/cesium/Source/DataSources/KmlCamera.js
function KmlCamera(position, headingPitchRoll) {
  this.position = position;
  this.headingPitchRoll = headingPitchRoll;
}
var KmlCamera_default = KmlCamera;

// node_modules/cesium/Source/ThirdParty/zip.js
var MAX_BITS$1 = 15;
var D_CODES = 30;
var BL_CODES = 19;
var LENGTH_CODES = 29;
var LITERALS = 256;
var L_CODES = LITERALS + 1 + LENGTH_CODES;
var HEAP_SIZE = 2 * L_CODES + 1;
var END_BLOCK = 256;
var MAX_BL_BITS = 7;
var REP_3_6 = 16;
var REPZ_3_10 = 17;
var REPZ_11_138 = 18;
var Buf_size = 8 * 2;
var Z_DEFAULT_COMPRESSION = -1;
var Z_FILTERED = 1;
var Z_HUFFMAN_ONLY = 2;
var Z_DEFAULT_STRATEGY = 0;
var Z_NO_FLUSH$1 = 0;
var Z_PARTIAL_FLUSH = 1;
var Z_FULL_FLUSH = 3;
var Z_FINISH$1 = 4;
var Z_OK$1 = 0;
var Z_STREAM_END$1 = 1;
var Z_NEED_DICT$1 = 2;
var Z_STREAM_ERROR$1 = -2;
var Z_DATA_ERROR$1 = -3;
var Z_BUF_ERROR$1 = -5;
function extractArray(array) {
  return flatArray(array.map(([length3, value]) => new Array(length3).fill(value, 0, length3)));
}
function flatArray(array) {
  return array.reduce((a4, b) => a4.concat(Array.isArray(b) ? flatArray(b) : b), []);
}
var _dist_code = [0, 1, 2, 3].concat(...extractArray([
  [2, 4],
  [2, 5],
  [4, 6],
  [4, 7],
  [8, 8],
  [8, 9],
  [16, 10],
  [16, 11],
  [32, 12],
  [32, 13],
  [64, 14],
  [64, 15],
  [2, 0],
  [1, 16],
  [1, 17],
  [2, 18],
  [2, 19],
  [4, 20],
  [4, 21],
  [8, 22],
  [8, 23],
  [16, 24],
  [16, 25],
  [32, 26],
  [32, 27],
  [64, 28],
  [64, 29]
]));
function Tree() {
  const that = this;
  function gen_bitlen(s2) {
    const tree = that.dyn_tree;
    const stree = that.stat_desc.static_tree;
    const extra = that.stat_desc.extra_bits;
    const base = that.stat_desc.extra_base;
    const max_length = that.stat_desc.max_length;
    let h;
    let n2, m;
    let bits;
    let xbits;
    let f2;
    let overflow = 0;
    for (bits = 0; bits <= MAX_BITS$1; bits++)
      s2.bl_count[bits] = 0;
    tree[s2.heap[s2.heap_max] * 2 + 1] = 0;
    for (h = s2.heap_max + 1; h < HEAP_SIZE; h++) {
      n2 = s2.heap[h];
      bits = tree[tree[n2 * 2 + 1] * 2 + 1] + 1;
      if (bits > max_length) {
        bits = max_length;
        overflow++;
      }
      tree[n2 * 2 + 1] = bits;
      if (n2 > that.max_code)
        continue;
      s2.bl_count[bits]++;
      xbits = 0;
      if (n2 >= base)
        xbits = extra[n2 - base];
      f2 = tree[n2 * 2];
      s2.opt_len += f2 * (bits + xbits);
      if (stree)
        s2.static_len += f2 * (stree[n2 * 2 + 1] + xbits);
    }
    if (overflow === 0)
      return;
    do {
      bits = max_length - 1;
      while (s2.bl_count[bits] === 0)
        bits--;
      s2.bl_count[bits]--;
      s2.bl_count[bits + 1] += 2;
      s2.bl_count[max_length]--;
      overflow -= 2;
    } while (overflow > 0);
    for (bits = max_length; bits !== 0; bits--) {
      n2 = s2.bl_count[bits];
      while (n2 !== 0) {
        m = s2.heap[--h];
        if (m > that.max_code)
          continue;
        if (tree[m * 2 + 1] != bits) {
          s2.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
          tree[m * 2 + 1] = bits;
        }
        n2--;
      }
    }
  }
  function bi_reverse(code, len) {
    let res = 0;
    do {
      res |= code & 1;
      code >>>= 1;
      res <<= 1;
    } while (--len > 0);
    return res >>> 1;
  }
  function gen_codes(tree, max_code, bl_count) {
    const next_code = [];
    let code = 0;
    let bits;
    let n2;
    let len;
    for (bits = 1; bits <= MAX_BITS$1; bits++) {
      next_code[bits] = code = code + bl_count[bits - 1] << 1;
    }
    for (n2 = 0; n2 <= max_code; n2++) {
      len = tree[n2 * 2 + 1];
      if (len === 0)
        continue;
      tree[n2 * 2] = bi_reverse(next_code[len]++, len);
    }
  }
  that.build_tree = function(s2) {
    const tree = that.dyn_tree;
    const stree = that.stat_desc.static_tree;
    const elems = that.stat_desc.elems;
    let n2, m;
    let max_code = -1;
    let node;
    s2.heap_len = 0;
    s2.heap_max = HEAP_SIZE;
    for (n2 = 0; n2 < elems; n2++) {
      if (tree[n2 * 2] !== 0) {
        s2.heap[++s2.heap_len] = max_code = n2;
        s2.depth[n2] = 0;
      } else {
        tree[n2 * 2 + 1] = 0;
      }
    }
    while (s2.heap_len < 2) {
      node = s2.heap[++s2.heap_len] = max_code < 2 ? ++max_code : 0;
      tree[node * 2] = 1;
      s2.depth[node] = 0;
      s2.opt_len--;
      if (stree)
        s2.static_len -= stree[node * 2 + 1];
    }
    that.max_code = max_code;
    for (n2 = Math.floor(s2.heap_len / 2); n2 >= 1; n2--)
      s2.pqdownheap(tree, n2);
    node = elems;
    do {
      n2 = s2.heap[1];
      s2.heap[1] = s2.heap[s2.heap_len--];
      s2.pqdownheap(tree, 1);
      m = s2.heap[1];
      s2.heap[--s2.heap_max] = n2;
      s2.heap[--s2.heap_max] = m;
      tree[node * 2] = tree[n2 * 2] + tree[m * 2];
      s2.depth[node] = Math.max(s2.depth[n2], s2.depth[m]) + 1;
      tree[n2 * 2 + 1] = tree[m * 2 + 1] = node;
      s2.heap[1] = node++;
      s2.pqdownheap(tree, 1);
    } while (s2.heap_len >= 2);
    s2.heap[--s2.heap_max] = s2.heap[1];
    gen_bitlen(s2);
    gen_codes(tree, that.max_code, s2.bl_count);
  };
}
Tree._length_code = [0, 1, 2, 3, 4, 5, 6, 7].concat(...extractArray([
  [2, 8],
  [2, 9],
  [2, 10],
  [2, 11],
  [4, 12],
  [4, 13],
  [4, 14],
  [4, 15],
  [8, 16],
  [8, 17],
  [8, 18],
  [8, 19],
  [16, 20],
  [16, 21],
  [16, 22],
  [16, 23],
  [32, 24],
  [32, 25],
  [32, 26],
  [31, 27],
  [1, 28]
]));
Tree.base_length = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0];
Tree.base_dist = [
  0,
  1,
  2,
  3,
  4,
  6,
  8,
  12,
  16,
  24,
  32,
  48,
  64,
  96,
  128,
  192,
  256,
  384,
  512,
  768,
  1024,
  1536,
  2048,
  3072,
  4096,
  6144,
  8192,
  12288,
  16384,
  24576
];
Tree.d_code = function(dist) {
  return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
};
Tree.extra_lbits = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
Tree.extra_dbits = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
Tree.extra_blbits = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7];
Tree.bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
function StaticTree(static_tree, extra_bits, extra_base, elems, max_length) {
  const that = this;
  that.static_tree = static_tree;
  that.extra_bits = extra_bits;
  that.extra_base = extra_base;
  that.elems = elems;
  that.max_length = max_length;
}
var static_ltree2_first_part = [
  12,
  140,
  76,
  204,
  44,
  172,
  108,
  236,
  28,
  156,
  92,
  220,
  60,
  188,
  124,
  252,
  2,
  130,
  66,
  194,
  34,
  162,
  98,
  226,
  18,
  146,
  82,
  210,
  50,
  178,
  114,
  242,
  10,
  138,
  74,
  202,
  42,
  170,
  106,
  234,
  26,
  154,
  90,
  218,
  58,
  186,
  122,
  250,
  6,
  134,
  70,
  198,
  38,
  166,
  102,
  230,
  22,
  150,
  86,
  214,
  54,
  182,
  118,
  246,
  14,
  142,
  78,
  206,
  46,
  174,
  110,
  238,
  30,
  158,
  94,
  222,
  62,
  190,
  126,
  254,
  1,
  129,
  65,
  193,
  33,
  161,
  97,
  225,
  17,
  145,
  81,
  209,
  49,
  177,
  113,
  241,
  9,
  137,
  73,
  201,
  41,
  169,
  105,
  233,
  25,
  153,
  89,
  217,
  57,
  185,
  121,
  249,
  5,
  133,
  69,
  197,
  37,
  165,
  101,
  229,
  21,
  149,
  85,
  213,
  53,
  181,
  117,
  245,
  13,
  141,
  77,
  205,
  45,
  173,
  109,
  237,
  29,
  157,
  93,
  221,
  61,
  189,
  125,
  253,
  19,
  275,
  147,
  403,
  83,
  339,
  211,
  467,
  51,
  307,
  179,
  435,
  115,
  371,
  243,
  499,
  11,
  267,
  139,
  395,
  75,
  331,
  203,
  459,
  43,
  299,
  171,
  427,
  107,
  363,
  235,
  491,
  27,
  283,
  155,
  411,
  91,
  347,
  219,
  475,
  59,
  315,
  187,
  443,
  123,
  379,
  251,
  507,
  7,
  263,
  135,
  391,
  71,
  327,
  199,
  455,
  39,
  295,
  167,
  423,
  103,
  359,
  231,
  487,
  23,
  279,
  151,
  407,
  87,
  343,
  215,
  471,
  55,
  311,
  183,
  439,
  119,
  375,
  247,
  503,
  15,
  271,
  143,
  399,
  79,
  335,
  207,
  463,
  47,
  303,
  175,
  431,
  111,
  367,
  239,
  495,
  31,
  287,
  159,
  415,
  95,
  351,
  223,
  479,
  63,
  319,
  191,
  447,
  127,
  383,
  255,
  511,
  0,
  64,
  32,
  96,
  16,
  80,
  48,
  112,
  8,
  72,
  40,
  104,
  24,
  88,
  56,
  120,
  4,
  68,
  36,
  100,
  20,
  84,
  52,
  116,
  3,
  131,
  67,
  195,
  35,
  163,
  99,
  227
];
var static_ltree2_second_part = extractArray([[144, 8], [112, 9], [24, 7], [8, 8]]);
StaticTree.static_ltree = flatArray(static_ltree2_first_part.map((value, index2) => [value, static_ltree2_second_part[index2]]));
var static_dtree_first_part = [0, 16, 8, 24, 4, 20, 12, 28, 2, 18, 10, 26, 6, 22, 14, 30, 1, 17, 9, 25, 5, 21, 13, 29, 3, 19, 11, 27, 7, 23];
var static_dtree_second_part = extractArray([[30, 5]]);
StaticTree.static_dtree = flatArray(static_dtree_first_part.map((value, index2) => [value, static_dtree_second_part[index2]]));
StaticTree.static_l_desc = new StaticTree(StaticTree.static_ltree, Tree.extra_lbits, LITERALS + 1, L_CODES, MAX_BITS$1);
StaticTree.static_d_desc = new StaticTree(StaticTree.static_dtree, Tree.extra_dbits, 0, D_CODES, MAX_BITS$1);
StaticTree.static_bl_desc = new StaticTree(null, Tree.extra_blbits, 0, BL_CODES, MAX_BL_BITS);
var MAX_MEM_LEVEL = 9;
var DEF_MEM_LEVEL = 8;
function Config(good_length, max_lazy, nice_length, max_chain, func) {
  const that = this;
  that.good_length = good_length;
  that.max_lazy = max_lazy;
  that.nice_length = nice_length;
  that.max_chain = max_chain;
  that.func = func;
}
var STORED$1 = 0;
var FAST = 1;
var SLOW = 2;
var config_table = [
  new Config(0, 0, 0, 0, STORED$1),
  new Config(4, 4, 8, 4, FAST),
  new Config(4, 5, 16, 8, FAST),
  new Config(4, 6, 32, 32, FAST),
  new Config(4, 4, 16, 16, SLOW),
  new Config(8, 16, 32, 32, SLOW),
  new Config(8, 16, 128, 128, SLOW),
  new Config(8, 32, 128, 256, SLOW),
  new Config(32, 128, 258, 1024, SLOW),
  new Config(32, 258, 258, 4096, SLOW)
];
var z_errmsg = [
  "need dictionary",
  "stream end",
  "",
  "",
  "stream error",
  "data error",
  "",
  "buffer error",
  "",
  ""
];
var NeedMore = 0;
var BlockDone = 1;
var FinishStarted = 2;
var FinishDone = 3;
var PRESET_DICT$1 = 32;
var INIT_STATE = 42;
var BUSY_STATE = 113;
var FINISH_STATE = 666;
var Z_DEFLATED$1 = 8;
var STORED_BLOCK = 0;
var STATIC_TREES = 1;
var DYN_TREES = 2;
var MIN_MATCH = 3;
var MAX_MATCH = 258;
var MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;
function smaller(tree, n2, m, depth) {
  const tn2 = tree[n2 * 2];
  const tm2 = tree[m * 2];
  return tn2 < tm2 || tn2 == tm2 && depth[n2] <= depth[m];
}
function Deflate$1() {
  const that = this;
  let strm;
  let status;
  let pending_buf_size;
  let last_flush;
  let w_size;
  let w_bits;
  let w_mask;
  let win;
  let window_size;
  let prev;
  let head;
  let ins_h;
  let hash_size;
  let hash_bits;
  let hash_mask;
  let hash_shift;
  let block_start;
  let match_length;
  let prev_match;
  let match_available;
  let strstart;
  let match_start;
  let lookahead;
  let prev_length;
  let max_chain_length;
  let max_lazy_match;
  let level;
  let strategy;
  let good_match;
  let nice_match;
  let dyn_ltree;
  let dyn_dtree;
  let bl_tree;
  const l_desc = new Tree();
  const d_desc = new Tree();
  const bl_desc = new Tree();
  that.depth = [];
  let lit_bufsize;
  let last_lit;
  let matches;
  let last_eob_len;
  let bi_buf;
  let bi_valid;
  that.bl_count = [];
  that.heap = [];
  dyn_ltree = [];
  dyn_dtree = [];
  bl_tree = [];
  function lm_init() {
    window_size = 2 * w_size;
    head[hash_size - 1] = 0;
    for (let i2 = 0; i2 < hash_size - 1; i2++) {
      head[i2] = 0;
    }
    max_lazy_match = config_table[level].max_lazy;
    good_match = config_table[level].good_length;
    nice_match = config_table[level].nice_length;
    max_chain_length = config_table[level].max_chain;
    strstart = 0;
    block_start = 0;
    lookahead = 0;
    match_length = prev_length = MIN_MATCH - 1;
    match_available = 0;
    ins_h = 0;
  }
  function init_block() {
    let i2;
    for (i2 = 0; i2 < L_CODES; i2++)
      dyn_ltree[i2 * 2] = 0;
    for (i2 = 0; i2 < D_CODES; i2++)
      dyn_dtree[i2 * 2] = 0;
    for (i2 = 0; i2 < BL_CODES; i2++)
      bl_tree[i2 * 2] = 0;
    dyn_ltree[END_BLOCK * 2] = 1;
    that.opt_len = that.static_len = 0;
    last_lit = matches = 0;
  }
  function tr_init() {
    l_desc.dyn_tree = dyn_ltree;
    l_desc.stat_desc = StaticTree.static_l_desc;
    d_desc.dyn_tree = dyn_dtree;
    d_desc.stat_desc = StaticTree.static_d_desc;
    bl_desc.dyn_tree = bl_tree;
    bl_desc.stat_desc = StaticTree.static_bl_desc;
    bi_buf = 0;
    bi_valid = 0;
    last_eob_len = 8;
    init_block();
  }
  that.pqdownheap = function(tree, k) {
    const heap = that.heap;
    const v7 = heap[k];
    let j = k << 1;
    while (j <= that.heap_len) {
      if (j < that.heap_len && smaller(tree, heap[j + 1], heap[j], that.depth)) {
        j++;
      }
      if (smaller(tree, v7, heap[j], that.depth))
        break;
      heap[k] = heap[j];
      k = j;
      j <<= 1;
    }
    heap[k] = v7;
  };
  function scan_tree(tree, max_code) {
    let prevlen = -1;
    let curlen;
    let nextlen = tree[0 * 2 + 1];
    let count = 0;
    let max_count = 7;
    let min_count = 4;
    if (nextlen === 0) {
      max_count = 138;
      min_count = 3;
    }
    tree[(max_code + 1) * 2 + 1] = 65535;
    for (let n2 = 0; n2 <= max_code; n2++) {
      curlen = nextlen;
      nextlen = tree[(n2 + 1) * 2 + 1];
      if (++count < max_count && curlen == nextlen) {
        continue;
      } else if (count < min_count) {
        bl_tree[curlen * 2] += count;
      } else if (curlen !== 0) {
        if (curlen != prevlen)
          bl_tree[curlen * 2]++;
        bl_tree[REP_3_6 * 2]++;
      } else if (count <= 10) {
        bl_tree[REPZ_3_10 * 2]++;
      } else {
        bl_tree[REPZ_11_138 * 2]++;
      }
      count = 0;
      prevlen = curlen;
      if (nextlen === 0) {
        max_count = 138;
        min_count = 3;
      } else if (curlen == nextlen) {
        max_count = 6;
        min_count = 3;
      } else {
        max_count = 7;
        min_count = 4;
      }
    }
  }
  function build_bl_tree() {
    let max_blindex;
    scan_tree(dyn_ltree, l_desc.max_code);
    scan_tree(dyn_dtree, d_desc.max_code);
    bl_desc.build_tree(that);
    for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
      if (bl_tree[Tree.bl_order[max_blindex] * 2 + 1] !== 0)
        break;
    }
    that.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
    return max_blindex;
  }
  function put_byte(p2) {
    that.pending_buf[that.pending++] = p2;
  }
  function put_short(w) {
    put_byte(w & 255);
    put_byte(w >>> 8 & 255);
  }
  function putShortMSB(b) {
    put_byte(b >> 8 & 255);
    put_byte(b & 255 & 255);
  }
  function send_bits(value, length3) {
    let val;
    const len = length3;
    if (bi_valid > Buf_size - len) {
      val = value;
      bi_buf |= val << bi_valid & 65535;
      put_short(bi_buf);
      bi_buf = val >>> Buf_size - bi_valid;
      bi_valid += len - Buf_size;
    } else {
      bi_buf |= value << bi_valid & 65535;
      bi_valid += len;
    }
  }
  function send_code(c14, tree) {
    const c22 = c14 * 2;
    send_bits(tree[c22] & 65535, tree[c22 + 1] & 65535);
  }
  function send_tree(tree, max_code) {
    let n2;
    let prevlen = -1;
    let curlen;
    let nextlen = tree[0 * 2 + 1];
    let count = 0;
    let max_count = 7;
    let min_count = 4;
    if (nextlen === 0) {
      max_count = 138;
      min_count = 3;
    }
    for (n2 = 0; n2 <= max_code; n2++) {
      curlen = nextlen;
      nextlen = tree[(n2 + 1) * 2 + 1];
      if (++count < max_count && curlen == nextlen) {
        continue;
      } else if (count < min_count) {
        do {
          send_code(curlen, bl_tree);
        } while (--count !== 0);
      } else if (curlen !== 0) {
        if (curlen != prevlen) {
          send_code(curlen, bl_tree);
          count--;
        }
        send_code(REP_3_6, bl_tree);
        send_bits(count - 3, 2);
      } else if (count <= 10) {
        send_code(REPZ_3_10, bl_tree);
        send_bits(count - 3, 3);
      } else {
        send_code(REPZ_11_138, bl_tree);
        send_bits(count - 11, 7);
      }
      count = 0;
      prevlen = curlen;
      if (nextlen === 0) {
        max_count = 138;
        min_count = 3;
      } else if (curlen == nextlen) {
        max_count = 6;
        min_count = 3;
      } else {
        max_count = 7;
        min_count = 4;
      }
    }
  }
  function send_all_trees(lcodes, dcodes, blcodes) {
    let rank;
    send_bits(lcodes - 257, 5);
    send_bits(dcodes - 1, 5);
    send_bits(blcodes - 4, 4);
    for (rank = 0; rank < blcodes; rank++) {
      send_bits(bl_tree[Tree.bl_order[rank] * 2 + 1], 3);
    }
    send_tree(dyn_ltree, lcodes - 1);
    send_tree(dyn_dtree, dcodes - 1);
  }
  function bi_flush() {
    if (bi_valid == 16) {
      put_short(bi_buf);
      bi_buf = 0;
      bi_valid = 0;
    } else if (bi_valid >= 8) {
      put_byte(bi_buf & 255);
      bi_buf >>>= 8;
      bi_valid -= 8;
    }
  }
  function _tr_align() {
    send_bits(STATIC_TREES << 1, 3);
    send_code(END_BLOCK, StaticTree.static_ltree);
    bi_flush();
    if (1 + last_eob_len + 10 - bi_valid < 9) {
      send_bits(STATIC_TREES << 1, 3);
      send_code(END_BLOCK, StaticTree.static_ltree);
      bi_flush();
    }
    last_eob_len = 7;
  }
  function _tr_tally(dist, lc) {
    let out_length, in_length, dcode;
    that.dist_buf[last_lit] = dist;
    that.lc_buf[last_lit] = lc & 255;
    last_lit++;
    if (dist === 0) {
      dyn_ltree[lc * 2]++;
    } else {
      matches++;
      dist--;
      dyn_ltree[(Tree._length_code[lc] + LITERALS + 1) * 2]++;
      dyn_dtree[Tree.d_code(dist) * 2]++;
    }
    if ((last_lit & 8191) === 0 && level > 2) {
      out_length = last_lit * 8;
      in_length = strstart - block_start;
      for (dcode = 0; dcode < D_CODES; dcode++) {
        out_length += dyn_dtree[dcode * 2] * (5 + Tree.extra_dbits[dcode]);
      }
      out_length >>>= 3;
      if (matches < Math.floor(last_lit / 2) && out_length < Math.floor(in_length / 2))
        return true;
    }
    return last_lit == lit_bufsize - 1;
  }
  function compress_block(ltree, dtree) {
    let dist;
    let lc;
    let lx = 0;
    let code;
    let extra;
    if (last_lit !== 0) {
      do {
        dist = that.dist_buf[lx];
        lc = that.lc_buf[lx];
        lx++;
        if (dist === 0) {
          send_code(lc, ltree);
        } else {
          code = Tree._length_code[lc];
          send_code(code + LITERALS + 1, ltree);
          extra = Tree.extra_lbits[code];
          if (extra !== 0) {
            lc -= Tree.base_length[code];
            send_bits(lc, extra);
          }
          dist--;
          code = Tree.d_code(dist);
          send_code(code, dtree);
          extra = Tree.extra_dbits[code];
          if (extra !== 0) {
            dist -= Tree.base_dist[code];
            send_bits(dist, extra);
          }
        }
      } while (lx < last_lit);
    }
    send_code(END_BLOCK, ltree);
    last_eob_len = ltree[END_BLOCK * 2 + 1];
  }
  function bi_windup() {
    if (bi_valid > 8) {
      put_short(bi_buf);
    } else if (bi_valid > 0) {
      put_byte(bi_buf & 255);
    }
    bi_buf = 0;
    bi_valid = 0;
  }
  function copy_block(buf, len, header) {
    bi_windup();
    last_eob_len = 8;
    if (header) {
      put_short(len);
      put_short(~len);
    }
    that.pending_buf.set(win.subarray(buf, buf + len), that.pending);
    that.pending += len;
  }
  function _tr_stored_block(buf, stored_len, eof) {
    send_bits((STORED_BLOCK << 1) + (eof ? 1 : 0), 3);
    copy_block(buf, stored_len, true);
  }
  function _tr_flush_block(buf, stored_len, eof) {
    let opt_lenb, static_lenb;
    let max_blindex = 0;
    if (level > 0) {
      l_desc.build_tree(that);
      d_desc.build_tree(that);
      max_blindex = build_bl_tree();
      opt_lenb = that.opt_len + 3 + 7 >>> 3;
      static_lenb = that.static_len + 3 + 7 >>> 3;
      if (static_lenb <= opt_lenb)
        opt_lenb = static_lenb;
    } else {
      opt_lenb = static_lenb = stored_len + 5;
    }
    if (stored_len + 4 <= opt_lenb && buf != -1) {
      _tr_stored_block(buf, stored_len, eof);
    } else if (static_lenb == opt_lenb) {
      send_bits((STATIC_TREES << 1) + (eof ? 1 : 0), 3);
      compress_block(StaticTree.static_ltree, StaticTree.static_dtree);
    } else {
      send_bits((DYN_TREES << 1) + (eof ? 1 : 0), 3);
      send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1, max_blindex + 1);
      compress_block(dyn_ltree, dyn_dtree);
    }
    init_block();
    if (eof) {
      bi_windup();
    }
  }
  function flush_block_only(eof) {
    _tr_flush_block(block_start >= 0 ? block_start : -1, strstart - block_start, eof);
    block_start = strstart;
    strm.flush_pending();
  }
  function fill_window() {
    let n2, m;
    let p2;
    let more;
    do {
      more = window_size - lookahead - strstart;
      if (more === 0 && strstart === 0 && lookahead === 0) {
        more = w_size;
      } else if (more == -1) {
        more--;
      } else if (strstart >= w_size + w_size - MIN_LOOKAHEAD) {
        win.set(win.subarray(w_size, w_size + w_size), 0);
        match_start -= w_size;
        strstart -= w_size;
        block_start -= w_size;
        n2 = hash_size;
        p2 = n2;
        do {
          m = head[--p2] & 65535;
          head[p2] = m >= w_size ? m - w_size : 0;
        } while (--n2 !== 0);
        n2 = w_size;
        p2 = n2;
        do {
          m = prev[--p2] & 65535;
          prev[p2] = m >= w_size ? m - w_size : 0;
        } while (--n2 !== 0);
        more += w_size;
      }
      if (strm.avail_in === 0)
        return;
      n2 = strm.read_buf(win, strstart + lookahead, more);
      lookahead += n2;
      if (lookahead >= MIN_MATCH) {
        ins_h = win[strstart] & 255;
        ins_h = (ins_h << hash_shift ^ win[strstart + 1] & 255) & hash_mask;
      }
    } while (lookahead < MIN_LOOKAHEAD && strm.avail_in !== 0);
  }
  function deflate_stored(flush) {
    let max_block_size = 65535;
    let max_start;
    if (max_block_size > pending_buf_size - 5) {
      max_block_size = pending_buf_size - 5;
    }
    while (true) {
      if (lookahead <= 1) {
        fill_window();
        if (lookahead === 0 && flush == Z_NO_FLUSH$1)
          return NeedMore;
        if (lookahead === 0)
          break;
      }
      strstart += lookahead;
      lookahead = 0;
      max_start = block_start + max_block_size;
      if (strstart === 0 || strstart >= max_start) {
        lookahead = strstart - max_start;
        strstart = max_start;
        flush_block_only(false);
        if (strm.avail_out === 0)
          return NeedMore;
      }
      if (strstart - block_start >= w_size - MIN_LOOKAHEAD) {
        flush_block_only(false);
        if (strm.avail_out === 0)
          return NeedMore;
      }
    }
    flush_block_only(flush == Z_FINISH$1);
    if (strm.avail_out === 0)
      return flush == Z_FINISH$1 ? FinishStarted : NeedMore;
    return flush == Z_FINISH$1 ? FinishDone : BlockDone;
  }
  function longest_match(cur_match) {
    let chain_length = max_chain_length;
    let scan = strstart;
    let match;
    let len;
    let best_len = prev_length;
    const limit = strstart > w_size - MIN_LOOKAHEAD ? strstart - (w_size - MIN_LOOKAHEAD) : 0;
    let _nice_match = nice_match;
    const wmask = w_mask;
    const strend = strstart + MAX_MATCH;
    let scan_end1 = win[scan + best_len - 1];
    let scan_end = win[scan + best_len];
    if (prev_length >= good_match) {
      chain_length >>= 2;
    }
    if (_nice_match > lookahead)
      _nice_match = lookahead;
    do {
      match = cur_match;
      if (win[match + best_len] != scan_end || win[match + best_len - 1] != scan_end1 || win[match] != win[scan] || win[++match] != win[scan + 1])
        continue;
      scan += 2;
      match++;
      do {
      } while (win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && scan < strend);
      len = MAX_MATCH - (strend - scan);
      scan = strend - MAX_MATCH;
      if (len > best_len) {
        match_start = cur_match;
        best_len = len;
        if (len >= _nice_match)
          break;
        scan_end1 = win[scan + best_len - 1];
        scan_end = win[scan + best_len];
      }
    } while ((cur_match = prev[cur_match & wmask] & 65535) > limit && --chain_length !== 0);
    if (best_len <= lookahead)
      return best_len;
    return lookahead;
  }
  function deflate_fast(flush) {
    let hash_head = 0;
    let bflush;
    while (true) {
      if (lookahead < MIN_LOOKAHEAD) {
        fill_window();
        if (lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH$1) {
          return NeedMore;
        }
        if (lookahead === 0)
          break;
      }
      if (lookahead >= MIN_MATCH) {
        ins_h = (ins_h << hash_shift ^ win[strstart + (MIN_MATCH - 1)] & 255) & hash_mask;
        hash_head = head[ins_h] & 65535;
        prev[strstart & w_mask] = head[ins_h];
        head[ins_h] = strstart;
      }
      if (hash_head !== 0 && (strstart - hash_head & 65535) <= w_size - MIN_LOOKAHEAD) {
        if (strategy != Z_HUFFMAN_ONLY) {
          match_length = longest_match(hash_head);
        }
      }
      if (match_length >= MIN_MATCH) {
        bflush = _tr_tally(strstart - match_start, match_length - MIN_MATCH);
        lookahead -= match_length;
        if (match_length <= max_lazy_match && lookahead >= MIN_MATCH) {
          match_length--;
          do {
            strstart++;
            ins_h = (ins_h << hash_shift ^ win[strstart + (MIN_MATCH - 1)] & 255) & hash_mask;
            hash_head = head[ins_h] & 65535;
            prev[strstart & w_mask] = head[ins_h];
            head[ins_h] = strstart;
          } while (--match_length !== 0);
          strstart++;
        } else {
          strstart += match_length;
          match_length = 0;
          ins_h = win[strstart] & 255;
          ins_h = (ins_h << hash_shift ^ win[strstart + 1] & 255) & hash_mask;
        }
      } else {
        bflush = _tr_tally(0, win[strstart] & 255);
        lookahead--;
        strstart++;
      }
      if (bflush) {
        flush_block_only(false);
        if (strm.avail_out === 0)
          return NeedMore;
      }
    }
    flush_block_only(flush == Z_FINISH$1);
    if (strm.avail_out === 0) {
      if (flush == Z_FINISH$1)
        return FinishStarted;
      else
        return NeedMore;
    }
    return flush == Z_FINISH$1 ? FinishDone : BlockDone;
  }
  function deflate_slow(flush) {
    let hash_head = 0;
    let bflush;
    let max_insert;
    while (true) {
      if (lookahead < MIN_LOOKAHEAD) {
        fill_window();
        if (lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH$1) {
          return NeedMore;
        }
        if (lookahead === 0)
          break;
      }
      if (lookahead >= MIN_MATCH) {
        ins_h = (ins_h << hash_shift ^ win[strstart + (MIN_MATCH - 1)] & 255) & hash_mask;
        hash_head = head[ins_h] & 65535;
        prev[strstart & w_mask] = head[ins_h];
        head[ins_h] = strstart;
      }
      prev_length = match_length;
      prev_match = match_start;
      match_length = MIN_MATCH - 1;
      if (hash_head !== 0 && prev_length < max_lazy_match && (strstart - hash_head & 65535) <= w_size - MIN_LOOKAHEAD) {
        if (strategy != Z_HUFFMAN_ONLY) {
          match_length = longest_match(hash_head);
        }
        if (match_length <= 5 && (strategy == Z_FILTERED || match_length == MIN_MATCH && strstart - match_start > 4096)) {
          match_length = MIN_MATCH - 1;
        }
      }
      if (prev_length >= MIN_MATCH && match_length <= prev_length) {
        max_insert = strstart + lookahead - MIN_MATCH;
        bflush = _tr_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
        lookahead -= prev_length - 1;
        prev_length -= 2;
        do {
          if (++strstart <= max_insert) {
            ins_h = (ins_h << hash_shift ^ win[strstart + (MIN_MATCH - 1)] & 255) & hash_mask;
            hash_head = head[ins_h] & 65535;
            prev[strstart & w_mask] = head[ins_h];
            head[ins_h] = strstart;
          }
        } while (--prev_length !== 0);
        match_available = 0;
        match_length = MIN_MATCH - 1;
        strstart++;
        if (bflush) {
          flush_block_only(false);
          if (strm.avail_out === 0)
            return NeedMore;
        }
      } else if (match_available !== 0) {
        bflush = _tr_tally(0, win[strstart - 1] & 255);
        if (bflush) {
          flush_block_only(false);
        }
        strstart++;
        lookahead--;
        if (strm.avail_out === 0)
          return NeedMore;
      } else {
        match_available = 1;
        strstart++;
        lookahead--;
      }
    }
    if (match_available !== 0) {
      bflush = _tr_tally(0, win[strstart - 1] & 255);
      match_available = 0;
    }
    flush_block_only(flush == Z_FINISH$1);
    if (strm.avail_out === 0) {
      if (flush == Z_FINISH$1)
        return FinishStarted;
      else
        return NeedMore;
    }
    return flush == Z_FINISH$1 ? FinishDone : BlockDone;
  }
  function deflateReset(strm2) {
    strm2.total_in = strm2.total_out = 0;
    strm2.msg = null;
    that.pending = 0;
    that.pending_out = 0;
    status = BUSY_STATE;
    last_flush = Z_NO_FLUSH$1;
    tr_init();
    lm_init();
    return Z_OK$1;
  }
  that.deflateInit = function(strm2, _level, bits, _method, memLevel, _strategy) {
    if (!_method)
      _method = Z_DEFLATED$1;
    if (!memLevel)
      memLevel = DEF_MEM_LEVEL;
    if (!_strategy)
      _strategy = Z_DEFAULT_STRATEGY;
    strm2.msg = null;
    if (_level == Z_DEFAULT_COMPRESSION)
      _level = 6;
    if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || _method != Z_DEFLATED$1 || bits < 9 || bits > 15 || _level < 0 || _level > 9 || _strategy < 0 || _strategy > Z_HUFFMAN_ONLY) {
      return Z_STREAM_ERROR$1;
    }
    strm2.dstate = that;
    w_bits = bits;
    w_size = 1 << w_bits;
    w_mask = w_size - 1;
    hash_bits = memLevel + 7;
    hash_size = 1 << hash_bits;
    hash_mask = hash_size - 1;
    hash_shift = Math.floor((hash_bits + MIN_MATCH - 1) / MIN_MATCH);
    win = new Uint8Array(w_size * 2);
    prev = [];
    head = [];
    lit_bufsize = 1 << memLevel + 6;
    that.pending_buf = new Uint8Array(lit_bufsize * 4);
    pending_buf_size = lit_bufsize * 4;
    that.dist_buf = new Uint16Array(lit_bufsize);
    that.lc_buf = new Uint8Array(lit_bufsize);
    level = _level;
    strategy = _strategy;
    return deflateReset(strm2);
  };
  that.deflateEnd = function() {
    if (status != INIT_STATE && status != BUSY_STATE && status != FINISH_STATE) {
      return Z_STREAM_ERROR$1;
    }
    that.lc_buf = null;
    that.dist_buf = null;
    that.pending_buf = null;
    head = null;
    prev = null;
    win = null;
    that.dstate = null;
    return status == BUSY_STATE ? Z_DATA_ERROR$1 : Z_OK$1;
  };
  that.deflateParams = function(strm2, _level, _strategy) {
    let err = Z_OK$1;
    if (_level == Z_DEFAULT_COMPRESSION) {
      _level = 6;
    }
    if (_level < 0 || _level > 9 || _strategy < 0 || _strategy > Z_HUFFMAN_ONLY) {
      return Z_STREAM_ERROR$1;
    }
    if (config_table[level].func != config_table[_level].func && strm2.total_in !== 0) {
      err = strm2.deflate(Z_PARTIAL_FLUSH);
    }
    if (level != _level) {
      level = _level;
      max_lazy_match = config_table[level].max_lazy;
      good_match = config_table[level].good_length;
      nice_match = config_table[level].nice_length;
      max_chain_length = config_table[level].max_chain;
    }
    strategy = _strategy;
    return err;
  };
  that.deflateSetDictionary = function(strm2, dictionary, dictLength) {
    let length3 = dictLength;
    let n2, index2 = 0;
    if (!dictionary || status != INIT_STATE)
      return Z_STREAM_ERROR$1;
    if (length3 < MIN_MATCH)
      return Z_OK$1;
    if (length3 > w_size - MIN_LOOKAHEAD) {
      length3 = w_size - MIN_LOOKAHEAD;
      index2 = dictLength - length3;
    }
    win.set(dictionary.subarray(index2, index2 + length3), 0);
    strstart = length3;
    block_start = length3;
    ins_h = win[0] & 255;
    ins_h = (ins_h << hash_shift ^ win[1] & 255) & hash_mask;
    for (n2 = 0; n2 <= length3 - MIN_MATCH; n2++) {
      ins_h = (ins_h << hash_shift ^ win[n2 + (MIN_MATCH - 1)] & 255) & hash_mask;
      prev[n2 & w_mask] = head[ins_h];
      head[ins_h] = n2;
    }
    return Z_OK$1;
  };
  that.deflate = function(_strm, flush) {
    let i2, header, level_flags, old_flush, bstate;
    if (flush > Z_FINISH$1 || flush < 0) {
      return Z_STREAM_ERROR$1;
    }
    if (!_strm.next_out || !_strm.next_in && _strm.avail_in !== 0 || status == FINISH_STATE && flush != Z_FINISH$1) {
      _strm.msg = z_errmsg[Z_NEED_DICT$1 - Z_STREAM_ERROR$1];
      return Z_STREAM_ERROR$1;
    }
    if (_strm.avail_out === 0) {
      _strm.msg = z_errmsg[Z_NEED_DICT$1 - Z_BUF_ERROR$1];
      return Z_BUF_ERROR$1;
    }
    strm = _strm;
    old_flush = last_flush;
    last_flush = flush;
    if (status == INIT_STATE) {
      header = Z_DEFLATED$1 + (w_bits - 8 << 4) << 8;
      level_flags = (level - 1 & 255) >> 1;
      if (level_flags > 3)
        level_flags = 3;
      header |= level_flags << 6;
      if (strstart !== 0)
        header |= PRESET_DICT$1;
      header += 31 - header % 31;
      status = BUSY_STATE;
      putShortMSB(header);
    }
    if (that.pending !== 0) {
      strm.flush_pending();
      if (strm.avail_out === 0) {
        last_flush = -1;
        return Z_OK$1;
      }
    } else if (strm.avail_in === 0 && flush <= old_flush && flush != Z_FINISH$1) {
      strm.msg = z_errmsg[Z_NEED_DICT$1 - Z_BUF_ERROR$1];
      return Z_BUF_ERROR$1;
    }
    if (status == FINISH_STATE && strm.avail_in !== 0) {
      _strm.msg = z_errmsg[Z_NEED_DICT$1 - Z_BUF_ERROR$1];
      return Z_BUF_ERROR$1;
    }
    if (strm.avail_in !== 0 || lookahead !== 0 || flush != Z_NO_FLUSH$1 && status != FINISH_STATE) {
      bstate = -1;
      switch (config_table[level].func) {
        case STORED$1:
          bstate = deflate_stored(flush);
          break;
        case FAST:
          bstate = deflate_fast(flush);
          break;
        case SLOW:
          bstate = deflate_slow(flush);
          break;
      }
      if (bstate == FinishStarted || bstate == FinishDone) {
        status = FINISH_STATE;
      }
      if (bstate == NeedMore || bstate == FinishStarted) {
        if (strm.avail_out === 0) {
          last_flush = -1;
        }
        return Z_OK$1;
      }
      if (bstate == BlockDone) {
        if (flush == Z_PARTIAL_FLUSH) {
          _tr_align();
        } else {
          _tr_stored_block(0, 0, false);
          if (flush == Z_FULL_FLUSH) {
            for (i2 = 0; i2 < hash_size; i2++)
              head[i2] = 0;
          }
        }
        strm.flush_pending();
        if (strm.avail_out === 0) {
          last_flush = -1;
          return Z_OK$1;
        }
      }
    }
    if (flush != Z_FINISH$1)
      return Z_OK$1;
    return Z_STREAM_END$1;
  };
}
function ZStream$1() {
  const that = this;
  that.next_in_index = 0;
  that.next_out_index = 0;
  that.avail_in = 0;
  that.total_in = 0;
  that.avail_out = 0;
  that.total_out = 0;
}
ZStream$1.prototype = {
  deflateInit: function(level, bits) {
    const that = this;
    that.dstate = new Deflate$1();
    if (!bits)
      bits = MAX_BITS$1;
    return that.dstate.deflateInit(that, level, bits);
  },
  deflate: function(flush) {
    const that = this;
    if (!that.dstate) {
      return Z_STREAM_ERROR$1;
    }
    return that.dstate.deflate(that, flush);
  },
  deflateEnd: function() {
    const that = this;
    if (!that.dstate)
      return Z_STREAM_ERROR$1;
    const ret = that.dstate.deflateEnd();
    that.dstate = null;
    return ret;
  },
  deflateParams: function(level, strategy) {
    const that = this;
    if (!that.dstate)
      return Z_STREAM_ERROR$1;
    return that.dstate.deflateParams(that, level, strategy);
  },
  deflateSetDictionary: function(dictionary, dictLength) {
    const that = this;
    if (!that.dstate)
      return Z_STREAM_ERROR$1;
    return that.dstate.deflateSetDictionary(that, dictionary, dictLength);
  },
  read_buf: function(buf, start, size) {
    const that = this;
    let len = that.avail_in;
    if (len > size)
      len = size;
    if (len === 0)
      return 0;
    that.avail_in -= len;
    buf.set(that.next_in.subarray(that.next_in_index, that.next_in_index + len), start);
    that.next_in_index += len;
    that.total_in += len;
    return len;
  },
  flush_pending: function() {
    const that = this;
    let len = that.dstate.pending;
    if (len > that.avail_out)
      len = that.avail_out;
    if (len === 0)
      return;
    that.next_out.set(that.dstate.pending_buf.subarray(that.dstate.pending_out, that.dstate.pending_out + len), that.next_out_index);
    that.next_out_index += len;
    that.dstate.pending_out += len;
    that.total_out += len;
    that.avail_out -= len;
    that.dstate.pending -= len;
    if (that.dstate.pending === 0) {
      that.dstate.pending_out = 0;
    }
  }
};
function ZipDeflate(options) {
  const that = this;
  const z = new ZStream$1();
  const bufsize = getMaximumCompressedSize$1(options && options.chunkSize ? options.chunkSize : 64 * 1024);
  const flush = Z_NO_FLUSH$1;
  const buf = new Uint8Array(bufsize);
  let level = options ? options.level : Z_DEFAULT_COMPRESSION;
  if (typeof level == "undefined")
    level = Z_DEFAULT_COMPRESSION;
  z.deflateInit(level);
  z.next_out = buf;
  that.append = function(data, onprogress) {
    let err, array, lastIndex = 0, bufferIndex = 0, bufferSize = 0;
    const buffers = [];
    if (!data.length)
      return;
    z.next_in_index = 0;
    z.next_in = data;
    z.avail_in = data.length;
    do {
      z.next_out_index = 0;
      z.avail_out = bufsize;
      err = z.deflate(flush);
      if (err != Z_OK$1)
        throw new Error("deflating: " + z.msg);
      if (z.next_out_index)
        if (z.next_out_index == bufsize)
          buffers.push(new Uint8Array(buf));
        else
          buffers.push(buf.slice(0, z.next_out_index));
      bufferSize += z.next_out_index;
      if (onprogress && z.next_in_index > 0 && z.next_in_index != lastIndex) {
        onprogress(z.next_in_index);
        lastIndex = z.next_in_index;
      }
    } while (z.avail_in > 0 || z.avail_out === 0);
    if (buffers.length > 1) {
      array = new Uint8Array(bufferSize);
      buffers.forEach(function(chunk) {
        array.set(chunk, bufferIndex);
        bufferIndex += chunk.length;
      });
    } else {
      array = buffers[0] || new Uint8Array(0);
    }
    return array;
  };
  that.flush = function() {
    let err, array, bufferIndex = 0, bufferSize = 0;
    const buffers = [];
    do {
      z.next_out_index = 0;
      z.avail_out = bufsize;
      err = z.deflate(Z_FINISH$1);
      if (err != Z_STREAM_END$1 && err != Z_OK$1)
        throw new Error("deflating: " + z.msg);
      if (bufsize - z.avail_out > 0)
        buffers.push(buf.slice(0, z.next_out_index));
      bufferSize += z.next_out_index;
    } while (z.avail_in > 0 || z.avail_out === 0);
    z.deflateEnd();
    array = new Uint8Array(bufferSize);
    buffers.forEach(function(chunk) {
      array.set(chunk, bufferIndex);
      bufferIndex += chunk.length;
    });
    return array;
  };
}
function getMaximumCompressedSize$1(uncompressedSize) {
  return uncompressedSize + 5 * (Math.floor(uncompressedSize / 16383) + 1);
}
var MAX_BITS = 15;
var Z_OK = 0;
var Z_STREAM_END = 1;
var Z_NEED_DICT = 2;
var Z_STREAM_ERROR = -2;
var Z_DATA_ERROR = -3;
var Z_MEM_ERROR = -4;
var Z_BUF_ERROR = -5;
var inflate_mask = [
  0,
  1,
  3,
  7,
  15,
  31,
  63,
  127,
  255,
  511,
  1023,
  2047,
  4095,
  8191,
  16383,
  32767,
  65535
];
var MANY = 1440;
var Z_NO_FLUSH = 0;
var Z_FINISH = 4;
var fixed_bl = 9;
var fixed_bd = 5;
var fixed_tl = [
  96,
  7,
  256,
  0,
  8,
  80,
  0,
  8,
  16,
  84,
  8,
  115,
  82,
  7,
  31,
  0,
  8,
  112,
  0,
  8,
  48,
  0,
  9,
  192,
  80,
  7,
  10,
  0,
  8,
  96,
  0,
  8,
  32,
  0,
  9,
  160,
  0,
  8,
  0,
  0,
  8,
  128,
  0,
  8,
  64,
  0,
  9,
  224,
  80,
  7,
  6,
  0,
  8,
  88,
  0,
  8,
  24,
  0,
  9,
  144,
  83,
  7,
  59,
  0,
  8,
  120,
  0,
  8,
  56,
  0,
  9,
  208,
  81,
  7,
  17,
  0,
  8,
  104,
  0,
  8,
  40,
  0,
  9,
  176,
  0,
  8,
  8,
  0,
  8,
  136,
  0,
  8,
  72,
  0,
  9,
  240,
  80,
  7,
  4,
  0,
  8,
  84,
  0,
  8,
  20,
  85,
  8,
  227,
  83,
  7,
  43,
  0,
  8,
  116,
  0,
  8,
  52,
  0,
  9,
  200,
  81,
  7,
  13,
  0,
  8,
  100,
  0,
  8,
  36,
  0,
  9,
  168,
  0,
  8,
  4,
  0,
  8,
  132,
  0,
  8,
  68,
  0,
  9,
  232,
  80,
  7,
  8,
  0,
  8,
  92,
  0,
  8,
  28,
  0,
  9,
  152,
  84,
  7,
  83,
  0,
  8,
  124,
  0,
  8,
  60,
  0,
  9,
  216,
  82,
  7,
  23,
  0,
  8,
  108,
  0,
  8,
  44,
  0,
  9,
  184,
  0,
  8,
  12,
  0,
  8,
  140,
  0,
  8,
  76,
  0,
  9,
  248,
  80,
  7,
  3,
  0,
  8,
  82,
  0,
  8,
  18,
  85,
  8,
  163,
  83,
  7,
  35,
  0,
  8,
  114,
  0,
  8,
  50,
  0,
  9,
  196,
  81,
  7,
  11,
  0,
  8,
  98,
  0,
  8,
  34,
  0,
  9,
  164,
  0,
  8,
  2,
  0,
  8,
  130,
  0,
  8,
  66,
  0,
  9,
  228,
  80,
  7,
  7,
  0,
  8,
  90,
  0,
  8,
  26,
  0,
  9,
  148,
  84,
  7,
  67,
  0,
  8,
  122,
  0,
  8,
  58,
  0,
  9,
  212,
  82,
  7,
  19,
  0,
  8,
  106,
  0,
  8,
  42,
  0,
  9,
  180,
  0,
  8,
  10,
  0,
  8,
  138,
  0,
  8,
  74,
  0,
  9,
  244,
  80,
  7,
  5,
  0,
  8,
  86,
  0,
  8,
  22,
  192,
  8,
  0,
  83,
  7,
  51,
  0,
  8,
  118,
  0,
  8,
  54,
  0,
  9,
  204,
  81,
  7,
  15,
  0,
  8,
  102,
  0,
  8,
  38,
  0,
  9,
  172,
  0,
  8,
  6,
  0,
  8,
  134,
  0,
  8,
  70,
  0,
  9,
  236,
  80,
  7,
  9,
  0,
  8,
  94,
  0,
  8,
  30,
  0,
  9,
  156,
  84,
  7,
  99,
  0,
  8,
  126,
  0,
  8,
  62,
  0,
  9,
  220,
  82,
  7,
  27,
  0,
  8,
  110,
  0,
  8,
  46,
  0,
  9,
  188,
  0,
  8,
  14,
  0,
  8,
  142,
  0,
  8,
  78,
  0,
  9,
  252,
  96,
  7,
  256,
  0,
  8,
  81,
  0,
  8,
  17,
  85,
  8,
  131,
  82,
  7,
  31,
  0,
  8,
  113,
  0,
  8,
  49,
  0,
  9,
  194,
  80,
  7,
  10,
  0,
  8,
  97,
  0,
  8,
  33,
  0,
  9,
  162,
  0,
  8,
  1,
  0,
  8,
  129,
  0,
  8,
  65,
  0,
  9,
  226,
  80,
  7,
  6,
  0,
  8,
  89,
  0,
  8,
  25,
  0,
  9,
  146,
  83,
  7,
  59,
  0,
  8,
  121,
  0,
  8,
  57,
  0,
  9,
  210,
  81,
  7,
  17,
  0,
  8,
  105,
  0,
  8,
  41,
  0,
  9,
  178,
  0,
  8,
  9,
  0,
  8,
  137,
  0,
  8,
  73,
  0,
  9,
  242,
  80,
  7,
  4,
  0,
  8,
  85,
  0,
  8,
  21,
  80,
  8,
  258,
  83,
  7,
  43,
  0,
  8,
  117,
  0,
  8,
  53,
  0,
  9,
  202,
  81,
  7,
  13,
  0,
  8,
  101,
  0,
  8,
  37,
  0,
  9,
  170,
  0,
  8,
  5,
  0,
  8,
  133,
  0,
  8,
  69,
  0,
  9,
  234,
  80,
  7,
  8,
  0,
  8,
  93,
  0,
  8,
  29,
  0,
  9,
  154,
  84,
  7,
  83,
  0,
  8,
  125,
  0,
  8,
  61,
  0,
  9,
  218,
  82,
  7,
  23,
  0,
  8,
  109,
  0,
  8,
  45,
  0,
  9,
  186,
  0,
  8,
  13,
  0,
  8,
  141,
  0,
  8,
  77,
  0,
  9,
  250,
  80,
  7,
  3,
  0,
  8,
  83,
  0,
  8,
  19,
  85,
  8,
  195,
  83,
  7,
  35,
  0,
  8,
  115,
  0,
  8,
  51,
  0,
  9,
  198,
  81,
  7,
  11,
  0,
  8,
  99,
  0,
  8,
  35,
  0,
  9,
  166,
  0,
  8,
  3,
  0,
  8,
  131,
  0,
  8,
  67,
  0,
  9,
  230,
  80,
  7,
  7,
  0,
  8,
  91,
  0,
  8,
  27,
  0,
  9,
  150,
  84,
  7,
  67,
  0,
  8,
  123,
  0,
  8,
  59,
  0,
  9,
  214,
  82,
  7,
  19,
  0,
  8,
  107,
  0,
  8,
  43,
  0,
  9,
  182,
  0,
  8,
  11,
  0,
  8,
  139,
  0,
  8,
  75,
  0,
  9,
  246,
  80,
  7,
  5,
  0,
  8,
  87,
  0,
  8,
  23,
  192,
  8,
  0,
  83,
  7,
  51,
  0,
  8,
  119,
  0,
  8,
  55,
  0,
  9,
  206,
  81,
  7,
  15,
  0,
  8,
  103,
  0,
  8,
  39,
  0,
  9,
  174,
  0,
  8,
  7,
  0,
  8,
  135,
  0,
  8,
  71,
  0,
  9,
  238,
  80,
  7,
  9,
  0,
  8,
  95,
  0,
  8,
  31,
  0,
  9,
  158,
  84,
  7,
  99,
  0,
  8,
  127,
  0,
  8,
  63,
  0,
  9,
  222,
  82,
  7,
  27,
  0,
  8,
  111,
  0,
  8,
  47,
  0,
  9,
  190,
  0,
  8,
  15,
  0,
  8,
  143,
  0,
  8,
  79,
  0,
  9,
  254,
  96,
  7,
  256,
  0,
  8,
  80,
  0,
  8,
  16,
  84,
  8,
  115,
  82,
  7,
  31,
  0,
  8,
  112,
  0,
  8,
  48,
  0,
  9,
  193,
  80,
  7,
  10,
  0,
  8,
  96,
  0,
  8,
  32,
  0,
  9,
  161,
  0,
  8,
  0,
  0,
  8,
  128,
  0,
  8,
  64,
  0,
  9,
  225,
  80,
  7,
  6,
  0,
  8,
  88,
  0,
  8,
  24,
  0,
  9,
  145,
  83,
  7,
  59,
  0,
  8,
  120,
  0,
  8,
  56,
  0,
  9,
  209,
  81,
  7,
  17,
  0,
  8,
  104,
  0,
  8,
  40,
  0,
  9,
  177,
  0,
  8,
  8,
  0,
  8,
  136,
  0,
  8,
  72,
  0,
  9,
  241,
  80,
  7,
  4,
  0,
  8,
  84,
  0,
  8,
  20,
  85,
  8,
  227,
  83,
  7,
  43,
  0,
  8,
  116,
  0,
  8,
  52,
  0,
  9,
  201,
  81,
  7,
  13,
  0,
  8,
  100,
  0,
  8,
  36,
  0,
  9,
  169,
  0,
  8,
  4,
  0,
  8,
  132,
  0,
  8,
  68,
  0,
  9,
  233,
  80,
  7,
  8,
  0,
  8,
  92,
  0,
  8,
  28,
  0,
  9,
  153,
  84,
  7,
  83,
  0,
  8,
  124,
  0,
  8,
  60,
  0,
  9,
  217,
  82,
  7,
  23,
  0,
  8,
  108,
  0,
  8,
  44,
  0,
  9,
  185,
  0,
  8,
  12,
  0,
  8,
  140,
  0,
  8,
  76,
  0,
  9,
  249,
  80,
  7,
  3,
  0,
  8,
  82,
  0,
  8,
  18,
  85,
  8,
  163,
  83,
  7,
  35,
  0,
  8,
  114,
  0,
  8,
  50,
  0,
  9,
  197,
  81,
  7,
  11,
  0,
  8,
  98,
  0,
  8,
  34,
  0,
  9,
  165,
  0,
  8,
  2,
  0,
  8,
  130,
  0,
  8,
  66,
  0,
  9,
  229,
  80,
  7,
  7,
  0,
  8,
  90,
  0,
  8,
  26,
  0,
  9,
  149,
  84,
  7,
  67,
  0,
  8,
  122,
  0,
  8,
  58,
  0,
  9,
  213,
  82,
  7,
  19,
  0,
  8,
  106,
  0,
  8,
  42,
  0,
  9,
  181,
  0,
  8,
  10,
  0,
  8,
  138,
  0,
  8,
  74,
  0,
  9,
  245,
  80,
  7,
  5,
  0,
  8,
  86,
  0,
  8,
  22,
  192,
  8,
  0,
  83,
  7,
  51,
  0,
  8,
  118,
  0,
  8,
  54,
  0,
  9,
  205,
  81,
  7,
  15,
  0,
  8,
  102,
  0,
  8,
  38,
  0,
  9,
  173,
  0,
  8,
  6,
  0,
  8,
  134,
  0,
  8,
  70,
  0,
  9,
  237,
  80,
  7,
  9,
  0,
  8,
  94,
  0,
  8,
  30,
  0,
  9,
  157,
  84,
  7,
  99,
  0,
  8,
  126,
  0,
  8,
  62,
  0,
  9,
  221,
  82,
  7,
  27,
  0,
  8,
  110,
  0,
  8,
  46,
  0,
  9,
  189,
  0,
  8,
  14,
  0,
  8,
  142,
  0,
  8,
  78,
  0,
  9,
  253,
  96,
  7,
  256,
  0,
  8,
  81,
  0,
  8,
  17,
  85,
  8,
  131,
  82,
  7,
  31,
  0,
  8,
  113,
  0,
  8,
  49,
  0,
  9,
  195,
  80,
  7,
  10,
  0,
  8,
  97,
  0,
  8,
  33,
  0,
  9,
  163,
  0,
  8,
  1,
  0,
  8,
  129,
  0,
  8,
  65,
  0,
  9,
  227,
  80,
  7,
  6,
  0,
  8,
  89,
  0,
  8,
  25,
  0,
  9,
  147,
  83,
  7,
  59,
  0,
  8,
  121,
  0,
  8,
  57,
  0,
  9,
  211,
  81,
  7,
  17,
  0,
  8,
  105,
  0,
  8,
  41,
  0,
  9,
  179,
  0,
  8,
  9,
  0,
  8,
  137,
  0,
  8,
  73,
  0,
  9,
  243,
  80,
  7,
  4,
  0,
  8,
  85,
  0,
  8,
  21,
  80,
  8,
  258,
  83,
  7,
  43,
  0,
  8,
  117,
  0,
  8,
  53,
  0,
  9,
  203,
  81,
  7,
  13,
  0,
  8,
  101,
  0,
  8,
  37,
  0,
  9,
  171,
  0,
  8,
  5,
  0,
  8,
  133,
  0,
  8,
  69,
  0,
  9,
  235,
  80,
  7,
  8,
  0,
  8,
  93,
  0,
  8,
  29,
  0,
  9,
  155,
  84,
  7,
  83,
  0,
  8,
  125,
  0,
  8,
  61,
  0,
  9,
  219,
  82,
  7,
  23,
  0,
  8,
  109,
  0,
  8,
  45,
  0,
  9,
  187,
  0,
  8,
  13,
  0,
  8,
  141,
  0,
  8,
  77,
  0,
  9,
  251,
  80,
  7,
  3,
  0,
  8,
  83,
  0,
  8,
  19,
  85,
  8,
  195,
  83,
  7,
  35,
  0,
  8,
  115,
  0,
  8,
  51,
  0,
  9,
  199,
  81,
  7,
  11,
  0,
  8,
  99,
  0,
  8,
  35,
  0,
  9,
  167,
  0,
  8,
  3,
  0,
  8,
  131,
  0,
  8,
  67,
  0,
  9,
  231,
  80,
  7,
  7,
  0,
  8,
  91,
  0,
  8,
  27,
  0,
  9,
  151,
  84,
  7,
  67,
  0,
  8,
  123,
  0,
  8,
  59,
  0,
  9,
  215,
  82,
  7,
  19,
  0,
  8,
  107,
  0,
  8,
  43,
  0,
  9,
  183,
  0,
  8,
  11,
  0,
  8,
  139,
  0,
  8,
  75,
  0,
  9,
  247,
  80,
  7,
  5,
  0,
  8,
  87,
  0,
  8,
  23,
  192,
  8,
  0,
  83,
  7,
  51,
  0,
  8,
  119,
  0,
  8,
  55,
  0,
  9,
  207,
  81,
  7,
  15,
  0,
  8,
  103,
  0,
  8,
  39,
  0,
  9,
  175,
  0,
  8,
  7,
  0,
  8,
  135,
  0,
  8,
  71,
  0,
  9,
  239,
  80,
  7,
  9,
  0,
  8,
  95,
  0,
  8,
  31,
  0,
  9,
  159,
  84,
  7,
  99,
  0,
  8,
  127,
  0,
  8,
  63,
  0,
  9,
  223,
  82,
  7,
  27,
  0,
  8,
  111,
  0,
  8,
  47,
  0,
  9,
  191,
  0,
  8,
  15,
  0,
  8,
  143,
  0,
  8,
  79,
  0,
  9,
  255
];
var fixed_td = [
  80,
  5,
  1,
  87,
  5,
  257,
  83,
  5,
  17,
  91,
  5,
  4097,
  81,
  5,
  5,
  89,
  5,
  1025,
  85,
  5,
  65,
  93,
  5,
  16385,
  80,
  5,
  3,
  88,
  5,
  513,
  84,
  5,
  33,
  92,
  5,
  8193,
  82,
  5,
  9,
  90,
  5,
  2049,
  86,
  5,
  129,
  192,
  5,
  24577,
  80,
  5,
  2,
  87,
  5,
  385,
  83,
  5,
  25,
  91,
  5,
  6145,
  81,
  5,
  7,
  89,
  5,
  1537,
  85,
  5,
  97,
  93,
  5,
  24577,
  80,
  5,
  4,
  88,
  5,
  769,
  84,
  5,
  49,
  92,
  5,
  12289,
  82,
  5,
  13,
  90,
  5,
  3073,
  86,
  5,
  193,
  192,
  5,
  24577
];
var cplens = [
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  11,
  13,
  15,
  17,
  19,
  23,
  27,
  31,
  35,
  43,
  51,
  59,
  67,
  83,
  99,
  115,
  131,
  163,
  195,
  227,
  258,
  0,
  0
];
var cplext = [
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  1,
  1,
  1,
  1,
  2,
  2,
  2,
  2,
  3,
  3,
  3,
  3,
  4,
  4,
  4,
  4,
  5,
  5,
  5,
  5,
  0,
  112,
  112
];
var cpdist = [
  1,
  2,
  3,
  4,
  5,
  7,
  9,
  13,
  17,
  25,
  33,
  49,
  65,
  97,
  129,
  193,
  257,
  385,
  513,
  769,
  1025,
  1537,
  2049,
  3073,
  4097,
  6145,
  8193,
  12289,
  16385,
  24577
];
var cpdext = [
  0,
  0,
  0,
  0,
  1,
  1,
  2,
  2,
  3,
  3,
  4,
  4,
  5,
  5,
  6,
  6,
  7,
  7,
  8,
  8,
  9,
  9,
  10,
  10,
  11,
  11,
  12,
  12,
  13,
  13
];
var BMAX = 15;
function InfTree() {
  const that = this;
  let hn;
  let v7;
  let c14;
  let r2;
  let u3;
  let x;
  function huft_build(b, bindex, n2, s2, d, e2, t, m, hp, hn2, v8) {
    let a4;
    let f2;
    let g;
    let h;
    let i2;
    let j;
    let k;
    let l2;
    let mask;
    let p2;
    let q;
    let w;
    let xp;
    let y;
    let z;
    p2 = 0;
    i2 = n2;
    do {
      c14[b[bindex + p2]]++;
      p2++;
      i2--;
    } while (i2 !== 0);
    if (c14[0] == n2) {
      t[0] = -1;
      m[0] = 0;
      return Z_OK;
    }
    l2 = m[0];
    for (j = 1; j <= BMAX; j++)
      if (c14[j] !== 0)
        break;
    k = j;
    if (l2 < j) {
      l2 = j;
    }
    for (i2 = BMAX; i2 !== 0; i2--) {
      if (c14[i2] !== 0)
        break;
    }
    g = i2;
    if (l2 > i2) {
      l2 = i2;
    }
    m[0] = l2;
    for (y = 1 << j; j < i2; j++, y <<= 1) {
      if ((y -= c14[j]) < 0) {
        return Z_DATA_ERROR;
      }
    }
    if ((y -= c14[i2]) < 0) {
      return Z_DATA_ERROR;
    }
    c14[i2] += y;
    x[1] = j = 0;
    p2 = 1;
    xp = 2;
    while (--i2 !== 0) {
      x[xp] = j += c14[p2];
      xp++;
      p2++;
    }
    i2 = 0;
    p2 = 0;
    do {
      if ((j = b[bindex + p2]) !== 0) {
        v8[x[j]++] = i2;
      }
      p2++;
    } while (++i2 < n2);
    n2 = x[g];
    x[0] = i2 = 0;
    p2 = 0;
    h = -1;
    w = -l2;
    u3[0] = 0;
    q = 0;
    z = 0;
    for (; k <= g; k++) {
      a4 = c14[k];
      while (a4-- !== 0) {
        while (k > w + l2) {
          h++;
          w += l2;
          z = g - w;
          z = z > l2 ? l2 : z;
          if ((f2 = 1 << (j = k - w)) > a4 + 1) {
            f2 -= a4 + 1;
            xp = k;
            if (j < z) {
              while (++j < z) {
                if ((f2 <<= 1) <= c14[++xp])
                  break;
                f2 -= c14[xp];
              }
            }
          }
          z = 1 << j;
          if (hn2[0] + z > MANY) {
            return Z_DATA_ERROR;
          }
          u3[h] = q = hn2[0];
          hn2[0] += z;
          if (h !== 0) {
            x[h] = i2;
            r2[0] = j;
            r2[1] = l2;
            j = i2 >>> w - l2;
            r2[2] = q - u3[h - 1] - j;
            hp.set(r2, (u3[h - 1] + j) * 3);
          } else {
            t[0] = q;
          }
        }
        r2[1] = k - w;
        if (p2 >= n2) {
          r2[0] = 128 + 64;
        } else if (v8[p2] < s2) {
          r2[0] = v8[p2] < 256 ? 0 : 32 + 64;
          r2[2] = v8[p2++];
        } else {
          r2[0] = e2[v8[p2] - s2] + 16 + 64;
          r2[2] = d[v8[p2++] - s2];
        }
        f2 = 1 << k - w;
        for (j = i2 >>> w; j < z; j += f2) {
          hp.set(r2, (q + j) * 3);
        }
        for (j = 1 << k - 1; (i2 & j) !== 0; j >>>= 1) {
          i2 ^= j;
        }
        i2 ^= j;
        mask = (1 << w) - 1;
        while ((i2 & mask) != x[h]) {
          h--;
          w -= l2;
          mask = (1 << w) - 1;
        }
      }
    }
    return y !== 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
  }
  function initWorkArea(vsize) {
    let i2;
    if (!hn) {
      hn = [];
      v7 = [];
      c14 = new Int32Array(BMAX + 1);
      r2 = [];
      u3 = new Int32Array(BMAX);
      x = new Int32Array(BMAX + 1);
    }
    if (v7.length < vsize) {
      v7 = [];
    }
    for (i2 = 0; i2 < vsize; i2++) {
      v7[i2] = 0;
    }
    for (i2 = 0; i2 < BMAX + 1; i2++) {
      c14[i2] = 0;
    }
    for (i2 = 0; i2 < 3; i2++) {
      r2[i2] = 0;
    }
    u3.set(c14.subarray(0, BMAX), 0);
    x.set(c14.subarray(0, BMAX + 1), 0);
  }
  that.inflate_trees_bits = function(c15, bb, tb, hp, z) {
    let result;
    initWorkArea(19);
    hn[0] = 0;
    result = huft_build(c15, 0, 19, 19, null, null, tb, bb, hp, hn, v7);
    if (result == Z_DATA_ERROR) {
      z.msg = "oversubscribed dynamic bit lengths tree";
    } else if (result == Z_BUF_ERROR || bb[0] === 0) {
      z.msg = "incomplete dynamic bit lengths tree";
      result = Z_DATA_ERROR;
    }
    return result;
  };
  that.inflate_trees_dynamic = function(nl, nd, c15, bl, bd, tl, td, hp, z) {
    let result;
    initWorkArea(288);
    hn[0] = 0;
    result = huft_build(c15, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v7);
    if (result != Z_OK || bl[0] === 0) {
      if (result == Z_DATA_ERROR) {
        z.msg = "oversubscribed literal/length tree";
      } else if (result != Z_MEM_ERROR) {
        z.msg = "incomplete literal/length tree";
        result = Z_DATA_ERROR;
      }
      return result;
    }
    initWorkArea(288);
    result = huft_build(c15, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v7);
    if (result != Z_OK || bd[0] === 0 && nl > 257) {
      if (result == Z_DATA_ERROR) {
        z.msg = "oversubscribed distance tree";
      } else if (result == Z_BUF_ERROR) {
        z.msg = "incomplete distance tree";
        result = Z_DATA_ERROR;
      } else if (result != Z_MEM_ERROR) {
        z.msg = "empty distance tree with lengths";
        result = Z_DATA_ERROR;
      }
      return result;
    }
    return Z_OK;
  };
}
InfTree.inflate_trees_fixed = function(bl, bd, tl, td) {
  bl[0] = fixed_bl;
  bd[0] = fixed_bd;
  tl[0] = fixed_tl;
  td[0] = fixed_td;
  return Z_OK;
};
var START = 0;
var LEN = 1;
var LENEXT = 2;
var DIST = 3;
var DISTEXT = 4;
var COPY = 5;
var LIT = 6;
var WASH = 7;
var END = 8;
var BADCODE = 9;
function InfCodes() {
  const that = this;
  let mode2;
  let len = 0;
  let tree;
  let tree_index = 0;
  let need = 0;
  let lit = 0;
  let get2 = 0;
  let dist = 0;
  let lbits = 0;
  let dbits = 0;
  let ltree;
  let ltree_index = 0;
  let dtree;
  let dtree_index = 0;
  function inflate_fast2(bl, bd, tl, tl_index, td, td_index, s2, z) {
    let t;
    let tp;
    let tp_index;
    let e2;
    let b;
    let k;
    let p2;
    let n2;
    let q;
    let m;
    let ml;
    let md;
    let c14;
    let d;
    let r2;
    let tp_index_t_3;
    p2 = z.next_in_index;
    n2 = z.avail_in;
    b = s2.bitb;
    k = s2.bitk;
    q = s2.write;
    m = q < s2.read ? s2.read - q - 1 : s2.end - q;
    ml = inflate_mask[bl];
    md = inflate_mask[bd];
    do {
      while (k < 20) {
        n2--;
        b |= (z.read_byte(p2++) & 255) << k;
        k += 8;
      }
      t = b & ml;
      tp = tl;
      tp_index = tl_index;
      tp_index_t_3 = (tp_index + t) * 3;
      if ((e2 = tp[tp_index_t_3]) === 0) {
        b >>= tp[tp_index_t_3 + 1];
        k -= tp[tp_index_t_3 + 1];
        s2.win[q++] = tp[tp_index_t_3 + 2];
        m--;
        continue;
      }
      do {
        b >>= tp[tp_index_t_3 + 1];
        k -= tp[tp_index_t_3 + 1];
        if ((e2 & 16) !== 0) {
          e2 &= 15;
          c14 = tp[tp_index_t_3 + 2] + (b & inflate_mask[e2]);
          b >>= e2;
          k -= e2;
          while (k < 15) {
            n2--;
            b |= (z.read_byte(p2++) & 255) << k;
            k += 8;
          }
          t = b & md;
          tp = td;
          tp_index = td_index;
          tp_index_t_3 = (tp_index + t) * 3;
          e2 = tp[tp_index_t_3];
          do {
            b >>= tp[tp_index_t_3 + 1];
            k -= tp[tp_index_t_3 + 1];
            if ((e2 & 16) !== 0) {
              e2 &= 15;
              while (k < e2) {
                n2--;
                b |= (z.read_byte(p2++) & 255) << k;
                k += 8;
              }
              d = tp[tp_index_t_3 + 2] + (b & inflate_mask[e2]);
              b >>= e2;
              k -= e2;
              m -= c14;
              if (q >= d) {
                r2 = q - d;
                if (q - r2 > 0 && 2 > q - r2) {
                  s2.win[q++] = s2.win[r2++];
                  s2.win[q++] = s2.win[r2++];
                  c14 -= 2;
                } else {
                  s2.win.set(s2.win.subarray(r2, r2 + 2), q);
                  q += 2;
                  r2 += 2;
                  c14 -= 2;
                }
              } else {
                r2 = q - d;
                do {
                  r2 += s2.end;
                } while (r2 < 0);
                e2 = s2.end - r2;
                if (c14 > e2) {
                  c14 -= e2;
                  if (q - r2 > 0 && e2 > q - r2) {
                    do {
                      s2.win[q++] = s2.win[r2++];
                    } while (--e2 !== 0);
                  } else {
                    s2.win.set(s2.win.subarray(r2, r2 + e2), q);
                    q += e2;
                    r2 += e2;
                    e2 = 0;
                  }
                  r2 = 0;
                }
              }
              if (q - r2 > 0 && c14 > q - r2) {
                do {
                  s2.win[q++] = s2.win[r2++];
                } while (--c14 !== 0);
              } else {
                s2.win.set(s2.win.subarray(r2, r2 + c14), q);
                q += c14;
                r2 += c14;
                c14 = 0;
              }
              break;
            } else if ((e2 & 64) === 0) {
              t += tp[tp_index_t_3 + 2];
              t += b & inflate_mask[e2];
              tp_index_t_3 = (tp_index + t) * 3;
              e2 = tp[tp_index_t_3];
            } else {
              z.msg = "invalid distance code";
              c14 = z.avail_in - n2;
              c14 = k >> 3 < c14 ? k >> 3 : c14;
              n2 += c14;
              p2 -= c14;
              k -= c14 << 3;
              s2.bitb = b;
              s2.bitk = k;
              z.avail_in = n2;
              z.total_in += p2 - z.next_in_index;
              z.next_in_index = p2;
              s2.write = q;
              return Z_DATA_ERROR;
            }
          } while (true);
          break;
        }
        if ((e2 & 64) === 0) {
          t += tp[tp_index_t_3 + 2];
          t += b & inflate_mask[e2];
          tp_index_t_3 = (tp_index + t) * 3;
          if ((e2 = tp[tp_index_t_3]) === 0) {
            b >>= tp[tp_index_t_3 + 1];
            k -= tp[tp_index_t_3 + 1];
            s2.win[q++] = tp[tp_index_t_3 + 2];
            m--;
            break;
          }
        } else if ((e2 & 32) !== 0) {
          c14 = z.avail_in - n2;
          c14 = k >> 3 < c14 ? k >> 3 : c14;
          n2 += c14;
          p2 -= c14;
          k -= c14 << 3;
          s2.bitb = b;
          s2.bitk = k;
          z.avail_in = n2;
          z.total_in += p2 - z.next_in_index;
          z.next_in_index = p2;
          s2.write = q;
          return Z_STREAM_END;
        } else {
          z.msg = "invalid literal/length code";
          c14 = z.avail_in - n2;
          c14 = k >> 3 < c14 ? k >> 3 : c14;
          n2 += c14;
          p2 -= c14;
          k -= c14 << 3;
          s2.bitb = b;
          s2.bitk = k;
          z.avail_in = n2;
          z.total_in += p2 - z.next_in_index;
          z.next_in_index = p2;
          s2.write = q;
          return Z_DATA_ERROR;
        }
      } while (true);
    } while (m >= 258 && n2 >= 10);
    c14 = z.avail_in - n2;
    c14 = k >> 3 < c14 ? k >> 3 : c14;
    n2 += c14;
    p2 -= c14;
    k -= c14 << 3;
    s2.bitb = b;
    s2.bitk = k;
    z.avail_in = n2;
    z.total_in += p2 - z.next_in_index;
    z.next_in_index = p2;
    s2.write = q;
    return Z_OK;
  }
  that.init = function(bl, bd, tl, tl_index, td, td_index) {
    mode2 = START;
    lbits = bl;
    dbits = bd;
    ltree = tl;
    ltree_index = tl_index;
    dtree = td;
    dtree_index = td_index;
    tree = null;
  };
  that.proc = function(s2, z, r2) {
    let j;
    let tindex;
    let e2;
    let b = 0;
    let k = 0;
    let p2 = 0;
    let n2;
    let q;
    let m;
    let f2;
    p2 = z.next_in_index;
    n2 = z.avail_in;
    b = s2.bitb;
    k = s2.bitk;
    q = s2.write;
    m = q < s2.read ? s2.read - q - 1 : s2.end - q;
    while (true) {
      switch (mode2) {
        case START:
          if (m >= 258 && n2 >= 10) {
            s2.bitb = b;
            s2.bitk = k;
            z.avail_in = n2;
            z.total_in += p2 - z.next_in_index;
            z.next_in_index = p2;
            s2.write = q;
            r2 = inflate_fast2(lbits, dbits, ltree, ltree_index, dtree, dtree_index, s2, z);
            p2 = z.next_in_index;
            n2 = z.avail_in;
            b = s2.bitb;
            k = s2.bitk;
            q = s2.write;
            m = q < s2.read ? s2.read - q - 1 : s2.end - q;
            if (r2 != Z_OK) {
              mode2 = r2 == Z_STREAM_END ? WASH : BADCODE;
              break;
            }
          }
          need = lbits;
          tree = ltree;
          tree_index = ltree_index;
          mode2 = LEN;
        case LEN:
          j = need;
          while (k < j) {
            if (n2 !== 0)
              r2 = Z_OK;
            else {
              s2.bitb = b;
              s2.bitk = k;
              z.avail_in = n2;
              z.total_in += p2 - z.next_in_index;
              z.next_in_index = p2;
              s2.write = q;
              return s2.inflate_flush(z, r2);
            }
            n2--;
            b |= (z.read_byte(p2++) & 255) << k;
            k += 8;
          }
          tindex = (tree_index + (b & inflate_mask[j])) * 3;
          b >>>= tree[tindex + 1];
          k -= tree[tindex + 1];
          e2 = tree[tindex];
          if (e2 === 0) {
            lit = tree[tindex + 2];
            mode2 = LIT;
            break;
          }
          if ((e2 & 16) !== 0) {
            get2 = e2 & 15;
            len = tree[tindex + 2];
            mode2 = LENEXT;
            break;
          }
          if ((e2 & 64) === 0) {
            need = e2;
            tree_index = tindex / 3 + tree[tindex + 2];
            break;
          }
          if ((e2 & 32) !== 0) {
            mode2 = WASH;
            break;
          }
          mode2 = BADCODE;
          z.msg = "invalid literal/length code";
          r2 = Z_DATA_ERROR;
          s2.bitb = b;
          s2.bitk = k;
          z.avail_in = n2;
          z.total_in += p2 - z.next_in_index;
          z.next_in_index = p2;
          s2.write = q;
          return s2.inflate_flush(z, r2);
        case LENEXT:
          j = get2;
          while (k < j) {
            if (n2 !== 0)
              r2 = Z_OK;
            else {
              s2.bitb = b;
              s2.bitk = k;
              z.avail_in = n2;
              z.total_in += p2 - z.next_in_index;
              z.next_in_index = p2;
              s2.write = q;
              return s2.inflate_flush(z, r2);
            }
            n2--;
            b |= (z.read_byte(p2++) & 255) << k;
            k += 8;
          }
          len += b & inflate_mask[j];
          b >>= j;
          k -= j;
          need = dbits;
          tree = dtree;
          tree_index = dtree_index;
          mode2 = DIST;
        case DIST:
          j = need;
          while (k < j) {
            if (n2 !== 0)
              r2 = Z_OK;
            else {
              s2.bitb = b;
              s2.bitk = k;
              z.avail_in = n2;
              z.total_in += p2 - z.next_in_index;
              z.next_in_index = p2;
              s2.write = q;
              return s2.inflate_flush(z, r2);
            }
            n2--;
            b |= (z.read_byte(p2++) & 255) << k;
            k += 8;
          }
          tindex = (tree_index + (b & inflate_mask[j])) * 3;
          b >>= tree[tindex + 1];
          k -= tree[tindex + 1];
          e2 = tree[tindex];
          if ((e2 & 16) !== 0) {
            get2 = e2 & 15;
            dist = tree[tindex + 2];
            mode2 = DISTEXT;
            break;
          }
          if ((e2 & 64) === 0) {
            need = e2;
            tree_index = tindex / 3 + tree[tindex + 2];
            break;
          }
          mode2 = BADCODE;
          z.msg = "invalid distance code";
          r2 = Z_DATA_ERROR;
          s2.bitb = b;
          s2.bitk = k;
          z.avail_in = n2;
          z.total_in += p2 - z.next_in_index;
          z.next_in_index = p2;
          s2.write = q;
          return s2.inflate_flush(z, r2);
        case DISTEXT:
          j = get2;
          while (k < j) {
            if (n2 !== 0)
              r2 = Z_OK;
            else {
              s2.bitb = b;
              s2.bitk = k;
              z.avail_in = n2;
              z.total_in += p2 - z.next_in_index;
              z.next_in_index = p2;
              s2.write = q;
              return s2.inflate_flush(z, r2);
            }
            n2--;
            b |= (z.read_byte(p2++) & 255) << k;
            k += 8;
          }
          dist += b & inflate_mask[j];
          b >>= j;
          k -= j;
          mode2 = COPY;
        case COPY:
          f2 = q - dist;
          while (f2 < 0) {
            f2 += s2.end;
          }
          while (len !== 0) {
            if (m === 0) {
              if (q == s2.end && s2.read !== 0) {
                q = 0;
                m = q < s2.read ? s2.read - q - 1 : s2.end - q;
              }
              if (m === 0) {
                s2.write = q;
                r2 = s2.inflate_flush(z, r2);
                q = s2.write;
                m = q < s2.read ? s2.read - q - 1 : s2.end - q;
                if (q == s2.end && s2.read !== 0) {
                  q = 0;
                  m = q < s2.read ? s2.read - q - 1 : s2.end - q;
                }
                if (m === 0) {
                  s2.bitb = b;
                  s2.bitk = k;
                  z.avail_in = n2;
                  z.total_in += p2 - z.next_in_index;
                  z.next_in_index = p2;
                  s2.write = q;
                  return s2.inflate_flush(z, r2);
                }
              }
            }
            s2.win[q++] = s2.win[f2++];
            m--;
            if (f2 == s2.end)
              f2 = 0;
            len--;
          }
          mode2 = START;
          break;
        case LIT:
          if (m === 0) {
            if (q == s2.end && s2.read !== 0) {
              q = 0;
              m = q < s2.read ? s2.read - q - 1 : s2.end - q;
            }
            if (m === 0) {
              s2.write = q;
              r2 = s2.inflate_flush(z, r2);
              q = s2.write;
              m = q < s2.read ? s2.read - q - 1 : s2.end - q;
              if (q == s2.end && s2.read !== 0) {
                q = 0;
                m = q < s2.read ? s2.read - q - 1 : s2.end - q;
              }
              if (m === 0) {
                s2.bitb = b;
                s2.bitk = k;
                z.avail_in = n2;
                z.total_in += p2 - z.next_in_index;
                z.next_in_index = p2;
                s2.write = q;
                return s2.inflate_flush(z, r2);
              }
            }
          }
          r2 = Z_OK;
          s2.win[q++] = lit;
          m--;
          mode2 = START;
          break;
        case WASH:
          if (k > 7) {
            k -= 8;
            n2++;
            p2--;
          }
          s2.write = q;
          r2 = s2.inflate_flush(z, r2);
          q = s2.write;
          m = q < s2.read ? s2.read - q - 1 : s2.end - q;
          if (s2.read != s2.write) {
            s2.bitb = b;
            s2.bitk = k;
            z.avail_in = n2;
            z.total_in += p2 - z.next_in_index;
            z.next_in_index = p2;
            s2.write = q;
            return s2.inflate_flush(z, r2);
          }
          mode2 = END;
        case END:
          r2 = Z_STREAM_END;
          s2.bitb = b;
          s2.bitk = k;
          z.avail_in = n2;
          z.total_in += p2 - z.next_in_index;
          z.next_in_index = p2;
          s2.write = q;
          return s2.inflate_flush(z, r2);
        case BADCODE:
          r2 = Z_DATA_ERROR;
          s2.bitb = b;
          s2.bitk = k;
          z.avail_in = n2;
          z.total_in += p2 - z.next_in_index;
          z.next_in_index = p2;
          s2.write = q;
          return s2.inflate_flush(z, r2);
        default:
          r2 = Z_STREAM_ERROR;
          s2.bitb = b;
          s2.bitk = k;
          z.avail_in = n2;
          z.total_in += p2 - z.next_in_index;
          z.next_in_index = p2;
          s2.write = q;
          return s2.inflate_flush(z, r2);
      }
    }
  };
  that.free = function() {
  };
}
var border = [
  16,
  17,
  18,
  0,
  8,
  7,
  9,
  6,
  10,
  5,
  11,
  4,
  12,
  3,
  13,
  2,
  14,
  1,
  15
];
var TYPE = 0;
var LENS = 1;
var STORED = 2;
var TABLE = 3;
var BTREE = 4;
var DTREE = 5;
var CODES = 6;
var DRY = 7;
var DONELOCKS = 8;
var BADBLOCKS = 9;
function InfBlocks(z, w) {
  const that = this;
  let mode2 = TYPE;
  let left = 0;
  let table2 = 0;
  let index2 = 0;
  let blens;
  const bb = [0];
  const tb = [0];
  const codes = new InfCodes();
  let last = 0;
  let hufts = new Int32Array(MANY * 3);
  const check = 0;
  const inftree = new InfTree();
  that.bitk = 0;
  that.bitb = 0;
  that.win = new Uint8Array(w);
  that.end = w;
  that.read = 0;
  that.write = 0;
  that.reset = function(z2, c14) {
    if (c14)
      c14[0] = check;
    if (mode2 == CODES) {
      codes.free(z2);
    }
    mode2 = TYPE;
    that.bitk = 0;
    that.bitb = 0;
    that.read = that.write = 0;
  };
  that.reset(z, null);
  that.inflate_flush = function(z2, r2) {
    let n2;
    let p2;
    let q;
    p2 = z2.next_out_index;
    q = that.read;
    n2 = (q <= that.write ? that.write : that.end) - q;
    if (n2 > z2.avail_out)
      n2 = z2.avail_out;
    if (n2 !== 0 && r2 == Z_BUF_ERROR)
      r2 = Z_OK;
    z2.avail_out -= n2;
    z2.total_out += n2;
    z2.next_out.set(that.win.subarray(q, q + n2), p2);
    p2 += n2;
    q += n2;
    if (q == that.end) {
      q = 0;
      if (that.write == that.end)
        that.write = 0;
      n2 = that.write - q;
      if (n2 > z2.avail_out)
        n2 = z2.avail_out;
      if (n2 !== 0 && r2 == Z_BUF_ERROR)
        r2 = Z_OK;
      z2.avail_out -= n2;
      z2.total_out += n2;
      z2.next_out.set(that.win.subarray(q, q + n2), p2);
      p2 += n2;
      q += n2;
    }
    z2.next_out_index = p2;
    that.read = q;
    return r2;
  };
  that.proc = function(z2, r2) {
    let t;
    let b;
    let k;
    let p2;
    let n2;
    let q;
    let m;
    let i2;
    p2 = z2.next_in_index;
    n2 = z2.avail_in;
    b = that.bitb;
    k = that.bitk;
    q = that.write;
    m = q < that.read ? that.read - q - 1 : that.end - q;
    while (true) {
      let bl, bd, tl, td, bl_, bd_, tl_, td_;
      switch (mode2) {
        case TYPE:
          while (k < 3) {
            if (n2 !== 0) {
              r2 = Z_OK;
            } else {
              that.bitb = b;
              that.bitk = k;
              z2.avail_in = n2;
              z2.total_in += p2 - z2.next_in_index;
              z2.next_in_index = p2;
              that.write = q;
              return that.inflate_flush(z2, r2);
            }
            n2--;
            b |= (z2.read_byte(p2++) & 255) << k;
            k += 8;
          }
          t = b & 7;
          last = t & 1;
          switch (t >>> 1) {
            case 0:
              b >>>= 3;
              k -= 3;
              t = k & 7;
              b >>>= t;
              k -= t;
              mode2 = LENS;
              break;
            case 1:
              bl = [];
              bd = [];
              tl = [[]];
              td = [[]];
              InfTree.inflate_trees_fixed(bl, bd, tl, td);
              codes.init(bl[0], bd[0], tl[0], 0, td[0], 0);
              b >>>= 3;
              k -= 3;
              mode2 = CODES;
              break;
            case 2:
              b >>>= 3;
              k -= 3;
              mode2 = TABLE;
              break;
            case 3:
              b >>>= 3;
              k -= 3;
              mode2 = BADBLOCKS;
              z2.msg = "invalid block type";
              r2 = Z_DATA_ERROR;
              that.bitb = b;
              that.bitk = k;
              z2.avail_in = n2;
              z2.total_in += p2 - z2.next_in_index;
              z2.next_in_index = p2;
              that.write = q;
              return that.inflate_flush(z2, r2);
          }
          break;
        case LENS:
          while (k < 32) {
            if (n2 !== 0) {
              r2 = Z_OK;
            } else {
              that.bitb = b;
              that.bitk = k;
              z2.avail_in = n2;
              z2.total_in += p2 - z2.next_in_index;
              z2.next_in_index = p2;
              that.write = q;
              return that.inflate_flush(z2, r2);
            }
            n2--;
            b |= (z2.read_byte(p2++) & 255) << k;
            k += 8;
          }
          if ((~b >>> 16 & 65535) != (b & 65535)) {
            mode2 = BADBLOCKS;
            z2.msg = "invalid stored block lengths";
            r2 = Z_DATA_ERROR;
            that.bitb = b;
            that.bitk = k;
            z2.avail_in = n2;
            z2.total_in += p2 - z2.next_in_index;
            z2.next_in_index = p2;
            that.write = q;
            return that.inflate_flush(z2, r2);
          }
          left = b & 65535;
          b = k = 0;
          mode2 = left !== 0 ? STORED : last !== 0 ? DRY : TYPE;
          break;
        case STORED:
          if (n2 === 0) {
            that.bitb = b;
            that.bitk = k;
            z2.avail_in = n2;
            z2.total_in += p2 - z2.next_in_index;
            z2.next_in_index = p2;
            that.write = q;
            return that.inflate_flush(z2, r2);
          }
          if (m === 0) {
            if (q == that.end && that.read !== 0) {
              q = 0;
              m = q < that.read ? that.read - q - 1 : that.end - q;
            }
            if (m === 0) {
              that.write = q;
              r2 = that.inflate_flush(z2, r2);
              q = that.write;
              m = q < that.read ? that.read - q - 1 : that.end - q;
              if (q == that.end && that.read !== 0) {
                q = 0;
                m = q < that.read ? that.read - q - 1 : that.end - q;
              }
              if (m === 0) {
                that.bitb = b;
                that.bitk = k;
                z2.avail_in = n2;
                z2.total_in += p2 - z2.next_in_index;
                z2.next_in_index = p2;
                that.write = q;
                return that.inflate_flush(z2, r2);
              }
            }
          }
          r2 = Z_OK;
          t = left;
          if (t > n2)
            t = n2;
          if (t > m)
            t = m;
          that.win.set(z2.read_buf(p2, t), q);
          p2 += t;
          n2 -= t;
          q += t;
          m -= t;
          if ((left -= t) !== 0)
            break;
          mode2 = last !== 0 ? DRY : TYPE;
          break;
        case TABLE:
          while (k < 14) {
            if (n2 !== 0) {
              r2 = Z_OK;
            } else {
              that.bitb = b;
              that.bitk = k;
              z2.avail_in = n2;
              z2.total_in += p2 - z2.next_in_index;
              z2.next_in_index = p2;
              that.write = q;
              return that.inflate_flush(z2, r2);
            }
            n2--;
            b |= (z2.read_byte(p2++) & 255) << k;
            k += 8;
          }
          table2 = t = b & 16383;
          if ((t & 31) > 29 || (t >> 5 & 31) > 29) {
            mode2 = BADBLOCKS;
            z2.msg = "too many length or distance symbols";
            r2 = Z_DATA_ERROR;
            that.bitb = b;
            that.bitk = k;
            z2.avail_in = n2;
            z2.total_in += p2 - z2.next_in_index;
            z2.next_in_index = p2;
            that.write = q;
            return that.inflate_flush(z2, r2);
          }
          t = 258 + (t & 31) + (t >> 5 & 31);
          if (!blens || blens.length < t) {
            blens = [];
          } else {
            for (i2 = 0; i2 < t; i2++) {
              blens[i2] = 0;
            }
          }
          b >>>= 14;
          k -= 14;
          index2 = 0;
          mode2 = BTREE;
        case BTREE:
          while (index2 < 4 + (table2 >>> 10)) {
            while (k < 3) {
              if (n2 !== 0) {
                r2 = Z_OK;
              } else {
                that.bitb = b;
                that.bitk = k;
                z2.avail_in = n2;
                z2.total_in += p2 - z2.next_in_index;
                z2.next_in_index = p2;
                that.write = q;
                return that.inflate_flush(z2, r2);
              }
              n2--;
              b |= (z2.read_byte(p2++) & 255) << k;
              k += 8;
            }
            blens[border[index2++]] = b & 7;
            b >>>= 3;
            k -= 3;
          }
          while (index2 < 19) {
            blens[border[index2++]] = 0;
          }
          bb[0] = 7;
          t = inftree.inflate_trees_bits(blens, bb, tb, hufts, z2);
          if (t != Z_OK) {
            r2 = t;
            if (r2 == Z_DATA_ERROR) {
              blens = null;
              mode2 = BADBLOCKS;
            }
            that.bitb = b;
            that.bitk = k;
            z2.avail_in = n2;
            z2.total_in += p2 - z2.next_in_index;
            z2.next_in_index = p2;
            that.write = q;
            return that.inflate_flush(z2, r2);
          }
          index2 = 0;
          mode2 = DTREE;
        case DTREE:
          while (true) {
            t = table2;
            if (index2 >= 258 + (t & 31) + (t >> 5 & 31)) {
              break;
            }
            let j, c14;
            t = bb[0];
            while (k < t) {
              if (n2 !== 0) {
                r2 = Z_OK;
              } else {
                that.bitb = b;
                that.bitk = k;
                z2.avail_in = n2;
                z2.total_in += p2 - z2.next_in_index;
                z2.next_in_index = p2;
                that.write = q;
                return that.inflate_flush(z2, r2);
              }
              n2--;
              b |= (z2.read_byte(p2++) & 255) << k;
              k += 8;
            }
            t = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 1];
            c14 = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 2];
            if (c14 < 16) {
              b >>>= t;
              k -= t;
              blens[index2++] = c14;
            } else {
              i2 = c14 == 18 ? 7 : c14 - 14;
              j = c14 == 18 ? 11 : 3;
              while (k < t + i2) {
                if (n2 !== 0) {
                  r2 = Z_OK;
                } else {
                  that.bitb = b;
                  that.bitk = k;
                  z2.avail_in = n2;
                  z2.total_in += p2 - z2.next_in_index;
                  z2.next_in_index = p2;
                  that.write = q;
                  return that.inflate_flush(z2, r2);
                }
                n2--;
                b |= (z2.read_byte(p2++) & 255) << k;
                k += 8;
              }
              b >>>= t;
              k -= t;
              j += b & inflate_mask[i2];
              b >>>= i2;
              k -= i2;
              i2 = index2;
              t = table2;
              if (i2 + j > 258 + (t & 31) + (t >> 5 & 31) || c14 == 16 && i2 < 1) {
                blens = null;
                mode2 = BADBLOCKS;
                z2.msg = "invalid bit length repeat";
                r2 = Z_DATA_ERROR;
                that.bitb = b;
                that.bitk = k;
                z2.avail_in = n2;
                z2.total_in += p2 - z2.next_in_index;
                z2.next_in_index = p2;
                that.write = q;
                return that.inflate_flush(z2, r2);
              }
              c14 = c14 == 16 ? blens[i2 - 1] : 0;
              do {
                blens[i2++] = c14;
              } while (--j !== 0);
              index2 = i2;
            }
          }
          tb[0] = -1;
          bl_ = [];
          bd_ = [];
          tl_ = [];
          td_ = [];
          bl_[0] = 9;
          bd_[0] = 6;
          t = table2;
          t = inftree.inflate_trees_dynamic(257 + (t & 31), 1 + (t >> 5 & 31), blens, bl_, bd_, tl_, td_, hufts, z2);
          if (t != Z_OK) {
            if (t == Z_DATA_ERROR) {
              blens = null;
              mode2 = BADBLOCKS;
            }
            r2 = t;
            that.bitb = b;
            that.bitk = k;
            z2.avail_in = n2;
            z2.total_in += p2 - z2.next_in_index;
            z2.next_in_index = p2;
            that.write = q;
            return that.inflate_flush(z2, r2);
          }
          codes.init(bl_[0], bd_[0], hufts, tl_[0], hufts, td_[0]);
          mode2 = CODES;
        case CODES:
          that.bitb = b;
          that.bitk = k;
          z2.avail_in = n2;
          z2.total_in += p2 - z2.next_in_index;
          z2.next_in_index = p2;
          that.write = q;
          if ((r2 = codes.proc(that, z2, r2)) != Z_STREAM_END) {
            return that.inflate_flush(z2, r2);
          }
          r2 = Z_OK;
          codes.free(z2);
          p2 = z2.next_in_index;
          n2 = z2.avail_in;
          b = that.bitb;
          k = that.bitk;
          q = that.write;
          m = q < that.read ? that.read - q - 1 : that.end - q;
          if (last === 0) {
            mode2 = TYPE;
            break;
          }
          mode2 = DRY;
        case DRY:
          that.write = q;
          r2 = that.inflate_flush(z2, r2);
          q = that.write;
          m = q < that.read ? that.read - q - 1 : that.end - q;
          if (that.read != that.write) {
            that.bitb = b;
            that.bitk = k;
            z2.avail_in = n2;
            z2.total_in += p2 - z2.next_in_index;
            z2.next_in_index = p2;
            that.write = q;
            return that.inflate_flush(z2, r2);
          }
          mode2 = DONELOCKS;
        case DONELOCKS:
          r2 = Z_STREAM_END;
          that.bitb = b;
          that.bitk = k;
          z2.avail_in = n2;
          z2.total_in += p2 - z2.next_in_index;
          z2.next_in_index = p2;
          that.write = q;
          return that.inflate_flush(z2, r2);
        case BADBLOCKS:
          r2 = Z_DATA_ERROR;
          that.bitb = b;
          that.bitk = k;
          z2.avail_in = n2;
          z2.total_in += p2 - z2.next_in_index;
          z2.next_in_index = p2;
          that.write = q;
          return that.inflate_flush(z2, r2);
        default:
          r2 = Z_STREAM_ERROR;
          that.bitb = b;
          that.bitk = k;
          z2.avail_in = n2;
          z2.total_in += p2 - z2.next_in_index;
          z2.next_in_index = p2;
          that.write = q;
          return that.inflate_flush(z2, r2);
      }
    }
  };
  that.free = function(z2) {
    that.reset(z2, null);
    that.win = null;
    hufts = null;
  };
  that.set_dictionary = function(d, start, n2) {
    that.win.set(d.subarray(start, start + n2), 0);
    that.read = that.write = n2;
  };
  that.sync_point = function() {
    return mode2 == LENS ? 1 : 0;
  };
}
var PRESET_DICT = 32;
var Z_DEFLATED = 8;
var METHOD = 0;
var FLAG = 1;
var DICT4 = 2;
var DICT3 = 3;
var DICT2 = 4;
var DICT1 = 5;
var DICT0 = 6;
var BLOCKS = 7;
var DONE = 12;
var BAD = 13;
var mark = [0, 0, 255, 255];
function Inflate$1() {
  const that = this;
  that.mode = 0;
  that.method = 0;
  that.was = [0];
  that.need = 0;
  that.marker = 0;
  that.wbits = 0;
  function inflateReset3(z) {
    if (!z || !z.istate)
      return Z_STREAM_ERROR;
    z.total_in = z.total_out = 0;
    z.msg = null;
    z.istate.mode = BLOCKS;
    z.istate.blocks.reset(z, null);
    return Z_OK;
  }
  that.inflateEnd = function(z) {
    if (that.blocks)
      that.blocks.free(z);
    that.blocks = null;
    return Z_OK;
  };
  that.inflateInit = function(z, w) {
    z.msg = null;
    that.blocks = null;
    if (w < 8 || w > 15) {
      that.inflateEnd(z);
      return Z_STREAM_ERROR;
    }
    that.wbits = w;
    z.istate.blocks = new InfBlocks(z, 1 << w);
    inflateReset3(z);
    return Z_OK;
  };
  that.inflate = function(z, f2) {
    let r2;
    let b;
    if (!z || !z.istate || !z.next_in)
      return Z_STREAM_ERROR;
    const istate = z.istate;
    f2 = f2 == Z_FINISH ? Z_BUF_ERROR : Z_OK;
    r2 = Z_BUF_ERROR;
    while (true) {
      switch (istate.mode) {
        case METHOD:
          if (z.avail_in === 0)
            return r2;
          r2 = f2;
          z.avail_in--;
          z.total_in++;
          if (((istate.method = z.read_byte(z.next_in_index++)) & 15) != Z_DEFLATED) {
            istate.mode = BAD;
            z.msg = "unknown compression method";
            istate.marker = 5;
            break;
          }
          if ((istate.method >> 4) + 8 > istate.wbits) {
            istate.mode = BAD;
            z.msg = "invalid win size";
            istate.marker = 5;
            break;
          }
          istate.mode = FLAG;
        case FLAG:
          if (z.avail_in === 0)
            return r2;
          r2 = f2;
          z.avail_in--;
          z.total_in++;
          b = z.read_byte(z.next_in_index++) & 255;
          if (((istate.method << 8) + b) % 31 !== 0) {
            istate.mode = BAD;
            z.msg = "incorrect header check";
            istate.marker = 5;
            break;
          }
          if ((b & PRESET_DICT) === 0) {
            istate.mode = BLOCKS;
            break;
          }
          istate.mode = DICT4;
        case DICT4:
          if (z.avail_in === 0)
            return r2;
          r2 = f2;
          z.avail_in--;
          z.total_in++;
          istate.need = (z.read_byte(z.next_in_index++) & 255) << 24 & 4278190080;
          istate.mode = DICT3;
        case DICT3:
          if (z.avail_in === 0)
            return r2;
          r2 = f2;
          z.avail_in--;
          z.total_in++;
          istate.need += (z.read_byte(z.next_in_index++) & 255) << 16 & 16711680;
          istate.mode = DICT2;
        case DICT2:
          if (z.avail_in === 0)
            return r2;
          r2 = f2;
          z.avail_in--;
          z.total_in++;
          istate.need += (z.read_byte(z.next_in_index++) & 255) << 8 & 65280;
          istate.mode = DICT1;
        case DICT1:
          if (z.avail_in === 0)
            return r2;
          r2 = f2;
          z.avail_in--;
          z.total_in++;
          istate.need += z.read_byte(z.next_in_index++) & 255;
          istate.mode = DICT0;
          return Z_NEED_DICT;
        case DICT0:
          istate.mode = BAD;
          z.msg = "need dictionary";
          istate.marker = 0;
          return Z_STREAM_ERROR;
        case BLOCKS:
          r2 = istate.blocks.proc(z, r2);
          if (r2 == Z_DATA_ERROR) {
            istate.mode = BAD;
            istate.marker = 0;
            break;
          }
          if (r2 == Z_OK) {
            r2 = f2;
          }
          if (r2 != Z_STREAM_END) {
            return r2;
          }
          r2 = f2;
          istate.blocks.reset(z, istate.was);
          istate.mode = DONE;
        case DONE:
          z.avail_in = 0;
          return Z_STREAM_END;
        case BAD:
          return Z_DATA_ERROR;
        default:
          return Z_STREAM_ERROR;
      }
    }
  };
  that.inflateSetDictionary = function(z, dictionary, dictLength) {
    let index2 = 0, length3 = dictLength;
    if (!z || !z.istate || z.istate.mode != DICT0)
      return Z_STREAM_ERROR;
    const istate = z.istate;
    if (length3 >= 1 << istate.wbits) {
      length3 = (1 << istate.wbits) - 1;
      index2 = dictLength - length3;
    }
    istate.blocks.set_dictionary(dictionary, index2, length3);
    istate.mode = BLOCKS;
    return Z_OK;
  };
  that.inflateSync = function(z) {
    let n2;
    let p2;
    let m;
    let r2, w;
    if (!z || !z.istate)
      return Z_STREAM_ERROR;
    const istate = z.istate;
    if (istate.mode != BAD) {
      istate.mode = BAD;
      istate.marker = 0;
    }
    if ((n2 = z.avail_in) === 0)
      return Z_BUF_ERROR;
    p2 = z.next_in_index;
    m = istate.marker;
    while (n2 !== 0 && m < 4) {
      if (z.read_byte(p2) == mark[m]) {
        m++;
      } else if (z.read_byte(p2) !== 0) {
        m = 0;
      } else {
        m = 4 - m;
      }
      p2++;
      n2--;
    }
    z.total_in += p2 - z.next_in_index;
    z.next_in_index = p2;
    z.avail_in = n2;
    istate.marker = m;
    if (m != 4) {
      return Z_DATA_ERROR;
    }
    r2 = z.total_in;
    w = z.total_out;
    inflateReset3(z);
    z.total_in = r2;
    z.total_out = w;
    istate.mode = BLOCKS;
    return Z_OK;
  };
  that.inflateSyncPoint = function(z) {
    if (!z || !z.istate || !z.istate.blocks)
      return Z_STREAM_ERROR;
    return z.istate.blocks.sync_point();
  };
}
function ZStream() {
}
ZStream.prototype = {
  inflateInit: function(bits) {
    const that = this;
    that.istate = new Inflate$1();
    if (!bits)
      bits = MAX_BITS;
    return that.istate.inflateInit(that, bits);
  },
  inflate: function(f2) {
    const that = this;
    if (!that.istate)
      return Z_STREAM_ERROR;
    return that.istate.inflate(that, f2);
  },
  inflateEnd: function() {
    const that = this;
    if (!that.istate)
      return Z_STREAM_ERROR;
    const ret = that.istate.inflateEnd(that);
    that.istate = null;
    return ret;
  },
  inflateSync: function() {
    const that = this;
    if (!that.istate)
      return Z_STREAM_ERROR;
    return that.istate.inflateSync(that);
  },
  inflateSetDictionary: function(dictionary, dictLength) {
    const that = this;
    if (!that.istate)
      return Z_STREAM_ERROR;
    return that.istate.inflateSetDictionary(that, dictionary, dictLength);
  },
  read_byte: function(start) {
    const that = this;
    return that.next_in[start];
  },
  read_buf: function(start, size) {
    const that = this;
    return that.next_in.subarray(start, start + size);
  }
};
function ZipInflate(options) {
  const that = this;
  const z = new ZStream();
  const bufsize = options && options.chunkSize ? Math.floor(options.chunkSize * 2) : 128 * 1024;
  const flush = Z_NO_FLUSH;
  const buf = new Uint8Array(bufsize);
  let nomoreinput = false;
  z.inflateInit();
  z.next_out = buf;
  that.append = function(data, onprogress) {
    const buffers = [];
    let err, array, lastIndex = 0, bufferIndex = 0, bufferSize = 0;
    if (data.length === 0)
      return;
    z.next_in_index = 0;
    z.next_in = data;
    z.avail_in = data.length;
    do {
      z.next_out_index = 0;
      z.avail_out = bufsize;
      if (z.avail_in === 0 && !nomoreinput) {
        z.next_in_index = 0;
        nomoreinput = true;
      }
      err = z.inflate(flush);
      if (nomoreinput && err === Z_BUF_ERROR) {
        if (z.avail_in !== 0)
          throw new Error("inflating: bad input");
      } else if (err !== Z_OK && err !== Z_STREAM_END)
        throw new Error("inflating: " + z.msg);
      if ((nomoreinput || err === Z_STREAM_END) && z.avail_in === data.length)
        throw new Error("inflating: bad input");
      if (z.next_out_index)
        if (z.next_out_index === bufsize)
          buffers.push(new Uint8Array(buf));
        else
          buffers.push(buf.slice(0, z.next_out_index));
      bufferSize += z.next_out_index;
      if (onprogress && z.next_in_index > 0 && z.next_in_index != lastIndex) {
        onprogress(z.next_in_index);
        lastIndex = z.next_in_index;
      }
    } while (z.avail_in > 0 || z.avail_out === 0);
    if (buffers.length > 1) {
      array = new Uint8Array(bufferSize);
      buffers.forEach(function(chunk) {
        array.set(chunk, bufferIndex);
        bufferIndex += chunk.length;
      });
    } else {
      array = buffers[0] || new Uint8Array(0);
    }
    return array;
  };
  that.flush = function() {
    z.inflateEnd();
  };
}
var DEFAULT_CONFIGURATION = {
  chunkSize: 512 * 1024,
  maxWorkers: typeof navigator != "undefined" && navigator.hardwareConcurrency || 2,
  terminateWorkerTimeout: 5e3,
  useWebWorkers: true,
  workerScripts: void 0
};
var config = Object.assign({}, DEFAULT_CONFIGURATION);
function getConfiguration() {
  return config;
}
function configure(configuration) {
  if (configuration.baseURL !== void 0) {
    config.baseURL = configuration.baseURL;
  }
  if (configuration.chunkSize !== void 0) {
    config.chunkSize = configuration.chunkSize;
  }
  if (configuration.maxWorkers !== void 0) {
    config.maxWorkers = configuration.maxWorkers;
  }
  if (configuration.terminateWorkerTimeout !== void 0) {
    config.terminateWorkerTimeout = configuration.terminateWorkerTimeout;
  }
  if (configuration.useWebWorkers !== void 0) {
    config.useWebWorkers = configuration.useWebWorkers;
  }
  if (configuration.Deflate !== void 0) {
    config.Deflate = configuration.Deflate;
  }
  if (configuration.Inflate !== void 0) {
    config.Inflate = configuration.Inflate;
  }
  if (configuration.workerScripts !== void 0) {
    if (configuration.workerScripts.deflate) {
      if (!Array.isArray(configuration.workerScripts.deflate)) {
        throw new Error("workerScripts.deflate must be an array");
      }
      if (!config.workerScripts) {
        config.workerScripts = {};
      }
      config.workerScripts.deflate = configuration.workerScripts.deflate;
    }
    if (configuration.workerScripts.inflate) {
      if (!Array.isArray(configuration.workerScripts.inflate)) {
        throw new Error("workerScripts.inflate must be an array");
      }
      if (!config.workerScripts) {
        config.workerScripts = {};
      }
      config.workerScripts.inflate = configuration.workerScripts.inflate;
    }
  }
}
function getMimeType() {
  return "application/octet-stream";
}
var table = [];
for (let i2 = 0; i2 < 256; i2++) {
  let t = i2;
  for (let j = 0; j < 8; j++) {
    if (t & 1) {
      t = t >>> 1 ^ 3988292384;
    } else {
      t = t >>> 1;
    }
  }
  table[i2] = t;
}
var Crc32 = class {
  constructor(crc) {
    this.crc = crc || -1;
  }
  append(data) {
    let crc = this.crc | 0;
    for (let offset2 = 0, length3 = data.length | 0; offset2 < length3; offset2++) {
      crc = crc >>> 8 ^ table[(crc ^ data[offset2]) & 255];
    }
    this.crc = crc;
  }
  get() {
    return ~this.crc;
  }
};
function encodeText(value) {
  if (typeof TextEncoder == "undefined") {
    value = unescape(encodeURIComponent(value));
    const result = new Uint8Array(value.length);
    for (let i2 = 0; i2 < result.length; i2++) {
      result[i2] = value.charCodeAt(i2);
    }
    return result;
  } else {
    return new TextEncoder().encode(value);
  }
}
var bitArray = {
  concat(a1, a22) {
    if (a1.length === 0 || a22.length === 0) {
      return a1.concat(a22);
    }
    const last = a1[a1.length - 1], shift = bitArray.getPartial(last);
    if (shift === 32) {
      return a1.concat(a22);
    } else {
      return bitArray._shiftRight(a22, shift, last | 0, a1.slice(0, a1.length - 1));
    }
  },
  bitLength(a4) {
    const l2 = a4.length;
    if (l2 === 0) {
      return 0;
    }
    const x = a4[l2 - 1];
    return (l2 - 1) * 32 + bitArray.getPartial(x);
  },
  clamp(a4, len) {
    if (a4.length * 32 < len) {
      return a4;
    }
    a4 = a4.slice(0, Math.ceil(len / 32));
    const l2 = a4.length;
    len = len & 31;
    if (l2 > 0 && len) {
      a4[l2 - 1] = bitArray.partial(len, a4[l2 - 1] & 2147483648 >> len - 1, 1);
    }
    return a4;
  },
  partial(len, x, _end) {
    if (len === 32) {
      return x;
    }
    return (_end ? x | 0 : x << 32 - len) + len * 1099511627776;
  },
  getPartial(x) {
    return Math.round(x / 1099511627776) || 32;
  },
  _shiftRight(a4, shift, carry, out) {
    if (out === void 0) {
      out = [];
    }
    for (; shift >= 32; shift -= 32) {
      out.push(carry);
      carry = 0;
    }
    if (shift === 0) {
      return out.concat(a4);
    }
    for (let i2 = 0; i2 < a4.length; i2++) {
      out.push(carry | a4[i2] >>> shift);
      carry = a4[i2] << 32 - shift;
    }
    const last2 = a4.length ? a4[a4.length - 1] : 0;
    const shift2 = bitArray.getPartial(last2);
    out.push(bitArray.partial(shift + shift2 & 31, shift + shift2 > 32 ? carry : out.pop(), 1));
    return out;
  }
};
var codec = {
  bytes: {
    fromBits(arr) {
      const bl = bitArray.bitLength(arr);
      const byteLength = bl / 8;
      const out = new Uint8Array(byteLength);
      let tmp2;
      for (let i2 = 0; i2 < byteLength; i2++) {
        if ((i2 & 3) === 0) {
          tmp2 = arr[i2 / 4];
        }
        out[i2] = tmp2 >>> 24;
        tmp2 <<= 8;
      }
      return out;
    },
    toBits(bytes) {
      const out = [];
      let i2;
      let tmp2 = 0;
      for (i2 = 0; i2 < bytes.length; i2++) {
        tmp2 = tmp2 << 8 | bytes[i2];
        if ((i2 & 3) === 3) {
          out.push(tmp2);
          tmp2 = 0;
        }
      }
      if (i2 & 3) {
        out.push(bitArray.partial(8 * (i2 & 3), tmp2));
      }
      return out;
    }
  }
};
var hash = {};
hash.sha1 = function(hash2) {
  if (hash2) {
    this._h = hash2._h.slice(0);
    this._buffer = hash2._buffer.slice(0);
    this._length = hash2._length;
  } else {
    this.reset();
  }
};
hash.sha1.prototype = {
  blockSize: 512,
  reset: function() {
    const sha1 = this;
    sha1._h = this._init.slice(0);
    sha1._buffer = [];
    sha1._length = 0;
    return sha1;
  },
  update: function(data) {
    const sha1 = this;
    if (typeof data === "string") {
      data = codec.utf8String.toBits(data);
    }
    const b = sha1._buffer = bitArray.concat(sha1._buffer, data);
    const ol = sha1._length;
    const nl = sha1._length = ol + bitArray.bitLength(data);
    if (nl > 9007199254740991) {
      throw new Error("Cannot hash more than 2^53 - 1 bits");
    }
    const c14 = new Uint32Array(b);
    let j = 0;
    for (let i2 = sha1.blockSize + ol - (sha1.blockSize + ol & sha1.blockSize - 1); i2 <= nl; i2 += sha1.blockSize) {
      sha1._block(c14.subarray(16 * j, 16 * (j + 1)));
      j += 1;
    }
    b.splice(0, 16 * j);
    return sha1;
  },
  finalize: function() {
    const sha1 = this;
    let b = sha1._buffer;
    const h = sha1._h;
    b = bitArray.concat(b, [bitArray.partial(1, 1)]);
    for (let i2 = b.length + 2; i2 & 15; i2++) {
      b.push(0);
    }
    b.push(Math.floor(sha1._length / 4294967296));
    b.push(sha1._length | 0);
    while (b.length) {
      sha1._block(b.splice(0, 16));
    }
    sha1.reset();
    return h;
  },
  _init: [1732584193, 4023233417, 2562383102, 271733878, 3285377520],
  _key: [1518500249, 1859775393, 2400959708, 3395469782],
  _f: function(t, b, c14, d) {
    if (t <= 19) {
      return b & c14 | ~b & d;
    } else if (t <= 39) {
      return b ^ c14 ^ d;
    } else if (t <= 59) {
      return b & c14 | b & d | c14 & d;
    } else if (t <= 79) {
      return b ^ c14 ^ d;
    }
  },
  _S: function(n2, x) {
    return x << n2 | x >>> 32 - n2;
  },
  _block: function(words) {
    const sha1 = this;
    const h = sha1._h;
    const w = Array(80);
    for (let j = 0; j < 16; j++) {
      w[j] = words[j];
    }
    let a4 = h[0];
    let b = h[1];
    let c14 = h[2];
    let d = h[3];
    let e2 = h[4];
    for (let t = 0; t <= 79; t++) {
      if (t >= 16) {
        w[t] = sha1._S(1, w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]);
      }
      const tmp2 = sha1._S(5, a4) + sha1._f(t, b, c14, d) + e2 + w[t] + sha1._key[Math.floor(t / 20)] | 0;
      e2 = d;
      d = c14;
      c14 = sha1._S(30, b);
      b = a4;
      a4 = tmp2;
    }
    h[0] = h[0] + a4 | 0;
    h[1] = h[1] + b | 0;
    h[2] = h[2] + c14 | 0;
    h[3] = h[3] + d | 0;
    h[4] = h[4] + e2 | 0;
  }
};
var cipher = {};
cipher.aes = class {
  constructor(key) {
    const aes = this;
    aes._tables = [[[], [], [], [], []], [[], [], [], [], []]];
    if (!aes._tables[0][0][0]) {
      aes._precompute();
    }
    const sbox = aes._tables[0][4];
    const decTable = aes._tables[1];
    const keyLen = key.length;
    let i2, encKey, decKey, rcon = 1;
    if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
      throw new Error("invalid aes key size");
    }
    aes._key = [encKey = key.slice(0), decKey = []];
    for (i2 = keyLen; i2 < 4 * keyLen + 28; i2++) {
      let tmp2 = encKey[i2 - 1];
      if (i2 % keyLen === 0 || keyLen === 8 && i2 % keyLen === 4) {
        tmp2 = sbox[tmp2 >>> 24] << 24 ^ sbox[tmp2 >> 16 & 255] << 16 ^ sbox[tmp2 >> 8 & 255] << 8 ^ sbox[tmp2 & 255];
        if (i2 % keyLen === 0) {
          tmp2 = tmp2 << 8 ^ tmp2 >>> 24 ^ rcon << 24;
          rcon = rcon << 1 ^ (rcon >> 7) * 283;
        }
      }
      encKey[i2] = encKey[i2 - keyLen] ^ tmp2;
    }
    for (let j = 0; i2; j++, i2--) {
      const tmp2 = encKey[j & 3 ? i2 : i2 - 4];
      if (i2 <= 4 || j < 4) {
        decKey[j] = tmp2;
      } else {
        decKey[j] = decTable[0][sbox[tmp2 >>> 24]] ^ decTable[1][sbox[tmp2 >> 16 & 255]] ^ decTable[2][sbox[tmp2 >> 8 & 255]] ^ decTable[3][sbox[tmp2 & 255]];
      }
    }
  }
  encrypt(data) {
    return this._crypt(data, 0);
  }
  decrypt(data) {
    return this._crypt(data, 1);
  }
  _precompute() {
    const encTable = this._tables[0];
    const decTable = this._tables[1];
    const sbox = encTable[4];
    const sboxInv = decTable[4];
    const d = [];
    const th = [];
    let xInv, x2, x4, x8;
    for (let i2 = 0; i2 < 256; i2++) {
      th[(d[i2] = i2 << 1 ^ (i2 >> 7) * 283) ^ i2] = i2;
    }
    for (let x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
      let s2 = xInv ^ xInv << 1 ^ xInv << 2 ^ xInv << 3 ^ xInv << 4;
      s2 = s2 >> 8 ^ s2 & 255 ^ 99;
      sbox[x] = s2;
      sboxInv[s2] = x;
      x8 = d[x4 = d[x2 = d[x]]];
      let tDec = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
      let tEnc = d[s2] * 257 ^ s2 * 16843008;
      for (let i2 = 0; i2 < 4; i2++) {
        encTable[i2][x] = tEnc = tEnc << 24 ^ tEnc >>> 8;
        decTable[i2][s2] = tDec = tDec << 24 ^ tDec >>> 8;
      }
    }
    for (let i2 = 0; i2 < 5; i2++) {
      encTable[i2] = encTable[i2].slice(0);
      decTable[i2] = decTable[i2].slice(0);
    }
  }
  _crypt(input, dir) {
    if (input.length !== 4) {
      throw new Error("invalid aes block size");
    }
    const key = this._key[dir];
    const nInnerRounds = key.length / 4 - 2;
    const out = [0, 0, 0, 0];
    const table2 = this._tables[dir];
    const t0 = table2[0];
    const t1 = table2[1];
    const t2 = table2[2];
    const t3 = table2[3];
    const sbox = table2[4];
    let a4 = input[0] ^ key[0];
    let b = input[dir ? 3 : 1] ^ key[1];
    let c14 = input[2] ^ key[2];
    let d = input[dir ? 1 : 3] ^ key[3];
    let kIndex = 4;
    let a22, b2, c22;
    for (let i2 = 0; i2 < nInnerRounds; i2++) {
      a22 = t0[a4 >>> 24] ^ t1[b >> 16 & 255] ^ t2[c14 >> 8 & 255] ^ t3[d & 255] ^ key[kIndex];
      b2 = t0[b >>> 24] ^ t1[c14 >> 16 & 255] ^ t2[d >> 8 & 255] ^ t3[a4 & 255] ^ key[kIndex + 1];
      c22 = t0[c14 >>> 24] ^ t1[d >> 16 & 255] ^ t2[a4 >> 8 & 255] ^ t3[b & 255] ^ key[kIndex + 2];
      d = t0[d >>> 24] ^ t1[a4 >> 16 & 255] ^ t2[b >> 8 & 255] ^ t3[c14 & 255] ^ key[kIndex + 3];
      kIndex += 4;
      a4 = a22;
      b = b2;
      c14 = c22;
    }
    for (let i2 = 0; i2 < 4; i2++) {
      out[dir ? 3 & -i2 : i2] = sbox[a4 >>> 24] << 24 ^ sbox[b >> 16 & 255] << 16 ^ sbox[c14 >> 8 & 255] << 8 ^ sbox[d & 255] ^ key[kIndex++];
      a22 = a4;
      a4 = b;
      b = c14;
      c14 = d;
      d = a22;
    }
    return out;
  }
};
var random = {
  getRandomValues(typedArray) {
    const words = new Uint32Array(typedArray.buffer);
    const r2 = (m_w) => {
      let m_z = 987654321;
      const mask = 4294967295;
      return function() {
        m_z = 36969 * (m_z & 65535) + (m_z >> 16) & mask;
        m_w = 18e3 * (m_w & 65535) + (m_w >> 16) & mask;
        const result = ((m_z << 16) + m_w & mask) / 4294967296 + 0.5;
        return result * (Math.random() > 0.5 ? 1 : -1);
      };
    };
    for (let i2 = 0, rcache; i2 < typedArray.length; i2 += 4) {
      let _r = r2((rcache || Math.random()) * 4294967296);
      rcache = _r() * 987654071;
      words[i2 / 4] = _r() * 4294967296 | 0;
    }
    return typedArray;
  }
};
var mode = {};
mode.ctrGladman = class {
  constructor(prf, iv) {
    this._prf = prf;
    this._initIv = iv;
    this._iv = iv;
  }
  reset() {
    this._iv = this._initIv;
  }
  update(data) {
    return this.calculate(this._prf, data, this._iv);
  }
  incWord(word) {
    if ((word >> 24 & 255) === 255) {
      let b1 = word >> 16 & 255;
      let b2 = word >> 8 & 255;
      let b3 = word & 255;
      if (b1 === 255) {
        b1 = 0;
        if (b2 === 255) {
          b2 = 0;
          if (b3 === 255) {
            b3 = 0;
          } else {
            ++b3;
          }
        } else {
          ++b2;
        }
      } else {
        ++b1;
      }
      word = 0;
      word += b1 << 16;
      word += b2 << 8;
      word += b3;
    } else {
      word += 1 << 24;
    }
    return word;
  }
  incCounter(counter) {
    if ((counter[0] = this.incWord(counter[0])) === 0) {
      counter[1] = this.incWord(counter[1]);
    }
  }
  calculate(prf, data, iv) {
    let l2;
    if (!(l2 = data.length)) {
      return [];
    }
    const bl = bitArray.bitLength(data);
    for (let i2 = 0; i2 < l2; i2 += 4) {
      this.incCounter(iv);
      const e2 = prf.encrypt(iv);
      data[i2] ^= e2[0];
      data[i2 + 1] ^= e2[1];
      data[i2 + 2] ^= e2[2];
      data[i2 + 3] ^= e2[3];
    }
    return bitArray.clamp(data, bl);
  }
};
var misc = {
  importKey(password) {
    return new misc.hmacSha1(codec.bytes.toBits(password));
  },
  pbkdf2(prf, salt, count, length3) {
    count = count || 1e4;
    if (length3 < 0 || count < 0) {
      throw new Error("invalid params to pbkdf2");
    }
    const byteLength = (length3 >> 5) + 1 << 2;
    let u3, ui, i2, j, k;
    const arrayBuffer = new ArrayBuffer(byteLength);
    let out = new DataView(arrayBuffer);
    let outLength = 0;
    const b = bitArray;
    salt = codec.bytes.toBits(salt);
    for (k = 1; outLength < (byteLength || 1); k++) {
      u3 = ui = prf.encrypt(b.concat(salt, [k]));
      for (i2 = 1; i2 < count; i2++) {
        ui = prf.encrypt(ui);
        for (j = 0; j < ui.length; j++) {
          u3[j] ^= ui[j];
        }
      }
      for (i2 = 0; outLength < (byteLength || 1) && i2 < u3.length; i2++) {
        out.setInt32(outLength, u3[i2]);
        outLength += 4;
      }
    }
    return arrayBuffer.slice(0, length3 / 8);
  }
};
misc.hmacSha1 = class {
  constructor(key) {
    const hmac = this;
    const Hash = hmac._hash = hash.sha1;
    const exKey = [[], []];
    const bs = Hash.prototype.blockSize / 32;
    hmac._baseHash = [new Hash(), new Hash()];
    if (key.length > bs) {
      key = Hash.hash(key);
    }
    for (let i2 = 0; i2 < bs; i2++) {
      exKey[0][i2] = key[i2] ^ 909522486;
      exKey[1][i2] = key[i2] ^ 1549556828;
    }
    hmac._baseHash[0].update(exKey[0]);
    hmac._baseHash[1].update(exKey[1]);
    hmac._resultHash = new Hash(hmac._baseHash[0]);
  }
  reset() {
    const hmac = this;
    hmac._resultHash = new hmac._hash(hmac._baseHash[0]);
    hmac._updated = false;
  }
  update(data) {
    const hmac = this;
    hmac._updated = true;
    hmac._resultHash.update(data);
  }
  digest() {
    const hmac = this;
    const w = hmac._resultHash.finalize();
    const result = new hmac._hash(hmac._baseHash[1]).update(w).finalize();
    hmac.reset();
    return result;
  }
  encrypt(data) {
    if (!this._updated) {
      this.update(data);
      return this.digest(data);
    } else {
      throw new Error("encrypt on already updated hmac called!");
    }
  }
};
var ERR_INVALID_PASSWORD = "Invalid pasword";
var BLOCK_LENGTH = 16;
var RAW_FORMAT = "raw";
var PBKDF2_ALGORITHM = { name: "PBKDF2" };
var HASH_ALGORITHM = { name: "HMAC" };
var HASH_FUNCTION = "SHA-1";
var BASE_KEY_ALGORITHM = Object.assign({ hash: HASH_ALGORITHM }, PBKDF2_ALGORITHM);
var DERIVED_BITS_ALGORITHM = Object.assign({ iterations: 1e3, hash: { name: HASH_FUNCTION } }, PBKDF2_ALGORITHM);
var DERIVED_BITS_USAGE = ["deriveBits"];
var SALT_LENGTH = [8, 12, 16];
var KEY_LENGTH = [16, 24, 32];
var SIGNATURE_LENGTH = 10;
var COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
var CRYPTO_API_SUPPORTED = typeof crypto != "undefined";
var SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof crypto.subtle != "undefined";
var codecBytes = codec.bytes;
var Aes = cipher.aes;
var CtrGladman = mode.ctrGladman;
var HmacSha1 = misc.hmacSha1;
var AESDecrypt = class {
  constructor(password, signed, strength) {
    Object.assign(this, {
      password,
      signed,
      strength: strength - 1,
      pendingInput: new Uint8Array(0)
    });
  }
  async append(input) {
    const aesCrypto = this;
    if (aesCrypto.password) {
      const preamble = subarray(input, 0, SALT_LENGTH[aesCrypto.strength] + 2);
      await createDecryptionKeys(aesCrypto, preamble, aesCrypto.password);
      aesCrypto.password = null;
      aesCrypto.aesCtrGladman = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
      aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
      input = subarray(input, SALT_LENGTH[aesCrypto.strength] + 2);
    }
    const output = new Uint8Array(input.length - SIGNATURE_LENGTH - (input.length - SIGNATURE_LENGTH) % BLOCK_LENGTH);
    return append(aesCrypto, input, output, 0, SIGNATURE_LENGTH, true);
  }
  flush() {
    const aesCrypto = this;
    const pendingInput = aesCrypto.pendingInput;
    const chunkToDecrypt = subarray(pendingInput, 0, pendingInput.length - SIGNATURE_LENGTH);
    const originalSignature = subarray(pendingInput, pendingInput.length - SIGNATURE_LENGTH);
    let decryptedChunkArray = new Uint8Array(0);
    if (chunkToDecrypt.length) {
      const encryptedChunk = codecBytes.toBits(chunkToDecrypt);
      aesCrypto.hmac.update(encryptedChunk);
      const decryptedChunk = aesCrypto.aesCtrGladman.update(encryptedChunk);
      decryptedChunkArray = codecBytes.fromBits(decryptedChunk);
    }
    let valid = true;
    if (aesCrypto.signed) {
      const signature = subarray(codecBytes.fromBits(aesCrypto.hmac.digest()), 0, SIGNATURE_LENGTH);
      for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) {
        if (signature[indexSignature] != originalSignature[indexSignature]) {
          valid = false;
        }
      }
    }
    return {
      valid,
      data: decryptedChunkArray
    };
  }
};
var AESEncrypt = class {
  constructor(password, strength) {
    Object.assign(this, {
      password,
      strength: strength - 1,
      pendingInput: new Uint8Array(0)
    });
  }
  async append(input) {
    const aesCrypto = this;
    let preamble = new Uint8Array(0);
    if (aesCrypto.password) {
      preamble = await createEncryptionKeys(aesCrypto, aesCrypto.password);
      aesCrypto.password = null;
      aesCrypto.aesCtrGladman = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
      aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
    }
    const output = new Uint8Array(preamble.length + input.length - input.length % BLOCK_LENGTH);
    output.set(preamble, 0);
    return append(aesCrypto, input, output, preamble.length, 0);
  }
  flush() {
    const aesCrypto = this;
    let encryptedChunkArray = new Uint8Array(0);
    if (aesCrypto.pendingInput.length) {
      const encryptedChunk = aesCrypto.aesCtrGladman.update(codecBytes.toBits(aesCrypto.pendingInput));
      aesCrypto.hmac.update(encryptedChunk);
      encryptedChunkArray = codecBytes.fromBits(encryptedChunk);
    }
    const signature = subarray(codecBytes.fromBits(aesCrypto.hmac.digest()), 0, SIGNATURE_LENGTH);
    return {
      data: concat(encryptedChunkArray, signature),
      signature
    };
  }
};
function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignature) {
  const inputLength = input.length - paddingEnd;
  if (aesCrypto.pendingInput.length) {
    input = concat(aesCrypto.pendingInput, input);
    output = expand(output, inputLength - inputLength % BLOCK_LENGTH);
  }
  let offset2;
  for (offset2 = 0; offset2 <= inputLength - BLOCK_LENGTH; offset2 += BLOCK_LENGTH) {
    const inputChunk = codecBytes.toBits(subarray(input, offset2, offset2 + BLOCK_LENGTH));
    if (verifySignature) {
      aesCrypto.hmac.update(inputChunk);
    }
    const outputChunk = aesCrypto.aesCtrGladman.update(inputChunk);
    if (!verifySignature) {
      aesCrypto.hmac.update(outputChunk);
    }
    output.set(codecBytes.fromBits(outputChunk), offset2 + paddingStart);
  }
  aesCrypto.pendingInput = subarray(input, offset2);
  return output;
}
async function createDecryptionKeys(decrypt2, preambleArray, password) {
  await createKeys$1(decrypt2, password, subarray(preambleArray, 0, SALT_LENGTH[decrypt2.strength]));
  const passwordVerification = subarray(preambleArray, SALT_LENGTH[decrypt2.strength]);
  const passwordVerificationKey = decrypt2.keys.passwordVerification;
  if (passwordVerificationKey[0] != passwordVerification[0] || passwordVerificationKey[1] != passwordVerification[1]) {
    throw new Error(ERR_INVALID_PASSWORD);
  }
}
async function createEncryptionKeys(encrypt2, password) {
  const salt = getRandomValues3(new Uint8Array(SALT_LENGTH[encrypt2.strength]));
  await createKeys$1(encrypt2, password, salt);
  return concat(salt, encrypt2.keys.passwordVerification);
}
async function createKeys$1(target, password, salt) {
  const encodedPassword = encodeText(password);
  const basekey = await importKey(RAW_FORMAT, encodedPassword, BASE_KEY_ALGORITHM, false, DERIVED_BITS_USAGE);
  const derivedBits = await deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), basekey, 8 * (KEY_LENGTH[target.strength] * 2 + 2));
  const compositeKey = new Uint8Array(derivedBits);
  target.keys = {
    key: codecBytes.toBits(subarray(compositeKey, 0, KEY_LENGTH[target.strength])),
    authentication: codecBytes.toBits(subarray(compositeKey, KEY_LENGTH[target.strength], KEY_LENGTH[target.strength] * 2)),
    passwordVerification: subarray(compositeKey, KEY_LENGTH[target.strength] * 2)
  };
}
function getRandomValues3(array) {
  if (CRYPTO_API_SUPPORTED && typeof crypto.getRandomValues == "function") {
    return crypto.getRandomValues(array);
  } else {
    return random.getRandomValues(array);
  }
}
async function importKey(format, password, algorithm, extractable, keyUsages) {
  if (CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.importKey == "function") {
    return crypto.subtle.importKey(format, password, algorithm, extractable, keyUsages);
  } else {
    return misc.importKey(password);
  }
}
async function deriveBits(algorithm, baseKey, length3) {
  if (CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.deriveBits == "function") {
    return await crypto.subtle.deriveBits(algorithm, baseKey, length3);
  } else {
    return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length3);
  }
}
function concat(leftArray, rightArray) {
  let array = leftArray;
  if (leftArray.length + rightArray.length) {
    array = new Uint8Array(leftArray.length + rightArray.length);
    array.set(leftArray, 0);
    array.set(rightArray, leftArray.length);
  }
  return array;
}
function expand(inputArray, length3) {
  if (length3 && length3 > inputArray.length) {
    const array = inputArray;
    inputArray = new Uint8Array(length3);
    inputArray.set(array, 0);
  }
  return inputArray;
}
function subarray(array, begin, end) {
  return array.subarray(begin, end);
}
var HEADER_LENGTH = 12;
var ZipCryptoDecrypt = class {
  constructor(password, passwordVerification) {
    const zipCrypto = this;
    Object.assign(zipCrypto, {
      password,
      passwordVerification
    });
    createKeys(zipCrypto, password);
  }
  append(input) {
    const zipCrypto = this;
    if (zipCrypto.password) {
      const decryptedHeader = decrypt(zipCrypto, input.subarray(0, HEADER_LENGTH));
      zipCrypto.password = null;
      if (decryptedHeader[HEADER_LENGTH - 1] != zipCrypto.passwordVerification) {
        throw new Error(ERR_INVALID_PASSWORD);
      }
      input = input.subarray(HEADER_LENGTH);
    }
    return decrypt(zipCrypto, input);
  }
  flush() {
    return {
      valid: true,
      data: new Uint8Array(0)
    };
  }
};
var ZipCryptoEncrypt = class {
  constructor(password, passwordVerification) {
    const zipCrypto = this;
    Object.assign(zipCrypto, {
      password,
      passwordVerification
    });
    createKeys(zipCrypto, password);
  }
  append(input) {
    const zipCrypto = this;
    let output;
    let offset2;
    if (zipCrypto.password) {
      zipCrypto.password = null;
      const header = crypto.getRandomValues(new Uint8Array(HEADER_LENGTH));
      header[HEADER_LENGTH - 1] = zipCrypto.passwordVerification;
      output = new Uint8Array(input.length + header.length);
      output.set(encrypt(zipCrypto, header), 0);
      offset2 = HEADER_LENGTH;
    } else {
      output = new Uint8Array(input.length);
      offset2 = 0;
    }
    output.set(encrypt(zipCrypto, input), offset2);
    return output;
  }
  flush() {
    return {
      data: new Uint8Array(0)
    };
  }
};
function decrypt(target, input) {
  const output = new Uint8Array(input.length);
  for (let index2 = 0; index2 < input.length; index2++) {
    output[index2] = getByte(target) ^ input[index2];
    updateKeys(target, output[index2]);
  }
  return output;
}
function encrypt(target, input) {
  const output = new Uint8Array(input.length);
  for (let index2 = 0; index2 < input.length; index2++) {
    output[index2] = getByte(target) ^ input[index2];
    updateKeys(target, input[index2]);
  }
  return output;
}
function createKeys(target, password) {
  target.keys = [305419896, 591751049, 878082192];
  target.crcKey0 = new Crc32(target.keys[0]);
  target.crcKey2 = new Crc32(target.keys[2]);
  for (let index2 = 0; index2 < password.length; index2++) {
    updateKeys(target, password.charCodeAt(index2));
  }
}
function updateKeys(target, byte) {
  target.crcKey0.append([byte]);
  target.keys[0] = ~target.crcKey0.get();
  target.keys[1] = getInt32(target.keys[1] + getInt8(target.keys[0]));
  target.keys[1] = getInt32(Math.imul(target.keys[1], 134775813) + 1);
  target.crcKey2.append([target.keys[1] >>> 24]);
  target.keys[2] = ~target.crcKey2.get();
}
function getByte(target) {
  const temp = target.keys[2] | 2;
  return getInt8(Math.imul(temp, temp ^ 1) >>> 8);
}
function getInt8(number) {
  return number & 255;
}
function getInt32(number) {
  return number & 4294967295;
}
var CODEC_DEFLATE = "deflate";
var CODEC_INFLATE = "inflate";
var ERR_INVALID_SIGNATURE = "Invalid signature";
var Inflate = class {
  constructor(codecConstructor, {
    signature,
    password,
    signed,
    compressed,
    zipCrypto,
    passwordVerification,
    encryptionStrength
  }, { chunkSize }) {
    const encrypted = Boolean(password);
    Object.assign(this, {
      signature,
      encrypted,
      signed,
      compressed,
      inflate: compressed && new codecConstructor({ chunkSize }),
      crc32: signed && new Crc32(),
      zipCrypto,
      decrypt: encrypted && zipCrypto ? new ZipCryptoDecrypt(password, passwordVerification) : new AESDecrypt(password, signed, encryptionStrength)
    });
  }
  async append(data) {
    const codec2 = this;
    if (codec2.encrypted && data.length) {
      data = await codec2.decrypt.append(data);
    }
    if (codec2.compressed && data.length) {
      data = await codec2.inflate.append(data);
    }
    if ((!codec2.encrypted || codec2.zipCrypto) && codec2.signed && data.length) {
      codec2.crc32.append(data);
    }
    return data;
  }
  async flush() {
    const codec2 = this;
    let signature;
    let data = new Uint8Array(0);
    if (codec2.encrypted) {
      const result = codec2.decrypt.flush();
      if (!result.valid) {
        throw new Error(ERR_INVALID_SIGNATURE);
      }
      data = result.data;
    }
    if ((!codec2.encrypted || codec2.zipCrypto) && codec2.signed) {
      const dataViewSignature = new DataView(new Uint8Array(4).buffer);
      signature = codec2.crc32.get();
      dataViewSignature.setUint32(0, signature);
      if (codec2.signature != dataViewSignature.getUint32(0, false)) {
        throw new Error(ERR_INVALID_SIGNATURE);
      }
    }
    if (codec2.compressed) {
      data = await codec2.inflate.append(data) || new Uint8Array(0);
      await codec2.inflate.flush();
    }
    return { data, signature };
  }
};
var Deflate = class {
  constructor(codecConstructor, {
    encrypted,
    signed,
    compressed,
    level,
    zipCrypto,
    password,
    passwordVerification,
    encryptionStrength
  }, { chunkSize }) {
    Object.assign(this, {
      encrypted,
      signed,
      compressed,
      deflate: compressed && new codecConstructor({ level: level || 5, chunkSize }),
      crc32: signed && new Crc32(),
      zipCrypto,
      encrypt: encrypted && zipCrypto ? new ZipCryptoEncrypt(password, passwordVerification) : new AESEncrypt(password, encryptionStrength)
    });
  }
  async append(inputData) {
    const codec2 = this;
    let data = inputData;
    if (codec2.compressed && inputData.length) {
      data = await codec2.deflate.append(inputData);
    }
    if (codec2.encrypted && data.length) {
      data = await codec2.encrypt.append(data);
    }
    if ((!codec2.encrypted || codec2.zipCrypto) && codec2.signed && inputData.length) {
      codec2.crc32.append(inputData);
    }
    return data;
  }
  async flush() {
    const codec2 = this;
    let signature;
    let data = new Uint8Array(0);
    if (codec2.compressed) {
      data = await codec2.deflate.flush() || new Uint8Array(0);
    }
    if (codec2.encrypted) {
      data = await codec2.encrypt.append(data);
      const result = codec2.encrypt.flush();
      signature = result.signature;
      const newData = new Uint8Array(data.length + result.data.length);
      newData.set(data, 0);
      newData.set(result.data, data.length);
      data = newData;
    }
    if ((!codec2.encrypted || codec2.zipCrypto) && codec2.signed) {
      signature = codec2.crc32.get();
    }
    return { data, signature };
  }
};
function createCodec$1(codecConstructor, options, config2) {
  if (options.codecType.startsWith(CODEC_DEFLATE)) {
    return new Deflate(codecConstructor, options, config2);
  } else if (options.codecType.startsWith(CODEC_INFLATE)) {
    return new Inflate(codecConstructor, options, config2);
  }
}
var MESSAGE_INIT = "init";
var MESSAGE_APPEND = "append";
var MESSAGE_FLUSH = "flush";
var MESSAGE_EVENT_TYPE = "message";
var classicWorkersSupported = true;
var getWorker = (workerData, codecConstructor, options, config2, onTaskFinished, webWorker, scripts) => {
  Object.assign(workerData, {
    busy: true,
    codecConstructor,
    options: Object.assign({}, options),
    scripts,
    terminate() {
      if (workerData.worker && !workerData.busy) {
        workerData.worker.terminate();
        workerData.interface = null;
      }
    },
    onTaskFinished() {
      workerData.busy = false;
      onTaskFinished(workerData);
    }
  });
  return webWorker ? createWebWorkerInterface(workerData, config2) : createWorkerInterface(workerData, config2);
};
function createWorkerInterface(workerData, config2) {
  const interfaceCodec = createCodec$1(workerData.codecConstructor, workerData.options, config2);
  return {
    async append(data) {
      try {
        return await interfaceCodec.append(data);
      } catch (error) {
        workerData.onTaskFinished();
        throw error;
      }
    },
    async flush() {
      try {
        return await interfaceCodec.flush();
      } finally {
        workerData.onTaskFinished();
      }
    },
    abort() {
      workerData.onTaskFinished();
    }
  };
}
function createWebWorkerInterface(workerData, config2) {
  let messageTask;
  const workerOptions = { type: "module" };
  if (!workerData.interface) {
    if (!classicWorkersSupported) {
      workerData.worker = getWorker2(workerOptions, config2.baseURL);
    } else {
      try {
        workerData.worker = getWorker2({}, config2.baseURL);
      } catch (error) {
        classicWorkersSupported = false;
        workerData.worker = getWorker2(workerOptions, config2.baseURL);
      }
    }
    workerData.worker.addEventListener(MESSAGE_EVENT_TYPE, onMessage, false);
    workerData.interface = {
      append(data) {
        return initAndSendMessage({ type: MESSAGE_APPEND, data });
      },
      flush() {
        return initAndSendMessage({ type: MESSAGE_FLUSH });
      },
      abort() {
        workerData.onTaskFinished();
      }
    };
  }
  return workerData.interface;
  function getWorker2(options, baseURL) {
    let url2, scriptUrl;
    url2 = workerData.scripts[0];
    if (typeof url2 == "function") {
      url2 = url2();
    }
    try {
      scriptUrl = new URL(url2, baseURL);
    } catch (error) {
      scriptUrl = url2;
    }
    return new Worker(scriptUrl, options);
  }
  async function initAndSendMessage(message) {
    if (!messageTask) {
      const options = workerData.options;
      const scripts = workerData.scripts.slice(1);
      await sendMessage({ scripts, type: MESSAGE_INIT, options, config: { chunkSize: config2.chunkSize } });
    }
    return sendMessage(message);
  }
  function sendMessage(message) {
    const worker = workerData.worker;
    const result = new Promise((resolve2, reject) => messageTask = { resolve: resolve2, reject });
    try {
      if (message.data) {
        try {
          message.data = message.data.buffer;
          worker.postMessage(message, [message.data]);
        } catch (error) {
          worker.postMessage(message);
        }
      } else {
        worker.postMessage(message);
      }
    } catch (error) {
      messageTask.reject(error);
      messageTask = null;
      workerData.onTaskFinished();
    }
    return result;
  }
  function onMessage(event) {
    const message = event.data;
    if (messageTask) {
      const reponseError = message.error;
      const type = message.type;
      if (reponseError) {
        const error = new Error(reponseError.message);
        error.stack = reponseError.stack;
        messageTask.reject(error);
        messageTask = null;
        workerData.onTaskFinished();
      } else if (type == MESSAGE_INIT || type == MESSAGE_FLUSH || type == MESSAGE_APPEND) {
        const data = message.data;
        if (type == MESSAGE_FLUSH) {
          messageTask.resolve({ data: new Uint8Array(data), signature: message.signature });
          messageTask = null;
          workerData.onTaskFinished();
        } else {
          messageTask.resolve(data && new Uint8Array(data));
        }
      }
    }
  }
}
var pool = [];
var pendingRequests = [];
function createCodec(codecConstructor, options, config2) {
  const streamCopy = !options.compressed && !options.signed && !options.encrypted;
  const webWorker = !streamCopy && (options.useWebWorkers || options.useWebWorkers === void 0 && config2.useWebWorkers);
  const scripts = webWorker && config2.workerScripts ? config2.workerScripts[options.codecType] : [];
  if (pool.length < config2.maxWorkers) {
    const workerData = {};
    pool.push(workerData);
    return getWorker(workerData, codecConstructor, options, config2, onTaskFinished, webWorker, scripts);
  } else {
    const workerData = pool.find((workerData2) => !workerData2.busy);
    if (workerData) {
      clearTerminateTimeout(workerData);
      return getWorker(workerData, codecConstructor, options, config2, onTaskFinished, webWorker, scripts);
    } else {
      return new Promise((resolve2) => pendingRequests.push({ resolve: resolve2, codecConstructor, options, webWorker, scripts }));
    }
  }
  function onTaskFinished(workerData) {
    if (pendingRequests.length) {
      const [{ resolve: resolve2, codecConstructor: codecConstructor2, options: options2, webWorker: webWorker2, scripts: scripts2 }] = pendingRequests.splice(0, 1);
      resolve2(getWorker(workerData, codecConstructor2, options2, config2, onTaskFinished, webWorker2, scripts2));
    } else if (workerData.worker) {
      clearTerminateTimeout(workerData);
      if (Number.isFinite(config2.terminateWorkerTimeout) && config2.terminateWorkerTimeout >= 0) {
        workerData.terminateTimeout = setTimeout(() => {
          pool = pool.filter((data) => data != workerData);
          workerData.terminate();
        }, config2.terminateWorkerTimeout);
      }
    } else {
      pool = pool.filter((data) => data != workerData);
    }
  }
}
function clearTerminateTimeout(workerData) {
  if (workerData.terminateTimeout) {
    clearTimeout(workerData.terminateTimeout);
    workerData.terminateTimeout = null;
  }
}
function terminateWorkers() {
  pool.forEach((workerData) => {
    clearTerminateTimeout(workerData);
    workerData.terminate();
  });
}
var MINIMUM_CHUNK_SIZE = 64;
var ERR_ABORT = "Abort error";
async function processData(codec2, reader, writer, offset2, inputLength, config2, options) {
  const chunkSize = Math.max(config2.chunkSize, MINIMUM_CHUNK_SIZE);
  return processChunk();
  async function processChunk(chunkOffset = 0, outputLength = 0) {
    const signal = options.signal;
    if (chunkOffset < inputLength) {
      testAborted(signal, codec2);
      const inputData = await reader.readUint8Array(chunkOffset + offset2, Math.min(chunkSize, inputLength - chunkOffset));
      const chunkLength = inputData.length;
      testAborted(signal, codec2);
      const data = await codec2.append(inputData);
      testAborted(signal, codec2);
      outputLength += await writeData(writer, data);
      if (options.onprogress) {
        try {
          options.onprogress(chunkOffset + chunkLength, inputLength);
        } catch (error) {
        }
      }
      return processChunk(chunkOffset + chunkSize, outputLength);
    } else {
      const result = await codec2.flush();
      outputLength += await writeData(writer, result.data);
      return { signature: result.signature, length: outputLength };
    }
  }
}
function testAborted(signal, codec2) {
  if (signal && signal.aborted) {
    codec2.abort();
    throw new Error(ERR_ABORT);
  }
}
async function writeData(writer, data) {
  if (data.length) {
    await writer.writeUint8Array(data);
  }
  return data.length;
}
var ERR_HTTP_STATUS = "HTTP error ";
var ERR_HTTP_RANGE = "HTTP Range not supported";
var CONTENT_TYPE_TEXT_PLAIN = "text/plain";
var HTTP_HEADER_CONTENT_LENGTH = "Content-Length";
var HTTP_HEADER_CONTENT_RANGE = "Content-Range";
var HTTP_HEADER_ACCEPT_RANGES = "Accept-Ranges";
var HTTP_HEADER_RANGE = "Range";
var HTTP_METHOD_HEAD = "HEAD";
var HTTP_METHOD_GET = "GET";
var HTTP_RANGE_UNIT = "bytes";
var Stream = class {
  constructor() {
    this.size = 0;
  }
  init() {
    this.initialized = true;
  }
};
var Reader = class extends Stream {
};
var Writer = class extends Stream {
  writeUint8Array(array) {
    this.size += array.length;
  }
};
var TextReader = class extends Reader {
  constructor(text2) {
    super();
    this.blobReader = new BlobReader(new Blob([text2], { type: CONTENT_TYPE_TEXT_PLAIN }));
  }
  async init() {
    super.init();
    this.blobReader.init();
    this.size = this.blobReader.size;
  }
  async readUint8Array(offset2, length3) {
    return this.blobReader.readUint8Array(offset2, length3);
  }
};
var TextWriter = class extends Writer {
  constructor(encoding) {
    super();
    this.encoding = encoding;
    this.blob = new Blob([], { type: CONTENT_TYPE_TEXT_PLAIN });
  }
  async writeUint8Array(array) {
    super.writeUint8Array(array);
    this.blob = new Blob([this.blob, array.buffer], { type: CONTENT_TYPE_TEXT_PLAIN });
  }
  getData() {
    if (this.blob.text) {
      return this.blob.text();
    } else {
      const reader = new FileReader();
      return new Promise((resolve2, reject) => {
        reader.onload = (event) => resolve2(event.target.result);
        reader.onerror = () => reject(reader.error);
        reader.readAsText(this.blob, this.encoding);
      });
    }
  }
};
var Data64URIReader = class extends Reader {
  constructor(dataURI) {
    super();
    this.dataURI = dataURI;
    let dataEnd = dataURI.length;
    while (dataURI.charAt(dataEnd - 1) == "=") {
      dataEnd--;
    }
    this.dataStart = dataURI.indexOf(",") + 1;
    this.size = Math.floor((dataEnd - this.dataStart) * 0.75);
  }
  async readUint8Array(offset2, length3) {
    const dataArray = new Uint8Array(length3);
    const start = Math.floor(offset2 / 3) * 4;
    const bytes = atob(this.dataURI.substring(start + this.dataStart, Math.ceil((offset2 + length3) / 3) * 4 + this.dataStart));
    const delta = offset2 - Math.floor(start / 4) * 3;
    for (let indexByte = delta; indexByte < delta + length3; indexByte++) {
      dataArray[indexByte - delta] = bytes.charCodeAt(indexByte);
    }
    return dataArray;
  }
};
var Data64URIWriter = class extends Writer {
  constructor(contentType) {
    super();
    this.data = "data:" + (contentType || "") + ";base64,";
    this.pending = [];
  }
  async writeUint8Array(array) {
    super.writeUint8Array(array);
    let indexArray = 0;
    let dataString = this.pending;
    const delta = this.pending.length;
    this.pending = "";
    for (indexArray = 0; indexArray < Math.floor((delta + array.length) / 3) * 3 - delta; indexArray++) {
      dataString += String.fromCharCode(array[indexArray]);
    }
    for (; indexArray < array.length; indexArray++) {
      this.pending += String.fromCharCode(array[indexArray]);
    }
    if (dataString.length > 2) {
      this.data += btoa(dataString);
    } else {
      this.pending = dataString;
    }
  }
  getData() {
    return this.data + btoa(this.pending);
  }
};
var BlobReader = class extends Reader {
  constructor(blob) {
    super();
    this.blob = blob;
    this.size = blob.size;
  }
  async readUint8Array(offset2, length3) {
    if (this.blob.arrayBuffer) {
      return new Uint8Array(await this.blob.slice(offset2, offset2 + length3).arrayBuffer());
    } else {
      const reader = new FileReader();
      return new Promise((resolve2, reject) => {
        reader.onload = (event) => resolve2(new Uint8Array(event.target.result));
        reader.onerror = () => reject(reader.error);
        reader.readAsArrayBuffer(this.blob.slice(offset2, offset2 + length3));
      });
    }
  }
};
var BlobWriter = class extends Writer {
  constructor(contentType) {
    super();
    this.contentType = contentType;
    this.arrayBuffersMaxlength = 8;
    initArrayBuffers(this);
  }
  async writeUint8Array(array) {
    super.writeUint8Array(array);
    if (this.arrayBuffers.length == this.arrayBuffersMaxlength) {
      flushArrayBuffers(this);
    }
    this.arrayBuffers.push(array.buffer);
  }
  getData() {
    if (!this.blob) {
      if (this.arrayBuffers.length) {
        flushArrayBuffers(this);
      }
      this.blob = this.pendingBlob;
      initArrayBuffers(this);
    }
    return this.blob;
  }
};
function initArrayBuffers(blobWriter) {
  blobWriter.pendingBlob = new Blob([], { type: blobWriter.contentType });
  blobWriter.arrayBuffers = [];
}
function flushArrayBuffers(blobWriter) {
  blobWriter.pendingBlob = new Blob([blobWriter.pendingBlob, ...blobWriter.arrayBuffers], { type: blobWriter.contentType });
  blobWriter.arrayBuffers = [];
}
var WritableStreamWriter = class extends Writer {
  constructor(writableStream) {
    super();
    this.writableStream = writableStream;
    this.writer = writableStream.getWriter();
  }
  async writeUint8Array(array) {
    await this.writer.ready;
    return this.writer.write(array);
  }
  async getData() {
    await this.writer.ready;
    await this.writer.close();
    return this.writableStream;
  }
};
var FetchReader = class extends Reader {
  constructor(url2, options) {
    super();
    this.url = url2;
    this.preventHeadRequest = options.preventHeadRequest;
    this.useRangeHeader = options.useRangeHeader;
    this.forceRangeRequests = options.forceRangeRequests;
    this.options = Object.assign({}, options);
    delete this.options.preventHeadRequest;
    delete this.options.useRangeHeader;
    delete this.options.forceRangeRequests;
    delete this.options.useXHR;
  }
  async init() {
    super.init();
    await initHttpReader(this, sendFetchRequest, getFetchRequestData);
  }
  async readUint8Array(index2, length3) {
    return readUint8ArrayHttpReader(this, index2, length3, sendFetchRequest, getFetchRequestData);
  }
};
var XHRReader = class extends Reader {
  constructor(url2, options) {
    super();
    this.url = url2;
    this.preventHeadRequest = options.preventHeadRequest;
    this.useRangeHeader = options.useRangeHeader;
    this.forceRangeRequests = options.forceRangeRequests;
    this.options = options;
  }
  async init() {
    super.init();
    await initHttpReader(this, sendXMLHttpRequest, getXMLHttpRequestData);
  }
  async readUint8Array(index2, length3) {
    return readUint8ArrayHttpReader(this, index2, length3, sendXMLHttpRequest, getXMLHttpRequestData);
  }
};
async function initHttpReader(httpReader, sendRequest, getRequestData2) {
  if (isHttpFamily(httpReader.url) && (httpReader.useRangeHeader || httpReader.forceRangeRequests)) {
    const response = await sendRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader));
    if (!httpReader.forceRangeRequests && response.headers.get(HTTP_HEADER_ACCEPT_RANGES) != HTTP_RANGE_UNIT) {
      throw new Error(ERR_HTTP_RANGE);
    } else {
      let contentSize;
      const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
      if (contentRangeHeader) {
        const splitHeader = contentRangeHeader.trim().split(/\s*\/\s*/);
        if (splitHeader.length) {
          const headerValue = splitHeader[1];
          if (headerValue && headerValue != "*") {
            contentSize = Number(headerValue);
          }
        }
      }
      if (contentSize === void 0) {
        await getContentLength(httpReader, sendRequest, getRequestData2);
      } else {
        httpReader.size = contentSize;
      }
    }
  } else {
    await getContentLength(httpReader, sendRequest, getRequestData2);
  }
}
async function readUint8ArrayHttpReader(httpReader, index2, length3, sendRequest, getRequestData2) {
  if (httpReader.useRangeHeader || httpReader.forceRangeRequests) {
    const response = await sendRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader, index2, length3));
    if (response.status != 206) {
      throw new Error(ERR_HTTP_RANGE);
    }
    return new Uint8Array(await response.arrayBuffer());
  } else {
    if (!httpReader.data) {
      await getRequestData2(httpReader, httpReader.options);
    }
    return new Uint8Array(httpReader.data.subarray(index2, index2 + length3));
  }
}
function getRangeHeaders(httpReader, index2 = 0, length3 = 1) {
  return Object.assign({}, getHeaders(httpReader), { [HTTP_HEADER_RANGE]: HTTP_RANGE_UNIT + "=" + index2 + "-" + (index2 + length3 - 1) });
}
function getHeaders(httpReader) {
  let headers = httpReader.options.headers;
  if (headers) {
    if (Symbol.iterator in headers) {
      return Object.fromEntries(headers);
    } else {
      return headers;
    }
  }
}
async function getFetchRequestData(httpReader) {
  await getRequestData(httpReader, sendFetchRequest);
}
async function getXMLHttpRequestData(httpReader) {
  await getRequestData(httpReader, sendXMLHttpRequest);
}
async function getRequestData(httpReader, sendRequest) {
  const response = await sendRequest(HTTP_METHOD_GET, httpReader, getHeaders(httpReader));
  httpReader.data = new Uint8Array(await response.arrayBuffer());
  if (!httpReader.size) {
    httpReader.size = httpReader.data.length;
  }
}
async function getContentLength(httpReader, sendRequest, getRequestData2) {
  if (httpReader.preventHeadRequest) {
    await getRequestData2(httpReader, httpReader.options);
  } else {
    const response = await sendRequest(HTTP_METHOD_HEAD, httpReader, getHeaders(httpReader));
    const contentLength = response.headers.get(HTTP_HEADER_CONTENT_LENGTH);
    if (contentLength) {
      httpReader.size = Number(contentLength);
    } else {
      await getRequestData2(httpReader, httpReader.options);
    }
  }
}
async function sendFetchRequest(method, { options, url: url2 }, headers) {
  const response = await fetch(url2, Object.assign({}, options, { method, headers }));
  if (response.status < 400) {
    return response;
  } else {
    throw new Error(ERR_HTTP_STATUS + (response.statusText || response.status));
  }
}
function sendXMLHttpRequest(method, { url: url2 }, headers) {
  return new Promise((resolve2, reject) => {
    const request = new XMLHttpRequest();
    request.addEventListener("load", () => {
      if (request.status < 400) {
        const headers2 = [];
        request.getAllResponseHeaders().trim().split(/[\r\n]+/).forEach((header) => {
          const splitHeader = header.trim().split(/\s*:\s*/);
          splitHeader[0] = splitHeader[0].trim().replace(/^[a-z]|-[a-z]/g, (value) => value.toUpperCase());
          headers2.push(splitHeader);
        });
        resolve2({
          status: request.status,
          arrayBuffer: () => request.response,
          headers: new Map(headers2)
        });
      } else {
        reject(new Error(ERR_HTTP_STATUS + (request.statusText || request.status)));
      }
    }, false);
    request.addEventListener("error", (event) => reject(event.detail.error), false);
    request.open(method, url2);
    if (headers) {
      for (const entry of Object.entries(headers)) {
        request.setRequestHeader(entry[0], entry[1]);
      }
    }
    request.responseType = "arraybuffer";
    request.send();
  });
}
var HttpReader = class extends Reader {
  constructor(url2, options = {}) {
    super();
    this.url = url2;
    if (options.useXHR) {
      this.reader = new XHRReader(url2, options);
    } else {
      this.reader = new FetchReader(url2, options);
    }
  }
  set size(value) {
  }
  get size() {
    return this.reader.size;
  }
  async init() {
    super.init();
    await this.reader.init();
  }
  async readUint8Array(index2, length3) {
    return this.reader.readUint8Array(index2, length3);
  }
};
var HttpRangeReader = class extends HttpReader {
  constructor(url2, options = {}) {
    options.useRangeHeader = true;
    super(url2, options);
  }
};
var Uint8ArrayReader = class extends Reader {
  constructor(array) {
    super();
    this.array = array;
    this.size = array.length;
  }
  async readUint8Array(index2, length3) {
    return this.array.slice(index2, index2 + length3);
  }
};
var Uint8ArrayWriter = class extends Writer {
  constructor() {
    super();
    this.array = new Uint8Array(0);
  }
  async writeUint8Array(array) {
    super.writeUint8Array(array);
    const previousArray = this.array;
    this.array = new Uint8Array(previousArray.length + array.length);
    this.array.set(previousArray);
    this.array.set(array, previousArray.length);
  }
  getData() {
    return this.array;
  }
};
function isHttpFamily(url2) {
  if (typeof document != "undefined") {
    const anchor = document.createElement("a");
    anchor.href = url2;
    return anchor.protocol == "http:" || anchor.protocol == "https:";
  } else {
    return /^https?:\/\//i.test(url2);
  }
}
var MAX_32_BITS = 4294967295;
var MAX_16_BITS = 65535;
var COMPRESSION_METHOD_DEFLATE = 8;
var COMPRESSION_METHOD_STORE = 0;
var COMPRESSION_METHOD_AES = 99;
var LOCAL_FILE_HEADER_SIGNATURE = 67324752;
var DATA_DESCRIPTOR_RECORD_SIGNATURE = 134695760;
var CENTRAL_FILE_HEADER_SIGNATURE = 33639248;
var END_OF_CENTRAL_DIR_SIGNATURE = 101010256;
var ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 101075792;
var ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE = 117853008;
var END_OF_CENTRAL_DIR_LENGTH = 22;
var ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH = 20;
var ZIP64_END_OF_CENTRAL_DIR_LENGTH = 56;
var ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH = END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LENGTH;
var ZIP64_TOTAL_NUMBER_OF_DISKS = 1;
var EXTRAFIELD_TYPE_ZIP64 = 1;
var EXTRAFIELD_TYPE_AES = 39169;
var EXTRAFIELD_TYPE_NTFS = 10;
var EXTRAFIELD_TYPE_NTFS_TAG1 = 1;
var EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP = 21589;
var EXTRAFIELD_TYPE_UNICODE_PATH = 28789;
var EXTRAFIELD_TYPE_UNICODE_COMMENT = 25461;
var BITFLAG_ENCRYPTED = 1;
var BITFLAG_LEVEL = 6;
var BITFLAG_DATA_DESCRIPTOR = 8;
var BITFLAG_LANG_ENCODING_FLAG = 2048;
var FILE_ATTR_MSDOS_DIR_MASK = 16;
var VERSION_DEFLATE = 20;
var VERSION_ZIP64 = 45;
var VERSION_AES = 51;
var DIRECTORY_SIGNATURE = "/";
var MAX_DATE = new Date(2107, 11, 31);
var MIN_DATE = new Date(1980, 0, 1);
var CP437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\xB6\xA7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0 ".split("");
var decodeCP437 = (stringValue) => {
  let result = "";
  for (let indexCharacter = 0; indexCharacter < stringValue.length; indexCharacter++) {
    result += CP437[stringValue[indexCharacter]];
  }
  return result;
};
async function decodeText(value, encoding) {
  if (encoding && encoding.trim().toLowerCase() == "cp437") {
    return decodeCP437(value);
  } else if (typeof TextDecoder == "undefined") {
    const fileReader = new FileReader();
    return new Promise((resolve2, reject) => {
      fileReader.onload = (event) => resolve2(event.target.result);
      fileReader.onerror = () => reject(fileReader.error);
      fileReader.readAsText(new Blob([value]));
    });
  } else {
    return new TextDecoder(encoding).decode(value);
  }
}
var PROPERTY_NAMES = [
  "filename",
  "rawFilename",
  "directory",
  "encrypted",
  "compressedSize",
  "uncompressedSize",
  "lastModDate",
  "rawLastModDate",
  "comment",
  "rawComment",
  "signature",
  "extraField",
  "rawExtraField",
  "bitFlag",
  "extraFieldZip64",
  "extraFieldUnicodePath",
  "extraFieldUnicodeComment",
  "extraFieldAES",
  "filenameUTF8",
  "commentUTF8",
  "offset",
  "zip64",
  "compressionMethod",
  "extraFieldNTFS",
  "lastAccessDate",
  "creationDate",
  "extraFieldExtendedTimestamp",
  "version",
  "versionMadeBy",
  "msDosCompatible",
  "internalFileAttribute",
  "externalFileAttribute"
];
var Entry = class {
  constructor(data) {
    PROPERTY_NAMES.forEach((name) => this[name] = data[name]);
  }
};
var ERR_BAD_FORMAT = "File format is not recognized";
var ERR_EOCDR_NOT_FOUND = "End of central directory not found";
var ERR_EOCDR_ZIP64_NOT_FOUND = "End of Zip64 central directory not found";
var ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND = "End of Zip64 central directory locator not found";
var ERR_CENTRAL_DIRECTORY_NOT_FOUND = "Central directory header not found";
var ERR_LOCAL_FILE_HEADER_NOT_FOUND = "Local file header not found";
var ERR_EXTRAFIELD_ZIP64_NOT_FOUND = "Zip64 extra field not found";
var ERR_ENCRYPTED = "File contains encrypted entry";
var ERR_UNSUPPORTED_ENCRYPTION = "Encryption method not supported";
var ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
var CHARSET_UTF8 = "utf-8";
var CHARSET_CP437 = "cp437";
var ZIP64_PROPERTIES = ["uncompressedSize", "compressedSize", "offset"];
var ZipReader = class {
  constructor(reader, options = {}) {
    Object.assign(this, {
      reader,
      options,
      config: getConfiguration()
    });
  }
  async getEntries(options = {}) {
    const zipReader = this;
    const reader = zipReader.reader;
    if (!reader.initialized) {
      await reader.init();
    }
    if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
      throw new Error(ERR_BAD_FORMAT);
    }
    const endOfDirectoryInfo = await seekSignature(reader, END_OF_CENTRAL_DIR_SIGNATURE, reader.size, END_OF_CENTRAL_DIR_LENGTH, MAX_16_BITS * 16);
    if (!endOfDirectoryInfo) {
      throw new Error(ERR_EOCDR_NOT_FOUND);
    }
    const endOfDirectoryView = getDataView$1(endOfDirectoryInfo);
    let directoryDataLength = getUint32(endOfDirectoryView, 12);
    let directoryDataOffset = getUint32(endOfDirectoryView, 16);
    let filesLength = getUint16(endOfDirectoryView, 8);
    let prependedDataLength = 0;
    if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS) {
      const endOfDirectoryLocatorArray = await readUint8Array(reader, endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH);
      const endOfDirectoryLocatorView = getDataView$1(endOfDirectoryLocatorArray);
      if (getUint32(endOfDirectoryLocatorView, 0) != ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
        throw new Error(ERR_EOCDR_ZIP64_NOT_FOUND);
      }
      directoryDataOffset = getBigUint64(endOfDirectoryLocatorView, 8);
      let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
      let endOfDirectoryView2 = getDataView$1(endOfDirectoryArray);
      const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
      if (getUint32(endOfDirectoryView2, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset) {
        const originalDirectoryDataOffset = directoryDataOffset;
        directoryDataOffset = expectedDirectoryDataOffset;
        prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
        endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
        endOfDirectoryView2 = getDataView$1(endOfDirectoryArray);
      }
      if (getUint32(endOfDirectoryView2, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
        throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
      }
      filesLength = getBigUint64(endOfDirectoryView2, 32);
      directoryDataLength = getBigUint64(endOfDirectoryView2, 40);
      directoryDataOffset -= directoryDataLength;
    }
    if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
      throw new Error(ERR_BAD_FORMAT);
    }
    let offset2 = 0;
    let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
    let directoryView = getDataView$1(directoryArray);
    if (directoryDataLength) {
      const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - directoryDataLength;
      if (getUint32(directoryView, offset2) != CENTRAL_FILE_HEADER_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset) {
        const originalDirectoryDataOffset = directoryDataOffset;
        directoryDataOffset = expectedDirectoryDataOffset;
        prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
        directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
        directoryView = getDataView$1(directoryArray);
      }
    }
    if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
      throw new Error(ERR_BAD_FORMAT);
    }
    const entries = [];
    for (let indexFile = 0; indexFile < filesLength; indexFile++) {
      const fileEntry = new ZipEntry(reader, zipReader.config, zipReader.options);
      if (getUint32(directoryView, offset2) != CENTRAL_FILE_HEADER_SIGNATURE) {
        throw new Error(ERR_CENTRAL_DIRECTORY_NOT_FOUND);
      }
      readCommonHeader(fileEntry, directoryView, offset2 + 6);
      const languageEncodingFlag = Boolean(fileEntry.bitFlag.languageEncodingFlag);
      const filenameOffset = offset2 + 46;
      const extraFieldOffset = filenameOffset + fileEntry.filenameLength;
      const commentOffset = extraFieldOffset + fileEntry.extraFieldLength;
      const versionMadeBy = getUint16(directoryView, offset2 + 4);
      const msDosCompatible = (versionMadeBy & 0) == 0;
      Object.assign(fileEntry, {
        versionMadeBy,
        msDosCompatible,
        compressedSize: 0,
        uncompressedSize: 0,
        commentLength: getUint16(directoryView, offset2 + 32),
        directory: msDosCompatible && (getUint8(directoryView, offset2 + 38) & FILE_ATTR_MSDOS_DIR_MASK) == FILE_ATTR_MSDOS_DIR_MASK,
        offset: getUint32(directoryView, offset2 + 42) + prependedDataLength,
        internalFileAttribute: getUint32(directoryView, offset2 + 34),
        externalFileAttribute: getUint32(directoryView, offset2 + 38),
        rawFilename: directoryArray.subarray(filenameOffset, extraFieldOffset),
        filenameUTF8: languageEncodingFlag,
        commentUTF8: languageEncodingFlag,
        rawExtraField: directoryArray.subarray(extraFieldOffset, commentOffset)
      });
      const endOffset = commentOffset + fileEntry.commentLength;
      fileEntry.rawComment = directoryArray.subarray(commentOffset, endOffset);
      const filenameEncoding = getOptionValue$1(zipReader, options, "filenameEncoding");
      const commentEncoding = getOptionValue$1(zipReader, options, "commentEncoding");
      const [filename, comment] = await Promise.all([
        decodeText(fileEntry.rawFilename, fileEntry.filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437),
        decodeText(fileEntry.rawComment, fileEntry.commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437)
      ]);
      fileEntry.filename = filename;
      fileEntry.comment = comment;
      if (!fileEntry.directory && fileEntry.filename.endsWith(DIRECTORY_SIGNATURE)) {
        fileEntry.directory = true;
      }
      await readCommonFooter(fileEntry, fileEntry, directoryView, offset2 + 6);
      const entry = new Entry(fileEntry);
      entry.getData = (writer, options2) => fileEntry.getData(writer, entry, options2);
      entries.push(entry);
      offset2 = endOffset;
      if (options.onprogress) {
        try {
          options.onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
        } catch (error) {
        }
      }
    }
    return entries;
  }
  async close() {
  }
};
var ZipEntry = class {
  constructor(reader, config2, options) {
    Object.assign(this, {
      reader,
      config: config2,
      options
    });
  }
  async getData(writer, fileEntry, options = {}) {
    const zipEntry = this;
    const {
      reader,
      offset: offset2,
      extraFieldAES,
      compressionMethod,
      config: config2,
      bitFlag,
      signature,
      rawLastModDate,
      compressedSize
    } = zipEntry;
    const localDirectory = zipEntry.localDirectory = {};
    if (!reader.initialized) {
      await reader.init();
    }
    let dataArray = await readUint8Array(reader, offset2, 30);
    const dataView = getDataView$1(dataArray);
    let password = getOptionValue$1(zipEntry, options, "password");
    password = password && password.length && password;
    if (extraFieldAES) {
      if (extraFieldAES.originalCompressionMethod != COMPRESSION_METHOD_AES) {
        throw new Error(ERR_UNSUPPORTED_COMPRESSION);
      }
    }
    if (compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE) {
      throw new Error(ERR_UNSUPPORTED_COMPRESSION);
    }
    if (getUint32(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
      throw new Error(ERR_LOCAL_FILE_HEADER_NOT_FOUND);
    }
    readCommonHeader(localDirectory, dataView, 4);
    dataArray = await readUint8Array(reader, offset2, 30 + localDirectory.filenameLength + localDirectory.extraFieldLength);
    localDirectory.rawExtraField = dataArray.subarray(30 + localDirectory.filenameLength);
    await readCommonFooter(zipEntry, localDirectory, dataView, 4);
    fileEntry.lastAccessDate = localDirectory.lastAccessDate;
    fileEntry.creationDate = localDirectory.creationDate;
    const encrypted = zipEntry.encrypted && localDirectory.encrypted;
    const zipCrypto = encrypted && !extraFieldAES;
    if (encrypted) {
      if (!zipCrypto && extraFieldAES.strength === void 0) {
        throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
      } else if (!password) {
        throw new Error(ERR_ENCRYPTED);
      }
    }
    const codec2 = await createCodec(config2.Inflate, {
      codecType: CODEC_INFLATE,
      password,
      zipCrypto,
      encryptionStrength: extraFieldAES && extraFieldAES.strength,
      signed: getOptionValue$1(zipEntry, options, "checkSignature"),
      passwordVerification: zipCrypto && (bitFlag.dataDescriptor ? rawLastModDate >>> 8 & 255 : signature >>> 24 & 255),
      signature,
      compressed: compressionMethod != 0,
      encrypted,
      useWebWorkers: getOptionValue$1(zipEntry, options, "useWebWorkers")
    }, config2);
    if (!writer.initialized) {
      await writer.init();
    }
    const signal = getOptionValue$1(zipEntry, options, "signal");
    const dataOffset = offset2 + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
    await processData(codec2, reader, writer, dataOffset, compressedSize, config2, { onprogress: options.onprogress, signal });
    return writer.getData();
  }
};
function readCommonHeader(directory, dataView, offset2) {
  const rawBitFlag = directory.rawBitFlag = getUint16(dataView, offset2 + 2);
  const encrypted = (rawBitFlag & BITFLAG_ENCRYPTED) == BITFLAG_ENCRYPTED;
  const rawLastModDate = getUint32(dataView, offset2 + 6);
  Object.assign(directory, {
    encrypted,
    version: getUint16(dataView, offset2),
    bitFlag: {
      level: (rawBitFlag & BITFLAG_LEVEL) >> 1,
      dataDescriptor: (rawBitFlag & BITFLAG_DATA_DESCRIPTOR) == BITFLAG_DATA_DESCRIPTOR,
      languageEncodingFlag: (rawBitFlag & BITFLAG_LANG_ENCODING_FLAG) == BITFLAG_LANG_ENCODING_FLAG
    },
    rawLastModDate,
    lastModDate: getDate(rawLastModDate),
    filenameLength: getUint16(dataView, offset2 + 22),
    extraFieldLength: getUint16(dataView, offset2 + 24)
  });
}
async function readCommonFooter(fileEntry, directory, dataView, offset2) {
  const rawExtraField = directory.rawExtraField;
  const extraField = directory.extraField = /* @__PURE__ */ new Map();
  const rawExtraFieldView = getDataView$1(new Uint8Array(rawExtraField));
  let offsetExtraField = 0;
  try {
    while (offsetExtraField < rawExtraField.length) {
      const type = getUint16(rawExtraFieldView, offsetExtraField);
      const size = getUint16(rawExtraFieldView, offsetExtraField + 2);
      extraField.set(type, {
        type,
        data: rawExtraField.slice(offsetExtraField + 4, offsetExtraField + 4 + size)
      });
      offsetExtraField += 4 + size;
    }
  } catch (error) {
  }
  const compressionMethod = getUint16(dataView, offset2 + 4);
  directory.signature = getUint32(dataView, offset2 + 10);
  directory.uncompressedSize = getUint32(dataView, offset2 + 18);
  directory.compressedSize = getUint32(dataView, offset2 + 14);
  const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
  if (extraFieldZip64) {
    readExtraFieldZip64(extraFieldZip64, directory);
    directory.extraFieldZip64 = extraFieldZip64;
  }
  const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
  if (extraFieldUnicodePath) {
    await readExtraFieldUnicode(extraFieldUnicodePath, "filename", "rawFilename", directory, fileEntry);
    directory.extraFieldUnicodePath = extraFieldUnicodePath;
  }
  const extraFieldUnicodeComment = extraField.get(EXTRAFIELD_TYPE_UNICODE_COMMENT);
  if (extraFieldUnicodeComment) {
    await readExtraFieldUnicode(extraFieldUnicodeComment, "comment", "rawComment", directory, fileEntry);
    directory.extraFieldUnicodeComment = extraFieldUnicodeComment;
  }
  const extraFieldAES = extraField.get(EXTRAFIELD_TYPE_AES);
  if (extraFieldAES) {
    readExtraFieldAES(extraFieldAES, directory, compressionMethod);
    directory.extraFieldAES = extraFieldAES;
  } else {
    directory.compressionMethod = compressionMethod;
  }
  const extraFieldNTFS = extraField.get(EXTRAFIELD_TYPE_NTFS);
  if (extraFieldNTFS) {
    readExtraFieldNTFS(extraFieldNTFS, directory);
    directory.extraFieldNTFS = extraFieldNTFS;
  }
  const extraFieldExtendedTimestamp = extraField.get(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
  if (extraFieldExtendedTimestamp) {
    readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory);
    directory.extraFieldExtendedTimestamp = extraFieldExtendedTimestamp;
  }
}
function readExtraFieldZip64(extraFieldZip64, directory) {
  directory.zip64 = true;
  const extraFieldView = getDataView$1(extraFieldZip64.data);
  extraFieldZip64.values = [];
  for (let indexValue = 0; indexValue < Math.floor(extraFieldZip64.data.length / 8); indexValue++) {
    extraFieldZip64.values.push(getBigUint64(extraFieldView, 0 + indexValue * 8));
  }
  const missingProperties = ZIP64_PROPERTIES.filter((propertyName) => directory[propertyName] == MAX_32_BITS);
  for (let indexMissingProperty = 0; indexMissingProperty < missingProperties.length; indexMissingProperty++) {
    extraFieldZip64[missingProperties[indexMissingProperty]] = extraFieldZip64.values[indexMissingProperty];
  }
  ZIP64_PROPERTIES.forEach((propertyName) => {
    if (directory[propertyName] == MAX_32_BITS) {
      if (extraFieldZip64[propertyName] !== void 0) {
        directory[propertyName] = extraFieldZip64[propertyName];
      } else {
        throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
      }
    }
  });
}
async function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName, directory, fileEntry) {
  const extraFieldView = getDataView$1(extraFieldUnicode.data);
  extraFieldUnicode.version = getUint8(extraFieldView, 0);
  extraFieldUnicode.signature = getUint32(extraFieldView, 1);
  const crc322 = new Crc32();
  crc322.append(fileEntry[rawPropertyName]);
  const dataViewSignature = getDataView$1(new Uint8Array(4));
  dataViewSignature.setUint32(0, crc322.get(), true);
  extraFieldUnicode[propertyName] = await decodeText(extraFieldUnicode.data.subarray(5));
  extraFieldUnicode.valid = !fileEntry.bitFlag.languageEncodingFlag && extraFieldUnicode.signature == getUint32(dataViewSignature, 0);
  if (extraFieldUnicode.valid) {
    directory[propertyName] = extraFieldUnicode[propertyName];
    directory[propertyName + "UTF8"] = true;
  }
}
function readExtraFieldAES(extraFieldAES, directory, compressionMethod) {
  const extraFieldView = getDataView$1(extraFieldAES.data);
  extraFieldAES.vendorVersion = getUint8(extraFieldView, 0);
  extraFieldAES.vendorId = getUint8(extraFieldView, 2);
  const strength = getUint8(extraFieldView, 4);
  extraFieldAES.strength = strength;
  extraFieldAES.originalCompressionMethod = compressionMethod;
  directory.compressionMethod = extraFieldAES.compressionMethod = getUint16(extraFieldView, 5);
}
function readExtraFieldNTFS(extraFieldNTFS, directory) {
  const extraFieldView = getDataView$1(extraFieldNTFS.data);
  let offsetExtraField = 4;
  let tag1Data;
  try {
    while (offsetExtraField < extraFieldNTFS.data.length && !tag1Data) {
      const tagValue = getUint16(extraFieldView, offsetExtraField);
      const attributeSize = getUint16(extraFieldView, offsetExtraField + 2);
      if (tagValue == EXTRAFIELD_TYPE_NTFS_TAG1) {
        tag1Data = extraFieldNTFS.data.slice(offsetExtraField + 4, offsetExtraField + 4 + attributeSize);
      }
      offsetExtraField += 4 + attributeSize;
    }
  } catch (error) {
  }
  try {
    if (tag1Data && tag1Data.length == 24) {
      const tag1View = getDataView$1(tag1Data);
      const rawLastModDate = tag1View.getBigUint64(0, true);
      const rawLastAccessDate = tag1View.getBigUint64(8, true);
      const rawCreationDate = tag1View.getBigUint64(16, true);
      Object.assign(extraFieldNTFS, {
        rawLastModDate,
        rawLastAccessDate,
        rawCreationDate
      });
      const lastModDate = getDateNTFS(rawLastModDate);
      const lastAccessDate = getDateNTFS(rawLastAccessDate);
      const creationDate = getDateNTFS(rawCreationDate);
      const extraFieldData = { lastModDate, lastAccessDate, creationDate };
      Object.assign(extraFieldNTFS, extraFieldData);
      Object.assign(directory, extraFieldData);
    }
  } catch (error) {
  }
}
function readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory) {
  const extraFieldView = getDataView$1(extraFieldExtendedTimestamp.data);
  const flags = getUint8(extraFieldView, 0);
  const timeProperties = [];
  const timeRawProperties = [];
  if ((flags & 1) == 1) {
    timeProperties.push("lastModDate");
    timeRawProperties.push("rawLastModDate");
  }
  if ((flags & 2) == 2) {
    timeProperties.push("lastAccessDate");
    timeRawProperties.push("rawLastAccessDate");
  }
  if ((flags & 4) == 4) {
    timeProperties.push("creationDate");
    timeRawProperties.push("rawCreationDate");
  }
  let offset2 = 1;
  timeProperties.forEach((propertyName, indexProperty) => {
    if (extraFieldExtendedTimestamp.data.length >= offset2 + 4) {
      const time = getUint32(extraFieldView, offset2);
      directory[propertyName] = extraFieldExtendedTimestamp[propertyName] = new Date(time * 1e3);
      const rawPropertyName = timeRawProperties[indexProperty];
      extraFieldExtendedTimestamp[rawPropertyName] = time;
    }
    offset2 += 4;
  });
}
async function seekSignature(reader, signature, startOffset, minimumBytes, maximumLength) {
  const signatureArray = new Uint8Array(4);
  const signatureView = getDataView$1(signatureArray);
  setUint32$1(signatureView, 0, signature);
  const maximumBytes = minimumBytes + maximumLength;
  return await seek(minimumBytes) || await seek(Math.min(maximumBytes, startOffset));
  async function seek(length3) {
    const offset2 = startOffset - length3;
    const bytes = await readUint8Array(reader, offset2, length3);
    for (let indexByte = bytes.length - minimumBytes; indexByte >= 0; indexByte--) {
      if (bytes[indexByte] == signatureArray[0] && bytes[indexByte + 1] == signatureArray[1] && bytes[indexByte + 2] == signatureArray[2] && bytes[indexByte + 3] == signatureArray[3]) {
        return {
          offset: offset2 + indexByte,
          buffer: bytes.slice(indexByte, indexByte + minimumBytes).buffer
        };
      }
    }
  }
}
function getOptionValue$1(zipReader, options, name) {
  return options[name] === void 0 ? zipReader.options[name] : options[name];
}
function getDate(timeRaw) {
  const date = (timeRaw & 4294901760) >> 16, time = timeRaw & 65535;
  try {
    return new Date(1980 + ((date & 65024) >> 9), ((date & 480) >> 5) - 1, date & 31, (time & 63488) >> 11, (time & 2016) >> 5, (time & 31) * 2, 0);
  } catch (error) {
  }
}
function getDateNTFS(timeRaw) {
  return new Date(Number(timeRaw / BigInt(1e4) - BigInt(116444736e5)));
}
function getUint8(view, offset2) {
  return view.getUint8(offset2);
}
function getUint16(view, offset2) {
  return view.getUint16(offset2, true);
}
function getUint32(view, offset2) {
  return view.getUint32(offset2, true);
}
function getBigUint64(view, offset2) {
  return Number(view.getBigUint64(offset2, true));
}
function setUint32$1(view, offset2, value) {
  view.setUint32(offset2, value, true);
}
function getDataView$1(array) {
  return new DataView(array.buffer);
}
function readUint8Array(reader, offset2, size) {
  return reader.readUint8Array(offset2, size);
}
var ERR_DUPLICATED_NAME = "File already exists";
var ERR_INVALID_COMMENT = "Zip file comment exceeds 64KB";
var ERR_INVALID_ENTRY_COMMENT = "File entry comment exceeds 64KB";
var ERR_INVALID_ENTRY_NAME = "File entry name exceeds 64KB";
var ERR_INVALID_VERSION = "Version exceeds 65535";
var ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
var ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
var ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
var ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported";
var EXTRAFIELD_DATA_AES = new Uint8Array([7, 0, 2, 0, 65, 69, 3, 0, 0]);
var EXTRAFIELD_LENGTH_ZIP64 = 24;
var workers = 0;
var ZipWriter = class {
  constructor(writer, options = {}) {
    Object.assign(this, {
      writer,
      options,
      config: getConfiguration(),
      files: /* @__PURE__ */ new Map(),
      offset: writer.size,
      pendingCompressedSize: 0,
      pendingEntries: []
    });
  }
  async add(name = "", reader, options = {}) {
    const zipWriter = this;
    if (workers < zipWriter.config.maxWorkers) {
      workers++;
      try {
        return await addFile(zipWriter, name, reader, options);
      } finally {
        workers--;
        const pendingEntry = zipWriter.pendingEntries.shift();
        if (pendingEntry) {
          zipWriter.add(pendingEntry.name, pendingEntry.reader, pendingEntry.options).then(pendingEntry.resolve).catch(pendingEntry.reject);
        }
      }
    } else {
      return new Promise((resolve2, reject) => zipWriter.pendingEntries.push({ name, reader, options, resolve: resolve2, reject }));
    }
  }
  async close(comment = new Uint8Array(0), options = {}) {
    await closeFile(this, comment, options);
    return this.writer.getData();
  }
};
async function addFile(zipWriter, name, reader, options) {
  name = name.trim();
  if (options.directory && !name.endsWith(DIRECTORY_SIGNATURE)) {
    name += DIRECTORY_SIGNATURE;
  } else {
    options.directory = name.endsWith(DIRECTORY_SIGNATURE);
  }
  if (zipWriter.files.has(name)) {
    throw new Error(ERR_DUPLICATED_NAME);
  }
  const rawFilename = encodeText(name);
  if (rawFilename.length > MAX_16_BITS) {
    throw new Error(ERR_INVALID_ENTRY_NAME);
  }
  const comment = options.comment || "";
  const rawComment = encodeText(comment);
  if (rawComment.length > MAX_16_BITS) {
    throw new Error(ERR_INVALID_ENTRY_COMMENT);
  }
  const version = zipWriter.options.version || options.version || 0;
  if (version > MAX_16_BITS) {
    throw new Error(ERR_INVALID_VERSION);
  }
  const versionMadeBy = zipWriter.options.versionMadeBy || options.versionMadeBy || 20;
  if (versionMadeBy > MAX_16_BITS) {
    throw new Error(ERR_INVALID_VERSION);
  }
  const lastModDate = getOptionValue(zipWriter, options, "lastModDate") || new Date();
  const lastAccessDate = getOptionValue(zipWriter, options, "lastAccessDate");
  const creationDate = getOptionValue(zipWriter, options, "creationDate");
  const password = getOptionValue(zipWriter, options, "password");
  const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength") || 3;
  const zipCrypto = getOptionValue(zipWriter, options, "zipCrypto");
  if (password !== void 0 && encryptionStrength !== void 0 && (encryptionStrength < 1 || encryptionStrength > 3)) {
    throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
  }
  let rawExtraField = new Uint8Array(0);
  const extraField = options.extraField;
  if (extraField) {
    let extraFieldSize = 0;
    let offset2 = 0;
    extraField.forEach((data) => extraFieldSize += 4 + data.length);
    rawExtraField = new Uint8Array(extraFieldSize);
    extraField.forEach((data, type) => {
      if (type > MAX_16_BITS) {
        throw new Error(ERR_INVALID_EXTRAFIELD_TYPE);
      }
      if (data.length > MAX_16_BITS) {
        throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
      }
      arraySet(rawExtraField, new Uint16Array([type]), offset2);
      arraySet(rawExtraField, new Uint16Array([data.length]), offset2 + 2);
      arraySet(rawExtraField, data, offset2 + 4);
      offset2 += 4 + data.length;
    });
  }
  let extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp");
  if (extendedTimestamp === void 0) {
    extendedTimestamp = true;
  }
  let maximumCompressedSize = 0;
  let keepOrder = getOptionValue(zipWriter, options, "keepOrder");
  if (keepOrder === void 0) {
    keepOrder = true;
  }
  let uncompressedSize = 0;
  let msDosCompatible = getOptionValue(zipWriter, options, "msDosCompatible");
  if (msDosCompatible === void 0) {
    msDosCompatible = true;
  }
  const internalFileAttribute = getOptionValue(zipWriter, options, "internalFileAttribute") || 0;
  const externalFileAttribute = getOptionValue(zipWriter, options, "externalFileAttribute") || 0;
  if (reader) {
    if (!reader.initialized) {
      await reader.init();
    }
    uncompressedSize = reader.size;
    maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
  }
  let zip64 = options.zip64 || zipWriter.options.zip64 || false;
  if (zipWriter.offset + zipWriter.pendingCompressedSize >= MAX_32_BITS || uncompressedSize >= MAX_32_BITS || maximumCompressedSize >= MAX_32_BITS) {
    if (options.zip64 === false || zipWriter.options.zip64 === false || !keepOrder) {
      throw new Error(ERR_UNSUPPORTED_FORMAT);
    } else {
      zip64 = true;
    }
  }
  zipWriter.pendingCompressedSize += maximumCompressedSize;
  await Promise.resolve();
  const level = getOptionValue(zipWriter, options, "level");
  const useWebWorkers = getOptionValue(zipWriter, options, "useWebWorkers");
  const bufferedWrite = getOptionValue(zipWriter, options, "bufferedWrite");
  let dataDescriptor = getOptionValue(zipWriter, options, "dataDescriptor");
  let dataDescriptorSignature = getOptionValue(zipWriter, options, "dataDescriptorSignature");
  const signal = getOptionValue(zipWriter, options, "signal");
  if (dataDescriptor === void 0) {
    dataDescriptor = true;
  }
  if (dataDescriptor && dataDescriptorSignature === void 0) {
    dataDescriptorSignature = true;
  }
  const fileEntry = await getFileEntry(zipWriter, name, reader, Object.assign({}, options, {
    rawFilename,
    rawComment,
    version,
    versionMadeBy,
    lastModDate,
    lastAccessDate,
    creationDate,
    rawExtraField,
    zip64,
    password,
    level,
    useWebWorkers,
    encryptionStrength,
    extendedTimestamp,
    zipCrypto,
    bufferedWrite,
    keepOrder,
    dataDescriptor,
    dataDescriptorSignature,
    signal,
    msDosCompatible,
    internalFileAttribute,
    externalFileAttribute
  }));
  if (maximumCompressedSize) {
    zipWriter.pendingCompressedSize -= maximumCompressedSize;
  }
  Object.assign(fileEntry, { name, comment, extraField });
  return new Entry(fileEntry);
}
async function getFileEntry(zipWriter, name, reader, options) {
  const files = zipWriter.files;
  const writer = zipWriter.writer;
  const previousFileEntry = Array.from(files.values()).pop();
  let fileEntry = {};
  let bufferedWrite;
  let resolveLockUnbufferedWrite;
  let resolveLockCurrentFileEntry;
  files.set(name, fileEntry);
  try {
    let lockPreviousFileEntry;
    let fileWriter;
    let lockCurrentFileEntry;
    if (options.keepOrder) {
      lockPreviousFileEntry = previousFileEntry && previousFileEntry.lock;
    }
    fileEntry.lock = lockCurrentFileEntry = new Promise((resolve2) => resolveLockCurrentFileEntry = resolve2);
    if (options.bufferedWrite || zipWriter.lockWrite || !options.dataDescriptor) {
      fileWriter = new BlobWriter();
      fileWriter.init();
      bufferedWrite = true;
    } else {
      zipWriter.lockWrite = new Promise((resolve2) => resolveLockUnbufferedWrite = resolve2);
      if (!writer.initialized) {
        await writer.init();
      }
      fileWriter = writer;
    }
    fileEntry = await createFileEntry(reader, fileWriter, zipWriter.config, options);
    fileEntry.lock = lockCurrentFileEntry;
    files.set(name, fileEntry);
    fileEntry.filename = name;
    if (bufferedWrite) {
      let indexWrittenData = 0;
      const blob = fileWriter.getData();
      await Promise.all([zipWriter.lockWrite, lockPreviousFileEntry]);
      let pendingFileEntry;
      do {
        pendingFileEntry = Array.from(files.values()).find((fileEntry2) => fileEntry2.writingBufferedData);
        if (pendingFileEntry) {
          await pendingFileEntry.lock;
        }
      } while (pendingFileEntry && pendingFileEntry.lock);
      fileEntry.writingBufferedData = true;
      if (!options.dataDescriptor) {
        const headerLength = 26;
        const arrayBuffer = await sliceAsArrayBuffer(blob, 0, headerLength);
        const arrayBufferView = new DataView(arrayBuffer);
        if (!fileEntry.encrypted || options.zipCrypto) {
          setUint32(arrayBufferView, 14, fileEntry.signature);
        }
        if (fileEntry.zip64) {
          setUint32(arrayBufferView, 18, MAX_32_BITS);
          setUint32(arrayBufferView, 22, MAX_32_BITS);
        } else {
          setUint32(arrayBufferView, 18, fileEntry.compressedSize);
          setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
        }
        await writer.writeUint8Array(new Uint8Array(arrayBuffer));
        indexWrittenData = headerLength;
      }
      await writeBlob(writer, blob, indexWrittenData);
      delete fileEntry.writingBufferedData;
    }
    fileEntry.offset = zipWriter.offset;
    if (fileEntry.zip64) {
      const rawExtraFieldZip64View = getDataView(fileEntry.rawExtraFieldZip64);
      setBigUint64(rawExtraFieldZip64View, 20, BigInt(fileEntry.offset));
    } else if (fileEntry.offset >= MAX_32_BITS) {
      throw new Error(ERR_UNSUPPORTED_FORMAT);
    }
    zipWriter.offset += fileEntry.length;
    return fileEntry;
  } catch (error) {
    if (bufferedWrite && fileEntry.writingBufferedData || !bufferedWrite && fileEntry.dataWritten) {
      error.corruptedEntry = zipWriter.hasCorruptedEntries = true;
      if (fileEntry.uncompressedSize) {
        zipWriter.offset += fileEntry.uncompressedSize;
      }
    }
    files.delete(name);
    throw error;
  } finally {
    resolveLockCurrentFileEntry();
    if (resolveLockUnbufferedWrite) {
      resolveLockUnbufferedWrite();
    }
  }
}
async function createFileEntry(reader, writer, config2, options) {
  const {
    rawFilename,
    lastAccessDate,
    creationDate,
    password,
    level,
    zip64,
    zipCrypto,
    dataDescriptor,
    dataDescriptorSignature,
    directory,
    version,
    versionMadeBy,
    rawComment,
    rawExtraField,
    useWebWorkers,
    onprogress,
    signal,
    encryptionStrength,
    extendedTimestamp,
    msDosCompatible,
    internalFileAttribute,
    externalFileAttribute
  } = options;
  const encrypted = Boolean(password && password.length);
  const compressed = level !== 0 && !directory;
  let rawExtraFieldAES;
  if (encrypted && !zipCrypto) {
    rawExtraFieldAES = new Uint8Array(EXTRAFIELD_DATA_AES.length + 2);
    const extraFieldAESView = getDataView(rawExtraFieldAES);
    setUint16(extraFieldAESView, 0, EXTRAFIELD_TYPE_AES);
    arraySet(rawExtraFieldAES, EXTRAFIELD_DATA_AES, 2);
    setUint8(extraFieldAESView, 8, encryptionStrength);
  } else {
    rawExtraFieldAES = new Uint8Array(0);
  }
  let rawExtraFieldNTFS;
  let rawExtraFieldExtendedTimestamp;
  if (extendedTimestamp) {
    rawExtraFieldExtendedTimestamp = new Uint8Array(9 + (lastAccessDate ? 4 : 0) + (creationDate ? 4 : 0));
    const extraFieldExtendedTimestampView = getDataView(rawExtraFieldExtendedTimestamp);
    setUint16(extraFieldExtendedTimestampView, 0, EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
    setUint16(extraFieldExtendedTimestampView, 2, rawExtraFieldExtendedTimestamp.length - 4);
    const extraFieldExtendedTimestampFlag = 1 + (lastAccessDate ? 2 : 0) + (creationDate ? 4 : 0);
    setUint8(extraFieldExtendedTimestampView, 4, extraFieldExtendedTimestampFlag);
    setUint32(extraFieldExtendedTimestampView, 5, Math.floor(options.lastModDate.getTime() / 1e3));
    if (lastAccessDate) {
      setUint32(extraFieldExtendedTimestampView, 9, Math.floor(lastAccessDate.getTime() / 1e3));
    }
    if (creationDate) {
      setUint32(extraFieldExtendedTimestampView, 13, Math.floor(creationDate.getTime() / 1e3));
    }
    try {
      rawExtraFieldNTFS = new Uint8Array(36);
      const extraFieldNTFSView = getDataView(rawExtraFieldNTFS);
      const lastModTimeNTFS = getTimeNTFS(options.lastModDate);
      setUint16(extraFieldNTFSView, 0, EXTRAFIELD_TYPE_NTFS);
      setUint16(extraFieldNTFSView, 2, 32);
      setUint16(extraFieldNTFSView, 8, EXTRAFIELD_TYPE_NTFS_TAG1);
      setUint16(extraFieldNTFSView, 10, 24);
      setBigUint64(extraFieldNTFSView, 12, lastModTimeNTFS);
      setBigUint64(extraFieldNTFSView, 20, getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
      setBigUint64(extraFieldNTFSView, 28, getTimeNTFS(creationDate) || lastModTimeNTFS);
    } catch (error) {
      rawExtraFieldNTFS = new Uint8Array(0);
    }
  } else {
    rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array(0);
  }
  const fileEntry = {
    version: version || VERSION_DEFLATE,
    versionMadeBy,
    zip64,
    directory: Boolean(directory),
    filenameUTF8: true,
    rawFilename,
    commentUTF8: true,
    rawComment,
    rawExtraFieldZip64: zip64 ? new Uint8Array(EXTRAFIELD_LENGTH_ZIP64 + 4) : new Uint8Array(0),
    rawExtraFieldExtendedTimestamp,
    rawExtraFieldNTFS,
    rawExtraFieldAES,
    rawExtraField,
    extendedTimestamp,
    msDosCompatible,
    internalFileAttribute,
    externalFileAttribute
  };
  let uncompressedSize = fileEntry.uncompressedSize = 0;
  let bitFlag = BITFLAG_LANG_ENCODING_FLAG;
  if (dataDescriptor) {
    bitFlag = bitFlag | BITFLAG_DATA_DESCRIPTOR;
  }
  let compressionMethod = COMPRESSION_METHOD_STORE;
  if (compressed) {
    compressionMethod = COMPRESSION_METHOD_DEFLATE;
  }
  if (zip64) {
    fileEntry.version = fileEntry.version > VERSION_ZIP64 ? fileEntry.version : VERSION_ZIP64;
  }
  if (encrypted) {
    bitFlag = bitFlag | BITFLAG_ENCRYPTED;
    if (!zipCrypto) {
      fileEntry.version = fileEntry.version > VERSION_AES ? fileEntry.version : VERSION_AES;
      compressionMethod = COMPRESSION_METHOD_AES;
      if (compressed) {
        fileEntry.rawExtraFieldAES[9] = COMPRESSION_METHOD_DEFLATE;
      }
    }
  }
  fileEntry.compressionMethod = compressionMethod;
  const headerArray = fileEntry.headerArray = new Uint8Array(26);
  const headerView = getDataView(headerArray);
  setUint16(headerView, 0, fileEntry.version);
  setUint16(headerView, 2, bitFlag);
  setUint16(headerView, 4, compressionMethod);
  const dateArray = new Uint32Array(1);
  const dateView = getDataView(dateArray);
  let lastModDate;
  if (options.lastModDate < MIN_DATE) {
    lastModDate = MIN_DATE;
  } else if (options.lastModDate > MAX_DATE) {
    lastModDate = MAX_DATE;
  } else {
    lastModDate = options.lastModDate;
  }
  setUint16(dateView, 0, (lastModDate.getHours() << 6 | lastModDate.getMinutes()) << 5 | lastModDate.getSeconds() / 2);
  setUint16(dateView, 2, (lastModDate.getFullYear() - 1980 << 4 | lastModDate.getMonth() + 1) << 5 | lastModDate.getDate());
  const rawLastModDate = dateArray[0];
  setUint32(headerView, 6, rawLastModDate);
  setUint16(headerView, 22, rawFilename.length);
  const extraFieldLength = rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length + fileEntry.rawExtraField.length;
  setUint16(headerView, 24, extraFieldLength);
  const localHeaderArray = new Uint8Array(30 + rawFilename.length + extraFieldLength);
  const localHeaderView = getDataView(localHeaderArray);
  setUint32(localHeaderView, 0, LOCAL_FILE_HEADER_SIGNATURE);
  arraySet(localHeaderArray, headerArray, 4);
  arraySet(localHeaderArray, rawFilename, 30);
  arraySet(localHeaderArray, rawExtraFieldAES, 30 + rawFilename.length);
  arraySet(localHeaderArray, rawExtraFieldExtendedTimestamp, 30 + rawFilename.length + rawExtraFieldAES.length);
  arraySet(localHeaderArray, rawExtraFieldNTFS, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length);
  arraySet(localHeaderArray, fileEntry.rawExtraField, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length);
  let result;
  let compressedSize = 0;
  if (reader) {
    uncompressedSize = fileEntry.uncompressedSize = reader.size;
    const codec2 = await createCodec(config2.Deflate, {
      codecType: CODEC_DEFLATE,
      level,
      password,
      encryptionStrength,
      zipCrypto: encrypted && zipCrypto,
      passwordVerification: encrypted && zipCrypto && rawLastModDate >> 8 & 255,
      signed: true,
      compressed,
      encrypted,
      useWebWorkers
    }, config2);
    await writer.writeUint8Array(localHeaderArray);
    fileEntry.dataWritten = true;
    result = await processData(codec2, reader, writer, 0, uncompressedSize, config2, { onprogress, signal });
    compressedSize = result.length;
  } else {
    await writer.writeUint8Array(localHeaderArray);
    fileEntry.dataWritten = true;
  }
  let dataDescriptorArray = new Uint8Array(0);
  let dataDescriptorView, dataDescriptorOffset = 0;
  if (dataDescriptor) {
    dataDescriptorArray = new Uint8Array(zip64 ? dataDescriptorSignature ? 24 : 20 : dataDescriptorSignature ? 16 : 12);
    dataDescriptorView = getDataView(dataDescriptorArray);
    if (dataDescriptorSignature) {
      dataDescriptorOffset = 4;
      setUint32(dataDescriptorView, 0, DATA_DESCRIPTOR_RECORD_SIGNATURE);
    }
  }
  if (reader) {
    const signature = result.signature;
    if ((!encrypted || zipCrypto) && signature !== void 0) {
      setUint32(headerView, 10, signature);
      fileEntry.signature = signature;
      if (dataDescriptor) {
        setUint32(dataDescriptorView, dataDescriptorOffset, signature);
      }
    }
    if (zip64) {
      const rawExtraFieldZip64View = getDataView(fileEntry.rawExtraFieldZip64);
      setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
      setUint16(rawExtraFieldZip64View, 2, EXTRAFIELD_LENGTH_ZIP64);
      setUint32(headerView, 14, MAX_32_BITS);
      setBigUint64(rawExtraFieldZip64View, 12, BigInt(compressedSize));
      setUint32(headerView, 18, MAX_32_BITS);
      setBigUint64(rawExtraFieldZip64View, 4, BigInt(uncompressedSize));
      if (dataDescriptor) {
        setBigUint64(dataDescriptorView, dataDescriptorOffset + 4, BigInt(compressedSize));
        setBigUint64(dataDescriptorView, dataDescriptorOffset + 12, BigInt(uncompressedSize));
      }
    } else {
      setUint32(headerView, 14, compressedSize);
      setUint32(headerView, 18, uncompressedSize);
      if (dataDescriptor) {
        setUint32(dataDescriptorView, dataDescriptorOffset + 4, compressedSize);
        setUint32(dataDescriptorView, dataDescriptorOffset + 8, uncompressedSize);
      }
    }
  }
  if (dataDescriptor) {
    await writer.writeUint8Array(dataDescriptorArray);
  }
  const length3 = localHeaderArray.length + compressedSize + dataDescriptorArray.length;
  Object.assign(fileEntry, { compressedSize, lastModDate, rawLastModDate, creationDate, lastAccessDate, encrypted, length: length3 });
  return fileEntry;
}
async function closeFile(zipWriter, comment, options) {
  const writer = zipWriter.writer;
  const files = zipWriter.files;
  let offset2 = 0;
  let directoryDataLength = 0;
  let directoryOffset = zipWriter.offset;
  let filesLength = files.size;
  for (const [, fileEntry] of files) {
    directoryDataLength += 46 + fileEntry.rawFilename.length + fileEntry.rawComment.length + fileEntry.rawExtraFieldZip64.length + fileEntry.rawExtraFieldAES.length + fileEntry.rawExtraFieldExtendedTimestamp.length + fileEntry.rawExtraFieldNTFS.length + fileEntry.rawExtraField.length;
  }
  let zip64 = options.zip64 || zipWriter.options.zip64 || false;
  if (directoryOffset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || filesLength >= MAX_16_BITS) {
    if (options.zip64 === false || zipWriter.options.zip64 === false) {
      throw new Error(ERR_UNSUPPORTED_FORMAT);
    } else {
      zip64 = true;
    }
  }
  const directoryArray = new Uint8Array(directoryDataLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH));
  const directoryView = getDataView(directoryArray);
  if (comment && comment.length) {
    if (comment.length <= MAX_16_BITS) {
      setUint16(directoryView, offset2 + 20, comment.length);
    } else {
      throw new Error(ERR_INVALID_COMMENT);
    }
  }
  for (const [indexFileEntry, fileEntry] of Array.from(files.values()).entries()) {
    const {
      rawFilename,
      rawExtraFieldZip64,
      rawExtraFieldAES,
      rawExtraField,
      rawComment,
      versionMadeBy,
      headerArray,
      directory,
      zip64: zip642,
      msDosCompatible,
      internalFileAttribute,
      externalFileAttribute
    } = fileEntry;
    let rawExtraFieldExtendedTimestamp;
    let rawExtraFieldNTFS;
    if (fileEntry.extendedTimestamp) {
      rawExtraFieldNTFS = fileEntry.rawExtraFieldNTFS;
      rawExtraFieldExtendedTimestamp = new Uint8Array(9);
      const extraFieldExtendedTimestampView = getDataView(rawExtraFieldExtendedTimestamp);
      setUint16(extraFieldExtendedTimestampView, 0, EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
      setUint16(extraFieldExtendedTimestampView, 2, rawExtraFieldExtendedTimestamp.length - 4);
      setUint8(extraFieldExtendedTimestampView, 4, 1);
      setUint32(extraFieldExtendedTimestampView, 5, Math.floor(fileEntry.lastModDate.getTime() / 1e3));
    } else {
      rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array(0);
    }
    const extraFieldLength = rawExtraFieldZip64.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length + rawExtraField.length;
    setUint32(directoryView, offset2, CENTRAL_FILE_HEADER_SIGNATURE);
    setUint16(directoryView, offset2 + 4, versionMadeBy);
    arraySet(directoryArray, headerArray, offset2 + 6);
    setUint16(directoryView, offset2 + 30, extraFieldLength);
    setUint16(directoryView, offset2 + 32, rawComment.length);
    setUint32(directoryView, offset2 + 34, internalFileAttribute);
    if (externalFileAttribute) {
      setUint32(directoryView, offset2 + 38, externalFileAttribute);
    } else if (directory && msDosCompatible) {
      setUint8(directoryView, offset2 + 38, FILE_ATTR_MSDOS_DIR_MASK);
    }
    if (zip642) {
      setUint32(directoryView, offset2 + 42, MAX_32_BITS);
    } else {
      setUint32(directoryView, offset2 + 42, fileEntry.offset);
    }
    arraySet(directoryArray, rawFilename, offset2 + 46);
    arraySet(directoryArray, rawExtraFieldZip64, offset2 + 46 + rawFilename.length);
    arraySet(directoryArray, rawExtraFieldAES, offset2 + 46 + rawFilename.length + rawExtraFieldZip64.length);
    arraySet(directoryArray, rawExtraFieldExtendedTimestamp, offset2 + 46 + rawFilename.length + rawExtraFieldZip64.length + rawExtraFieldAES.length);
    arraySet(directoryArray, rawExtraFieldNTFS, offset2 + 46 + rawFilename.length + rawExtraFieldZip64.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length);
    arraySet(directoryArray, rawExtraField, offset2 + 46 + rawFilename.length + rawExtraFieldZip64.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length);
    arraySet(directoryArray, rawComment, offset2 + 46 + rawFilename.length + extraFieldLength);
    offset2 += 46 + rawFilename.length + extraFieldLength + rawComment.length;
    if (options.onprogress) {
      try {
        options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
      } catch (error) {
      }
    }
  }
  if (zip64) {
    setUint32(directoryView, offset2, ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
    setBigUint64(directoryView, offset2 + 4, BigInt(44));
    setUint16(directoryView, offset2 + 12, 45);
    setUint16(directoryView, offset2 + 14, 45);
    setBigUint64(directoryView, offset2 + 24, BigInt(filesLength));
    setBigUint64(directoryView, offset2 + 32, BigInt(filesLength));
    setBigUint64(directoryView, offset2 + 40, BigInt(directoryDataLength));
    setBigUint64(directoryView, offset2 + 48, BigInt(directoryOffset));
    setUint32(directoryView, offset2 + 56, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
    setBigUint64(directoryView, offset2 + 64, BigInt(directoryOffset) + BigInt(directoryDataLength));
    setUint32(directoryView, offset2 + 72, ZIP64_TOTAL_NUMBER_OF_DISKS);
    filesLength = MAX_16_BITS;
    directoryOffset = MAX_32_BITS;
    directoryDataLength = MAX_32_BITS;
    offset2 += 76;
  }
  setUint32(directoryView, offset2, END_OF_CENTRAL_DIR_SIGNATURE);
  setUint16(directoryView, offset2 + 8, filesLength);
  setUint16(directoryView, offset2 + 10, filesLength);
  setUint32(directoryView, offset2 + 12, directoryDataLength);
  setUint32(directoryView, offset2 + 16, directoryOffset);
  await writer.writeUint8Array(directoryArray);
  if (comment && comment.length) {
    await writer.writeUint8Array(comment);
  }
}
function sliceAsArrayBuffer(blob, start, end) {
  if (blob.arrayBuffer) {
    if (start || end) {
      return blob.slice(start, end).arrayBuffer();
    } else {
      return blob.arrayBuffer();
    }
  } else {
    const fileReader = new FileReader();
    return new Promise((resolve2, reject) => {
      fileReader.onload = (event) => resolve2(event.target.result);
      fileReader.onerror = () => reject(fileReader.error);
      fileReader.readAsArrayBuffer(start || end ? blob.slice(start, end) : blob);
    });
  }
}
async function writeBlob(writer, blob, start = 0) {
  const blockSize = 512 * 1024 * 1024;
  await writeSlice();
  async function writeSlice() {
    if (start < blob.size) {
      const arrayBuffer = await sliceAsArrayBuffer(blob, start, start + blockSize);
      await writer.writeUint8Array(new Uint8Array(arrayBuffer));
      start += blockSize;
      await writeSlice();
    }
  }
}
function getTimeNTFS(date) {
  if (date) {
    return (BigInt(date.getTime()) + BigInt(116444736e5)) * BigInt(1e4);
  }
}
function getOptionValue(zipWriter, options, name) {
  return options[name] === void 0 ? zipWriter.options[name] : options[name];
}
function getMaximumCompressedSize(uncompressedSize) {
  return uncompressedSize + 5 * (Math.floor(uncompressedSize / 16383) + 1);
}
function setUint8(view, offset2, value) {
  view.setUint8(offset2, value);
}
function setUint16(view, offset2, value) {
  view.setUint16(offset2, value, true);
}
function setUint32(view, offset2, value) {
  view.setUint32(offset2, value, true);
}
function setBigUint64(view, offset2, value) {
  view.setBigUint64(offset2, value, true);
}
function arraySet(array, typedArray, offset2) {
  array.set(typedArray, offset2);
}
function getDataView(array) {
  return new DataView(array.buffer);
}
configure({ Deflate: ZipDeflate, Inflate: ZipInflate });
var zipNoWorker = Object.freeze({
  __proto__: null,
  configure,
  getMimeType,
  terminateWorkers,
  ERR_ABORT,
  Reader,
  Writer,
  TextReader,
  TextWriter,
  Data64URIReader,
  Data64URIWriter,
  BlobReader,
  BlobWriter,
  Uint8ArrayReader,
  Uint8ArrayWriter,
  HttpReader,
  HttpRangeReader,
  WritableStreamWriter,
  ERR_HTTP_RANGE,
  ZipReader,
  ERR_BAD_FORMAT,
  ERR_EOCDR_NOT_FOUND,
  ERR_EOCDR_ZIP64_NOT_FOUND,
  ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND,
  ERR_CENTRAL_DIRECTORY_NOT_FOUND,
  ERR_LOCAL_FILE_HEADER_NOT_FOUND,
  ERR_EXTRAFIELD_ZIP64_NOT_FOUND,
  ERR_ENCRYPTED,
  ERR_UNSUPPORTED_ENCRYPTION,
  ERR_UNSUPPORTED_COMPRESSION,
  ERR_INVALID_SIGNATURE,
  ERR_INVALID_PASSWORD,
  ZipWriter,
  ERR_DUPLICATED_NAME,
  ERR_INVALID_COMMENT,
  ERR_INVALID_ENTRY_NAME,
  ERR_INVALID_ENTRY_COMMENT,
  ERR_INVALID_VERSION,
  ERR_INVALID_EXTRAFIELD_TYPE,
  ERR_INVALID_EXTRAFIELD_DATA,
  ERR_INVALID_ENCRYPTION_STRENGTH,
  ERR_UNSUPPORTED_FORMAT
});

// node_modules/cesium/Source/Widgets/getElement.js
function getElement(element) {
  if (typeof element === "string") {
    const foundElement = document.getElementById(element);
    if (foundElement === null) {
      throw new DeveloperError_default(
        `Element with id "${element}" does not exist in the document.`
      );
    }
    element = foundElement;
  }
  return element;
}
var getElement_default = getElement;

// node_modules/cesium/Source/DataSources/KmlLookAt.js
function KmlLookAt(position, headingPitchRange) {
  this.position = position;
  this.headingPitchRange = headingPitchRange;
}
var KmlLookAt_default = KmlLookAt;

// node_modules/cesium/Source/DataSources/KmlTour.js
function KmlTour(name, id) {
  this.id = id;
  this.name = name;
  this.playlistIndex = 0;
  this.playlist = [];
  this.tourStart = new Event_default();
  this.tourEnd = new Event_default();
  this.entryStart = new Event_default();
  this.entryEnd = new Event_default();
  this._activeEntries = [];
}
KmlTour.prototype.addPlaylistEntry = function(entry) {
  this.playlist.push(entry);
};
KmlTour.prototype.play = function(viewer, cameraOptions) {
  this.tourStart.raiseEvent();
  const tour = this;
  playEntry.call(this, viewer, cameraOptions, function(terminated) {
    tour.playlistIndex = 0;
    if (!terminated) {
      cancelAllEntries(tour._activeEntries);
    }
    tour.tourEnd.raiseEvent(terminated);
  });
};
KmlTour.prototype.stop = function() {
  cancelAllEntries(this._activeEntries);
};
function cancelAllEntries(activeEntries) {
  for (let entry = activeEntries.pop(); entry !== void 0; entry = activeEntries.pop()) {
    entry.stop();
  }
}
function playEntry(viewer, cameraOptions, allDone) {
  const entry = this.playlist[this.playlistIndex];
  if (entry) {
    const _playNext = playNext.bind(this, viewer, cameraOptions, allDone);
    this._activeEntries.push(entry);
    this.entryStart.raiseEvent(entry);
    if (entry.blocking) {
      entry.play(_playNext, viewer.scene.camera, cameraOptions);
    } else {
      const tour = this;
      entry.play(function() {
        tour.entryEnd.raiseEvent(entry);
        const indx = tour._activeEntries.indexOf(entry);
        if (indx >= 0) {
          tour._activeEntries.splice(indx, 1);
        }
      });
      _playNext(viewer, cameraOptions, allDone);
    }
  } else if (defined_default(allDone)) {
    allDone(false);
  }
}
function playNext(viewer, cameraOptions, allDone, terminated) {
  const entry = this.playlist[this.playlistIndex];
  this.entryEnd.raiseEvent(entry, terminated);
  if (terminated) {
    allDone(terminated);
  } else {
    const indx = this._activeEntries.indexOf(entry);
    if (indx >= 0) {
      this._activeEntries.splice(indx, 1);
    }
    this.playlistIndex++;
    playEntry.call(this, viewer, cameraOptions, allDone);
  }
}
var KmlTour_default = KmlTour;

// node_modules/cesium/Source/DataSources/KmlTourFlyTo.js
function KmlTourFlyTo(duration, flyToMode, view) {
  this.type = "KmlTourFlyTo";
  this.blocking = true;
  this.activeCamera = null;
  this.activeCallback = null;
  this.duration = duration;
  this.view = view;
  this.flyToMode = flyToMode;
}
KmlTourFlyTo.prototype.play = function(done, camera, cameraOptions) {
  this.activeCamera = camera;
  if (defined_default(done) && done !== null) {
    const self2 = this;
    this.activeCallback = function(terminated) {
      delete self2.activeCallback;
      delete self2.activeCamera;
      done(defined_default(terminated) ? false : terminated);
    };
  }
  const options = this.getCameraOptions(cameraOptions);
  if (this.view.headingPitchRoll) {
    camera.flyTo(options);
  } else if (this.view.headingPitchRange) {
    const target = new BoundingSphere_default(this.view.position);
    camera.flyToBoundingSphere(target, options);
  }
};
KmlTourFlyTo.prototype.stop = function() {
  if (defined_default(this.activeCamera)) {
    this.activeCamera.cancelFlight();
  }
  if (defined_default(this.activeCallback)) {
    this.activeCallback(true);
  }
};
KmlTourFlyTo.prototype.getCameraOptions = function(cameraOptions) {
  let options = {
    duration: this.duration
  };
  if (defined_default(this.activeCallback)) {
    options.complete = this.activeCallback;
  }
  if (this.flyToMode === "smooth") {
    options.easingFunction = EasingFunction_default.LINEAR_NONE;
  }
  if (this.view.headingPitchRoll) {
    options.destination = this.view.position;
    options.orientation = this.view.headingPitchRoll;
  } else if (this.view.headingPitchRange) {
    options.offset = this.view.headingPitchRange;
  }
  if (defined_default(cameraOptions)) {
    options = combine_default(options, cameraOptions);
  }
  return options;
};
var KmlTourFlyTo_default = KmlTourFlyTo;

// node_modules/cesium/Source/DataSources/KmlTourWait.js
function KmlTourWait(duration) {
  this.type = "KmlTourWait";
  this.blocking = true;
  this.duration = duration;
  this.timeout = null;
}
KmlTourWait.prototype.play = function(done) {
  const self2 = this;
  this.activeCallback = done;
  this.timeout = setTimeout(function() {
    delete self2.activeCallback;
    done(false);
  }, this.duration * 1e3);
};
KmlTourWait.prototype.stop = function() {
  clearTimeout(this.timeout);
  if (defined_default(this.activeCallback)) {
    this.activeCallback(true);
  }
};
var KmlTourWait_default = KmlTourWait;

// node_modules/cesium/Source/DataSources/KmlDataSource.js
var MimeTypes = {
  avi: "video/x-msvideo",
  bmp: "image/bmp",
  bz2: "application/x-bzip2",
  chm: "application/vnd.ms-htmlhelp",
  css: "text/css",
  csv: "text/csv",
  doc: "application/msword",
  dvi: "application/x-dvi",
  eps: "application/postscript",
  flv: "video/x-flv",
  gif: "image/gif",
  gz: "application/x-gzip",
  htm: "text/html",
  html: "text/html",
  ico: "image/vnd.microsoft.icon",
  jnlp: "application/x-java-jnlp-file",
  jpeg: "image/jpeg",
  jpg: "image/jpeg",
  m3u: "audio/x-mpegurl",
  m4v: "video/mp4",
  mathml: "application/mathml+xml",
  mid: "audio/midi",
  midi: "audio/midi",
  mov: "video/quicktime",
  mp3: "audio/mpeg",
  mp4: "video/mp4",
  mp4v: "video/mp4",
  mpeg: "video/mpeg",
  mpg: "video/mpeg",
  odp: "application/vnd.oasis.opendocument.presentation",
  ods: "application/vnd.oasis.opendocument.spreadsheet",
  odt: "application/vnd.oasis.opendocument.text",
  ogg: "application/ogg",
  pdf: "application/pdf",
  png: "image/png",
  pps: "application/vnd.ms-powerpoint",
  ppt: "application/vnd.ms-powerpoint",
  ps: "application/postscript",
  qt: "video/quicktime",
  rdf: "application/rdf+xml",
  rss: "application/rss+xml",
  rtf: "application/rtf",
  svg: "image/svg+xml",
  swf: "application/x-shockwave-flash",
  text: "text/plain",
  tif: "image/tiff",
  tiff: "image/tiff",
  txt: "text/plain",
  wav: "audio/x-wav",
  wma: "audio/x-ms-wma",
  wmv: "video/x-ms-wmv",
  xml: "application/xml",
  zip: "application/zip",
  detectFromFilename: function(filename) {
    let ext = filename.toLowerCase();
    ext = getExtensionFromUri_default(ext);
    return MimeTypes[ext];
  }
};
var parser2;
if (typeof DOMParser !== "undefined") {
  parser2 = new DOMParser();
}
var autolinker2 = new Autolinker({
  stripPrefix: false,
  email: false,
  replaceFn: function(match) {
    if (!match.protocolUrlMatch) {
      return false;
    }
  }
});
var BILLBOARD_SIZE2 = 32;
var BILLBOARD_NEAR_DISTANCE2 = 2414016;
var BILLBOARD_NEAR_RATIO2 = 1;
var BILLBOARD_FAR_DISTANCE2 = 16093e3;
var BILLBOARD_FAR_RATIO2 = 0.1;
var kmlNamespaces = [
  null,
  void 0,
  "http://www.opengis.net/kml/2.2",
  "http://earth.google.com/kml/2.2",
  "http://earth.google.com/kml/2.1",
  "http://earth.google.com/kml/2.0"
];
var gxNamespaces = ["http://www.google.com/kml/ext/2.2"];
var atomNamespaces = ["http://www.w3.org/2005/Atom"];
var namespaces2 = {
  kml: kmlNamespaces,
  gx: gxNamespaces,
  atom: atomNamespaces,
  kmlgx: kmlNamespaces.concat(gxNamespaces)
};
var featureTypes = {
  Document: processDocument2,
  Folder: processFolder,
  Placemark: processPlacemark,
  NetworkLink: processNetworkLink,
  GroundOverlay: processGroundOverlay,
  PhotoOverlay: processUnsupportedFeature,
  ScreenOverlay: processScreenOverlay,
  Tour: processTour
};
function DeferredLoading(dataSource) {
  this._dataSource = dataSource;
  this._deferred = defer_default();
  this._stack = [];
  this._promises = [];
  this._timeoutSet = false;
  this._used = false;
  this._started = 0;
  this._timeThreshold = 1e3;
}
Object.defineProperties(DeferredLoading.prototype, {
  dataSource: {
    get: function() {
      return this._dataSource;
    }
  }
});
DeferredLoading.prototype.addNodes = function(nodes, processingData) {
  this._stack.push({
    nodes,
    index: 0,
    processingData
  });
  this._used = true;
};
DeferredLoading.prototype.addPromise = function(promise) {
  this._promises.push(promise);
};
DeferredLoading.prototype.wait = function() {
  const deferred = this._deferred;
  if (!this._used) {
    deferred.resolve();
  }
  return Promise.all([deferred.promise, Promise.all(this._promises)]);
};
DeferredLoading.prototype.process = function() {
  const isFirstCall = this._stack.length === 1;
  if (isFirstCall) {
    this._started = KmlDataSource._getTimestamp();
  }
  return this._process(isFirstCall);
};
DeferredLoading.prototype._giveUpTime = function() {
  if (this._timeoutSet) {
    return;
  }
  this._timeoutSet = true;
  this._timeThreshold = 50;
  const that = this;
  setTimeout(function() {
    that._timeoutSet = false;
    that._started = KmlDataSource._getTimestamp();
    that._process(true);
  }, 0);
};
DeferredLoading.prototype._nextNode = function() {
  const stack = this._stack;
  const top = stack[stack.length - 1];
  const index2 = top.index;
  const nodes = top.nodes;
  if (index2 === nodes.length) {
    return;
  }
  ++top.index;
  return nodes[index2];
};
DeferredLoading.prototype._pop = function() {
  const stack = this._stack;
  stack.pop();
  if (stack.length === 0) {
    this._deferred.resolve();
    return false;
  }
  return true;
};
DeferredLoading.prototype._process = function(isFirstCall) {
  const dataSource = this.dataSource;
  const processingData = this._stack[this._stack.length - 1].processingData;
  let child = this._nextNode();
  while (defined_default(child)) {
    const featureProcessor = featureTypes[child.localName];
    if (defined_default(featureProcessor) && (namespaces2.kml.indexOf(child.namespaceURI) !== -1 || namespaces2.gx.indexOf(child.namespaceURI) !== -1)) {
      featureProcessor(dataSource, child, processingData, this);
      if (this._timeoutSet || KmlDataSource._getTimestamp() > this._started + this._timeThreshold) {
        this._giveUpTime();
        return;
      }
    }
    child = this._nextNode();
  }
  if (this._pop() && isFirstCall) {
    this._process(true);
  }
};
function isZipFile(blob) {
  const magicBlob = blob.slice(0, Math.min(4, blob.size));
  const deferred = defer_default();
  const reader = new FileReader();
  reader.addEventListener("load", function() {
    deferred.resolve(
      new DataView(reader.result).getUint32(0, false) === 1347093252
    );
  });
  reader.addEventListener("error", function() {
    deferred.reject(reader.error);
  });
  reader.readAsArrayBuffer(magicBlob);
  return deferred.promise;
}
function readBlobAsText2(blob) {
  const deferred = defer_default();
  const reader = new FileReader();
  reader.addEventListener("load", function() {
    deferred.resolve(reader.result);
  });
  reader.addEventListener("error", function() {
    deferred.reject(reader.error);
  });
  reader.readAsText(blob);
  return deferred.promise;
}
function insertNamespaces(text2) {
  const namespaceMap = {
    xsi: "http://www.w3.org/2001/XMLSchema-instance"
  };
  let firstPart, lastPart, reg, declaration;
  for (const key in namespaceMap) {
    if (namespaceMap.hasOwnProperty(key)) {
      reg = RegExp(`[< ]${key}:`);
      declaration = `xmlns:${key}=`;
      if (reg.test(text2) && text2.indexOf(declaration) === -1) {
        if (!defined_default(firstPart)) {
          firstPart = text2.substr(0, text2.indexOf("<kml") + 4);
          lastPart = text2.substr(firstPart.length);
        }
        firstPart += ` ${declaration}"${namespaceMap[key]}"`;
      }
    }
  }
  if (defined_default(firstPart)) {
    text2 = firstPart + lastPart;
  }
  return text2;
}
function removeDuplicateNamespaces(text2) {
  let index2 = text2.indexOf("xmlns:");
  const endDeclaration = text2.indexOf(">", index2);
  let namespace, startIndex, endIndex;
  while (index2 !== -1 && index2 < endDeclaration) {
    namespace = text2.slice(index2, text2.indexOf('"', index2));
    startIndex = index2;
    index2 = text2.indexOf(namespace, index2 + 1);
    if (index2 !== -1) {
      endIndex = text2.indexOf('"', text2.indexOf('"', index2) + 1);
      text2 = text2.slice(0, index2 - 1) + text2.slice(endIndex + 1, text2.length);
      index2 = text2.indexOf("xmlns:", startIndex - 1);
    } else {
      index2 = text2.indexOf("xmlns:", startIndex + 1);
    }
  }
  return text2;
}
function loadXmlFromZip(entry, uriResolver) {
  return Promise.resolve(entry.getData(new zipNoWorker.TextWriter())).then(function(text2) {
    text2 = insertNamespaces(text2);
    text2 = removeDuplicateNamespaces(text2);
    uriResolver.kml = parser2.parseFromString(text2, "application/xml");
  });
}
function loadDataUriFromZip(entry, uriResolver) {
  const mimeType = defaultValue_default(
    MimeTypes.detectFromFilename(entry.filename),
    "application/octet-stream"
  );
  return Promise.resolve(entry.getData(new zipNoWorker.Data64URIWriter(mimeType))).then(
    function(dataUri) {
      uriResolver[entry.filename] = dataUri;
    }
  );
}
function embedDataUris(div, elementType, attributeName, uriResolver) {
  const keys = uriResolver.keys;
  const baseUri = new URI(".");
  const elements = div.querySelectorAll(elementType);
  for (let i2 = 0; i2 < elements.length; i2++) {
    const element = elements[i2];
    const value = element.getAttribute(attributeName);
    const relativeUri = new URI(value);
    const uri = relativeUri.absoluteTo(baseUri).toString();
    const index2 = keys.indexOf(uri);
    if (index2 !== -1) {
      const key = keys[index2];
      element.setAttribute(attributeName, uriResolver[key]);
      if (elementType === "a" && element.getAttribute("download") === null) {
        element.setAttribute("download", key);
      }
    }
  }
}
function applyBasePath(div, elementType, attributeName, sourceResource) {
  const elements = div.querySelectorAll(elementType);
  for (let i2 = 0; i2 < elements.length; i2++) {
    const element = elements[i2];
    const value = element.getAttribute(attributeName);
    const resource = resolveHref(value, sourceResource);
    element.setAttribute(attributeName, resource.url);
  }
}
function createEntity(node, entityCollection, context) {
  let id = queryStringAttribute2(node, "id");
  id = defined_default(id) && id.length !== 0 ? id : createGuid_default();
  if (defined_default(context)) {
    id = context + id;
  }
  let entity = entityCollection.getById(id);
  if (defined_default(entity)) {
    id = createGuid_default();
    if (defined_default(context)) {
      id = context + id;
    }
  }
  entity = entityCollection.add(new Entity_default({ id }));
  if (!defined_default(entity.kml)) {
    entity.addProperty("kml");
    entity.kml = new KmlFeatureData();
  }
  return entity;
}
function isExtrudable(altitudeMode, gxAltitudeMode) {
  return altitudeMode === "absolute" || altitudeMode === "relativeToGround" || gxAltitudeMode === "relativeToSeaFloor";
}
function readCoordinate(value, ellipsoid) {
  if (!defined_default(value)) {
    return Cartesian3_default.fromDegrees(0, 0, 0, ellipsoid);
  }
  const digits = value.match(/[^\s,\n]+/g);
  if (!defined_default(digits)) {
    return Cartesian3_default.fromDegrees(0, 0, 0, ellipsoid);
  }
  let longitude = parseFloat(digits[0]);
  let latitude = parseFloat(digits[1]);
  let height = parseFloat(digits[2]);
  longitude = isNaN(longitude) ? 0 : longitude;
  latitude = isNaN(latitude) ? 0 : latitude;
  height = isNaN(height) ? 0 : height;
  return Cartesian3_default.fromDegrees(longitude, latitude, height, ellipsoid);
}
function readCoordinates(element, ellipsoid) {
  if (!defined_default(element)) {
    return void 0;
  }
  const tuples = element.textContent.match(/[^\s\n]+/g);
  if (!defined_default(tuples)) {
    return void 0;
  }
  const length3 = tuples.length;
  const result = new Array(length3);
  let resultIndex = 0;
  for (let i2 = 0; i2 < length3; i2++) {
    result[resultIndex++] = readCoordinate(tuples[i2], ellipsoid);
  }
  return result;
}
function queryNumericAttribute2(node, attributeName) {
  if (!defined_default(node)) {
    return void 0;
  }
  const value = node.getAttribute(attributeName);
  if (value !== null) {
    const result = parseFloat(value);
    return !isNaN(result) ? result : void 0;
  }
  return void 0;
}
function queryStringAttribute2(node, attributeName) {
  if (!defined_default(node)) {
    return void 0;
  }
  const value = node.getAttribute(attributeName);
  return value !== null ? value : void 0;
}
function queryFirstNode2(node, tagName, namespace) {
  if (!defined_default(node)) {
    return void 0;
  }
  const childNodes = node.childNodes;
  const length3 = childNodes.length;
  for (let q = 0; q < length3; q++) {
    const child = childNodes[q];
    if (child.localName === tagName && namespace.indexOf(child.namespaceURI) !== -1) {
      return child;
    }
  }
  return void 0;
}
function queryNodes2(node, tagName, namespace) {
  if (!defined_default(node)) {
    return void 0;
  }
  const result = [];
  const childNodes = node.getElementsByTagNameNS("*", tagName);
  const length3 = childNodes.length;
  for (let q = 0; q < length3; q++) {
    const child = childNodes[q];
    if (child.localName === tagName && namespace.indexOf(child.namespaceURI) !== -1) {
      result.push(child);
    }
  }
  return result;
}
function queryChildNodes(node, tagName, namespace) {
  if (!defined_default(node)) {
    return [];
  }
  const result = [];
  const childNodes = node.childNodes;
  const length3 = childNodes.length;
  for (let q = 0; q < length3; q++) {
    const child = childNodes[q];
    if (child.localName === tagName && namespace.indexOf(child.namespaceURI) !== -1) {
      result.push(child);
    }
  }
  return result;
}
function queryNumericValue2(node, tagName, namespace) {
  const resultNode = queryFirstNode2(node, tagName, namespace);
  if (defined_default(resultNode)) {
    const result = parseFloat(resultNode.textContent);
    return !isNaN(result) ? result : void 0;
  }
  return void 0;
}
function queryStringValue2(node, tagName, namespace) {
  const result = queryFirstNode2(node, tagName, namespace);
  if (defined_default(result)) {
    return result.textContent.trim();
  }
  return void 0;
}
function queryBooleanValue(node, tagName, namespace) {
  const result = queryFirstNode2(node, tagName, namespace);
  if (defined_default(result)) {
    const value = result.textContent.trim();
    return value === "1" || /^true$/i.test(value);
  }
  return void 0;
}
function resolveHref(href, sourceResource, uriResolver) {
  if (!defined_default(href)) {
    return void 0;
  }
  let resource;
  if (defined_default(uriResolver)) {
    href = href.replace(/\\/g, "/");
    let blob = uriResolver[href];
    if (defined_default(blob)) {
      resource = new Resource_default({
        url: blob
      });
    } else {
      const baseUri = new URI(sourceResource.getUrlComponent());
      const uri = new URI(href);
      blob = uriResolver[uri.absoluteTo(baseUri)];
      if (defined_default(blob)) {
        resource = new Resource_default({
          url: blob
        });
      }
    }
  }
  if (!defined_default(resource)) {
    resource = sourceResource.getDerivedResource({
      url: href
    });
  }
  return resource;
}
var colorOptions = {
  maximumRed: void 0,
  red: void 0,
  maximumGreen: void 0,
  green: void 0,
  maximumBlue: void 0,
  blue: void 0
};
function parseColorString(value, isRandom) {
  if (!defined_default(value) || /^\s*$/gm.test(value)) {
    return void 0;
  }
  if (value[0] === "#") {
    value = value.substring(1);
  }
  const alpha = parseInt(value.substring(0, 2), 16) / 255;
  const blue = parseInt(value.substring(2, 4), 16) / 255;
  const green = parseInt(value.substring(4, 6), 16) / 255;
  const red = parseInt(value.substring(6, 8), 16) / 255;
  if (!isRandom) {
    return new Color_default(red, green, blue, alpha);
  }
  if (red > 0) {
    colorOptions.maximumRed = red;
    colorOptions.red = void 0;
  } else {
    colorOptions.maximumRed = void 0;
    colorOptions.red = 0;
  }
  if (green > 0) {
    colorOptions.maximumGreen = green;
    colorOptions.green = void 0;
  } else {
    colorOptions.maximumGreen = void 0;
    colorOptions.green = 0;
  }
  if (blue > 0) {
    colorOptions.maximumBlue = blue;
    colorOptions.blue = void 0;
  } else {
    colorOptions.maximumBlue = void 0;
    colorOptions.blue = 0;
  }
  colorOptions.alpha = alpha;
  return Color_default.fromRandom(colorOptions);
}
function queryColorValue(node, tagName, namespace) {
  const value = queryStringValue2(node, tagName, namespace);
  if (!defined_default(value)) {
    return void 0;
  }
  return parseColorString(
    value,
    queryStringValue2(node, "colorMode", namespace) === "random"
  );
}
function processTimeStamp(featureNode) {
  const node = queryFirstNode2(featureNode, "TimeStamp", namespaces2.kmlgx);
  const whenString = queryStringValue2(node, "when", namespaces2.kmlgx);
  if (!defined_default(node) || !defined_default(whenString) || whenString.length === 0) {
    return void 0;
  }
  const when = JulianDate_default.fromIso8601(whenString);
  const result = new TimeIntervalCollection_default();
  result.addInterval(
    new TimeInterval_default({
      start: when,
      stop: Iso8601_default.MAXIMUM_VALUE
    })
  );
  return result;
}
function processTimeSpan(featureNode) {
  const node = queryFirstNode2(featureNode, "TimeSpan", namespaces2.kmlgx);
  if (!defined_default(node)) {
    return void 0;
  }
  let result;
  const beginNode = queryFirstNode2(node, "begin", namespaces2.kmlgx);
  let beginDate = defined_default(beginNode) ? JulianDate_default.fromIso8601(beginNode.textContent) : void 0;
  const endNode = queryFirstNode2(node, "end", namespaces2.kmlgx);
  let endDate = defined_default(endNode) ? JulianDate_default.fromIso8601(endNode.textContent) : void 0;
  if (defined_default(beginDate) && defined_default(endDate)) {
    if (JulianDate_default.lessThan(endDate, beginDate)) {
      const tmp2 = beginDate;
      beginDate = endDate;
      endDate = tmp2;
    }
    result = new TimeIntervalCollection_default();
    result.addInterval(
      new TimeInterval_default({
        start: beginDate,
        stop: endDate
      })
    );
  } else if (defined_default(beginDate)) {
    result = new TimeIntervalCollection_default();
    result.addInterval(
      new TimeInterval_default({
        start: beginDate,
        stop: Iso8601_default.MAXIMUM_VALUE
      })
    );
  } else if (defined_default(endDate)) {
    result = new TimeIntervalCollection_default();
    result.addInterval(
      new TimeInterval_default({
        start: Iso8601_default.MINIMUM_VALUE,
        stop: endDate
      })
    );
  }
  return result;
}
function createDefaultBillboard2() {
  const billboard = new BillboardGraphics_default();
  billboard.width = BILLBOARD_SIZE2;
  billboard.height = BILLBOARD_SIZE2;
  billboard.scaleByDistance = new NearFarScalar_default(
    BILLBOARD_NEAR_DISTANCE2,
    BILLBOARD_NEAR_RATIO2,
    BILLBOARD_FAR_DISTANCE2,
    BILLBOARD_FAR_RATIO2
  );
  billboard.pixelOffsetScaleByDistance = new NearFarScalar_default(
    BILLBOARD_NEAR_DISTANCE2,
    BILLBOARD_NEAR_RATIO2,
    BILLBOARD_FAR_DISTANCE2,
    BILLBOARD_FAR_RATIO2
  );
  return billboard;
}
function createDefaultPolygon() {
  const polygon = new PolygonGraphics_default();
  polygon.outline = true;
  polygon.outlineColor = Color_default.WHITE;
  return polygon;
}
function createDefaultLabel2() {
  const label = new LabelGraphics_default();
  label.translucencyByDistance = new NearFarScalar_default(3e6, 1, 5e6, 0);
  label.pixelOffset = new Cartesian2_default(17, 0);
  label.horizontalOrigin = HorizontalOrigin_default.LEFT;
  label.font = "16px sans-serif";
  label.style = LabelStyle_default.FILL_AND_OUTLINE;
  return label;
}
function getIconHref(iconNode, dataSource, sourceResource, uriResolver, canRefresh) {
  let href = queryStringValue2(iconNode, "href", namespaces2.kml);
  if (!defined_default(href) || href.length === 0) {
    return void 0;
  }
  if (href.indexOf("root://icons/palette-") === 0) {
    const palette = href.charAt(21);
    let x = defaultValue_default(queryNumericValue2(iconNode, "x", namespaces2.gx), 0);
    let y = defaultValue_default(queryNumericValue2(iconNode, "y", namespaces2.gx), 0);
    x = Math.min(x / 32, 7);
    y = 7 - Math.min(y / 32, 7);
    const iconNum = 8 * y + x;
    href = `https://maps.google.com/mapfiles/kml/pal${palette}/icon${iconNum}.png`;
  }
  const hrefResource = resolveHref(href, sourceResource, uriResolver);
  if (canRefresh) {
    const refreshMode = queryStringValue2(
      iconNode,
      "refreshMode",
      namespaces2.kml
    );
    const viewRefreshMode = queryStringValue2(
      iconNode,
      "viewRefreshMode",
      namespaces2.kml
    );
    if (refreshMode === "onInterval" || refreshMode === "onExpire") {
      oneTimeWarning_default(
        `kml-refreshMode-${refreshMode}`,
        `KML - Unsupported Icon refreshMode: ${refreshMode}`
      );
    } else if (viewRefreshMode === "onStop" || viewRefreshMode === "onRegion") {
      oneTimeWarning_default(
        `kml-refreshMode-${viewRefreshMode}`,
        `KML - Unsupported Icon viewRefreshMode: ${viewRefreshMode}`
      );
    }
    const viewBoundScale = defaultValue_default(
      queryStringValue2(iconNode, "viewBoundScale", namespaces2.kml),
      1
    );
    const defaultViewFormat = viewRefreshMode === "onStop" ? "BBOX=[bboxWest],[bboxSouth],[bboxEast],[bboxNorth]" : "";
    const viewFormat = defaultValue_default(
      queryStringValue2(iconNode, "viewFormat", namespaces2.kml),
      defaultViewFormat
    );
    const httpQuery = queryStringValue2(iconNode, "httpQuery", namespaces2.kml);
    if (defined_default(viewFormat)) {
      hrefResource.setQueryParameters(queryToObject_default(cleanupString(viewFormat)));
    }
    if (defined_default(httpQuery)) {
      hrefResource.setQueryParameters(queryToObject_default(cleanupString(httpQuery)));
    }
    const ellipsoid = dataSource._ellipsoid;
    processNetworkLinkQueryString(
      hrefResource,
      dataSource.camera,
      dataSource.canvas,
      viewBoundScale,
      dataSource._lastCameraView.bbox,
      ellipsoid
    );
    return hrefResource;
  }
  return hrefResource;
}
function processBillboardIcon(dataSource, node, targetEntity, sourceResource, uriResolver) {
  let scale = queryNumericValue2(node, "scale", namespaces2.kml);
  const heading = queryNumericValue2(node, "heading", namespaces2.kml);
  const color = queryColorValue(node, "color", namespaces2.kml);
  const iconNode = queryFirstNode2(node, "Icon", namespaces2.kml);
  let icon = getIconHref(
    iconNode,
    dataSource,
    sourceResource,
    uriResolver,
    false
  );
  if (defined_default(iconNode) && !defined_default(icon)) {
    icon = false;
  }
  const x = queryNumericValue2(iconNode, "x", namespaces2.gx);
  const y = queryNumericValue2(iconNode, "y", namespaces2.gx);
  const w = queryNumericValue2(iconNode, "w", namespaces2.gx);
  const h = queryNumericValue2(iconNode, "h", namespaces2.gx);
  const hotSpotNode = queryFirstNode2(node, "hotSpot", namespaces2.kml);
  const hotSpotX = queryNumericAttribute2(hotSpotNode, "x");
  const hotSpotY = queryNumericAttribute2(hotSpotNode, "y");
  const hotSpotXUnit = queryStringAttribute2(hotSpotNode, "xunits");
  const hotSpotYUnit = queryStringAttribute2(hotSpotNode, "yunits");
  let billboard = targetEntity.billboard;
  if (!defined_default(billboard)) {
    billboard = createDefaultBillboard2();
    targetEntity.billboard = billboard;
  }
  billboard.image = icon;
  billboard.scale = scale;
  billboard.color = color;
  if (defined_default(x) || defined_default(y) || defined_default(w) || defined_default(h)) {
    billboard.imageSubRegion = new BoundingRectangle_default(x, y, w, h);
  }
  if (defined_default(heading) && heading !== 0) {
    billboard.rotation = Math_default.toRadians(-heading);
    billboard.alignedAxis = Cartesian3_default.UNIT_Z;
  }
  scale = defaultValue_default(scale, 1);
  let xOffset;
  let yOffset;
  if (defined_default(hotSpotX)) {
    if (hotSpotXUnit === "pixels") {
      xOffset = -hotSpotX * scale;
    } else if (hotSpotXUnit === "insetPixels") {
      xOffset = (hotSpotX - BILLBOARD_SIZE2) * scale;
    } else if (hotSpotXUnit === "fraction") {
      xOffset = -hotSpotX * BILLBOARD_SIZE2 * scale;
    }
    xOffset += BILLBOARD_SIZE2 * 0.5 * scale;
  }
  if (defined_default(hotSpotY)) {
    if (hotSpotYUnit === "pixels") {
      yOffset = hotSpotY * scale;
    } else if (hotSpotYUnit === "insetPixels") {
      yOffset = (-hotSpotY + BILLBOARD_SIZE2) * scale;
    } else if (hotSpotYUnit === "fraction") {
      yOffset = hotSpotY * BILLBOARD_SIZE2 * scale;
    }
    yOffset -= BILLBOARD_SIZE2 * 0.5 * scale;
  }
  if (defined_default(xOffset) || defined_default(yOffset)) {
    billboard.pixelOffset = new Cartesian2_default(xOffset, yOffset);
  }
}
function applyStyle(dataSource, styleNode, targetEntity, sourceResource, uriResolver) {
  for (let i2 = 0, len = styleNode.childNodes.length; i2 < len; i2++) {
    const node = styleNode.childNodes.item(i2);
    if (node.localName === "IconStyle") {
      processBillboardIcon(
        dataSource,
        node,
        targetEntity,
        sourceResource,
        uriResolver
      );
    } else if (node.localName === "LabelStyle") {
      let label = targetEntity.label;
      if (!defined_default(label)) {
        label = createDefaultLabel2();
        targetEntity.label = label;
      }
      label.scale = defaultValue_default(
        queryNumericValue2(node, "scale", namespaces2.kml),
        label.scale
      );
      label.fillColor = defaultValue_default(
        queryColorValue(node, "color", namespaces2.kml),
        label.fillColor
      );
      label.text = targetEntity.name;
    } else if (node.localName === "LineStyle") {
      let polyline = targetEntity.polyline;
      if (!defined_default(polyline)) {
        polyline = new PolylineGraphics_default();
        targetEntity.polyline = polyline;
      }
      polyline.width = queryNumericValue2(node, "width", namespaces2.kml);
      polyline.material = queryColorValue(node, "color", namespaces2.kml);
      if (defined_default(queryColorValue(node, "outerColor", namespaces2.gx))) {
        oneTimeWarning_default(
          "kml-gx:outerColor",
          "KML - gx:outerColor is not supported in a LineStyle"
        );
      }
      if (defined_default(queryNumericValue2(node, "outerWidth", namespaces2.gx))) {
        oneTimeWarning_default(
          "kml-gx:outerWidth",
          "KML - gx:outerWidth is not supported in a LineStyle"
        );
      }
      if (defined_default(queryNumericValue2(node, "physicalWidth", namespaces2.gx))) {
        oneTimeWarning_default(
          "kml-gx:physicalWidth",
          "KML - gx:physicalWidth is not supported in a LineStyle"
        );
      }
      if (defined_default(queryBooleanValue(node, "labelVisibility", namespaces2.gx))) {
        oneTimeWarning_default(
          "kml-gx:labelVisibility",
          "KML - gx:labelVisibility is not supported in a LineStyle"
        );
      }
    } else if (node.localName === "PolyStyle") {
      let polygon = targetEntity.polygon;
      if (!defined_default(polygon)) {
        polygon = createDefaultPolygon();
        targetEntity.polygon = polygon;
      }
      polygon.material = defaultValue_default(
        queryColorValue(node, "color", namespaces2.kml),
        polygon.material
      );
      polygon.fill = defaultValue_default(
        queryBooleanValue(node, "fill", namespaces2.kml),
        polygon.fill
      );
      polygon.outline = defaultValue_default(
        queryBooleanValue(node, "outline", namespaces2.kml),
        polygon.outline
      );
    } else if (node.localName === "BalloonStyle") {
      const bgColor = defaultValue_default(
        parseColorString(queryStringValue2(node, "bgColor", namespaces2.kml)),
        Color_default.WHITE
      );
      const textColor2 = defaultValue_default(
        parseColorString(queryStringValue2(node, "textColor", namespaces2.kml)),
        Color_default.BLACK
      );
      const text2 = queryStringValue2(node, "text", namespaces2.kml);
      targetEntity.addProperty("balloonStyle");
      targetEntity.balloonStyle = {
        bgColor,
        textColor: textColor2,
        text: text2
      };
    } else if (node.localName === "ListStyle") {
      const listItemType = queryStringValue2(
        node,
        "listItemType",
        namespaces2.kml
      );
      if (listItemType === "radioFolder" || listItemType === "checkOffOnly") {
        oneTimeWarning_default(
          `kml-listStyle-${listItemType}`,
          `KML - Unsupported ListStyle with listItemType: ${listItemType}`
        );
      }
    }
  }
}
function computeFinalStyle(dataSource, placeMark, styleCollection, sourceResource, uriResolver) {
  const result = new Entity_default();
  let styleEntity;
  let styleIndex = -1;
  const childNodes = placeMark.childNodes;
  const length3 = childNodes.length;
  for (let q = 0; q < length3; q++) {
    const child = childNodes[q];
    if (child.localName === "Style" || child.localName === "StyleMap") {
      styleIndex = q;
    }
  }
  if (styleIndex !== -1) {
    const inlineStyleNode = childNodes[styleIndex];
    if (inlineStyleNode.localName === "Style") {
      applyStyle(
        dataSource,
        inlineStyleNode,
        result,
        sourceResource,
        uriResolver
      );
    } else {
      const pairs = queryChildNodes(inlineStyleNode, "Pair", namespaces2.kml);
      for (let p2 = 0; p2 < pairs.length; p2++) {
        const pair = pairs[p2];
        const key = queryStringValue2(pair, "key", namespaces2.kml);
        if (key === "normal") {
          const styleUrl = queryStringValue2(pair, "styleUrl", namespaces2.kml);
          if (defined_default(styleUrl)) {
            styleEntity = styleCollection.getById(styleUrl);
            if (!defined_default(styleEntity)) {
              styleEntity = styleCollection.getById(`#${styleUrl}`);
            }
            if (defined_default(styleEntity)) {
              result.merge(styleEntity);
            }
          } else {
            const node = queryFirstNode2(pair, "Style", namespaces2.kml);
            applyStyle(dataSource, node, result, sourceResource, uriResolver);
          }
        } else {
          oneTimeWarning_default(
            `kml-styleMap-${key}`,
            `KML - Unsupported StyleMap key: ${key}`
          );
        }
      }
    }
  }
  const externalStyle = queryStringValue2(placeMark, "styleUrl", namespaces2.kml);
  if (defined_default(externalStyle)) {
    let id = externalStyle;
    if (externalStyle[0] !== "#" && externalStyle.indexOf("#") !== -1) {
      const tokens = externalStyle.split("#");
      const uri = tokens[0];
      const resource = sourceResource.getDerivedResource({
        url: uri
      });
      id = `${resource.getUrlComponent()}#${tokens[1]}`;
    }
    styleEntity = styleCollection.getById(id);
    if (!defined_default(styleEntity)) {
      styleEntity = styleCollection.getById(`#${id}`);
    }
    if (defined_default(styleEntity)) {
      result.merge(styleEntity);
    }
  }
  return result;
}
function processExternalStyles(dataSource, resource, styleCollection) {
  return resource.fetchXML().then(function(styleKml) {
    return processStyles(dataSource, styleKml, styleCollection, resource, true);
  });
}
function processStyles(dataSource, kml, styleCollection, sourceResource, isExternal, uriResolver) {
  let i2;
  let id;
  let styleEntity;
  let node;
  const styleNodes = queryNodes2(kml, "Style", namespaces2.kml);
  if (defined_default(styleNodes)) {
    const styleNodesLength = styleNodes.length;
    for (i2 = 0; i2 < styleNodesLength; i2++) {
      node = styleNodes[i2];
      id = queryStringAttribute2(node, "id");
      if (defined_default(id)) {
        id = `#${id}`;
        if (isExternal && defined_default(sourceResource)) {
          id = sourceResource.getUrlComponent() + id;
        }
        if (!defined_default(styleCollection.getById(id))) {
          styleEntity = new Entity_default({
            id
          });
          styleCollection.add(styleEntity);
          applyStyle(
            dataSource,
            node,
            styleEntity,
            sourceResource,
            uriResolver
          );
        }
      }
    }
  }
  const styleMaps = queryNodes2(kml, "StyleMap", namespaces2.kml);
  if (defined_default(styleMaps)) {
    const styleMapsLength = styleMaps.length;
    for (i2 = 0; i2 < styleMapsLength; i2++) {
      const styleMap = styleMaps[i2];
      id = queryStringAttribute2(styleMap, "id");
      if (defined_default(id)) {
        const pairs = queryChildNodes(styleMap, "Pair", namespaces2.kml);
        for (let p2 = 0; p2 < pairs.length; p2++) {
          const pair = pairs[p2];
          const key = queryStringValue2(pair, "key", namespaces2.kml);
          if (key === "normal") {
            id = `#${id}`;
            if (isExternal && defined_default(sourceResource)) {
              id = sourceResource.getUrlComponent() + id;
            }
            if (!defined_default(styleCollection.getById(id))) {
              styleEntity = styleCollection.getOrCreateEntity(id);
              let styleUrl = queryStringValue2(pair, "styleUrl", namespaces2.kml);
              if (defined_default(styleUrl)) {
                if (styleUrl[0] !== "#") {
                  styleUrl = `#${styleUrl}`;
                }
                if (isExternal && defined_default(sourceResource)) {
                  styleUrl = sourceResource.getUrlComponent() + styleUrl;
                }
                const base = styleCollection.getById(styleUrl);
                if (defined_default(base)) {
                  styleEntity.merge(base);
                }
              } else {
                node = queryFirstNode2(pair, "Style", namespaces2.kml);
                applyStyle(
                  dataSource,
                  node,
                  styleEntity,
                  sourceResource,
                  uriResolver
                );
              }
            }
          } else {
            oneTimeWarning_default(
              `kml-styleMap-${key}`,
              `KML - Unsupported StyleMap key: ${key}`
            );
          }
        }
      }
    }
  }
  const promises = [];
  const styleUrlNodes = kml.getElementsByTagName("styleUrl");
  const styleUrlNodesLength = styleUrlNodes.length;
  for (i2 = 0; i2 < styleUrlNodesLength; i2++) {
    const styleReference = styleUrlNodes[i2].textContent;
    if (styleReference[0] !== "#") {
      const tokens = styleReference.split("#");
      if (tokens.length === 2) {
        const uri = tokens[0];
        const resource = sourceResource.getDerivedResource({
          url: uri
        });
        promises.push(
          processExternalStyles(dataSource, resource, styleCollection)
        );
      }
    }
  }
  return promises;
}
function createDropLine(entityCollection, entity, styleEntity) {
  const entityPosition = new ReferenceProperty_default(entityCollection, entity.id, [
    "position"
  ]);
  const surfacePosition = new ScaledPositionProperty_default(entity.position);
  entity.polyline = defined_default(styleEntity.polyline) ? styleEntity.polyline.clone() : new PolylineGraphics_default();
  entity.polyline.positions = new PositionPropertyArray_default([
    entityPosition,
    surfacePosition
  ]);
}
function heightReferenceFromAltitudeMode(altitudeMode, gxAltitudeMode) {
  if (!defined_default(altitudeMode) && !defined_default(gxAltitudeMode) || altitudeMode === "clampToGround") {
    return HeightReference_default.CLAMP_TO_GROUND;
  }
  if (altitudeMode === "relativeToGround") {
    return HeightReference_default.RELATIVE_TO_GROUND;
  }
  if (altitudeMode === "absolute") {
    return HeightReference_default.NONE;
  }
  if (gxAltitudeMode === "clampToSeaFloor") {
    oneTimeWarning_default(
      "kml-gx:altitudeMode-clampToSeaFloor",
      "KML - <gx:altitudeMode>:clampToSeaFloor is currently not supported, using <kml:altitudeMode>:clampToGround."
    );
    return HeightReference_default.CLAMP_TO_GROUND;
  }
  if (gxAltitudeMode === "relativeToSeaFloor") {
    oneTimeWarning_default(
      "kml-gx:altitudeMode-relativeToSeaFloor",
      "KML - <gx:altitudeMode>:relativeToSeaFloor is currently not supported, using <kml:altitudeMode>:relativeToGround."
    );
    return HeightReference_default.RELATIVE_TO_GROUND;
  }
  if (defined_default(altitudeMode)) {
    oneTimeWarning_default(
      "kml-altitudeMode-unknown",
      `KML - Unknown <kml:altitudeMode>:${altitudeMode}, using <kml:altitudeMode>:CLAMP_TO_GROUND.`
    );
  } else {
    oneTimeWarning_default(
      "kml-gx:altitudeMode-unknown",
      `KML - Unknown <gx:altitudeMode>:${gxAltitudeMode}, using <kml:altitudeMode>:CLAMP_TO_GROUND.`
    );
  }
  return HeightReference_default.CLAMP_TO_GROUND;
}
function createPositionPropertyFromAltitudeMode(property, altitudeMode, gxAltitudeMode) {
  if (gxAltitudeMode === "relativeToSeaFloor" || altitudeMode === "absolute" || altitudeMode === "relativeToGround") {
    return property;
  }
  if (defined_default(altitudeMode) && altitudeMode !== "clampToGround" || defined_default(gxAltitudeMode) && gxAltitudeMode !== "clampToSeaFloor") {
    oneTimeWarning_default(
      "kml-altitudeMode-unknown",
      `KML - Unknown altitudeMode: ${defaultValue_default(
        altitudeMode,
        gxAltitudeMode
      )}`
    );
  }
  return new ScaledPositionProperty_default(property);
}
function createPositionPropertyArrayFromAltitudeMode(properties, altitudeMode, gxAltitudeMode, ellipsoid) {
  if (!defined_default(properties)) {
    return void 0;
  }
  if (gxAltitudeMode === "relativeToSeaFloor" || altitudeMode === "absolute" || altitudeMode === "relativeToGround") {
    return properties;
  }
  if (defined_default(altitudeMode) && altitudeMode !== "clampToGround" || defined_default(gxAltitudeMode) && gxAltitudeMode !== "clampToSeaFloor") {
    oneTimeWarning_default(
      "kml-altitudeMode-unknown",
      `KML - Unknown altitudeMode: ${defaultValue_default(
        altitudeMode,
        gxAltitudeMode
      )}`
    );
  }
  const propertiesLength = properties.length;
  for (let i2 = 0; i2 < propertiesLength; i2++) {
    const property = properties[i2];
    ellipsoid.scaleToGeodeticSurface(property, property);
  }
  return properties;
}
function processPositionGraphics(dataSource, entity, styleEntity, heightReference) {
  let label = entity.label;
  if (!defined_default(label)) {
    label = defined_default(styleEntity.label) ? styleEntity.label.clone() : createDefaultLabel2();
    entity.label = label;
  }
  label.text = entity.name;
  let billboard = entity.billboard;
  if (!defined_default(billboard)) {
    billboard = defined_default(styleEntity.billboard) ? styleEntity.billboard.clone() : createDefaultBillboard2();
    entity.billboard = billboard;
  }
  if (!defined_default(billboard.image)) {
    billboard.image = dataSource._pinBuilder.fromColor(Color_default.YELLOW, 64);
  } else if (!billboard.image.getValue()) {
    billboard.image = void 0;
  }
  let scale = 1;
  if (defined_default(billboard.scale)) {
    scale = billboard.scale.getValue();
    if (scale !== 0) {
      label.pixelOffset = new Cartesian2_default(scale * 16 + 1, 0);
    } else {
      label.pixelOffset = void 0;
      label.horizontalOrigin = void 0;
    }
  }
  if (defined_default(heightReference) && dataSource._clampToGround) {
    billboard.heightReference = heightReference;
    label.heightReference = heightReference;
  }
}
function processPathGraphics(entity, styleEntity) {
  let path = entity.path;
  if (!defined_default(path)) {
    path = new PathGraphics_default();
    path.leadTime = 0;
    entity.path = path;
  }
  const polyline = styleEntity.polyline;
  if (defined_default(polyline)) {
    path.material = polyline.material;
    path.width = polyline.width;
  }
}
function processPoint3(dataSource, entityCollection, geometryNode, entity, styleEntity) {
  const coordinatesString = queryStringValue2(
    geometryNode,
    "coordinates",
    namespaces2.kml
  );
  const altitudeMode = queryStringValue2(
    geometryNode,
    "altitudeMode",
    namespaces2.kml
  );
  const gxAltitudeMode = queryStringValue2(
    geometryNode,
    "altitudeMode",
    namespaces2.gx
  );
  const extrude = queryBooleanValue(geometryNode, "extrude", namespaces2.kml);
  const ellipsoid = dataSource._ellipsoid;
  const position = readCoordinate(coordinatesString, ellipsoid);
  entity.position = position;
  processPositionGraphics(
    dataSource,
    entity,
    styleEntity,
    heightReferenceFromAltitudeMode(altitudeMode, gxAltitudeMode)
  );
  if (extrude && isExtrudable(altitudeMode, gxAltitudeMode)) {
    createDropLine(entityCollection, entity, styleEntity);
  }
  return true;
}
function processLineStringOrLinearRing(dataSource, entityCollection, geometryNode, entity, styleEntity) {
  const coordinatesNode = queryFirstNode2(
    geometryNode,
    "coordinates",
    namespaces2.kml
  );
  const altitudeMode = queryStringValue2(
    geometryNode,
    "altitudeMode",
    namespaces2.kml
  );
  const gxAltitudeMode = queryStringValue2(
    geometryNode,
    "altitudeMode",
    namespaces2.gx
  );
  const extrude = queryBooleanValue(geometryNode, "extrude", namespaces2.kml);
  const tessellate = queryBooleanValue(
    geometryNode,
    "tessellate",
    namespaces2.kml
  );
  const canExtrude = isExtrudable(altitudeMode, gxAltitudeMode);
  const zIndex = queryNumericValue2(geometryNode, "drawOrder", namespaces2.gx);
  const ellipsoid = dataSource._ellipsoid;
  const coordinates = readCoordinates(coordinatesNode, ellipsoid);
  let polyline = styleEntity.polyline;
  if (canExtrude && extrude) {
    const wall = new WallGraphics_default();
    entity.wall = wall;
    wall.positions = coordinates;
    const polygon = styleEntity.polygon;
    if (defined_default(polygon)) {
      wall.fill = polygon.fill;
      wall.material = polygon.material;
    }
    wall.outline = true;
    if (defined_default(polyline)) {
      wall.outlineColor = defined_default(polyline.material) ? polyline.material.color : Color_default.WHITE;
      wall.outlineWidth = polyline.width;
    } else if (defined_default(polygon)) {
      wall.outlineColor = defined_default(polygon.material) ? polygon.material.color : Color_default.WHITE;
    }
  } else if (dataSource._clampToGround && !canExtrude && tessellate) {
    const polylineGraphics = new PolylineGraphics_default();
    polylineGraphics.clampToGround = true;
    entity.polyline = polylineGraphics;
    polylineGraphics.positions = coordinates;
    if (defined_default(polyline)) {
      polylineGraphics.material = defined_default(polyline.material) ? polyline.material.color.getValue(Iso8601_default.MINIMUM_VALUE) : Color_default.WHITE;
      polylineGraphics.width = defaultValue_default(polyline.width, 1);
    } else {
      polylineGraphics.material = Color_default.WHITE;
      polylineGraphics.width = 1;
    }
    polylineGraphics.zIndex = zIndex;
  } else {
    if (defined_default(zIndex)) {
      oneTimeWarning_default(
        "kml-gx:drawOrder",
        "KML - gx:drawOrder is not supported in LineStrings when clampToGround is false"
      );
    }
    if (dataSource._clampToGround && !tessellate) {
      oneTimeWarning_default(
        "kml-line-tesselate",
        "Ignoring clampToGround for KML lines without the tessellate flag."
      );
    }
    polyline = defined_default(polyline) ? polyline.clone() : new PolylineGraphics_default();
    entity.polyline = polyline;
    polyline.positions = createPositionPropertyArrayFromAltitudeMode(
      coordinates,
      altitudeMode,
      gxAltitudeMode,
      ellipsoid
    );
    if (!tessellate || canExtrude) {
      polyline.arcType = ArcType_default.NONE;
    }
  }
  return true;
}
function processPolygon3(dataSource, entityCollection, geometryNode, entity, styleEntity) {
  const outerBoundaryIsNode = queryFirstNode2(
    geometryNode,
    "outerBoundaryIs",
    namespaces2.kml
  );
  let linearRingNode = queryFirstNode2(
    outerBoundaryIsNode,
    "LinearRing",
    namespaces2.kml
  );
  let coordinatesNode = queryFirstNode2(
    linearRingNode,
    "coordinates",
    namespaces2.kml
  );
  const ellipsoid = dataSource._ellipsoid;
  let coordinates = readCoordinates(coordinatesNode, ellipsoid);
  const extrude = queryBooleanValue(geometryNode, "extrude", namespaces2.kml);
  const altitudeMode = queryStringValue2(
    geometryNode,
    "altitudeMode",
    namespaces2.kml
  );
  const gxAltitudeMode = queryStringValue2(
    geometryNode,
    "altitudeMode",
    namespaces2.gx
  );
  const canExtrude = isExtrudable(altitudeMode, gxAltitudeMode);
  const polygon = defined_default(styleEntity.polygon) ? styleEntity.polygon.clone() : createDefaultPolygon();
  const polyline = styleEntity.polyline;
  if (defined_default(polyline)) {
    polygon.outlineColor = defined_default(polyline.material) ? polyline.material.color : Color_default.WHITE;
    polygon.outlineWidth = polyline.width;
  }
  entity.polygon = polygon;
  if (canExtrude) {
    polygon.perPositionHeight = true;
    polygon.extrudedHeight = extrude ? 0 : void 0;
  } else if (!dataSource._clampToGround) {
    polygon.height = 0;
  }
  if (defined_default(coordinates)) {
    const hierarchy = new PolygonHierarchy_default(coordinates);
    const innerBoundaryIsNodes = queryChildNodes(
      geometryNode,
      "innerBoundaryIs",
      namespaces2.kml
    );
    for (let j = 0; j < innerBoundaryIsNodes.length; j++) {
      linearRingNode = queryChildNodes(
        innerBoundaryIsNodes[j],
        "LinearRing",
        namespaces2.kml
      );
      for (let k = 0; k < linearRingNode.length; k++) {
        coordinatesNode = queryFirstNode2(
          linearRingNode[k],
          "coordinates",
          namespaces2.kml
        );
        coordinates = readCoordinates(coordinatesNode, ellipsoid);
        if (defined_default(coordinates)) {
          hierarchy.holes.push(new PolygonHierarchy_default(coordinates));
        }
      }
    }
    polygon.hierarchy = hierarchy;
  }
  return true;
}
function processTrack(dataSource, entityCollection, geometryNode, entity, styleEntity) {
  const altitudeMode = queryStringValue2(
    geometryNode,
    "altitudeMode",
    namespaces2.kml
  );
  const gxAltitudeMode = queryStringValue2(
    geometryNode,
    "altitudeMode",
    namespaces2.gx
  );
  const coordNodes = queryChildNodes(geometryNode, "coord", namespaces2.gx);
  const angleNodes = queryChildNodes(geometryNode, "angles", namespaces2.gx);
  const timeNodes = queryChildNodes(geometryNode, "when", namespaces2.kml);
  const extrude = queryBooleanValue(geometryNode, "extrude", namespaces2.kml);
  const canExtrude = isExtrudable(altitudeMode, gxAltitudeMode);
  const ellipsoid = dataSource._ellipsoid;
  if (angleNodes.length > 0) {
    oneTimeWarning_default(
      "kml-gx:angles",
      "KML - gx:angles are not supported in gx:Tracks"
    );
  }
  const length3 = Math.min(coordNodes.length, timeNodes.length);
  const coordinates = [];
  const times = [];
  for (let i2 = 0; i2 < length3; i2++) {
    const position = readCoordinate(coordNodes[i2].textContent, ellipsoid);
    coordinates.push(position);
    times.push(JulianDate_default.fromIso8601(timeNodes[i2].textContent));
  }
  const property = new SampledPositionProperty_default();
  property.addSamples(times, coordinates);
  entity.position = property;
  processPositionGraphics(
    dataSource,
    entity,
    styleEntity,
    heightReferenceFromAltitudeMode(altitudeMode, gxAltitudeMode)
  );
  processPathGraphics(entity, styleEntity);
  entity.availability = new TimeIntervalCollection_default();
  if (timeNodes.length > 0) {
    entity.availability.addInterval(
      new TimeInterval_default({
        start: times[0],
        stop: times[times.length - 1]
      })
    );
  }
  if (canExtrude && extrude) {
    createDropLine(entityCollection, entity, styleEntity);
  }
  return true;
}
function addToMultiTrack(times, positions, composite, availability, dropShowProperty, extrude, altitudeMode, gxAltitudeMode, includeEndPoints) {
  const start = times[0];
  const stop2 = times[times.length - 1];
  const data = new SampledPositionProperty_default();
  data.addSamples(times, positions);
  composite.intervals.addInterval(
    new TimeInterval_default({
      start,
      stop: stop2,
      isStartIncluded: includeEndPoints,
      isStopIncluded: includeEndPoints,
      data: createPositionPropertyFromAltitudeMode(
        data,
        altitudeMode,
        gxAltitudeMode
      )
    })
  );
  availability.addInterval(
    new TimeInterval_default({
      start,
      stop: stop2,
      isStartIncluded: includeEndPoints,
      isStopIncluded: includeEndPoints
    })
  );
  dropShowProperty.intervals.addInterval(
    new TimeInterval_default({
      start,
      stop: stop2,
      isStartIncluded: includeEndPoints,
      isStopIncluded: includeEndPoints,
      data: extrude
    })
  );
}
function processMultiTrack(dataSource, entityCollection, geometryNode, entity, styleEntity) {
  const interpolate2 = queryBooleanValue(
    geometryNode,
    "interpolate",
    namespaces2.gx
  );
  const trackNodes = queryChildNodes(geometryNode, "Track", namespaces2.gx);
  let times;
  let lastStop;
  let lastStopPosition;
  let needDropLine = false;
  const dropShowProperty = new TimeIntervalCollectionProperty_default();
  const availability = new TimeIntervalCollection_default();
  const composite = new CompositePositionProperty_default();
  const ellipsoid = dataSource._ellipsoid;
  for (let i2 = 0, len = trackNodes.length; i2 < len; i2++) {
    const trackNode = trackNodes[i2];
    const timeNodes = queryChildNodes(trackNode, "when", namespaces2.kml);
    const coordNodes = queryChildNodes(trackNode, "coord", namespaces2.gx);
    const altitudeMode = queryStringValue2(
      trackNode,
      "altitudeMode",
      namespaces2.kml
    );
    const gxAltitudeMode = queryStringValue2(
      trackNode,
      "altitudeMode",
      namespaces2.gx
    );
    const canExtrude = isExtrudable(altitudeMode, gxAltitudeMode);
    const extrude = queryBooleanValue(trackNode, "extrude", namespaces2.kml);
    const length3 = Math.min(coordNodes.length, timeNodes.length);
    const positions = [];
    times = [];
    for (let x = 0; x < length3; x++) {
      const position = readCoordinate(coordNodes[x].textContent, ellipsoid);
      positions.push(position);
      times.push(JulianDate_default.fromIso8601(timeNodes[x].textContent));
    }
    if (interpolate2) {
      if (defined_default(lastStop)) {
        addToMultiTrack(
          [lastStop, times[0]],
          [lastStopPosition, positions[0]],
          composite,
          availability,
          dropShowProperty,
          false,
          "absolute",
          void 0,
          false
        );
      }
      lastStop = times[length3 - 1];
      lastStopPosition = positions[positions.length - 1];
    }
    addToMultiTrack(
      times,
      positions,
      composite,
      availability,
      dropShowProperty,
      canExtrude && extrude,
      altitudeMode,
      gxAltitudeMode,
      true
    );
    needDropLine = needDropLine || canExtrude && extrude;
  }
  entity.availability = availability;
  entity.position = composite;
  processPositionGraphics(dataSource, entity, styleEntity);
  processPathGraphics(entity, styleEntity);
  if (needDropLine) {
    createDropLine(entityCollection, entity, styleEntity);
    entity.polyline.show = dropShowProperty;
  }
  return true;
}
var geometryTypes2 = {
  Point: processPoint3,
  LineString: processLineStringOrLinearRing,
  LinearRing: processLineStringOrLinearRing,
  Polygon: processPolygon3,
  Track: processTrack,
  MultiTrack: processMultiTrack,
  MultiGeometry: processMultiGeometry,
  Model: processUnsupportedGeometry
};
function processMultiGeometry(dataSource, entityCollection, geometryNode, entity, styleEntity, context) {
  const childNodes = geometryNode.childNodes;
  let hasGeometry = false;
  for (let i2 = 0, len = childNodes.length; i2 < len; i2++) {
    const childNode = childNodes.item(i2);
    const geometryProcessor = geometryTypes2[childNode.localName];
    if (defined_default(geometryProcessor)) {
      const childEntity = createEntity(childNode, entityCollection, context);
      childEntity.parent = entity;
      childEntity.name = entity.name;
      childEntity.availability = entity.availability;
      childEntity.description = entity.description;
      childEntity.kml = entity.kml;
      if (geometryProcessor(
        dataSource,
        entityCollection,
        childNode,
        childEntity,
        styleEntity
      )) {
        hasGeometry = true;
      }
    }
  }
  return hasGeometry;
}
function processUnsupportedGeometry(dataSource, entityCollection, geometryNode, entity, styleEntity) {
  oneTimeWarning_default(
    "kml-unsupportedGeometry",
    `KML - Unsupported geometry: ${geometryNode.localName}`
  );
  return false;
}
function processExtendedData(node, entity) {
  const extendedDataNode = queryFirstNode2(node, "ExtendedData", namespaces2.kml);
  if (!defined_default(extendedDataNode)) {
    return void 0;
  }
  if (defined_default(queryFirstNode2(extendedDataNode, "SchemaData", namespaces2.kml))) {
    oneTimeWarning_default("kml-schemaData", "KML - SchemaData is unsupported");
  }
  if (defined_default(queryStringAttribute2(extendedDataNode, "xmlns:prefix"))) {
    oneTimeWarning_default(
      "kml-extendedData",
      "KML - ExtendedData with xmlns:prefix is unsupported"
    );
  }
  const result = {};
  const dataNodes = queryChildNodes(extendedDataNode, "Data", namespaces2.kml);
  if (defined_default(dataNodes)) {
    const length3 = dataNodes.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const dataNode = dataNodes[i2];
      const name = queryStringAttribute2(dataNode, "name");
      if (defined_default(name)) {
        result[name] = {
          displayName: queryStringValue2(
            dataNode,
            "displayName",
            namespaces2.kml
          ),
          value: queryStringValue2(dataNode, "value", namespaces2.kml)
        };
      }
    }
  }
  entity.kml.extendedData = result;
}
var scratchDiv2;
if (typeof document !== "undefined") {
  scratchDiv2 = document.createElement("div");
}
function processDescription3(node, entity, styleEntity, uriResolver, sourceResource) {
  let i2;
  let key;
  let keys;
  const kmlData = entity.kml;
  const extendedData = kmlData.extendedData;
  const description = queryStringValue2(node, "description", namespaces2.kml);
  const balloonStyle = defaultValue_default(
    entity.balloonStyle,
    styleEntity.balloonStyle
  );
  let background = Color_default.WHITE;
  let foreground = Color_default.BLACK;
  let text2 = description;
  if (defined_default(balloonStyle)) {
    background = defaultValue_default(balloonStyle.bgColor, Color_default.WHITE);
    foreground = defaultValue_default(balloonStyle.textColor, Color_default.BLACK);
    text2 = defaultValue_default(balloonStyle.text, description);
  }
  let value;
  if (defined_default(text2)) {
    text2 = text2.replace("$[name]", defaultValue_default(entity.name, ""));
    text2 = text2.replace("$[description]", defaultValue_default(description, ""));
    text2 = text2.replace("$[address]", defaultValue_default(kmlData.address, ""));
    text2 = text2.replace("$[Snippet]", defaultValue_default(kmlData.snippet, ""));
    text2 = text2.replace("$[id]", entity.id);
    text2 = text2.replace("$[geDirections]", "");
    if (defined_default(extendedData)) {
      const matches = text2.match(/\$\[.+?\]/g);
      if (matches !== null) {
        for (i2 = 0; i2 < matches.length; i2++) {
          const token = matches[i2];
          let propertyName = token.substr(2, token.length - 3);
          const isDisplayName = /\/displayName$/.test(propertyName);
          propertyName = propertyName.replace(/\/displayName$/, "");
          value = extendedData[propertyName];
          if (defined_default(value)) {
            value = isDisplayName ? value.displayName : value.value;
          }
          if (defined_default(value)) {
            text2 = text2.replace(token, defaultValue_default(value, ""));
          }
        }
      }
    }
  } else if (defined_default(extendedData)) {
    keys = Object.keys(extendedData);
    if (keys.length > 0) {
      text2 = '<table class="cesium-infoBox-defaultTable cesium-infoBox-defaultTable-lighter"><tbody>';
      for (i2 = 0; i2 < keys.length; i2++) {
        key = keys[i2];
        value = extendedData[key];
        text2 += `<tr><th>${defaultValue_default(
          value.displayName,
          key
        )}</th><td>${defaultValue_default(value.value, "")}</td></tr>`;
      }
      text2 += "</tbody></table>";
    }
  }
  if (!defined_default(text2)) {
    return;
  }
  text2 = autolinker2.link(text2);
  scratchDiv2.innerHTML = text2;
  const links = scratchDiv2.querySelectorAll("a");
  for (i2 = 0; i2 < links.length; i2++) {
    links[i2].setAttribute("target", "_blank");
  }
  if (defined_default(uriResolver) && uriResolver.keys.length > 1) {
    embedDataUris(scratchDiv2, "a", "href", uriResolver);
    embedDataUris(scratchDiv2, "link", "href", uriResolver);
    embedDataUris(scratchDiv2, "area", "href", uriResolver);
    embedDataUris(scratchDiv2, "img", "src", uriResolver);
    embedDataUris(scratchDiv2, "iframe", "src", uriResolver);
    embedDataUris(scratchDiv2, "video", "src", uriResolver);
    embedDataUris(scratchDiv2, "audio", "src", uriResolver);
    embedDataUris(scratchDiv2, "source", "src", uriResolver);
    embedDataUris(scratchDiv2, "track", "src", uriResolver);
    embedDataUris(scratchDiv2, "input", "src", uriResolver);
    embedDataUris(scratchDiv2, "embed", "src", uriResolver);
    embedDataUris(scratchDiv2, "script", "src", uriResolver);
    embedDataUris(scratchDiv2, "video", "poster", uriResolver);
  }
  applyBasePath(scratchDiv2, "a", "href", sourceResource);
  applyBasePath(scratchDiv2, "link", "href", sourceResource);
  applyBasePath(scratchDiv2, "area", "href", sourceResource);
  applyBasePath(scratchDiv2, "img", "src", sourceResource);
  applyBasePath(scratchDiv2, "iframe", "src", sourceResource);
  applyBasePath(scratchDiv2, "video", "src", sourceResource);
  applyBasePath(scratchDiv2, "audio", "src", sourceResource);
  applyBasePath(scratchDiv2, "source", "src", sourceResource);
  applyBasePath(scratchDiv2, "track", "src", sourceResource);
  applyBasePath(scratchDiv2, "input", "src", sourceResource);
  applyBasePath(scratchDiv2, "embed", "src", sourceResource);
  applyBasePath(scratchDiv2, "script", "src", sourceResource);
  applyBasePath(scratchDiv2, "video", "poster", sourceResource);
  let tmp2 = '<div class="cesium-infoBox-description-lighter" style="';
  tmp2 += "overflow:auto;";
  tmp2 += "word-wrap:break-word;";
  tmp2 += `background-color:${background.toCssColorString()};`;
  tmp2 += `color:${foreground.toCssColorString()};`;
  tmp2 += '">';
  tmp2 += `${scratchDiv2.innerHTML}</div>`;
  scratchDiv2.innerHTML = "";
  entity.description = tmp2;
}
function processFeature2(dataSource, featureNode, processingData) {
  const entityCollection = processingData.entityCollection;
  const parent = processingData.parentEntity;
  const sourceResource = processingData.sourceResource;
  const uriResolver = processingData.uriResolver;
  const entity = createEntity(
    featureNode,
    entityCollection,
    processingData.context
  );
  const kmlData = entity.kml;
  const styleEntity = computeFinalStyle(
    dataSource,
    featureNode,
    processingData.styleCollection,
    sourceResource,
    uriResolver
  );
  const name = queryStringValue2(featureNode, "name", namespaces2.kml);
  entity.name = name;
  entity.parent = parent;
  let availability = processTimeSpan(featureNode);
  if (!defined_default(availability)) {
    availability = processTimeStamp(featureNode);
  }
  entity.availability = availability;
  mergeAvailabilityWithParent(entity);
  function ancestryIsVisible(parentEntity) {
    if (!parentEntity) {
      return true;
    }
    return parentEntity.show && ancestryIsVisible(parentEntity.parent);
  }
  const visibility = queryBooleanValue(
    featureNode,
    "visibility",
    namespaces2.kml
  );
  entity.show = ancestryIsVisible(parent) && defaultValue_default(visibility, true);
  const authorNode = queryFirstNode2(featureNode, "author", namespaces2.atom);
  const author = kmlData.author;
  author.name = queryStringValue2(authorNode, "name", namespaces2.atom);
  author.uri = queryStringValue2(authorNode, "uri", namespaces2.atom);
  author.email = queryStringValue2(authorNode, "email", namespaces2.atom);
  const linkNode = queryFirstNode2(featureNode, "link", namespaces2.atom);
  const link = kmlData.link;
  link.href = queryStringAttribute2(linkNode, "href");
  link.hreflang = queryStringAttribute2(linkNode, "hreflang");
  link.rel = queryStringAttribute2(linkNode, "rel");
  link.type = queryStringAttribute2(linkNode, "type");
  link.title = queryStringAttribute2(linkNode, "title");
  link.length = queryStringAttribute2(linkNode, "length");
  kmlData.address = queryStringValue2(featureNode, "address", namespaces2.kml);
  kmlData.phoneNumber = queryStringValue2(
    featureNode,
    "phoneNumber",
    namespaces2.kml
  );
  kmlData.snippet = queryStringValue2(featureNode, "Snippet", namespaces2.kml);
  processExtendedData(featureNode, entity);
  processDescription3(
    featureNode,
    entity,
    styleEntity,
    uriResolver,
    sourceResource
  );
  const ellipsoid = dataSource._ellipsoid;
  processLookAt(featureNode, entity, ellipsoid);
  processCamera(featureNode, entity, ellipsoid);
  if (defined_default(queryFirstNode2(featureNode, "Region", namespaces2.kml))) {
    oneTimeWarning_default("kml-region", "KML - Placemark Regions are unsupported");
  }
  return {
    entity,
    styleEntity
  };
}
function processDocument2(dataSource, node, processingData, deferredLoading) {
  deferredLoading.addNodes(node.childNodes, processingData);
  deferredLoading.process();
}
function processFolder(dataSource, node, processingData, deferredLoading) {
  const r2 = processFeature2(dataSource, node, processingData);
  const newProcessingData = clone_default(processingData);
  newProcessingData.parentEntity = r2.entity;
  processDocument2(dataSource, node, newProcessingData, deferredLoading);
}
function processPlacemark(dataSource, placemark, processingData, deferredLoading) {
  const r2 = processFeature2(dataSource, placemark, processingData);
  const entity = r2.entity;
  const styleEntity = r2.styleEntity;
  let hasGeometry = false;
  const childNodes = placemark.childNodes;
  for (let i2 = 0, len = childNodes.length; i2 < len && !hasGeometry; i2++) {
    const childNode = childNodes.item(i2);
    const geometryProcessor = geometryTypes2[childNode.localName];
    if (defined_default(geometryProcessor)) {
      geometryProcessor(
        dataSource,
        processingData.entityCollection,
        childNode,
        entity,
        styleEntity,
        entity.id
      );
      hasGeometry = true;
    }
  }
  if (!hasGeometry) {
    entity.merge(styleEntity);
    processPositionGraphics(dataSource, entity, styleEntity);
  }
}
var playlistNodeProcessors = {
  FlyTo: processTourFlyTo,
  Wait: processTourWait,
  SoundCue: processTourUnsupportedNode,
  AnimatedUpdate: processTourUnsupportedNode,
  TourControl: processTourUnsupportedNode
};
function processTour(dataSource, node, processingData, deferredLoading) {
  const name = queryStringValue2(node, "name", namespaces2.kml);
  const id = queryStringAttribute2(node, "id");
  const tour = new KmlTour_default(name, id);
  const playlistNode = queryFirstNode2(node, "Playlist", namespaces2.gx);
  if (playlistNode) {
    const ellipsoid = dataSource._ellipsoid;
    const childNodes = playlistNode.childNodes;
    for (let i2 = 0; i2 < childNodes.length; i2++) {
      const entryNode = childNodes[i2];
      if (entryNode.localName) {
        const playlistNodeProcessor = playlistNodeProcessors[entryNode.localName];
        if (playlistNodeProcessor) {
          playlistNodeProcessor(tour, entryNode, ellipsoid);
        } else {
          console.log(
            `Unknown KML Tour playlist entry type ${entryNode.localName}`
          );
        }
      }
    }
  }
  dataSource._kmlTours.push(tour);
}
function processTourUnsupportedNode(tour, entryNode) {
  oneTimeWarning_default(`KML Tour unsupported node ${entryNode.localName}`);
}
function processTourWait(tour, entryNode) {
  const duration = queryNumericValue2(entryNode, "duration", namespaces2.gx);
  tour.addPlaylistEntry(new KmlTourWait_default(duration));
}
function processTourFlyTo(tour, entryNode, ellipsoid) {
  const duration = queryNumericValue2(entryNode, "duration", namespaces2.gx);
  const flyToMode = queryStringValue2(entryNode, "flyToMode", namespaces2.gx);
  const t = { kml: {} };
  processLookAt(entryNode, t, ellipsoid);
  processCamera(entryNode, t, ellipsoid);
  const view = t.kml.lookAt || t.kml.camera;
  const flyto = new KmlTourFlyTo_default(duration, flyToMode, view);
  tour.addPlaylistEntry(flyto);
}
function processCamera(featureNode, entity, ellipsoid) {
  const camera = queryFirstNode2(featureNode, "Camera", namespaces2.kml);
  if (defined_default(camera)) {
    const lon = defaultValue_default(
      queryNumericValue2(camera, "longitude", namespaces2.kml),
      0
    );
    const lat = defaultValue_default(
      queryNumericValue2(camera, "latitude", namespaces2.kml),
      0
    );
    const altitude = defaultValue_default(
      queryNumericValue2(camera, "altitude", namespaces2.kml),
      0
    );
    const heading = defaultValue_default(
      queryNumericValue2(camera, "heading", namespaces2.kml),
      0
    );
    const tilt = defaultValue_default(
      queryNumericValue2(camera, "tilt", namespaces2.kml),
      0
    );
    const roll = defaultValue_default(
      queryNumericValue2(camera, "roll", namespaces2.kml),
      0
    );
    const position = Cartesian3_default.fromDegrees(lon, lat, altitude, ellipsoid);
    const hpr = HeadingPitchRoll_default.fromDegrees(heading, tilt - 90, roll);
    entity.kml.camera = new KmlCamera_default(position, hpr);
  }
}
function processLookAt(featureNode, entity, ellipsoid) {
  const lookAt = queryFirstNode2(featureNode, "LookAt", namespaces2.kml);
  if (defined_default(lookAt)) {
    const lon = defaultValue_default(
      queryNumericValue2(lookAt, "longitude", namespaces2.kml),
      0
    );
    const lat = defaultValue_default(
      queryNumericValue2(lookAt, "latitude", namespaces2.kml),
      0
    );
    const altitude = defaultValue_default(
      queryNumericValue2(lookAt, "altitude", namespaces2.kml),
      0
    );
    let heading = queryNumericValue2(lookAt, "heading", namespaces2.kml);
    let tilt = queryNumericValue2(lookAt, "tilt", namespaces2.kml);
    const range2 = defaultValue_default(
      queryNumericValue2(lookAt, "range", namespaces2.kml),
      0
    );
    tilt = Math_default.toRadians(defaultValue_default(tilt, 0));
    heading = Math_default.toRadians(defaultValue_default(heading, 0));
    const hpr = new HeadingPitchRange_default(
      heading,
      tilt - Math_default.PI_OVER_TWO,
      range2
    );
    const viewPoint = Cartesian3_default.fromDegrees(lon, lat, altitude, ellipsoid);
    entity.kml.lookAt = new KmlLookAt_default(viewPoint, hpr);
  }
}
function processScreenOverlay(dataSource, screenOverlayNode, processingData, deferredLoading) {
  const screenOverlay = processingData.screenOverlayContainer;
  if (!defined_default(screenOverlay)) {
    return void 0;
  }
  const sourceResource = processingData.sourceResource;
  const uriResolver = processingData.uriResolver;
  const iconNode = queryFirstNode2(screenOverlayNode, "Icon", namespaces2.kml);
  const icon = getIconHref(
    iconNode,
    dataSource,
    sourceResource,
    uriResolver,
    false
  );
  if (!defined_default(icon)) {
    return void 0;
  }
  const img = document.createElement("img");
  dataSource._screenOverlays.push(img);
  img.src = icon.url;
  img.onload = function() {
    const styles = ["position: absolute"];
    const screenXY = queryFirstNode2(
      screenOverlayNode,
      "screenXY",
      namespaces2.kml
    );
    const overlayXY = queryFirstNode2(
      screenOverlayNode,
      "overlayXY",
      namespaces2.kml
    );
    const size = queryFirstNode2(screenOverlayNode, "size", namespaces2.kml);
    let x, y;
    let xUnit, yUnit;
    let xStyle, yStyle;
    if (defined_default(size)) {
      x = queryNumericAttribute2(size, "x");
      y = queryNumericAttribute2(size, "y");
      xUnit = queryStringAttribute2(size, "xunits");
      yUnit = queryStringAttribute2(size, "yunits");
      if (defined_default(x) && x !== -1 && x !== 0) {
        if (xUnit === "fraction") {
          xStyle = `width: ${Math.floor(x * 100)}%`;
        } else if (xUnit === "pixels") {
          xStyle = `width: ${x}px`;
        }
        styles.push(xStyle);
      }
      if (defined_default(y) && y !== -1 && y !== 0) {
        if (yUnit === "fraction") {
          yStyle = `height: ${Math.floor(y * 100)}%`;
        } else if (yUnit === "pixels") {
          yStyle = `height: ${y}px`;
        }
        styles.push(yStyle);
      }
    }
    img.style = styles.join(";");
    let xOrigin = 0;
    let yOrigin = img.height;
    if (defined_default(overlayXY)) {
      x = queryNumericAttribute2(overlayXY, "x");
      y = queryNumericAttribute2(overlayXY, "y");
      xUnit = queryStringAttribute2(overlayXY, "xunits");
      yUnit = queryStringAttribute2(overlayXY, "yunits");
      if (defined_default(x)) {
        if (xUnit === "fraction") {
          xOrigin = x * img.width;
        } else if (xUnit === "pixels") {
          xOrigin = x;
        } else if (xUnit === "insetPixels") {
          xOrigin = x;
        }
      }
      if (defined_default(y)) {
        if (yUnit === "fraction") {
          yOrigin = y * img.height;
        } else if (yUnit === "pixels") {
          yOrigin = y;
        } else if (yUnit === "insetPixels") {
          yOrigin = y;
        }
      }
    }
    if (defined_default(screenXY)) {
      x = queryNumericAttribute2(screenXY, "x");
      y = queryNumericAttribute2(screenXY, "y");
      xUnit = queryStringAttribute2(screenXY, "xunits");
      yUnit = queryStringAttribute2(screenXY, "yunits");
      if (defined_default(x)) {
        if (xUnit === "fraction") {
          xStyle = `${"left: calc("}${Math.floor(
            x * 100
          )}% - ${xOrigin}px)`;
        } else if (xUnit === "pixels") {
          xStyle = `left: ${x - xOrigin}px`;
        } else if (xUnit === "insetPixels") {
          xStyle = `right: ${x - xOrigin}px`;
        }
        styles.push(xStyle);
      }
      if (defined_default(y)) {
        if (yUnit === "fraction") {
          yStyle = `${"bottom: calc("}${Math.floor(
            y * 100
          )}% - ${yOrigin}px)`;
        } else if (yUnit === "pixels") {
          yStyle = `bottom: ${y - yOrigin}px`;
        } else if (yUnit === "insetPixels") {
          yStyle = `top: ${y - yOrigin}px`;
        }
        styles.push(yStyle);
      }
    }
    img.style = styles.join(";");
  };
  screenOverlay.appendChild(img);
}
function processGroundOverlay(dataSource, groundOverlay, processingData, deferredLoading) {
  const r2 = processFeature2(dataSource, groundOverlay, processingData);
  const entity = r2.entity;
  let geometry;
  let isLatLonQuad = false;
  const ellipsoid = dataSource._ellipsoid;
  const positions = readCoordinates(
    queryFirstNode2(groundOverlay, "LatLonQuad", namespaces2.gx),
    ellipsoid
  );
  const zIndex = queryNumericValue2(groundOverlay, "drawOrder", namespaces2.kml);
  if (defined_default(positions)) {
    geometry = createDefaultPolygon();
    geometry.hierarchy = new PolygonHierarchy_default(positions);
    geometry.zIndex = zIndex;
    entity.polygon = geometry;
    isLatLonQuad = true;
  } else {
    geometry = new RectangleGraphics_default();
    geometry.zIndex = zIndex;
    entity.rectangle = geometry;
    const latLonBox = queryFirstNode2(
      groundOverlay,
      "LatLonBox",
      namespaces2.kml
    );
    if (defined_default(latLonBox)) {
      let west = queryNumericValue2(latLonBox, "west", namespaces2.kml);
      let south = queryNumericValue2(latLonBox, "south", namespaces2.kml);
      let east = queryNumericValue2(latLonBox, "east", namespaces2.kml);
      let north = queryNumericValue2(latLonBox, "north", namespaces2.kml);
      if (defined_default(west)) {
        west = Math_default.negativePiToPi(Math_default.toRadians(west));
      }
      if (defined_default(south)) {
        south = Math_default.clampToLatitudeRange(Math_default.toRadians(south));
      }
      if (defined_default(east)) {
        east = Math_default.negativePiToPi(Math_default.toRadians(east));
      }
      if (defined_default(north)) {
        north = Math_default.clampToLatitudeRange(Math_default.toRadians(north));
      }
      geometry.coordinates = new Rectangle_default(west, south, east, north);
      const rotation = queryNumericValue2(latLonBox, "rotation", namespaces2.kml);
      if (defined_default(rotation)) {
        const rotationRadians = Math_default.toRadians(rotation);
        geometry.rotation = rotationRadians;
        geometry.stRotation = rotationRadians;
      }
    }
  }
  const iconNode = queryFirstNode2(groundOverlay, "Icon", namespaces2.kml);
  const href = getIconHref(
    iconNode,
    dataSource,
    processingData.sourceResource,
    processingData.uriResolver,
    true
  );
  if (defined_default(href)) {
    if (isLatLonQuad) {
      oneTimeWarning_default(
        "kml-gx:LatLonQuad",
        "KML - gx:LatLonQuad Icon does not support texture projection."
      );
    }
    const x = queryNumericValue2(iconNode, "x", namespaces2.gx);
    const y = queryNumericValue2(iconNode, "y", namespaces2.gx);
    const w = queryNumericValue2(iconNode, "w", namespaces2.gx);
    const h = queryNumericValue2(iconNode, "h", namespaces2.gx);
    if (defined_default(x) || defined_default(y) || defined_default(w) || defined_default(h)) {
      oneTimeWarning_default(
        "kml-groundOverlay-xywh",
        "KML - gx:x, gx:y, gx:w, gx:h aren't supported for GroundOverlays"
      );
    }
    geometry.material = href;
    geometry.material.color = queryColorValue(
      groundOverlay,
      "color",
      namespaces2.kml
    );
    geometry.material.transparent = true;
  } else {
    geometry.material = queryColorValue(groundOverlay, "color", namespaces2.kml);
  }
  let altitudeMode = queryStringValue2(
    groundOverlay,
    "altitudeMode",
    namespaces2.kml
  );
  if (defined_default(altitudeMode)) {
    if (altitudeMode === "absolute") {
      geometry.height = queryNumericValue2(
        groundOverlay,
        "altitude",
        namespaces2.kml
      );
      geometry.zIndex = void 0;
    } else if (altitudeMode !== "clampToGround") {
      oneTimeWarning_default(
        "kml-altitudeMode-unknown",
        `KML - Unknown altitudeMode: ${altitudeMode}`
      );
    }
  } else {
    altitudeMode = queryStringValue2(
      groundOverlay,
      "altitudeMode",
      namespaces2.gx
    );
    if (altitudeMode === "relativeToSeaFloor") {
      oneTimeWarning_default(
        "kml-altitudeMode-relativeToSeaFloor",
        "KML - altitudeMode relativeToSeaFloor is currently not supported, treating as absolute."
      );
      geometry.height = queryNumericValue2(
        groundOverlay,
        "altitude",
        namespaces2.kml
      );
      geometry.zIndex = void 0;
    } else if (altitudeMode === "clampToSeaFloor") {
      oneTimeWarning_default(
        "kml-altitudeMode-clampToSeaFloor",
        "KML - altitudeMode clampToSeaFloor is currently not supported, treating as clampToGround."
      );
    } else if (defined_default(altitudeMode)) {
      oneTimeWarning_default(
        "kml-altitudeMode-unknown",
        `KML - Unknown altitudeMode: ${altitudeMode}`
      );
    }
  }
}
function processUnsupportedFeature(dataSource, node, processingData, deferredLoading) {
  dataSource._unsupportedNode.raiseEvent(
    dataSource,
    processingData.parentEntity,
    node,
    processingData.entityCollection,
    processingData.styleCollection,
    processingData.sourceResource,
    processingData.uriResolver
  );
  oneTimeWarning_default(
    `kml-unsupportedFeature-${node.nodeName}`,
    `KML - Unsupported feature: ${node.nodeName}`
  );
}
var RefreshMode = {
  INTERVAL: 0,
  EXPIRE: 1,
  STOP: 2
};
function cleanupString(s2) {
  if (!defined_default(s2) || s2.length === 0) {
    return "";
  }
  const sFirst = s2[0];
  if (sFirst === "&" || sFirst === "?") {
    s2 = s2.substring(1);
  }
  return s2;
}
var zeroRectangle = new Rectangle_default();
var scratchCartographic11 = new Cartographic_default();
var scratchCartesian211 = new Cartesian2_default();
var scratchCartesian311 = new Cartesian3_default();
function processNetworkLinkQueryString(resource, camera, canvas, viewBoundScale, bbox2, ellipsoid) {
  function fixLatitude(value) {
    if (value < -Math_default.PI_OVER_TWO) {
      return -Math_default.PI_OVER_TWO;
    } else if (value > Math_default.PI_OVER_TWO) {
      return Math_default.PI_OVER_TWO;
    }
    return value;
  }
  function fixLongitude(value) {
    if (value > Math_default.PI) {
      return value - Math_default.TWO_PI;
    } else if (value < -Math_default.PI) {
      return value + Math_default.TWO_PI;
    }
    return value;
  }
  let queryString = objectToQuery_default(resource.queryParameters);
  queryString = queryString.replace(/%5B/g, "[").replace(/%5D/g, "]");
  if (defined_default(camera) && camera._mode !== SceneMode_default.MORPHING) {
    let centerCartesian2;
    let centerCartographic;
    bbox2 = defaultValue_default(bbox2, zeroRectangle);
    if (defined_default(canvas)) {
      scratchCartesian211.x = canvas.clientWidth * 0.5;
      scratchCartesian211.y = canvas.clientHeight * 0.5;
      centerCartesian2 = camera.pickEllipsoid(
        scratchCartesian211,
        ellipsoid,
        scratchCartesian311
      );
    }
    if (defined_default(centerCartesian2)) {
      centerCartographic = ellipsoid.cartesianToCartographic(
        centerCartesian2,
        scratchCartographic11
      );
    } else {
      centerCartographic = Rectangle_default.center(bbox2, scratchCartographic11);
      centerCartesian2 = ellipsoid.cartographicToCartesian(centerCartographic);
    }
    if (defined_default(viewBoundScale) && !Math_default.equalsEpsilon(viewBoundScale, 1, Math_default.EPSILON9)) {
      const newHalfWidth = bbox2.width * viewBoundScale * 0.5;
      const newHalfHeight = bbox2.height * viewBoundScale * 0.5;
      bbox2 = new Rectangle_default(
        fixLongitude(centerCartographic.longitude - newHalfWidth),
        fixLatitude(centerCartographic.latitude - newHalfHeight),
        fixLongitude(centerCartographic.longitude + newHalfWidth),
        fixLatitude(centerCartographic.latitude + newHalfHeight)
      );
    }
    queryString = queryString.replace(
      "[bboxWest]",
      Math_default.toDegrees(bbox2.west).toString()
    );
    queryString = queryString.replace(
      "[bboxSouth]",
      Math_default.toDegrees(bbox2.south).toString()
    );
    queryString = queryString.replace(
      "[bboxEast]",
      Math_default.toDegrees(bbox2.east).toString()
    );
    queryString = queryString.replace(
      "[bboxNorth]",
      Math_default.toDegrees(bbox2.north).toString()
    );
    const lon = Math_default.toDegrees(centerCartographic.longitude).toString();
    const lat = Math_default.toDegrees(centerCartographic.latitude).toString();
    queryString = queryString.replace("[lookatLon]", lon);
    queryString = queryString.replace("[lookatLat]", lat);
    queryString = queryString.replace(
      "[lookatTilt]",
      Math_default.toDegrees(camera.pitch).toString()
    );
    queryString = queryString.replace(
      "[lookatHeading]",
      Math_default.toDegrees(camera.heading).toString()
    );
    queryString = queryString.replace(
      "[lookatRange]",
      Cartesian3_default.distance(camera.positionWC, centerCartesian2)
    );
    queryString = queryString.replace("[lookatTerrainLon]", lon);
    queryString = queryString.replace("[lookatTerrainLat]", lat);
    queryString = queryString.replace(
      "[lookatTerrainAlt]",
      centerCartographic.height.toString()
    );
    ellipsoid.cartesianToCartographic(camera.positionWC, scratchCartographic11);
    queryString = queryString.replace(
      "[cameraLon]",
      Math_default.toDegrees(scratchCartographic11.longitude).toString()
    );
    queryString = queryString.replace(
      "[cameraLat]",
      Math_default.toDegrees(scratchCartographic11.latitude).toString()
    );
    queryString = queryString.replace(
      "[cameraAlt]",
      Math_default.toDegrees(scratchCartographic11.height).toString()
    );
    const frustum = camera.frustum;
    const aspectRatio = frustum.aspectRatio;
    let horizFov = "";
    let vertFov = "";
    if (defined_default(aspectRatio)) {
      const fov = Math_default.toDegrees(frustum.fov);
      if (aspectRatio > 1) {
        horizFov = fov;
        vertFov = fov / aspectRatio;
      } else {
        vertFov = fov;
        horizFov = fov * aspectRatio;
      }
    }
    queryString = queryString.replace("[horizFov]", horizFov.toString());
    queryString = queryString.replace("[vertFov]", vertFov.toString());
  } else {
    queryString = queryString.replace("[bboxWest]", "-180");
    queryString = queryString.replace("[bboxSouth]", "-90");
    queryString = queryString.replace("[bboxEast]", "180");
    queryString = queryString.replace("[bboxNorth]", "90");
    queryString = queryString.replace("[lookatLon]", "");
    queryString = queryString.replace("[lookatLat]", "");
    queryString = queryString.replace("[lookatRange]", "");
    queryString = queryString.replace("[lookatTilt]", "");
    queryString = queryString.replace("[lookatHeading]", "");
    queryString = queryString.replace("[lookatTerrainLon]", "");
    queryString = queryString.replace("[lookatTerrainLat]", "");
    queryString = queryString.replace("[lookatTerrainAlt]", "");
    queryString = queryString.replace("[cameraLon]", "");
    queryString = queryString.replace("[cameraLat]", "");
    queryString = queryString.replace("[cameraAlt]", "");
    queryString = queryString.replace("[horizFov]", "");
    queryString = queryString.replace("[vertFov]", "");
  }
  if (defined_default(canvas)) {
    queryString = queryString.replace("[horizPixels]", canvas.clientWidth);
    queryString = queryString.replace("[vertPixels]", canvas.clientHeight);
  } else {
    queryString = queryString.replace("[horizPixels]", "");
    queryString = queryString.replace("[vertPixels]", "");
  }
  queryString = queryString.replace("[terrainEnabled]", "1");
  queryString = queryString.replace("[clientVersion]", "1");
  queryString = queryString.replace("[kmlVersion]", "2.2");
  queryString = queryString.replace("[clientName]", "Cesium");
  queryString = queryString.replace("[language]", "English");
  resource.setQueryParameters(queryToObject_default(queryString));
}
function processNetworkLink(dataSource, node, processingData, deferredLoading) {
  const r2 = processFeature2(dataSource, node, processingData);
  const networkEntity = r2.entity;
  const sourceResource = processingData.sourceResource;
  const uriResolver = processingData.uriResolver;
  let link = queryFirstNode2(node, "Link", namespaces2.kml);
  if (!defined_default(link)) {
    link = queryFirstNode2(node, "Url", namespaces2.kml);
  }
  if (defined_default(link)) {
    let href = queryStringValue2(link, "href", namespaces2.kml);
    let viewRefreshMode;
    let viewBoundScale;
    if (defined_default(href)) {
      let newSourceUri = href;
      href = resolveHref(href, sourceResource, processingData.uriResolver);
      if (/^data:/.test(href.getUrlComponent())) {
        if (!/\.kmz/i.test(sourceResource.getUrlComponent())) {
          newSourceUri = sourceResource.getDerivedResource({
            url: newSourceUri
          });
        }
      } else {
        newSourceUri = href.clone();
        viewRefreshMode = queryStringValue2(
          link,
          "viewRefreshMode",
          namespaces2.kml
        );
        viewBoundScale = defaultValue_default(
          queryStringValue2(link, "viewBoundScale", namespaces2.kml),
          1
        );
        const defaultViewFormat = viewRefreshMode === "onStop" ? "BBOX=[bboxWest],[bboxSouth],[bboxEast],[bboxNorth]" : "";
        const viewFormat = defaultValue_default(
          queryStringValue2(link, "viewFormat", namespaces2.kml),
          defaultViewFormat
        );
        const httpQuery = queryStringValue2(link, "httpQuery", namespaces2.kml);
        if (defined_default(viewFormat)) {
          href.setQueryParameters(queryToObject_default(cleanupString(viewFormat)));
        }
        if (defined_default(httpQuery)) {
          href.setQueryParameters(queryToObject_default(cleanupString(httpQuery)));
        }
        const ellipsoid = dataSource._ellipsoid;
        processNetworkLinkQueryString(
          href,
          dataSource.camera,
          dataSource.canvas,
          viewBoundScale,
          dataSource._lastCameraView.bbox,
          ellipsoid
        );
      }
      const options = {
        sourceUri: newSourceUri,
        uriResolver,
        context: networkEntity.id,
        screenOverlayContainer: processingData.screenOverlayContainer
      };
      const networkLinkCollection = new EntityCollection_default();
      const promise = load4(dataSource, networkLinkCollection, href, options).then(function(rootElement) {
        const entities = dataSource._entityCollection;
        const newEntities = networkLinkCollection.values;
        entities.suspendEvents();
        for (let i2 = 0; i2 < newEntities.length; i2++) {
          const newEntity = newEntities[i2];
          if (!defined_default(newEntity.parent)) {
            newEntity.parent = networkEntity;
            mergeAvailabilityWithParent(newEntity);
          }
          entities.add(newEntity);
        }
        entities.resumeEvents();
        const refreshMode = queryStringValue2(
          link,
          "refreshMode",
          namespaces2.kml
        );
        let refreshInterval = defaultValue_default(
          queryNumericValue2(link, "refreshInterval", namespaces2.kml),
          0
        );
        if (refreshMode === "onInterval" && refreshInterval > 0 || refreshMode === "onExpire" || viewRefreshMode === "onStop") {
          const networkLinkControl = queryFirstNode2(
            rootElement,
            "NetworkLinkControl",
            namespaces2.kml
          );
          const hasNetworkLinkControl = defined_default(networkLinkControl);
          const now = JulianDate_default.now();
          const networkLinkInfo = {
            id: createGuid_default(),
            href,
            cookie: {},
            lastUpdated: now,
            updating: false,
            entity: networkEntity,
            viewBoundScale,
            needsUpdate: false,
            cameraUpdateTime: now
          };
          let minRefreshPeriod = 0;
          if (hasNetworkLinkControl) {
            networkLinkInfo.cookie = queryToObject_default(
              defaultValue_default(
                queryStringValue2(
                  networkLinkControl,
                  "cookie",
                  namespaces2.kml
                ),
                ""
              )
            );
            minRefreshPeriod = defaultValue_default(
              queryNumericValue2(
                networkLinkControl,
                "minRefreshPeriod",
                namespaces2.kml
              ),
              0
            );
          }
          if (refreshMode === "onInterval") {
            if (hasNetworkLinkControl) {
              refreshInterval = Math.max(minRefreshPeriod, refreshInterval);
            }
            networkLinkInfo.refreshMode = RefreshMode.INTERVAL;
            networkLinkInfo.time = refreshInterval;
          } else if (refreshMode === "onExpire") {
            let expires;
            if (hasNetworkLinkControl) {
              expires = queryStringValue2(
                networkLinkControl,
                "expires",
                namespaces2.kml
              );
            }
            if (defined_default(expires)) {
              try {
                const date = JulianDate_default.fromIso8601(expires);
                const diff = JulianDate_default.secondsDifference(date, now);
                if (diff > 0 && diff < minRefreshPeriod) {
                  JulianDate_default.addSeconds(now, minRefreshPeriod, date);
                }
                networkLinkInfo.refreshMode = RefreshMode.EXPIRE;
                networkLinkInfo.time = date;
              } catch (e2) {
                oneTimeWarning_default(
                  "kml-refreshMode-onInterval-onExpire",
                  "KML - NetworkLinkControl expires is not a valid date"
                );
              }
            } else {
              oneTimeWarning_default(
                "kml-refreshMode-onExpire",
                "KML - refreshMode of onExpire requires the NetworkLinkControl to have an expires element"
              );
            }
          } else if (defined_default(dataSource.camera)) {
            networkLinkInfo.refreshMode = RefreshMode.STOP;
            networkLinkInfo.time = defaultValue_default(
              queryNumericValue2(link, "viewRefreshTime", namespaces2.kml),
              0
            );
          } else {
            oneTimeWarning_default(
              "kml-refrehMode-onStop-noCamera",
              "A NetworkLink with viewRefreshMode=onStop requires the `camera` property to be defined."
            );
          }
          if (defined_default(networkLinkInfo.refreshMode)) {
            dataSource._networkLinks.set(networkLinkInfo.id, networkLinkInfo);
          }
        } else if (viewRefreshMode === "onRegion") {
          oneTimeWarning_default(
            "kml-refrehMode-onRegion",
            "KML - Unsupported viewRefreshMode: onRegion"
          );
        }
      }).catch(function(error) {
        oneTimeWarning_default(`An error occured during loading ${href.url}`);
        dataSource._error.raiseEvent(dataSource, error);
      });
      deferredLoading.addPromise(promise);
    }
  }
}
function processFeatureNode(dataSource, node, processingData, deferredLoading) {
  const featureProcessor = featureTypes[node.localName];
  if (defined_default(featureProcessor)) {
    return featureProcessor(dataSource, node, processingData, deferredLoading);
  }
  return processUnsupportedFeature(
    dataSource,
    node,
    processingData,
    deferredLoading
  );
}
function loadKml(dataSource, entityCollection, kml, sourceResource, uriResolver, screenOverlayContainer, context) {
  entityCollection.removeAll();
  const documentElement = kml.documentElement;
  const document2 = documentElement.localName === "Document" ? documentElement : queryFirstNode2(documentElement, "Document", namespaces2.kml);
  let name = queryStringValue2(document2, "name", namespaces2.kml);
  if (!defined_default(name)) {
    name = getFilenameFromUri_default(sourceResource.getUrlComponent());
  }
  if (!defined_default(dataSource._name)) {
    dataSource._name = name;
  }
  const deferredLoading = new KmlDataSource._DeferredLoading(dataSource);
  const styleCollection = new EntityCollection_default(dataSource);
  return Promise.all(
    processStyles(
      dataSource,
      kml,
      styleCollection,
      sourceResource,
      false,
      uriResolver
    )
  ).then(function() {
    let element = kml.documentElement;
    if (element.localName === "kml") {
      const childNodes = element.childNodes;
      for (let i2 = 0; i2 < childNodes.length; i2++) {
        const tmp2 = childNodes[i2];
        if (defined_default(featureTypes[tmp2.localName])) {
          element = tmp2;
          break;
        }
      }
    }
    const processingData = {
      parentEntity: void 0,
      entityCollection,
      styleCollection,
      sourceResource,
      uriResolver,
      context,
      screenOverlayContainer
    };
    entityCollection.suspendEvents();
    processFeatureNode(dataSource, element, processingData, deferredLoading);
    entityCollection.resumeEvents();
    return deferredLoading.wait().then(function() {
      return kml.documentElement;
    });
  });
}
function loadKmz(dataSource, entityCollection, blob, sourceResource, screenOverlayContainer) {
  const zWorkerUrl = buildModuleUrl_default("ThirdParty/Workers/z-worker-pako.js");
  zipNoWorker.configure({
    workerScripts: {
      deflate: [zWorkerUrl, "./pako_deflate.min.js"],
      inflate: [zWorkerUrl, "./pako_inflate.min.js"]
    }
  });
  const reader = new zipNoWorker.ZipReader(new zipNoWorker.BlobReader(blob));
  return Promise.resolve(reader.getEntries()).then(function(entries) {
    const promises = [];
    const uriResolver = {};
    let docEntry;
    for (let i2 = 0; i2 < entries.length; i2++) {
      const entry = entries[i2];
      if (!entry.directory) {
        if (/\.kml$/i.test(entry.filename)) {
          if (!defined_default(docEntry) || !/\//i.test(entry.filename)) {
            if (defined_default(docEntry)) {
              promises.push(loadDataUriFromZip(docEntry, uriResolver));
            }
            docEntry = entry;
          } else {
            promises.push(loadDataUriFromZip(entry, uriResolver));
          }
        } else {
          promises.push(loadDataUriFromZip(entry, uriResolver));
        }
      }
    }
    if (defined_default(docEntry)) {
      promises.push(loadXmlFromZip(docEntry, uriResolver));
    }
    return Promise.all(promises).then(function() {
      reader.close();
      if (!defined_default(uriResolver.kml)) {
        throw new RuntimeError_default("KMZ file does not contain a KML document.");
      }
      uriResolver.keys = Object.keys(uriResolver);
      return loadKml(
        dataSource,
        entityCollection,
        uriResolver.kml,
        sourceResource,
        uriResolver,
        screenOverlayContainer
      );
    });
  });
}
function load4(dataSource, entityCollection, data, options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let sourceUri = options.sourceUri;
  const uriResolver = options.uriResolver;
  const context = options.context;
  let screenOverlayContainer = options.screenOverlayContainer;
  let promise = data;
  if (typeof data === "string" || data instanceof Resource_default) {
    data = Resource_default.createIfNeeded(data);
    promise = data.fetchBlob();
    sourceUri = defaultValue_default(sourceUri, data.clone());
    const resourceCredits = dataSource._resourceCredits;
    const credits = data.credits;
    if (defined_default(credits)) {
      const length3 = credits.length;
      for (let i2 = 0; i2 < length3; i2++) {
        resourceCredits.push(credits[i2]);
      }
    }
  } else {
    sourceUri = defaultValue_default(sourceUri, Resource_default.DEFAULT.clone());
  }
  sourceUri = Resource_default.createIfNeeded(sourceUri);
  if (defined_default(screenOverlayContainer)) {
    screenOverlayContainer = getElement_default(screenOverlayContainer);
  }
  return Promise.resolve(promise).then(function(dataToLoad) {
    if (dataToLoad instanceof Blob) {
      return isZipFile(dataToLoad).then(function(isZip) {
        if (isZip) {
          return loadKmz(
            dataSource,
            entityCollection,
            dataToLoad,
            sourceUri,
            screenOverlayContainer
          );
        }
        return readBlobAsText2(dataToLoad).then(function(text2) {
          text2 = insertNamespaces(text2);
          text2 = removeDuplicateNamespaces(text2);
          let kml;
          let error;
          try {
            kml = parser2.parseFromString(text2, "application/xml");
          } catch (e2) {
            error = e2.toString();
          }
          if (defined_default(error) || kml.body || kml.documentElement.tagName === "parsererror") {
            let msg = defined_default(error) ? error : kml.documentElement.firstChild.nodeValue;
            if (!msg) {
              msg = kml.body.innerText;
            }
            throw new RuntimeError_default(msg);
          }
          return loadKml(
            dataSource,
            entityCollection,
            kml,
            sourceUri,
            uriResolver,
            screenOverlayContainer,
            context
          );
        });
      });
    }
    return loadKml(
      dataSource,
      entityCollection,
      dataToLoad,
      sourceUri,
      uriResolver,
      screenOverlayContainer,
      context
    );
  }).catch(function(error) {
    dataSource._error.raiseEvent(dataSource, error);
    console.log(error);
    return Promise.reject(error);
  });
}
function KmlDataSource(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const camera = options.camera;
  const canvas = options.canvas;
  this._changed = new Event_default();
  this._error = new Event_default();
  this._loading = new Event_default();
  this._refresh = new Event_default();
  this._unsupportedNode = new Event_default();
  this._clock = void 0;
  this._entityCollection = new EntityCollection_default(this);
  this._name = void 0;
  this._isLoading = false;
  this._pinBuilder = new PinBuilder_default();
  this._networkLinks = new AssociativeArray_default();
  this._entityCluster = new EntityCluster_default();
  this.canvas = canvas;
  this.camera = camera;
  this._lastCameraView = {
    position: defined_default(camera) ? Cartesian3_default.clone(camera.positionWC) : void 0,
    direction: defined_default(camera) ? Cartesian3_default.clone(camera.directionWC) : void 0,
    up: defined_default(camera) ? Cartesian3_default.clone(camera.upWC) : void 0,
    bbox: defined_default(camera) ? camera.computeViewRectangle() : Rectangle_default.clone(Rectangle_default.MAX_VALUE)
  };
  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  this._credit = credit;
  this._resourceCredits = [];
  this._kmlTours = [];
  this._screenOverlays = [];
}
KmlDataSource.load = function(data, options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const dataSource = new KmlDataSource(options);
  return dataSource.load(data, options);
};
Object.defineProperties(KmlDataSource.prototype, {
  name: {
    get: function() {
      return this._name;
    },
    set: function(value) {
      if (this._name !== value) {
        this._name = value;
        this._changed.raiseEvent(this);
      }
    }
  },
  clock: {
    get: function() {
      return this._clock;
    }
  },
  entities: {
    get: function() {
      return this._entityCollection;
    }
  },
  isLoading: {
    get: function() {
      return this._isLoading;
    }
  },
  changedEvent: {
    get: function() {
      return this._changed;
    }
  },
  errorEvent: {
    get: function() {
      return this._error;
    }
  },
  loadingEvent: {
    get: function() {
      return this._loading;
    }
  },
  refreshEvent: {
    get: function() {
      return this._refresh;
    }
  },
  unsupportedNodeEvent: {
    get: function() {
      return this._unsupportedNode;
    }
  },
  show: {
    get: function() {
      return this._entityCollection.show;
    },
    set: function(value) {
      this._entityCollection.show = value;
    }
  },
  clustering: {
    get: function() {
      return this._entityCluster;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value must be defined.");
      }
      this._entityCluster = value;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  kmlTours: {
    get: function() {
      return this._kmlTours;
    }
  }
});
KmlDataSource.prototype.load = function(data, options) {
  if (!defined_default(data)) {
    throw new DeveloperError_default("data is required.");
  }
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  DataSource_default.setLoading(this, true);
  const oldName = this._name;
  this._name = void 0;
  this._clampToGround = defaultValue_default(options.clampToGround, false);
  const that = this;
  return load4(this, this._entityCollection, data, options).then(function() {
    let clock;
    const availability = that._entityCollection.computeAvailability();
    let start = availability.start;
    let stop2 = availability.stop;
    const isMinStart = JulianDate_default.equals(start, Iso8601_default.MINIMUM_VALUE);
    const isMaxStop = JulianDate_default.equals(stop2, Iso8601_default.MAXIMUM_VALUE);
    if (!isMinStart || !isMaxStop) {
      let date;
      if (isMinStart) {
        date = new Date();
        date.setHours(0, 0, 0, 0);
        start = JulianDate_default.fromDate(date);
      }
      if (isMaxStop) {
        date = new Date();
        date.setHours(24, 0, 0, 0);
        stop2 = JulianDate_default.fromDate(date);
      }
      clock = new DataSourceClock_default();
      clock.startTime = start;
      clock.stopTime = stop2;
      clock.currentTime = JulianDate_default.clone(start);
      clock.clockRange = ClockRange_default.LOOP_STOP;
      clock.clockStep = ClockStep_default.SYSTEM_CLOCK_MULTIPLIER;
      clock.multiplier = Math.round(
        Math.min(
          Math.max(JulianDate_default.secondsDifference(stop2, start) / 60, 1),
          31556900
        )
      );
    }
    let changed = false;
    if (clock !== that._clock) {
      that._clock = clock;
      changed = true;
    }
    if (oldName !== that._name) {
      changed = true;
    }
    if (changed) {
      that._changed.raiseEvent(that);
    }
    DataSource_default.setLoading(that, false);
    return that;
  }).catch(function(error) {
    DataSource_default.setLoading(that, false);
    that._error.raiseEvent(that, error);
    console.log(error);
    return Promise.reject(error);
  });
};
KmlDataSource.prototype.destroy = function() {
  while (this._screenOverlays.length > 0) {
    const elem = this._screenOverlays.pop();
    elem.remove();
  }
};
function mergeAvailabilityWithParent(child) {
  const parent = child.parent;
  if (defined_default(parent)) {
    const parentAvailability = parent.availability;
    if (defined_default(parentAvailability)) {
      const childAvailability = child.availability;
      if (defined_default(childAvailability)) {
        childAvailability.intersect(parentAvailability);
      } else {
        child.availability = parentAvailability;
      }
    }
  }
}
function getNetworkLinkUpdateCallback(dataSource, networkLink, newEntityCollection, networkLinks, processedHref) {
  return function(rootElement) {
    if (!networkLinks.contains(networkLink.id)) {
      return;
    }
    let remove4 = false;
    const networkLinkControl = queryFirstNode2(
      rootElement,
      "NetworkLinkControl",
      namespaces2.kml
    );
    const hasNetworkLinkControl = defined_default(networkLinkControl);
    let minRefreshPeriod = 0;
    if (hasNetworkLinkControl) {
      if (defined_default(queryFirstNode2(networkLinkControl, "Update", namespaces2.kml))) {
        oneTimeWarning_default(
          "kml-networkLinkControl-update",
          "KML - NetworkLinkControl updates aren't supported."
        );
        networkLink.updating = false;
        networkLinks.remove(networkLink.id);
        return;
      }
      networkLink.cookie = queryToObject_default(
        defaultValue_default(
          queryStringValue2(networkLinkControl, "cookie", namespaces2.kml),
          ""
        )
      );
      minRefreshPeriod = defaultValue_default(
        queryNumericValue2(
          networkLinkControl,
          "minRefreshPeriod",
          namespaces2.kml
        ),
        0
      );
    }
    const now = JulianDate_default.now();
    const refreshMode = networkLink.refreshMode;
    if (refreshMode === RefreshMode.INTERVAL) {
      if (defined_default(networkLinkControl)) {
        networkLink.time = Math.max(minRefreshPeriod, networkLink.time);
      }
    } else if (refreshMode === RefreshMode.EXPIRE) {
      let expires;
      if (defined_default(networkLinkControl)) {
        expires = queryStringValue2(
          networkLinkControl,
          "expires",
          namespaces2.kml
        );
      }
      if (defined_default(expires)) {
        try {
          const date = JulianDate_default.fromIso8601(expires);
          const diff = JulianDate_default.secondsDifference(date, now);
          if (diff > 0 && diff < minRefreshPeriod) {
            JulianDate_default.addSeconds(now, minRefreshPeriod, date);
          }
          networkLink.time = date;
        } catch (e2) {
          oneTimeWarning_default(
            "kml-networkLinkControl-expires",
            "KML - NetworkLinkControl expires is not a valid date"
          );
          remove4 = true;
        }
      } else {
        oneTimeWarning_default(
          "kml-refreshMode-onExpire",
          "KML - refreshMode of onExpire requires the NetworkLinkControl to have an expires element"
        );
        remove4 = true;
      }
    }
    const networkLinkEntity = networkLink.entity;
    const entityCollection = dataSource._entityCollection;
    const newEntities = newEntityCollection.values;
    function removeChildren(entity) {
      entityCollection.remove(entity);
      const children = entity._children;
      const count = children.length;
      for (let i3 = 0; i3 < count; ++i3) {
        removeChildren(children[i3]);
      }
    }
    entityCollection.suspendEvents();
    const entitiesCopy = entityCollection.values.slice();
    let i2;
    for (i2 = 0; i2 < entitiesCopy.length; ++i2) {
      const entityToRemove = entitiesCopy[i2];
      if (entityToRemove.parent === networkLinkEntity) {
        entityToRemove.parent = void 0;
        removeChildren(entityToRemove);
      }
    }
    entityCollection.resumeEvents();
    entityCollection.suspendEvents();
    for (i2 = 0; i2 < newEntities.length; i2++) {
      const newEntity = newEntities[i2];
      if (!defined_default(newEntity.parent)) {
        newEntity.parent = networkLinkEntity;
        mergeAvailabilityWithParent(newEntity);
      }
      entityCollection.add(newEntity);
    }
    entityCollection.resumeEvents();
    if (remove4) {
      networkLinks.remove(networkLink.id);
    } else {
      networkLink.lastUpdated = now;
    }
    const availability = entityCollection.computeAvailability();
    const start = availability.start;
    const stop2 = availability.stop;
    const isMinStart = JulianDate_default.equals(start, Iso8601_default.MINIMUM_VALUE);
    const isMaxStop = JulianDate_default.equals(stop2, Iso8601_default.MAXIMUM_VALUE);
    if (!isMinStart || !isMaxStop) {
      const clock = dataSource._clock;
      if (clock.startTime !== start || clock.stopTime !== stop2) {
        clock.startTime = start;
        clock.stopTime = stop2;
        dataSource._changed.raiseEvent(dataSource);
      }
    }
    networkLink.updating = false;
    networkLink.needsUpdate = false;
    dataSource._refresh.raiseEvent(
      dataSource,
      processedHref.getUrlComponent(true)
    );
  };
}
var entitiesToIgnore = new AssociativeArray_default();
KmlDataSource.prototype.update = function(time) {
  const networkLinks = this._networkLinks;
  if (networkLinks.length === 0) {
    return true;
  }
  const now = JulianDate_default.now();
  const that = this;
  entitiesToIgnore.removeAll();
  function recurseIgnoreEntities(entity) {
    const children = entity._children;
    const count = children.length;
    for (let i2 = 0; i2 < count; ++i2) {
      const child = children[i2];
      entitiesToIgnore.set(child.id, child);
      recurseIgnoreEntities(child);
    }
  }
  let cameraViewUpdate = false;
  const lastCameraView = this._lastCameraView;
  const camera = this.camera;
  if (defined_default(camera) && !(camera.positionWC.equalsEpsilon(
    lastCameraView.position,
    Math_default.EPSILON7
  ) && camera.directionWC.equalsEpsilon(
    lastCameraView.direction,
    Math_default.EPSILON7
  ) && camera.upWC.equalsEpsilon(lastCameraView.up, Math_default.EPSILON7))) {
    lastCameraView.position = Cartesian3_default.clone(camera.positionWC);
    lastCameraView.direction = Cartesian3_default.clone(camera.directionWC);
    lastCameraView.up = Cartesian3_default.clone(camera.upWC);
    lastCameraView.bbox = camera.computeViewRectangle();
    cameraViewUpdate = true;
  }
  const newNetworkLinks = new AssociativeArray_default();
  let changed = false;
  networkLinks.values.forEach(function(networkLink) {
    const entity = networkLink.entity;
    if (entitiesToIgnore.contains(entity.id)) {
      return;
    }
    if (!networkLink.updating) {
      let doUpdate = false;
      if (networkLink.refreshMode === RefreshMode.INTERVAL) {
        if (JulianDate_default.secondsDifference(now, networkLink.lastUpdated) > networkLink.time) {
          doUpdate = true;
        }
      } else if (networkLink.refreshMode === RefreshMode.EXPIRE) {
        if (JulianDate_default.greaterThan(now, networkLink.time)) {
          doUpdate = true;
        }
      } else if (networkLink.refreshMode === RefreshMode.STOP) {
        if (cameraViewUpdate) {
          networkLink.needsUpdate = true;
          networkLink.cameraUpdateTime = now;
        }
        if (networkLink.needsUpdate && JulianDate_default.secondsDifference(now, networkLink.cameraUpdateTime) >= networkLink.time) {
          doUpdate = true;
        }
      }
      if (doUpdate) {
        recurseIgnoreEntities(entity);
        networkLink.updating = true;
        const newEntityCollection = new EntityCollection_default();
        const href = networkLink.href.clone();
        href.setQueryParameters(networkLink.cookie);
        const ellipsoid = defaultValue_default(that._ellipsoid, Ellipsoid_default.WGS84);
        processNetworkLinkQueryString(
          href,
          that.camera,
          that.canvas,
          networkLink.viewBoundScale,
          lastCameraView.bbox,
          ellipsoid
        );
        load4(that, newEntityCollection, href, {
          context: entity.id
        }).then(
          getNetworkLinkUpdateCallback(
            that,
            networkLink,
            newEntityCollection,
            newNetworkLinks,
            href
          )
        ).catch(function(error) {
          const msg = `NetworkLink ${networkLink.href} refresh failed: ${error}`;
          console.log(msg);
          that._error.raiseEvent(that, msg);
        });
        changed = true;
      }
    }
    newNetworkLinks.set(networkLink.id, networkLink);
  });
  if (changed) {
    this._networkLinks = newNetworkLinks;
    this._changed.raiseEvent(this);
  }
  return true;
};
function KmlFeatureData() {
  this.author = {
    name: void 0,
    uri: void 0,
    email: void 0
  };
  this.link = {
    href: void 0,
    hreflang: void 0,
    rel: void 0,
    type: void 0,
    title: void 0,
    length: void 0
  };
  this.address = void 0;
  this.phoneNumber = void 0;
  this.snippet = void 0;
  this.extendedData = void 0;
}
KmlDataSource._DeferredLoading = DeferredLoading;
KmlDataSource._getTimestamp = getTimestamp_default;
var KmlDataSource_default = KmlDataSource;

// node_modules/cesium/Source/DataSources/Visualizer.js
function Visualizer() {
  DeveloperError_default.throwInstantiationError();
}
Visualizer.prototype.update = DeveloperError_default.throwInstantiationError;
Visualizer.prototype.getBoundingSphere = DeveloperError_default.throwInstantiationError;
Visualizer.prototype.isDestroyed = DeveloperError_default.throwInstantiationError;
Visualizer.prototype.destroy = DeveloperError_default.throwInstantiationError;
var Visualizer_default = Visualizer;

// node_modules/cesium/Source/DataSources/exportKml.js
var BILLBOARD_SIZE3 = 32;
var kmlNamespace = "http://www.opengis.net/kml/2.2";
var gxNamespace = "http://www.google.com/kml/ext/2.2";
var xmlnsNamespace = "http://www.w3.org/2000/xmlns/";
function ExternalFileHandler(modelCallback) {
  this._files = {};
  this._promises = [];
  this._count = 0;
  this._modelCallback = modelCallback;
}
var imageTypeRegex = /^data:image\/([^,;]+)/;
ExternalFileHandler.prototype.texture = function(texture) {
  const that = this;
  let filename;
  if (typeof texture === "string" || texture instanceof Resource_default) {
    texture = Resource_default.createIfNeeded(texture);
    if (!texture.isDataUri) {
      return texture.url;
    }
    const regexResult = texture.url.match(imageTypeRegex);
    filename = `texture_${++this._count}`;
    if (defined_default(regexResult)) {
      filename += `.${regexResult[1]}`;
    }
    const promise = texture.fetchBlob().then(function(blob) {
      that._files[filename] = blob;
    });
    this._promises.push(promise);
    return filename;
  }
  if (texture instanceof HTMLCanvasElement) {
    const deferred = defer_default();
    this._promises.push(deferred.promise);
    filename = `texture_${++this._count}.png`;
    texture.toBlob(function(blob) {
      that._files[filename] = blob;
      deferred.resolve();
    });
    return filename;
  }
  return "";
};
function getModelBlobHander(that, filename) {
  return function(blob) {
    that._files[filename] = blob;
  };
}
ExternalFileHandler.prototype.model = function(model, time) {
  const modelCallback = this._modelCallback;
  if (!defined_default(modelCallback)) {
    throw new RuntimeError_default(
      "Encountered a model entity while exporting to KML, but no model callback was supplied."
    );
  }
  const externalFiles = {};
  const url2 = modelCallback(model, time, externalFiles);
  for (const filename in externalFiles) {
    if (externalFiles.hasOwnProperty(filename)) {
      const promise = Promise.resolve(externalFiles[filename]);
      this._promises.push(promise);
      promise.then(getModelBlobHander(this, filename));
    }
  }
  return url2;
};
Object.defineProperties(ExternalFileHandler.prototype, {
  promise: {
    get: function() {
      return Promise.all(this._promises);
    }
  },
  files: {
    get: function() {
      return this._files;
    }
  }
});
function ValueGetter(time) {
  this._time = time;
}
ValueGetter.prototype.get = function(property, defaultVal, result) {
  let value;
  if (defined_default(property)) {
    value = defined_default(property.getValue) ? property.getValue(this._time, result) : property;
  }
  return defaultValue_default(value, defaultVal);
};
ValueGetter.prototype.getColor = function(property, defaultVal) {
  const result = this.get(property, defaultVal);
  if (defined_default(result)) {
    return colorToString(result);
  }
};
ValueGetter.prototype.getMaterialType = function(property) {
  if (!defined_default(property)) {
    return;
  }
  return property.getType(this._time);
};
function StyleCache() {
  this._ids = {};
  this._styles = {};
  this._count = 0;
}
StyleCache.prototype.get = function(element) {
  const ids = this._ids;
  const key = element.innerHTML;
  if (defined_default(ids[key])) {
    return ids[key];
  }
  let styleId = `style-${++this._count}`;
  element.setAttribute("id", styleId);
  styleId = `#${styleId}`;
  ids[key] = styleId;
  this._styles[key] = element;
  return styleId;
};
StyleCache.prototype.save = function(parentElement) {
  const styles = this._styles;
  const firstElement = parentElement.childNodes[0];
  for (const key in styles) {
    if (styles.hasOwnProperty(key)) {
      parentElement.insertBefore(styles[key], firstElement);
    }
  }
};
function IdManager() {
  this._ids = {};
}
IdManager.prototype.get = function(id) {
  if (!defined_default(id)) {
    return this.get(createGuid_default());
  }
  const ids = this._ids;
  if (!defined_default(ids[id])) {
    ids[id] = 0;
    return id;
  }
  return `${id.toString()}-${++ids[id]}`;
};
function exportKml(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const entities = options.entities;
  const kmz = defaultValue_default(options.kmz, false);
  if (!defined_default(entities)) {
    throw new DeveloperError_default("entities is required.");
  }
  const state = exportKml._createState(options);
  const rootEntities = entities.values.filter(function(entity) {
    return !defined_default(entity.parent);
  });
  const kmlDoc = state.kmlDoc;
  const kmlElement = kmlDoc.documentElement;
  kmlElement.setAttributeNS(xmlnsNamespace, "xmlns:gx", gxNamespace);
  const kmlDocumentElement = kmlDoc.createElement("Document");
  kmlElement.appendChild(kmlDocumentElement);
  recurseEntities(state, kmlDocumentElement, rootEntities);
  state.styleCache.save(kmlDocumentElement);
  const externalFileHandler = state.externalFileHandler;
  return externalFileHandler.promise.then(function() {
    const serializer = new XMLSerializer();
    const kmlString = serializer.serializeToString(state.kmlDoc);
    if (kmz) {
      return createKmz(kmlString, externalFileHandler.files);
    }
    return {
      kml: kmlString,
      externalFiles: externalFileHandler.files
    };
  });
}
function createKmz(kmlString, externalFiles) {
  const zWorkerUrl = buildModuleUrl_default("ThirdParty/Workers/z-worker-pako.js");
  zipNoWorker.configure({
    workerScripts: {
      deflate: [zWorkerUrl, "./pako_deflate.min.js"],
      inflate: [zWorkerUrl, "./pako_inflate.min.js"]
    }
  });
  const blobWriter = new zipNoWorker.BlobWriter();
  const writer = new zipNoWorker.ZipWriter(blobWriter);
  return writer.add("doc.kml", new zipNoWorker.TextReader(kmlString)).then(function() {
    const keys = Object.keys(externalFiles);
    return addExternalFilesToZip(writer, keys, externalFiles, 0);
  }).then(function() {
    return writer.close();
  }).then(function(blob) {
    return {
      kmz: blob
    };
  });
}
function addExternalFilesToZip(writer, keys, externalFiles, index2) {
  if (keys.length === index2) {
    return;
  }
  const filename = keys[index2];
  return writer.add(filename, new zipNoWorker.BlobReader(externalFiles[filename])).then(function() {
    return addExternalFilesToZip(writer, keys, externalFiles, index2 + 1);
  });
}
exportKml._createState = function(options) {
  const entities = options.entities;
  const styleCache = new StyleCache();
  const entityAvailability = entities.computeAvailability();
  const time = defined_default(options.time) ? options.time : entityAvailability.start;
  let defaultAvailability = defaultValue_default(
    options.defaultAvailability,
    entityAvailability
  );
  const sampleDuration = defaultValue_default(options.sampleDuration, 60);
  if (defaultAvailability.start === Iso8601_default.MINIMUM_VALUE) {
    if (defaultAvailability.stop === Iso8601_default.MAXIMUM_VALUE) {
      defaultAvailability = new TimeInterval_default();
    } else {
      JulianDate_default.addSeconds(
        defaultAvailability.stop,
        -10 * sampleDuration,
        defaultAvailability.start
      );
    }
  } else if (defaultAvailability.stop === Iso8601_default.MAXIMUM_VALUE) {
    JulianDate_default.addSeconds(
      defaultAvailability.start,
      10 * sampleDuration,
      defaultAvailability.stop
    );
  }
  const externalFileHandler = new ExternalFileHandler(options.modelCallback);
  const kmlDoc = document.implementation.createDocument(kmlNamespace, "kml");
  return {
    kmlDoc,
    ellipsoid: defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84),
    idManager: new IdManager(),
    styleCache,
    externalFileHandler,
    time,
    valueGetter: new ValueGetter(time),
    sampleDuration,
    defaultAvailability: new TimeIntervalCollection_default([defaultAvailability])
  };
};
function recurseEntities(state, parentNode, entities) {
  const kmlDoc = state.kmlDoc;
  const styleCache = state.styleCache;
  const valueGetter = state.valueGetter;
  const idManager = state.idManager;
  const count = entities.length;
  let overlays;
  let geometries;
  let styles;
  for (let i2 = 0; i2 < count; ++i2) {
    const entity = entities[i2];
    overlays = [];
    geometries = [];
    styles = [];
    createPoint2(state, entity, geometries, styles);
    createLineString2(state, entity.polyline, geometries, styles);
    createPolygon2(state, entity.rectangle, geometries, styles, overlays);
    createPolygon2(state, entity.polygon, geometries, styles, overlays);
    createModel2(state, entity, entity.model, geometries, styles);
    let timeSpan;
    const availability = entity.availability;
    if (defined_default(availability)) {
      timeSpan = kmlDoc.createElement("TimeSpan");
      if (!JulianDate_default.equals(availability.start, Iso8601_default.MINIMUM_VALUE)) {
        timeSpan.appendChild(
          createBasicElementWithText(
            kmlDoc,
            "begin",
            JulianDate_default.toIso8601(availability.start)
          )
        );
      }
      if (!JulianDate_default.equals(availability.stop, Iso8601_default.MAXIMUM_VALUE)) {
        timeSpan.appendChild(
          createBasicElementWithText(
            kmlDoc,
            "end",
            JulianDate_default.toIso8601(availability.stop)
          )
        );
      }
    }
    for (let overlayIndex = 0; overlayIndex < overlays.length; ++overlayIndex) {
      const overlay = overlays[overlayIndex];
      overlay.setAttribute("id", idManager.get(entity.id));
      overlay.appendChild(
        createBasicElementWithText(kmlDoc, "name", entity.name)
      );
      overlay.appendChild(
        createBasicElementWithText(kmlDoc, "visibility", entity.show)
      );
      overlay.appendChild(
        createBasicElementWithText(kmlDoc, "description", entity.description)
      );
      if (defined_default(timeSpan)) {
        overlay.appendChild(timeSpan);
      }
      parentNode.appendChild(overlay);
    }
    const geometryCount = geometries.length;
    if (geometryCount > 0) {
      const placemark = kmlDoc.createElement("Placemark");
      placemark.setAttribute("id", idManager.get(entity.id));
      let name = entity.name;
      const labelGraphics = entity.label;
      if (defined_default(labelGraphics)) {
        const labelStyle = kmlDoc.createElement("LabelStyle");
        const text2 = valueGetter.get(labelGraphics.text);
        name = defined_default(text2) && text2.length > 0 ? text2 : name;
        const color = valueGetter.getColor(labelGraphics.fillColor);
        if (defined_default(color)) {
          labelStyle.appendChild(
            createBasicElementWithText(kmlDoc, "color", color)
          );
          labelStyle.appendChild(
            createBasicElementWithText(kmlDoc, "colorMode", "normal")
          );
        }
        const scale = valueGetter.get(labelGraphics.scale);
        if (defined_default(scale)) {
          labelStyle.appendChild(
            createBasicElementWithText(kmlDoc, "scale", scale)
          );
        }
        styles.push(labelStyle);
      }
      placemark.appendChild(createBasicElementWithText(kmlDoc, "name", name));
      placemark.appendChild(
        createBasicElementWithText(kmlDoc, "visibility", entity.show)
      );
      placemark.appendChild(
        createBasicElementWithText(kmlDoc, "description", entity.description)
      );
      if (defined_default(timeSpan)) {
        placemark.appendChild(timeSpan);
      }
      parentNode.appendChild(placemark);
      const styleCount = styles.length;
      if (styleCount > 0) {
        const style = kmlDoc.createElement("Style");
        for (let styleIndex = 0; styleIndex < styleCount; ++styleIndex) {
          style.appendChild(styles[styleIndex]);
        }
        placemark.appendChild(
          createBasicElementWithText(kmlDoc, "styleUrl", styleCache.get(style))
        );
      }
      if (geometries.length === 1) {
        placemark.appendChild(geometries[0]);
      } else if (geometries.length > 1) {
        const multigeometry = kmlDoc.createElement("MultiGeometry");
        for (let geometryIndex = 0; geometryIndex < geometryCount; ++geometryIndex) {
          multigeometry.appendChild(geometries[geometryIndex]);
        }
        placemark.appendChild(multigeometry);
      }
    }
    const children = entity._children;
    if (children.length > 0) {
      const folderNode = kmlDoc.createElement("Folder");
      folderNode.setAttribute("id", idManager.get(entity.id));
      folderNode.appendChild(
        createBasicElementWithText(kmlDoc, "name", entity.name)
      );
      folderNode.appendChild(
        createBasicElementWithText(kmlDoc, "visibility", entity.show)
      );
      folderNode.appendChild(
        createBasicElementWithText(kmlDoc, "description", entity.description)
      );
      parentNode.appendChild(folderNode);
      recurseEntities(state, folderNode, children);
    }
  }
}
var scratchCartesian312 = new Cartesian3_default();
var scratchCartographic14 = new Cartographic_default();
var scratchJulianDate3 = new JulianDate_default();
function createPoint2(state, entity, geometries, styles) {
  const kmlDoc = state.kmlDoc;
  const ellipsoid = state.ellipsoid;
  const valueGetter = state.valueGetter;
  const pointGraphics = defaultValue_default(entity.billboard, entity.point);
  if (!defined_default(pointGraphics) && !defined_default(entity.path)) {
    return;
  }
  const entityPositionProperty = entity.position;
  if (!entityPositionProperty.isConstant) {
    createTracks(state, entity, pointGraphics, geometries, styles);
    return;
  }
  valueGetter.get(entityPositionProperty, void 0, scratchCartesian312);
  const coordinates = createBasicElementWithText(
    kmlDoc,
    "coordinates",
    getCoordinates(scratchCartesian312, ellipsoid)
  );
  const pointGeometry = kmlDoc.createElement("Point");
  const altitudeMode = kmlDoc.createElement("altitudeMode");
  altitudeMode.appendChild(
    getAltitudeMode(state, pointGraphics.heightReference)
  );
  pointGeometry.appendChild(altitudeMode);
  pointGeometry.appendChild(coordinates);
  geometries.push(pointGeometry);
  const iconStyle = pointGraphics instanceof BillboardGraphics_default ? createIconStyleFromBillboard(state, pointGraphics) : createIconStyleFromPoint(state, pointGraphics);
  styles.push(iconStyle);
}
function createTracks(state, entity, pointGraphics, geometries, styles) {
  const kmlDoc = state.kmlDoc;
  const ellipsoid = state.ellipsoid;
  const valueGetter = state.valueGetter;
  let intervals;
  const entityPositionProperty = entity.position;
  let useEntityPositionProperty = true;
  if (entityPositionProperty instanceof CompositePositionProperty_default) {
    intervals = entityPositionProperty.intervals;
    useEntityPositionProperty = false;
  } else {
    intervals = defaultValue_default(entity.availability, state.defaultAvailability);
  }
  const isModel = pointGraphics instanceof ModelGraphics_default;
  let i2, j, times;
  const tracks = [];
  for (i2 = 0; i2 < intervals.length; ++i2) {
    const interval = intervals.get(i2);
    let positionProperty = useEntityPositionProperty ? entityPositionProperty : interval.data;
    const trackAltitudeMode = kmlDoc.createElement("altitudeMode");
    if (positionProperty instanceof ScaledPositionProperty_default) {
      positionProperty = positionProperty._value;
      trackAltitudeMode.appendChild(
        getAltitudeMode(state, HeightReference_default.CLAMP_TO_GROUND)
      );
    } else if (defined_default(pointGraphics)) {
      trackAltitudeMode.appendChild(
        getAltitudeMode(state, pointGraphics.heightReference)
      );
    } else {
      trackAltitudeMode.appendChild(
        getAltitudeMode(state, HeightReference_default.NONE)
      );
    }
    const positionTimes = [];
    const positionValues = [];
    if (positionProperty.isConstant) {
      valueGetter.get(positionProperty, void 0, scratchCartesian312);
      const constCoordinates = createBasicElementWithText(
        kmlDoc,
        "coordinates",
        getCoordinates(scratchCartesian312, ellipsoid)
      );
      positionTimes.push(JulianDate_default.toIso8601(interval.start));
      positionValues.push(constCoordinates);
      positionTimes.push(JulianDate_default.toIso8601(interval.stop));
      positionValues.push(constCoordinates);
    } else if (positionProperty instanceof SampledPositionProperty_default) {
      times = positionProperty._property._times;
      for (j = 0; j < times.length; ++j) {
        positionTimes.push(JulianDate_default.toIso8601(times[j]));
        positionProperty.getValueInReferenceFrame(
          times[j],
          ReferenceFrame_default.FIXED,
          scratchCartesian312
        );
        positionValues.push(getCoordinates(scratchCartesian312, ellipsoid));
      }
    } else if (positionProperty instanceof SampledProperty_default) {
      times = positionProperty._times;
      const values = positionProperty._values;
      for (j = 0; j < times.length; ++j) {
        positionTimes.push(JulianDate_default.toIso8601(times[j]));
        Cartesian3_default.fromArray(values, j * 3, scratchCartesian312);
        positionValues.push(getCoordinates(scratchCartesian312, ellipsoid));
      }
    } else {
      const duration = state.sampleDuration;
      interval.start.clone(scratchJulianDate3);
      if (!interval.isStartIncluded) {
        JulianDate_default.addSeconds(scratchJulianDate3, duration, scratchJulianDate3);
      }
      const stopDate = interval.stop;
      while (JulianDate_default.lessThan(scratchJulianDate3, stopDate)) {
        positionProperty.getValue(scratchJulianDate3, scratchCartesian312);
        positionTimes.push(JulianDate_default.toIso8601(scratchJulianDate3));
        positionValues.push(getCoordinates(scratchCartesian312, ellipsoid));
        JulianDate_default.addSeconds(scratchJulianDate3, duration, scratchJulianDate3);
      }
      if (interval.isStopIncluded && JulianDate_default.equals(scratchJulianDate3, stopDate)) {
        positionProperty.getValue(scratchJulianDate3, scratchCartesian312);
        positionTimes.push(JulianDate_default.toIso8601(scratchJulianDate3));
        positionValues.push(getCoordinates(scratchCartesian312, ellipsoid));
      }
    }
    const trackGeometry = kmlDoc.createElementNS(gxNamespace, "Track");
    trackGeometry.appendChild(trackAltitudeMode);
    for (let k = 0; k < positionTimes.length; ++k) {
      const when = createBasicElementWithText(kmlDoc, "when", positionTimes[k]);
      const coord = createBasicElementWithText(
        kmlDoc,
        "coord",
        positionValues[k],
        gxNamespace
      );
      trackGeometry.appendChild(when);
      trackGeometry.appendChild(coord);
    }
    if (isModel) {
      trackGeometry.appendChild(createModelGeometry(state, pointGraphics));
    }
    tracks.push(trackGeometry);
  }
  if (tracks.length === 1) {
    geometries.push(tracks[0]);
  } else if (tracks.length > 1) {
    const multiTrackGeometry = kmlDoc.createElementNS(
      gxNamespace,
      "MultiTrack"
    );
    for (i2 = 0; i2 < tracks.length; ++i2) {
      multiTrackGeometry.appendChild(tracks[i2]);
    }
    geometries.push(multiTrackGeometry);
  }
  if (defined_default(pointGraphics) && !isModel) {
    const iconStyle = pointGraphics instanceof BillboardGraphics_default ? createIconStyleFromBillboard(state, pointGraphics) : createIconStyleFromPoint(state, pointGraphics);
    styles.push(iconStyle);
  }
  const path = entity.path;
  if (defined_default(path)) {
    const width = valueGetter.get(path.width);
    const material = path.material;
    if (defined_default(material) || defined_default(width)) {
      const lineStyle = kmlDoc.createElement("LineStyle");
      if (defined_default(width)) {
        lineStyle.appendChild(
          createBasicElementWithText(kmlDoc, "width", width)
        );
      }
      processMaterial(state, material, lineStyle);
      styles.push(lineStyle);
    }
  }
}
function createIconStyleFromPoint(state, pointGraphics) {
  const kmlDoc = state.kmlDoc;
  const valueGetter = state.valueGetter;
  const iconStyle = kmlDoc.createElement("IconStyle");
  const color = valueGetter.getColor(pointGraphics.color);
  if (defined_default(color)) {
    iconStyle.appendChild(createBasicElementWithText(kmlDoc, "color", color));
    iconStyle.appendChild(
      createBasicElementWithText(kmlDoc, "colorMode", "normal")
    );
  }
  const pixelSize = valueGetter.get(pointGraphics.pixelSize);
  if (defined_default(pixelSize)) {
    iconStyle.appendChild(
      createBasicElementWithText(kmlDoc, "scale", pixelSize / BILLBOARD_SIZE3)
    );
  }
  return iconStyle;
}
function createIconStyleFromBillboard(state, billboardGraphics) {
  const kmlDoc = state.kmlDoc;
  const valueGetter = state.valueGetter;
  const externalFileHandler = state.externalFileHandler;
  const iconStyle = kmlDoc.createElement("IconStyle");
  let image = valueGetter.get(billboardGraphics.image);
  if (defined_default(image)) {
    image = externalFileHandler.texture(image);
    const icon = kmlDoc.createElement("Icon");
    icon.appendChild(createBasicElementWithText(kmlDoc, "href", image));
    const imageSubRegion = valueGetter.get(billboardGraphics.imageSubRegion);
    if (defined_default(imageSubRegion)) {
      icon.appendChild(
        createBasicElementWithText(kmlDoc, "x", imageSubRegion.x, gxNamespace)
      );
      icon.appendChild(
        createBasicElementWithText(kmlDoc, "y", imageSubRegion.y, gxNamespace)
      );
      icon.appendChild(
        createBasicElementWithText(
          kmlDoc,
          "w",
          imageSubRegion.width,
          gxNamespace
        )
      );
      icon.appendChild(
        createBasicElementWithText(
          kmlDoc,
          "h",
          imageSubRegion.height,
          gxNamespace
        )
      );
    }
    iconStyle.appendChild(icon);
  }
  const color = valueGetter.getColor(billboardGraphics.color);
  if (defined_default(color)) {
    iconStyle.appendChild(createBasicElementWithText(kmlDoc, "color", color));
    iconStyle.appendChild(
      createBasicElementWithText(kmlDoc, "colorMode", "normal")
    );
  }
  let scale = valueGetter.get(billboardGraphics.scale);
  if (defined_default(scale)) {
    iconStyle.appendChild(createBasicElementWithText(kmlDoc, "scale", scale));
  }
  const pixelOffset = valueGetter.get(billboardGraphics.pixelOffset);
  if (defined_default(pixelOffset)) {
    scale = defaultValue_default(scale, 1);
    Cartesian2_default.divideByScalar(pixelOffset, scale, pixelOffset);
    const width = valueGetter.get(billboardGraphics.width, BILLBOARD_SIZE3);
    const height = valueGetter.get(billboardGraphics.height, BILLBOARD_SIZE3);
    const horizontalOrigin = valueGetter.get(
      billboardGraphics.horizontalOrigin,
      HorizontalOrigin_default.CENTER
    );
    if (horizontalOrigin === HorizontalOrigin_default.CENTER) {
      pixelOffset.x -= width * 0.5;
    } else if (horizontalOrigin === HorizontalOrigin_default.RIGHT) {
      pixelOffset.x -= width;
    }
    const verticalOrigin = valueGetter.get(
      billboardGraphics.verticalOrigin,
      VerticalOrigin_default.CENTER
    );
    if (verticalOrigin === VerticalOrigin_default.TOP) {
      pixelOffset.y += height;
    } else if (verticalOrigin === VerticalOrigin_default.CENTER) {
      pixelOffset.y += height * 0.5;
    }
    const hotSpot = kmlDoc.createElement("hotSpot");
    hotSpot.setAttribute("x", -pixelOffset.x);
    hotSpot.setAttribute("y", pixelOffset.y);
    hotSpot.setAttribute("xunits", "pixels");
    hotSpot.setAttribute("yunits", "pixels");
    iconStyle.appendChild(hotSpot);
  }
  let rotation = valueGetter.get(billboardGraphics.rotation);
  const alignedAxis = valueGetter.get(billboardGraphics.alignedAxis);
  if (defined_default(rotation) && Cartesian3_default.equals(Cartesian3_default.UNIT_Z, alignedAxis)) {
    rotation = Math_default.toDegrees(-rotation);
    if (rotation === 0) {
      rotation = 360;
    }
    iconStyle.appendChild(
      createBasicElementWithText(kmlDoc, "heading", rotation)
    );
  }
  return iconStyle;
}
function createLineString2(state, polylineGraphics, geometries, styles) {
  const kmlDoc = state.kmlDoc;
  const ellipsoid = state.ellipsoid;
  const valueGetter = state.valueGetter;
  if (!defined_default(polylineGraphics)) {
    return;
  }
  const lineStringGeometry = kmlDoc.createElement("LineString");
  const altitudeMode = kmlDoc.createElement("altitudeMode");
  const clampToGround = valueGetter.get(polylineGraphics.clampToGround, false);
  let altitudeModeText;
  if (clampToGround) {
    lineStringGeometry.appendChild(
      createBasicElementWithText(kmlDoc, "tessellate", true)
    );
    altitudeModeText = kmlDoc.createTextNode("clampToGround");
  } else {
    altitudeModeText = kmlDoc.createTextNode("absolute");
  }
  altitudeMode.appendChild(altitudeModeText);
  lineStringGeometry.appendChild(altitudeMode);
  const positionsProperty = polylineGraphics.positions;
  const cartesians = valueGetter.get(positionsProperty);
  const coordinates = createBasicElementWithText(
    kmlDoc,
    "coordinates",
    getCoordinates(cartesians, ellipsoid)
  );
  lineStringGeometry.appendChild(coordinates);
  const zIndex = valueGetter.get(polylineGraphics.zIndex);
  if (clampToGround && defined_default(zIndex)) {
    lineStringGeometry.appendChild(
      createBasicElementWithText(kmlDoc, "drawOrder", zIndex, gxNamespace)
    );
  }
  geometries.push(lineStringGeometry);
  const lineStyle = kmlDoc.createElement("LineStyle");
  const width = valueGetter.get(polylineGraphics.width);
  if (defined_default(width)) {
    lineStyle.appendChild(createBasicElementWithText(kmlDoc, "width", width));
  }
  processMaterial(state, polylineGraphics.material, lineStyle);
  styles.push(lineStyle);
}
function getRectangleBoundaries(state, rectangleGraphics, extrudedHeight) {
  const kmlDoc = state.kmlDoc;
  const valueGetter = state.valueGetter;
  let height = valueGetter.get(rectangleGraphics.height, 0);
  if (extrudedHeight > 0) {
    height = extrudedHeight;
  }
  const coordinatesProperty = rectangleGraphics.coordinates;
  const rectangle = valueGetter.get(coordinatesProperty);
  const coordinateStrings = [];
  const cornerFunction = [
    Rectangle_default.northeast,
    Rectangle_default.southeast,
    Rectangle_default.southwest,
    Rectangle_default.northwest
  ];
  for (let i2 = 0; i2 < 4; ++i2) {
    cornerFunction[i2](rectangle, scratchCartographic14);
    coordinateStrings.push(
      `${Math_default.toDegrees(
        scratchCartographic14.longitude
      )},${Math_default.toDegrees(scratchCartographic14.latitude)},${height}`
    );
  }
  const coordinates = createBasicElementWithText(
    kmlDoc,
    "coordinates",
    coordinateStrings.join(" ")
  );
  const outerBoundaryIs = kmlDoc.createElement("outerBoundaryIs");
  const linearRing = kmlDoc.createElement("LinearRing");
  linearRing.appendChild(coordinates);
  outerBoundaryIs.appendChild(linearRing);
  return [outerBoundaryIs];
}
function getLinearRing(state, positions, height, perPositionHeight) {
  const kmlDoc = state.kmlDoc;
  const ellipsoid = state.ellipsoid;
  const coordinateStrings = [];
  const positionCount = positions.length;
  for (let i2 = 0; i2 < positionCount; ++i2) {
    Cartographic_default.fromCartesian(positions[i2], ellipsoid, scratchCartographic14);
    coordinateStrings.push(
      `${Math_default.toDegrees(
        scratchCartographic14.longitude
      )},${Math_default.toDegrees(scratchCartographic14.latitude)},${perPositionHeight ? scratchCartographic14.height : height}`
    );
  }
  const coordinates = createBasicElementWithText(
    kmlDoc,
    "coordinates",
    coordinateStrings.join(" ")
  );
  const linearRing = kmlDoc.createElement("LinearRing");
  linearRing.appendChild(coordinates);
  return linearRing;
}
function getPolygonBoundaries(state, polygonGraphics, extrudedHeight) {
  const kmlDoc = state.kmlDoc;
  const valueGetter = state.valueGetter;
  let height = valueGetter.get(polygonGraphics.height, 0);
  const perPositionHeight = valueGetter.get(
    polygonGraphics.perPositionHeight,
    false
  );
  if (!perPositionHeight && extrudedHeight > 0) {
    height = extrudedHeight;
  }
  const boundaries = [];
  const hierarchyProperty = polygonGraphics.hierarchy;
  const hierarchy = valueGetter.get(hierarchyProperty);
  const positions = Array.isArray(hierarchy) ? hierarchy : hierarchy.positions;
  const outerBoundaryIs = kmlDoc.createElement("outerBoundaryIs");
  outerBoundaryIs.appendChild(
    getLinearRing(state, positions, height, perPositionHeight)
  );
  boundaries.push(outerBoundaryIs);
  const holes = hierarchy.holes;
  if (defined_default(holes)) {
    const holeCount = holes.length;
    for (let i2 = 0; i2 < holeCount; ++i2) {
      const innerBoundaryIs = kmlDoc.createElement("innerBoundaryIs");
      innerBoundaryIs.appendChild(
        getLinearRing(state, holes[i2].positions, height, perPositionHeight)
      );
      boundaries.push(innerBoundaryIs);
    }
  }
  return boundaries;
}
function createPolygon2(state, geometry, geometries, styles, overlays) {
  const kmlDoc = state.kmlDoc;
  const valueGetter = state.valueGetter;
  if (!defined_default(geometry)) {
    return;
  }
  const isRectangle = geometry instanceof RectangleGraphics_default;
  if (isRectangle && valueGetter.getMaterialType(geometry.material) === "Image") {
    createGroundOverlay(state, geometry, overlays);
    return;
  }
  const polygonGeometry = kmlDoc.createElement("Polygon");
  const extrudedHeight = valueGetter.get(geometry.extrudedHeight, 0);
  if (extrudedHeight > 0) {
    polygonGeometry.appendChild(
      createBasicElementWithText(kmlDoc, "extrude", true)
    );
  }
  const boundaries = isRectangle ? getRectangleBoundaries(state, geometry, extrudedHeight) : getPolygonBoundaries(state, geometry, extrudedHeight);
  const boundaryCount = boundaries.length;
  for (let i2 = 0; i2 < boundaryCount; ++i2) {
    polygonGeometry.appendChild(boundaries[i2]);
  }
  const altitudeMode = kmlDoc.createElement("altitudeMode");
  altitudeMode.appendChild(getAltitudeMode(state, geometry.heightReference));
  polygonGeometry.appendChild(altitudeMode);
  geometries.push(polygonGeometry);
  const polyStyle = kmlDoc.createElement("PolyStyle");
  const fill = valueGetter.get(geometry.fill, false);
  if (fill) {
    polyStyle.appendChild(createBasicElementWithText(kmlDoc, "fill", fill));
  }
  processMaterial(state, geometry.material, polyStyle);
  const outline = valueGetter.get(geometry.outline, false);
  if (outline) {
    polyStyle.appendChild(
      createBasicElementWithText(kmlDoc, "outline", outline)
    );
    const lineStyle = kmlDoc.createElement("LineStyle");
    const outlineWidth = valueGetter.get(geometry.outlineWidth, 1);
    lineStyle.appendChild(
      createBasicElementWithText(kmlDoc, "width", outlineWidth)
    );
    const outlineColor = valueGetter.getColor(
      geometry.outlineColor,
      Color_default.BLACK
    );
    lineStyle.appendChild(
      createBasicElementWithText(kmlDoc, "color", outlineColor)
    );
    lineStyle.appendChild(
      createBasicElementWithText(kmlDoc, "colorMode", "normal")
    );
    styles.push(lineStyle);
  }
  styles.push(polyStyle);
}
function createGroundOverlay(state, rectangleGraphics, overlays) {
  const kmlDoc = state.kmlDoc;
  const valueGetter = state.valueGetter;
  const externalFileHandler = state.externalFileHandler;
  const groundOverlay = kmlDoc.createElement("GroundOverlay");
  const altitudeMode = kmlDoc.createElement("altitudeMode");
  altitudeMode.appendChild(
    getAltitudeMode(state, rectangleGraphics.heightReference)
  );
  groundOverlay.appendChild(altitudeMode);
  const height = valueGetter.get(rectangleGraphics.height);
  if (defined_default(height)) {
    groundOverlay.appendChild(
      createBasicElementWithText(kmlDoc, "altitude", height)
    );
  }
  const rectangle = valueGetter.get(rectangleGraphics.coordinates);
  const latLonBox = kmlDoc.createElement("LatLonBox");
  latLonBox.appendChild(
    createBasicElementWithText(
      kmlDoc,
      "north",
      Math_default.toDegrees(rectangle.north)
    )
  );
  latLonBox.appendChild(
    createBasicElementWithText(
      kmlDoc,
      "south",
      Math_default.toDegrees(rectangle.south)
    )
  );
  latLonBox.appendChild(
    createBasicElementWithText(
      kmlDoc,
      "east",
      Math_default.toDegrees(rectangle.east)
    )
  );
  latLonBox.appendChild(
    createBasicElementWithText(
      kmlDoc,
      "west",
      Math_default.toDegrees(rectangle.west)
    )
  );
  groundOverlay.appendChild(latLonBox);
  const material = valueGetter.get(rectangleGraphics.material);
  const href = externalFileHandler.texture(material.image);
  const icon = kmlDoc.createElement("Icon");
  icon.appendChild(createBasicElementWithText(kmlDoc, "href", href));
  groundOverlay.appendChild(icon);
  const color = material.color;
  if (defined_default(color)) {
    groundOverlay.appendChild(
      createBasicElementWithText(kmlDoc, "color", colorToString(material.color))
    );
  }
  overlays.push(groundOverlay);
}
function createModelGeometry(state, modelGraphics) {
  const kmlDoc = state.kmlDoc;
  const valueGetter = state.valueGetter;
  const externalFileHandler = state.externalFileHandler;
  const modelGeometry = kmlDoc.createElement("Model");
  const scale = valueGetter.get(modelGraphics.scale);
  if (defined_default(scale)) {
    const scaleElement = kmlDoc.createElement("scale");
    scaleElement.appendChild(createBasicElementWithText(kmlDoc, "x", scale));
    scaleElement.appendChild(createBasicElementWithText(kmlDoc, "y", scale));
    scaleElement.appendChild(createBasicElementWithText(kmlDoc, "z", scale));
    modelGeometry.appendChild(scaleElement);
  }
  const link = kmlDoc.createElement("Link");
  const uri = externalFileHandler.model(modelGraphics, state.time);
  link.appendChild(createBasicElementWithText(kmlDoc, "href", uri));
  modelGeometry.appendChild(link);
  return modelGeometry;
}
function createModel2(state, entity, modelGraphics, geometries, styles) {
  const kmlDoc = state.kmlDoc;
  const ellipsoid = state.ellipsoid;
  const valueGetter = state.valueGetter;
  if (!defined_default(modelGraphics)) {
    return;
  }
  const entityPositionProperty = entity.position;
  if (!entityPositionProperty.isConstant) {
    createTracks(state, entity, modelGraphics, geometries, styles);
    return;
  }
  const modelGeometry = createModelGeometry(state, modelGraphics);
  const altitudeMode = kmlDoc.createElement("altitudeMode");
  altitudeMode.appendChild(
    getAltitudeMode(state, modelGraphics.heightReference)
  );
  modelGeometry.appendChild(altitudeMode);
  valueGetter.get(entityPositionProperty, void 0, scratchCartesian312);
  Cartographic_default.fromCartesian(scratchCartesian312, ellipsoid, scratchCartographic14);
  const location2 = kmlDoc.createElement("Location");
  location2.appendChild(
    createBasicElementWithText(
      kmlDoc,
      "longitude",
      Math_default.toDegrees(scratchCartographic14.longitude)
    )
  );
  location2.appendChild(
    createBasicElementWithText(
      kmlDoc,
      "latitude",
      Math_default.toDegrees(scratchCartographic14.latitude)
    )
  );
  location2.appendChild(
    createBasicElementWithText(kmlDoc, "altitude", scratchCartographic14.height)
  );
  modelGeometry.appendChild(location2);
  geometries.push(modelGeometry);
}
function processMaterial(state, materialProperty, style) {
  const kmlDoc = state.kmlDoc;
  const valueGetter = state.valueGetter;
  if (!defined_default(materialProperty)) {
    return;
  }
  const material = valueGetter.get(materialProperty);
  if (!defined_default(material)) {
    return;
  }
  let color;
  const type = valueGetter.getMaterialType(materialProperty);
  let outlineColor;
  let outlineWidth;
  switch (type) {
    case "Image":
      color = colorToString(Color_default.WHITE);
      break;
    case "Color":
    case "Grid":
    case "PolylineGlow":
    case "PolylineArrow":
    case "PolylineDash":
      color = colorToString(material.color);
      break;
    case "PolylineOutline":
      color = colorToString(material.color);
      outlineColor = colorToString(material.outlineColor);
      outlineWidth = material.outlineWidth;
      style.appendChild(
        createBasicElementWithText(
          kmlDoc,
          "outerColor",
          outlineColor,
          gxNamespace
        )
      );
      style.appendChild(
        createBasicElementWithText(
          kmlDoc,
          "outerWidth",
          outlineWidth,
          gxNamespace
        )
      );
      break;
    case "Stripe":
      color = colorToString(material.oddColor);
      break;
  }
  if (defined_default(color)) {
    style.appendChild(createBasicElementWithText(kmlDoc, "color", color));
    style.appendChild(
      createBasicElementWithText(kmlDoc, "colorMode", "normal")
    );
  }
}
function getAltitudeMode(state, heightReferenceProperty) {
  const kmlDoc = state.kmlDoc;
  const valueGetter = state.valueGetter;
  const heightReference = valueGetter.get(
    heightReferenceProperty,
    HeightReference_default.NONE
  );
  let altitudeModeText;
  switch (heightReference) {
    case HeightReference_default.NONE:
      altitudeModeText = kmlDoc.createTextNode("absolute");
      break;
    case HeightReference_default.CLAMP_TO_GROUND:
      altitudeModeText = kmlDoc.createTextNode("clampToGround");
      break;
    case HeightReference_default.RELATIVE_TO_GROUND:
      altitudeModeText = kmlDoc.createTextNode("relativeToGround");
      break;
  }
  return altitudeModeText;
}
function getCoordinates(coordinates, ellipsoid) {
  if (!Array.isArray(coordinates)) {
    coordinates = [coordinates];
  }
  const count = coordinates.length;
  const coordinateStrings = [];
  for (let i2 = 0; i2 < count; ++i2) {
    Cartographic_default.fromCartesian(coordinates[i2], ellipsoid, scratchCartographic14);
    coordinateStrings.push(
      `${Math_default.toDegrees(
        scratchCartographic14.longitude
      )},${Math_default.toDegrees(scratchCartographic14.latitude)},${scratchCartographic14.height}`
    );
  }
  return coordinateStrings.join(" ");
}
function createBasicElementWithText(kmlDoc, elementName, elementValue, namespace) {
  elementValue = defaultValue_default(elementValue, "");
  if (typeof elementValue === "boolean") {
    elementValue = elementValue ? "1" : "0";
  }
  const element = defined_default(namespace) ? kmlDoc.createElementNS(namespace, elementName) : kmlDoc.createElement(elementName);
  const text2 = elementValue === "string" && elementValue.indexOf("<") !== -1 ? kmlDoc.createCDATASection(elementValue) : kmlDoc.createTextNode(elementValue);
  element.appendChild(text2);
  return element;
}
function colorToString(color) {
  let result = "";
  const bytes = color.toBytes();
  for (let i2 = 3; i2 >= 0; --i2) {
    result += bytes[i2] < 16 ? `0${bytes[i2].toString(16)}` : bytes[i2].toString(16);
  }
  return result;
}
var exportKml_default = exportKml;

// node_modules/cesium/Source/Shaders/ViewportQuadVS.js
var ViewportQuadVS_default = "attribute vec4 position;\nattribute vec2 textureCoordinates;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main() \n{\n    gl_Position = position;\n    v_textureCoordinates = textureCoordinates;\n}\n";

// node_modules/cesium/Source/Renderer/ComputeEngine.js
function ComputeEngine(context) {
  this._context = context;
}
var renderStateScratch;
var drawCommandScratch = new DrawCommand_default({
  primitiveType: PrimitiveType_default.TRIANGLES
});
var clearCommandScratch = new ClearCommand_default({
  color: new Color_default(0, 0, 0, 0)
});
function createFramebuffer(context, outputTexture) {
  return new Framebuffer_default({
    context,
    colorTextures: [outputTexture],
    destroyAttachments: false
  });
}
function createViewportQuadShader(context, fragmentShaderSource) {
  return ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: ViewportQuadVS_default,
    fragmentShaderSource,
    attributeLocations: {
      position: 0,
      textureCoordinates: 1
    }
  });
}
function createRenderState(width, height) {
  if (!defined_default(renderStateScratch) || renderStateScratch.viewport.width !== width || renderStateScratch.viewport.height !== height) {
    renderStateScratch = RenderState_default.fromCache({
      viewport: new BoundingRectangle_default(0, 0, width, height)
    });
  }
  return renderStateScratch;
}
ComputeEngine.prototype.execute = function(computeCommand) {
  Check_default.defined("computeCommand", computeCommand);
  if (defined_default(computeCommand.preExecute)) {
    computeCommand.preExecute(computeCommand);
  }
  if (!defined_default(computeCommand.fragmentShaderSource) && !defined_default(computeCommand.shaderProgram)) {
    throw new DeveloperError_default(
      "computeCommand.fragmentShaderSource or computeCommand.shaderProgram is required."
    );
  }
  Check_default.defined("computeCommand.outputTexture", computeCommand.outputTexture);
  const outputTexture = computeCommand.outputTexture;
  const width = outputTexture.width;
  const height = outputTexture.height;
  const context = this._context;
  const vertexArray = defined_default(computeCommand.vertexArray) ? computeCommand.vertexArray : context.getViewportQuadVertexArray();
  const shaderProgram = defined_default(computeCommand.shaderProgram) ? computeCommand.shaderProgram : createViewportQuadShader(context, computeCommand.fragmentShaderSource);
  const framebuffer = createFramebuffer(context, outputTexture);
  const renderState = createRenderState(width, height);
  const uniformMap2 = computeCommand.uniformMap;
  const clearCommand = clearCommandScratch;
  clearCommand.framebuffer = framebuffer;
  clearCommand.renderState = renderState;
  clearCommand.execute(context);
  const drawCommand = drawCommandScratch;
  drawCommand.vertexArray = vertexArray;
  drawCommand.renderState = renderState;
  drawCommand.shaderProgram = shaderProgram;
  drawCommand.uniformMap = uniformMap2;
  drawCommand.framebuffer = framebuffer;
  drawCommand.execute(context);
  framebuffer.destroy();
  if (!computeCommand.persists) {
    shaderProgram.destroy();
    if (defined_default(computeCommand.vertexArray)) {
      vertexArray.destroy();
    }
  }
  if (defined_default(computeCommand.postExecute)) {
    computeCommand.postExecute(outputTexture);
  }
};
ComputeEngine.prototype.isDestroyed = function() {
  return false;
};
ComputeEngine.prototype.destroy = function() {
  return destroyObject_default(this);
};
var ComputeEngine_default = ComputeEngine;

// node_modules/cesium/Source/Renderer/PassState.js
function PassState(context) {
  this.context = context;
  this.framebuffer = void 0;
  this.blendingEnabled = void 0;
  this.scissorTest = void 0;
  this.viewport = void 0;
}
var PassState_default = PassState;

// node_modules/cesium/Source/Renderer/ShaderCache.js
function ShaderCache(context) {
  this._context = context;
  this._shaders = {};
  this._numberOfShaders = 0;
  this._shadersToRelease = {};
}
Object.defineProperties(ShaderCache.prototype, {
  numberOfShaders: {
    get: function() {
      return this._numberOfShaders;
    }
  }
});
ShaderCache.prototype.replaceShaderProgram = function(options) {
  if (defined_default(options.shaderProgram)) {
    options.shaderProgram.destroy();
  }
  return this.getShaderProgram(options);
};
ShaderCache.prototype.getShaderProgram = function(options) {
  let vertexShaderSource = options.vertexShaderSource;
  let fragmentShaderSource = options.fragmentShaderSource;
  const attributeLocations8 = options.attributeLocations;
  if (typeof vertexShaderSource === "string") {
    vertexShaderSource = new ShaderSource_default({
      sources: [vertexShaderSource]
    });
  }
  if (typeof fragmentShaderSource === "string") {
    fragmentShaderSource = new ShaderSource_default({
      sources: [fragmentShaderSource]
    });
  }
  const vertexShaderText = vertexShaderSource.createCombinedVertexShader(
    this._context
  );
  const fragmentShaderText = fragmentShaderSource.createCombinedFragmentShader(
    this._context
  );
  const keyword = vertexShaderText + fragmentShaderText + JSON.stringify(attributeLocations8);
  let cachedShader;
  if (defined_default(this._shaders[keyword])) {
    cachedShader = this._shaders[keyword];
    delete this._shadersToRelease[keyword];
  } else {
    const context = this._context;
    const shaderProgram = new ShaderProgram_default({
      gl: context._gl,
      logShaderCompilation: context.logShaderCompilation,
      debugShaders: context.debugShaders,
      vertexShaderSource,
      vertexShaderText,
      fragmentShaderSource,
      fragmentShaderText,
      attributeLocations: attributeLocations8
    });
    cachedShader = {
      cache: this,
      shaderProgram,
      keyword,
      derivedKeywords: [],
      count: 0
    };
    shaderProgram._cachedShader = cachedShader;
    this._shaders[keyword] = cachedShader;
    ++this._numberOfShaders;
  }
  ++cachedShader.count;
  return cachedShader.shaderProgram;
};
ShaderCache.prototype.replaceDerivedShaderProgram = function(shaderProgram, keyword, options) {
  const cachedShader = shaderProgram._cachedShader;
  const derivedKeyword = keyword + cachedShader.keyword;
  const cachedDerivedShader = this._shaders[derivedKeyword];
  if (defined_default(cachedDerivedShader)) {
    destroyShader(this, cachedDerivedShader);
    const index2 = cachedShader.derivedKeywords.indexOf(keyword);
    if (index2 > -1) {
      cachedShader.derivedKeywords.splice(index2, 1);
    }
  }
  return this.createDerivedShaderProgram(shaderProgram, keyword, options);
};
ShaderCache.prototype.getDerivedShaderProgram = function(shaderProgram, keyword) {
  const cachedShader = shaderProgram._cachedShader;
  const derivedKeyword = keyword + cachedShader.keyword;
  const cachedDerivedShader = this._shaders[derivedKeyword];
  if (!defined_default(cachedDerivedShader)) {
    return void 0;
  }
  return cachedDerivedShader.shaderProgram;
};
ShaderCache.prototype.createDerivedShaderProgram = function(shaderProgram, keyword, options) {
  const cachedShader = shaderProgram._cachedShader;
  const derivedKeyword = keyword + cachedShader.keyword;
  let vertexShaderSource = options.vertexShaderSource;
  let fragmentShaderSource = options.fragmentShaderSource;
  const attributeLocations8 = options.attributeLocations;
  if (typeof vertexShaderSource === "string") {
    vertexShaderSource = new ShaderSource_default({
      sources: [vertexShaderSource]
    });
  }
  if (typeof fragmentShaderSource === "string") {
    fragmentShaderSource = new ShaderSource_default({
      sources: [fragmentShaderSource]
    });
  }
  const context = this._context;
  const vertexShaderText = vertexShaderSource.createCombinedVertexShader(
    context
  );
  const fragmentShaderText = fragmentShaderSource.createCombinedFragmentShader(
    context
  );
  const derivedShaderProgram = new ShaderProgram_default({
    gl: context._gl,
    logShaderCompilation: context.logShaderCompilation,
    debugShaders: context.debugShaders,
    vertexShaderSource,
    vertexShaderText,
    fragmentShaderSource,
    fragmentShaderText,
    attributeLocations: attributeLocations8
  });
  const derivedCachedShader = {
    cache: this,
    shaderProgram: derivedShaderProgram,
    keyword: derivedKeyword,
    derivedKeywords: [],
    count: 0
  };
  cachedShader.derivedKeywords.push(keyword);
  derivedShaderProgram._cachedShader = derivedCachedShader;
  this._shaders[derivedKeyword] = derivedCachedShader;
  return derivedShaderProgram;
};
function destroyShader(cache, cachedShader) {
  const derivedKeywords = cachedShader.derivedKeywords;
  const length3 = derivedKeywords.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const keyword = derivedKeywords[i2] + cachedShader.keyword;
    const derivedCachedShader = cache._shaders[keyword];
    destroyShader(cache, derivedCachedShader);
  }
  delete cache._shaders[cachedShader.keyword];
  cachedShader.shaderProgram.finalDestroy();
}
ShaderCache.prototype.destroyReleasedShaderPrograms = function() {
  const shadersToRelease = this._shadersToRelease;
  for (const keyword in shadersToRelease) {
    if (shadersToRelease.hasOwnProperty(keyword)) {
      const cachedShader = shadersToRelease[keyword];
      destroyShader(this, cachedShader);
      --this._numberOfShaders;
    }
  }
  this._shadersToRelease = {};
};
ShaderCache.prototype.releaseShaderProgram = function(shaderProgram) {
  if (defined_default(shaderProgram)) {
    const cachedShader = shaderProgram._cachedShader;
    if (cachedShader && --cachedShader.count === 0) {
      this._shadersToRelease[cachedShader.keyword] = cachedShader;
    }
  }
};
ShaderCache.prototype.isDestroyed = function() {
  return false;
};
ShaderCache.prototype.destroy = function() {
  const shaders = this._shaders;
  for (const keyword in shaders) {
    if (shaders.hasOwnProperty(keyword)) {
      shaders[keyword].shaderProgram.finalDestroy();
    }
  }
  return destroyObject_default(this);
};
var ShaderCache_default = ShaderCache;

// node_modules/cesium/Source/Renderer/TextureCache.js
function TextureCache() {
  this._textures = {};
  this._numberOfTextures = 0;
  this._texturesToRelease = {};
}
Object.defineProperties(TextureCache.prototype, {
  numberOfTextures: {
    get: function() {
      return this._numberOfTextures;
    }
  }
});
TextureCache.prototype.getTexture = function(keyword) {
  const cachedTexture = this._textures[keyword];
  if (!defined_default(cachedTexture)) {
    return void 0;
  }
  delete this._texturesToRelease[keyword];
  ++cachedTexture.count;
  return cachedTexture.texture;
};
TextureCache.prototype.addTexture = function(keyword, texture) {
  const cachedTexture = {
    texture,
    count: 1
  };
  texture.finalDestroy = texture.destroy;
  const that = this;
  texture.destroy = function() {
    if (--cachedTexture.count === 0) {
      that._texturesToRelease[keyword] = cachedTexture;
    }
  };
  this._textures[keyword] = cachedTexture;
  ++this._numberOfTextures;
};
TextureCache.prototype.destroyReleasedTextures = function() {
  const texturesToRelease = this._texturesToRelease;
  for (const keyword in texturesToRelease) {
    if (texturesToRelease.hasOwnProperty(keyword)) {
      const cachedTexture = texturesToRelease[keyword];
      delete this._textures[keyword];
      cachedTexture.texture.finalDestroy();
      --this._numberOfTextures;
    }
  }
  this._texturesToRelease = {};
};
TextureCache.prototype.isDestroyed = function() {
  return false;
};
TextureCache.prototype.destroy = function() {
  const textures = this._textures;
  for (const keyword in textures) {
    if (textures.hasOwnProperty(keyword)) {
      textures[keyword].texture.finalDestroy();
    }
  }
  return destroyObject_default(this);
};
var TextureCache_default = TextureCache;

// node_modules/cesium/Source/Scene/SunLight.js
function SunLight(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.color = Color_default.clone(defaultValue_default(options.color, Color_default.WHITE));
  this.intensity = defaultValue_default(options.intensity, 2);
}
var SunLight_default = SunLight;

// node_modules/cesium/Source/Renderer/UniformState.js
function UniformState() {
  this.globeDepthTexture = void 0;
  this.gamma = void 0;
  this._viewport = new BoundingRectangle_default();
  this._viewportCartesian4 = new Cartesian4_default();
  this._viewportDirty = false;
  this._viewportOrthographicMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._viewportTransformation = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._model = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._view = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._inverseView = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._projection = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._infiniteProjection = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._entireFrustum = new Cartesian2_default();
  this._currentFrustum = new Cartesian2_default();
  this._frustumPlanes = new Cartesian4_default();
  this._farDepthFromNearPlusOne = void 0;
  this._log2FarDepthFromNearPlusOne = void 0;
  this._oneOverLog2FarDepthFromNearPlusOne = void 0;
  this._frameState = void 0;
  this._temeToPseudoFixed = Matrix3_default.clone(Matrix4_default.IDENTITY);
  this._view3DDirty = true;
  this._view3D = new Matrix4_default();
  this._inverseView3DDirty = true;
  this._inverseView3D = new Matrix4_default();
  this._inverseModelDirty = true;
  this._inverseModel = new Matrix4_default();
  this._inverseTransposeModelDirty = true;
  this._inverseTransposeModel = new Matrix3_default();
  this._viewRotation = new Matrix3_default();
  this._inverseViewRotation = new Matrix3_default();
  this._viewRotation3D = new Matrix3_default();
  this._inverseViewRotation3D = new Matrix3_default();
  this._inverseProjectionDirty = true;
  this._inverseProjection = new Matrix4_default();
  this._modelViewDirty = true;
  this._modelView = new Matrix4_default();
  this._modelView3DDirty = true;
  this._modelView3D = new Matrix4_default();
  this._modelViewRelativeToEyeDirty = true;
  this._modelViewRelativeToEye = new Matrix4_default();
  this._inverseModelViewDirty = true;
  this._inverseModelView = new Matrix4_default();
  this._inverseModelView3DDirty = true;
  this._inverseModelView3D = new Matrix4_default();
  this._viewProjectionDirty = true;
  this._viewProjection = new Matrix4_default();
  this._inverseViewProjectionDirty = true;
  this._inverseViewProjection = new Matrix4_default();
  this._modelViewProjectionDirty = true;
  this._modelViewProjection = new Matrix4_default();
  this._inverseModelViewProjectionDirty = true;
  this._inverseModelViewProjection = new Matrix4_default();
  this._modelViewProjectionRelativeToEyeDirty = true;
  this._modelViewProjectionRelativeToEye = new Matrix4_default();
  this._modelViewInfiniteProjectionDirty = true;
  this._modelViewInfiniteProjection = new Matrix4_default();
  this._normalDirty = true;
  this._normal = new Matrix3_default();
  this._normal3DDirty = true;
  this._normal3D = new Matrix3_default();
  this._inverseNormalDirty = true;
  this._inverseNormal = new Matrix3_default();
  this._inverseNormal3DDirty = true;
  this._inverseNormal3D = new Matrix3_default();
  this._encodedCameraPositionMCDirty = true;
  this._encodedCameraPositionMC = new EncodedCartesian3_default();
  this._cameraPosition = new Cartesian3_default();
  this._sunPositionWC = new Cartesian3_default();
  this._sunPositionColumbusView = new Cartesian3_default();
  this._sunDirectionWC = new Cartesian3_default();
  this._sunDirectionEC = new Cartesian3_default();
  this._moonDirectionEC = new Cartesian3_default();
  this._lightDirectionWC = new Cartesian3_default();
  this._lightDirectionEC = new Cartesian3_default();
  this._lightColor = new Cartesian3_default();
  this._lightColorHdr = new Cartesian3_default();
  this._pass = void 0;
  this._mode = void 0;
  this._mapProjection = void 0;
  this._ellipsoid = void 0;
  this._cameraDirection = new Cartesian3_default();
  this._cameraRight = new Cartesian3_default();
  this._cameraUp = new Cartesian3_default();
  this._frustum2DWidth = 0;
  this._eyeHeight = 0;
  this._eyeHeight2D = new Cartesian2_default();
  this._pixelRatio = 1;
  this._orthographicIn3D = false;
  this._backgroundColor = new Color_default();
  this._brdfLut = void 0;
  this._environmentMap = void 0;
  this._sphericalHarmonicCoefficients = void 0;
  this._specularEnvironmentMaps = void 0;
  this._specularEnvironmentMapsDimensions = new Cartesian2_default();
  this._specularEnvironmentMapsMaximumLOD = void 0;
  this._fogDensity = void 0;
  this._invertClassificationColor = void 0;
  this._splitPosition = 0;
  this._pixelSizePerMeter = void 0;
  this._geometricToleranceOverMeter = void 0;
  this._minimumDisableDepthTestDistance = void 0;
}
Object.defineProperties(UniformState.prototype, {
  frameState: {
    get: function() {
      return this._frameState;
    }
  },
  viewport: {
    get: function() {
      return this._viewport;
    },
    set: function(viewport) {
      if (!BoundingRectangle_default.equals(viewport, this._viewport)) {
        BoundingRectangle_default.clone(viewport, this._viewport);
        const v7 = this._viewport;
        const vc = this._viewportCartesian4;
        vc.x = v7.x;
        vc.y = v7.y;
        vc.z = v7.width;
        vc.w = v7.height;
        this._viewportDirty = true;
      }
    }
  },
  viewportCartesian4: {
    get: function() {
      return this._viewportCartesian4;
    }
  },
  viewportOrthographic: {
    get: function() {
      cleanViewport(this);
      return this._viewportOrthographicMatrix;
    }
  },
  viewportTransformation: {
    get: function() {
      cleanViewport(this);
      return this._viewportTransformation;
    }
  },
  model: {
    get: function() {
      return this._model;
    },
    set: function(matrix) {
      Matrix4_default.clone(matrix, this._model);
      this._modelView3DDirty = true;
      this._inverseModelView3DDirty = true;
      this._inverseModelDirty = true;
      this._inverseTransposeModelDirty = true;
      this._modelViewDirty = true;
      this._inverseModelViewDirty = true;
      this._modelViewRelativeToEyeDirty = true;
      this._inverseModelViewDirty = true;
      this._modelViewProjectionDirty = true;
      this._inverseModelViewProjectionDirty = true;
      this._modelViewProjectionRelativeToEyeDirty = true;
      this._modelViewInfiniteProjectionDirty = true;
      this._normalDirty = true;
      this._inverseNormalDirty = true;
      this._normal3DDirty = true;
      this._inverseNormal3DDirty = true;
      this._encodedCameraPositionMCDirty = true;
    }
  },
  inverseModel: {
    get: function() {
      if (this._inverseModelDirty) {
        this._inverseModelDirty = false;
        Matrix4_default.inverse(this._model, this._inverseModel);
      }
      return this._inverseModel;
    }
  },
  inverseTransposeModel: {
    get: function() {
      const m = this._inverseTransposeModel;
      if (this._inverseTransposeModelDirty) {
        this._inverseTransposeModelDirty = false;
        Matrix4_default.getMatrix3(this.inverseModel, m);
        Matrix3_default.transpose(m, m);
      }
      return m;
    }
  },
  view: {
    get: function() {
      return this._view;
    }
  },
  view3D: {
    get: function() {
      updateView3D(this);
      return this._view3D;
    }
  },
  viewRotation: {
    get: function() {
      updateView3D(this);
      return this._viewRotation;
    }
  },
  viewRotation3D: {
    get: function() {
      updateView3D(this);
      return this._viewRotation3D;
    }
  },
  inverseView: {
    get: function() {
      return this._inverseView;
    }
  },
  inverseView3D: {
    get: function() {
      updateInverseView3D(this);
      return this._inverseView3D;
    }
  },
  inverseViewRotation: {
    get: function() {
      return this._inverseViewRotation;
    }
  },
  inverseViewRotation3D: {
    get: function() {
      updateInverseView3D(this);
      return this._inverseViewRotation3D;
    }
  },
  projection: {
    get: function() {
      return this._projection;
    }
  },
  inverseProjection: {
    get: function() {
      cleanInverseProjection(this);
      return this._inverseProjection;
    }
  },
  infiniteProjection: {
    get: function() {
      return this._infiniteProjection;
    }
  },
  modelView: {
    get: function() {
      cleanModelView(this);
      return this._modelView;
    }
  },
  modelView3D: {
    get: function() {
      cleanModelView3D(this);
      return this._modelView3D;
    }
  },
  modelViewRelativeToEye: {
    get: function() {
      cleanModelViewRelativeToEye(this);
      return this._modelViewRelativeToEye;
    }
  },
  inverseModelView: {
    get: function() {
      cleanInverseModelView(this);
      return this._inverseModelView;
    }
  },
  inverseModelView3D: {
    get: function() {
      cleanInverseModelView3D(this);
      return this._inverseModelView3D;
    }
  },
  viewProjection: {
    get: function() {
      cleanViewProjection(this);
      return this._viewProjection;
    }
  },
  inverseViewProjection: {
    get: function() {
      cleanInverseViewProjection(this);
      return this._inverseViewProjection;
    }
  },
  modelViewProjection: {
    get: function() {
      cleanModelViewProjection(this);
      return this._modelViewProjection;
    }
  },
  inverseModelViewProjection: {
    get: function() {
      cleanInverseModelViewProjection(this);
      return this._inverseModelViewProjection;
    }
  },
  modelViewProjectionRelativeToEye: {
    get: function() {
      cleanModelViewProjectionRelativeToEye(this);
      return this._modelViewProjectionRelativeToEye;
    }
  },
  modelViewInfiniteProjection: {
    get: function() {
      cleanModelViewInfiniteProjection(this);
      return this._modelViewInfiniteProjection;
    }
  },
  normal: {
    get: function() {
      cleanNormal(this);
      return this._normal;
    }
  },
  normal3D: {
    get: function() {
      cleanNormal3D(this);
      return this._normal3D;
    }
  },
  inverseNormal: {
    get: function() {
      cleanInverseNormal(this);
      return this._inverseNormal;
    }
  },
  inverseNormal3D: {
    get: function() {
      cleanInverseNormal3D(this);
      return this._inverseNormal3D;
    }
  },
  entireFrustum: {
    get: function() {
      return this._entireFrustum;
    }
  },
  currentFrustum: {
    get: function() {
      return this._currentFrustum;
    }
  },
  frustumPlanes: {
    get: function() {
      return this._frustumPlanes;
    }
  },
  farDepthFromNearPlusOne: {
    get: function() {
      return this._farDepthFromNearPlusOne;
    }
  },
  log2FarDepthFromNearPlusOne: {
    get: function() {
      return this._log2FarDepthFromNearPlusOne;
    }
  },
  oneOverLog2FarDepthFromNearPlusOne: {
    get: function() {
      return this._oneOverLog2FarDepthFromNearPlusOne;
    }
  },
  eyeHeight: {
    get: function() {
      return this._eyeHeight;
    }
  },
  eyeHeight2D: {
    get: function() {
      return this._eyeHeight2D;
    }
  },
  sunPositionWC: {
    get: function() {
      return this._sunPositionWC;
    }
  },
  sunPositionColumbusView: {
    get: function() {
      return this._sunPositionColumbusView;
    }
  },
  sunDirectionWC: {
    get: function() {
      return this._sunDirectionWC;
    }
  },
  sunDirectionEC: {
    get: function() {
      return this._sunDirectionEC;
    }
  },
  moonDirectionEC: {
    get: function() {
      return this._moonDirectionEC;
    }
  },
  lightDirectionWC: {
    get: function() {
      return this._lightDirectionWC;
    }
  },
  lightDirectionEC: {
    get: function() {
      return this._lightDirectionEC;
    }
  },
  lightColor: {
    get: function() {
      return this._lightColor;
    }
  },
  lightColorHdr: {
    get: function() {
      return this._lightColorHdr;
    }
  },
  encodedCameraPositionMCHigh: {
    get: function() {
      cleanEncodedCameraPositionMC(this);
      return this._encodedCameraPositionMC.high;
    }
  },
  encodedCameraPositionMCLow: {
    get: function() {
      cleanEncodedCameraPositionMC(this);
      return this._encodedCameraPositionMC.low;
    }
  },
  temeToPseudoFixedMatrix: {
    get: function() {
      return this._temeToPseudoFixed;
    }
  },
  pixelRatio: {
    get: function() {
      return this._pixelRatio;
    }
  },
  fogDensity: {
    get: function() {
      return this._fogDensity;
    }
  },
  geometricToleranceOverMeter: {
    get: function() {
      return this._geometricToleranceOverMeter;
    }
  },
  pass: {
    get: function() {
      return this._pass;
    }
  },
  backgroundColor: {
    get: function() {
      return this._backgroundColor;
    }
  },
  brdfLut: {
    get: function() {
      return this._brdfLut;
    }
  },
  environmentMap: {
    get: function() {
      return this._environmentMap;
    }
  },
  sphericalHarmonicCoefficients: {
    get: function() {
      return this._sphericalHarmonicCoefficients;
    }
  },
  specularEnvironmentMaps: {
    get: function() {
      return this._specularEnvironmentMaps;
    }
  },
  specularEnvironmentMapsDimensions: {
    get: function() {
      return this._specularEnvironmentMapsDimensions;
    }
  },
  specularEnvironmentMapsMaximumLOD: {
    get: function() {
      return this._specularEnvironmentMapsMaximumLOD;
    }
  },
  imagerySplitPosition: {
    get: function() {
      deprecationWarning_default(
        "UniformState.imagerySplitPosition",
        "czm_imagerySplitPosition has been deprecated in Cesium 1.92. It will be removed in Cesium 1.94. Use czm_splitPosition instead."
      );
      return this._splitPosition;
    }
  },
  splitPosition: {
    get: function() {
      return this._splitPosition;
    }
  },
  minimumDisableDepthTestDistance: {
    get: function() {
      return this._minimumDisableDepthTestDistance;
    }
  },
  invertClassificationColor: {
    get: function() {
      return this._invertClassificationColor;
    }
  },
  orthographicIn3D: {
    get: function() {
      return this._orthographicIn3D;
    }
  },
  ellipsoid: {
    get: function() {
      return defaultValue_default(this._ellipsoid, Ellipsoid_default.WGS84);
    }
  }
});
function setView(uniformState, matrix) {
  Matrix4_default.clone(matrix, uniformState._view);
  Matrix4_default.getMatrix3(matrix, uniformState._viewRotation);
  uniformState._view3DDirty = true;
  uniformState._inverseView3DDirty = true;
  uniformState._modelViewDirty = true;
  uniformState._modelView3DDirty = true;
  uniformState._modelViewRelativeToEyeDirty = true;
  uniformState._inverseModelViewDirty = true;
  uniformState._inverseModelView3DDirty = true;
  uniformState._viewProjectionDirty = true;
  uniformState._inverseViewProjectionDirty = true;
  uniformState._modelViewProjectionDirty = true;
  uniformState._modelViewProjectionRelativeToEyeDirty = true;
  uniformState._modelViewInfiniteProjectionDirty = true;
  uniformState._normalDirty = true;
  uniformState._inverseNormalDirty = true;
  uniformState._normal3DDirty = true;
  uniformState._inverseNormal3DDirty = true;
}
function setInverseView(uniformState, matrix) {
  Matrix4_default.clone(matrix, uniformState._inverseView);
  Matrix4_default.getMatrix3(matrix, uniformState._inverseViewRotation);
}
function setProjection(uniformState, matrix) {
  Matrix4_default.clone(matrix, uniformState._projection);
  uniformState._inverseProjectionDirty = true;
  uniformState._viewProjectionDirty = true;
  uniformState._inverseViewProjectionDirty = true;
  uniformState._modelViewProjectionDirty = true;
  uniformState._modelViewProjectionRelativeToEyeDirty = true;
}
function setInfiniteProjection(uniformState, matrix) {
  Matrix4_default.clone(matrix, uniformState._infiniteProjection);
  uniformState._modelViewInfiniteProjectionDirty = true;
}
function setCamera(uniformState, camera) {
  Cartesian3_default.clone(camera.positionWC, uniformState._cameraPosition);
  Cartesian3_default.clone(camera.directionWC, uniformState._cameraDirection);
  Cartesian3_default.clone(camera.rightWC, uniformState._cameraRight);
  Cartesian3_default.clone(camera.upWC, uniformState._cameraUp);
  const positionCartographic = camera.positionCartographic;
  if (!defined_default(positionCartographic)) {
    uniformState._eyeHeight = -uniformState._ellipsoid.maximumRadius;
  } else {
    uniformState._eyeHeight = positionCartographic.height;
  }
  uniformState._encodedCameraPositionMCDirty = true;
}
var transformMatrix = new Matrix3_default();
var sunCartographicScratch = new Cartographic_default();
function setSunAndMoonDirections(uniformState, frameState) {
  if (!defined_default(
    Transforms_default.computeIcrfToFixedMatrix(frameState.time, transformMatrix)
  )) {
    transformMatrix = Transforms_default.computeTemeToPseudoFixedMatrix(
      frameState.time,
      transformMatrix
    );
  }
  let position = Simon1994PlanetaryPositions_default.computeSunPositionInEarthInertialFrame(
    frameState.time,
    uniformState._sunPositionWC
  );
  Matrix3_default.multiplyByVector(transformMatrix, position, position);
  Cartesian3_default.normalize(position, uniformState._sunDirectionWC);
  position = Matrix3_default.multiplyByVector(
    uniformState.viewRotation3D,
    position,
    uniformState._sunDirectionEC
  );
  Cartesian3_default.normalize(position, position);
  position = Simon1994PlanetaryPositions_default.computeMoonPositionInEarthInertialFrame(
    frameState.time,
    uniformState._moonDirectionEC
  );
  Matrix3_default.multiplyByVector(transformMatrix, position, position);
  Matrix3_default.multiplyByVector(uniformState.viewRotation3D, position, position);
  Cartesian3_default.normalize(position, position);
  const projection = frameState.mapProjection;
  const ellipsoid = projection.ellipsoid;
  const sunCartographic = ellipsoid.cartesianToCartographic(
    uniformState._sunPositionWC,
    sunCartographicScratch
  );
  projection.project(sunCartographic, uniformState._sunPositionColumbusView);
}
UniformState.prototype.updateCamera = function(camera) {
  setView(this, camera.viewMatrix);
  setInverseView(this, camera.inverseViewMatrix);
  setCamera(this, camera);
  this._entireFrustum.x = camera.frustum.near;
  this._entireFrustum.y = camera.frustum.far;
  this.updateFrustum(camera.frustum);
  this._orthographicIn3D = this._mode !== SceneMode_default.SCENE2D && camera.frustum instanceof OrthographicFrustum_default;
};
UniformState.prototype.updateFrustum = function(frustum) {
  setProjection(this, frustum.projectionMatrix);
  if (defined_default(frustum.infiniteProjectionMatrix)) {
    setInfiniteProjection(this, frustum.infiniteProjectionMatrix);
  }
  this._currentFrustum.x = frustum.near;
  this._currentFrustum.y = frustum.far;
  this._farDepthFromNearPlusOne = frustum.far - frustum.near + 1;
  this._log2FarDepthFromNearPlusOne = Math_default.log2(
    this._farDepthFromNearPlusOne
  );
  this._oneOverLog2FarDepthFromNearPlusOne = 1 / this._log2FarDepthFromNearPlusOne;
  if (defined_default(frustum._offCenterFrustum)) {
    frustum = frustum._offCenterFrustum;
  }
  this._frustumPlanes.x = frustum.top;
  this._frustumPlanes.y = frustum.bottom;
  this._frustumPlanes.z = frustum.left;
  this._frustumPlanes.w = frustum.right;
};
UniformState.prototype.updatePass = function(pass) {
  this._pass = pass;
};
var EMPTY_ARRAY = [];
var defaultLight = new SunLight_default();
UniformState.prototype.update = function(frameState) {
  this._mode = frameState.mode;
  this._mapProjection = frameState.mapProjection;
  this._ellipsoid = frameState.mapProjection.ellipsoid;
  this._pixelRatio = frameState.pixelRatio;
  const camera = frameState.camera;
  this.updateCamera(camera);
  if (frameState.mode === SceneMode_default.SCENE2D) {
    this._frustum2DWidth = camera.frustum.right - camera.frustum.left;
    this._eyeHeight2D.x = this._frustum2DWidth * 0.5;
    this._eyeHeight2D.y = this._eyeHeight2D.x * this._eyeHeight2D.x;
  } else {
    this._frustum2DWidth = 0;
    this._eyeHeight2D.x = 0;
    this._eyeHeight2D.y = 0;
  }
  setSunAndMoonDirections(this, frameState);
  const light = defaultValue_default(frameState.light, defaultLight);
  if (light instanceof SunLight_default) {
    this._lightDirectionWC = Cartesian3_default.clone(
      this._sunDirectionWC,
      this._lightDirectionWC
    );
    this._lightDirectionEC = Cartesian3_default.clone(
      this._sunDirectionEC,
      this._lightDirectionEC
    );
  } else {
    this._lightDirectionWC = Cartesian3_default.normalize(
      Cartesian3_default.negate(light.direction, this._lightDirectionWC),
      this._lightDirectionWC
    );
    this._lightDirectionEC = Matrix3_default.multiplyByVector(
      this.viewRotation3D,
      this._lightDirectionWC,
      this._lightDirectionEC
    );
  }
  const lightColor = light.color;
  let lightColorHdr = Cartesian3_default.fromElements(
    lightColor.red,
    lightColor.green,
    lightColor.blue,
    this._lightColorHdr
  );
  lightColorHdr = Cartesian3_default.multiplyByScalar(
    lightColorHdr,
    light.intensity,
    lightColorHdr
  );
  const maximumComponent = Cartesian3_default.maximumComponent(lightColorHdr);
  if (maximumComponent > 1) {
    Cartesian3_default.divideByScalar(
      lightColorHdr,
      maximumComponent,
      this._lightColor
    );
  } else {
    Cartesian3_default.clone(lightColorHdr, this._lightColor);
  }
  const brdfLutGenerator = frameState.brdfLutGenerator;
  const brdfLut = defined_default(brdfLutGenerator) ? brdfLutGenerator.colorTexture : void 0;
  this._brdfLut = brdfLut;
  this._environmentMap = defaultValue_default(
    frameState.environmentMap,
    frameState.context.defaultCubeMap
  );
  this._sphericalHarmonicCoefficients = defaultValue_default(
    frameState.sphericalHarmonicCoefficients,
    EMPTY_ARRAY
  );
  this._specularEnvironmentMaps = frameState.specularEnvironmentMaps;
  this._specularEnvironmentMapsMaximumLOD = frameState.specularEnvironmentMapsMaximumLOD;
  if (defined_default(this._specularEnvironmentMaps)) {
    Cartesian2_default.clone(
      this._specularEnvironmentMaps.dimensions,
      this._specularEnvironmentMapsDimensions
    );
  }
  this._fogDensity = frameState.fog.density;
  this._invertClassificationColor = frameState.invertClassificationColor;
  this._frameState = frameState;
  this._temeToPseudoFixed = Transforms_default.computeTemeToPseudoFixedMatrix(
    frameState.time,
    this._temeToPseudoFixed
  );
  this._splitPosition = frameState.splitPosition * frameState.context.drawingBufferWidth;
  const fov = camera.frustum.fov;
  const viewport = this._viewport;
  let pixelSizePerMeter;
  if (defined_default(fov)) {
    if (viewport.height > viewport.width) {
      pixelSizePerMeter = Math.tan(0.5 * fov) * 2 / viewport.height;
    } else {
      pixelSizePerMeter = Math.tan(0.5 * fov) * 2 / viewport.width;
    }
  } else {
    pixelSizePerMeter = 1 / Math.max(viewport.width, viewport.height);
  }
  this._geometricToleranceOverMeter = pixelSizePerMeter * frameState.maximumScreenSpaceError;
  Color_default.clone(frameState.backgroundColor, this._backgroundColor);
  this._minimumDisableDepthTestDistance = frameState.minimumDisableDepthTestDistance;
  this._minimumDisableDepthTestDistance *= this._minimumDisableDepthTestDistance;
  if (this._minimumDisableDepthTestDistance === Number.POSITIVE_INFINITY) {
    this._minimumDisableDepthTestDistance = -1;
  }
};
function cleanViewport(uniformState) {
  if (uniformState._viewportDirty) {
    const v7 = uniformState._viewport;
    Matrix4_default.computeOrthographicOffCenter(
      v7.x,
      v7.x + v7.width,
      v7.y,
      v7.y + v7.height,
      0,
      1,
      uniformState._viewportOrthographicMatrix
    );
    Matrix4_default.computeViewportTransformation(
      v7,
      0,
      1,
      uniformState._viewportTransformation
    );
    uniformState._viewportDirty = false;
  }
}
function cleanInverseProjection(uniformState) {
  if (uniformState._inverseProjectionDirty) {
    uniformState._inverseProjectionDirty = false;
    if (uniformState._mode !== SceneMode_default.SCENE2D && uniformState._mode !== SceneMode_default.MORPHING && !uniformState._orthographicIn3D) {
      Matrix4_default.inverse(
        uniformState._projection,
        uniformState._inverseProjection
      );
    } else {
      Matrix4_default.clone(Matrix4_default.ZERO, uniformState._inverseProjection);
    }
  }
}
function cleanModelView(uniformState) {
  if (uniformState._modelViewDirty) {
    uniformState._modelViewDirty = false;
    Matrix4_default.multiplyTransformation(
      uniformState._view,
      uniformState._model,
      uniformState._modelView
    );
  }
}
function cleanModelView3D(uniformState) {
  if (uniformState._modelView3DDirty) {
    uniformState._modelView3DDirty = false;
    Matrix4_default.multiplyTransformation(
      uniformState.view3D,
      uniformState._model,
      uniformState._modelView3D
    );
  }
}
function cleanInverseModelView(uniformState) {
  if (uniformState._inverseModelViewDirty) {
    uniformState._inverseModelViewDirty = false;
    Matrix4_default.inverse(uniformState.modelView, uniformState._inverseModelView);
  }
}
function cleanInverseModelView3D(uniformState) {
  if (uniformState._inverseModelView3DDirty) {
    uniformState._inverseModelView3DDirty = false;
    Matrix4_default.inverse(uniformState.modelView3D, uniformState._inverseModelView3D);
  }
}
function cleanViewProjection(uniformState) {
  if (uniformState._viewProjectionDirty) {
    uniformState._viewProjectionDirty = false;
    Matrix4_default.multiply(
      uniformState._projection,
      uniformState._view,
      uniformState._viewProjection
    );
  }
}
function cleanInverseViewProjection(uniformState) {
  if (uniformState._inverseViewProjectionDirty) {
    uniformState._inverseViewProjectionDirty = false;
    Matrix4_default.inverse(
      uniformState.viewProjection,
      uniformState._inverseViewProjection
    );
  }
}
function cleanModelViewProjection(uniformState) {
  if (uniformState._modelViewProjectionDirty) {
    uniformState._modelViewProjectionDirty = false;
    Matrix4_default.multiply(
      uniformState._projection,
      uniformState.modelView,
      uniformState._modelViewProjection
    );
  }
}
function cleanModelViewRelativeToEye(uniformState) {
  if (uniformState._modelViewRelativeToEyeDirty) {
    uniformState._modelViewRelativeToEyeDirty = false;
    const mv = uniformState.modelView;
    const mvRte = uniformState._modelViewRelativeToEye;
    mvRte[0] = mv[0];
    mvRte[1] = mv[1];
    mvRte[2] = mv[2];
    mvRte[3] = mv[3];
    mvRte[4] = mv[4];
    mvRte[5] = mv[5];
    mvRte[6] = mv[6];
    mvRte[7] = mv[7];
    mvRte[8] = mv[8];
    mvRte[9] = mv[9];
    mvRte[10] = mv[10];
    mvRte[11] = mv[11];
    mvRte[12] = 0;
    mvRte[13] = 0;
    mvRte[14] = 0;
    mvRte[15] = mv[15];
  }
}
function cleanInverseModelViewProjection(uniformState) {
  if (uniformState._inverseModelViewProjectionDirty) {
    uniformState._inverseModelViewProjectionDirty = false;
    Matrix4_default.inverse(
      uniformState.modelViewProjection,
      uniformState._inverseModelViewProjection
    );
  }
}
function cleanModelViewProjectionRelativeToEye(uniformState) {
  if (uniformState._modelViewProjectionRelativeToEyeDirty) {
    uniformState._modelViewProjectionRelativeToEyeDirty = false;
    Matrix4_default.multiply(
      uniformState._projection,
      uniformState.modelViewRelativeToEye,
      uniformState._modelViewProjectionRelativeToEye
    );
  }
}
function cleanModelViewInfiniteProjection(uniformState) {
  if (uniformState._modelViewInfiniteProjectionDirty) {
    uniformState._modelViewInfiniteProjectionDirty = false;
    Matrix4_default.multiply(
      uniformState._infiniteProjection,
      uniformState.modelView,
      uniformState._modelViewInfiniteProjection
    );
  }
}
function cleanNormal(uniformState) {
  if (uniformState._normalDirty) {
    uniformState._normalDirty = false;
    const m = uniformState._normal;
    Matrix4_default.getMatrix3(uniformState.inverseModelView, m);
    Matrix3_default.getRotation(m, m);
    Matrix3_default.transpose(m, m);
  }
}
function cleanNormal3D(uniformState) {
  if (uniformState._normal3DDirty) {
    uniformState._normal3DDirty = false;
    const m = uniformState._normal3D;
    Matrix4_default.getMatrix3(uniformState.inverseModelView3D, m);
    Matrix3_default.getRotation(m, m);
    Matrix3_default.transpose(m, m);
  }
}
function cleanInverseNormal(uniformState) {
  if (uniformState._inverseNormalDirty) {
    uniformState._inverseNormalDirty = false;
    Matrix4_default.getMatrix3(
      uniformState.inverseModelView,
      uniformState._inverseNormal
    );
    Matrix3_default.getRotation(
      uniformState._inverseNormal,
      uniformState._inverseNormal
    );
  }
}
function cleanInverseNormal3D(uniformState) {
  if (uniformState._inverseNormal3DDirty) {
    uniformState._inverseNormal3DDirty = false;
    Matrix4_default.getMatrix3(
      uniformState.inverseModelView3D,
      uniformState._inverseNormal3D
    );
    Matrix3_default.getRotation(
      uniformState._inverseNormal3D,
      uniformState._inverseNormal3D
    );
  }
}
var cameraPositionMC = new Cartesian3_default();
function cleanEncodedCameraPositionMC(uniformState) {
  if (uniformState._encodedCameraPositionMCDirty) {
    uniformState._encodedCameraPositionMCDirty = false;
    Matrix4_default.multiplyByPoint(
      uniformState.inverseModel,
      uniformState._cameraPosition,
      cameraPositionMC
    );
    EncodedCartesian3_default.fromCartesian(
      cameraPositionMC,
      uniformState._encodedCameraPositionMC
    );
  }
}
var view2Dto3DPScratch = new Cartesian3_default();
var view2Dto3DRScratch = new Cartesian3_default();
var view2Dto3DUScratch = new Cartesian3_default();
var view2Dto3DDScratch = new Cartesian3_default();
var view2Dto3DCartographicScratch = new Cartographic_default();
var view2Dto3DCartesian3Scratch = new Cartesian3_default();
var view2Dto3DMatrix4Scratch = new Matrix4_default();
function view2Dto3D(position2D, direction2D, right2D, up2D, frustum2DWidth, mode2, projection, result) {
  const p2 = view2Dto3DPScratch;
  p2.x = position2D.y;
  p2.y = position2D.z;
  p2.z = position2D.x;
  const r2 = view2Dto3DRScratch;
  r2.x = right2D.y;
  r2.y = right2D.z;
  r2.z = right2D.x;
  const u3 = view2Dto3DUScratch;
  u3.x = up2D.y;
  u3.y = up2D.z;
  u3.z = up2D.x;
  const d = view2Dto3DDScratch;
  d.x = direction2D.y;
  d.y = direction2D.z;
  d.z = direction2D.x;
  if (mode2 === SceneMode_default.SCENE2D) {
    p2.z = frustum2DWidth * 0.5;
  }
  const cartographic2 = projection.unproject(p2, view2Dto3DCartographicScratch);
  cartographic2.longitude = Math_default.clamp(
    cartographic2.longitude,
    -Math.PI,
    Math.PI
  );
  cartographic2.latitude = Math_default.clamp(
    cartographic2.latitude,
    -Math_default.PI_OVER_TWO,
    Math_default.PI_OVER_TWO
  );
  const ellipsoid = projection.ellipsoid;
  const position3D = ellipsoid.cartographicToCartesian(
    cartographic2,
    view2Dto3DCartesian3Scratch
  );
  const enuToFixed = Transforms_default.eastNorthUpToFixedFrame(
    position3D,
    ellipsoid,
    view2Dto3DMatrix4Scratch
  );
  Matrix4_default.multiplyByPointAsVector(enuToFixed, r2, r2);
  Matrix4_default.multiplyByPointAsVector(enuToFixed, u3, u3);
  Matrix4_default.multiplyByPointAsVector(enuToFixed, d, d);
  if (!defined_default(result)) {
    result = new Matrix4_default();
  }
  result[0] = r2.x;
  result[1] = u3.x;
  result[2] = -d.x;
  result[3] = 0;
  result[4] = r2.y;
  result[5] = u3.y;
  result[6] = -d.y;
  result[7] = 0;
  result[8] = r2.z;
  result[9] = u3.z;
  result[10] = -d.z;
  result[11] = 0;
  result[12] = -Cartesian3_default.dot(r2, position3D);
  result[13] = -Cartesian3_default.dot(u3, position3D);
  result[14] = Cartesian3_default.dot(d, position3D);
  result[15] = 1;
  return result;
}
function updateView3D(that) {
  if (that._view3DDirty) {
    if (that._mode === SceneMode_default.SCENE3D) {
      Matrix4_default.clone(that._view, that._view3D);
    } else {
      view2Dto3D(
        that._cameraPosition,
        that._cameraDirection,
        that._cameraRight,
        that._cameraUp,
        that._frustum2DWidth,
        that._mode,
        that._mapProjection,
        that._view3D
      );
    }
    Matrix4_default.getMatrix3(that._view3D, that._viewRotation3D);
    that._view3DDirty = false;
  }
}
function updateInverseView3D(that) {
  if (that._inverseView3DDirty) {
    Matrix4_default.inverseTransformation(that.view3D, that._inverseView3D);
    Matrix4_default.getMatrix3(that._inverseView3D, that._inverseViewRotation3D);
    that._inverseView3DDirty = false;
  }
}
var UniformState_default = UniformState;

// node_modules/cesium/Source/Renderer/Context.js
function errorToString(gl, error) {
  let message = "WebGL Error:  ";
  switch (error) {
    case gl.INVALID_ENUM:
      message += "INVALID_ENUM";
      break;
    case gl.INVALID_VALUE:
      message += "INVALID_VALUE";
      break;
    case gl.INVALID_OPERATION:
      message += "INVALID_OPERATION";
      break;
    case gl.OUT_OF_MEMORY:
      message += "OUT_OF_MEMORY";
      break;
    case gl.CONTEXT_LOST_WEBGL:
      message += "CONTEXT_LOST_WEBGL lost";
      break;
    default:
      message += `Unknown (${error})`;
  }
  return message;
}
function createErrorMessage(gl, glFunc, glFuncArguments, error) {
  let message = `${errorToString(gl, error)}: ${glFunc.name}(`;
  for (let i2 = 0; i2 < glFuncArguments.length; ++i2) {
    if (i2 !== 0) {
      message += ", ";
    }
    message += glFuncArguments[i2];
  }
  message += ");";
  return message;
}
function throwOnError(gl, glFunc, glFuncArguments) {
  const error = gl.getError();
  if (error !== gl.NO_ERROR) {
    throw new RuntimeError_default(
      createErrorMessage(gl, glFunc, glFuncArguments, error)
    );
  }
}
function makeGetterSetter(gl, propertyName, logFunction) {
  return {
    get: function() {
      const value = gl[propertyName];
      logFunction(gl, `get: ${propertyName}`, value);
      return gl[propertyName];
    },
    set: function(value) {
      gl[propertyName] = value;
      logFunction(gl, `set: ${propertyName}`, value);
    }
  };
}
function wrapGL(gl, logFunction) {
  if (!defined_default(logFunction)) {
    return gl;
  }
  function wrapFunction2(property) {
    return function() {
      const result = property.apply(gl, arguments);
      logFunction(gl, property, arguments);
      return result;
    };
  }
  const glWrapper = {};
  for (const propertyName in gl) {
    const property = gl[propertyName];
    if (property instanceof Function) {
      glWrapper[propertyName] = wrapFunction2(property);
    } else {
      Object.defineProperty(
        glWrapper,
        propertyName,
        makeGetterSetter(gl, propertyName, logFunction)
      );
    }
  }
  return glWrapper;
}
function getExtension(gl, names) {
  const length3 = names.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const extension = gl.getExtension(names[i2]);
    if (extension) {
      return extension;
    }
  }
  return void 0;
}
function Context(canvas, options) {
  if (typeof WebGLRenderingContext === "undefined") {
    throw new RuntimeError_default(
      "The browser does not support WebGL.  Visit http://get.webgl.org."
    );
  }
  Check_default.defined("canvas", canvas);
  this._canvas = canvas;
  options = clone_default(options, true);
  options = defaultValue_default(options, {});
  options.allowTextureFilterAnisotropic = defaultValue_default(
    options.allowTextureFilterAnisotropic,
    true
  );
  const webglOptions = defaultValue_default(options.webgl, {});
  webglOptions.alpha = defaultValue_default(webglOptions.alpha, false);
  webglOptions.stencil = defaultValue_default(webglOptions.stencil, true);
  const requestWebgl2 = defaultValue_default(options.requestWebgl2, false) && typeof WebGL2RenderingContext !== "undefined";
  let webgl2 = false;
  let glContext;
  const getWebGLStub = options.getWebGLStub;
  if (!defined_default(getWebGLStub)) {
    if (requestWebgl2) {
      glContext = canvas.getContext("webgl2", webglOptions) || canvas.getContext("experimental-webgl2", webglOptions) || void 0;
      if (defined_default(glContext)) {
        webgl2 = true;
      }
    }
    if (!defined_default(glContext)) {
      glContext = canvas.getContext("webgl", webglOptions) || canvas.getContext("experimental-webgl", webglOptions) || void 0;
    }
    if (!defined_default(glContext)) {
      throw new RuntimeError_default(
        "The browser supports WebGL, but initialization failed."
      );
    }
  } else {
    glContext = getWebGLStub(canvas, webglOptions);
  }
  this._originalGLContext = glContext;
  this._gl = glContext;
  this._webgl2 = webgl2;
  this._id = createGuid_default();
  this.validateFramebuffer = false;
  this.validateShaderProgram = false;
  this.logShaderCompilation = false;
  this._throwOnWebGLError = false;
  this._shaderCache = new ShaderCache_default(this);
  this._textureCache = new TextureCache_default();
  const gl = glContext;
  this._stencilBits = gl.getParameter(gl.STENCIL_BITS);
  ContextLimits_default._maximumCombinedTextureImageUnits = gl.getParameter(
    gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS
  );
  ContextLimits_default._maximumCubeMapSize = gl.getParameter(
    gl.MAX_CUBE_MAP_TEXTURE_SIZE
  );
  ContextLimits_default._maximumFragmentUniformVectors = gl.getParameter(
    gl.MAX_FRAGMENT_UNIFORM_VECTORS
  );
  ContextLimits_default._maximumTextureImageUnits = gl.getParameter(
    gl.MAX_TEXTURE_IMAGE_UNITS
  );
  ContextLimits_default._maximumRenderbufferSize = gl.getParameter(
    gl.MAX_RENDERBUFFER_SIZE
  );
  ContextLimits_default._maximumTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
  ContextLimits_default._maximumVaryingVectors = gl.getParameter(
    gl.MAX_VARYING_VECTORS
  );
  ContextLimits_default._maximumVertexAttributes = gl.getParameter(
    gl.MAX_VERTEX_ATTRIBS
  );
  ContextLimits_default._maximumVertexTextureImageUnits = gl.getParameter(
    gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS
  );
  ContextLimits_default._maximumVertexUniformVectors = gl.getParameter(
    gl.MAX_VERTEX_UNIFORM_VECTORS
  );
  ContextLimits_default._maximumSamples = this._webgl2 ? gl.getParameter(gl.MAX_SAMPLES) : 0;
  const aliasedLineWidthRange = gl.getParameter(gl.ALIASED_LINE_WIDTH_RANGE);
  ContextLimits_default._minimumAliasedLineWidth = aliasedLineWidthRange[0];
  ContextLimits_default._maximumAliasedLineWidth = aliasedLineWidthRange[1];
  const aliasedPointSizeRange = gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE);
  ContextLimits_default._minimumAliasedPointSize = aliasedPointSizeRange[0];
  ContextLimits_default._maximumAliasedPointSize = aliasedPointSizeRange[1];
  const maximumViewportDimensions = gl.getParameter(gl.MAX_VIEWPORT_DIMS);
  ContextLimits_default._maximumViewportWidth = maximumViewportDimensions[0];
  ContextLimits_default._maximumViewportHeight = maximumViewportDimensions[1];
  const highpFloat = gl.getShaderPrecisionFormat(
    gl.FRAGMENT_SHADER,
    gl.HIGH_FLOAT
  );
  ContextLimits_default._highpFloatSupported = highpFloat.precision !== 0;
  const highpInt = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_INT);
  ContextLimits_default._highpIntSupported = highpInt.rangeMax !== 0;
  this._antialias = gl.getContextAttributes().antialias;
  this._standardDerivatives = !!getExtension(gl, ["OES_standard_derivatives"]);
  this._blendMinmax = !!getExtension(gl, ["EXT_blend_minmax"]);
  this._elementIndexUint = !!getExtension(gl, ["OES_element_index_uint"]);
  this._depthTexture = !!getExtension(gl, [
    "WEBGL_depth_texture",
    "WEBKIT_WEBGL_depth_texture"
  ]);
  this._fragDepth = !!getExtension(gl, ["EXT_frag_depth"]);
  this._debugShaders = getExtension(gl, ["WEBGL_debug_shaders"]);
  this._textureFloat = !!getExtension(gl, ["OES_texture_float"]);
  this._textureHalfFloat = !!getExtension(gl, ["OES_texture_half_float"]);
  this._textureFloatLinear = !!getExtension(gl, ["OES_texture_float_linear"]);
  this._textureHalfFloatLinear = !!getExtension(gl, [
    "OES_texture_half_float_linear"
  ]);
  this._colorBufferFloat = !!getExtension(gl, [
    "EXT_color_buffer_float",
    "WEBGL_color_buffer_float"
  ]);
  this._floatBlend = !!getExtension(gl, ["EXT_float_blend"]);
  this._colorBufferHalfFloat = !!getExtension(gl, [
    "EXT_color_buffer_half_float"
  ]);
  this._s3tc = !!getExtension(gl, [
    "WEBGL_compressed_texture_s3tc",
    "MOZ_WEBGL_compressed_texture_s3tc",
    "WEBKIT_WEBGL_compressed_texture_s3tc"
  ]);
  this._pvrtc = !!getExtension(gl, [
    "WEBGL_compressed_texture_pvrtc",
    "WEBKIT_WEBGL_compressed_texture_pvrtc"
  ]);
  this._astc = !!getExtension(gl, ["WEBGL_compressed_texture_astc"]);
  this._etc = !!getExtension(gl, ["WEBG_compressed_texture_etc"]);
  this._etc1 = !!getExtension(gl, ["WEBGL_compressed_texture_etc1"]);
  this._bc7 = !!getExtension(gl, ["EXT_texture_compression_bptc"]);
  loadKTX2_default.setKTX2SupportedFormats(
    this._s3tc,
    this._pvrtc,
    this._astc,
    this._etc,
    this._etc1,
    this._bc7
  );
  const textureFilterAnisotropic = options.allowTextureFilterAnisotropic ? getExtension(gl, [
    "EXT_texture_filter_anisotropic",
    "WEBKIT_EXT_texture_filter_anisotropic"
  ]) : void 0;
  this._textureFilterAnisotropic = textureFilterAnisotropic;
  ContextLimits_default._maximumTextureFilterAnisotropy = defined_default(
    textureFilterAnisotropic
  ) ? gl.getParameter(textureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1;
  let glCreateVertexArray;
  let glBindVertexArray;
  let glDeleteVertexArray;
  let glDrawElementsInstanced;
  let glDrawArraysInstanced;
  let glVertexAttribDivisor;
  let glDrawBuffers;
  let vertexArrayObject;
  let instancedArrays;
  let drawBuffers;
  if (webgl2) {
    const that = this;
    glCreateVertexArray = function() {
      return that._gl.createVertexArray();
    };
    glBindVertexArray = function(vao) {
      that._gl.bindVertexArray(vao);
    };
    glDeleteVertexArray = function(vao) {
      that._gl.deleteVertexArray(vao);
    };
    glDrawElementsInstanced = function(mode2, count, type, offset2, instanceCount) {
      gl.drawElementsInstanced(mode2, count, type, offset2, instanceCount);
    };
    glDrawArraysInstanced = function(mode2, first, count, instanceCount) {
      gl.drawArraysInstanced(mode2, first, count, instanceCount);
    };
    glVertexAttribDivisor = function(index2, divisor) {
      gl.vertexAttribDivisor(index2, divisor);
    };
    glDrawBuffers = function(buffers) {
      gl.drawBuffers(buffers);
    };
  } else {
    vertexArrayObject = getExtension(gl, ["OES_vertex_array_object"]);
    if (defined_default(vertexArrayObject)) {
      glCreateVertexArray = function() {
        return vertexArrayObject.createVertexArrayOES();
      };
      glBindVertexArray = function(vertexArray) {
        vertexArrayObject.bindVertexArrayOES(vertexArray);
      };
      glDeleteVertexArray = function(vertexArray) {
        vertexArrayObject.deleteVertexArrayOES(vertexArray);
      };
    }
    instancedArrays = getExtension(gl, ["ANGLE_instanced_arrays"]);
    if (defined_default(instancedArrays)) {
      glDrawElementsInstanced = function(mode2, count, type, offset2, instanceCount) {
        instancedArrays.drawElementsInstancedANGLE(
          mode2,
          count,
          type,
          offset2,
          instanceCount
        );
      };
      glDrawArraysInstanced = function(mode2, first, count, instanceCount) {
        instancedArrays.drawArraysInstancedANGLE(
          mode2,
          first,
          count,
          instanceCount
        );
      };
      glVertexAttribDivisor = function(index2, divisor) {
        instancedArrays.vertexAttribDivisorANGLE(index2, divisor);
      };
    }
    drawBuffers = getExtension(gl, ["WEBGL_draw_buffers"]);
    if (defined_default(drawBuffers)) {
      glDrawBuffers = function(buffers) {
        drawBuffers.drawBuffersWEBGL(buffers);
      };
    }
  }
  this.glCreateVertexArray = glCreateVertexArray;
  this.glBindVertexArray = glBindVertexArray;
  this.glDeleteVertexArray = glDeleteVertexArray;
  this.glDrawElementsInstanced = glDrawElementsInstanced;
  this.glDrawArraysInstanced = glDrawArraysInstanced;
  this.glVertexAttribDivisor = glVertexAttribDivisor;
  this.glDrawBuffers = glDrawBuffers;
  this._vertexArrayObject = !!vertexArrayObject;
  this._instancedArrays = !!instancedArrays;
  this._drawBuffers = !!drawBuffers;
  ContextLimits_default._maximumDrawBuffers = this.drawBuffers ? gl.getParameter(WebGLConstants_default.MAX_DRAW_BUFFERS) : 1;
  ContextLimits_default._maximumColorAttachments = this.drawBuffers ? gl.getParameter(WebGLConstants_default.MAX_COLOR_ATTACHMENTS) : 1;
  this._clearColor = new Color_default(0, 0, 0, 0);
  this._clearDepth = 1;
  this._clearStencil = 0;
  const us = new UniformState_default();
  const ps = new PassState_default(this);
  const rs = RenderState_default.fromCache();
  this._defaultPassState = ps;
  this._defaultRenderState = rs;
  this._defaultTexture = void 0;
  this._defaultEmissiveTexture = void 0;
  this._defaultNormalTexture = void 0;
  this._defaultCubeMap = void 0;
  this._us = us;
  this._currentRenderState = rs;
  this._currentPassState = ps;
  this._currentFramebuffer = void 0;
  this._maxFrameTextureUnitIndex = 0;
  this._vertexAttribDivisors = [];
  this._previousDrawInstanced = false;
  for (let i2 = 0; i2 < ContextLimits_default._maximumVertexAttributes; i2++) {
    this._vertexAttribDivisors.push(0);
  }
  this._pickObjects = {};
  this._nextPickColor = new Uint32Array(1);
  this.options = options;
  this.cache = {};
  RenderState_default.apply(gl, rs, ps);
}
var defaultFramebufferMarker = {};
Object.defineProperties(Context.prototype, {
  id: {
    get: function() {
      return this._id;
    }
  },
  webgl2: {
    get: function() {
      return this._webgl2;
    }
  },
  canvas: {
    get: function() {
      return this._canvas;
    }
  },
  shaderCache: {
    get: function() {
      return this._shaderCache;
    }
  },
  textureCache: {
    get: function() {
      return this._textureCache;
    }
  },
  uniformState: {
    get: function() {
      return this._us;
    }
  },
  stencilBits: {
    get: function() {
      return this._stencilBits;
    }
  },
  stencilBuffer: {
    get: function() {
      return this._stencilBits >= 8;
    }
  },
  antialias: {
    get: function() {
      return this._antialias;
    }
  },
  msaa: {
    get: function() {
      return this._webgl2;
    }
  },
  standardDerivatives: {
    get: function() {
      return this._standardDerivatives || this._webgl2;
    }
  },
  floatBlend: {
    get: function() {
      return this._floatBlend;
    }
  },
  blendMinmax: {
    get: function() {
      return this._blendMinmax || this._webgl2;
    }
  },
  elementIndexUint: {
    get: function() {
      return this._elementIndexUint || this._webgl2;
    }
  },
  depthTexture: {
    get: function() {
      return this._depthTexture || this._webgl2;
    }
  },
  floatingPointTexture: {
    get: function() {
      return this._webgl2 || this._textureFloat;
    }
  },
  halfFloatingPointTexture: {
    get: function() {
      return this._webgl2 || this._textureHalfFloat;
    }
  },
  textureFloatLinear: {
    get: function() {
      return this._textureFloatLinear;
    }
  },
  textureHalfFloatLinear: {
    get: function() {
      return this._webgl2 && this._textureFloatLinear || !this._webgl2 && this._textureHalfFloatLinear;
    }
  },
  textureFilterAnisotropic: {
    get: function() {
      return !!this._textureFilterAnisotropic;
    }
  },
  s3tc: {
    get: function() {
      return this._s3tc;
    }
  },
  pvrtc: {
    get: function() {
      return this._pvrtc;
    }
  },
  astc: {
    get: function() {
      return this._astc;
    }
  },
  etc: {
    get: function() {
      return this._etc;
    }
  },
  etc1: {
    get: function() {
      return this._etc1;
    }
  },
  bc7: {
    get: function() {
      return this._bc7;
    }
  },
  supportsBasis: {
    get: function() {
      return this._s3tc || this._pvrtc || this._astc || this._etc || this._etc1 || this._bc7;
    }
  },
  vertexArrayObject: {
    get: function() {
      return this._vertexArrayObject || this._webgl2;
    }
  },
  fragmentDepth: {
    get: function() {
      return this._fragDepth || this._webgl2;
    }
  },
  instancedArrays: {
    get: function() {
      return this._instancedArrays || this._webgl2;
    }
  },
  colorBufferFloat: {
    get: function() {
      return this._colorBufferFloat;
    }
  },
  colorBufferHalfFloat: {
    get: function() {
      return this._webgl2 && this._colorBufferFloat || !this._webgl2 && this._colorBufferHalfFloat;
    }
  },
  drawBuffers: {
    get: function() {
      return this._drawBuffers || this._webgl2;
    }
  },
  debugShaders: {
    get: function() {
      return this._debugShaders;
    }
  },
  throwOnWebGLError: {
    get: function() {
      return this._throwOnWebGLError;
    },
    set: function(value) {
      this._throwOnWebGLError = value;
      this._gl = wrapGL(
        this._originalGLContext,
        value ? throwOnError : void 0
      );
    }
  },
  defaultTexture: {
    get: function() {
      if (this._defaultTexture === void 0) {
        this._defaultTexture = new Texture_default({
          context: this,
          source: {
            width: 1,
            height: 1,
            arrayBufferView: new Uint8Array([255, 255, 255, 255])
          },
          flipY: false
        });
      }
      return this._defaultTexture;
    }
  },
  defaultEmissiveTexture: {
    get: function() {
      if (this._defaultEmissiveTexture === void 0) {
        this._defaultEmissiveTexture = new Texture_default({
          context: this,
          pixelFormat: PixelFormat_default.RGB,
          source: {
            width: 1,
            height: 1,
            arrayBufferView: new Uint8Array([0, 0, 0])
          },
          flipY: false
        });
      }
      return this._defaultEmissiveTexture;
    }
  },
  defaultNormalTexture: {
    get: function() {
      if (this._defaultNormalTexture === void 0) {
        this._defaultNormalTexture = new Texture_default({
          context: this,
          pixelFormat: PixelFormat_default.RGB,
          source: {
            width: 1,
            height: 1,
            arrayBufferView: new Uint8Array([128, 128, 255])
          },
          flipY: false
        });
      }
      return this._defaultNormalTexture;
    }
  },
  defaultCubeMap: {
    get: function() {
      if (this._defaultCubeMap === void 0) {
        const face = {
          width: 1,
          height: 1,
          arrayBufferView: new Uint8Array([255, 255, 255, 255])
        };
        this._defaultCubeMap = new CubeMap_default({
          context: this,
          source: {
            positiveX: face,
            negativeX: face,
            positiveY: face,
            negativeY: face,
            positiveZ: face,
            negativeZ: face
          },
          flipY: false
        });
      }
      return this._defaultCubeMap;
    }
  },
  drawingBufferHeight: {
    get: function() {
      return this._gl.drawingBufferHeight;
    }
  },
  drawingBufferWidth: {
    get: function() {
      return this._gl.drawingBufferWidth;
    }
  },
  defaultFramebuffer: {
    get: function() {
      return defaultFramebufferMarker;
    }
  }
});
function validateFramebuffer(context) {
  if (context.validateFramebuffer) {
    const gl = context._gl;
    const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
    if (status !== gl.FRAMEBUFFER_COMPLETE) {
      let message;
      switch (status) {
        case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
          message = "Framebuffer is not complete.  Incomplete attachment: at least one attachment point with a renderbuffer or texture attached has its attached object no longer in existence or has an attached image with a width or height of zero, or the color attachment point has a non-color-renderable image attached, or the depth attachment point has a non-depth-renderable image attached, or the stencil attachment point has a non-stencil-renderable image attached.  Color-renderable formats include GL_RGBA4, GL_RGB5_A1, and GL_RGB565. GL_DEPTH_COMPONENT16 is the only depth-renderable format. GL_STENCIL_INDEX8 is the only stencil-renderable format.";
          break;
        case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
          message = "Framebuffer is not complete.  Incomplete dimensions: not all attached images have the same width and height.";
          break;
        case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
          message = "Framebuffer is not complete.  Missing attachment: no images are attached to the framebuffer.";
          break;
        case gl.FRAMEBUFFER_UNSUPPORTED:
          message = "Framebuffer is not complete.  Unsupported: the combination of internal formats of the attached images violates an implementation-dependent set of restrictions.";
          break;
      }
      throw new DeveloperError_default(message);
    }
  }
}
function applyRenderState(context, renderState, passState, clear2) {
  const previousRenderState = context._currentRenderState;
  const previousPassState = context._currentPassState;
  context._currentRenderState = renderState;
  context._currentPassState = passState;
  RenderState_default.partialApply(
    context._gl,
    previousRenderState,
    renderState,
    previousPassState,
    passState,
    clear2
  );
}
var scratchBackBufferArray;
if (typeof WebGLRenderingContext !== "undefined") {
  scratchBackBufferArray = [WebGLConstants_default.BACK];
}
function bindFramebuffer(context, framebuffer) {
  if (framebuffer !== context._currentFramebuffer) {
    context._currentFramebuffer = framebuffer;
    let buffers = scratchBackBufferArray;
    if (defined_default(framebuffer)) {
      framebuffer._bind();
      validateFramebuffer(context);
      buffers = framebuffer._getActiveColorAttachments();
    } else {
      const gl = context._gl;
      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
    }
    if (context.drawBuffers) {
      context.glDrawBuffers(buffers);
    }
  }
}
var defaultClearCommand = new ClearCommand_default();
Context.prototype.clear = function(clearCommand, passState) {
  clearCommand = defaultValue_default(clearCommand, defaultClearCommand);
  passState = defaultValue_default(passState, this._defaultPassState);
  const gl = this._gl;
  let bitmask = 0;
  const c14 = clearCommand.color;
  const d = clearCommand.depth;
  const s2 = clearCommand.stencil;
  if (defined_default(c14)) {
    if (!Color_default.equals(this._clearColor, c14)) {
      Color_default.clone(c14, this._clearColor);
      gl.clearColor(c14.red, c14.green, c14.blue, c14.alpha);
    }
    bitmask |= gl.COLOR_BUFFER_BIT;
  }
  if (defined_default(d)) {
    if (d !== this._clearDepth) {
      this._clearDepth = d;
      gl.clearDepth(d);
    }
    bitmask |= gl.DEPTH_BUFFER_BIT;
  }
  if (defined_default(s2)) {
    if (s2 !== this._clearStencil) {
      this._clearStencil = s2;
      gl.clearStencil(s2);
    }
    bitmask |= gl.STENCIL_BUFFER_BIT;
  }
  const rs = defaultValue_default(clearCommand.renderState, this._defaultRenderState);
  applyRenderState(this, rs, passState, true);
  const framebuffer = defaultValue_default(
    clearCommand.framebuffer,
    passState.framebuffer
  );
  bindFramebuffer(this, framebuffer);
  gl.clear(bitmask);
};
function beginDraw(context, framebuffer, passState, shaderProgram, renderState) {
  if (defined_default(framebuffer) && renderState.depthTest) {
    if (renderState.depthTest.enabled && !framebuffer.hasDepthAttachment) {
      throw new DeveloperError_default(
        "The depth test can not be enabled (drawCommand.renderState.depthTest.enabled) because the framebuffer (drawCommand.framebuffer) does not have a depth or depth-stencil renderbuffer."
      );
    }
  }
  bindFramebuffer(context, framebuffer);
  applyRenderState(context, renderState, passState, false);
  shaderProgram._bind();
  context._maxFrameTextureUnitIndex = Math.max(
    context._maxFrameTextureUnitIndex,
    shaderProgram.maximumTextureUnitIndex
  );
}
function continueDraw(context, drawCommand, shaderProgram, uniformMap2) {
  const primitiveType = drawCommand._primitiveType;
  const va = drawCommand._vertexArray;
  let offset2 = drawCommand._offset;
  let count = drawCommand._count;
  const instanceCount = drawCommand.instanceCount;
  if (!PrimitiveType_default.validate(primitiveType)) {
    throw new DeveloperError_default(
      "drawCommand.primitiveType is required and must be valid."
    );
  }
  Check_default.defined("drawCommand.vertexArray", va);
  Check_default.typeOf.number.greaterThanOrEquals("drawCommand.offset", offset2, 0);
  if (defined_default(count)) {
    Check_default.typeOf.number.greaterThanOrEquals("drawCommand.count", count, 0);
  }
  Check_default.typeOf.number.greaterThanOrEquals(
    "drawCommand.instanceCount",
    instanceCount,
    0
  );
  if (instanceCount > 0 && !context.instancedArrays) {
    throw new DeveloperError_default("Instanced arrays extension is not supported");
  }
  context._us.model = defaultValue_default(drawCommand._modelMatrix, Matrix4_default.IDENTITY);
  shaderProgram._setUniforms(
    uniformMap2,
    context._us,
    context.validateShaderProgram
  );
  va._bind();
  const indexBuffer = va.indexBuffer;
  if (defined_default(indexBuffer)) {
    offset2 = offset2 * indexBuffer.bytesPerIndex;
    count = defaultValue_default(count, indexBuffer.numberOfIndices);
    if (instanceCount === 0) {
      context._gl.drawElements(
        primitiveType,
        count,
        indexBuffer.indexDatatype,
        offset2
      );
    } else {
      context.glDrawElementsInstanced(
        primitiveType,
        count,
        indexBuffer.indexDatatype,
        offset2,
        instanceCount
      );
    }
  } else {
    count = defaultValue_default(count, va.numberOfVertices);
    if (instanceCount === 0) {
      context._gl.drawArrays(primitiveType, offset2, count);
    } else {
      context.glDrawArraysInstanced(
        primitiveType,
        offset2,
        count,
        instanceCount
      );
    }
  }
  va._unBind();
}
Context.prototype.draw = function(drawCommand, passState, shaderProgram, uniformMap2) {
  Check_default.defined("drawCommand", drawCommand);
  Check_default.defined("drawCommand.shaderProgram", drawCommand._shaderProgram);
  passState = defaultValue_default(passState, this._defaultPassState);
  const framebuffer = defaultValue_default(
    drawCommand._framebuffer,
    passState.framebuffer
  );
  const renderState = defaultValue_default(
    drawCommand._renderState,
    this._defaultRenderState
  );
  shaderProgram = defaultValue_default(shaderProgram, drawCommand._shaderProgram);
  uniformMap2 = defaultValue_default(uniformMap2, drawCommand._uniformMap);
  beginDraw(this, framebuffer, passState, shaderProgram, renderState);
  continueDraw(this, drawCommand, shaderProgram, uniformMap2);
};
Context.prototype.endFrame = function() {
  const gl = this._gl;
  gl.useProgram(null);
  this._currentFramebuffer = void 0;
  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
  const buffers = scratchBackBufferArray;
  if (this.drawBuffers) {
    this.glDrawBuffers(buffers);
  }
  const length3 = this._maxFrameTextureUnitIndex;
  this._maxFrameTextureUnitIndex = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    gl.activeTexture(gl.TEXTURE0 + i2);
    gl.bindTexture(gl.TEXTURE_2D, null);
    gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);
  }
};
Context.prototype.readPixels = function(readState) {
  const gl = this._gl;
  readState = defaultValue_default(readState, defaultValue_default.EMPTY_OBJECT);
  const x = Math.max(defaultValue_default(readState.x, 0), 0);
  const y = Math.max(defaultValue_default(readState.y, 0), 0);
  const width = defaultValue_default(readState.width, gl.drawingBufferWidth);
  const height = defaultValue_default(readState.height, gl.drawingBufferHeight);
  const framebuffer = readState.framebuffer;
  Check_default.typeOf.number.greaterThan("readState.width", width, 0);
  Check_default.typeOf.number.greaterThan("readState.height", height, 0);
  let pixelDatatype = PixelDatatype_default.UNSIGNED_BYTE;
  if (defined_default(framebuffer) && framebuffer.numberOfColorAttachments > 0) {
    pixelDatatype = framebuffer.getColorTexture(0).pixelDatatype;
  }
  const pixels = PixelFormat_default.createTypedArray(
    PixelFormat_default.RGBA,
    pixelDatatype,
    width,
    height
  );
  bindFramebuffer(this, framebuffer);
  gl.readPixels(
    x,
    y,
    width,
    height,
    PixelFormat_default.RGBA,
    PixelDatatype_default.toWebGLConstant(pixelDatatype, this),
    pixels
  );
  return pixels;
};
var viewportQuadAttributeLocations = {
  position: 0,
  textureCoordinates: 1
};
Context.prototype.getViewportQuadVertexArray = function() {
  let vertexArray = this.cache.viewportQuad_vertexArray;
  if (!defined_default(vertexArray)) {
    const geometry = new Geometry_default({
      attributes: {
        position: new GeometryAttribute_default({
          componentDatatype: ComponentDatatype_default.FLOAT,
          componentsPerAttribute: 2,
          values: [-1, -1, 1, -1, 1, 1, -1, 1]
        }),
        textureCoordinates: new GeometryAttribute_default({
          componentDatatype: ComponentDatatype_default.FLOAT,
          componentsPerAttribute: 2,
          values: [0, 0, 1, 0, 1, 1, 0, 1]
        })
      },
      indices: new Uint16Array([0, 1, 2, 0, 2, 3]),
      primitiveType: PrimitiveType_default.TRIANGLES
    });
    vertexArray = VertexArray_default.fromGeometry({
      context: this,
      geometry,
      attributeLocations: viewportQuadAttributeLocations,
      bufferUsage: BufferUsage_default.STATIC_DRAW,
      interleave: true
    });
    this.cache.viewportQuad_vertexArray = vertexArray;
  }
  return vertexArray;
};
Context.prototype.createViewportQuadCommand = function(fragmentShaderSource, overrides) {
  overrides = defaultValue_default(overrides, defaultValue_default.EMPTY_OBJECT);
  return new DrawCommand_default({
    vertexArray: this.getViewportQuadVertexArray(),
    primitiveType: PrimitiveType_default.TRIANGLES,
    renderState: overrides.renderState,
    shaderProgram: ShaderProgram_default.fromCache({
      context: this,
      vertexShaderSource: ViewportQuadVS_default,
      fragmentShaderSource,
      attributeLocations: viewportQuadAttributeLocations
    }),
    uniformMap: overrides.uniformMap,
    owner: overrides.owner,
    framebuffer: overrides.framebuffer,
    pass: overrides.pass
  });
};
Context.prototype.getObjectByPickColor = function(pickColor) {
  Check_default.defined("pickColor", pickColor);
  return this._pickObjects[pickColor.toRgba()];
};
function PickId(pickObjects, key, color) {
  this._pickObjects = pickObjects;
  this.key = key;
  this.color = color;
}
Object.defineProperties(PickId.prototype, {
  object: {
    get: function() {
      return this._pickObjects[this.key];
    },
    set: function(value) {
      this._pickObjects[this.key] = value;
    }
  }
});
PickId.prototype.destroy = function() {
  delete this._pickObjects[this.key];
  return void 0;
};
Context.prototype.createPickId = function(object2) {
  Check_default.defined("object", object2);
  ++this._nextPickColor[0];
  const key = this._nextPickColor[0];
  if (key === 0) {
    throw new RuntimeError_default("Out of unique Pick IDs.");
  }
  this._pickObjects[key] = object2;
  return new PickId(this._pickObjects, key, Color_default.fromRgba(key));
};
Context.prototype.isDestroyed = function() {
  return false;
};
Context.prototype.destroy = function() {
  const cache = this.cache;
  for (const property in cache) {
    if (cache.hasOwnProperty(property)) {
      const propertyValue = cache[property];
      if (defined_default(propertyValue.destroy)) {
        propertyValue.destroy();
      }
    }
  }
  this._shaderCache = this._shaderCache.destroy();
  this._textureCache = this._textureCache.destroy();
  this._defaultTexture = this._defaultTexture && this._defaultTexture.destroy();
  this._defaultEmissiveTexture = this._defaultEmissiveTexture && this._defaultEmissiveTexture.destroy();
  this._defaultNormalTexture = this._defaultNormalTexture && this._defaultNormalTexture.destroy();
  this._defaultCubeMap = this._defaultCubeMap && this._defaultCubeMap.destroy();
  return destroyObject_default(this);
};
var Context_default = Context;

// node_modules/cesium/Source/Renderer/loadCubeMap.js
function loadCubeMap(context, urls, skipColorSpaceConversion) {
  Check_default.defined("context", context);
  if (!defined_default(urls) || !defined_default(urls.positiveX) || !defined_default(urls.negativeX) || !defined_default(urls.positiveY) || !defined_default(urls.negativeY) || !defined_default(urls.positiveZ) || !defined_default(urls.negativeZ)) {
    throw new DeveloperError_default(
      "urls is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties."
    );
  }
  const flipOptions = {
    flipY: true,
    skipColorSpaceConversion,
    preferImageBitmap: true
  };
  const facePromises = [
    Resource_default.createIfNeeded(urls.positiveX).fetchImage(flipOptions),
    Resource_default.createIfNeeded(urls.negativeX).fetchImage(flipOptions),
    Resource_default.createIfNeeded(urls.positiveY).fetchImage(flipOptions),
    Resource_default.createIfNeeded(urls.negativeY).fetchImage(flipOptions),
    Resource_default.createIfNeeded(urls.positiveZ).fetchImage(flipOptions),
    Resource_default.createIfNeeded(urls.negativeZ).fetchImage(flipOptions)
  ];
  return Promise.all(facePromises).then(function(images) {
    return new CubeMap_default({
      context,
      source: {
        positiveX: images[0],
        negativeX: images[1],
        positiveY: images[2],
        negativeY: images[3],
        positiveZ: images[4],
        negativeZ: images[5]
      }
    });
  });
}
var loadCubeMap_default = loadCubeMap;

// node_modules/cesium/Source/Scene/DiscardMissingTileImagePolicy.js
function DiscardMissingTileImagePolicy(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.missingImageUrl)) {
    throw new DeveloperError_default("options.missingImageUrl is required.");
  }
  if (!defined_default(options.pixelsToCheck)) {
    throw new DeveloperError_default("options.pixelsToCheck is required.");
  }
  this._pixelsToCheck = options.pixelsToCheck;
  this._missingImagePixels = void 0;
  this._missingImageByteLength = void 0;
  this._isReady = false;
  const resource = Resource_default.createIfNeeded(options.missingImageUrl);
  const that = this;
  function success(image) {
    if (defined_default(image.blob)) {
      that._missingImageByteLength = image.blob.size;
    }
    let pixels = getImagePixels_default(image);
    if (options.disableCheckIfAllPixelsAreTransparent) {
      let allAreTransparent = true;
      const width = image.width;
      const pixelsToCheck = options.pixelsToCheck;
      for (let i2 = 0, len = pixelsToCheck.length; allAreTransparent && i2 < len; ++i2) {
        const pos = pixelsToCheck[i2];
        const index2 = pos.x * 4 + pos.y * width;
        const alpha = pixels[index2 + 3];
        if (alpha > 0) {
          allAreTransparent = false;
        }
      }
      if (allAreTransparent) {
        pixels = void 0;
      }
    }
    that._missingImagePixels = pixels;
    that._isReady = true;
  }
  function failure() {
    that._missingImagePixels = void 0;
    that._isReady = true;
  }
  resource.fetchImage({
    preferBlob: true,
    preferImageBitmap: true,
    flipY: true
  }).then(success).catch(failure);
}
DiscardMissingTileImagePolicy.prototype.isReady = function() {
  return this._isReady;
};
DiscardMissingTileImagePolicy.prototype.shouldDiscardImage = function(image) {
  if (!this._isReady) {
    throw new DeveloperError_default(
      "shouldDiscardImage must not be called before the discard policy is ready."
    );
  }
  const pixelsToCheck = this._pixelsToCheck;
  const missingImagePixels = this._missingImagePixels;
  if (!defined_default(missingImagePixels)) {
    return false;
  }
  if (defined_default(image.blob) && image.blob.size !== this._missingImageByteLength) {
    return false;
  }
  const pixels = getImagePixels_default(image);
  const width = image.width;
  for (let i2 = 0, len = pixelsToCheck.length; i2 < len; ++i2) {
    const pos = pixelsToCheck[i2];
    const index2 = pos.x * 4 + pos.y * width;
    for (let offset2 = 0; offset2 < 4; ++offset2) {
      const pixel = index2 + offset2;
      if (pixels[pixel] !== missingImagePixels[pixel]) {
        return false;
      }
    }
  }
  return true;
};
var DiscardMissingTileImagePolicy_default = DiscardMissingTileImagePolicy;

// node_modules/cesium/Source/Scene/ImageryLayerFeatureInfo.js
function ImageryLayerFeatureInfo() {
  this.name = void 0;
  this.description = void 0;
  this.position = void 0;
  this.data = void 0;
  this.imageryLayer = void 0;
}
ImageryLayerFeatureInfo.prototype.configureNameFromProperties = function(properties) {
  let namePropertyPrecedence = 10;
  let nameProperty;
  for (const key in properties) {
    if (properties.hasOwnProperty(key) && properties[key]) {
      const lowerKey = key.toLowerCase();
      if (namePropertyPrecedence > 1 && lowerKey === "name") {
        namePropertyPrecedence = 1;
        nameProperty = key;
      } else if (namePropertyPrecedence > 2 && lowerKey === "title") {
        namePropertyPrecedence = 2;
        nameProperty = key;
      } else if (namePropertyPrecedence > 3 && /name/i.test(key)) {
        namePropertyPrecedence = 3;
        nameProperty = key;
      } else if (namePropertyPrecedence > 4 && /title/i.test(key)) {
        namePropertyPrecedence = 4;
        nameProperty = key;
      }
    }
  }
  if (defined_default(nameProperty)) {
    this.name = properties[nameProperty];
  }
};
ImageryLayerFeatureInfo.prototype.configureDescriptionFromProperties = function(properties) {
  function describe(properties2) {
    let html2 = '<table class="cesium-infoBox-defaultTable">';
    for (const key in properties2) {
      if (properties2.hasOwnProperty(key)) {
        const value = properties2[key];
        if (defined_default(value)) {
          if (typeof value === "object") {
            html2 += `<tr><td>${key}</td><td>${describe(value)}</td></tr>`;
          } else {
            html2 += `<tr><td>${key}</td><td>${value}</td></tr>`;
          }
        }
      }
    }
    html2 += "</table>";
    return html2;
  }
  this.description = describe(properties);
};
var ImageryLayerFeatureInfo_default = ImageryLayerFeatureInfo;

// node_modules/cesium/Source/Scene/ImageryProvider.js
function ImageryProvider() {
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  DeveloperError_default.throwInstantiationError();
}
Object.defineProperties(ImageryProvider.prototype, {
  ready: {
    get: DeveloperError_default.throwInstantiationError
  },
  readyPromise: {
    get: DeveloperError_default.throwInstantiationError
  },
  rectangle: {
    get: DeveloperError_default.throwInstantiationError
  },
  tileWidth: {
    get: DeveloperError_default.throwInstantiationError
  },
  tileHeight: {
    get: DeveloperError_default.throwInstantiationError
  },
  maximumLevel: {
    get: DeveloperError_default.throwInstantiationError
  },
  minimumLevel: {
    get: DeveloperError_default.throwInstantiationError
  },
  tilingScheme: {
    get: DeveloperError_default.throwInstantiationError
  },
  tileDiscardPolicy: {
    get: DeveloperError_default.throwInstantiationError
  },
  errorEvent: {
    get: DeveloperError_default.throwInstantiationError
  },
  credit: {
    get: DeveloperError_default.throwInstantiationError
  },
  proxy: {
    get: DeveloperError_default.throwInstantiationError
  },
  hasAlphaChannel: {
    get: DeveloperError_default.throwInstantiationError
  }
});
ImageryProvider.prototype.getTileCredits = function(x, y, level) {
  DeveloperError_default.throwInstantiationError();
};
ImageryProvider.prototype.requestImage = function(x, y, level, request) {
  DeveloperError_default.throwInstantiationError();
};
ImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  DeveloperError_default.throwInstantiationError();
};
var ktx2Regex4 = /\.ktx2$/i;
ImageryProvider.loadImage = function(imageryProvider, url2) {
  Check_default.defined("url", url2);
  const resource = Resource_default.createIfNeeded(url2);
  if (ktx2Regex4.test(resource.url)) {
    return loadKTX2_default(resource);
  } else if (defined_default(imageryProvider) && defined_default(imageryProvider.tileDiscardPolicy)) {
    return resource.fetchImage({
      preferBlob: true,
      preferImageBitmap: true,
      flipY: true
    });
  }
  return resource.fetchImage({
    preferImageBitmap: true,
    flipY: true
  });
};
var ImageryProvider_default = ImageryProvider;

// node_modules/cesium/Source/Scene/ArcGisMapServerImageryProvider.js
function ArcGisMapServerImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  const resource = Resource_default.createIfNeeded(options.url);
  resource.appendForwardSlash();
  if (defined_default(options.token)) {
    resource.setQueryParameters({
      token: options.token
    });
  }
  this._resource = resource;
  this._tileDiscardPolicy = options.tileDiscardPolicy;
  this._tileWidth = defaultValue_default(options.tileWidth, 256);
  this._tileHeight = defaultValue_default(options.tileHeight, 256);
  this._maximumLevel = options.maximumLevel;
  this._tilingScheme = defaultValue_default(
    options.tilingScheme,
    new GeographicTilingScheme_default({ ellipsoid: options.ellipsoid })
  );
  this._useTiles = defaultValue_default(options.usePreCachedTilesIfAvailable, true);
  this._rectangle = defaultValue_default(
    options.rectangle,
    this._tilingScheme.rectangle
  );
  this._layers = options.layers;
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  this._credit = credit;
  this.enablePickFeatures = defaultValue_default(options.enablePickFeatures, true);
  this._errorEvent = new Event_default();
  this._ready = false;
  this._readyPromise = defer_default();
  const that = this;
  let metadataError;
  function metadataSuccess(data) {
    const tileInfo = data.tileInfo;
    if (!defined_default(tileInfo)) {
      that._useTiles = false;
    } else {
      that._tileWidth = tileInfo.rows;
      that._tileHeight = tileInfo.cols;
      if (tileInfo.spatialReference.wkid === 102100 || tileInfo.spatialReference.wkid === 102113) {
        that._tilingScheme = new WebMercatorTilingScheme_default({
          ellipsoid: options.ellipsoid
        });
      } else if (data.tileInfo.spatialReference.wkid === 4326) {
        that._tilingScheme = new GeographicTilingScheme_default({
          ellipsoid: options.ellipsoid
        });
      } else {
        const message = `Tile spatial reference WKID ${data.tileInfo.spatialReference.wkid} is not supported.`;
        metadataError = TileProviderError_default.handleError(
          metadataError,
          that,
          that._errorEvent,
          message,
          void 0,
          void 0,
          void 0,
          requestMetadata
        );
        if (!metadataError.retry) {
          that._readyPromise.reject(new RuntimeError_default(message));
        }
        return;
      }
      that._maximumLevel = data.tileInfo.lods.length - 1;
      if (defined_default(data.fullExtent)) {
        if (defined_default(data.fullExtent.spatialReference) && defined_default(data.fullExtent.spatialReference.wkid)) {
          if (data.fullExtent.spatialReference.wkid === 102100 || data.fullExtent.spatialReference.wkid === 102113) {
            const projection = new WebMercatorProjection_default();
            const extent = data.fullExtent;
            const sw = projection.unproject(
              new Cartesian3_default(
                Math.max(
                  extent.xmin,
                  -that._tilingScheme.ellipsoid.maximumRadius * Math.PI
                ),
                Math.max(
                  extent.ymin,
                  -that._tilingScheme.ellipsoid.maximumRadius * Math.PI
                ),
                0
              )
            );
            const ne = projection.unproject(
              new Cartesian3_default(
                Math.min(
                  extent.xmax,
                  that._tilingScheme.ellipsoid.maximumRadius * Math.PI
                ),
                Math.min(
                  extent.ymax,
                  that._tilingScheme.ellipsoid.maximumRadius * Math.PI
                ),
                0
              )
            );
            that._rectangle = new Rectangle_default(
              sw.longitude,
              sw.latitude,
              ne.longitude,
              ne.latitude
            );
          } else if (data.fullExtent.spatialReference.wkid === 4326) {
            that._rectangle = Rectangle_default.fromDegrees(
              data.fullExtent.xmin,
              data.fullExtent.ymin,
              data.fullExtent.xmax,
              data.fullExtent.ymax
            );
          } else {
            const extentMessage = `fullExtent.spatialReference WKID ${data.fullExtent.spatialReference.wkid} is not supported.`;
            metadataError = TileProviderError_default.handleError(
              metadataError,
              that,
              that._errorEvent,
              extentMessage,
              void 0,
              void 0,
              void 0,
              requestMetadata
            );
            if (!metadataError.retry) {
              that._readyPromise.reject(new RuntimeError_default(extentMessage));
            }
            return;
          }
        }
      } else {
        that._rectangle = that._tilingScheme.rectangle;
      }
      if (!defined_default(that._tileDiscardPolicy)) {
        that._tileDiscardPolicy = new DiscardMissingTileImagePolicy_default({
          missingImageUrl: buildImageResource(that, 0, 0, that._maximumLevel).url,
          pixelsToCheck: [
            new Cartesian2_default(0, 0),
            new Cartesian2_default(200, 20),
            new Cartesian2_default(20, 200),
            new Cartesian2_default(80, 110),
            new Cartesian2_default(160, 130)
          ],
          disableCheckIfAllPixelsAreTransparent: true
        });
      }
      that._useTiles = true;
    }
    if (defined_default(data.copyrightText) && data.copyrightText.length > 0) {
      that._credit = new Credit_default(data.copyrightText);
    }
    that._ready = true;
    that._readyPromise.resolve(true);
    TileProviderError_default.handleSuccess(metadataError);
  }
  function metadataFailure(e2) {
    const message = `An error occurred while accessing ${that._resource.url}.`;
    metadataError = TileProviderError_default.handleError(
      metadataError,
      that,
      that._errorEvent,
      message,
      void 0,
      void 0,
      void 0,
      requestMetadata
    );
    that._readyPromise.reject(new RuntimeError_default(message));
  }
  function requestMetadata() {
    const resource2 = that._resource.getDerivedResource({
      queryParameters: {
        f: "json"
      }
    });
    resource2.fetchJsonp().then(function(result) {
      metadataSuccess(result);
    }).catch(function(e2) {
      metadataFailure(e2);
    });
  }
  if (this._useTiles) {
    requestMetadata();
  } else {
    this._ready = true;
    this._readyPromise.resolve(true);
  }
}
function buildImageResource(imageryProvider, x, y, level, request) {
  let resource;
  if (imageryProvider._useTiles) {
    resource = imageryProvider._resource.getDerivedResource({
      url: `tile/${level}/${y}/${x}`,
      request
    });
  } else {
    const nativeRectangle = imageryProvider._tilingScheme.tileXYToNativeRectangle(
      x,
      y,
      level
    );
    const bbox2 = `${nativeRectangle.west},${nativeRectangle.south},${nativeRectangle.east},${nativeRectangle.north}`;
    const query = {
      bbox: bbox2,
      size: `${imageryProvider._tileWidth},${imageryProvider._tileHeight}`,
      format: "png32",
      transparent: true,
      f: "image"
    };
    if (imageryProvider._tilingScheme.projection instanceof GeographicProjection_default) {
      query.bboxSR = 4326;
      query.imageSR = 4326;
    } else {
      query.bboxSR = 3857;
      query.imageSR = 3857;
    }
    if (imageryProvider.layers) {
      query.layers = `show:${imageryProvider.layers}`;
    }
    resource = imageryProvider._resource.getDerivedResource({
      url: "export",
      request,
      queryParameters: query
    });
  }
  return resource;
}
Object.defineProperties(ArcGisMapServerImageryProvider.prototype, {
  url: {
    get: function() {
      return this._resource._url;
    }
  },
  token: {
    get: function() {
      return this._resource.queryParameters.token;
    }
  },
  proxy: {
    get: function() {
      return this._resource.proxy;
    }
  },
  tileWidth: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileWidth must not be called before the imagery provider is ready."
        );
      }
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileHeight must not be called before the imagery provider is ready."
        );
      }
      return this._tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "maximumLevel must not be called before the imagery provider is ready."
        );
      }
      return this._maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "minimumLevel must not be called before the imagery provider is ready."
        );
      }
      return 0;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "rectangle must not be called before the imagery provider is ready."
        );
      }
      return this._rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileDiscardPolicy must not be called before the imagery provider is ready."
        );
      }
      return this._tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  usingPrecachedTiles: {
    get: function() {
      return this._useTiles;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return true;
    }
  },
  layers: {
    get: function() {
      return this._layers;
    }
  }
});
ArcGisMapServerImageryProvider.prototype.getTileCredits = function(x, y, level) {
  return void 0;
};
ArcGisMapServerImageryProvider.prototype.requestImage = function(x, y, level, request) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "requestImage must not be called before the imagery provider is ready."
    );
  }
  return ImageryProvider_default.loadImage(
    this,
    buildImageResource(this, x, y, level, request)
  );
};
ArcGisMapServerImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "pickFeatures must not be called before the imagery provider is ready."
    );
  }
  if (!this.enablePickFeatures) {
    return void 0;
  }
  const rectangle = this._tilingScheme.tileXYToNativeRectangle(x, y, level);
  let horizontal;
  let vertical;
  let sr;
  if (this._tilingScheme.projection instanceof GeographicProjection_default) {
    horizontal = Math_default.toDegrees(longitude);
    vertical = Math_default.toDegrees(latitude);
    sr = "4326";
  } else {
    const projected = this._tilingScheme.projection.project(
      new Cartographic_default(longitude, latitude, 0)
    );
    horizontal = projected.x;
    vertical = projected.y;
    sr = "3857";
  }
  let layers = "visible";
  if (defined_default(this._layers)) {
    layers += `:${this._layers}`;
  }
  const query = {
    f: "json",
    tolerance: 2,
    geometryType: "esriGeometryPoint",
    geometry: `${horizontal},${vertical}`,
    mapExtent: `${rectangle.west},${rectangle.south},${rectangle.east},${rectangle.north}`,
    imageDisplay: `${this._tileWidth},${this._tileHeight},96`,
    sr,
    layers
  };
  const resource = this._resource.getDerivedResource({
    url: "identify",
    queryParameters: query
  });
  return resource.fetchJson().then(function(json) {
    const result = [];
    const features = json.results;
    if (!defined_default(features)) {
      return result;
    }
    for (let i2 = 0; i2 < features.length; ++i2) {
      const feature2 = features[i2];
      const featureInfo = new ImageryLayerFeatureInfo_default();
      featureInfo.data = feature2;
      featureInfo.name = feature2.value;
      featureInfo.properties = feature2.attributes;
      featureInfo.configureDescriptionFromProperties(feature2.attributes);
      if (feature2.geometryType === "esriGeometryPoint" && feature2.geometry) {
        const wkid = feature2.geometry.spatialReference && feature2.geometry.spatialReference.wkid ? feature2.geometry.spatialReference.wkid : 4326;
        if (wkid === 4326 || wkid === 4283) {
          featureInfo.position = Cartographic_default.fromDegrees(
            feature2.geometry.x,
            feature2.geometry.y,
            feature2.geometry.z
          );
        } else if (wkid === 102100 || wkid === 900913 || wkid === 3857) {
          const projection = new WebMercatorProjection_default();
          featureInfo.position = projection.unproject(
            new Cartesian3_default(
              feature2.geometry.x,
              feature2.geometry.y,
              feature2.geometry.z
            )
          );
        }
      }
      result.push(featureInfo);
    }
    return result;
  });
};
var ArcGisMapServerImageryProvider_default = ArcGisMapServerImageryProvider;

// node_modules/cesium/Source/Scene/AutoExposure.js
function AutoExposure() {
  this._uniformMap = void 0;
  this._command = void 0;
  this._colorTexture = void 0;
  this._depthTexture = void 0;
  this._ready = false;
  this._name = "czm_autoexposure";
  this._logDepthChanged = void 0;
  this._useLogDepth = void 0;
  this._framebuffers = void 0;
  this._previousLuminance = new FramebufferManager_default();
  this._commands = void 0;
  this._clearCommand = void 0;
  this._minMaxLuminance = new Cartesian2_default();
  this.enabled = true;
  this._enabled = true;
  this.minimumLuminance = 0.1;
  this.maximumLuminance = 10;
}
Object.defineProperties(AutoExposure.prototype, {
  ready: {
    get: function() {
      return this._ready;
    }
  },
  name: {
    get: function() {
      return this._name;
    }
  },
  outputTexture: {
    get: function() {
      const framebuffers = this._framebuffers;
      if (!defined_default(framebuffers)) {
        return void 0;
      }
      return framebuffers[framebuffers.length - 1].getColorTexture(0);
    }
  }
});
function destroyFramebuffers(autoexposure) {
  const framebuffers = autoexposure._framebuffers;
  if (!defined_default(framebuffers)) {
    return;
  }
  const length3 = framebuffers.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    framebuffers[i2].destroy();
  }
  autoexposure._framebuffers = void 0;
  autoexposure._previousLuminance.destroy();
  autoexposure._previousLuminance = void 0;
}
function createFramebuffers(autoexposure, context) {
  destroyFramebuffers(autoexposure);
  let width = autoexposure._width;
  let height = autoexposure._height;
  const pixelDatatype = context.halfFloatingPointTexture ? PixelDatatype_default.HALF_FLOAT : PixelDatatype_default.FLOAT;
  const length3 = Math.ceil(Math.log(Math.max(width, height)) / Math.log(3));
  const framebuffers = new Array(length3);
  for (let i2 = 0; i2 < length3; ++i2) {
    width = Math.max(Math.ceil(width / 3), 1);
    height = Math.max(Math.ceil(height / 3), 1);
    framebuffers[i2] = new FramebufferManager_default();
    framebuffers[i2].update(context, width, height, 1, pixelDatatype);
  }
  const lastTexture = framebuffers[length3 - 1].getColorTexture(0);
  autoexposure._previousLuminance.update(
    context,
    lastTexture.width,
    lastTexture.height,
    1,
    pixelDatatype
  );
  autoexposure._framebuffers = framebuffers;
}
function destroyCommands(autoexposure) {
  const commands = autoexposure._commands;
  if (!defined_default(commands)) {
    return;
  }
  const length3 = commands.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    commands[i2].shaderProgram.destroy();
  }
  autoexposure._commands = void 0;
}
function createUniformMap6(autoexposure, index2) {
  let uniforms;
  if (index2 === 0) {
    uniforms = {
      colorTexture: function() {
        return autoexposure._colorTexture;
      },
      colorTextureDimensions: function() {
        return autoexposure._colorTexture.dimensions;
      }
    };
  } else {
    const texture = autoexposure._framebuffers[index2 - 1].getColorTexture(0);
    uniforms = {
      colorTexture: function() {
        return texture;
      },
      colorTextureDimensions: function() {
        return texture.dimensions;
      }
    };
  }
  uniforms.minMaxLuminance = function() {
    return autoexposure._minMaxLuminance;
  };
  uniforms.previousLuminance = function() {
    return autoexposure._previousLuminance.getColorTexture(0);
  };
  return uniforms;
}
function getShaderSource(index2, length3) {
  let source = "uniform sampler2D colorTexture; \nvarying vec2 v_textureCoordinates; \nfloat sampleTexture(vec2 offset) { \n";
  if (index2 === 0) {
    source += "    vec4 color = texture2D(colorTexture, v_textureCoordinates + offset); \n    return czm_luminance(color.rgb); \n";
  } else {
    source += "    return texture2D(colorTexture, v_textureCoordinates + offset).r; \n";
  }
  source += "}\n\n";
  source += "uniform vec2 colorTextureDimensions; \nuniform vec2 minMaxLuminance; \nuniform sampler2D previousLuminance; \nvoid main() { \n    float color = 0.0; \n    float xStep = 1.0 / colorTextureDimensions.x; \n    float yStep = 1.0 / colorTextureDimensions.y; \n    int count = 0; \n    for (int i = 0; i < 3; ++i) { \n        for (int j = 0; j < 3; ++j) { \n            vec2 offset; \n            offset.x = -xStep + float(i) * xStep; \n            offset.y = -yStep + float(j) * yStep; \n            if (offset.x < 0.0 || offset.x > 1.0 || offset.y < 0.0 || offset.y > 1.0) { \n                continue; \n            } \n            color += sampleTexture(offset); \n            ++count; \n        } \n    } \n    if (count > 0) { \n        color /= float(count); \n    } \n";
  if (index2 === length3 - 1) {
    source += "    float previous = texture2D(previousLuminance, vec2(0.5)).r; \n    color = clamp(color, minMaxLuminance.x, minMaxLuminance.y); \n    color = previous + (color - previous) / (60.0 * 1.5); \n    color = clamp(color, minMaxLuminance.x, minMaxLuminance.y); \n";
  }
  source += "    gl_FragColor = vec4(color); \n} \n";
  return source;
}
function createCommands6(autoexposure, context) {
  destroyCommands(autoexposure);
  const framebuffers = autoexposure._framebuffers;
  const length3 = framebuffers.length;
  const commands = new Array(length3);
  for (let i2 = 0; i2 < length3; ++i2) {
    commands[i2] = context.createViewportQuadCommand(
      getShaderSource(i2, length3),
      {
        framebuffer: framebuffers[i2].framebuffer,
        uniformMap: createUniformMap6(autoexposure, i2)
      }
    );
  }
  autoexposure._commands = commands;
}
AutoExposure.prototype.clear = function(context) {
  const framebuffers = this._framebuffers;
  if (!defined_default(framebuffers)) {
    return;
  }
  let clearCommand = this._clearCommand;
  if (!defined_default(clearCommand)) {
    clearCommand = this._clearCommand = new ClearCommand_default({
      color: new Color_default(0, 0, 0, 0),
      framebuffer: void 0
    });
  }
  const length3 = framebuffers.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    framebuffers[i2].clear(context, clearCommand);
  }
};
AutoExposure.prototype.update = function(context) {
  const width = context.drawingBufferWidth;
  const height = context.drawingBufferHeight;
  if (width !== this._width || height !== this._height) {
    this._width = width;
    this._height = height;
    createFramebuffers(this, context);
    createCommands6(this, context);
    if (!this._ready) {
      this._ready = true;
    }
  }
  this._minMaxLuminance.x = this.minimumLuminance;
  this._minMaxLuminance.y = this.maximumLuminance;
  const framebuffers = this._framebuffers;
  const temp = framebuffers[framebuffers.length - 1];
  framebuffers[framebuffers.length - 1] = this._previousLuminance;
  this._commands[this._commands.length - 1].framebuffer = this._previousLuminance.framebuffer;
  this._previousLuminance = temp;
};
AutoExposure.prototype.execute = function(context, colorTexture) {
  this._colorTexture = colorTexture;
  const commands = this._commands;
  if (!defined_default(commands)) {
    return;
  }
  const length3 = commands.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    commands[i2].execute(context);
  }
};
AutoExposure.prototype.isDestroyed = function() {
  return false;
};
AutoExposure.prototype.destroy = function() {
  destroyFramebuffers(this);
  destroyCommands(this);
  return destroyObject_default(this);
};
var AutoExposure_default = AutoExposure;

// node_modules/cesium/Source/Scene/BingMapsStyle.js
var BingMapsStyle = {
  AERIAL: "Aerial",
  AERIAL_WITH_LABELS: "AerialWithLabels",
  AERIAL_WITH_LABELS_ON_DEMAND: "AerialWithLabelsOnDemand",
  ROAD: "Road",
  ROAD_ON_DEMAND: "RoadOnDemand",
  CANVAS_DARK: "CanvasDark",
  CANVAS_LIGHT: "CanvasLight",
  CANVAS_GRAY: "CanvasGray",
  ORDNANCE_SURVEY: "OrdnanceSurvey",
  COLLINS_BART: "CollinsBart"
};
var BingMapsStyle_default = Object.freeze(BingMapsStyle);

// node_modules/cesium/Source/Scene/DiscardEmptyTileImagePolicy.js
function DiscardEmptyTileImagePolicy(options) {
}
DiscardEmptyTileImagePolicy.prototype.isReady = function() {
  return true;
};
DiscardEmptyTileImagePolicy.prototype.shouldDiscardImage = function(image) {
  return DiscardEmptyTileImagePolicy.EMPTY_IMAGE === image;
};
var emptyImage;
Object.defineProperties(DiscardEmptyTileImagePolicy, {
  EMPTY_IMAGE: {
    get: function() {
      if (!defined_default(emptyImage)) {
        emptyImage = new Image();
        emptyImage.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
      }
      return emptyImage;
    }
  }
});
var DiscardEmptyTileImagePolicy_default = DiscardEmptyTileImagePolicy;

// node_modules/cesium/Source/Scene/BingMapsImageryProvider.js
function BingMapsImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const accessKey = options.key;
  if (!defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  if (!defined_default(accessKey)) {
    throw new DeveloperError_default("options.key is required.");
  }
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = 1;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  this._key = accessKey;
  this._resource = Resource_default.createIfNeeded(options.url);
  this._resource.appendForwardSlash();
  this._tileProtocol = options.tileProtocol;
  this._mapStyle = defaultValue_default(options.mapStyle, BingMapsStyle_default.AERIAL);
  this._culture = defaultValue_default(options.culture, "");
  this._tileDiscardPolicy = options.tileDiscardPolicy;
  if (!defined_default(this._tileDiscardPolicy)) {
    this._tileDiscardPolicy = new DiscardEmptyTileImagePolicy_default();
  }
  this._proxy = options.proxy;
  this._credit = new Credit_default(
    `<a href="http://www.bing.com"><img src="${BingMapsImageryProvider.logoUrl}" title="Bing Imagery"/></a>`
  );
  this._tilingScheme = new WebMercatorTilingScheme_default({
    numberOfLevelZeroTilesX: 2,
    numberOfLevelZeroTilesY: 2,
    ellipsoid: options.ellipsoid
  });
  this._tileWidth = void 0;
  this._tileHeight = void 0;
  this._maximumLevel = void 0;
  this._imageUrlTemplate = void 0;
  this._imageUrlSubdomains = void 0;
  this._errorEvent = new Event_default();
  this._ready = false;
  this._readyPromise = defer_default();
  let tileProtocol = this._tileProtocol;
  if (defined_default(tileProtocol)) {
    if (tileProtocol.length > 0 && tileProtocol[tileProtocol.length - 1] === ":") {
      tileProtocol = tileProtocol.substr(0, tileProtocol.length - 1);
    }
  } else {
    const documentProtocol = document.location.protocol;
    tileProtocol = documentProtocol === "http:" ? "http" : "https";
  }
  const metadataResource = this._resource.getDerivedResource({
    url: `REST/v1/Imagery/Metadata/${this._mapStyle}`,
    queryParameters: {
      incl: "ImageryProviders",
      key: this._key,
      uriScheme: tileProtocol
    }
  });
  const that = this;
  let metadataError;
  function metadataSuccess(data) {
    if (data.resourceSets.length !== 1) {
      metadataFailure();
      return;
    }
    const resource = data.resourceSets[0].resources[0];
    that._tileWidth = resource.imageWidth;
    that._tileHeight = resource.imageHeight;
    that._maximumLevel = resource.zoomMax - 1;
    that._imageUrlSubdomains = resource.imageUrlSubdomains;
    that._imageUrlTemplate = resource.imageUrl;
    let attributionList = that._attributionList = resource.imageryProviders;
    if (!attributionList) {
      attributionList = that._attributionList = [];
    }
    for (let attributionIndex = 0, attributionLength = attributionList.length; attributionIndex < attributionLength; ++attributionIndex) {
      const attribution = attributionList[attributionIndex];
      if (attribution.credit instanceof Credit_default) {
        break;
      }
      attribution.credit = new Credit_default(attribution.attribution);
      const coverageAreas = attribution.coverageAreas;
      for (let areaIndex = 0, areaLength = attribution.coverageAreas.length; areaIndex < areaLength; ++areaIndex) {
        const area2 = coverageAreas[areaIndex];
        const bbox2 = area2.bbox;
        area2.bbox = new Rectangle_default(
          Math_default.toRadians(bbox2[1]),
          Math_default.toRadians(bbox2[0]),
          Math_default.toRadians(bbox2[3]),
          Math_default.toRadians(bbox2[2])
        );
      }
    }
    that._ready = true;
    that._readyPromise.resolve(true);
    TileProviderError_default.handleSuccess(metadataError);
  }
  function metadataFailure(e2) {
    const message = `An error occurred while accessing ${metadataResource.url}.`;
    metadataError = TileProviderError_default.handleError(
      metadataError,
      that,
      that._errorEvent,
      message,
      void 0,
      void 0,
      void 0,
      requestMetadata
    );
    that._readyPromise.reject(new RuntimeError_default(message));
  }
  const cacheKey = metadataResource.url;
  function requestMetadata() {
    const promise2 = metadataResource.fetchJsonp("jsonp");
    BingMapsImageryProvider._metadataCache[cacheKey] = promise2;
    promise2.then(metadataSuccess).catch(metadataFailure);
  }
  const promise = BingMapsImageryProvider._metadataCache[cacheKey];
  if (defined_default(promise)) {
    promise.then(metadataSuccess).catch(metadataFailure);
  } else {
    requestMetadata();
  }
}
Object.defineProperties(BingMapsImageryProvider.prototype, {
  url: {
    get: function() {
      return this._resource.url;
    }
  },
  proxy: {
    get: function() {
      return this._resource.proxy;
    }
  },
  key: {
    get: function() {
      return this._key;
    }
  },
  mapStyle: {
    get: function() {
      return this._mapStyle;
    }
  },
  culture: {
    get: function() {
      return this._culture;
    }
  },
  tileWidth: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileWidth must not be called before the imagery provider is ready."
        );
      }
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileHeight must not be called before the imagery provider is ready."
        );
      }
      return this._tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "maximumLevel must not be called before the imagery provider is ready."
        );
      }
      return this._maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "minimumLevel must not be called before the imagery provider is ready."
        );
      }
      return 0;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "rectangle must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme.rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileDiscardPolicy must not be called before the imagery provider is ready."
        );
      }
      return this._tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return false;
    }
  }
});
var rectangleScratch6 = new Rectangle_default();
BingMapsImageryProvider.prototype.getTileCredits = function(x, y, level) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "getTileCredits must not be called before the imagery provider is ready."
    );
  }
  const rectangle = this._tilingScheme.tileXYToRectangle(
    x,
    y,
    level,
    rectangleScratch6
  );
  const result = getRectangleAttribution(
    this._attributionList,
    level,
    rectangle
  );
  return result;
};
BingMapsImageryProvider.prototype.requestImage = function(x, y, level, request) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "requestImage must not be called before the imagery provider is ready."
    );
  }
  const promise = ImageryProvider_default.loadImage(
    this,
    buildImageResource2(this, x, y, level, request)
  );
  if (defined_default(promise)) {
    return promise.catch(function(error) {
      if (defined_default(error.blob) && error.blob.size === 0) {
        return DiscardEmptyTileImagePolicy_default.EMPTY_IMAGE;
      }
      return Promise.reject(error);
    });
  }
  return void 0;
};
BingMapsImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  return void 0;
};
BingMapsImageryProvider.tileXYToQuadKey = function(x, y, level) {
  let quadkey = "";
  for (let i2 = level; i2 >= 0; --i2) {
    const bitmask = 1 << i2;
    let digit = 0;
    if ((x & bitmask) !== 0) {
      digit |= 1;
    }
    if ((y & bitmask) !== 0) {
      digit |= 2;
    }
    quadkey += digit;
  }
  return quadkey;
};
BingMapsImageryProvider.quadKeyToTileXY = function(quadkey) {
  let x = 0;
  let y = 0;
  const level = quadkey.length - 1;
  for (let i2 = level; i2 >= 0; --i2) {
    const bitmask = 1 << i2;
    const digit = +quadkey[level - i2];
    if ((digit & 1) !== 0) {
      x |= bitmask;
    }
    if ((digit & 2) !== 0) {
      y |= bitmask;
    }
  }
  return {
    x,
    y,
    level
  };
};
BingMapsImageryProvider._logoUrl = void 0;
Object.defineProperties(BingMapsImageryProvider, {
  logoUrl: {
    get: function() {
      if (!defined_default(BingMapsImageryProvider._logoUrl)) {
        BingMapsImageryProvider._logoUrl = buildModuleUrl_default(
          "Assets/Images/bing_maps_credit.png"
        );
      }
      return BingMapsImageryProvider._logoUrl;
    },
    set: function(value) {
      Check_default.defined("value", value);
      BingMapsImageryProvider._logoUrl = value;
    }
  }
});
function buildImageResource2(imageryProvider, x, y, level, request) {
  const imageUrl = imageryProvider._imageUrlTemplate;
  const subdomains = imageryProvider._imageUrlSubdomains;
  const subdomainIndex = (x + y + level) % subdomains.length;
  return imageryProvider._resource.getDerivedResource({
    url: imageUrl,
    request,
    templateValues: {
      quadkey: BingMapsImageryProvider.tileXYToQuadKey(x, y, level),
      subdomain: subdomains[subdomainIndex],
      culture: imageryProvider._culture
    },
    queryParameters: {
      n: "z"
    }
  });
}
var intersectionScratch2 = new Rectangle_default();
function getRectangleAttribution(attributionList, level, rectangle) {
  ++level;
  const result = [];
  for (let attributionIndex = 0, attributionLength = attributionList.length; attributionIndex < attributionLength; ++attributionIndex) {
    const attribution = attributionList[attributionIndex];
    const coverageAreas = attribution.coverageAreas;
    let included = false;
    for (let areaIndex = 0, areaLength = attribution.coverageAreas.length; !included && areaIndex < areaLength; ++areaIndex) {
      const area2 = coverageAreas[areaIndex];
      if (level >= area2.zoomMin && level <= area2.zoomMax) {
        const intersection = Rectangle_default.intersection(
          rectangle,
          area2.bbox,
          intersectionScratch2
        );
        if (defined_default(intersection)) {
          included = true;
        }
      }
    }
    if (included) {
      result.push(attribution.credit);
    }
  }
  return result;
}
BingMapsImageryProvider._metadataCache = {};
var BingMapsImageryProvider_default = BingMapsImageryProvider;

// node_modules/cesium/Source/Scene/BoxEmitter.js
var defaultDimensions = new Cartesian3_default(1, 1, 1);
function BoxEmitter(dimensions) {
  dimensions = defaultValue_default(dimensions, defaultDimensions);
  Check_default.defined("dimensions", dimensions);
  Check_default.typeOf.number.greaterThanOrEquals("dimensions.x", dimensions.x, 0);
  Check_default.typeOf.number.greaterThanOrEquals("dimensions.y", dimensions.y, 0);
  Check_default.typeOf.number.greaterThanOrEquals("dimensions.z", dimensions.z, 0);
  this._dimensions = Cartesian3_default.clone(dimensions);
}
Object.defineProperties(BoxEmitter.prototype, {
  dimensions: {
    get: function() {
      return this._dimensions;
    },
    set: function(value) {
      Check_default.defined("value", value);
      Check_default.typeOf.number.greaterThanOrEquals("value.x", value.x, 0);
      Check_default.typeOf.number.greaterThanOrEquals("value.y", value.y, 0);
      Check_default.typeOf.number.greaterThanOrEquals("value.z", value.z, 0);
      Cartesian3_default.clone(value, this._dimensions);
    }
  }
});
var scratchHalfDim = new Cartesian3_default();
BoxEmitter.prototype.emit = function(particle) {
  const dim = this._dimensions;
  const halfDim = Cartesian3_default.multiplyByScalar(dim, 0.5, scratchHalfDim);
  const x = Math_default.randomBetween(-halfDim.x, halfDim.x);
  const y = Math_default.randomBetween(-halfDim.y, halfDim.y);
  const z = Math_default.randomBetween(-halfDim.z, halfDim.z);
  particle.position = Cartesian3_default.fromElements(x, y, z, particle.position);
  particle.velocity = Cartesian3_default.normalize(
    particle.position,
    particle.velocity
  );
};
var BoxEmitter_default = BoxEmitter;

// node_modules/cesium/Source/Shaders/BrdfLutGeneratorFS.js
var BrdfLutGeneratorFS_default = "varying vec2 v_textureCoordinates;\nconst float M_PI = 3.141592653589793;\n\nfloat vdcRadicalInverse(int i)\n{\n    float r;\n    float base = 2.0;\n    float value = 0.0;\n    float invBase = 1.0 / base;\n    float invBi = invBase;\n    for (int x = 0; x < 100; x++)\n    {\n        if (i <= 0)\n        {\n            break;\n        }\n        r = mod(float(i), base);\n        value += r * invBi;\n        invBi *= invBase;\n        i = int(float(i) * invBase);\n    }\n    return value;\n}\n\nvec2 hammersley2D(int i, int N)\n{\n    return vec2(float(i) / float(N), vdcRadicalInverse(i));\n}\n\nvec3 importanceSampleGGX(vec2 xi, float roughness, vec3 N)\n{\n    float a = roughness * roughness;\n    float phi = 2.0 * M_PI * xi.x;\n    float cosTheta = sqrt((1.0 - xi.y) / (1.0 + (a * a - 1.0) * xi.y));\n    float sinTheta = sqrt(1.0 - cosTheta * cosTheta);\n    vec3 H = vec3(sinTheta * cos(phi), sinTheta * sin(phi), cosTheta);\n    vec3 upVector = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);\n    vec3 tangentX = normalize(cross(upVector, N));\n    vec3 tangentY = cross(N, tangentX);\n    return tangentX * H.x + tangentY * H.y + N * H.z;\n}\n\nfloat G1_Smith(float NdotV, float k)\n{\n    return NdotV / (NdotV * (1.0 - k) + k);\n}\n\nfloat G_Smith(float roughness, float NdotV, float NdotL)\n{\n    float k = roughness * roughness / 2.0;\n    return G1_Smith(NdotV, k) * G1_Smith(NdotL, k);\n}\n\nvec2 integrateBrdf(float roughness, float NdotV)\n{\n    vec3 V = vec3(sqrt(1.0 - NdotV * NdotV), 0.0, NdotV);\n    float A = 0.0;\n    float B = 0.0;\n    const int NumSamples = 1024;\n    for (int i = 0; i < NumSamples; i++)\n    {\n        vec2 xi = hammersley2D(i, NumSamples);\n        vec3 H = importanceSampleGGX(xi, roughness, vec3(0.0, 0.0, 1.0));\n        vec3 L = 2.0 * dot(V, H) * H - V;\n        float NdotL = clamp(L.z, 0.0, 1.0);\n        float NdotH = clamp(H.z, 0.0, 1.0);\n        float VdotH = clamp(dot(V, H), 0.0, 1.0);\n        if (NdotL > 0.0)\n        {\n            float G = G_Smith(roughness, NdotV, NdotL);\n            float G_Vis = G * VdotH / (NdotH * NdotV);\n            float Fc = pow(1.0 - VdotH, 5.0);\n            A += (1.0 - Fc) * G_Vis;\n            B += Fc * G_Vis;\n        }\n    }\n    return vec2(A, B) / float(NumSamples);\n}\n\nvoid main()\n{\n    gl_FragColor = vec4(integrateBrdf(v_textureCoordinates.y, v_textureCoordinates.x), 0.0, 1.0);\n}\n";

// node_modules/cesium/Source/Scene/BrdfLutGenerator.js
function BrdfLutGenerator() {
  this._colorTexture = void 0;
  this._drawCommand = void 0;
}
Object.defineProperties(BrdfLutGenerator.prototype, {
  colorTexture: {
    get: function() {
      return this._colorTexture;
    }
  }
});
function createCommand2(generator, context, framebuffer) {
  const drawCommand = context.createViewportQuadCommand(BrdfLutGeneratorFS_default, {
    framebuffer,
    renderState: RenderState_default.fromCache({
      viewport: new BoundingRectangle_default(0, 0, 256, 256)
    })
  });
  generator._drawCommand = drawCommand;
}
BrdfLutGenerator.prototype.update = function(frameState) {
  if (!defined_default(this._colorTexture)) {
    const context = frameState.context;
    const colorTexture = new Texture_default({
      context,
      width: 256,
      height: 256,
      pixelFormat: PixelFormat_default.RGBA,
      pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
      sampler: Sampler_default.NEAREST
    });
    this._colorTexture = colorTexture;
    const framebuffer = new Framebuffer_default({
      context,
      colorTextures: [colorTexture],
      destroyAttachments: false
    });
    createCommand2(this, context, framebuffer);
    this._drawCommand.execute(context);
    framebuffer.destroy();
    this._drawCommand.shaderProgram = this._drawCommand.shaderProgram && this._drawCommand.shaderProgram.destroy();
  }
};
BrdfLutGenerator.prototype.isDestroyed = function() {
  return false;
};
BrdfLutGenerator.prototype.destroy = function() {
  this._colorTexture = this._colorTexture && this._colorTexture.destroy();
  return destroyObject_default(this);
};
var BrdfLutGenerator_default = BrdfLutGenerator;

// node_modules/cesium/Source/Scene/CameraFlightPath.js
var CameraFlightPath = {};
function getAltitude(frustum, dx, dy) {
  let near;
  let top;
  let right;
  if (frustum instanceof PerspectiveFrustum_default) {
    const tanTheta = Math.tan(0.5 * frustum.fovy);
    near = frustum.near;
    top = frustum.near * tanTheta;
    right = frustum.aspectRatio * top;
    return Math.max(dx * near / right, dy * near / top);
  } else if (frustum instanceof PerspectiveOffCenterFrustum_default) {
    near = frustum.near;
    top = frustum.top;
    right = frustum.right;
    return Math.max(dx * near / right, dy * near / top);
  }
  return Math.max(dx, dy);
}
var scratchCart = new Cartesian3_default();
var scratchCart23 = new Cartesian3_default();
function createPitchFunction(startPitch, endPitch, heightFunction, pitchAdjustHeight) {
  if (defined_default(pitchAdjustHeight) && heightFunction(0.5) > pitchAdjustHeight) {
    const startHeight = heightFunction(0);
    const endHeight = heightFunction(1);
    const middleHeight = heightFunction(0.5);
    const d1 = middleHeight - startHeight;
    const d2 = middleHeight - endHeight;
    return function(time) {
      const altitude = heightFunction(time);
      if (time <= 0.5) {
        const t1 = (altitude - startHeight) / d1;
        return Math_default.lerp(startPitch, -Math_default.PI_OVER_TWO, t1);
      }
      const t2 = (altitude - endHeight) / d2;
      return Math_default.lerp(-Math_default.PI_OVER_TWO, endPitch, 1 - t2);
    };
  }
  return function(time) {
    return Math_default.lerp(startPitch, endPitch, time);
  };
}
function createHeightFunction(camera, destination, startHeight, endHeight, optionAltitude) {
  let altitude = optionAltitude;
  const maxHeight = Math.max(startHeight, endHeight);
  if (!defined_default(altitude)) {
    const start = camera.position;
    const end = destination;
    const up = camera.up;
    const right = camera.right;
    const frustum = camera.frustum;
    const diff = Cartesian3_default.subtract(start, end, scratchCart);
    const verticalDistance = Cartesian3_default.magnitude(
      Cartesian3_default.multiplyByScalar(up, Cartesian3_default.dot(diff, up), scratchCart23)
    );
    const horizontalDistance = Cartesian3_default.magnitude(
      Cartesian3_default.multiplyByScalar(
        right,
        Cartesian3_default.dot(diff, right),
        scratchCart23
      )
    );
    altitude = Math.min(
      getAltitude(frustum, verticalDistance, horizontalDistance) * 0.2,
      1e9
    );
  }
  if (maxHeight < altitude) {
    const power = 8;
    const factor2 = 1e6;
    const s2 = -Math.pow((altitude - startHeight) * factor2, 1 / power);
    const e2 = Math.pow((altitude - endHeight) * factor2, 1 / power);
    return function(t) {
      const x = t * (e2 - s2) + s2;
      return -Math.pow(x, power) / factor2 + altitude;
    };
  }
  return function(t) {
    return Math_default.lerp(startHeight, endHeight, t);
  };
}
function adjustAngleForLERP(startAngle, endAngle) {
  if (Math_default.equalsEpsilon(
    startAngle,
    Math_default.TWO_PI,
    Math_default.EPSILON11
  )) {
    startAngle = 0;
  }
  if (endAngle > startAngle + Math.PI) {
    startAngle += Math_default.TWO_PI;
  } else if (endAngle < startAngle - Math.PI) {
    startAngle -= Math_default.TWO_PI;
  }
  return startAngle;
}
var scratchStart = new Cartesian3_default();
function createUpdateCV(scene, duration, destination, heading, pitch, roll, optionAltitude, optionPitchAdjustHeight) {
  const camera = scene.camera;
  const start = Cartesian3_default.clone(camera.position, scratchStart);
  const startPitch = camera.pitch;
  const startHeading = adjustAngleForLERP(camera.heading, heading);
  const startRoll = adjustAngleForLERP(camera.roll, roll);
  const heightFunction = createHeightFunction(
    camera,
    destination,
    start.z,
    destination.z,
    optionAltitude
  );
  const pitchFunction = createPitchFunction(
    startPitch,
    pitch,
    heightFunction,
    optionPitchAdjustHeight
  );
  function update7(value) {
    const time = value.time / duration;
    camera.setView({
      orientation: {
        heading: Math_default.lerp(startHeading, heading, time),
        pitch: pitchFunction(time),
        roll: Math_default.lerp(startRoll, roll, time)
      }
    });
    Cartesian2_default.lerp(start, destination, time, camera.position);
    camera.position.z = heightFunction(time);
  }
  return update7;
}
function useLongestFlight(startCart, destCart) {
  if (startCart.longitude < destCart.longitude) {
    startCart.longitude += Math_default.TWO_PI;
  } else {
    destCart.longitude += Math_default.TWO_PI;
  }
}
function useShortestFlight(startCart, destCart) {
  const diff = startCart.longitude - destCart.longitude;
  if (diff < -Math_default.PI) {
    startCart.longitude += Math_default.TWO_PI;
  } else if (diff > Math_default.PI) {
    destCart.longitude += Math_default.TWO_PI;
  }
}
var scratchStartCart = new Cartographic_default();
var scratchEndCart = new Cartographic_default();
function createUpdate3D(scene, duration, destination, heading, pitch, roll, optionAltitude, optionFlyOverLongitude, optionFlyOverLongitudeWeight, optionPitchAdjustHeight) {
  const camera = scene.camera;
  const projection = scene.mapProjection;
  const ellipsoid = projection.ellipsoid;
  const startCart = Cartographic_default.clone(
    camera.positionCartographic,
    scratchStartCart
  );
  const startPitch = camera.pitch;
  const startHeading = adjustAngleForLERP(camera.heading, heading);
  const startRoll = adjustAngleForLERP(camera.roll, roll);
  const destCart = ellipsoid.cartesianToCartographic(
    destination,
    scratchEndCart
  );
  startCart.longitude = Math_default.zeroToTwoPi(startCart.longitude);
  destCart.longitude = Math_default.zeroToTwoPi(destCart.longitude);
  let useLongFlight = false;
  if (defined_default(optionFlyOverLongitude)) {
    const hitLon = Math_default.zeroToTwoPi(optionFlyOverLongitude);
    const lonMin = Math.min(startCart.longitude, destCart.longitude);
    const lonMax = Math.max(startCart.longitude, destCart.longitude);
    const hitInside = hitLon >= lonMin && hitLon <= lonMax;
    if (defined_default(optionFlyOverLongitudeWeight)) {
      const din = Math.abs(startCart.longitude - destCart.longitude);
      const dot2 = Math_default.TWO_PI - din;
      const hitDistance = hitInside ? din : dot2;
      const offDistance = hitInside ? dot2 : din;
      if (hitDistance < offDistance * optionFlyOverLongitudeWeight && !hitInside) {
        useLongFlight = true;
      }
    } else if (!hitInside) {
      useLongFlight = true;
    }
  }
  if (useLongFlight) {
    useLongestFlight(startCart, destCart);
  } else {
    useShortestFlight(startCart, destCart);
  }
  const heightFunction = createHeightFunction(
    camera,
    destination,
    startCart.height,
    destCart.height,
    optionAltitude
  );
  const pitchFunction = createPitchFunction(
    startPitch,
    pitch,
    heightFunction,
    optionPitchAdjustHeight
  );
  function isolateUpdateFunction() {
    const startLongitude = startCart.longitude;
    const destLongitude = destCart.longitude;
    const startLatitude = startCart.latitude;
    const destLatitude = destCart.latitude;
    return function update7(value) {
      const time = value.time / duration;
      const position = Cartesian3_default.fromRadians(
        Math_default.lerp(startLongitude, destLongitude, time),
        Math_default.lerp(startLatitude, destLatitude, time),
        heightFunction(time),
        ellipsoid
      );
      camera.setView({
        destination: position,
        orientation: {
          heading: Math_default.lerp(startHeading, heading, time),
          pitch: pitchFunction(time),
          roll: Math_default.lerp(startRoll, roll, time)
        }
      });
    };
  }
  return isolateUpdateFunction();
}
function createUpdate2D(scene, duration, destination, heading, pitch, roll, optionAltitude) {
  const camera = scene.camera;
  const start = Cartesian3_default.clone(camera.position, scratchStart);
  const startHeading = adjustAngleForLERP(camera.heading, heading);
  const startHeight = camera.frustum.right - camera.frustum.left;
  const heightFunction = createHeightFunction(
    camera,
    destination,
    startHeight,
    destination.z,
    optionAltitude
  );
  function update7(value) {
    const time = value.time / duration;
    camera.setView({
      orientation: {
        heading: Math_default.lerp(startHeading, heading, time)
      }
    });
    Cartesian2_default.lerp(start, destination, time, camera.position);
    const zoom = heightFunction(time);
    const frustum = camera.frustum;
    const ratio = frustum.top / frustum.right;
    const incrementAmount = (zoom - (frustum.right - frustum.left)) * 0.5;
    frustum.right += incrementAmount;
    frustum.left -= incrementAmount;
    frustum.top = ratio * frustum.right;
    frustum.bottom = -frustum.top;
  }
  return update7;
}
var scratchCartographic15 = new Cartographic_default();
var scratchDestination = new Cartesian3_default();
function emptyFlight(complete, cancel) {
  return {
    startObject: {},
    stopObject: {},
    duration: 0,
    complete,
    cancel
  };
}
function wrapCallback(controller, cb) {
  function wrapped() {
    if (typeof cb === "function") {
      cb();
    }
    controller.enableInputs = true;
  }
  return wrapped;
}
CameraFlightPath.createTween = function(scene, options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let destination = options.destination;
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  if (!defined_default(destination)) {
    throw new DeveloperError_default("destination is required.");
  }
  const mode2 = scene.mode;
  if (mode2 === SceneMode_default.MORPHING) {
    return emptyFlight();
  }
  const convert = defaultValue_default(options.convert, true);
  const projection = scene.mapProjection;
  const ellipsoid = projection.ellipsoid;
  const maximumHeight = options.maximumHeight;
  const flyOverLongitude = options.flyOverLongitude;
  const flyOverLongitudeWeight = options.flyOverLongitudeWeight;
  const pitchAdjustHeight = options.pitchAdjustHeight;
  let easingFunction = options.easingFunction;
  if (convert && mode2 !== SceneMode_default.SCENE3D) {
    ellipsoid.cartesianToCartographic(destination, scratchCartographic15);
    destination = projection.project(scratchCartographic15, scratchDestination);
  }
  const camera = scene.camera;
  const transform4 = options.endTransform;
  if (defined_default(transform4)) {
    camera._setTransform(transform4);
  }
  let duration = options.duration;
  if (!defined_default(duration)) {
    duration = Math.ceil(Cartesian3_default.distance(camera.position, destination) / 1e6) + 2;
    duration = Math.min(duration, 3);
  }
  const heading = defaultValue_default(options.heading, 0);
  const pitch = defaultValue_default(options.pitch, -Math_default.PI_OVER_TWO);
  const roll = defaultValue_default(options.roll, 0);
  const controller = scene.screenSpaceCameraController;
  controller.enableInputs = false;
  const complete = wrapCallback(controller, options.complete);
  const cancel = wrapCallback(controller, options.cancel);
  const frustum = camera.frustum;
  let empty = scene.mode === SceneMode_default.SCENE2D;
  empty = empty && Cartesian2_default.equalsEpsilon(camera.position, destination, Math_default.EPSILON6);
  empty = empty && Math_default.equalsEpsilon(
    Math.max(frustum.right - frustum.left, frustum.top - frustum.bottom),
    destination.z,
    Math_default.EPSILON6
  );
  empty = empty || scene.mode !== SceneMode_default.SCENE2D && Cartesian3_default.equalsEpsilon(
    destination,
    camera.position,
    Math_default.EPSILON10
  );
  empty = empty && Math_default.equalsEpsilon(
    Math_default.negativePiToPi(heading),
    Math_default.negativePiToPi(camera.heading),
    Math_default.EPSILON10
  ) && Math_default.equalsEpsilon(
    Math_default.negativePiToPi(pitch),
    Math_default.negativePiToPi(camera.pitch),
    Math_default.EPSILON10
  ) && Math_default.equalsEpsilon(
    Math_default.negativePiToPi(roll),
    Math_default.negativePiToPi(camera.roll),
    Math_default.EPSILON10
  );
  if (empty) {
    return emptyFlight(complete, cancel);
  }
  const updateFunctions2 = new Array(4);
  updateFunctions2[SceneMode_default.SCENE2D] = createUpdate2D;
  updateFunctions2[SceneMode_default.SCENE3D] = createUpdate3D;
  updateFunctions2[SceneMode_default.COLUMBUS_VIEW] = createUpdateCV;
  if (duration <= 0) {
    const newOnComplete = function() {
      const update8 = updateFunctions2[mode2](
        scene,
        1,
        destination,
        heading,
        pitch,
        roll,
        maximumHeight,
        flyOverLongitude,
        flyOverLongitudeWeight,
        pitchAdjustHeight
      );
      update8({ time: 1 });
      if (typeof complete === "function") {
        complete();
      }
    };
    return emptyFlight(newOnComplete, cancel);
  }
  const update7 = updateFunctions2[mode2](
    scene,
    duration,
    destination,
    heading,
    pitch,
    roll,
    maximumHeight,
    flyOverLongitude,
    flyOverLongitudeWeight,
    pitchAdjustHeight
  );
  if (!defined_default(easingFunction)) {
    const startHeight = camera.positionCartographic.height;
    const endHeight = mode2 === SceneMode_default.SCENE3D ? ellipsoid.cartesianToCartographic(destination).height : destination.z;
    if (startHeight > endHeight && startHeight > 11500) {
      easingFunction = EasingFunction_default.CUBIC_OUT;
    } else {
      easingFunction = EasingFunction_default.QUINTIC_IN_OUT;
    }
  }
  return {
    duration,
    easingFunction,
    startObject: {
      time: 0
    },
    stopObject: {
      time: duration
    },
    update: update7,
    complete,
    cancel
  };
};
var CameraFlightPath_default = CameraFlightPath;

// node_modules/cesium/Source/Scene/MapMode2D.js
var MapMode2D = {
  ROTATE: 0,
  INFINITE_SCROLL: 1
};
var MapMode2D_default = Object.freeze(MapMode2D);

// node_modules/cesium/Source/Scene/Camera.js
function Camera(scene) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  this._scene = scene;
  this._transform = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._invTransform = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._actualTransform = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._actualInvTransform = Matrix4_default.clone(Matrix4_default.IDENTITY);
  this._transformChanged = false;
  this.position = new Cartesian3_default();
  this._position = new Cartesian3_default();
  this._positionWC = new Cartesian3_default();
  this._positionCartographic = new Cartographic_default();
  this._oldPositionWC = void 0;
  this.positionWCDeltaMagnitude = 0;
  this.positionWCDeltaMagnitudeLastFrame = 0;
  this.timeSinceMoved = 0;
  this._lastMovedTimestamp = 0;
  this.direction = new Cartesian3_default();
  this._direction = new Cartesian3_default();
  this._directionWC = new Cartesian3_default();
  this.up = new Cartesian3_default();
  this._up = new Cartesian3_default();
  this._upWC = new Cartesian3_default();
  this.right = new Cartesian3_default();
  this._right = new Cartesian3_default();
  this._rightWC = new Cartesian3_default();
  this.frustum = new PerspectiveFrustum_default();
  this.frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
  this.frustum.fov = Math_default.toRadians(60);
  this.defaultMoveAmount = 1e5;
  this.defaultLookAmount = Math.PI / 60;
  this.defaultRotateAmount = Math.PI / 3600;
  this.defaultZoomAmount = 1e5;
  this.constrainedAxis = void 0;
  this.maximumZoomFactor = 1.5;
  this._moveStart = new Event_default();
  this._moveEnd = new Event_default();
  this._changed = new Event_default();
  this._changedPosition = void 0;
  this._changedDirection = void 0;
  this._changedFrustum = void 0;
  this._changedHeading = void 0;
  this.percentageChanged = 0.5;
  this._viewMatrix = new Matrix4_default();
  this._invViewMatrix = new Matrix4_default();
  updateViewMatrix(this);
  this._mode = SceneMode_default.SCENE3D;
  this._modeChanged = true;
  const projection = scene.mapProjection;
  this._projection = projection;
  this._maxCoord = projection.project(
    new Cartographic_default(Math.PI, Math_default.PI_OVER_TWO)
  );
  this._max2Dfrustum = void 0;
  rectangleCameraPosition3D(
    this,
    Camera.DEFAULT_VIEW_RECTANGLE,
    this.position,
    true
  );
  let mag = Cartesian3_default.magnitude(this.position);
  mag += mag * Camera.DEFAULT_VIEW_FACTOR;
  Cartesian3_default.normalize(this.position, this.position);
  Cartesian3_default.multiplyByScalar(this.position, mag, this.position);
}
Camera.TRANSFORM_2D = new Matrix4_default(
  0,
  0,
  1,
  0,
  1,
  0,
  0,
  0,
  0,
  1,
  0,
  0,
  0,
  0,
  0,
  1
);
Camera.TRANSFORM_2D_INVERSE = Matrix4_default.inverseTransformation(
  Camera.TRANSFORM_2D,
  new Matrix4_default()
);
Camera.DEFAULT_VIEW_RECTANGLE = Rectangle_default.fromDegrees(
  -95,
  -20,
  -70,
  90
);
Camera.DEFAULT_VIEW_FACTOR = 0.5;
Camera.DEFAULT_OFFSET = new HeadingPitchRange_default(
  0,
  -Math_default.PI_OVER_FOUR,
  0
);
function updateViewMatrix(camera) {
  Matrix4_default.computeView(
    camera._position,
    camera._direction,
    camera._up,
    camera._right,
    camera._viewMatrix
  );
  Matrix4_default.multiply(
    camera._viewMatrix,
    camera._actualInvTransform,
    camera._viewMatrix
  );
  Matrix4_default.inverseTransformation(camera._viewMatrix, camera._invViewMatrix);
}
function updateCameraDeltas(camera) {
  if (!defined_default(camera._oldPositionWC)) {
    camera._oldPositionWC = Cartesian3_default.clone(
      camera.positionWC,
      camera._oldPositionWC
    );
  } else {
    camera.positionWCDeltaMagnitudeLastFrame = camera.positionWCDeltaMagnitude;
    const delta = Cartesian3_default.subtract(
      camera.positionWC,
      camera._oldPositionWC,
      camera._oldPositionWC
    );
    camera.positionWCDeltaMagnitude = Cartesian3_default.magnitude(delta);
    camera._oldPositionWC = Cartesian3_default.clone(
      camera.positionWC,
      camera._oldPositionWC
    );
    if (camera.positionWCDeltaMagnitude > 0) {
      camera.timeSinceMoved = 0;
      camera._lastMovedTimestamp = getTimestamp_default();
    } else {
      camera.timeSinceMoved = Math.max(getTimestamp_default() - camera._lastMovedTimestamp, 0) / 1e3;
    }
  }
}
Camera.prototype.canPreloadFlight = function() {
  return defined_default(this._currentFlight) && this._mode !== SceneMode_default.SCENE2D;
};
Camera.prototype._updateCameraChanged = function() {
  const camera = this;
  updateCameraDeltas(camera);
  if (camera._changed.numberOfListeners === 0) {
    return;
  }
  const percentageChanged = camera.percentageChanged;
  const currentHeading = camera.heading;
  if (!defined_default(camera._changedHeading)) {
    camera._changedHeading = currentHeading;
  }
  let delta = Math.abs(camera._changedHeading - currentHeading) % Math_default.TWO_PI;
  delta = delta > Math_default.PI ? Math_default.TWO_PI - delta : delta;
  const headingChangedPercentage = delta / Math.PI;
  if (headingChangedPercentage > percentageChanged) {
    camera._changed.raiseEvent(headingChangedPercentage);
    camera._changedHeading = currentHeading;
  }
  if (camera._mode === SceneMode_default.SCENE2D) {
    if (!defined_default(camera._changedFrustum)) {
      camera._changedPosition = Cartesian3_default.clone(
        camera.position,
        camera._changedPosition
      );
      camera._changedFrustum = camera.frustum.clone();
      return;
    }
    const position = camera.position;
    const lastPosition = camera._changedPosition;
    const frustum = camera.frustum;
    const lastFrustum = camera._changedFrustum;
    const x0 = position.x + frustum.left;
    const x1 = position.x + frustum.right;
    const x2 = lastPosition.x + lastFrustum.left;
    const x3 = lastPosition.x + lastFrustum.right;
    const y0 = position.y + frustum.bottom;
    const y1 = position.y + frustum.top;
    const y2 = lastPosition.y + lastFrustum.bottom;
    const y3 = lastPosition.y + lastFrustum.top;
    const leftX = Math.max(x0, x2);
    const rightX = Math.min(x1, x3);
    const bottomY = Math.max(y0, y2);
    const topY = Math.min(y1, y3);
    let areaPercentage;
    if (leftX >= rightX || bottomY >= y1) {
      areaPercentage = 1;
    } else {
      let areaRef = lastFrustum;
      if (x0 < x2 && x1 > x3 && y0 < y2 && y1 > y3) {
        areaRef = frustum;
      }
      areaPercentage = 1 - (rightX - leftX) * (topY - bottomY) / ((areaRef.right - areaRef.left) * (areaRef.top - areaRef.bottom));
    }
    if (areaPercentage > percentageChanged) {
      camera._changed.raiseEvent(areaPercentage);
      camera._changedPosition = Cartesian3_default.clone(
        camera.position,
        camera._changedPosition
      );
      camera._changedFrustum = camera.frustum.clone(camera._changedFrustum);
    }
    return;
  }
  if (!defined_default(camera._changedDirection)) {
    camera._changedPosition = Cartesian3_default.clone(
      camera.positionWC,
      camera._changedPosition
    );
    camera._changedDirection = Cartesian3_default.clone(
      camera.directionWC,
      camera._changedDirection
    );
    return;
  }
  const dirAngle = Math_default.acosClamped(
    Cartesian3_default.dot(camera.directionWC, camera._changedDirection)
  );
  let dirPercentage;
  if (defined_default(camera.frustum.fovy)) {
    dirPercentage = dirAngle / (camera.frustum.fovy * 0.5);
  } else {
    dirPercentage = dirAngle;
  }
  const distance2 = Cartesian3_default.distance(
    camera.positionWC,
    camera._changedPosition
  );
  const heightPercentage = distance2 / camera.positionCartographic.height;
  if (dirPercentage > percentageChanged || heightPercentage > percentageChanged) {
    camera._changed.raiseEvent(Math.max(dirPercentage, heightPercentage));
    camera._changedPosition = Cartesian3_default.clone(
      camera.positionWC,
      camera._changedPosition
    );
    camera._changedDirection = Cartesian3_default.clone(
      camera.directionWC,
      camera._changedDirection
    );
  }
};
function convertTransformForColumbusView(camera) {
  Transforms_default.basisTo2D(
    camera._projection,
    camera._transform,
    camera._actualTransform
  );
}
var scratchCartographic16 = new Cartographic_default();
var scratchCartesian3Projection2 = new Cartesian3_default();
var scratchCartesian313 = new Cartesian3_default();
var scratchCartesian4Origin = new Cartesian4_default();
var scratchCartesian4NewOrigin = new Cartesian4_default();
var scratchCartesian4NewXAxis = new Cartesian4_default();
var scratchCartesian4NewYAxis = new Cartesian4_default();
var scratchCartesian4NewZAxis = new Cartesian4_default();
function convertTransformFor2D(camera) {
  const projection = camera._projection;
  const ellipsoid = projection.ellipsoid;
  const origin = Matrix4_default.getColumn(
    camera._transform,
    3,
    scratchCartesian4Origin
  );
  const cartographic2 = ellipsoid.cartesianToCartographic(
    origin,
    scratchCartographic16
  );
  const projectedPosition2 = projection.project(
    cartographic2,
    scratchCartesian3Projection2
  );
  const newOrigin = scratchCartesian4NewOrigin;
  newOrigin.x = projectedPosition2.z;
  newOrigin.y = projectedPosition2.x;
  newOrigin.z = projectedPosition2.y;
  newOrigin.w = 1;
  const newZAxis = Cartesian4_default.clone(
    Cartesian4_default.UNIT_X,
    scratchCartesian4NewZAxis
  );
  const xAxis = Cartesian4_default.add(
    Matrix4_default.getColumn(camera._transform, 0, scratchCartesian313),
    origin,
    scratchCartesian313
  );
  ellipsoid.cartesianToCartographic(xAxis, cartographic2);
  projection.project(cartographic2, projectedPosition2);
  const newXAxis = scratchCartesian4NewXAxis;
  newXAxis.x = projectedPosition2.z;
  newXAxis.y = projectedPosition2.x;
  newXAxis.z = projectedPosition2.y;
  newXAxis.w = 0;
  Cartesian3_default.subtract(newXAxis, newOrigin, newXAxis);
  newXAxis.x = 0;
  const newYAxis = scratchCartesian4NewYAxis;
  if (Cartesian3_default.magnitudeSquared(newXAxis) > Math_default.EPSILON10) {
    Cartesian3_default.cross(newZAxis, newXAxis, newYAxis);
  } else {
    const yAxis = Cartesian4_default.add(
      Matrix4_default.getColumn(camera._transform, 1, scratchCartesian313),
      origin,
      scratchCartesian313
    );
    ellipsoid.cartesianToCartographic(yAxis, cartographic2);
    projection.project(cartographic2, projectedPosition2);
    newYAxis.x = projectedPosition2.z;
    newYAxis.y = projectedPosition2.x;
    newYAxis.z = projectedPosition2.y;
    newYAxis.w = 0;
    Cartesian3_default.subtract(newYAxis, newOrigin, newYAxis);
    newYAxis.x = 0;
    if (Cartesian3_default.magnitudeSquared(newYAxis) < Math_default.EPSILON10) {
      Cartesian4_default.clone(Cartesian4_default.UNIT_Y, newXAxis);
      Cartesian4_default.clone(Cartesian4_default.UNIT_Z, newYAxis);
    }
  }
  Cartesian3_default.cross(newYAxis, newZAxis, newXAxis);
  Cartesian3_default.normalize(newXAxis, newXAxis);
  Cartesian3_default.cross(newZAxis, newXAxis, newYAxis);
  Cartesian3_default.normalize(newYAxis, newYAxis);
  Matrix4_default.setColumn(
    camera._actualTransform,
    0,
    newXAxis,
    camera._actualTransform
  );
  Matrix4_default.setColumn(
    camera._actualTransform,
    1,
    newYAxis,
    camera._actualTransform
  );
  Matrix4_default.setColumn(
    camera._actualTransform,
    2,
    newZAxis,
    camera._actualTransform
  );
  Matrix4_default.setColumn(
    camera._actualTransform,
    3,
    newOrigin,
    camera._actualTransform
  );
}
var scratchCartesian30 = new Cartesian3_default();
function updateMembers(camera) {
  const mode2 = camera._mode;
  let heightChanged = false;
  let height = 0;
  if (mode2 === SceneMode_default.SCENE2D) {
    height = camera.frustum.right - camera.frustum.left;
    heightChanged = height !== camera._positionCartographic.height;
  }
  let position = camera._position;
  const positionChanged = !Cartesian3_default.equals(position, camera.position) || heightChanged;
  if (positionChanged) {
    position = Cartesian3_default.clone(camera.position, camera._position);
  }
  let direction2 = camera._direction;
  const directionChanged = !Cartesian3_default.equals(direction2, camera.direction);
  if (directionChanged) {
    Cartesian3_default.normalize(camera.direction, camera.direction);
    direction2 = Cartesian3_default.clone(camera.direction, camera._direction);
  }
  let up = camera._up;
  const upChanged = !Cartesian3_default.equals(up, camera.up);
  if (upChanged) {
    Cartesian3_default.normalize(camera.up, camera.up);
    up = Cartesian3_default.clone(camera.up, camera._up);
  }
  let right = camera._right;
  const rightChanged = !Cartesian3_default.equals(right, camera.right);
  if (rightChanged) {
    Cartesian3_default.normalize(camera.right, camera.right);
    right = Cartesian3_default.clone(camera.right, camera._right);
  }
  const transformChanged = camera._transformChanged || camera._modeChanged;
  camera._transformChanged = false;
  if (transformChanged) {
    Matrix4_default.inverseTransformation(camera._transform, camera._invTransform);
    if (camera._mode === SceneMode_default.COLUMBUS_VIEW || camera._mode === SceneMode_default.SCENE2D) {
      if (Matrix4_default.equals(Matrix4_default.IDENTITY, camera._transform)) {
        Matrix4_default.clone(Camera.TRANSFORM_2D, camera._actualTransform);
      } else if (camera._mode === SceneMode_default.COLUMBUS_VIEW) {
        convertTransformForColumbusView(camera);
      } else {
        convertTransformFor2D(camera);
      }
    } else {
      Matrix4_default.clone(camera._transform, camera._actualTransform);
    }
    Matrix4_default.inverseTransformation(
      camera._actualTransform,
      camera._actualInvTransform
    );
    camera._modeChanged = false;
  }
  const transform4 = camera._actualTransform;
  if (positionChanged || transformChanged) {
    camera._positionWC = Matrix4_default.multiplyByPoint(
      transform4,
      position,
      camera._positionWC
    );
    if (mode2 === SceneMode_default.SCENE3D || mode2 === SceneMode_default.MORPHING) {
      camera._positionCartographic = camera._projection.ellipsoid.cartesianToCartographic(
        camera._positionWC,
        camera._positionCartographic
      );
    } else {
      const positionENU = scratchCartesian30;
      positionENU.x = camera._positionWC.y;
      positionENU.y = camera._positionWC.z;
      positionENU.z = camera._positionWC.x;
      if (mode2 === SceneMode_default.SCENE2D) {
        positionENU.z = height;
      }
      camera._projection.unproject(positionENU, camera._positionCartographic);
    }
  }
  if (directionChanged || upChanged || rightChanged) {
    const det = Cartesian3_default.dot(
      direction2,
      Cartesian3_default.cross(up, right, scratchCartesian30)
    );
    if (Math.abs(1 - det) > Math_default.EPSILON2) {
      const invUpMag = 1 / Cartesian3_default.magnitudeSquared(up);
      const scalar = Cartesian3_default.dot(up, direction2) * invUpMag;
      const w0 = Cartesian3_default.multiplyByScalar(
        direction2,
        scalar,
        scratchCartesian30
      );
      up = Cartesian3_default.normalize(
        Cartesian3_default.subtract(up, w0, camera._up),
        camera._up
      );
      Cartesian3_default.clone(up, camera.up);
      right = Cartesian3_default.cross(direction2, up, camera._right);
      Cartesian3_default.clone(right, camera.right);
    }
  }
  if (directionChanged || transformChanged) {
    camera._directionWC = Matrix4_default.multiplyByPointAsVector(
      transform4,
      direction2,
      camera._directionWC
    );
    Cartesian3_default.normalize(camera._directionWC, camera._directionWC);
  }
  if (upChanged || transformChanged) {
    camera._upWC = Matrix4_default.multiplyByPointAsVector(transform4, up, camera._upWC);
    Cartesian3_default.normalize(camera._upWC, camera._upWC);
  }
  if (rightChanged || transformChanged) {
    camera._rightWC = Matrix4_default.multiplyByPointAsVector(
      transform4,
      right,
      camera._rightWC
    );
    Cartesian3_default.normalize(camera._rightWC, camera._rightWC);
  }
  if (positionChanged || directionChanged || upChanged || rightChanged || transformChanged) {
    updateViewMatrix(camera);
  }
}
function getHeading(direction2, up) {
  let heading;
  if (!Math_default.equalsEpsilon(Math.abs(direction2.z), 1, Math_default.EPSILON3)) {
    heading = Math.atan2(direction2.y, direction2.x) - Math_default.PI_OVER_TWO;
  } else {
    heading = Math.atan2(up.y, up.x) - Math_default.PI_OVER_TWO;
  }
  return Math_default.TWO_PI - Math_default.zeroToTwoPi(heading);
}
function getPitch(direction2) {
  return Math_default.PI_OVER_TWO - Math_default.acosClamped(direction2.z);
}
function getRoll(direction2, up, right) {
  let roll = 0;
  if (!Math_default.equalsEpsilon(Math.abs(direction2.z), 1, Math_default.EPSILON3)) {
    roll = Math.atan2(-right.z, up.z);
    roll = Math_default.zeroToTwoPi(roll + Math_default.TWO_PI);
  }
  return roll;
}
var scratchHPRMatrix1 = new Matrix4_default();
var scratchHPRMatrix2 = new Matrix4_default();
Object.defineProperties(Camera.prototype, {
  transform: {
    get: function() {
      return this._transform;
    }
  },
  inverseTransform: {
    get: function() {
      updateMembers(this);
      return this._invTransform;
    }
  },
  viewMatrix: {
    get: function() {
      updateMembers(this);
      return this._viewMatrix;
    }
  },
  inverseViewMatrix: {
    get: function() {
      updateMembers(this);
      return this._invViewMatrix;
    }
  },
  positionCartographic: {
    get: function() {
      updateMembers(this);
      return this._positionCartographic;
    }
  },
  positionWC: {
    get: function() {
      updateMembers(this);
      return this._positionWC;
    }
  },
  directionWC: {
    get: function() {
      updateMembers(this);
      return this._directionWC;
    }
  },
  upWC: {
    get: function() {
      updateMembers(this);
      return this._upWC;
    }
  },
  rightWC: {
    get: function() {
      updateMembers(this);
      return this._rightWC;
    }
  },
  heading: {
    get: function() {
      if (this._mode !== SceneMode_default.MORPHING) {
        const ellipsoid = this._projection.ellipsoid;
        const oldTransform = Matrix4_default.clone(this._transform, scratchHPRMatrix1);
        const transform4 = Transforms_default.eastNorthUpToFixedFrame(
          this.positionWC,
          ellipsoid,
          scratchHPRMatrix2
        );
        this._setTransform(transform4);
        const heading = getHeading(this.direction, this.up);
        this._setTransform(oldTransform);
        return heading;
      }
      return void 0;
    }
  },
  pitch: {
    get: function() {
      if (this._mode !== SceneMode_default.MORPHING) {
        const ellipsoid = this._projection.ellipsoid;
        const oldTransform = Matrix4_default.clone(this._transform, scratchHPRMatrix1);
        const transform4 = Transforms_default.eastNorthUpToFixedFrame(
          this.positionWC,
          ellipsoid,
          scratchHPRMatrix2
        );
        this._setTransform(transform4);
        const pitch = getPitch(this.direction);
        this._setTransform(oldTransform);
        return pitch;
      }
      return void 0;
    }
  },
  roll: {
    get: function() {
      if (this._mode !== SceneMode_default.MORPHING) {
        const ellipsoid = this._projection.ellipsoid;
        const oldTransform = Matrix4_default.clone(this._transform, scratchHPRMatrix1);
        const transform4 = Transforms_default.eastNorthUpToFixedFrame(
          this.positionWC,
          ellipsoid,
          scratchHPRMatrix2
        );
        this._setTransform(transform4);
        const roll = getRoll(this.direction, this.up, this.right);
        this._setTransform(oldTransform);
        return roll;
      }
      return void 0;
    }
  },
  moveStart: {
    get: function() {
      return this._moveStart;
    }
  },
  moveEnd: {
    get: function() {
      return this._moveEnd;
    }
  },
  changed: {
    get: function() {
      return this._changed;
    }
  }
});
Camera.prototype.update = function(mode2) {
  if (!defined_default(mode2)) {
    throw new DeveloperError_default("mode is required.");
  }
  if (mode2 === SceneMode_default.SCENE2D && !(this.frustum instanceof OrthographicOffCenterFrustum_default)) {
    throw new DeveloperError_default(
      "An OrthographicOffCenterFrustum is required in 2D."
    );
  }
  if ((mode2 === SceneMode_default.SCENE3D || mode2 === SceneMode_default.COLUMBUS_VIEW) && !(this.frustum instanceof PerspectiveFrustum_default) && !(this.frustum instanceof OrthographicFrustum_default)) {
    throw new DeveloperError_default(
      "A PerspectiveFrustum or OrthographicFrustum is required in 3D and Columbus view"
    );
  }
  let updateFrustum = false;
  if (mode2 !== this._mode) {
    this._mode = mode2;
    this._modeChanged = mode2 !== SceneMode_default.MORPHING;
    updateFrustum = this._mode === SceneMode_default.SCENE2D;
  }
  if (updateFrustum) {
    const frustum = this._max2Dfrustum = this.frustum.clone();
    if (!(frustum instanceof OrthographicOffCenterFrustum_default)) {
      throw new DeveloperError_default(
        "The camera frustum is expected to be orthographic for 2D camera control."
      );
    }
    const maxZoomOut = 2;
    const ratio = frustum.top / frustum.right;
    frustum.right = this._maxCoord.x * maxZoomOut;
    frustum.left = -frustum.right;
    frustum.top = ratio * frustum.right;
    frustum.bottom = -frustum.top;
  }
  if (this._mode === SceneMode_default.SCENE2D) {
    clampMove2D(this, this.position);
  }
};
var setTransformPosition = new Cartesian3_default();
var setTransformUp = new Cartesian3_default();
var setTransformDirection = new Cartesian3_default();
Camera.prototype._setTransform = function(transform4) {
  const position = Cartesian3_default.clone(this.positionWC, setTransformPosition);
  const up = Cartesian3_default.clone(this.upWC, setTransformUp);
  const direction2 = Cartesian3_default.clone(this.directionWC, setTransformDirection);
  Matrix4_default.clone(transform4, this._transform);
  this._transformChanged = true;
  updateMembers(this);
  const inverse = this._actualInvTransform;
  Matrix4_default.multiplyByPoint(inverse, position, this.position);
  Matrix4_default.multiplyByPointAsVector(inverse, direction2, this.direction);
  Matrix4_default.multiplyByPointAsVector(inverse, up, this.up);
  Cartesian3_default.cross(this.direction, this.up, this.right);
  updateMembers(this);
};
var scratchAdjustOrthographicFrustumMousePosition = new Cartesian2_default();
var scratchPickRay = new Ray_default();
var scratchRayIntersection = new Cartesian3_default();
var scratchDepthIntersection = new Cartesian3_default();
function calculateOrthographicFrustumWidth(camera) {
  if (!Matrix4_default.equals(Matrix4_default.IDENTITY, camera.transform)) {
    return Cartesian3_default.magnitude(camera.position);
  }
  const scene = camera._scene;
  const globe = scene.globe;
  const mousePosition = scratchAdjustOrthographicFrustumMousePosition;
  mousePosition.x = scene.drawingBufferWidth / 2;
  mousePosition.y = scene.drawingBufferHeight / 2;
  let rayIntersection;
  if (defined_default(globe)) {
    const ray = camera.getPickRay(mousePosition, scratchPickRay);
    rayIntersection = globe.pickWorldCoordinates(
      ray,
      scene,
      true,
      scratchRayIntersection
    );
  }
  let depthIntersection;
  if (scene.pickPositionSupported) {
    depthIntersection = scene.pickPositionWorldCoordinates(
      mousePosition,
      scratchDepthIntersection
    );
  }
  let distance2;
  if (defined_default(rayIntersection) || defined_default(depthIntersection)) {
    const depthDistance = defined_default(depthIntersection) ? Cartesian3_default.distance(depthIntersection, camera.positionWC) : Number.POSITIVE_INFINITY;
    const rayDistance = defined_default(rayIntersection) ? Cartesian3_default.distance(rayIntersection, camera.positionWC) : Number.POSITIVE_INFINITY;
    distance2 = Math.min(depthDistance, rayDistance);
  } else {
    distance2 = Math.max(camera.positionCartographic.height, 0);
  }
  return distance2;
}
Camera.prototype._adjustOrthographicFrustum = function(zooming) {
  if (!(this.frustum instanceof OrthographicFrustum_default)) {
    return;
  }
  if (!zooming && this._positionCartographic.height < 15e4) {
    return;
  }
  this.frustum.width = calculateOrthographicFrustumWidth(this);
};
var scratchSetViewCartesian = new Cartesian3_default();
var scratchSetViewTransform1 = new Matrix4_default();
var scratchSetViewTransform2 = new Matrix4_default();
var scratchSetViewQuaternion = new Quaternion_default();
var scratchSetViewMatrix3 = new Matrix3_default();
var scratchSetViewCartographic = new Cartographic_default();
function setView3D(camera, position, hpr) {
  const currentTransform = Matrix4_default.clone(
    camera.transform,
    scratchSetViewTransform1
  );
  const localTransform = Transforms_default.eastNorthUpToFixedFrame(
    position,
    camera._projection.ellipsoid,
    scratchSetViewTransform2
  );
  camera._setTransform(localTransform);
  Cartesian3_default.clone(Cartesian3_default.ZERO, camera.position);
  hpr.heading = hpr.heading - Math_default.PI_OVER_TWO;
  const rotQuat = Quaternion_default.fromHeadingPitchRoll(
    hpr,
    scratchSetViewQuaternion
  );
  const rotMat = Matrix3_default.fromQuaternion(rotQuat, scratchSetViewMatrix3);
  Matrix3_default.getColumn(rotMat, 0, camera.direction);
  Matrix3_default.getColumn(rotMat, 2, camera.up);
  Cartesian3_default.cross(camera.direction, camera.up, camera.right);
  camera._setTransform(currentTransform);
  camera._adjustOrthographicFrustum(true);
}
function setViewCV(camera, position, hpr, convert) {
  const currentTransform = Matrix4_default.clone(
    camera.transform,
    scratchSetViewTransform1
  );
  camera._setTransform(Matrix4_default.IDENTITY);
  if (!Cartesian3_default.equals(position, camera.positionWC)) {
    if (convert) {
      const projection = camera._projection;
      const cartographic2 = projection.ellipsoid.cartesianToCartographic(
        position,
        scratchSetViewCartographic
      );
      position = projection.project(cartographic2, scratchSetViewCartesian);
    }
    Cartesian3_default.clone(position, camera.position);
  }
  hpr.heading = hpr.heading - Math_default.PI_OVER_TWO;
  const rotQuat = Quaternion_default.fromHeadingPitchRoll(
    hpr,
    scratchSetViewQuaternion
  );
  const rotMat = Matrix3_default.fromQuaternion(rotQuat, scratchSetViewMatrix3);
  Matrix3_default.getColumn(rotMat, 0, camera.direction);
  Matrix3_default.getColumn(rotMat, 2, camera.up);
  Cartesian3_default.cross(camera.direction, camera.up, camera.right);
  camera._setTransform(currentTransform);
  camera._adjustOrthographicFrustum(true);
}
function setView2D(camera, position, hpr, convert) {
  const currentTransform = Matrix4_default.clone(
    camera.transform,
    scratchSetViewTransform1
  );
  camera._setTransform(Matrix4_default.IDENTITY);
  if (!Cartesian3_default.equals(position, camera.positionWC)) {
    if (convert) {
      const projection = camera._projection;
      const cartographic2 = projection.ellipsoid.cartesianToCartographic(
        position,
        scratchSetViewCartographic
      );
      position = projection.project(cartographic2, scratchSetViewCartesian);
    }
    Cartesian2_default.clone(position, camera.position);
    const newLeft = -position.z * 0.5;
    const newRight = -newLeft;
    const frustum = camera.frustum;
    if (newRight > newLeft) {
      const ratio = frustum.top / frustum.right;
      frustum.right = newRight;
      frustum.left = newLeft;
      frustum.top = frustum.right * ratio;
      frustum.bottom = -frustum.top;
    }
  }
  if (camera._scene.mapMode2D === MapMode2D_default.ROTATE) {
    hpr.heading = hpr.heading - Math_default.PI_OVER_TWO;
    hpr.pitch = -Math_default.PI_OVER_TWO;
    hpr.roll = 0;
    const rotQuat = Quaternion_default.fromHeadingPitchRoll(
      hpr,
      scratchSetViewQuaternion
    );
    const rotMat = Matrix3_default.fromQuaternion(rotQuat, scratchSetViewMatrix3);
    Matrix3_default.getColumn(rotMat, 2, camera.up);
    Cartesian3_default.cross(camera.direction, camera.up, camera.right);
  }
  camera._setTransform(currentTransform);
}
var scratchToHPRDirection = new Cartesian3_default();
var scratchToHPRUp = new Cartesian3_default();
var scratchToHPRRight = new Cartesian3_default();
function directionUpToHeadingPitchRoll(camera, position, orientation, result) {
  const direction2 = Cartesian3_default.clone(
    orientation.direction,
    scratchToHPRDirection
  );
  const up = Cartesian3_default.clone(orientation.up, scratchToHPRUp);
  if (camera._scene.mode === SceneMode_default.SCENE3D) {
    const ellipsoid = camera._projection.ellipsoid;
    const transform4 = Transforms_default.eastNorthUpToFixedFrame(
      position,
      ellipsoid,
      scratchHPRMatrix1
    );
    const invTransform = Matrix4_default.inverseTransformation(
      transform4,
      scratchHPRMatrix2
    );
    Matrix4_default.multiplyByPointAsVector(invTransform, direction2, direction2);
    Matrix4_default.multiplyByPointAsVector(invTransform, up, up);
  }
  const right = Cartesian3_default.cross(direction2, up, scratchToHPRRight);
  result.heading = getHeading(direction2, up);
  result.pitch = getPitch(direction2);
  result.roll = getRoll(direction2, up, right);
  return result;
}
var scratchSetViewOptions = {
  destination: void 0,
  orientation: {
    direction: void 0,
    up: void 0,
    heading: void 0,
    pitch: void 0,
    roll: void 0
  },
  convert: void 0,
  endTransform: void 0
};
var scratchHpr = new HeadingPitchRoll_default();
Camera.prototype.setView = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let orientation = defaultValue_default(
    options.orientation,
    defaultValue_default.EMPTY_OBJECT
  );
  const mode2 = this._mode;
  if (mode2 === SceneMode_default.MORPHING) {
    return;
  }
  if (defined_default(options.endTransform)) {
    this._setTransform(options.endTransform);
  }
  let convert = defaultValue_default(options.convert, true);
  let destination = defaultValue_default(
    options.destination,
    Cartesian3_default.clone(this.positionWC, scratchSetViewCartesian)
  );
  if (defined_default(destination) && defined_default(destination.west)) {
    destination = this.getRectangleCameraCoordinates(
      destination,
      scratchSetViewCartesian
    );
    convert = false;
  }
  if (defined_default(orientation.direction)) {
    orientation = directionUpToHeadingPitchRoll(
      this,
      destination,
      orientation,
      scratchSetViewOptions.orientation
    );
  }
  scratchHpr.heading = defaultValue_default(orientation.heading, 0);
  scratchHpr.pitch = defaultValue_default(orientation.pitch, -Math_default.PI_OVER_TWO);
  scratchHpr.roll = defaultValue_default(orientation.roll, 0);
  if (mode2 === SceneMode_default.SCENE3D) {
    setView3D(this, destination, scratchHpr);
  } else if (mode2 === SceneMode_default.SCENE2D) {
    setView2D(this, destination, scratchHpr, convert);
  } else {
    setViewCV(this, destination, scratchHpr, convert);
  }
};
var pitchScratch = new Cartesian3_default();
Camera.prototype.flyHome = function(duration) {
  const mode2 = this._mode;
  if (mode2 === SceneMode_default.MORPHING) {
    this._scene.completeMorph();
  }
  if (mode2 === SceneMode_default.SCENE2D) {
    this.flyTo({
      destination: Camera.DEFAULT_VIEW_RECTANGLE,
      duration,
      endTransform: Matrix4_default.IDENTITY
    });
  } else if (mode2 === SceneMode_default.SCENE3D) {
    const destination = this.getRectangleCameraCoordinates(
      Camera.DEFAULT_VIEW_RECTANGLE
    );
    let mag = Cartesian3_default.magnitude(destination);
    mag += mag * Camera.DEFAULT_VIEW_FACTOR;
    Cartesian3_default.normalize(destination, destination);
    Cartesian3_default.multiplyByScalar(destination, mag, destination);
    this.flyTo({
      destination,
      duration,
      endTransform: Matrix4_default.IDENTITY
    });
  } else if (mode2 === SceneMode_default.COLUMBUS_VIEW) {
    const maxRadii = this._projection.ellipsoid.maximumRadius;
    let position = new Cartesian3_default(0, -1, 1);
    position = Cartesian3_default.multiplyByScalar(
      Cartesian3_default.normalize(position, position),
      5 * maxRadii,
      position
    );
    this.flyTo({
      destination: position,
      duration,
      orientation: {
        heading: 0,
        pitch: -Math.acos(Cartesian3_default.normalize(position, pitchScratch).z),
        roll: 0
      },
      endTransform: Matrix4_default.IDENTITY,
      convert: false
    });
  }
};
Camera.prototype.worldToCameraCoordinates = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian4_default();
  }
  updateMembers(this);
  return Matrix4_default.multiplyByVector(this._actualInvTransform, cartesian11, result);
};
Camera.prototype.worldToCameraCoordinatesPoint = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  updateMembers(this);
  return Matrix4_default.multiplyByPoint(this._actualInvTransform, cartesian11, result);
};
Camera.prototype.worldToCameraCoordinatesVector = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  updateMembers(this);
  return Matrix4_default.multiplyByPointAsVector(
    this._actualInvTransform,
    cartesian11,
    result
  );
};
Camera.prototype.cameraToWorldCoordinates = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian4_default();
  }
  updateMembers(this);
  return Matrix4_default.multiplyByVector(this._actualTransform, cartesian11, result);
};
Camera.prototype.cameraToWorldCoordinatesPoint = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  updateMembers(this);
  return Matrix4_default.multiplyByPoint(this._actualTransform, cartesian11, result);
};
Camera.prototype.cameraToWorldCoordinatesVector = function(cartesian11, result) {
  if (!defined_default(cartesian11)) {
    throw new DeveloperError_default("cartesian is required.");
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  updateMembers(this);
  return Matrix4_default.multiplyByPointAsVector(
    this._actualTransform,
    cartesian11,
    result
  );
};
function clampMove2D(camera, position) {
  const rotatable2D = camera._scene.mapMode2D === MapMode2D_default.ROTATE;
  const maxProjectedX = camera._maxCoord.x;
  const maxProjectedY = camera._maxCoord.y;
  let minX;
  let maxX;
  if (rotatable2D) {
    maxX = maxProjectedX;
    minX = -maxX;
  } else {
    maxX = position.x - maxProjectedX * 2;
    minX = position.x + maxProjectedX * 2;
  }
  if (position.x > maxProjectedX) {
    position.x = maxX;
  }
  if (position.x < -maxProjectedX) {
    position.x = minX;
  }
  if (position.y > maxProjectedY) {
    position.y = maxProjectedY;
  }
  if (position.y < -maxProjectedY) {
    position.y = -maxProjectedY;
  }
}
var moveScratch = new Cartesian3_default();
Camera.prototype.move = function(direction2, amount) {
  if (!defined_default(direction2)) {
    throw new DeveloperError_default("direction is required.");
  }
  const cameraPosition = this.position;
  Cartesian3_default.multiplyByScalar(direction2, amount, moveScratch);
  Cartesian3_default.add(cameraPosition, moveScratch, cameraPosition);
  if (this._mode === SceneMode_default.SCENE2D) {
    clampMove2D(this, cameraPosition);
  }
  this._adjustOrthographicFrustum(true);
};
Camera.prototype.moveForward = function(amount) {
  amount = defaultValue_default(amount, this.defaultMoveAmount);
  if (this._mode === SceneMode_default.SCENE2D) {
    zoom2D(this, amount);
  } else {
    this.move(this.direction, amount);
  }
};
Camera.prototype.moveBackward = function(amount) {
  amount = defaultValue_default(amount, this.defaultMoveAmount);
  if (this._mode === SceneMode_default.SCENE2D) {
    zoom2D(this, -amount);
  } else {
    this.move(this.direction, -amount);
  }
};
Camera.prototype.moveUp = function(amount) {
  amount = defaultValue_default(amount, this.defaultMoveAmount);
  this.move(this.up, amount);
};
Camera.prototype.moveDown = function(amount) {
  amount = defaultValue_default(amount, this.defaultMoveAmount);
  this.move(this.up, -amount);
};
Camera.prototype.moveRight = function(amount) {
  amount = defaultValue_default(amount, this.defaultMoveAmount);
  this.move(this.right, amount);
};
Camera.prototype.moveLeft = function(amount) {
  amount = defaultValue_default(amount, this.defaultMoveAmount);
  this.move(this.right, -amount);
};
Camera.prototype.lookLeft = function(amount) {
  amount = defaultValue_default(amount, this.defaultLookAmount);
  if (this._mode !== SceneMode_default.SCENE2D) {
    this.look(this.up, -amount);
  }
};
Camera.prototype.lookRight = function(amount) {
  amount = defaultValue_default(amount, this.defaultLookAmount);
  if (this._mode !== SceneMode_default.SCENE2D) {
    this.look(this.up, amount);
  }
};
Camera.prototype.lookUp = function(amount) {
  amount = defaultValue_default(amount, this.defaultLookAmount);
  if (this._mode !== SceneMode_default.SCENE2D) {
    this.look(this.right, -amount);
  }
};
Camera.prototype.lookDown = function(amount) {
  amount = defaultValue_default(amount, this.defaultLookAmount);
  if (this._mode !== SceneMode_default.SCENE2D) {
    this.look(this.right, amount);
  }
};
var lookScratchQuaternion = new Quaternion_default();
var lookScratchMatrix = new Matrix3_default();
Camera.prototype.look = function(axis, angle) {
  if (!defined_default(axis)) {
    throw new DeveloperError_default("axis is required.");
  }
  const turnAngle = defaultValue_default(angle, this.defaultLookAmount);
  const quaternion = Quaternion_default.fromAxisAngle(
    axis,
    -turnAngle,
    lookScratchQuaternion
  );
  const rotation = Matrix3_default.fromQuaternion(quaternion, lookScratchMatrix);
  const direction2 = this.direction;
  const up = this.up;
  const right = this.right;
  Matrix3_default.multiplyByVector(rotation, direction2, direction2);
  Matrix3_default.multiplyByVector(rotation, up, up);
  Matrix3_default.multiplyByVector(rotation, right, right);
};
Camera.prototype.twistLeft = function(amount) {
  amount = defaultValue_default(amount, this.defaultLookAmount);
  this.look(this.direction, amount);
};
Camera.prototype.twistRight = function(amount) {
  amount = defaultValue_default(amount, this.defaultLookAmount);
  this.look(this.direction, -amount);
};
var rotateScratchQuaternion = new Quaternion_default();
var rotateScratchMatrix = new Matrix3_default();
Camera.prototype.rotate = function(axis, angle) {
  if (!defined_default(axis)) {
    throw new DeveloperError_default("axis is required.");
  }
  const turnAngle = defaultValue_default(angle, this.defaultRotateAmount);
  const quaternion = Quaternion_default.fromAxisAngle(
    axis,
    -turnAngle,
    rotateScratchQuaternion
  );
  const rotation = Matrix3_default.fromQuaternion(quaternion, rotateScratchMatrix);
  Matrix3_default.multiplyByVector(rotation, this.position, this.position);
  Matrix3_default.multiplyByVector(rotation, this.direction, this.direction);
  Matrix3_default.multiplyByVector(rotation, this.up, this.up);
  Cartesian3_default.cross(this.direction, this.up, this.right);
  Cartesian3_default.cross(this.right, this.direction, this.up);
  this._adjustOrthographicFrustum(false);
};
Camera.prototype.rotateDown = function(angle) {
  angle = defaultValue_default(angle, this.defaultRotateAmount);
  rotateVertical(this, angle);
};
Camera.prototype.rotateUp = function(angle) {
  angle = defaultValue_default(angle, this.defaultRotateAmount);
  rotateVertical(this, -angle);
};
var rotateVertScratchP = new Cartesian3_default();
var rotateVertScratchA = new Cartesian3_default();
var rotateVertScratchTan = new Cartesian3_default();
var rotateVertScratchNegate = new Cartesian3_default();
function rotateVertical(camera, angle) {
  const position = camera.position;
  if (defined_default(camera.constrainedAxis) && !Cartesian3_default.equalsEpsilon(
    camera.position,
    Cartesian3_default.ZERO,
    Math_default.EPSILON2
  )) {
    const p2 = Cartesian3_default.normalize(position, rotateVertScratchP);
    const northParallel = Cartesian3_default.equalsEpsilon(
      p2,
      camera.constrainedAxis,
      Math_default.EPSILON2
    );
    const southParallel = Cartesian3_default.equalsEpsilon(
      p2,
      Cartesian3_default.negate(camera.constrainedAxis, rotateVertScratchNegate),
      Math_default.EPSILON2
    );
    if (!northParallel && !southParallel) {
      const constrainedAxis = Cartesian3_default.normalize(
        camera.constrainedAxis,
        rotateVertScratchA
      );
      let dot2 = Cartesian3_default.dot(p2, constrainedAxis);
      let angleToAxis = Math_default.acosClamped(dot2);
      if (angle > 0 && angle > angleToAxis) {
        angle = angleToAxis - Math_default.EPSILON4;
      }
      dot2 = Cartesian3_default.dot(
        p2,
        Cartesian3_default.negate(constrainedAxis, rotateVertScratchNegate)
      );
      angleToAxis = Math_default.acosClamped(dot2);
      if (angle < 0 && -angle > angleToAxis) {
        angle = -angleToAxis + Math_default.EPSILON4;
      }
      const tangent = Cartesian3_default.cross(
        constrainedAxis,
        p2,
        rotateVertScratchTan
      );
      camera.rotate(tangent, angle);
    } else if (northParallel && angle < 0 || southParallel && angle > 0) {
      camera.rotate(camera.right, angle);
    }
  } else {
    camera.rotate(camera.right, angle);
  }
}
Camera.prototype.rotateRight = function(angle) {
  angle = defaultValue_default(angle, this.defaultRotateAmount);
  rotateHorizontal(this, -angle);
};
Camera.prototype.rotateLeft = function(angle) {
  angle = defaultValue_default(angle, this.defaultRotateAmount);
  rotateHorizontal(this, angle);
};
function rotateHorizontal(camera, angle) {
  if (defined_default(camera.constrainedAxis)) {
    camera.rotate(camera.constrainedAxis, angle);
  } else {
    camera.rotate(camera.up, angle);
  }
}
function zoom2D(camera, amount) {
  const frustum = camera.frustum;
  if (!(frustum instanceof OrthographicOffCenterFrustum_default) || !defined_default(frustum.left) || !defined_default(frustum.right) || !defined_default(frustum.bottom) || !defined_default(frustum.top)) {
    throw new DeveloperError_default(
      "The camera frustum is expected to be orthographic for 2D camera control."
    );
  }
  let ratio;
  amount = amount * 0.5;
  if (Math.abs(frustum.top) + Math.abs(frustum.bottom) > Math.abs(frustum.left) + Math.abs(frustum.right)) {
    let newTop = frustum.top - amount;
    let newBottom = frustum.bottom + amount;
    let maxBottom = camera._maxCoord.y;
    if (camera._scene.mapMode2D === MapMode2D_default.ROTATE) {
      maxBottom *= camera.maximumZoomFactor;
    }
    if (newBottom > maxBottom) {
      newBottom = maxBottom;
      newTop = -maxBottom;
    }
    if (newTop <= newBottom) {
      newTop = 1;
      newBottom = -1;
    }
    ratio = frustum.right / frustum.top;
    frustum.top = newTop;
    frustum.bottom = newBottom;
    frustum.right = frustum.top * ratio;
    frustum.left = -frustum.right;
  } else {
    let newRight = frustum.right - amount;
    let newLeft = frustum.left + amount;
    let maxRight = camera._maxCoord.x;
    if (camera._scene.mapMode2D === MapMode2D_default.ROTATE) {
      maxRight *= camera.maximumZoomFactor;
    }
    if (newRight > maxRight) {
      newRight = maxRight;
      newLeft = -maxRight;
    }
    if (newRight <= newLeft) {
      newRight = 1;
      newLeft = -1;
    }
    ratio = frustum.top / frustum.right;
    frustum.right = newRight;
    frustum.left = newLeft;
    frustum.top = frustum.right * ratio;
    frustum.bottom = -frustum.top;
  }
}
function zoom3D(camera, amount) {
  camera.move(camera.direction, amount);
}
Camera.prototype.zoomIn = function(amount) {
  amount = defaultValue_default(amount, this.defaultZoomAmount);
  if (this._mode === SceneMode_default.SCENE2D) {
    zoom2D(this, amount);
  } else {
    zoom3D(this, amount);
  }
};
Camera.prototype.zoomOut = function(amount) {
  amount = defaultValue_default(amount, this.defaultZoomAmount);
  if (this._mode === SceneMode_default.SCENE2D) {
    zoom2D(this, -amount);
  } else {
    zoom3D(this, -amount);
  }
};
Camera.prototype.getMagnitude = function() {
  if (this._mode === SceneMode_default.SCENE3D) {
    return Cartesian3_default.magnitude(this.position);
  } else if (this._mode === SceneMode_default.COLUMBUS_VIEW) {
    return Math.abs(this.position.z);
  } else if (this._mode === SceneMode_default.SCENE2D) {
    return Math.max(
      this.frustum.right - this.frustum.left,
      this.frustum.top - this.frustum.bottom
    );
  }
};
var scratchLookAtMatrix4 = new Matrix4_default();
Camera.prototype.lookAt = function(target, offset2) {
  if (!defined_default(target)) {
    throw new DeveloperError_default("target is required");
  }
  if (!defined_default(offset2)) {
    throw new DeveloperError_default("offset is required");
  }
  if (this._mode === SceneMode_default.MORPHING) {
    throw new DeveloperError_default("lookAt is not supported while morphing.");
  }
  const transform4 = Transforms_default.eastNorthUpToFixedFrame(
    target,
    Ellipsoid_default.WGS84,
    scratchLookAtMatrix4
  );
  this.lookAtTransform(transform4, offset2);
};
var scratchLookAtHeadingPitchRangeOffset = new Cartesian3_default();
var scratchLookAtHeadingPitchRangeQuaternion1 = new Quaternion_default();
var scratchLookAtHeadingPitchRangeQuaternion2 = new Quaternion_default();
var scratchHeadingPitchRangeMatrix3 = new Matrix3_default();
function offsetFromHeadingPitchRange(heading, pitch, range2) {
  pitch = Math_default.clamp(
    pitch,
    -Math_default.PI_OVER_TWO,
    Math_default.PI_OVER_TWO
  );
  heading = Math_default.zeroToTwoPi(heading) - Math_default.PI_OVER_TWO;
  const pitchQuat = Quaternion_default.fromAxisAngle(
    Cartesian3_default.UNIT_Y,
    -pitch,
    scratchLookAtHeadingPitchRangeQuaternion1
  );
  const headingQuat = Quaternion_default.fromAxisAngle(
    Cartesian3_default.UNIT_Z,
    -heading,
    scratchLookAtHeadingPitchRangeQuaternion2
  );
  const rotQuat = Quaternion_default.multiply(headingQuat, pitchQuat, headingQuat);
  const rotMatrix3 = Matrix3_default.fromQuaternion(
    rotQuat,
    scratchHeadingPitchRangeMatrix3
  );
  const offset2 = Cartesian3_default.clone(
    Cartesian3_default.UNIT_X,
    scratchLookAtHeadingPitchRangeOffset
  );
  Matrix3_default.multiplyByVector(rotMatrix3, offset2, offset2);
  Cartesian3_default.negate(offset2, offset2);
  Cartesian3_default.multiplyByScalar(offset2, range2, offset2);
  return offset2;
}
Camera.prototype.lookAtTransform = function(transform4, offset2) {
  if (!defined_default(transform4)) {
    throw new DeveloperError_default("transform is required");
  }
  if (this._mode === SceneMode_default.MORPHING) {
    throw new DeveloperError_default(
      "lookAtTransform is not supported while morphing."
    );
  }
  this._setTransform(transform4);
  if (!defined_default(offset2)) {
    return;
  }
  let cartesianOffset;
  if (defined_default(offset2.heading)) {
    cartesianOffset = offsetFromHeadingPitchRange(
      offset2.heading,
      offset2.pitch,
      offset2.range
    );
  } else {
    cartesianOffset = offset2;
  }
  if (this._mode === SceneMode_default.SCENE2D) {
    Cartesian2_default.clone(Cartesian2_default.ZERO, this.position);
    Cartesian3_default.negate(cartesianOffset, this.up);
    this.up.z = 0;
    if (Cartesian3_default.magnitudeSquared(this.up) < Math_default.EPSILON10) {
      Cartesian3_default.clone(Cartesian3_default.UNIT_Y, this.up);
    }
    Cartesian3_default.normalize(this.up, this.up);
    this._setTransform(Matrix4_default.IDENTITY);
    Cartesian3_default.negate(Cartesian3_default.UNIT_Z, this.direction);
    Cartesian3_default.cross(this.direction, this.up, this.right);
    Cartesian3_default.normalize(this.right, this.right);
    const frustum = this.frustum;
    const ratio = frustum.top / frustum.right;
    frustum.right = Cartesian3_default.magnitude(cartesianOffset) * 0.5;
    frustum.left = -frustum.right;
    frustum.top = ratio * frustum.right;
    frustum.bottom = -frustum.top;
    this._setTransform(transform4);
    return;
  }
  Cartesian3_default.clone(cartesianOffset, this.position);
  Cartesian3_default.negate(this.position, this.direction);
  Cartesian3_default.normalize(this.direction, this.direction);
  Cartesian3_default.cross(this.direction, Cartesian3_default.UNIT_Z, this.right);
  if (Cartesian3_default.magnitudeSquared(this.right) < Math_default.EPSILON10) {
    Cartesian3_default.clone(Cartesian3_default.UNIT_X, this.right);
  }
  Cartesian3_default.normalize(this.right, this.right);
  Cartesian3_default.cross(this.right, this.direction, this.up);
  Cartesian3_default.normalize(this.up, this.up);
  this._adjustOrthographicFrustum(true);
};
var viewRectangle3DCartographic1 = new Cartographic_default();
var viewRectangle3DCartographic2 = new Cartographic_default();
var viewRectangle3DNorthEast = new Cartesian3_default();
var viewRectangle3DSouthWest = new Cartesian3_default();
var viewRectangle3DNorthWest = new Cartesian3_default();
var viewRectangle3DSouthEast = new Cartesian3_default();
var viewRectangle3DNorthCenter = new Cartesian3_default();
var viewRectangle3DSouthCenter = new Cartesian3_default();
var viewRectangle3DCenter = new Cartesian3_default();
var viewRectangle3DEquator = new Cartesian3_default();
var defaultRF = {
  direction: new Cartesian3_default(),
  right: new Cartesian3_default(),
  up: new Cartesian3_default()
};
var viewRectangle3DEllipsoidGeodesic;
function computeD(direction2, upOrRight, corner, tanThetaOrPhi) {
  const opposite = Math.abs(Cartesian3_default.dot(upOrRight, corner));
  return opposite / tanThetaOrPhi - Cartesian3_default.dot(direction2, corner);
}
function rectangleCameraPosition3D(camera, rectangle, result, updateCamera) {
  const ellipsoid = camera._projection.ellipsoid;
  const cameraRF = updateCamera ? camera : defaultRF;
  const north = rectangle.north;
  const south = rectangle.south;
  let east = rectangle.east;
  const west = rectangle.west;
  if (west > east) {
    east += Math_default.TWO_PI;
  }
  const longitude = (west + east) * 0.5;
  let latitude;
  if (south < -Math_default.PI_OVER_TWO + Math_default.RADIANS_PER_DEGREE && north > Math_default.PI_OVER_TWO - Math_default.RADIANS_PER_DEGREE) {
    latitude = 0;
  } else {
    const northCartographic = viewRectangle3DCartographic1;
    northCartographic.longitude = longitude;
    northCartographic.latitude = north;
    northCartographic.height = 0;
    const southCartographic = viewRectangle3DCartographic2;
    southCartographic.longitude = longitude;
    southCartographic.latitude = south;
    southCartographic.height = 0;
    let ellipsoidGeodesic3 = viewRectangle3DEllipsoidGeodesic;
    if (!defined_default(ellipsoidGeodesic3) || ellipsoidGeodesic3.ellipsoid !== ellipsoid) {
      viewRectangle3DEllipsoidGeodesic = ellipsoidGeodesic3 = new EllipsoidGeodesic_default(
        void 0,
        void 0,
        ellipsoid
      );
    }
    ellipsoidGeodesic3.setEndPoints(northCartographic, southCartographic);
    latitude = ellipsoidGeodesic3.interpolateUsingFraction(
      0.5,
      viewRectangle3DCartographic1
    ).latitude;
  }
  const centerCartographic = viewRectangle3DCartographic1;
  centerCartographic.longitude = longitude;
  centerCartographic.latitude = latitude;
  centerCartographic.height = 0;
  const center = ellipsoid.cartographicToCartesian(
    centerCartographic,
    viewRectangle3DCenter
  );
  const cart = viewRectangle3DCartographic1;
  cart.longitude = east;
  cart.latitude = north;
  const northEast = ellipsoid.cartographicToCartesian(
    cart,
    viewRectangle3DNorthEast
  );
  cart.longitude = west;
  const northWest = ellipsoid.cartographicToCartesian(
    cart,
    viewRectangle3DNorthWest
  );
  cart.longitude = longitude;
  const northCenter = ellipsoid.cartographicToCartesian(
    cart,
    viewRectangle3DNorthCenter
  );
  cart.latitude = south;
  const southCenter = ellipsoid.cartographicToCartesian(
    cart,
    viewRectangle3DSouthCenter
  );
  cart.longitude = east;
  const southEast = ellipsoid.cartographicToCartesian(
    cart,
    viewRectangle3DSouthEast
  );
  cart.longitude = west;
  const southWest = ellipsoid.cartographicToCartesian(
    cart,
    viewRectangle3DSouthWest
  );
  Cartesian3_default.subtract(northWest, center, northWest);
  Cartesian3_default.subtract(southEast, center, southEast);
  Cartesian3_default.subtract(northEast, center, northEast);
  Cartesian3_default.subtract(southWest, center, southWest);
  Cartesian3_default.subtract(northCenter, center, northCenter);
  Cartesian3_default.subtract(southCenter, center, southCenter);
  const direction2 = ellipsoid.geodeticSurfaceNormal(center, cameraRF.direction);
  Cartesian3_default.negate(direction2, direction2);
  const right = Cartesian3_default.cross(direction2, Cartesian3_default.UNIT_Z, cameraRF.right);
  Cartesian3_default.normalize(right, right);
  const up = Cartesian3_default.cross(right, direction2, cameraRF.up);
  let d;
  if (camera.frustum instanceof OrthographicFrustum_default) {
    const width = Math.max(
      Cartesian3_default.distance(northEast, northWest),
      Cartesian3_default.distance(southEast, southWest)
    );
    const height = Math.max(
      Cartesian3_default.distance(northEast, southEast),
      Cartesian3_default.distance(northWest, southWest)
    );
    let rightScalar;
    let topScalar;
    const ratio = camera.frustum._offCenterFrustum.right / camera.frustum._offCenterFrustum.top;
    const heightRatio = height * ratio;
    if (width > heightRatio) {
      rightScalar = width;
      topScalar = rightScalar / ratio;
    } else {
      topScalar = height;
      rightScalar = heightRatio;
    }
    d = Math.max(rightScalar, topScalar);
  } else {
    const tanPhi = Math.tan(camera.frustum.fovy * 0.5);
    const tanTheta = camera.frustum.aspectRatio * tanPhi;
    d = Math.max(
      computeD(direction2, up, northWest, tanPhi),
      computeD(direction2, up, southEast, tanPhi),
      computeD(direction2, up, northEast, tanPhi),
      computeD(direction2, up, southWest, tanPhi),
      computeD(direction2, up, northCenter, tanPhi),
      computeD(direction2, up, southCenter, tanPhi),
      computeD(direction2, right, northWest, tanTheta),
      computeD(direction2, right, southEast, tanTheta),
      computeD(direction2, right, northEast, tanTheta),
      computeD(direction2, right, southWest, tanTheta),
      computeD(direction2, right, northCenter, tanTheta),
      computeD(direction2, right, southCenter, tanTheta)
    );
    if (south < 0 && north > 0) {
      const equatorCartographic = viewRectangle3DCartographic1;
      equatorCartographic.longitude = west;
      equatorCartographic.latitude = 0;
      equatorCartographic.height = 0;
      let equatorPosition = ellipsoid.cartographicToCartesian(
        equatorCartographic,
        viewRectangle3DEquator
      );
      Cartesian3_default.subtract(equatorPosition, center, equatorPosition);
      d = Math.max(
        d,
        computeD(direction2, up, equatorPosition, tanPhi),
        computeD(direction2, right, equatorPosition, tanTheta)
      );
      equatorCartographic.longitude = east;
      equatorPosition = ellipsoid.cartographicToCartesian(
        equatorCartographic,
        viewRectangle3DEquator
      );
      Cartesian3_default.subtract(equatorPosition, center, equatorPosition);
      d = Math.max(
        d,
        computeD(direction2, up, equatorPosition, tanPhi),
        computeD(direction2, right, equatorPosition, tanTheta)
      );
    }
  }
  return Cartesian3_default.add(
    center,
    Cartesian3_default.multiplyByScalar(direction2, -d, viewRectangle3DEquator),
    result
  );
}
var viewRectangleCVCartographic = new Cartographic_default();
var viewRectangleCVNorthEast = new Cartesian3_default();
var viewRectangleCVSouthWest = new Cartesian3_default();
function rectangleCameraPositionColumbusView(camera, rectangle, result) {
  const projection = camera._projection;
  if (rectangle.west > rectangle.east) {
    rectangle = Rectangle_default.MAX_VALUE;
  }
  const transform4 = camera._actualTransform;
  const invTransform = camera._actualInvTransform;
  const cart = viewRectangleCVCartographic;
  cart.longitude = rectangle.east;
  cart.latitude = rectangle.north;
  const northEast = projection.project(cart, viewRectangleCVNorthEast);
  Matrix4_default.multiplyByPoint(transform4, northEast, northEast);
  Matrix4_default.multiplyByPoint(invTransform, northEast, northEast);
  cart.longitude = rectangle.west;
  cart.latitude = rectangle.south;
  const southWest = projection.project(cart, viewRectangleCVSouthWest);
  Matrix4_default.multiplyByPoint(transform4, southWest, southWest);
  Matrix4_default.multiplyByPoint(invTransform, southWest, southWest);
  result.x = (northEast.x - southWest.x) * 0.5 + southWest.x;
  result.y = (northEast.y - southWest.y) * 0.5 + southWest.y;
  if (defined_default(camera.frustum.fovy)) {
    const tanPhi = Math.tan(camera.frustum.fovy * 0.5);
    const tanTheta = camera.frustum.aspectRatio * tanPhi;
    result.z = Math.max(
      (northEast.x - southWest.x) / tanTheta,
      (northEast.y - southWest.y) / tanPhi
    ) * 0.5;
  } else {
    const width = northEast.x - southWest.x;
    const height = northEast.y - southWest.y;
    result.z = Math.max(width, height);
  }
  return result;
}
var viewRectangle2DCartographic = new Cartographic_default();
var viewRectangle2DNorthEast = new Cartesian3_default();
var viewRectangle2DSouthWest = new Cartesian3_default();
function rectangleCameraPosition2D(camera, rectangle, result) {
  const projection = camera._projection;
  let east = rectangle.east;
  if (rectangle.west > rectangle.east) {
    if (camera._scene.mapMode2D === MapMode2D_default.INFINITE_SCROLL) {
      east += Math_default.TWO_PI;
    } else {
      rectangle = Rectangle_default.MAX_VALUE;
      east = rectangle.east;
    }
  }
  let cart = viewRectangle2DCartographic;
  cart.longitude = east;
  cart.latitude = rectangle.north;
  const northEast = projection.project(cart, viewRectangle2DNorthEast);
  cart.longitude = rectangle.west;
  cart.latitude = rectangle.south;
  const southWest = projection.project(cart, viewRectangle2DSouthWest);
  const width = Math.abs(northEast.x - southWest.x) * 0.5;
  let height = Math.abs(northEast.y - southWest.y) * 0.5;
  let right, top;
  const ratio = camera.frustum.right / camera.frustum.top;
  const heightRatio = height * ratio;
  if (width > heightRatio) {
    right = width;
    top = right / ratio;
  } else {
    top = height;
    right = heightRatio;
  }
  height = Math.max(2 * right, 2 * top);
  result.x = (northEast.x - southWest.x) * 0.5 + southWest.x;
  result.y = (northEast.y - southWest.y) * 0.5 + southWest.y;
  cart = projection.unproject(result, cart);
  cart.height = height;
  result = projection.project(cart, result);
  return result;
}
Camera.prototype.getRectangleCameraCoordinates = function(rectangle, result) {
  if (!defined_default(rectangle)) {
    throw new DeveloperError_default("rectangle is required");
  }
  const mode2 = this._mode;
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  if (mode2 === SceneMode_default.SCENE3D) {
    return rectangleCameraPosition3D(this, rectangle, result);
  } else if (mode2 === SceneMode_default.COLUMBUS_VIEW) {
    return rectangleCameraPositionColumbusView(this, rectangle, result);
  } else if (mode2 === SceneMode_default.SCENE2D) {
    return rectangleCameraPosition2D(this, rectangle, result);
  }
  return void 0;
};
var pickEllipsoid3DRay = new Ray_default();
function pickEllipsoid3D(camera, windowPosition, ellipsoid, result) {
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  const ray = camera.getPickRay(windowPosition, pickEllipsoid3DRay);
  const intersection = IntersectionTests_default.rayEllipsoid(ray, ellipsoid);
  if (!intersection) {
    return void 0;
  }
  const t = intersection.start > 0 ? intersection.start : intersection.stop;
  return Ray_default.getPoint(ray, t, result);
}
var pickEllipsoid2DRay = new Ray_default();
function pickMap2D(camera, windowPosition, projection, result) {
  const ray = camera.getPickRay(windowPosition, pickEllipsoid2DRay);
  let position = ray.origin;
  position = Cartesian3_default.fromElements(position.y, position.z, 0, position);
  const cart = projection.unproject(position);
  if (cart.latitude < -Math_default.PI_OVER_TWO || cart.latitude > Math_default.PI_OVER_TWO) {
    return void 0;
  }
  return projection.ellipsoid.cartographicToCartesian(cart, result);
}
var pickEllipsoidCVRay = new Ray_default();
function pickMapColumbusView(camera, windowPosition, projection, result) {
  const ray = camera.getPickRay(windowPosition, pickEllipsoidCVRay);
  const scalar = -ray.origin.x / ray.direction.x;
  Ray_default.getPoint(ray, scalar, result);
  const cart = projection.unproject(new Cartesian3_default(result.y, result.z, 0));
  if (cart.latitude < -Math_default.PI_OVER_TWO || cart.latitude > Math_default.PI_OVER_TWO || cart.longitude < -Math.PI || cart.longitude > Math.PI) {
    return void 0;
  }
  return projection.ellipsoid.cartographicToCartesian(cart, result);
}
Camera.prototype.pickEllipsoid = function(windowPosition, ellipsoid, result) {
  if (!defined_default(windowPosition)) {
    throw new DeveloperError_default("windowPosition is required.");
  }
  const canvas = this._scene.canvas;
  if (canvas.clientWidth === 0 || canvas.clientHeight === 0) {
    return void 0;
  }
  if (!defined_default(result)) {
    result = new Cartesian3_default();
  }
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  if (this._mode === SceneMode_default.SCENE3D) {
    result = pickEllipsoid3D(this, windowPosition, ellipsoid, result);
  } else if (this._mode === SceneMode_default.SCENE2D) {
    result = pickMap2D(this, windowPosition, this._projection, result);
  } else if (this._mode === SceneMode_default.COLUMBUS_VIEW) {
    result = pickMapColumbusView(
      this,
      windowPosition,
      this._projection,
      result
    );
  } else {
    return void 0;
  }
  return result;
};
var pickPerspCenter = new Cartesian3_default();
var pickPerspXDir = new Cartesian3_default();
var pickPerspYDir = new Cartesian3_default();
function getPickRayPerspective(camera, windowPosition, result) {
  const canvas = camera._scene.canvas;
  const width = canvas.clientWidth;
  const height = canvas.clientHeight;
  const tanPhi = Math.tan(camera.frustum.fovy * 0.5);
  const tanTheta = camera.frustum.aspectRatio * tanPhi;
  const near = camera.frustum.near;
  const x = 2 / width * windowPosition.x - 1;
  const y = 2 / height * (height - windowPosition.y) - 1;
  const position = camera.positionWC;
  Cartesian3_default.clone(position, result.origin);
  const nearCenter = Cartesian3_default.multiplyByScalar(
    camera.directionWC,
    near,
    pickPerspCenter
  );
  Cartesian3_default.add(position, nearCenter, nearCenter);
  const xDir = Cartesian3_default.multiplyByScalar(
    camera.rightWC,
    x * near * tanTheta,
    pickPerspXDir
  );
  const yDir = Cartesian3_default.multiplyByScalar(
    camera.upWC,
    y * near * tanPhi,
    pickPerspYDir
  );
  const direction2 = Cartesian3_default.add(nearCenter, xDir, result.direction);
  Cartesian3_default.add(direction2, yDir, direction2);
  Cartesian3_default.subtract(direction2, position, direction2);
  Cartesian3_default.normalize(direction2, direction2);
  return result;
}
var scratchDirection2 = new Cartesian3_default();
function getPickRayOrthographic(camera, windowPosition, result) {
  const canvas = camera._scene.canvas;
  const width = canvas.clientWidth;
  const height = canvas.clientHeight;
  let frustum = camera.frustum;
  if (defined_default(frustum._offCenterFrustum)) {
    frustum = frustum._offCenterFrustum;
  }
  let x = 2 / width * windowPosition.x - 1;
  x *= (frustum.right - frustum.left) * 0.5;
  let y = 2 / height * (height - windowPosition.y) - 1;
  y *= (frustum.top - frustum.bottom) * 0.5;
  const origin = result.origin;
  Cartesian3_default.clone(camera.position, origin);
  Cartesian3_default.multiplyByScalar(camera.right, x, scratchDirection2);
  Cartesian3_default.add(scratchDirection2, origin, origin);
  Cartesian3_default.multiplyByScalar(camera.up, y, scratchDirection2);
  Cartesian3_default.add(scratchDirection2, origin, origin);
  Cartesian3_default.clone(camera.directionWC, result.direction);
  if (camera._mode === SceneMode_default.COLUMBUS_VIEW || camera._mode === SceneMode_default.SCENE2D) {
    Cartesian3_default.fromElements(
      result.origin.z,
      result.origin.x,
      result.origin.y,
      result.origin
    );
  }
  return result;
}
Camera.prototype.getPickRay = function(windowPosition, result) {
  if (!defined_default(windowPosition)) {
    throw new DeveloperError_default("windowPosition is required.");
  }
  if (!defined_default(result)) {
    result = new Ray_default();
  }
  const canvas = this._scene.canvas;
  if (canvas.clientWidth <= 0 || canvas.clientHeight <= 0) {
    return void 0;
  }
  const frustum = this.frustum;
  if (defined_default(frustum.aspectRatio) && defined_default(frustum.fov) && defined_default(frustum.near)) {
    return getPickRayPerspective(this, windowPosition, result);
  }
  return getPickRayOrthographic(this, windowPosition, result);
};
var scratchToCenter2 = new Cartesian3_default();
var scratchProj = new Cartesian3_default();
Camera.prototype.distanceToBoundingSphere = function(boundingSphere) {
  if (!defined_default(boundingSphere)) {
    throw new DeveloperError_default("boundingSphere is required.");
  }
  const toCenter = Cartesian3_default.subtract(
    this.positionWC,
    boundingSphere.center,
    scratchToCenter2
  );
  const proj2 = Cartesian3_default.multiplyByScalar(
    this.directionWC,
    Cartesian3_default.dot(toCenter, this.directionWC),
    scratchProj
  );
  return Math.max(0, Cartesian3_default.magnitude(proj2) - boundingSphere.radius);
};
var scratchPixelSize = new Cartesian2_default();
Camera.prototype.getPixelSize = function(boundingSphere, drawingBufferWidth, drawingBufferHeight) {
  if (!defined_default(boundingSphere)) {
    throw new DeveloperError_default("boundingSphere is required.");
  }
  if (!defined_default(drawingBufferWidth)) {
    throw new DeveloperError_default("drawingBufferWidth is required.");
  }
  if (!defined_default(drawingBufferHeight)) {
    throw new DeveloperError_default("drawingBufferHeight is required.");
  }
  const distance2 = this.distanceToBoundingSphere(boundingSphere);
  const pixelSize = this.frustum.getPixelDimensions(
    drawingBufferWidth,
    drawingBufferHeight,
    distance2,
    this._scene.pixelRatio,
    scratchPixelSize
  );
  return Math.max(pixelSize.x, pixelSize.y);
};
function createAnimationTemplateCV(camera, position, center, maxX, maxY, duration) {
  const newPosition = Cartesian3_default.clone(position);
  if (center.y > maxX) {
    newPosition.y -= center.y - maxX;
  } else if (center.y < -maxX) {
    newPosition.y += -maxX - center.y;
  }
  if (center.z > maxY) {
    newPosition.z -= center.z - maxY;
  } else if (center.z < -maxY) {
    newPosition.z += -maxY - center.z;
  }
  function updateCV2(value) {
    const interp = Cartesian3_default.lerp(
      position,
      newPosition,
      value.time,
      new Cartesian3_default()
    );
    camera.worldToCameraCoordinatesPoint(interp, camera.position);
  }
  return {
    easingFunction: EasingFunction_default.EXPONENTIAL_OUT,
    startObject: {
      time: 0
    },
    stopObject: {
      time: 1
    },
    duration,
    update: updateCV2
  };
}
var normalScratch5 = new Cartesian3_default();
var centerScratch5 = new Cartesian3_default();
var posScratch = new Cartesian3_default();
var scratchCartesian3Subtract = new Cartesian3_default();
function createAnimationCV(camera, duration) {
  let position = camera.position;
  const direction2 = camera.direction;
  const normal2 = camera.worldToCameraCoordinatesVector(
    Cartesian3_default.UNIT_X,
    normalScratch5
  );
  const scalar = -Cartesian3_default.dot(normal2, position) / Cartesian3_default.dot(normal2, direction2);
  const center = Cartesian3_default.add(
    position,
    Cartesian3_default.multiplyByScalar(direction2, scalar, centerScratch5),
    centerScratch5
  );
  camera.cameraToWorldCoordinatesPoint(center, center);
  position = camera.cameraToWorldCoordinatesPoint(camera.position, posScratch);
  const tanPhi = Math.tan(camera.frustum.fovy * 0.5);
  const tanTheta = camera.frustum.aspectRatio * tanPhi;
  const distToC = Cartesian3_default.magnitude(
    Cartesian3_default.subtract(position, center, scratchCartesian3Subtract)
  );
  const dWidth = tanTheta * distToC;
  const dHeight = tanPhi * distToC;
  const mapWidth = camera._maxCoord.x;
  const mapHeight = camera._maxCoord.y;
  const maxX = Math.max(dWidth - mapWidth, mapWidth);
  const maxY = Math.max(dHeight - mapHeight, mapHeight);
  if (position.z < -maxX || position.z > maxX || position.y < -maxY || position.y > maxY) {
    const translateX = center.y < -maxX || center.y > maxX;
    const translateY = center.z < -maxY || center.z > maxY;
    if (translateX || translateY) {
      return createAnimationTemplateCV(
        camera,
        position,
        center,
        maxX,
        maxY,
        duration
      );
    }
  }
  return void 0;
}
Camera.prototype.createCorrectPositionTween = function(duration) {
  if (!defined_default(duration)) {
    throw new DeveloperError_default("duration is required.");
  }
  if (this._mode === SceneMode_default.COLUMBUS_VIEW) {
    return createAnimationCV(this, duration);
  }
  return void 0;
};
var scratchFlyToDestination = new Cartesian3_default();
var newOptions = {
  destination: void 0,
  heading: void 0,
  pitch: void 0,
  roll: void 0,
  duration: void 0,
  complete: void 0,
  cancel: void 0,
  endTransform: void 0,
  maximumHeight: void 0,
  easingFunction: void 0
};
Camera.prototype.cancelFlight = function() {
  if (defined_default(this._currentFlight)) {
    this._currentFlight.cancelTween();
    this._currentFlight = void 0;
  }
};
Camera.prototype.completeFlight = function() {
  if (defined_default(this._currentFlight)) {
    this._currentFlight.cancelTween();
    const options = {
      destination: void 0,
      orientation: {
        heading: void 0,
        pitch: void 0,
        roll: void 0
      }
    };
    options.destination = newOptions.destination;
    options.orientation.heading = newOptions.heading;
    options.orientation.pitch = newOptions.pitch;
    options.orientation.roll = newOptions.roll;
    this.setView(options);
    if (defined_default(this._currentFlight.complete)) {
      this._currentFlight.complete();
    }
    this._currentFlight = void 0;
  }
};
Camera.prototype.flyTo = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let destination = options.destination;
  if (!defined_default(destination)) {
    throw new DeveloperError_default("destination is required.");
  }
  const mode2 = this._mode;
  if (mode2 === SceneMode_default.MORPHING) {
    return;
  }
  this.cancelFlight();
  let orientation = defaultValue_default(
    options.orientation,
    defaultValue_default.EMPTY_OBJECT
  );
  if (defined_default(orientation.direction)) {
    orientation = directionUpToHeadingPitchRoll(
      this,
      destination,
      orientation,
      scratchSetViewOptions.orientation
    );
  }
  if (defined_default(options.duration) && options.duration <= 0) {
    const setViewOptions = scratchSetViewOptions;
    setViewOptions.destination = options.destination;
    setViewOptions.orientation.heading = orientation.heading;
    setViewOptions.orientation.pitch = orientation.pitch;
    setViewOptions.orientation.roll = orientation.roll;
    setViewOptions.convert = options.convert;
    setViewOptions.endTransform = options.endTransform;
    this.setView(setViewOptions);
    if (typeof options.complete === "function") {
      options.complete();
    }
    return;
  }
  const isRectangle = defined_default(destination.west);
  if (isRectangle) {
    destination = this.getRectangleCameraCoordinates(
      destination,
      scratchFlyToDestination
    );
  }
  const that = this;
  let flightTween;
  newOptions.destination = destination;
  newOptions.heading = orientation.heading;
  newOptions.pitch = orientation.pitch;
  newOptions.roll = orientation.roll;
  newOptions.duration = options.duration;
  newOptions.complete = function() {
    if (flightTween === that._currentFlight) {
      that._currentFlight = void 0;
    }
    if (defined_default(options.complete)) {
      options.complete();
    }
  };
  newOptions.cancel = options.cancel;
  newOptions.endTransform = options.endTransform;
  newOptions.convert = isRectangle ? false : options.convert;
  newOptions.maximumHeight = options.maximumHeight;
  newOptions.pitchAdjustHeight = options.pitchAdjustHeight;
  newOptions.flyOverLongitude = options.flyOverLongitude;
  newOptions.flyOverLongitudeWeight = options.flyOverLongitudeWeight;
  newOptions.easingFunction = options.easingFunction;
  const scene = this._scene;
  const tweenOptions = CameraFlightPath_default.createTween(scene, newOptions);
  if (tweenOptions.duration === 0) {
    if (typeof tweenOptions.complete === "function") {
      tweenOptions.complete();
    }
    return;
  }
  flightTween = scene.tweens.add(tweenOptions);
  this._currentFlight = flightTween;
  let preloadFlightCamera = this._scene.preloadFlightCamera;
  if (this._mode !== SceneMode_default.SCENE2D) {
    if (!defined_default(preloadFlightCamera)) {
      preloadFlightCamera = Camera.clone(this);
    }
    preloadFlightCamera.setView({
      destination,
      orientation
    });
    this._scene.preloadFlightCullingVolume = preloadFlightCamera.frustum.computeCullingVolume(
      preloadFlightCamera.positionWC,
      preloadFlightCamera.directionWC,
      preloadFlightCamera.upWC
    );
  }
};
function distanceToBoundingSphere3D(camera, radius) {
  const frustum = camera.frustum;
  const tanPhi = Math.tan(frustum.fovy * 0.5);
  const tanTheta = frustum.aspectRatio * tanPhi;
  return Math.max(radius / tanTheta, radius / tanPhi);
}
function distanceToBoundingSphere2D(camera, radius) {
  let frustum = camera.frustum;
  if (defined_default(frustum._offCenterFrustum)) {
    frustum = frustum._offCenterFrustum;
  }
  let right, top;
  const ratio = frustum.right / frustum.top;
  const heightRatio = radius * ratio;
  if (radius > heightRatio) {
    right = radius;
    top = right / ratio;
  } else {
    top = radius;
    right = heightRatio;
  }
  return Math.max(right, top) * 1.5;
}
var MINIMUM_ZOOM = 100;
function adjustBoundingSphereOffset(camera, boundingSphere, offset2) {
  offset2 = HeadingPitchRange_default.clone(
    defined_default(offset2) ? offset2 : Camera.DEFAULT_OFFSET
  );
  const minimumZoom = camera._scene.screenSpaceCameraController.minimumZoomDistance;
  const maximumZoom = camera._scene.screenSpaceCameraController.maximumZoomDistance;
  const range2 = offset2.range;
  if (!defined_default(range2) || range2 === 0) {
    const radius = boundingSphere.radius;
    if (radius === 0) {
      offset2.range = MINIMUM_ZOOM;
    } else if (camera.frustum instanceof OrthographicFrustum_default || camera._mode === SceneMode_default.SCENE2D) {
      offset2.range = distanceToBoundingSphere2D(camera, radius);
    } else {
      offset2.range = distanceToBoundingSphere3D(camera, radius);
    }
    offset2.range = Math_default.clamp(offset2.range, minimumZoom, maximumZoom);
  }
  return offset2;
}
Camera.prototype.viewBoundingSphere = function(boundingSphere, offset2) {
  if (!defined_default(boundingSphere)) {
    throw new DeveloperError_default("boundingSphere is required.");
  }
  if (this._mode === SceneMode_default.MORPHING) {
    throw new DeveloperError_default(
      "viewBoundingSphere is not supported while morphing."
    );
  }
  offset2 = adjustBoundingSphereOffset(this, boundingSphere, offset2);
  this.lookAt(boundingSphere.center, offset2);
};
var scratchflyToBoundingSphereTransform = new Matrix4_default();
var scratchflyToBoundingSphereDestination = new Cartesian3_default();
var scratchflyToBoundingSphereDirection = new Cartesian3_default();
var scratchflyToBoundingSphereUp = new Cartesian3_default();
var scratchflyToBoundingSphereRight = new Cartesian3_default();
var scratchFlyToBoundingSphereCart4 = new Cartesian4_default();
var scratchFlyToBoundingSphereQuaternion = new Quaternion_default();
var scratchFlyToBoundingSphereMatrix3 = new Matrix3_default();
Camera.prototype.flyToBoundingSphere = function(boundingSphere, options) {
  if (!defined_default(boundingSphere)) {
    throw new DeveloperError_default("boundingSphere is required.");
  }
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const scene2D = this._mode === SceneMode_default.SCENE2D || this._mode === SceneMode_default.COLUMBUS_VIEW;
  this._setTransform(Matrix4_default.IDENTITY);
  const offset2 = adjustBoundingSphereOffset(
    this,
    boundingSphere,
    options.offset
  );
  let position;
  if (scene2D) {
    position = Cartesian3_default.multiplyByScalar(
      Cartesian3_default.UNIT_Z,
      offset2.range,
      scratchflyToBoundingSphereDestination
    );
  } else {
    position = offsetFromHeadingPitchRange(
      offset2.heading,
      offset2.pitch,
      offset2.range
    );
  }
  const transform4 = Transforms_default.eastNorthUpToFixedFrame(
    boundingSphere.center,
    Ellipsoid_default.WGS84,
    scratchflyToBoundingSphereTransform
  );
  Matrix4_default.multiplyByPoint(transform4, position, position);
  let direction2;
  let up;
  if (!scene2D) {
    direction2 = Cartesian3_default.subtract(
      boundingSphere.center,
      position,
      scratchflyToBoundingSphereDirection
    );
    Cartesian3_default.normalize(direction2, direction2);
    up = Matrix4_default.multiplyByPointAsVector(
      transform4,
      Cartesian3_default.UNIT_Z,
      scratchflyToBoundingSphereUp
    );
    if (1 - Math.abs(Cartesian3_default.dot(direction2, up)) < Math_default.EPSILON6) {
      const rotateQuat = Quaternion_default.fromAxisAngle(
        direction2,
        offset2.heading,
        scratchFlyToBoundingSphereQuaternion
      );
      const rotation = Matrix3_default.fromQuaternion(
        rotateQuat,
        scratchFlyToBoundingSphereMatrix3
      );
      Cartesian3_default.fromCartesian4(
        Matrix4_default.getColumn(transform4, 1, scratchFlyToBoundingSphereCart4),
        up
      );
      Matrix3_default.multiplyByVector(rotation, up, up);
    }
    const right = Cartesian3_default.cross(
      direction2,
      up,
      scratchflyToBoundingSphereRight
    );
    Cartesian3_default.cross(right, direction2, up);
    Cartesian3_default.normalize(up, up);
  }
  this.flyTo({
    destination: position,
    orientation: {
      direction: direction2,
      up
    },
    duration: options.duration,
    complete: options.complete,
    cancel: options.cancel,
    endTransform: options.endTransform,
    maximumHeight: options.maximumHeight,
    easingFunction: options.easingFunction,
    flyOverLongitude: options.flyOverLongitude,
    flyOverLongitudeWeight: options.flyOverLongitudeWeight,
    pitchAdjustHeight: options.pitchAdjustHeight
  });
};
var scratchCartesian3_1 = new Cartesian3_default();
var scratchCartesian3_2 = new Cartesian3_default();
var scratchCartesian3_3 = new Cartesian3_default();
var scratchCartesian3_4 = new Cartesian3_default();
var horizonPoints = [
  new Cartesian3_default(),
  new Cartesian3_default(),
  new Cartesian3_default(),
  new Cartesian3_default()
];
function computeHorizonQuad(camera, ellipsoid) {
  const radii = ellipsoid.radii;
  const p2 = camera.positionWC;
  const q = Cartesian3_default.multiplyComponents(
    ellipsoid.oneOverRadii,
    p2,
    scratchCartesian3_1
  );
  const qMagnitude = Cartesian3_default.magnitude(q);
  const qUnit = Cartesian3_default.normalize(q, scratchCartesian3_2);
  let eUnit;
  let nUnit;
  if (Cartesian3_default.equalsEpsilon(qUnit, Cartesian3_default.UNIT_Z, Math_default.EPSILON10)) {
    eUnit = new Cartesian3_default(0, 1, 0);
    nUnit = new Cartesian3_default(0, 0, 1);
  } else {
    eUnit = Cartesian3_default.normalize(
      Cartesian3_default.cross(Cartesian3_default.UNIT_Z, qUnit, scratchCartesian3_3),
      scratchCartesian3_3
    );
    nUnit = Cartesian3_default.normalize(
      Cartesian3_default.cross(qUnit, eUnit, scratchCartesian3_4),
      scratchCartesian3_4
    );
  }
  const wMagnitude = Math.sqrt(Cartesian3_default.magnitudeSquared(q) - 1);
  const center = Cartesian3_default.multiplyByScalar(
    qUnit,
    1 / qMagnitude,
    scratchCartesian3_1
  );
  const scalar = wMagnitude / qMagnitude;
  const eastOffset = Cartesian3_default.multiplyByScalar(
    eUnit,
    scalar,
    scratchCartesian3_2
  );
  const northOffset = Cartesian3_default.multiplyByScalar(
    nUnit,
    scalar,
    scratchCartesian3_3
  );
  const upperLeft = Cartesian3_default.add(center, northOffset, horizonPoints[0]);
  Cartesian3_default.subtract(upperLeft, eastOffset, upperLeft);
  Cartesian3_default.multiplyComponents(radii, upperLeft, upperLeft);
  const lowerLeft = Cartesian3_default.subtract(center, northOffset, horizonPoints[1]);
  Cartesian3_default.subtract(lowerLeft, eastOffset, lowerLeft);
  Cartesian3_default.multiplyComponents(radii, lowerLeft, lowerLeft);
  const lowerRight = Cartesian3_default.subtract(center, northOffset, horizonPoints[2]);
  Cartesian3_default.add(lowerRight, eastOffset, lowerRight);
  Cartesian3_default.multiplyComponents(radii, lowerRight, lowerRight);
  const upperRight = Cartesian3_default.add(center, northOffset, horizonPoints[3]);
  Cartesian3_default.add(upperRight, eastOffset, upperRight);
  Cartesian3_default.multiplyComponents(radii, upperRight, upperRight);
  return horizonPoints;
}
var scratchPickCartesian2 = new Cartesian2_default();
var scratchRectCartesian = new Cartesian3_default();
var cartoArray = [
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default(),
  new Cartographic_default()
];
function addToResult(x, y, index2, camera, ellipsoid, computedHorizonQuad) {
  scratchPickCartesian2.x = x;
  scratchPickCartesian2.y = y;
  const r2 = camera.pickEllipsoid(
    scratchPickCartesian2,
    ellipsoid,
    scratchRectCartesian
  );
  if (defined_default(r2)) {
    cartoArray[index2] = ellipsoid.cartesianToCartographic(r2, cartoArray[index2]);
    return 1;
  }
  cartoArray[index2] = ellipsoid.cartesianToCartographic(
    computedHorizonQuad[index2],
    cartoArray[index2]
  );
  return 0;
}
Camera.prototype.computeViewRectangle = function(ellipsoid, result) {
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  const cullingVolume = this.frustum.computeCullingVolume(
    this.positionWC,
    this.directionWC,
    this.upWC
  );
  const boundingSphere = new BoundingSphere_default(
    Cartesian3_default.ZERO,
    ellipsoid.maximumRadius
  );
  const visibility = cullingVolume.computeVisibility(boundingSphere);
  if (visibility === Intersect_default.OUTSIDE) {
    return void 0;
  }
  const canvas = this._scene.canvas;
  const width = canvas.clientWidth;
  const height = canvas.clientHeight;
  let successfulPickCount = 0;
  const computedHorizonQuad = computeHorizonQuad(this, ellipsoid);
  successfulPickCount += addToResult(
    0,
    0,
    0,
    this,
    ellipsoid,
    computedHorizonQuad
  );
  successfulPickCount += addToResult(
    0,
    height,
    1,
    this,
    ellipsoid,
    computedHorizonQuad
  );
  successfulPickCount += addToResult(
    width,
    height,
    2,
    this,
    ellipsoid,
    computedHorizonQuad
  );
  successfulPickCount += addToResult(
    width,
    0,
    3,
    this,
    ellipsoid,
    computedHorizonQuad
  );
  if (successfulPickCount < 2) {
    return Rectangle_default.MAX_VALUE;
  }
  result = Rectangle_default.fromCartographicArray(cartoArray, result);
  let distance2 = 0;
  let lastLon = cartoArray[3].longitude;
  for (let i2 = 0; i2 < 4; ++i2) {
    const lon = cartoArray[i2].longitude;
    const diff = Math.abs(lon - lastLon);
    if (diff > Math_default.PI) {
      distance2 += Math_default.TWO_PI - diff;
    } else {
      distance2 += diff;
    }
    lastLon = lon;
  }
  if (Math_default.equalsEpsilon(
    Math.abs(distance2),
    Math_default.TWO_PI,
    Math_default.EPSILON9
  )) {
    result.west = -Math_default.PI;
    result.east = Math_default.PI;
    if (cartoArray[0].latitude >= 0) {
      result.north = Math_default.PI_OVER_TWO;
    } else {
      result.south = -Math_default.PI_OVER_TWO;
    }
  }
  return result;
};
Camera.prototype.switchToPerspectiveFrustum = function() {
  if (this._mode === SceneMode_default.SCENE2D || this.frustum instanceof PerspectiveFrustum_default) {
    return;
  }
  const scene = this._scene;
  this.frustum = new PerspectiveFrustum_default();
  this.frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
  this.frustum.fov = Math_default.toRadians(60);
};
Camera.prototype.switchToOrthographicFrustum = function() {
  if (this._mode === SceneMode_default.SCENE2D || this.frustum instanceof OrthographicFrustum_default) {
    return;
  }
  const frustumWidth = calculateOrthographicFrustumWidth(this);
  const scene = this._scene;
  this.frustum = new OrthographicFrustum_default();
  this.frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
  this.frustum.width = frustumWidth;
};
Camera.clone = function(camera, result) {
  if (!defined_default(result)) {
    result = new Camera(camera._scene);
  }
  Cartesian3_default.clone(camera.position, result.position);
  Cartesian3_default.clone(camera.direction, result.direction);
  Cartesian3_default.clone(camera.up, result.up);
  Cartesian3_default.clone(camera.right, result.right);
  Matrix4_default.clone(camera._transform, result.transform);
  result._transformChanged = true;
  result.frustum = camera.frustum.clone();
  return result;
};
var Camera_default = Camera;

// node_modules/cesium/Source/Scene/CameraEventType.js
var CameraEventType = {
  LEFT_DRAG: 0,
  RIGHT_DRAG: 1,
  MIDDLE_DRAG: 2,
  WHEEL: 3,
  PINCH: 4
};
var CameraEventType_default = Object.freeze(CameraEventType);

// node_modules/cesium/Source/Scene/CameraEventAggregator.js
function getKey(type, modifier) {
  let key = type;
  if (defined_default(modifier)) {
    key += `+${modifier}`;
  }
  return key;
}
function clonePinchMovement(pinchMovement, result) {
  Cartesian2_default.clone(
    pinchMovement.distance.startPosition,
    result.distance.startPosition
  );
  Cartesian2_default.clone(
    pinchMovement.distance.endPosition,
    result.distance.endPosition
  );
  Cartesian2_default.clone(
    pinchMovement.angleAndHeight.startPosition,
    result.angleAndHeight.startPosition
  );
  Cartesian2_default.clone(
    pinchMovement.angleAndHeight.endPosition,
    result.angleAndHeight.endPosition
  );
}
function listenToPinch(aggregator, modifier, canvas) {
  const key = getKey(CameraEventType_default.PINCH, modifier);
  const update7 = aggregator._update;
  const isDown = aggregator._isDown;
  const eventStartPosition = aggregator._eventStartPosition;
  const pressTime = aggregator._pressTime;
  const releaseTime = aggregator._releaseTime;
  update7[key] = true;
  isDown[key] = false;
  eventStartPosition[key] = new Cartesian2_default();
  let movement = aggregator._movement[key];
  if (!defined_default(movement)) {
    movement = aggregator._movement[key] = {};
  }
  movement.distance = {
    startPosition: new Cartesian2_default(),
    endPosition: new Cartesian2_default()
  };
  movement.angleAndHeight = {
    startPosition: new Cartesian2_default(),
    endPosition: new Cartesian2_default()
  };
  movement.prevAngle = 0;
  aggregator._eventHandler.setInputAction(
    function(event) {
      aggregator._buttonsDown++;
      isDown[key] = true;
      pressTime[key] = new Date();
      Cartesian2_default.lerp(
        event.position1,
        event.position2,
        0.5,
        eventStartPosition[key]
      );
    },
    ScreenSpaceEventType_default.PINCH_START,
    modifier
  );
  aggregator._eventHandler.setInputAction(
    function() {
      aggregator._buttonsDown = Math.max(aggregator._buttonsDown - 1, 0);
      isDown[key] = false;
      releaseTime[key] = new Date();
    },
    ScreenSpaceEventType_default.PINCH_END,
    modifier
  );
  aggregator._eventHandler.setInputAction(
    function(mouseMovement) {
      if (isDown[key]) {
        if (!update7[key]) {
          Cartesian2_default.clone(
            mouseMovement.distance.endPosition,
            movement.distance.endPosition
          );
          Cartesian2_default.clone(
            mouseMovement.angleAndHeight.endPosition,
            movement.angleAndHeight.endPosition
          );
        } else {
          clonePinchMovement(mouseMovement, movement);
          update7[key] = false;
          movement.prevAngle = movement.angleAndHeight.startPosition.x;
        }
        let angle = movement.angleAndHeight.endPosition.x;
        const prevAngle = movement.prevAngle;
        const TwoPI = Math.PI * 2;
        while (angle >= prevAngle + Math.PI) {
          angle -= TwoPI;
        }
        while (angle < prevAngle - Math.PI) {
          angle += TwoPI;
        }
        movement.angleAndHeight.endPosition.x = -angle * canvas.clientWidth / 12;
        movement.angleAndHeight.startPosition.x = -prevAngle * canvas.clientWidth / 12;
      }
    },
    ScreenSpaceEventType_default.PINCH_MOVE,
    modifier
  );
}
function listenToWheel(aggregator, modifier) {
  const key = getKey(CameraEventType_default.WHEEL, modifier);
  const update7 = aggregator._update;
  update7[key] = true;
  let movement = aggregator._movement[key];
  if (!defined_default(movement)) {
    movement = aggregator._movement[key] = {};
  }
  movement.startPosition = new Cartesian2_default();
  movement.endPosition = new Cartesian2_default();
  aggregator._eventHandler.setInputAction(
    function(delta) {
      const arcLength = 15 * Math_default.toRadians(delta);
      if (!update7[key]) {
        movement.endPosition.y = movement.endPosition.y + arcLength;
      } else {
        Cartesian2_default.clone(Cartesian2_default.ZERO, movement.startPosition);
        movement.endPosition.x = 0;
        movement.endPosition.y = arcLength;
        update7[key] = false;
      }
    },
    ScreenSpaceEventType_default.WHEEL,
    modifier
  );
}
function listenMouseButtonDownUp(aggregator, modifier, type) {
  const key = getKey(type, modifier);
  const isDown = aggregator._isDown;
  const eventStartPosition = aggregator._eventStartPosition;
  const pressTime = aggregator._pressTime;
  const releaseTime = aggregator._releaseTime;
  isDown[key] = false;
  eventStartPosition[key] = new Cartesian2_default();
  let lastMovement = aggregator._lastMovement[key];
  if (!defined_default(lastMovement)) {
    lastMovement = aggregator._lastMovement[key] = {
      startPosition: new Cartesian2_default(),
      endPosition: new Cartesian2_default(),
      valid: false
    };
  }
  let down;
  let up;
  if (type === CameraEventType_default.LEFT_DRAG) {
    down = ScreenSpaceEventType_default.LEFT_DOWN;
    up = ScreenSpaceEventType_default.LEFT_UP;
  } else if (type === CameraEventType_default.RIGHT_DRAG) {
    down = ScreenSpaceEventType_default.RIGHT_DOWN;
    up = ScreenSpaceEventType_default.RIGHT_UP;
  } else if (type === CameraEventType_default.MIDDLE_DRAG) {
    down = ScreenSpaceEventType_default.MIDDLE_DOWN;
    up = ScreenSpaceEventType_default.MIDDLE_UP;
  }
  aggregator._eventHandler.setInputAction(
    function(event) {
      aggregator._buttonsDown++;
      lastMovement.valid = false;
      isDown[key] = true;
      pressTime[key] = new Date();
      Cartesian2_default.clone(event.position, eventStartPosition[key]);
    },
    down,
    modifier
  );
  aggregator._eventHandler.setInputAction(
    function() {
      aggregator._buttonsDown = Math.max(aggregator._buttonsDown - 1, 0);
      isDown[key] = false;
      releaseTime[key] = new Date();
    },
    up,
    modifier
  );
}
function cloneMouseMovement(mouseMovement, result) {
  Cartesian2_default.clone(mouseMovement.startPosition, result.startPosition);
  Cartesian2_default.clone(mouseMovement.endPosition, result.endPosition);
}
function listenMouseMove(aggregator, modifier) {
  const update7 = aggregator._update;
  const movement = aggregator._movement;
  const lastMovement = aggregator._lastMovement;
  const isDown = aggregator._isDown;
  for (const typeName in CameraEventType_default) {
    if (CameraEventType_default.hasOwnProperty(typeName)) {
      const type = CameraEventType_default[typeName];
      if (defined_default(type)) {
        const key = getKey(type, modifier);
        update7[key] = true;
        if (!defined_default(aggregator._lastMovement[key])) {
          aggregator._lastMovement[key] = {
            startPosition: new Cartesian2_default(),
            endPosition: new Cartesian2_default(),
            valid: false
          };
        }
        if (!defined_default(aggregator._movement[key])) {
          aggregator._movement[key] = {
            startPosition: new Cartesian2_default(),
            endPosition: new Cartesian2_default()
          };
        }
      }
    }
  }
  aggregator._eventHandler.setInputAction(
    function(mouseMovement) {
      for (const typeName in CameraEventType_default) {
        if (CameraEventType_default.hasOwnProperty(typeName)) {
          const type = CameraEventType_default[typeName];
          if (defined_default(type)) {
            const key = getKey(type, modifier);
            if (isDown[key]) {
              if (!update7[key]) {
                Cartesian2_default.clone(
                  mouseMovement.endPosition,
                  movement[key].endPosition
                );
              } else {
                cloneMouseMovement(movement[key], lastMovement[key]);
                lastMovement[key].valid = true;
                cloneMouseMovement(mouseMovement, movement[key]);
                update7[key] = false;
              }
            }
          }
        }
      }
      Cartesian2_default.clone(
        mouseMovement.endPosition,
        aggregator._currentMousePosition
      );
    },
    ScreenSpaceEventType_default.MOUSE_MOVE,
    modifier
  );
}
function CameraEventAggregator(canvas) {
  if (!defined_default(canvas)) {
    throw new DeveloperError_default("canvas is required.");
  }
  this._eventHandler = new ScreenSpaceEventHandler_default(canvas);
  this._update = {};
  this._movement = {};
  this._lastMovement = {};
  this._isDown = {};
  this._eventStartPosition = {};
  this._pressTime = {};
  this._releaseTime = {};
  this._buttonsDown = 0;
  this._currentMousePosition = new Cartesian2_default();
  listenToWheel(this, void 0);
  listenToPinch(this, void 0, canvas);
  listenMouseButtonDownUp(this, void 0, CameraEventType_default.LEFT_DRAG);
  listenMouseButtonDownUp(this, void 0, CameraEventType_default.RIGHT_DRAG);
  listenMouseButtonDownUp(this, void 0, CameraEventType_default.MIDDLE_DRAG);
  listenMouseMove(this, void 0);
  for (const modifierName in KeyboardEventModifier_default) {
    if (KeyboardEventModifier_default.hasOwnProperty(modifierName)) {
      const modifier = KeyboardEventModifier_default[modifierName];
      if (defined_default(modifier)) {
        listenToWheel(this, modifier);
        listenToPinch(this, modifier, canvas);
        listenMouseButtonDownUp(this, modifier, CameraEventType_default.LEFT_DRAG);
        listenMouseButtonDownUp(this, modifier, CameraEventType_default.RIGHT_DRAG);
        listenMouseButtonDownUp(this, modifier, CameraEventType_default.MIDDLE_DRAG);
        listenMouseMove(this, modifier);
      }
    }
  }
}
Object.defineProperties(CameraEventAggregator.prototype, {
  currentMousePosition: {
    get: function() {
      return this._currentMousePosition;
    }
  },
  anyButtonDown: {
    get: function() {
      const wheelMoved = !this._update[getKey(CameraEventType_default.WHEEL)] || !this._update[getKey(CameraEventType_default.WHEEL, KeyboardEventModifier_default.SHIFT)] || !this._update[getKey(CameraEventType_default.WHEEL, KeyboardEventModifier_default.CTRL)] || !this._update[getKey(CameraEventType_default.WHEEL, KeyboardEventModifier_default.ALT)];
      return this._buttonsDown > 0 || wheelMoved;
    }
  }
});
CameraEventAggregator.prototype.isMoving = function(type, modifier) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  const key = getKey(type, modifier);
  return !this._update[key];
};
CameraEventAggregator.prototype.getMovement = function(type, modifier) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  const key = getKey(type, modifier);
  const movement = this._movement[key];
  return movement;
};
CameraEventAggregator.prototype.getLastMovement = function(type, modifier) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  const key = getKey(type, modifier);
  const lastMovement = this._lastMovement[key];
  if (lastMovement.valid) {
    return lastMovement;
  }
  return void 0;
};
CameraEventAggregator.prototype.isButtonDown = function(type, modifier) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  const key = getKey(type, modifier);
  return this._isDown[key];
};
CameraEventAggregator.prototype.getStartMousePosition = function(type, modifier) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  if (type === CameraEventType_default.WHEEL) {
    return this._currentMousePosition;
  }
  const key = getKey(type, modifier);
  return this._eventStartPosition[key];
};
CameraEventAggregator.prototype.getButtonPressTime = function(type, modifier) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  const key = getKey(type, modifier);
  return this._pressTime[key];
};
CameraEventAggregator.prototype.getButtonReleaseTime = function(type, modifier) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  const key = getKey(type, modifier);
  return this._releaseTime[key];
};
CameraEventAggregator.prototype.reset = function() {
  for (const name in this._update) {
    if (this._update.hasOwnProperty(name)) {
      this._update[name] = true;
    }
  }
};
CameraEventAggregator.prototype.isDestroyed = function() {
  return false;
};
CameraEventAggregator.prototype.destroy = function() {
  this._eventHandler = this._eventHandler && this._eventHandler.destroy();
  return destroyObject_default(this);
};
var CameraEventAggregator_default = CameraEventAggregator;

// node_modules/cesium/Source/Scene/Cesium3DTileContent.js
function Cesium3DTileContent() {
  this.featurePropertiesDirty = false;
}
Object.defineProperties(Cesium3DTileContent.prototype, {
  featuresLength: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  pointsLength: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  trianglesLength: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  geometryByteLength: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  texturesByteLength: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  batchTableByteLength: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  innerContents: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  readyPromise: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  tileset: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  tile: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  url: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  batchTable: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    }
  },
  metadata: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    },
    set: function(value) {
      DeveloperError_default.throwInstantiationError();
    }
  },
  group: {
    get: function() {
      DeveloperError_default.throwInstantiationError();
    },
    set: function(value) {
      DeveloperError_default.throwInstantiationError();
    }
  }
});
Cesium3DTileContent.prototype.hasProperty = function(batchId, name) {
  DeveloperError_default.throwInstantiationError();
};
Cesium3DTileContent.prototype.getFeature = function(batchId) {
  DeveloperError_default.throwInstantiationError();
};
Cesium3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
  DeveloperError_default.throwInstantiationError();
};
Cesium3DTileContent.prototype.applyStyle = function(style) {
  DeveloperError_default.throwInstantiationError();
};
Cesium3DTileContent.prototype.update = function(tileset, frameState) {
  DeveloperError_default.throwInstantiationError();
};
Cesium3DTileContent.prototype.isDestroyed = function() {
  DeveloperError_default.throwInstantiationError();
};
Cesium3DTileContent.prototype.destroy = function() {
  DeveloperError_default.throwInstantiationError();
};
var Cesium3DTileContent_default = Cesium3DTileContent;

// node_modules/cesium/Source/Scene/Cesium3DTilePassState.js
function Cesium3DTilePassState(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.number("options.pass", options.pass);
  this.pass = options.pass;
  this.commandList = options.commandList;
  this.camera = options.camera;
  this.cullingVolume = options.cullingVolume;
  this.ready = false;
}
var Cesium3DTilePassState_default = Cesium3DTilePassState;

// node_modules/cesium/Source/Scene/ConditionsExpression.js
function ConditionsExpression(conditionsExpression, defines) {
  this._conditionsExpression = clone_default(conditionsExpression, true);
  this._conditions = conditionsExpression.conditions;
  this._runtimeConditions = void 0;
  setRuntime(this, defines);
}
Object.defineProperties(ConditionsExpression.prototype, {
  conditionsExpression: {
    get: function() {
      return this._conditionsExpression;
    }
  }
});
function Statement(condition, expression) {
  this.condition = condition;
  this.expression = expression;
}
function setRuntime(expression, defines) {
  const runtimeConditions = [];
  const conditions = expression._conditions;
  if (!defined_default(conditions)) {
    return;
  }
  const length3 = conditions.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const statement = conditions[i2];
    const cond = String(statement[0]);
    const condExpression = String(statement[1]);
    runtimeConditions.push(
      new Statement(
        new Expression_default(cond, defines),
        new Expression_default(condExpression, defines)
      )
    );
  }
  expression._runtimeConditions = runtimeConditions;
}
ConditionsExpression.prototype.evaluate = function(feature2, result) {
  const conditions = this._runtimeConditions;
  if (!defined_default(conditions)) {
    return void 0;
  }
  const length3 = conditions.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const statement = conditions[i2];
    if (statement.condition.evaluate(feature2)) {
      return statement.expression.evaluate(feature2, result);
    }
  }
};
ConditionsExpression.prototype.evaluateColor = function(feature2, result) {
  const conditions = this._runtimeConditions;
  if (!defined_default(conditions)) {
    return void 0;
  }
  const length3 = conditions.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const statement = conditions[i2];
    if (statement.condition.evaluate(feature2)) {
      return statement.expression.evaluateColor(feature2, result);
    }
  }
};
ConditionsExpression.prototype.getShaderFunction = function(functionSignature, variableSubstitutionMap, shaderState, returnType) {
  const conditions = this._runtimeConditions;
  if (!defined_default(conditions) || conditions.length === 0) {
    return void 0;
  }
  let shaderFunction = "";
  const length3 = conditions.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const statement = conditions[i2];
    const condition = statement.condition.getShaderExpression(
      variableSubstitutionMap,
      shaderState
    );
    const expression = statement.expression.getShaderExpression(
      variableSubstitutionMap,
      shaderState
    );
    shaderFunction += `    ${i2 === 0 ? "if" : "else if"} (${condition})
    {
        return ${expression};
    }
`;
  }
  shaderFunction = `${returnType} ${functionSignature}
{
${shaderFunction}    return ${returnType}(1.0);
}
`;
  return shaderFunction;
};
ConditionsExpression.prototype.getVariables = function() {
  let variables = [];
  const conditions = this._runtimeConditions;
  if (!defined_default(conditions) || conditions.length === 0) {
    return variables;
  }
  const length3 = conditions.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const statement = conditions[i2];
    variables.push.apply(variables, statement.condition.getVariables());
    variables.push.apply(variables, statement.expression.getVariables());
  }
  variables = variables.filter(function(variable, index2, variables2) {
    return variables2.indexOf(variable) === index2;
  });
  return variables;
};
var ConditionsExpression_default = ConditionsExpression;

// node_modules/cesium/Source/Scene/Cesium3DTileStyle.js
function Cesium3DTileStyle(style) {
  this._style = {};
  this._ready = false;
  this._show = void 0;
  this._color = void 0;
  this._pointSize = void 0;
  this._pointOutlineColor = void 0;
  this._pointOutlineWidth = void 0;
  this._labelColor = void 0;
  this._labelOutlineColor = void 0;
  this._labelOutlineWidth = void 0;
  this._font = void 0;
  this._labelStyle = void 0;
  this._labelText = void 0;
  this._backgroundColor = void 0;
  this._backgroundPadding = void 0;
  this._backgroundEnabled = void 0;
  this._scaleByDistance = void 0;
  this._translucencyByDistance = void 0;
  this._distanceDisplayCondition = void 0;
  this._heightOffset = void 0;
  this._anchorLineEnabled = void 0;
  this._anchorLineColor = void 0;
  this._image = void 0;
  this._disableDepthTestDistance = void 0;
  this._horizontalOrigin = void 0;
  this._verticalOrigin = void 0;
  this._labelHorizontalOrigin = void 0;
  this._labelVerticalOrigin = void 0;
  this._meta = void 0;
  this._colorShaderFunction = void 0;
  this._showShaderFunction = void 0;
  this._pointSizeShaderFunction = void 0;
  this._colorShaderFunctionReady = false;
  this._showShaderFunctionReady = false;
  this._pointSizeShaderFunctionReady = false;
  this._colorShaderTranslucent = false;
  let promise;
  if (typeof style === "string" || style instanceof Resource_default) {
    const resource = Resource_default.createIfNeeded(style);
    promise = resource.fetchJson(style);
  } else {
    promise = Promise.resolve(style);
  }
  const that = this;
  this._readyPromise = promise.then(function(styleJson) {
    setup(that, styleJson);
    return that;
  });
}
function setup(that, styleJson) {
  styleJson = defaultValue_default(clone_default(styleJson, true), that._style);
  that._style = styleJson;
  that.show = styleJson.show;
  that.color = styleJson.color;
  that.pointSize = styleJson.pointSize;
  that.pointOutlineColor = styleJson.pointOutlineColor;
  that.pointOutlineWidth = styleJson.pointOutlineWidth;
  that.labelColor = styleJson.labelColor;
  that.labelOutlineColor = styleJson.labelOutlineColor;
  that.labelOutlineWidth = styleJson.labelOutlineWidth;
  that.labelStyle = styleJson.labelStyle;
  that.font = styleJson.font;
  that.labelText = styleJson.labelText;
  that.backgroundColor = styleJson.backgroundColor;
  that.backgroundPadding = styleJson.backgroundPadding;
  that.backgroundEnabled = styleJson.backgroundEnabled;
  that.scaleByDistance = styleJson.scaleByDistance;
  that.translucencyByDistance = styleJson.translucencyByDistance;
  that.distanceDisplayCondition = styleJson.distanceDisplayCondition;
  that.heightOffset = styleJson.heightOffset;
  that.anchorLineEnabled = styleJson.anchorLineEnabled;
  that.anchorLineColor = styleJson.anchorLineColor;
  that.image = styleJson.image;
  that.disableDepthTestDistance = styleJson.disableDepthTestDistance;
  that.horizontalOrigin = styleJson.horizontalOrigin;
  that.verticalOrigin = styleJson.verticalOrigin;
  that.labelHorizontalOrigin = styleJson.labelHorizontalOrigin;
  that.labelVerticalOrigin = styleJson.labelVerticalOrigin;
  const meta = {};
  if (defined_default(styleJson.meta)) {
    const defines = styleJson.defines;
    const metaJson = defaultValue_default(styleJson.meta, defaultValue_default.EMPTY_OBJECT);
    for (const property in metaJson) {
      if (metaJson.hasOwnProperty(property)) {
        meta[property] = new Expression_default(metaJson[property], defines);
      }
    }
  }
  that._meta = meta;
  that._ready = true;
}
function getExpression(tileStyle, value) {
  const defines = defaultValue_default(tileStyle._style, defaultValue_default.EMPTY_OBJECT).defines;
  if (!defined_default(value)) {
    return void 0;
  } else if (typeof value === "boolean" || typeof value === "number") {
    return new Expression_default(String(value));
  } else if (typeof value === "string") {
    return new Expression_default(value, defines);
  } else if (defined_default(value.conditions)) {
    return new ConditionsExpression_default(value, defines);
  }
  return value;
}
function getJsonFromExpression(expression) {
  if (!defined_default(expression)) {
    return void 0;
  } else if (defined_default(expression.expression)) {
    return expression.expression;
  } else if (defined_default(expression.conditionsExpression)) {
    return clone_default(expression.conditionsExpression, true);
  }
  return expression;
}
Object.defineProperties(Cesium3DTileStyle.prototype, {
  style: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._style;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  show: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._show;
    },
    set: function(value) {
      this._show = getExpression(this, value);
      this._style.show = getJsonFromExpression(this._show);
      this._showShaderFunctionReady = false;
    }
  },
  color: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._color;
    },
    set: function(value) {
      this._color = getExpression(this, value);
      this._style.color = getJsonFromExpression(this._color);
      this._colorShaderFunctionReady = false;
    }
  },
  pointSize: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._pointSize;
    },
    set: function(value) {
      this._pointSize = getExpression(this, value);
      this._style.pointSize = getJsonFromExpression(this._pointSize);
      this._pointSizeShaderFunctionReady = false;
    }
  },
  pointOutlineColor: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._pointOutlineColor;
    },
    set: function(value) {
      this._pointOutlineColor = getExpression(this, value);
      this._style.pointOutlineColor = getJsonFromExpression(
        this._pointOutlineColor
      );
    }
  },
  pointOutlineWidth: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._pointOutlineWidth;
    },
    set: function(value) {
      this._pointOutlineWidth = getExpression(this, value);
      this._style.pointOutlineWidth = getJsonFromExpression(
        this._pointOutlineWidth
      );
    }
  },
  labelColor: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._labelColor;
    },
    set: function(value) {
      this._labelColor = getExpression(this, value);
      this._style.labelColor = getJsonFromExpression(this._labelColor);
    }
  },
  labelOutlineColor: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._labelOutlineColor;
    },
    set: function(value) {
      this._labelOutlineColor = getExpression(this, value);
      this._style.labelOutlineColor = getJsonFromExpression(
        this._labelOutlineColor
      );
    }
  },
  labelOutlineWidth: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._labelOutlineWidth;
    },
    set: function(value) {
      this._labelOutlineWidth = getExpression(this, value);
      this._style.labelOutlineWidth = getJsonFromExpression(
        this._labelOutlineWidth
      );
    }
  },
  font: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._font;
    },
    set: function(value) {
      this._font = getExpression(this, value);
      this._style.font = getJsonFromExpression(this._font);
    }
  },
  labelStyle: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._labelStyle;
    },
    set: function(value) {
      this._labelStyle = getExpression(this, value);
      this._style.labelStyle = getJsonFromExpression(this._labelStyle);
    }
  },
  labelText: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._labelText;
    },
    set: function(value) {
      this._labelText = getExpression(this, value);
      this._style.labelText = getJsonFromExpression(this._labelText);
    }
  },
  backgroundColor: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._backgroundColor;
    },
    set: function(value) {
      this._backgroundColor = getExpression(this, value);
      this._style.backgroundColor = getJsonFromExpression(
        this._backgroundColor
      );
    }
  },
  backgroundPadding: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._backgroundPadding;
    },
    set: function(value) {
      this._backgroundPadding = getExpression(this, value);
      this._style.backgroundPadding = getJsonFromExpression(
        this._backgroundPadding
      );
    }
  },
  backgroundEnabled: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._backgroundEnabled;
    },
    set: function(value) {
      this._backgroundEnabled = getExpression(this, value);
      this._style.backgroundEnabled = getJsonFromExpression(
        this._backgroundEnabled
      );
    }
  },
  scaleByDistance: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._scaleByDistance;
    },
    set: function(value) {
      this._scaleByDistance = getExpression(this, value);
      this._style.scaleByDistance = getJsonFromExpression(
        this._scaleByDistance
      );
    }
  },
  translucencyByDistance: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._translucencyByDistance;
    },
    set: function(value) {
      this._translucencyByDistance = getExpression(this, value);
      this._style.translucencyByDistance = getJsonFromExpression(
        this._translucencyByDistance
      );
    }
  },
  distanceDisplayCondition: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._distanceDisplayCondition;
    },
    set: function(value) {
      this._distanceDisplayCondition = getExpression(this, value);
      this._style.distanceDisplayCondition = getJsonFromExpression(
        this._distanceDisplayCondition
      );
    }
  },
  heightOffset: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._heightOffset;
    },
    set: function(value) {
      this._heightOffset = getExpression(this, value);
      this._style.heightOffset = getJsonFromExpression(this._heightOffset);
    }
  },
  anchorLineEnabled: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._anchorLineEnabled;
    },
    set: function(value) {
      this._anchorLineEnabled = getExpression(this, value);
      this._style.anchorLineEnabled = getJsonFromExpression(
        this._anchorLineEnabled
      );
    }
  },
  anchorLineColor: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._anchorLineColor;
    },
    set: function(value) {
      this._anchorLineColor = getExpression(this, value);
      this._style.anchorLineColor = getJsonFromExpression(
        this._anchorLineColor
      );
    }
  },
  image: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._image;
    },
    set: function(value) {
      this._image = getExpression(this, value);
      this._style.image = getJsonFromExpression(this._image);
    }
  },
  disableDepthTestDistance: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._disableDepthTestDistance;
    },
    set: function(value) {
      this._disableDepthTestDistance = getExpression(this, value);
      this._style.disableDepthTestDistance = getJsonFromExpression(
        this._disableDepthTestDistance
      );
    }
  },
  horizontalOrigin: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._horizontalOrigin;
    },
    set: function(value) {
      this._horizontalOrigin = getExpression(this, value);
      this._style.horizontalOrigin = getJsonFromExpression(
        this._horizontalOrigin
      );
    }
  },
  verticalOrigin: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._verticalOrigin;
    },
    set: function(value) {
      this._verticalOrigin = getExpression(this, value);
      this._style.verticalOrigin = getJsonFromExpression(this._verticalOrigin);
    }
  },
  labelHorizontalOrigin: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._labelHorizontalOrigin;
    },
    set: function(value) {
      this._labelHorizontalOrigin = getExpression(this, value);
      this._style.labelHorizontalOrigin = getJsonFromExpression(
        this._labelHorizontalOrigin
      );
    }
  },
  labelVerticalOrigin: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._labelVerticalOrigin;
    },
    set: function(value) {
      this._labelVerticalOrigin = getExpression(this, value);
      this._style.labelVerticalOrigin = getJsonFromExpression(
        this._labelVerticalOrigin
      );
    }
  },
  meta: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "The style is not loaded.  Use Cesium3DTileStyle.readyPromise or wait for Cesium3DTileStyle.ready to be true."
        );
      }
      return this._meta;
    },
    set: function(value) {
      this._meta = value;
    }
  }
});
Cesium3DTileStyle.prototype.getColorShaderFunction = function(functionSignature, variableSubstitutionMap, shaderState) {
  if (this._colorShaderFunctionReady) {
    shaderState.translucent = this._colorShaderTranslucent;
    return this._colorShaderFunction;
  }
  this._colorShaderFunctionReady = true;
  if (defined_default(this.color) && defined_default(this.color.getShaderFunction)) {
    this._colorShaderFunction = this.color.getShaderFunction(
      functionSignature,
      variableSubstitutionMap,
      shaderState,
      "vec4"
    );
  } else {
    this._colorShaderFunction = void 0;
  }
  this._colorShaderTranslucent = shaderState.translucent;
  return this._colorShaderFunction;
};
Cesium3DTileStyle.prototype.getShowShaderFunction = function(functionSignature, variableSubstitutionMap, shaderState) {
  if (this._showShaderFunctionReady) {
    return this._showShaderFunction;
  }
  this._showShaderFunctionReady = true;
  if (defined_default(this.show) && defined_default(this.show.getShaderFunction)) {
    this._showShaderFunction = this.show.getShaderFunction(
      functionSignature,
      variableSubstitutionMap,
      shaderState,
      "bool"
    );
  } else {
    this._showShaderFunction = void 0;
  }
  return this._showShaderFunction;
};
Cesium3DTileStyle.prototype.getPointSizeShaderFunction = function(functionSignature, variableSubstitutionMap, shaderState) {
  if (this._pointSizeShaderFunctionReady) {
    return this._pointSizeShaderFunction;
  }
  this._pointSizeShaderFunctionReady = true;
  if (defined_default(this.pointSize) && defined_default(this.pointSize.getShaderFunction)) {
    this._pointSizeShaderFunction = this.pointSize.getShaderFunction(
      functionSignature,
      variableSubstitutionMap,
      shaderState,
      "float"
    );
  } else {
    this._pointSizeShaderFunction = void 0;
  }
  return this._pointSizeShaderFunction;
};
Cesium3DTileStyle.prototype.getVariables = function() {
  let variables = [];
  if (defined_default(this.color) && defined_default(this.color.getVariables)) {
    variables.push.apply(variables, this.color.getVariables());
  }
  if (defined_default(this.show) && defined_default(this.show.getVariables)) {
    variables.push.apply(variables, this.show.getVariables());
  }
  if (defined_default(this.pointSize) && defined_default(this.pointSize.getVariables)) {
    variables.push.apply(variables, this.pointSize.getVariables());
  }
  variables = variables.filter(function(variable, index2, variables2) {
    return variables2.indexOf(variable) === index2;
  });
  return variables;
};
var Cesium3DTileStyle_default = Cesium3DTileStyle;

// node_modules/cesium/Source/Scene/CircleEmitter.js
function CircleEmitter(radius) {
  radius = defaultValue_default(radius, 1);
  Check_default.typeOf.number.greaterThan("radius", radius, 0);
  this._radius = defaultValue_default(radius, 1);
}
Object.defineProperties(CircleEmitter.prototype, {
  radius: {
    get: function() {
      return this._radius;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThan("value", value, 0);
      this._radius = value;
    }
  }
});
CircleEmitter.prototype.emit = function(particle) {
  const theta = Math_default.randomBetween(0, Math_default.TWO_PI);
  const rad = Math_default.randomBetween(0, this._radius);
  const x = rad * Math.cos(theta);
  const y = rad * Math.sin(theta);
  const z = 0;
  particle.position = Cartesian3_default.fromElements(x, y, z, particle.position);
  particle.velocity = Cartesian3_default.clone(Cartesian3_default.UNIT_Z, particle.velocity);
};
var CircleEmitter_default = CircleEmitter;

// node_modules/cesium/Source/Scene/CloudType.js
var CloudType = {
  CUMULUS: 0
};
CloudType.validate = function(cloudType) {
  return cloudType === CloudType.CUMULUS;
};
var CloudType_default = Object.freeze(CloudType);

// node_modules/cesium/Source/Shaders/CloudCollectionFS.js
var CloudCollectionFS_default = `uniform sampler2D u_noiseTexture;
uniform vec3 u_noiseTextureDimensions;
uniform float u_noiseDetail;
varying vec2 v_offset;
varying vec3 v_maximumSize;
varying vec4 v_color;
varying float v_slice;
varying float v_brightness;

float wrap(float value, float rangeLength) {
    if(value < 0.0) {
        float absValue = abs(value);
        float modValue = mod(absValue, rangeLength);
        return mod(rangeLength - modValue, rangeLength);
    }
    return mod(value, rangeLength);
}

vec3 wrapVec(vec3 value, float rangeLength) {
    return vec3(wrap(value.x, rangeLength),
                wrap(value.y, rangeLength),
                wrap(value.z, rangeLength));
}

float textureSliceWidth = u_noiseTextureDimensions.x;
float noiseTextureRows = u_noiseTextureDimensions.y;
float inverseNoiseTextureRows = u_noiseTextureDimensions.z;

float textureSliceWidthSquared = textureSliceWidth * textureSliceWidth;
vec2 inverseNoiseTextureDimensions = vec2(noiseTextureRows / textureSliceWidthSquared,
                                          inverseNoiseTextureRows / textureSliceWidth);

vec2 voxelToUV(vec3 voxelIndex) {
    vec3 wrappedIndex = wrapVec(voxelIndex, textureSliceWidth);
    float column = mod(wrappedIndex.z, textureSliceWidth * inverseNoiseTextureRows);
    float row = floor(wrappedIndex.z / textureSliceWidth * noiseTextureRows);

    float xPixelCoord = wrappedIndex.x + column * textureSliceWidth;
    float yPixelCoord = wrappedIndex.y + row * textureSliceWidth;
    return vec2(xPixelCoord, yPixelCoord) * inverseNoiseTextureDimensions;
}

// Interpolate a voxel with its neighbor (along the positive X-axis)
vec4 lerpSamplesX(vec3 voxelIndex, float x) {
    vec2 uv0 = voxelToUV(voxelIndex);
    vec2 uv1 = voxelToUV(voxelIndex + vec3(1.0, 0.0, 0.0));
    vec4 sample0 = texture2D(u_noiseTexture, uv0);
    vec4 sample1 = texture2D(u_noiseTexture, uv1);
    return mix(sample0, sample1, x);
}

vec4 sampleNoiseTexture(vec3 position) {
    vec3 recenteredPos = position + vec3(textureSliceWidth / 2.0);
    vec3 lerpValue = fract(recenteredPos);
    vec3 voxelIndex = floor(recenteredPos);

    vec4 xLerp00 = lerpSamplesX(voxelIndex, lerpValue.x);
    vec4 xLerp01 = lerpSamplesX(voxelIndex + vec3(0.0, 0.0, 1.0), lerpValue.x);
    vec4 xLerp10 = lerpSamplesX(voxelIndex + vec3(0.0, 1.0, 0.0), lerpValue.x);
    vec4 xLerp11 = lerpSamplesX(voxelIndex + vec3(0.0, 1.0, 1.0), lerpValue.x);

    vec4 yLerp0 = mix(xLerp00, xLerp10, lerpValue.y);
    vec4 yLerp1 = mix(xLerp01, xLerp11, lerpValue.y);
    return mix(yLerp0, yLerp1, lerpValue.z);
}

// Intersection with a unit sphere with radius 0.5 at center (0, 0, 0).
bool intersectSphere(vec3 origin, vec3 dir, float slice,
                     out vec3 point, out vec3 normal) {
    float A = dot(dir, dir);
    float B = dot(origin, dir);
    float C = dot(origin, origin) - 0.25;
    float discriminant = (B * B) - (A * C);
    if(discriminant < 0.0) {
        return false;
    }
    float root = sqrt(discriminant);
    float t = (-B - root) / A;
    if(t < 0.0) {
        t = (-B + root) / A;
    }
    point = origin + t * dir;

    if(slice >= 0.0) {
        point.z = (slice / 2.0) - 0.5;
        if(length(point) > 0.5) {
            return false;
        }
    }

    normal = normalize(point);
    point -= czm_epsilon2 * normal;
    return true;
}

// Transforms the ray origin and direction into unit sphere space,
// then transforms the result back into the ellipsoid's space.
bool intersectEllipsoid(vec3 origin, vec3 dir, vec3 center, vec3 scale, float slice,
                        out vec3 point, out vec3 normal) {
    if(scale.x <= 0.01 || scale.y < 0.01 || scale.z < 0.01) {
        return false;
    }

    vec3 o = (origin - center) / scale;
    vec3 d = dir / scale;
    vec3 p, n;
    bool intersected = intersectSphere(o, d, slice, p, n);
    if(intersected) {
        point = (p * scale) + center;
        normal = n;
    }
    return intersected;
}

// Assume that if phase shift is being called for octave i,
// the frequency is of i - 1. This saves us from doing extra
// division / multiplication operations.
vec2 phaseShift2D(vec2 p, vec2 freq) {
    return (czm_pi / 2.0) * sin(freq.yx * p.yx);
}

vec2 phaseShift3D(vec3 p, vec2 freq) {
    return phaseShift2D(p.xy, freq) + czm_pi * vec2(sin(freq.x * p.z));
}

// The cloud texture function derived from Gardner's 1985 paper,
// "Visual Simulation of Clouds."
// https://www.cs.drexel.edu/~david/Classes/Papers/p297-gardner.pdf
const float T0    = 0.6;  // contrast of the texture pattern
const float k     = 0.1;  // computed to produce a maximum value of 1
const float C0    = 0.8;  // coefficient
const float FX0   = 0.6;  // frequency X
const float FY0   = 0.6;  // frequency Y
const int octaves = 5;

float T(vec3 point) {
    vec2 sum = vec2(0.0);
    float Ci = C0;
    vec2 FXY = vec2(FX0, FY0);
    vec2 PXY = vec2(0.0);
    for(int i = 1; i <= octaves; i++) {
        PXY = phaseShift3D(point, FXY);
        Ci *= 0.707;
        FXY *= 2.0;
        vec2 sinTerm = sin(FXY * point.xy + PXY);
        sum += Ci * sinTerm + vec2(T0);
    }
    return k * sum.x * sum.y;
}

const float a = 0.5;  // fraction of surface reflection due to ambient or scattered light,
const float t = 0.4;  // fraction of texture shading
const float s = 0.25; // fraction of specular reflection

float I(float Id, float Is, float It) {
    return (1.0 - a) * ((1.0 - t) * ((1.0 - s) * Id + s * Is) + t * It) + a;
}

const vec3 lightDir = normalize(vec3(0.2, -1.0, 0.7));

vec4 drawCloud(vec3 rayOrigin, vec3 rayDir, vec3 cloudCenter, vec3 cloudScale, float cloudSlice,
               float brightness) {
    vec3 cloudPoint, cloudNormal;
    if(!intersectEllipsoid(rayOrigin, rayDir, cloudCenter, cloudScale, cloudSlice,
                            cloudPoint, cloudNormal)) {
        return vec4(0.0);
    }

    float Id = clamp(dot(cloudNormal, -lightDir), 0.0, 1.0);  // diffuse reflection
    float Is = max(pow(dot(-lightDir, -rayDir), 2.0), 0.0);   // specular reflection
    float It = T(cloudPoint);                                 // texture function
    float intensity = I(Id, Is, It);
    vec3 color = vec3(intensity * clamp(brightness, 0.1, 1.0));

    vec4 noise = sampleNoiseTexture(u_noiseDetail * cloudPoint);
    float W = noise.x;
    float W2 = noise.y;
    float W3 = noise.z;

    // The dot product between the cloud's normal and the ray's direction is greatest
    // in the center of the ellipsoid's surface. It decreases towards the edge.
    // Thus, it is used to blur the areas leading to the edges of the ellipsoid,
    // so that no harsh lines appear.

    // The first (and biggest) layer of worley noise is then subtracted from this.
    // The final result is scaled up so that the base cloud is not too translucent.
    float ndDot = clamp(dot(cloudNormal, -rayDir), 0.0, 1.0);
    float TR = pow(ndDot, 3.0) - W; // translucency
    TR *= 1.3;

    // Subtracting the second and third layers of worley noise is more complicated.
    // If these layers of noise were simply subtracted from the current translucency,
    // the shape derived from the first layer of noise would be completely deleted.
    // The erosion of this noise should thus be constricted to the edges of the cloud.
    // However, because the edges of the ellipsoid were already blurred away, mapping
    // the noise to (1.0 - ndDot) will have no impact on most of the cloud's appearance.
    // The value of (0.5 - ndDot) provides the best compromise.
    float minusDot = 0.5 - ndDot;

    // Even with the previous calculation, subtracting the second layer of wnoise
    // erode too much of the cloud. The addition of it, however, will detailed
    // volume to the cloud. As long as the noise is only added and not subtracted,
    // the results are aesthetically pleasing.

    // The minusDot product is mapped in a way that it is larger at the edges of
    // the ellipsoid, so a subtraction and min operation are used instead of
    // an addition and max one.
    TR -= min(minusDot * W2, 0.0);

    // The third level of worley noise is subtracted from the result, with some
    // modifications. First, a scalar is added to minusDot so that the noise
    // starts affecting the shape farther away from the center of the ellipsoid's
    // surface. Then, it is scaled down so its impact is not too intense.
    TR -= 0.8 * (minusDot + 0.25) * W3;

    // The texture function's shading does not correlate with the shape of the cloud
    // produced by the layers of noise, so an extra shading scalar is calculated.
    // The darkest areas of the cloud are assigned to be where the noise erodes
    // the cloud the most. This is then interpolated based on the translucency
    // and the diffuse shading term of that point in the cloud.
    float shading = mix(1.0 - 0.8 * W * W, 1.0, Id * TR);

    // To avoid values that are too dark, this scalar is increased by a small amount
    // and clamped so it never goes to zero.
    shading = clamp(shading + 0.2, 0.3, 1.0);

    // Finally, the contrast of the cloud's color is increased.
    vec3 finalColor = mix(vec3(0.5), shading * color, 1.15);
    return vec4(finalColor, clamp(TR, 0.0, 1.0)) * v_color;
}

void main() {
#ifdef DEBUG_BILLBOARDS
    gl_FragColor = vec4(0.0, 0.5, 0.5, 1.0);
#endif
    // To avoid calculations with high values,
    // we raycast from an arbitrarily smaller space.
    vec2 coordinate = v_maximumSize.xy * v_offset;

    vec3 ellipsoidScale = 0.82 * v_maximumSize;
    vec3 ellipsoidCenter = vec3(0.0);

    float zOffset = max(ellipsoidScale.z - 10.0, 0.0);
    vec3 eye = vec3(0, 0, -10.0 - zOffset);
    vec3 rayDir = normalize(vec3(coordinate, 1.0) - eye);
    vec3 rayOrigin = eye;
#ifdef DEBUG_ELLIPSOIDS
    vec3 point, normal;
    if(intersectEllipsoid(rayOrigin, rayDir, ellipsoidCenter, ellipsoidScale, v_slice,
                          point, normal)) {
        gl_FragColor = v_brightness * v_color;
    }
#else
#ifndef DEBUG_BILLBOARDS
    vec4 cloud = drawCloud(rayOrigin, rayDir,
                           ellipsoidCenter, ellipsoidScale, v_slice, v_brightness);
    if(cloud.w < 0.01) {
        discard;
    }
    gl_FragColor = cloud;
#endif
#endif
}
`;

// node_modules/cesium/Source/Shaders/CloudCollectionVS.js
var CloudCollectionVS_default = "#ifdef INSTANCED\nattribute vec2 direction;\n#endif\nattribute vec4 positionHighAndScaleX;\nattribute vec4 positionLowAndScaleY;\nattribute vec4 packedAttribute0;\nattribute vec4 packedAttribute1;\nattribute vec4 color;\n\nvarying vec2 v_offset;\nvarying vec3 v_maximumSize;\nvarying vec4 v_color;\nvarying float v_slice;\nvarying float v_brightness;\n\nvoid main() {\n    // Unpack attributes.\n    vec3 positionHigh = positionHighAndScaleX.xyz;\n    vec3 positionLow = positionLowAndScaleY.xyz;\n    vec2 scale = vec2(positionHighAndScaleX.w, positionLowAndScaleY.w);\n\n    float show = packedAttribute0.x;\n    float brightness = packedAttribute0.y;\n    vec2 coordinates = packedAttribute0.wz;\n    vec3 maximumSize = packedAttribute1.xyz;\n    float slice = packedAttribute1.w;\n\n#ifdef INSTANCED\n    vec2 dir = direction;\n#else\n    vec2 dir = coordinates;\n#endif\n\n    vec2 offset = dir - vec2(0.5, 0.5);\n    vec2 scaledOffset = scale * offset;\n    vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);\n    vec4 positionEC = czm_modelViewRelativeToEye * p;\n    positionEC.xy += scaledOffset;\n    \n    positionEC.xyz *= show;\n    gl_Position = czm_projection * positionEC;\n\n    v_offset = offset;\n    v_maximumSize = maximumSize;\n    v_color = color;\n    v_slice = slice;\n    v_brightness = brightness;\n}\n";

// node_modules/cesium/Source/Shaders/CloudNoiseFS.js
var CloudNoiseFS_default = "uniform vec3 u_noiseTextureDimensions;\nuniform float u_noiseDetail;\nuniform vec3 u_noiseOffset;\nvarying vec2 v_position;\n\nfloat textureSliceWidth = u_noiseTextureDimensions.x;\nfloat inverseNoiseTextureRows = u_noiseTextureDimensions.z;\n\nfloat wrap(float value, float rangeLength) {\n    if(value < 0.0) {\n        float absValue = abs(value);\n        float modValue = mod(absValue, rangeLength);\n        return mod(rangeLength - modValue, rangeLength);\n    }\n    return mod(value, rangeLength);\n}\n\nvec3 wrapVec(vec3 value, float rangeLength) {\n    return vec3(wrap(value.x, rangeLength),\n                wrap(value.y, rangeLength),\n                wrap(value.z, rangeLength));\n}\n\nvec3 random3(vec3 p) {\n    float dot1 = dot(p, vec3(127.1, 311.7, 932.8));\n    float dot2 = dot(p, vec3(269.5, 183.3, 421.4));\n    return fract(vec3(sin(dot1 - dot2), cos(dot1 * dot2), dot1 * dot2));\n}\n\n// Frequency corresponds to cell size.\n// The higher the frequency, the smaller the cell size.\nvec3 getWorleyCellPoint(vec3 centerCell, vec3 offset, float freq) {\n    vec3 cell = centerCell + offset;\n    cell = wrapVec(cell, textureSliceWidth / u_noiseDetail);\n    cell += floor(u_noiseOffset / u_noiseDetail);\n    vec3 p = offset + random3(cell);\n    return p;\n}\n\nfloat worleyNoise(vec3 p, float freq) {\n    vec3 centerCell = floor(p * freq);\n    vec3 pointInCell = fract(p * freq);\n    float shortestDistance = 1000.0;\n\n    for(float z = -1.0; z <= 1.0; z++) {\n        for(float y = -1.0; y <= 1.0; y++) {\n            for(float x = -1.0; x <= 1.0; x++) {\n                vec3 offset = vec3(x, y, z);\n                vec3 point = getWorleyCellPoint(centerCell, offset, freq);\n\n                float distance = length(pointInCell - point);\n                if(distance < shortestDistance) {\n                    shortestDistance = distance;\n                }\n            }\n        }\n    }\n\n    return shortestDistance;\n}\n\nconst float MAX_FBM_ITERATIONS = 10.0;\n\nfloat worleyFBMNoise(vec3 p, float octaves, float scale) {\n    float noise = 0.0;\n    float freq = 1.0;\n    float persistence = 0.625;\n    for(float i = 0.0; i < MAX_FBM_ITERATIONS; i++) {\n        if(i >= octaves) {\n            break;\n        }\n\n        noise += worleyNoise(p * scale, freq * scale) * persistence;\n        persistence *= 0.5;\n        freq *= 2.0;\n    }\n    return noise;\n}\n\nvoid main() {\n    float x = mod(v_position.x, textureSliceWidth);\n    float y = mod(v_position.y, textureSliceWidth);\n    float sliceRow = floor(v_position.y / textureSliceWidth);\n    float z = floor(v_position.x / textureSliceWidth) + sliceRow * inverseNoiseTextureRows * textureSliceWidth;\n\n    vec3 position = vec3(x, y, z);\n    position /= u_noiseDetail;\n    float worley0 = clamp(worleyFBMNoise(position, 3.0, 1.0), 0.0, 1.0);\n    float worley1 = clamp(worleyFBMNoise(position, 3.0, 2.0), 0.0, 1.0);\n    float worley2 = clamp(worleyFBMNoise(position, 3.0, 3.0), 0.0, 1.0);\n    gl_FragColor = vec4(worley0, worley1, worley2, 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/CloudNoiseVS.js
var CloudNoiseVS_default = "uniform vec3 u_noiseTextureDimensions;\nattribute vec2 position;\n\nvarying vec2 v_position;\n\nvoid main()\n{\n    gl_Position = vec4(position, 0.1, 1.0);\n\n    float textureSliceWidth = u_noiseTextureDimensions.x;\n    float noiseTextureRows = u_noiseTextureDimensions.y;\n    float inverseNoiseTextureRows = u_noiseTextureDimensions.z;\n    vec2 transformedPos = (position * 0.5) + vec2(0.5);\n    transformedPos *= textureSliceWidth;\n    transformedPos.x *= textureSliceWidth * inverseNoiseTextureRows;\n    transformedPos.y *= noiseTextureRows;\n    v_position = transformedPos;\n}\n";

// node_modules/cesium/Source/Scene/CumulusCloud.js
function CumulusCloud(options, cloudCollection) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._show = defaultValue_default(options.show, true);
  this._position = Cartesian3_default.clone(
    defaultValue_default(options.position, Cartesian3_default.ZERO)
  );
  if (!defined_default(options.scale) && defined_default(options.maximumSize)) {
    this._maximumSize = Cartesian3_default.clone(options.maximumSize);
    this._scale = new Cartesian2_default(this._maximumSize.x, this._maximumSize.y);
  } else {
    this._scale = Cartesian2_default.clone(
      defaultValue_default(options.scale, new Cartesian2_default(20, 12))
    );
    const defaultMaxSize = new Cartesian3_default(
      this._scale.x,
      this._scale.y,
      Math.min(this._scale.x, this._scale.y) / 1.5
    );
    this._maximumSize = Cartesian3_default.clone(
      defaultValue_default(options.maximumSize, defaultMaxSize)
    );
  }
  this._slice = defaultValue_default(options.slice, -1);
  this._color = Color_default.clone(defaultValue_default(options.color, Color_default.WHITE));
  this._brightness = defaultValue_default(options.brightness, 1);
  this._cloudCollection = cloudCollection;
  this._index = -1;
}
var SHOW_INDEX7 = CumulusCloud.SHOW_INDEX = 0;
var POSITION_INDEX7 = CumulusCloud.POSITION_INDEX = 1;
var SCALE_INDEX3 = CumulusCloud.SCALE_INDEX = 2;
var MAXIMUM_SIZE_INDEX = CumulusCloud.MAXIMUM_SIZE_INDEX = 3;
var SLICE_INDEX = CumulusCloud.SLICE_INDEX = 4;
var BRIGHTNESS_INDEX = CumulusCloud.BRIGHTNESS_INDEX = 5;
var COLOR_INDEX5 = CumulusCloud.COLOR_INDEX = 6;
CumulusCloud.NUMBER_OF_PROPERTIES = 7;
function makeDirty4(cloud, propertyChanged) {
  const cloudCollection = cloud._cloudCollection;
  if (defined_default(cloudCollection)) {
    cloudCollection._updateCloud(cloud, propertyChanged);
    cloud._dirty = true;
  }
}
Object.defineProperties(CumulusCloud.prototype, {
  show: {
    get: function() {
      return this._show;
    },
    set: function(value) {
      Check_default.typeOf.bool("value", value);
      if (this._show !== value) {
        this._show = value;
        makeDirty4(this, SHOW_INDEX7);
      }
    }
  },
  position: {
    get: function() {
      return this._position;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      const position = this._position;
      if (!Cartesian3_default.equals(position, value)) {
        Cartesian3_default.clone(value, position);
        makeDirty4(this, POSITION_INDEX7);
      }
    }
  },
  scale: {
    get: function() {
      return this._scale;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      const scale = this._scale;
      if (!Cartesian2_default.equals(scale, value)) {
        Cartesian2_default.clone(value, scale);
        makeDirty4(this, SCALE_INDEX3);
      }
    }
  },
  maximumSize: {
    get: function() {
      return this._maximumSize;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      const maximumSize = this._maximumSize;
      if (!Cartesian3_default.equals(maximumSize, value)) {
        Cartesian3_default.clone(value, maximumSize);
        makeDirty4(this, MAXIMUM_SIZE_INDEX);
      }
    }
  },
  color: {
    get: function() {
      return this._color;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      const color = this._color;
      if (!Color_default.equals(color, value)) {
        Color_default.clone(value, color);
        makeDirty4(this, COLOR_INDEX5);
      }
    }
  },
  slice: {
    get: function() {
      return this._slice;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      const slice = this._slice;
      if (slice !== value) {
        this._slice = value;
        makeDirty4(this, SLICE_INDEX);
      }
    }
  },
  brightness: {
    get: function() {
      return this._brightness;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      const brightness = this._brightness;
      if (brightness !== value) {
        this._brightness = value;
        makeDirty4(this, BRIGHTNESS_INDEX);
      }
    }
  }
});
CumulusCloud.prototype._destroy = function() {
  this._cloudCollection = void 0;
};
var CumulusCloud_default = CumulusCloud;

// node_modules/cesium/Source/Scene/CloudCollection.js
var attributeLocations6;
var scratchTextureDimensions = new Cartesian3_default();
var attributeLocationsBatched2 = {
  positionHighAndScaleX: 0,
  positionLowAndScaleY: 1,
  packedAttribute0: 2,
  packedAttribute1: 3,
  color: 4
};
var attributeLocationsInstanced2 = {
  direction: 0,
  positionHighAndScaleX: 1,
  positionLowAndScaleY: 2,
  packedAttribute0: 3,
  packedAttribute1: 4,
  color: 5
};
var SHOW_INDEX8 = CumulusCloud_default.SHOW_INDEX;
var POSITION_INDEX8 = CumulusCloud_default.POSITION_INDEX;
var SCALE_INDEX4 = CumulusCloud_default.SCALE_INDEX;
var MAXIMUM_SIZE_INDEX2 = CumulusCloud_default.MAXIMUM_SIZE_INDEX;
var SLICE_INDEX2 = CumulusCloud_default.SLICE_INDEX;
var BRIGHTNESS_INDEX2 = CumulusCloud_default.BRIGHTNESS_INDEX;
var NUMBER_OF_PROPERTIES5 = CumulusCloud_default.NUMBER_OF_PROPERTIES;
var COLOR_INDEX6 = CumulusCloud_default.COLOR_INDEX;
function CloudCollection(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._clouds = [];
  this._cloudsToUpdate = [];
  this._cloudsToUpdateIndex = 0;
  this._cloudsRemoved = false;
  this._createVertexArray = false;
  this._propertiesChanged = new Uint32Array(NUMBER_OF_PROPERTIES5);
  this._noiseTexture = void 0;
  this._textureSliceWidth = 128;
  this._noiseTextureRows = 4;
  this.noiseDetail = defaultValue_default(options.noiseDetail, 16);
  this.noiseOffset = Cartesian3_default.clone(
    defaultValue_default(options.noiseOffset, Cartesian3_default.ZERO)
  );
  this._loading = false;
  this._ready = false;
  const that = this;
  this._uniforms = {
    u_noiseTexture: function() {
      return that._noiseTexture;
    },
    u_noiseTextureDimensions: getNoiseTextureDimensions(that),
    u_noiseDetail: function() {
      return that.noiseDetail;
    }
  };
  this._vaNoise = void 0;
  this._spNoise = void 0;
  this._spCreated = false;
  this._sp = void 0;
  this._rs = void 0;
  this.show = defaultValue_default(options.show, true);
  this._colorCommands = [];
  this.debugBillboards = defaultValue_default(options.debugBillboards, false);
  this._compiledDebugBillboards = false;
  this.debugEllipsoids = defaultValue_default(options.debugEllipsoids, false);
  this._compiledDebugEllipsoids = false;
}
function getNoiseTextureDimensions(collection) {
  return function() {
    scratchTextureDimensions.x = collection._textureSliceWidth;
    scratchTextureDimensions.y = collection._noiseTextureRows;
    scratchTextureDimensions.z = 1 / collection._noiseTextureRows;
    return scratchTextureDimensions;
  };
}
Object.defineProperties(CloudCollection.prototype, {
  length: {
    get: function() {
      removeClouds(this);
      return this._clouds.length;
    }
  }
});
function destroyClouds(clouds) {
  const length3 = clouds.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (clouds[i2]) {
      clouds[i2]._destroy();
    }
  }
}
CloudCollection.prototype.add = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const cloudType = defaultValue_default(options.cloudType, CloudType_default.CUMULUS);
  if (!CloudType_default.validate(cloudType)) {
    throw new DeveloperError_default("invalid cloud type");
  }
  let cloud;
  if (cloudType === CloudType_default.CUMULUS) {
    cloud = new CumulusCloud_default(options, this);
    cloud._index = this._clouds.length;
    this._clouds.push(cloud);
    this._createVertexArray = true;
  }
  return cloud;
};
CloudCollection.prototype.remove = function(cloud) {
  if (this.contains(cloud)) {
    this._clouds[cloud._index] = void 0;
    this._cloudsRemoved = true;
    this._createVertexArray = true;
    cloud._destroy();
    return true;
  }
  return false;
};
CloudCollection.prototype.removeAll = function() {
  destroyClouds(this._clouds);
  this._clouds = [];
  this._cloudsToUpdate = [];
  this._cloudsToUpdateIndex = 0;
  this._cloudsRemoved = false;
  this._createVertexArray = true;
};
function removeClouds(cloudCollection) {
  if (cloudCollection._cloudsRemoved) {
    cloudCollection._cloudsRemoved = false;
    const newClouds = [];
    const clouds = cloudCollection._clouds;
    const length3 = clouds.length;
    for (let i2 = 0, j = 0; i2 < length3; ++i2) {
      const cloud = clouds[i2];
      if (defined_default(cloud)) {
        clouds._index = j++;
        newClouds.push(cloud);
      }
    }
    cloudCollection._clouds = newClouds;
  }
}
CloudCollection.prototype._updateCloud = function(cloud, propertyChanged) {
  if (!cloud._dirty) {
    this._cloudsToUpdate[this._cloudsToUpdateIndex++] = cloud;
  }
  ++this._propertiesChanged[propertyChanged];
};
CloudCollection.prototype.contains = function(cloud) {
  return defined_default(cloud) && cloud._cloudCollection === this;
};
CloudCollection.prototype.get = function(index2) {
  Check_default.typeOf.number("index", index2);
  removeClouds(this);
  return this._clouds[index2];
};
var texturePositions = new Float32Array([
  -1,
  -1,
  1,
  -1,
  1,
  1,
  -1,
  1
]);
var textureIndices = new Uint16Array([0, 1, 2, 0, 2, 3]);
function createTextureVA(context) {
  const positionBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: texturePositions,
    usage: BufferUsage_default.STATIC_DRAW
  });
  const indexBuffer = Buffer_default.createIndexBuffer({
    context,
    typedArray: textureIndices,
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
  });
  const attributes = [
    {
      index: 0,
      vertexBuffer: positionBuffer,
      componentsPerAttribute: 2,
      componentDatatype: ComponentDatatype_default.FLOAT
    }
  ];
  return new VertexArray_default({
    context,
    attributes,
    indexBuffer
  });
}
var getIndexBuffer3;
function getIndexBufferBatched2(context) {
  const sixteenK = 16 * 1024;
  let indexBuffer = context.cache.cloudCollection_indexBufferBatched;
  if (defined_default(indexBuffer)) {
    return indexBuffer;
  }
  const length3 = sixteenK * 6 - 6;
  const indices2 = new Uint16Array(length3);
  for (let i2 = 0, j = 0; i2 < length3; i2 += 6, j += 4) {
    indices2[i2] = j;
    indices2[i2 + 1] = j + 1;
    indices2[i2 + 2] = j + 2;
    indices2[i2 + 3] = j;
    indices2[i2 + 4] = j + 2;
    indices2[i2 + 5] = j + 3;
  }
  indexBuffer = Buffer_default.createIndexBuffer({
    context,
    typedArray: indices2,
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
  });
  indexBuffer.vertexArrayDestroyable = false;
  context.cache.cloudCollection_indexBufferBatched = indexBuffer;
  return indexBuffer;
}
function getIndexBufferInstanced2(context) {
  let indexBuffer = context.cache.cloudCollection_indexBufferInstanced;
  if (defined_default(indexBuffer)) {
    return indexBuffer;
  }
  indexBuffer = Buffer_default.createIndexBuffer({
    context,
    typedArray: new Uint16Array([0, 1, 2, 0, 2, 3]),
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
  });
  indexBuffer.vertexArrayDestroyable = false;
  context.cache.cloudCollection_indexBufferInstanced = indexBuffer;
  return indexBuffer;
}
function getVertexBufferInstanced2(context) {
  let vertexBuffer = context.cache.cloudCollection_vertexBufferInstanced;
  if (defined_default(vertexBuffer)) {
    return vertexBuffer;
  }
  vertexBuffer = Buffer_default.createVertexBuffer({
    context,
    typedArray: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
    usage: BufferUsage_default.STATIC_DRAW
  });
  vertexBuffer.vertexArrayDestroyable = false;
  context.cache.cloudCollection_vertexBufferInstanced = vertexBuffer;
  return vertexBuffer;
}
function createVAF3(context, numberOfClouds, instanced) {
  const attributes = [
    {
      index: attributeLocations6.positionHighAndScaleX,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: BufferUsage_default.STATIC_DRAW
    },
    {
      index: attributeLocations6.positionLowAndScaleY,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: BufferUsage_default.STATIC_DRAW
    },
    {
      index: attributeLocations6.packedAttribute0,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: BufferUsage_default.STATIC_DRAW
    },
    {
      index: attributeLocations6.packedAttribute1,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.FLOAT,
      usage: BufferUsage_default.STATIC_DRAW
    },
    {
      index: attributeLocations6.color,
      componentsPerAttribute: 4,
      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
      normalize: true,
      usage: BufferUsage_default.STATIC_DRAW
    }
  ];
  if (instanced) {
    attributes.push({
      index: attributeLocations6.direction,
      componentsPerAttribute: 2,
      componentDatatype: ComponentDatatype_default.FLOAT,
      vertexBuffer: getVertexBufferInstanced2(context)
    });
  }
  const sizeInVertices = instanced ? numberOfClouds : 4 * numberOfClouds;
  return new VertexArrayFacade_default(context, attributes, sizeInVertices, instanced);
}
var writePositionScratch3 = new EncodedCartesian3_default();
function writePositionAndScale(cloudCollection, frameState, vafWriters, cloud) {
  let i2;
  const positionHighWriter = vafWriters[attributeLocations6.positionHighAndScaleX];
  const positionLowWriter = vafWriters[attributeLocations6.positionLowAndScaleY];
  const position = cloud.position;
  EncodedCartesian3_default.fromCartesian(position, writePositionScratch3);
  const scale = cloud.scale;
  const high = writePositionScratch3.high;
  const low = writePositionScratch3.low;
  if (cloudCollection._instanced) {
    i2 = cloud._index;
    positionHighWriter(i2, high.x, high.y, high.z, scale.x);
    positionLowWriter(i2, low.x, low.y, low.z, scale.y);
  } else {
    i2 = cloud._index * 4;
    positionHighWriter(i2 + 0, high.x, high.y, high.z, scale.x);
    positionHighWriter(i2 + 1, high.x, high.y, high.z, scale.x);
    positionHighWriter(i2 + 2, high.x, high.y, high.z, scale.x);
    positionHighWriter(i2 + 3, high.x, high.y, high.z, scale.x);
    positionLowWriter(i2 + 0, low.x, low.y, low.z, scale.y);
    positionLowWriter(i2 + 1, low.x, low.y, low.z, scale.y);
    positionLowWriter(i2 + 2, low.x, low.y, low.z, scale.y);
    positionLowWriter(i2 + 3, low.x, low.y, low.z, scale.y);
  }
}
function writePackedAttribute0(cloudCollection, frameState, vafWriters, cloud) {
  let i2;
  const writer = vafWriters[attributeLocations6.packedAttribute0];
  const show = cloud.show;
  const brightness = cloud.brightness;
  if (cloudCollection._instanced) {
    i2 = cloud._index;
    writer(i2, show, brightness, 0, 0);
  } else {
    i2 = cloud._index * 4;
    writer(i2 + 0, show, brightness, 0, 0);
    writer(i2 + 1, show, brightness, 1, 0);
    writer(i2 + 2, show, brightness, 1, 1);
    writer(i2 + 3, show, brightness, 0, 1);
  }
}
function writePackedAttribute1(cloudCollection, frameState, vafWriters, cloud) {
  let i2;
  const writer = vafWriters[attributeLocations6.packedAttribute1];
  const maximumSize = cloud.maximumSize;
  const slice = cloud.slice;
  if (cloudCollection._instanced) {
    i2 = cloud._index;
    writer(i2, maximumSize.x, maximumSize.y, maximumSize.z, slice);
  } else {
    i2 = cloud._index * 4;
    writer(i2 + 0, maximumSize.x, maximumSize.y, maximumSize.z, slice);
    writer(i2 + 1, maximumSize.x, maximumSize.y, maximumSize.z, slice);
    writer(i2 + 2, maximumSize.x, maximumSize.y, maximumSize.z, slice);
    writer(i2 + 3, maximumSize.x, maximumSize.y, maximumSize.z, slice);
  }
}
function writeColor(cloudCollection, frameState, vafWriters, cloud) {
  let i2;
  const writer = vafWriters[attributeLocations6.color];
  const color = cloud.color;
  const red = Color_default.floatToByte(color.red);
  const green = Color_default.floatToByte(color.green);
  const blue = Color_default.floatToByte(color.blue);
  const alpha = Color_default.floatToByte(color.alpha);
  if (cloudCollection._instanced) {
    i2 = cloud._index;
    writer(i2, red, green, blue, alpha);
  } else {
    i2 = cloud._index * 4;
    writer(i2 + 0, red, green, blue, alpha);
    writer(i2 + 1, red, green, blue, alpha);
    writer(i2 + 2, red, green, blue, alpha);
    writer(i2 + 3, red, green, blue, alpha);
  }
}
function writeCloud(cloudCollection, frameState, vafWriters, cloud) {
  writePositionAndScale(cloudCollection, frameState, vafWriters, cloud);
  writePackedAttribute0(cloudCollection, frameState, vafWriters, cloud);
  writePackedAttribute1(cloudCollection, frameState, vafWriters, cloud);
  writeColor(cloudCollection, frameState, vafWriters, cloud);
}
function createNoiseTexture(cloudCollection, frameState, vsSource, fsSource) {
  const that = cloudCollection;
  const textureSliceWidth = that._textureSliceWidth;
  const noiseTextureRows = that._noiseTextureRows;
  if (textureSliceWidth / noiseTextureRows < 1 || textureSliceWidth % noiseTextureRows !== 0) {
    throw new DeveloperError_default(
      "noiseTextureRows must evenly divide textureSliceWidth"
    );
  }
  const context = frameState.context;
  that._vaNoise = createTextureVA(context);
  that._spNoise = ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: vsSource,
    fragmentShaderSource: fsSource,
    attributeLocations: {
      position: 0
    }
  });
  const noiseDetail = that.noiseDetail;
  const noiseOffset = that.noiseOffset;
  that._noiseTexture = new Texture_default({
    context,
    width: textureSliceWidth * textureSliceWidth / noiseTextureRows,
    height: textureSliceWidth * noiseTextureRows,
    pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
    pixelFormat: PixelFormat_default.RGBA,
    sampler: new Sampler_default({
      wrapS: TextureWrap_default.REPEAT,
      wrapT: TextureWrap_default.REPEAT,
      minificationFilter: TextureMinificationFilter_default.NEAREST,
      magnificationFilter: TextureMagnificationFilter_default.NEAREST
    })
  });
  const textureCommand = new ComputeCommand_default({
    vertexArray: that._vaNoise,
    shaderProgram: that._spNoise,
    outputTexture: that._noiseTexture,
    uniformMap: {
      u_noiseTextureDimensions: getNoiseTextureDimensions(that),
      u_noiseDetail: function() {
        return noiseDetail;
      },
      u_noiseOffset: function() {
        return noiseOffset;
      }
    },
    persists: false,
    owner: cloudCollection,
    postExecute: function(texture) {
      that._ready = true;
      that._loading = false;
    }
  });
  frameState.commandList.push(textureCommand);
  that._loading = true;
}
function createVertexArray7(cloudCollection, frameState) {
  const that = cloudCollection;
  const context = frameState.context;
  that._createVertexArray = false;
  that._vaf = that._vaf && that._vaf.destroy();
  const clouds = cloudCollection._clouds;
  const cloudsLength = clouds.length;
  if (cloudsLength > 0) {
    that._vaf = createVAF3(context, cloudsLength, that._instanced);
    const vafWriters = that._vaf.writers;
    let i2;
    for (i2 = 0; i2 < cloudsLength; ++i2) {
      const cloud = clouds[i2];
      writeCloud(cloudCollection, frameState, vafWriters, cloud);
    }
    that._vaf.commit(getIndexBuffer3(context));
  }
}
var scratchWriterArray3 = [];
function updateClouds(cloudCollection, frameState) {
  const context = frameState.context;
  const that = cloudCollection;
  const clouds = that._clouds;
  const cloudsLength = clouds.length;
  const cloudsToUpdate = that._cloudsToUpdate;
  const cloudsToUpdateLength = that._cloudsToUpdateIndex;
  const properties = that._propertiesChanged;
  const writers = scratchWriterArray3;
  writers.length = 0;
  if (properties[POSITION_INDEX8] || properties[SCALE_INDEX4]) {
    writers.push(writePositionAndScale);
  }
  if (properties[SHOW_INDEX8] || properties[BRIGHTNESS_INDEX2]) {
    writers.push(writePackedAttribute0);
  }
  if (properties[MAXIMUM_SIZE_INDEX2] || properties[SLICE_INDEX2]) {
    writers.push(writePackedAttribute1);
  }
  if (properties[COLOR_INDEX6]) {
    writers.push(writeColor);
  }
  const numWriters = writers.length;
  const vafWriters = that._vaf.writers;
  let i2, c14, w;
  if (cloudsToUpdateLength / cloudsLength > 0.1) {
    for (i2 = 0; i2 < cloudsToUpdateLength; ++i2) {
      c14 = cloudsToUpdate[i2];
      c14._dirty = false;
      for (w = 0; w < numWriters; ++w) {
        writers[w](cloudCollection, frameState, vafWriters, c14);
      }
    }
    that._vaf.commit(getIndexBuffer3(context));
  } else {
    for (i2 = 0; i2 < cloudsToUpdateLength; ++i2) {
      c14 = cloudsToUpdate[i2];
      c14._dirty = false;
      for (w = 0; w < numWriters; ++w) {
        writers[w](cloudCollection, frameState, vafWriters, c14);
      }
      if (that._instanced) {
        that._vaf.subCommit(c14._index, 1);
      } else {
        that._vaf.subCommit(c14._index * 4, 4);
      }
    }
    that._vaf.endSubCommits();
  }
  that._cloudsToUpdateIndex = 0;
}
function createShaderProgram4(cloudCollection, frameState, vsSource, fsSource) {
  const context = frameState.context;
  const that = cloudCollection;
  const vs = new ShaderSource_default({
    defines: [],
    sources: [vsSource]
  });
  if (that._instanced) {
    vs.defines.push("INSTANCED");
  }
  const fs = new ShaderSource_default({
    defines: [],
    sources: [fsSource]
  });
  if (that.debugBillboards) {
    fs.defines.push("DEBUG_BILLBOARDS");
  }
  if (that.debugEllipsoids) {
    fs.defines.push("DEBUG_ELLIPSOIDS");
  }
  that._sp = ShaderProgram_default.replaceCache({
    context,
    shaderProgram: that._sp,
    vertexShaderSource: vs,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations6
  });
  that._rs = RenderState_default.fromCache({
    depthTest: {
      enabled: true,
      func: WebGLConstants_default.LESS
    },
    depthMask: false,
    blending: BlendingState_default.ALPHA_BLEND
  });
  that._spCreated = true;
  that._compiledDebugBillboards = that.debugBillboards;
  that._compiledDebugEllipsoids = that.debugEllipsoids;
}
function createDrawCommands(cloudCollection, frameState) {
  const that = cloudCollection;
  const pass = frameState.passes;
  const uniforms = that._uniforms;
  const commandList = frameState.commandList;
  if (pass.render) {
    const colorList = that._colorCommands;
    const va = that._vaf.va;
    const vaLength = va.length;
    colorList.length = vaLength;
    for (let i2 = 0; i2 < vaLength; i2++) {
      let command = colorList[i2];
      if (!defined_default(command)) {
        command = colorList[i2] = new DrawCommand_default();
      }
      command.pass = Pass_default.TRANSLUCENT;
      command.owner = cloudCollection;
      command.uniformMap = uniforms;
      command.count = va[i2].indicesCount;
      command.vertexArray = va[i2].va;
      command.shaderProgram = that._sp;
      command.renderState = that._rs;
      if (that._instanced) {
        command.count = 6;
        command.instanceCount = that._clouds.length;
      }
      commandList.push(command);
    }
  }
}
CloudCollection.prototype.update = function(frameState) {
  removeClouds(this);
  if (!this.show) {
    return;
  }
  const debugging = this.debugBillboards || this.debugEllipsoids;
  this._ready = debugging ? true : defined_default(this._noiseTexture);
  if (!this._ready && !this._loading && !debugging) {
    createNoiseTexture(this, frameState, CloudNoiseVS_default, CloudNoiseFS_default);
  }
  this._instanced = frameState.context.instancedArrays;
  attributeLocations6 = this._instanced ? attributeLocationsInstanced2 : attributeLocationsBatched2;
  getIndexBuffer3 = this._instanced ? getIndexBufferInstanced2 : getIndexBufferBatched2;
  const clouds = this._clouds;
  const cloudsLength = clouds.length;
  const cloudsToUpdate = this._cloudsToUpdate;
  const cloudsToUpdateLength = this._cloudsToUpdateIndex;
  if (this._createVertexArray) {
    createVertexArray7(this, frameState);
  } else if (cloudsToUpdateLength > 0) {
    updateClouds(this, frameState);
  }
  if (cloudsToUpdateLength > cloudsLength * 1.5) {
    cloudsToUpdate.length = cloudsLength;
  }
  if (!defined_default(this._vaf) || !defined_default(this._vaf.va) || !this._ready & !debugging) {
    return;
  }
  if (!this._spCreated || this.debugBillboards !== this._compiledDebugBillboards || this.debugEllipsoids !== this._compiledDebugEllipsoids) {
    createShaderProgram4(this, frameState, CloudCollectionVS_default, CloudCollectionFS_default);
  }
  createDrawCommands(this, frameState);
};
CloudCollection.prototype.isDestroyed = function() {
  return false;
};
CloudCollection.prototype.destroy = function() {
  this._noiseTexture = this._noiseTexture && this._noiseTexture.destroy();
  this._sp = this._sp && this._sp.destroy();
  this._vaf = this._vaf && this._vaf.destroy();
  destroyClouds(this._clouds);
  return destroyObject_default(this);
};
var CloudCollection_default = CloudCollection;

// node_modules/cesium/Source/Scene/ConeEmitter.js
var defaultAngle = Math_default.toRadians(30);
function ConeEmitter(angle) {
  this._angle = defaultValue_default(angle, defaultAngle);
}
Object.defineProperties(ConeEmitter.prototype, {
  angle: {
    get: function() {
      return this._angle;
    },
    set: function(value) {
      Check_default.typeOf.number("value", value);
      this._angle = value;
    }
  }
});
ConeEmitter.prototype.emit = function(particle) {
  const radius = Math.tan(this._angle);
  const theta = Math_default.randomBetween(0, Math_default.TWO_PI);
  const rad = Math_default.randomBetween(0, radius);
  const x = rad * Math.cos(theta);
  const y = rad * Math.sin(theta);
  const z = 1;
  particle.velocity = Cartesian3_default.fromElements(x, y, z, particle.velocity);
  Cartesian3_default.normalize(particle.velocity, particle.velocity);
  particle.position = Cartesian3_default.clone(Cartesian3_default.ZERO, particle.position);
};
var ConeEmitter_default = ConeEmitter;

// node_modules/cesium/Source/Scene/CreditDisplay.js
var mobileWidth = 576;
var lightboxHeight = 100;
var textColor = "#ffffff";
var highlightColor = "#48b";
function CreditDisplayElement(credit, count) {
  this.credit = credit;
  this.count = defaultValue_default(count, 1);
}
function contains2(credits, credit) {
  const len = credits.length;
  for (let i2 = 0; i2 < len; i2++) {
    const existingCredit = credits[i2];
    if (Credit_default.equals(existingCredit, credit)) {
      return true;
    }
  }
  return false;
}
function swapCesiumCredit(creditDisplay) {
  const previousCredit = creditDisplay._previousCesiumCredit;
  const currentCredit = creditDisplay._currentCesiumCredit;
  if (Credit_default.equals(currentCredit, previousCredit)) {
    return;
  }
  if (defined_default(previousCredit)) {
    creditDisplay._cesiumCreditContainer.removeChild(previousCredit.element);
  }
  if (defined_default(currentCredit)) {
    creditDisplay._cesiumCreditContainer.appendChild(currentCredit.element);
  }
  creditDisplay._previousCesiumCredit = currentCredit;
}
var delimiterClassName = "cesium-credit-delimiter";
function createDelimiterElement(delimiter) {
  const delimiterElement = document.createElement("span");
  delimiterElement.textContent = delimiter;
  delimiterElement.className = delimiterClassName;
  return delimiterElement;
}
function createCreditElement(element, elementWrapperTagName) {
  if (defined_default(elementWrapperTagName)) {
    const wrapper = document.createElement(elementWrapperTagName);
    wrapper._creditId = element._creditId;
    wrapper.appendChild(element);
    element = wrapper;
  }
  return element;
}
function displayCredits(container, credits, delimiter, elementWrapperTagName) {
  const childNodes = container.childNodes;
  let domIndex = -1;
  credits.sort(function(credit1, credit2) {
    return credit2.count - credit1.count;
  });
  for (let creditIndex = 0; creditIndex < credits.length; ++creditIndex) {
    const credit = credits[creditIndex].credit;
    if (defined_default(credit)) {
      domIndex = creditIndex;
      if (defined_default(delimiter)) {
        domIndex *= 2;
        if (creditIndex > 0) {
          const delimiterDomIndex = domIndex - 1;
          if (childNodes.length <= delimiterDomIndex) {
            container.appendChild(createDelimiterElement(delimiter));
          } else {
            const existingDelimiter = childNodes[delimiterDomIndex];
            if (existingDelimiter.className !== delimiterClassName) {
              container.replaceChild(
                createDelimiterElement(delimiter),
                existingDelimiter
              );
            }
          }
        }
      }
      const element = credit.element;
      if (childNodes.length <= domIndex) {
        container.appendChild(
          createCreditElement(element, elementWrapperTagName)
        );
      } else {
        const existingElement = childNodes[domIndex];
        if (existingElement._creditId !== credit._id) {
          container.replaceChild(
            createCreditElement(element, elementWrapperTagName),
            existingElement
          );
        }
      }
    }
  }
  ++domIndex;
  while (domIndex < childNodes.length) {
    container.removeChild(childNodes[domIndex]);
  }
}
function styleLightboxContainer(that) {
  const lightboxCredits = that._lightboxCredits;
  const width = that.viewport.clientWidth;
  const height = that.viewport.clientHeight;
  if (width !== that._lastViewportWidth) {
    if (width < mobileWidth) {
      lightboxCredits.className = "cesium-credit-lightbox cesium-credit-lightbox-mobile";
      lightboxCredits.style.marginTop = "0";
    } else {
      lightboxCredits.className = "cesium-credit-lightbox cesium-credit-lightbox-expanded";
      lightboxCredits.style.marginTop = `${Math.floor(
        (height - lightboxCredits.clientHeight) * 0.5
      )}px`;
    }
    that._lastViewportWidth = width;
  }
  if (width >= mobileWidth && height !== that._lastViewportHeight) {
    lightboxCredits.style.marginTop = `${Math.floor(
      (height - lightboxCredits.clientHeight) * 0.5
    )}px`;
    that._lastViewportHeight = height;
  }
}
function addStyle(selector, styles) {
  let style = `${selector} {`;
  for (const attribute in styles) {
    if (styles.hasOwnProperty(attribute)) {
      style += `${attribute}: ${styles[attribute]}; `;
    }
  }
  style += " }\n";
  return style;
}
function appendCss() {
  let style = "";
  style += addStyle(".cesium-credit-lightbox-overlay", {
    display: "none",
    "z-index": "1",
    position: "absolute",
    top: "0",
    left: "0",
    width: "100%",
    height: "100%",
    "background-color": "rgba(80, 80, 80, 0.8)"
  });
  style += addStyle(".cesium-credit-lightbox", {
    "background-color": "#303336",
    color: textColor,
    position: "relative",
    "min-height": `${lightboxHeight}px`,
    margin: "auto"
  });
  style += addStyle(
    ".cesium-credit-lightbox > ul > li a, .cesium-credit-lightbox > ul > li a:visited",
    {
      color: textColor
    }
  );
  style += addStyle(".cesium-credit-lightbox > ul > li a:hover", {
    color: highlightColor
  });
  style += addStyle(".cesium-credit-lightbox.cesium-credit-lightbox-expanded", {
    border: "1px solid #444",
    "border-radius": "5px",
    "max-width": "370px"
  });
  style += addStyle(".cesium-credit-lightbox.cesium-credit-lightbox-mobile", {
    height: "100%",
    width: "100%"
  });
  style += addStyle(".cesium-credit-lightbox-title", {
    padding: "20px 20px 0 20px"
  });
  style += addStyle(".cesium-credit-lightbox-close", {
    "font-size": "18pt",
    cursor: "pointer",
    position: "absolute",
    top: "0",
    right: "6px",
    color: textColor
  });
  style += addStyle(".cesium-credit-lightbox-close:hover", {
    color: highlightColor
  });
  style += addStyle(".cesium-credit-lightbox > ul", {
    margin: "0",
    padding: "12px 20px 12px 40px",
    "font-size": "13px"
  });
  style += addStyle(".cesium-credit-lightbox > ul > li", {
    "padding-bottom": "6px"
  });
  style += addStyle(".cesium-credit-lightbox > ul > li *", {
    padding: "0",
    margin: "0"
  });
  style += addStyle(".cesium-credit-expand-link", {
    "padding-left": "5px",
    cursor: "pointer",
    "text-decoration": "underline",
    color: textColor
  });
  style += addStyle(".cesium-credit-expand-link:hover", {
    color: highlightColor
  });
  style += addStyle(".cesium-credit-text", {
    color: textColor
  });
  style += addStyle(
    ".cesium-credit-textContainer *, .cesium-credit-logoContainer *",
    {
      display: "inline"
    }
  );
  const head = document.head;
  const css = document.createElement("style");
  css.innerHTML = style;
  head.insertBefore(css, head.firstChild);
}
function CreditDisplay(container, delimiter, viewport) {
  Check_default.defined("container", container);
  const that = this;
  viewport = defaultValue_default(viewport, document.body);
  const lightbox = document.createElement("div");
  lightbox.className = "cesium-credit-lightbox-overlay";
  viewport.appendChild(lightbox);
  const lightboxCredits = document.createElement("div");
  lightboxCredits.className = "cesium-credit-lightbox";
  lightbox.appendChild(lightboxCredits);
  function hideLightbox(event) {
    if (lightboxCredits.contains(event.target)) {
      return;
    }
    that.hideLightbox();
  }
  lightbox.addEventListener("click", hideLightbox, false);
  const title = document.createElement("div");
  title.className = "cesium-credit-lightbox-title";
  title.textContent = "Data provided by:";
  lightboxCredits.appendChild(title);
  const closeButton = document.createElement("a");
  closeButton.onclick = this.hideLightbox.bind(this);
  closeButton.innerHTML = "&times;";
  closeButton.className = "cesium-credit-lightbox-close";
  lightboxCredits.appendChild(closeButton);
  const creditList = document.createElement("ul");
  lightboxCredits.appendChild(creditList);
  const cesiumCreditContainer = document.createElement("div");
  cesiumCreditContainer.className = "cesium-credit-logoContainer";
  cesiumCreditContainer.style.display = "inline";
  container.appendChild(cesiumCreditContainer);
  const screenContainer = document.createElement("div");
  screenContainer.className = "cesium-credit-textContainer";
  screenContainer.style.display = "inline";
  container.appendChild(screenContainer);
  const expandLink = document.createElement("a");
  expandLink.className = "cesium-credit-expand-link";
  expandLink.onclick = this.showLightbox.bind(this);
  expandLink.textContent = "Data attribution";
  container.appendChild(expandLink);
  appendCss();
  const cesiumCredit = Credit_default.clone(CreditDisplay.cesiumCredit);
  this._delimiter = defaultValue_default(delimiter, " \u2022 ");
  this._screenContainer = screenContainer;
  this._cesiumCreditContainer = cesiumCreditContainer;
  this._lastViewportHeight = void 0;
  this._lastViewportWidth = void 0;
  this._lightboxCredits = lightboxCredits;
  this._creditList = creditList;
  this._lightbox = lightbox;
  this._hideLightbox = hideLightbox;
  this._expandLink = expandLink;
  this._expanded = false;
  this._defaultCredits = [];
  this._cesiumCredit = cesiumCredit;
  this._previousCesiumCredit = void 0;
  this._currentCesiumCredit = cesiumCredit;
  this._creditDisplayElementPool = [];
  this._creditDisplayElementIndex = 0;
  this._currentFrameCredits = {
    screenCredits: new AssociativeArray_default(),
    lightboxCredits: new AssociativeArray_default()
  };
  this._defaultCredit = void 0;
  this.viewport = viewport;
  this.container = container;
}
function setCredit(creditDisplay, credits, credit, count) {
  count = defaultValue_default(count, 1);
  let creditDisplayElement = credits.get(credit.id);
  if (!defined_default(creditDisplayElement)) {
    const pool2 = creditDisplay._creditDisplayElementPool;
    const poolIndex = creditDisplay._creditDisplayElementPoolIndex;
    if (poolIndex < pool2.length) {
      creditDisplayElement = pool2[poolIndex];
      creditDisplayElement.credit = credit;
      creditDisplayElement.count = count;
    } else {
      creditDisplayElement = new CreditDisplayElement(credit, count);
      pool2.push(creditDisplayElement);
    }
    ++creditDisplay._creditDisplayElementPoolIndex;
    credits.set(credit.id, creditDisplayElement);
  } else if (creditDisplayElement.count < Number.MAX_VALUE) {
    creditDisplayElement.count += count;
  }
}
CreditDisplay.prototype.addCredit = function(credit) {
  Check_default.defined("credit", credit);
  if (credit._isIon) {
    if (!defined_default(this._defaultCredit)) {
      this._defaultCredit = Credit_default.clone(getDefaultCredit());
    }
    this._currentCesiumCredit = this._defaultCredit;
    return;
  }
  let credits;
  if (!credit.showOnScreen) {
    credits = this._currentFrameCredits.lightboxCredits;
  } else {
    credits = this._currentFrameCredits.screenCredits;
  }
  setCredit(this, credits, credit);
};
CreditDisplay.prototype.addDefaultCredit = function(credit) {
  Check_default.defined("credit", credit);
  const defaultCredits = this._defaultCredits;
  if (!contains2(defaultCredits, credit)) {
    defaultCredits.push(credit);
  }
};
CreditDisplay.prototype.removeDefaultCredit = function(credit) {
  Check_default.defined("credit", credit);
  const defaultCredits = this._defaultCredits;
  const index2 = defaultCredits.indexOf(credit);
  if (index2 !== -1) {
    defaultCredits.splice(index2, 1);
  }
};
CreditDisplay.prototype.showLightbox = function() {
  this._lightbox.style.display = "block";
  this._expanded = true;
};
CreditDisplay.prototype.hideLightbox = function() {
  this._lightbox.style.display = "none";
  this._expanded = false;
};
CreditDisplay.prototype.update = function() {
  if (this._expanded) {
    styleLightboxContainer(this);
  }
};
CreditDisplay.prototype.beginFrame = function() {
  const currentFrameCredits = this._currentFrameCredits;
  this._creditDisplayElementPoolIndex = 0;
  const screenCredits = currentFrameCredits.screenCredits;
  screenCredits.removeAll();
  const defaultCredits = this._defaultCredits;
  for (let i2 = 0; i2 < defaultCredits.length; ++i2) {
    const defaultCredit5 = defaultCredits[i2];
    setCredit(this, screenCredits, defaultCredit5, Number.MAX_VALUE);
  }
  currentFrameCredits.lightboxCredits.removeAll();
  if (!Credit_default.equals(CreditDisplay.cesiumCredit, this._cesiumCredit)) {
    this._cesiumCredit = Credit_default.clone(CreditDisplay.cesiumCredit);
  }
  this._currentCesiumCredit = this._cesiumCredit;
};
CreditDisplay.prototype.endFrame = function() {
  const screenCredits = this._currentFrameCredits.screenCredits.values;
  displayCredits(
    this._screenContainer,
    screenCredits,
    this._delimiter,
    void 0
  );
  const lightboxCredits = this._currentFrameCredits.lightboxCredits.values;
  this._expandLink.style.display = lightboxCredits.length > 0 ? "inline" : "none";
  displayCredits(this._creditList, lightboxCredits, void 0, "li");
  swapCesiumCredit(this);
};
CreditDisplay.prototype.destroy = function() {
  this._lightbox.removeEventListener("click", this._hideLightbox, false);
  this.container.removeChild(this._cesiumCreditContainer);
  this.container.removeChild(this._screenContainer);
  this.container.removeChild(this._expandLink);
  this.viewport.removeChild(this._lightbox);
  return destroyObject_default(this);
};
CreditDisplay.prototype.isDestroyed = function() {
  return false;
};
CreditDisplay._cesiumCredit = void 0;
CreditDisplay._cesiumCreditInitialized = false;
var defaultCredit;
function getDefaultCredit() {
  if (!defined_default(defaultCredit)) {
    let logo = buildModuleUrl_default("Assets/Images/ion-credit.png");
    if (logo.indexOf("http://") !== 0 && logo.indexOf("https://") !== 0 && logo.indexOf("data:") !== 0) {
      const logoUrl = new URI(logo);
      logo = logoUrl.path();
    }
    defaultCredit = new Credit_default(
      `<a href="https://cesium.com/" target="_blank"><img src="${logo}" title="Cesium ion"/></a>`,
      true
    );
  }
  if (!CreditDisplay._cesiumCreditInitialized) {
    CreditDisplay._cesiumCredit = defaultCredit;
    CreditDisplay._cesiumCreditInitialized = true;
  }
  return defaultCredit;
}
Object.defineProperties(CreditDisplay, {
  cesiumCredit: {
    get: function() {
      getDefaultCredit();
      return CreditDisplay._cesiumCredit;
    },
    set: function(value) {
      CreditDisplay._cesiumCredit = value;
      CreditDisplay._cesiumCreditInitialized = true;
    }
  }
});
CreditDisplay.CreditDisplayElement = CreditDisplayElement;
var CreditDisplay_default = CreditDisplay;

// node_modules/cesium/Source/Scene/DebugAppearance.js
function DebugAppearance(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const attributeName = options.attributeName;
  let perInstanceAttribute = options.perInstanceAttribute;
  if (!defined_default(attributeName)) {
    throw new DeveloperError_default("options.attributeName is required.");
  }
  if (!defined_default(perInstanceAttribute)) {
    perInstanceAttribute = false;
  }
  let glslDatatype = defaultValue_default(options.glslDatatype, "vec3");
  const varyingName = `v_${attributeName}`;
  let getColor;
  if (attributeName === "normal" || attributeName === "tangent" || attributeName === "bitangent") {
    getColor = `vec4 getColor() { return vec4((${varyingName} + vec3(1.0)) * 0.5, 1.0); }
`;
  } else {
    if (attributeName === "st") {
      glslDatatype = "vec2";
    }
    switch (glslDatatype) {
      case "float":
        getColor = `vec4 getColor() { return vec4(vec3(${varyingName}), 1.0); }
`;
        break;
      case "vec2":
        getColor = `vec4 getColor() { return vec4(${varyingName}, 0.0, 1.0); }
`;
        break;
      case "vec3":
        getColor = `vec4 getColor() { return vec4(${varyingName}, 1.0); }
`;
        break;
      case "vec4":
        getColor = `vec4 getColor() { return ${varyingName}; }
`;
        break;
      default:
        throw new DeveloperError_default(
          "options.glslDatatype must be float, vec2, vec3, or vec4."
        );
    }
  }
  const vs = `${"attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute float batchId;\n"}${perInstanceAttribute ? "" : `attribute ${glslDatatype} ${attributeName};
`}varying ${glslDatatype} ${varyingName};
void main()
{
vec4 p = czm_translateRelativeToEye(position3DHigh, position3DLow);
${perInstanceAttribute ? `${varyingName} = czm_batchTable_${attributeName}(batchId);
` : `${varyingName} = ${attributeName};
`}gl_Position = czm_modelViewProjectionRelativeToEye * p;
}`;
  const fs = `varying ${glslDatatype} ${varyingName};
${getColor}
void main()
{
gl_FragColor = getColor();
}`;
  this.material = void 0;
  this.translucent = defaultValue_default(options.translucent, false);
  this._vertexShaderSource = defaultValue_default(options.vertexShaderSource, vs);
  this._fragmentShaderSource = defaultValue_default(options.fragmentShaderSource, fs);
  this._renderState = Appearance_default.getDefaultRenderState(
    false,
    false,
    options.renderState
  );
  this._closed = defaultValue_default(options.closed, false);
  this._attributeName = attributeName;
  this._glslDatatype = glslDatatype;
}
Object.defineProperties(DebugAppearance.prototype, {
  vertexShaderSource: {
    get: function() {
      return this._vertexShaderSource;
    }
  },
  fragmentShaderSource: {
    get: function() {
      return this._fragmentShaderSource;
    }
  },
  renderState: {
    get: function() {
      return this._renderState;
    }
  },
  closed: {
    get: function() {
      return this._closed;
    }
  },
  attributeName: {
    get: function() {
      return this._attributeName;
    }
  },
  glslDatatype: {
    get: function() {
      return this._glslDatatype;
    }
  }
});
DebugAppearance.prototype.getFragmentShaderSource = Appearance_default.prototype.getFragmentShaderSource;
DebugAppearance.prototype.isTranslucent = Appearance_default.prototype.isTranslucent;
DebugAppearance.prototype.getRenderState = Appearance_default.prototype.getRenderState;
var DebugAppearance_default = DebugAppearance;

// node_modules/cesium/Source/Scene/DebugCameraPrimitive.js
function DebugCameraPrimitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.camera)) {
    throw new DeveloperError_default("options.camera is required.");
  }
  this._camera = options.camera;
  this._frustumSplits = options.frustumSplits;
  this._color = defaultValue_default(options.color, Color_default.CYAN);
  this._updateOnChange = defaultValue_default(options.updateOnChange, true);
  this.show = defaultValue_default(options.show, true);
  this.id = options.id;
  this._id = void 0;
  this._outlinePrimitives = [];
  this._planesPrimitives = [];
}
var scratchRight2 = new Cartesian3_default();
var scratchRotation3 = new Matrix3_default();
var scratchOrientation = new Quaternion_default();
var scratchPerspective = new PerspectiveFrustum_default();
var scratchPerspectiveOffCenter = new PerspectiveOffCenterFrustum_default();
var scratchOrthographic = new OrthographicFrustum_default();
var scratchOrthographicOffCenter = new OrthographicOffCenterFrustum_default();
var scratchColor24 = new Color_default();
var scratchSplits = [1, 1e5];
DebugCameraPrimitive.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  const planesPrimitives = this._planesPrimitives;
  const outlinePrimitives = this._outlinePrimitives;
  let i2;
  let length3;
  if (this._updateOnChange) {
    length3 = planesPrimitives.length;
    for (i2 = 0; i2 < length3; ++i2) {
      outlinePrimitives[i2] = outlinePrimitives[i2] && outlinePrimitives[i2].destroy();
      planesPrimitives[i2] = planesPrimitives[i2] && planesPrimitives[i2].destroy();
    }
    planesPrimitives.length = 0;
    outlinePrimitives.length = 0;
  }
  if (planesPrimitives.length === 0) {
    const camera = this._camera;
    const cameraFrustum = camera.frustum;
    let frustum;
    if (cameraFrustum instanceof PerspectiveFrustum_default) {
      frustum = scratchPerspective;
    } else if (cameraFrustum instanceof PerspectiveOffCenterFrustum_default) {
      frustum = scratchPerspectiveOffCenter;
    } else if (cameraFrustum instanceof OrthographicFrustum_default) {
      frustum = scratchOrthographic;
    } else {
      frustum = scratchOrthographicOffCenter;
    }
    frustum = cameraFrustum.clone(frustum);
    let numFrustums;
    let frustumSplits2 = this._frustumSplits;
    if (!defined_default(frustumSplits2) || frustumSplits2.length <= 1) {
      frustumSplits2 = scratchSplits;
      frustumSplits2[0] = this._camera.frustum.near;
      frustumSplits2[1] = this._camera.frustum.far;
      numFrustums = 1;
    } else {
      numFrustums = frustumSplits2.length - 1;
    }
    const position = camera.positionWC;
    const direction2 = camera.directionWC;
    const up = camera.upWC;
    let right = camera.rightWC;
    right = Cartesian3_default.negate(right, scratchRight2);
    const rotation = scratchRotation3;
    Matrix3_default.setColumn(rotation, 0, right, rotation);
    Matrix3_default.setColumn(rotation, 1, up, rotation);
    Matrix3_default.setColumn(rotation, 2, direction2, rotation);
    const orientation = Quaternion_default.fromRotationMatrix(
      rotation,
      scratchOrientation
    );
    planesPrimitives.length = outlinePrimitives.length = numFrustums;
    for (i2 = 0; i2 < numFrustums; ++i2) {
      frustum.near = frustumSplits2[i2];
      frustum.far = frustumSplits2[i2 + 1];
      planesPrimitives[i2] = new Primitive_default({
        geometryInstances: new GeometryInstance_default({
          geometry: new FrustumGeometry_default({
            origin: position,
            orientation,
            frustum,
            _drawNearPlane: i2 === 0
          }),
          attributes: {
            color: ColorGeometryInstanceAttribute_default.fromColor(
              Color_default.fromAlpha(this._color, 0.1, scratchColor24)
            )
          },
          id: this.id,
          pickPrimitive: this
        }),
        appearance: new PerInstanceColorAppearance_default({
          translucent: true,
          flat: true
        }),
        asynchronous: false
      });
      outlinePrimitives[i2] = new Primitive_default({
        geometryInstances: new GeometryInstance_default({
          geometry: new FrustumOutlineGeometry_default({
            origin: position,
            orientation,
            frustum,
            _drawNearPlane: i2 === 0
          }),
          attributes: {
            color: ColorGeometryInstanceAttribute_default.fromColor(this._color)
          },
          id: this.id,
          pickPrimitive: this
        }),
        appearance: new PerInstanceColorAppearance_default({
          translucent: false,
          flat: true
        }),
        asynchronous: false
      });
    }
  }
  length3 = planesPrimitives.length;
  for (i2 = 0; i2 < length3; ++i2) {
    outlinePrimitives[i2].update(frameState);
    planesPrimitives[i2].update(frameState);
  }
};
DebugCameraPrimitive.prototype.isDestroyed = function() {
  return false;
};
DebugCameraPrimitive.prototype.destroy = function() {
  const length3 = this._planesPrimitives.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    this._outlinePrimitives[i2] = this._outlinePrimitives[i2] && this._outlinePrimitives[i2].destroy();
    this._planesPrimitives[i2] = this._planesPrimitives[i2] && this._planesPrimitives[i2].destroy();
  }
  return destroyObject_default(this);
};
var DebugCameraPrimitive_default = DebugCameraPrimitive;

// node_modules/cesium/Source/Scene/DebugInspector.js
function DebugInspector() {
  this._cachedShowFrustumsShaders = {};
}
function getAttributeLocations3(shaderProgram) {
  const attributeLocations8 = {};
  const attributes = shaderProgram.vertexAttributes;
  for (const a4 in attributes) {
    if (attributes.hasOwnProperty(a4)) {
      attributeLocations8[a4] = attributes[a4].index;
    }
  }
  return attributeLocations8;
}
function createDebugShowFrustumsShaderProgram(scene, shaderProgram) {
  const context = scene.context;
  const sp = shaderProgram;
  const fs = sp.fragmentShaderSource.clone();
  const targets = [];
  fs.sources = fs.sources.map(function(source) {
    source = ShaderSource_default.replaceMain(source, "czm_Debug_main");
    const re = /gl_FragData\[(\d+)\]/g;
    let match;
    while ((match = re.exec(source)) !== null) {
      if (targets.indexOf(match[1]) === -1) {
        targets.push(match[1]);
      }
    }
    return source;
  });
  const length3 = targets.length;
  let newMain = "";
  newMain += "uniform vec3 debugShowCommandsColor;\n";
  newMain += "uniform vec3 debugShowFrustumsColor;\n";
  newMain += "void main() \n{ \n    czm_Debug_main(); \n";
  let i2;
  if (length3 > 0) {
    for (i2 = 0; i2 < length3; ++i2) {
      newMain += `    gl_FragData[${targets[i2]}].rgb *= debugShowCommandsColor;
`;
      newMain += `    gl_FragData[${targets[i2]}].rgb *= debugShowFrustumsColor;
`;
    }
  } else {
    newMain += "    gl_FragColor.rgb *= debugShowCommandsColor;\n";
    newMain += "    gl_FragColor.rgb *= debugShowFrustumsColor;\n";
  }
  newMain += "}";
  fs.sources.push(newMain);
  const attributeLocations8 = getAttributeLocations3(sp);
  return ShaderProgram_default.fromCache({
    context,
    vertexShaderSource: sp.vertexShaderSource,
    fragmentShaderSource: fs,
    attributeLocations: attributeLocations8
  });
}
var scratchFrustumColor = new Color_default();
function createDebugShowFrustumsUniformMap(scene, command) {
  let debugUniformMap;
  if (!defined_default(command.uniformMap)) {
    debugUniformMap = {};
  } else {
    debugUniformMap = command.uniformMap;
  }
  if (defined_default(debugUniformMap.debugShowCommandsColor) || defined_default(debugUniformMap.debugShowFrustumsColor)) {
    return debugUniformMap;
  }
  debugUniformMap.debugShowCommandsColor = function() {
    if (!scene.debugShowCommands) {
      return Color_default.WHITE;
    }
    if (!defined_default(command._debugColor)) {
      command._debugColor = Color_default.fromRandom();
    }
    return command._debugColor;
  };
  debugUniformMap.debugShowFrustumsColor = function() {
    if (!scene.debugShowFrustums) {
      return Color_default.WHITE;
    }
    scratchFrustumColor.red = command.debugOverlappingFrustums & 1 << 0 ? 1 : 0;
    scratchFrustumColor.green = command.debugOverlappingFrustums & 1 << 1 ? 1 : 0;
    scratchFrustumColor.blue = command.debugOverlappingFrustums & 1 << 2 ? 1 : 0;
    scratchFrustumColor.alpha = 1;
    return scratchFrustumColor;
  };
  return debugUniformMap;
}
var scratchShowFrustumCommand = new DrawCommand_default();
DebugInspector.prototype.executeDebugShowFrustumsCommand = function(scene, command, passState) {
  const shaderProgramId = command.shaderProgram.id;
  let debugShaderProgram = this._cachedShowFrustumsShaders[shaderProgramId];
  if (!defined_default(debugShaderProgram)) {
    debugShaderProgram = createDebugShowFrustumsShaderProgram(
      scene,
      command.shaderProgram
    );
    this._cachedShowFrustumsShaders[shaderProgramId] = debugShaderProgram;
  }
  const debugCommand = DrawCommand_default.shallowClone(
    command,
    scratchShowFrustumCommand
  );
  debugCommand.shaderProgram = debugShaderProgram;
  debugCommand.uniformMap = createDebugShowFrustumsUniformMap(scene, command);
  debugCommand.execute(scene.context, passState);
};
var DebugInspector_default = DebugInspector;

// node_modules/cesium/Source/Scene/DebugModelMatrixPrimitive.js
function DebugModelMatrixPrimitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.length = defaultValue_default(options.length, 1e7);
  this._length = void 0;
  this.width = defaultValue_default(options.width, 2);
  this._width = void 0;
  this.show = defaultValue_default(options.show, true);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._modelMatrix = new Matrix4_default();
  this.id = options.id;
  this._id = void 0;
  this._primitive = void 0;
}
DebugModelMatrixPrimitive.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  if (!defined_default(this._primitive) || !Matrix4_default.equals(this._modelMatrix, this.modelMatrix) || this._length !== this.length || this._width !== this.width || this._id !== this.id) {
    this._modelMatrix = Matrix4_default.clone(this.modelMatrix, this._modelMatrix);
    this._length = this.length;
    this._width = this.width;
    this._id = this.id;
    if (defined_default(this._primitive)) {
      this._primitive.destroy();
    }
    if (this.modelMatrix[12] === 0 && this.modelMatrix[13] === 0 && this.modelMatrix[14] === 0) {
      this.modelMatrix[14] = 0.01;
    }
    const x = new GeometryInstance_default({
      geometry: new PolylineGeometry_default({
        positions: [Cartesian3_default.ZERO, Cartesian3_default.UNIT_X],
        width: this.width,
        vertexFormat: PolylineColorAppearance_default.VERTEX_FORMAT,
        colors: [Color_default.RED, Color_default.RED],
        arcType: ArcType_default.NONE
      }),
      modelMatrix: Matrix4_default.multiplyByUniformScale(
        this.modelMatrix,
        this.length,
        new Matrix4_default()
      ),
      id: this.id,
      pickPrimitive: this
    });
    const y = new GeometryInstance_default({
      geometry: new PolylineGeometry_default({
        positions: [Cartesian3_default.ZERO, Cartesian3_default.UNIT_Y],
        width: this.width,
        vertexFormat: PolylineColorAppearance_default.VERTEX_FORMAT,
        colors: [Color_default.GREEN, Color_default.GREEN],
        arcType: ArcType_default.NONE
      }),
      modelMatrix: Matrix4_default.multiplyByUniformScale(
        this.modelMatrix,
        this.length,
        new Matrix4_default()
      ),
      id: this.id,
      pickPrimitive: this
    });
    const z = new GeometryInstance_default({
      geometry: new PolylineGeometry_default({
        positions: [Cartesian3_default.ZERO, Cartesian3_default.UNIT_Z],
        width: this.width,
        vertexFormat: PolylineColorAppearance_default.VERTEX_FORMAT,
        colors: [Color_default.BLUE, Color_default.BLUE],
        arcType: ArcType_default.NONE
      }),
      modelMatrix: Matrix4_default.multiplyByUniformScale(
        this.modelMatrix,
        this.length,
        new Matrix4_default()
      ),
      id: this.id,
      pickPrimitive: this
    });
    this._primitive = new Primitive_default({
      geometryInstances: [x, y, z],
      appearance: new PolylineColorAppearance_default(),
      asynchronous: false
    });
  }
  this._primitive.update(frameState);
};
DebugModelMatrixPrimitive.prototype.isDestroyed = function() {
  return false;
};
DebugModelMatrixPrimitive.prototype.destroy = function() {
  this._primitive = this._primitive && this._primitive.destroy();
  return destroyObject_default(this);
};
var DebugModelMatrixPrimitive_default = DebugModelMatrixPrimitive;

// node_modules/cesium/Source/Shaders/DepthPlaneFS.js
var DepthPlaneFS_default = "varying vec4 positionEC;\n\nvoid main()\n{\n    vec3 position;\n    vec3 direction;\n    if (czm_orthographicIn3D == 1.0)\n    {\n        vec2 uv = (gl_FragCoord.xy -  czm_viewport.xy) / czm_viewport.zw;\n        vec2 minPlane = vec2(czm_frustumPlanes.z, czm_frustumPlanes.y); // left, bottom\n        vec2 maxPlane = vec2(czm_frustumPlanes.w, czm_frustumPlanes.x); // right, top\n        position = vec3(mix(minPlane, maxPlane, uv), 0.0);\n        direction = vec3(0.0, 0.0, -1.0);\n    } \n    else \n    {\n        position = vec3(0.0);\n        direction = normalize(positionEC.xyz);\n    }\n\n    czm_ray ray = czm_ray(position, direction);\n\n    vec3 ellipsoid_center = czm_view[3].xyz;\n\n    czm_raySegment intersection = czm_rayEllipsoidIntersectionInterval(ray, ellipsoid_center, czm_ellipsoidInverseRadii);\n    if (!czm_isEmpty(intersection))\n    {\n        gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0);\n    }\n    else\n    {\n        discard;\n    }\n\n    czm_writeLogDepth();\n}\n";

// node_modules/cesium/Source/Shaders/DepthPlaneVS.js
var DepthPlaneVS_default = "attribute vec4 position;\n\nvarying vec4 positionEC;\n\nvoid main()\n{\n    positionEC = czm_modelView * position;\n    gl_Position = czm_projection * positionEC;\n\n    czm_vertexLogDepth();\n}\n";

// node_modules/cesium/Source/Scene/DepthPlane.js
function DepthPlane(depthPlaneEllipsoidOffset) {
  this._rs = void 0;
  this._sp = void 0;
  this._va = void 0;
  this._command = void 0;
  this._mode = void 0;
  this._useLogDepth = false;
  this._ellipsoidOffset = defaultValue_default(depthPlaneEllipsoidOffset, 0);
}
var depthQuadScratch = FeatureDetection_default.supportsTypedArrays() ? new Float32Array(12) : [];
var scratchCartesian110 = new Cartesian3_default();
var scratchCartesian212 = new Cartesian3_default();
var scratchCartesian314 = new Cartesian3_default();
var scratchCartesian46 = new Cartesian3_default();
var scratchCartesian53 = new Cartesian3_default();
function computeDepthQuad(ellipsoid, frameState) {
  const radii = ellipsoid.radii;
  const camera = frameState.camera;
  let center, eastOffset, northOffset;
  if (camera.frustum instanceof OrthographicFrustum_default) {
    center = Cartesian3_default.ZERO;
    eastOffset = camera.rightWC;
    northOffset = camera.upWC;
  } else {
    const p2 = camera.positionWC;
    const q = Cartesian3_default.multiplyComponents(
      ellipsoid.oneOverRadii,
      p2,
      scratchCartesian110
    );
    const qUnit = Cartesian3_default.normalize(q, scratchCartesian212);
    const eUnit = Cartesian3_default.normalize(
      Cartesian3_default.cross(Cartesian3_default.UNIT_Z, q, scratchCartesian314),
      scratchCartesian314
    );
    const nUnit = Cartesian3_default.normalize(
      Cartesian3_default.cross(qUnit, eUnit, scratchCartesian46),
      scratchCartesian46
    );
    const qMagnitude = Cartesian3_default.magnitude(q);
    const wMagnitude = Math.sqrt(qMagnitude * qMagnitude - 1);
    center = Cartesian3_default.multiplyByScalar(
      qUnit,
      1 / qMagnitude,
      scratchCartesian110
    );
    const scalar = wMagnitude / qMagnitude;
    eastOffset = Cartesian3_default.multiplyByScalar(eUnit, scalar, scratchCartesian212);
    northOffset = Cartesian3_default.multiplyByScalar(nUnit, scalar, scratchCartesian314);
  }
  const upperLeft = Cartesian3_default.add(center, northOffset, scratchCartesian53);
  Cartesian3_default.subtract(upperLeft, eastOffset, upperLeft);
  Cartesian3_default.multiplyComponents(radii, upperLeft, upperLeft);
  Cartesian3_default.pack(upperLeft, depthQuadScratch, 0);
  const lowerLeft = Cartesian3_default.subtract(center, northOffset, scratchCartesian53);
  Cartesian3_default.subtract(lowerLeft, eastOffset, lowerLeft);
  Cartesian3_default.multiplyComponents(radii, lowerLeft, lowerLeft);
  Cartesian3_default.pack(lowerLeft, depthQuadScratch, 3);
  const upperRight = Cartesian3_default.add(center, northOffset, scratchCartesian53);
  Cartesian3_default.add(upperRight, eastOffset, upperRight);
  Cartesian3_default.multiplyComponents(radii, upperRight, upperRight);
  Cartesian3_default.pack(upperRight, depthQuadScratch, 6);
  const lowerRight = Cartesian3_default.subtract(
    center,
    northOffset,
    scratchCartesian53
  );
  Cartesian3_default.add(lowerRight, eastOffset, lowerRight);
  Cartesian3_default.multiplyComponents(radii, lowerRight, lowerRight);
  Cartesian3_default.pack(lowerRight, depthQuadScratch, 9);
  return depthQuadScratch;
}
DepthPlane.prototype.update = function(frameState) {
  this._mode = frameState.mode;
  if (frameState.mode !== SceneMode_default.SCENE3D) {
    return;
  }
  const context = frameState.context;
  const radii = frameState.mapProjection.ellipsoid.radii;
  const ellipsoid = new Ellipsoid_default(
    radii.x + this._ellipsoidOffset,
    radii.y + this._ellipsoidOffset,
    radii.z + this._ellipsoidOffset
  );
  const useLogDepth = frameState.useLogDepth;
  if (!defined_default(this._command)) {
    this._rs = RenderState_default.fromCache({
      cull: {
        enabled: true
      },
      depthTest: {
        enabled: true
      },
      colorMask: {
        red: false,
        green: false,
        blue: false,
        alpha: false
      }
    });
    this._command = new DrawCommand_default({
      renderState: this._rs,
      boundingVolume: new BoundingSphere_default(
        Cartesian3_default.ZERO,
        ellipsoid.maximumRadius
      ),
      pass: Pass_default.OPAQUE,
      owner: this
    });
  }
  if (!defined_default(this._sp) || this._useLogDepth !== useLogDepth) {
    this._useLogDepth = useLogDepth;
    const vs = new ShaderSource_default({
      sources: [DepthPlaneVS_default]
    });
    const fs = new ShaderSource_default({
      sources: [DepthPlaneFS_default]
    });
    if (useLogDepth) {
      const extension = "#ifdef GL_EXT_frag_depth \n#extension GL_EXT_frag_depth : enable \n#endif \n\n";
      fs.sources.push(extension);
      fs.defines.push("LOG_DEPTH");
      vs.defines.push("LOG_DEPTH");
    }
    this._sp = ShaderProgram_default.replaceCache({
      shaderProgram: this._sp,
      context,
      vertexShaderSource: vs,
      fragmentShaderSource: fs,
      attributeLocations: {
        position: 0
      }
    });
    this._command.shaderProgram = this._sp;
  }
  const depthQuad = computeDepthQuad(ellipsoid, frameState);
  if (!defined_default(this._va)) {
    const geometry = new Geometry_default({
      attributes: {
        position: new GeometryAttribute_default({
          componentDatatype: ComponentDatatype_default.FLOAT,
          componentsPerAttribute: 3,
          values: depthQuad
        })
      },
      indices: [0, 1, 2, 2, 1, 3],
      primitiveType: PrimitiveType_default.TRIANGLES
    });
    this._va = VertexArray_default.fromGeometry({
      context,
      geometry,
      attributeLocations: {
        position: 0
      },
      bufferUsage: BufferUsage_default.DYNAMIC_DRAW
    });
    this._command.vertexArray = this._va;
  } else {
    this._va.getAttribute(0).vertexBuffer.copyFromArrayView(depthQuad);
  }
};
DepthPlane.prototype.execute = function(context, passState) {
  if (this._mode === SceneMode_default.SCENE3D) {
    this._command.execute(context, passState);
  }
};
DepthPlane.prototype.isDestroyed = function() {
  return false;
};
DepthPlane.prototype.destroy = function() {
  this._sp = this._sp && this._sp.destroy();
  this._va = this._va && this._va.destroy();
};
var DepthPlane_default = DepthPlane;

// node_modules/cesium/Source/Scene/DerivedCommand.js
function DerivedCommand() {
}
var fragDepthRegex = /\bgl_FragDepthEXT\b/;
var discardRegex = /\bdiscard\b/;
function getDepthOnlyShaderProgram(context, shaderProgram) {
  let shader = context.shaderCache.getDerivedShaderProgram(
    shaderProgram,
    "depthOnly"
  );
  if (!defined_default(shader)) {
    const attributeLocations8 = shaderProgram._attributeLocations;
    let fs = shaderProgram.fragmentShaderSource;
    let i2;
    let writesDepthOrDiscards = false;
    const sources = fs.sources;
    let length3 = sources.length;
    for (i2 = 0; i2 < length3; ++i2) {
      if (fragDepthRegex.test(sources[i2]) || discardRegex.test(sources[i2])) {
        writesDepthOrDiscards = true;
        break;
      }
    }
    let usesLogDepth = false;
    const defines = fs.defines;
    length3 = defines.length;
    for (i2 = 0; i2 < length3; ++i2) {
      if (defines[i2] === "LOG_DEPTH") {
        usesLogDepth = true;
        break;
      }
    }
    let source;
    if (!writesDepthOrDiscards && !usesLogDepth) {
      source = "void main() \n{ \n    gl_FragColor = vec4(1.0); \n} \n";
      fs = new ShaderSource_default({
        sources: [source]
      });
    } else if (!writesDepthOrDiscards && usesLogDepth) {
      source = "#ifdef GL_EXT_frag_depth \n#extension GL_EXT_frag_depth : enable \n#endif \n\nvoid main() \n{ \n    gl_FragColor = vec4(1.0); \n    czm_writeLogDepth(); \n} \n";
      fs = new ShaderSource_default({
        defines: ["LOG_DEPTH"],
        sources: [source]
      });
    }
    shader = context.shaderCache.createDerivedShaderProgram(
      shaderProgram,
      "depthOnly",
      {
        vertexShaderSource: shaderProgram.vertexShaderSource,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations8
      }
    );
  }
  return shader;
}
function getDepthOnlyRenderState(scene, renderState) {
  const cache = scene._depthOnlyRenderStateCache;
  let depthOnlyState = cache[renderState.id];
  if (!defined_default(depthOnlyState)) {
    const rs = RenderState_default.getState(renderState);
    rs.depthMask = true;
    rs.colorMask = {
      red: false,
      green: false,
      blue: false,
      alpha: false
    };
    depthOnlyState = RenderState_default.fromCache(rs);
    cache[renderState.id] = depthOnlyState;
  }
  return depthOnlyState;
}
DerivedCommand.createDepthOnlyDerivedCommand = function(scene, command, context, result) {
  if (!defined_default(result)) {
    result = {};
  }
  let shader;
  let renderState;
  if (defined_default(result.depthOnlyCommand)) {
    shader = result.depthOnlyCommand.shaderProgram;
    renderState = result.depthOnlyCommand.renderState;
  }
  result.depthOnlyCommand = DrawCommand_default.shallowClone(
    command,
    result.depthOnlyCommand
  );
  if (!defined_default(shader) || result.shaderProgramId !== command.shaderProgram.id) {
    result.depthOnlyCommand.shaderProgram = getDepthOnlyShaderProgram(
      context,
      command.shaderProgram
    );
    result.depthOnlyCommand.renderState = getDepthOnlyRenderState(
      scene,
      command.renderState
    );
    result.shaderProgramId = command.shaderProgram.id;
  } else {
    result.depthOnlyCommand.shaderProgram = shader;
    result.depthOnlyCommand.renderState = renderState;
  }
  return result;
};
var writeLogDepthRegex = /\s+czm_writeLogDepth\(/;
var vertexlogDepthRegex = /\s+czm_vertexLogDepth\(/;
var extensionRegex = /\s*#extension\s+GL_EXT_frag_depth\s*:\s*enable/;
function getLogDepthShaderProgram(context, shaderProgram) {
  let shader = context.shaderCache.getDerivedShaderProgram(
    shaderProgram,
    "logDepth"
  );
  if (!defined_default(shader)) {
    const attributeLocations8 = shaderProgram._attributeLocations;
    const vs = shaderProgram.vertexShaderSource.clone();
    const fs = shaderProgram.fragmentShaderSource.clone();
    vs.defines = defined_default(vs.defines) ? vs.defines.slice(0) : [];
    vs.defines.push("LOG_DEPTH");
    fs.defines = defined_default(fs.defines) ? fs.defines.slice(0) : [];
    fs.defines.push("LOG_DEPTH");
    let i2;
    let logMain;
    let writesLogDepth = false;
    let sources = vs.sources;
    let length3 = sources.length;
    for (i2 = 0; i2 < length3; ++i2) {
      if (vertexlogDepthRegex.test(sources[i2])) {
        writesLogDepth = true;
        break;
      }
    }
    if (!writesLogDepth) {
      for (i2 = 0; i2 < length3; ++i2) {
        sources[i2] = ShaderSource_default.replaceMain(sources[i2], "czm_log_depth_main");
      }
      logMain = "\n\nvoid main() \n{ \n    czm_log_depth_main(); \n    czm_vertexLogDepth(); \n} \n";
      sources.push(logMain);
    }
    sources = fs.sources;
    length3 = sources.length;
    writesLogDepth = false;
    for (i2 = 0; i2 < length3; ++i2) {
      if (writeLogDepthRegex.test(sources[i2])) {
        writesLogDepth = true;
      }
    }
    if (fs.defines.indexOf("LOG_DEPTH_WRITE") !== -1) {
      writesLogDepth = true;
    }
    let addExtension = true;
    for (i2 = 0; i2 < length3; ++i2) {
      if (extensionRegex.test(sources[i2])) {
        addExtension = false;
      }
    }
    let logSource = "";
    if (addExtension) {
      logSource += "#ifdef GL_EXT_frag_depth \n#extension GL_EXT_frag_depth : enable \n#endif \n\n";
    }
    if (!writesLogDepth) {
      for (i2 = 0; i2 < length3; i2++) {
        sources[i2] = ShaderSource_default.replaceMain(sources[i2], "czm_log_depth_main");
      }
      logSource += "\nvoid main() \n{ \n    czm_log_depth_main(); \n    czm_writeLogDepth(); \n} \n";
    }
    sources.push(logSource);
    shader = context.shaderCache.createDerivedShaderProgram(
      shaderProgram,
      "logDepth",
      {
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations8
      }
    );
  }
  return shader;
}
DerivedCommand.createLogDepthCommand = function(command, context, result) {
  if (!defined_default(result)) {
    result = {};
  }
  let shader;
  if (defined_default(result.command)) {
    shader = result.command.shaderProgram;
  }
  result.command = DrawCommand_default.shallowClone(command, result.command);
  if (!defined_default(shader) || result.shaderProgramId !== command.shaderProgram.id) {
    result.command.shaderProgram = getLogDepthShaderProgram(
      context,
      command.shaderProgram
    );
    result.shaderProgramId = command.shaderProgram.id;
  } else {
    result.command.shaderProgram = shader;
  }
  return result;
};
function getPickShaderProgram(context, shaderProgram, pickId) {
  let shader = context.shaderCache.getDerivedShaderProgram(
    shaderProgram,
    "pick"
  );
  if (!defined_default(shader)) {
    const attributeLocations8 = shaderProgram._attributeLocations;
    let fs = shaderProgram.fragmentShaderSource;
    const sources = fs.sources;
    const length3 = sources.length;
    const newMain = `${"void main() \n{ \n    czm_non_pick_main(); \n    if (gl_FragColor.a == 0.0) { \n        discard; \n    } \n    gl_FragColor = "}${pickId}; 
} 
`;
    const newSources = new Array(length3 + 1);
    for (let i2 = 0; i2 < length3; ++i2) {
      newSources[i2] = ShaderSource_default.replaceMain(sources[i2], "czm_non_pick_main");
    }
    newSources[length3] = newMain;
    fs = new ShaderSource_default({
      sources: newSources,
      defines: fs.defines
    });
    shader = context.shaderCache.createDerivedShaderProgram(
      shaderProgram,
      "pick",
      {
        vertexShaderSource: shaderProgram.vertexShaderSource,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations8
      }
    );
  }
  return shader;
}
function getPickRenderState(scene, renderState) {
  const cache = scene.picking.pickRenderStateCache;
  let pickState = cache[renderState.id];
  if (!defined_default(pickState)) {
    const rs = RenderState_default.getState(renderState);
    rs.blending.enabled = false;
    rs.depthMask = true;
    pickState = RenderState_default.fromCache(rs);
    cache[renderState.id] = pickState;
  }
  return pickState;
}
DerivedCommand.createPickDerivedCommand = function(scene, command, context, result) {
  if (!defined_default(result)) {
    result = {};
  }
  let shader;
  let renderState;
  if (defined_default(result.pickCommand)) {
    shader = result.pickCommand.shaderProgram;
    renderState = result.pickCommand.renderState;
  }
  result.pickCommand = DrawCommand_default.shallowClone(command, result.pickCommand);
  if (!defined_default(shader) || result.shaderProgramId !== command.shaderProgram.id) {
    result.pickCommand.shaderProgram = getPickShaderProgram(
      context,
      command.shaderProgram,
      command.pickId
    );
    result.pickCommand.renderState = getPickRenderState(
      scene,
      command.renderState
    );
    result.shaderProgramId = command.shaderProgram.id;
  } else {
    result.pickCommand.shaderProgram = shader;
    result.pickCommand.renderState = renderState;
  }
  return result;
};
function getHdrShaderProgram(context, shaderProgram) {
  let shader = context.shaderCache.getDerivedShaderProgram(
    shaderProgram,
    "HDR"
  );
  if (!defined_default(shader)) {
    const attributeLocations8 = shaderProgram._attributeLocations;
    const vs = shaderProgram.vertexShaderSource.clone();
    const fs = shaderProgram.fragmentShaderSource.clone();
    vs.defines = defined_default(vs.defines) ? vs.defines.slice(0) : [];
    vs.defines.push("HDR");
    fs.defines = defined_default(fs.defines) ? fs.defines.slice(0) : [];
    fs.defines.push("HDR");
    shader = context.shaderCache.createDerivedShaderProgram(
      shaderProgram,
      "HDR",
      {
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations8
      }
    );
  }
  return shader;
}
DerivedCommand.createHdrCommand = function(command, context, result) {
  if (!defined_default(result)) {
    result = {};
  }
  let shader;
  if (defined_default(result.command)) {
    shader = result.command.shaderProgram;
  }
  result.command = DrawCommand_default.shallowClone(command, result.command);
  if (!defined_default(shader) || result.shaderProgramId !== command.shaderProgram.id) {
    result.command.shaderProgram = getHdrShaderProgram(
      context,
      command.shaderProgram
    );
    result.shaderProgramId = command.shaderProgram.id;
  } else {
    result.command.shaderProgram = shader;
  }
  return result;
};
var DerivedCommand_default = DerivedCommand;

// node_modules/cesium/Source/Scene/DeviceOrientationCameraController.js
function DeviceOrientationCameraController(scene) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  this._scene = scene;
  this._lastAlpha = void 0;
  this._lastBeta = void 0;
  this._lastGamma = void 0;
  this._alpha = void 0;
  this._beta = void 0;
  this._gamma = void 0;
  const that = this;
  function callback(e2) {
    const alpha = e2.alpha;
    if (!defined_default(alpha)) {
      that._alpha = void 0;
      that._beta = void 0;
      that._gamma = void 0;
      return;
    }
    that._alpha = Math_default.toRadians(alpha);
    that._beta = Math_default.toRadians(e2.beta);
    that._gamma = Math_default.toRadians(e2.gamma);
  }
  window.addEventListener("deviceorientation", callback, false);
  this._removeListener = function() {
    window.removeEventListener("deviceorientation", callback, false);
  };
}
var scratchQuaternion1 = new Quaternion_default();
var scratchQuaternion2 = new Quaternion_default();
var scratchMatrix32 = new Matrix3_default();
function rotate2(camera, alpha, beta, gamma) {
  const direction2 = camera.direction;
  const right = camera.right;
  const up = camera.up;
  const bQuat = Quaternion_default.fromAxisAngle(direction2, beta, scratchQuaternion2);
  const gQuat = Quaternion_default.fromAxisAngle(right, gamma, scratchQuaternion1);
  const rotQuat = Quaternion_default.multiply(gQuat, bQuat, gQuat);
  const aQuat = Quaternion_default.fromAxisAngle(up, alpha, scratchQuaternion2);
  Quaternion_default.multiply(aQuat, rotQuat, rotQuat);
  const matrix = Matrix3_default.fromQuaternion(rotQuat, scratchMatrix32);
  Matrix3_default.multiplyByVector(matrix, right, right);
  Matrix3_default.multiplyByVector(matrix, up, up);
  Matrix3_default.multiplyByVector(matrix, direction2, direction2);
}
DeviceOrientationCameraController.prototype.update = function() {
  if (!defined_default(this._alpha)) {
    return;
  }
  if (!defined_default(this._lastAlpha)) {
    this._lastAlpha = this._alpha;
    this._lastBeta = this._beta;
    this._lastGamma = this._gamma;
  }
  const a4 = this._lastAlpha - this._alpha;
  const b = this._lastBeta - this._beta;
  const g = this._lastGamma - this._gamma;
  rotate2(this._scene.camera, -a4, b, g);
  this._lastAlpha = this._alpha;
  this._lastBeta = this._beta;
  this._lastGamma = this._gamma;
};
DeviceOrientationCameraController.prototype.isDestroyed = function() {
  return false;
};
DeviceOrientationCameraController.prototype.destroy = function() {
  this._removeListener();
  return destroyObject_default(this);
};
var DeviceOrientationCameraController_default = DeviceOrientationCameraController;

// node_modules/cesium/Source/Scene/DirectionalLight.js
function DirectionalLight(options) {
  Check_default.typeOf.object("options", options);
  Check_default.typeOf.object("options.direction", options.direction);
  if (Cartesian3_default.equals(options.direction, Cartesian3_default.ZERO)) {
    throw new DeveloperError_default("options.direction cannot be zero-length");
  }
  this.direction = Cartesian3_default.clone(options.direction);
  this.color = Color_default.clone(defaultValue_default(options.color, Color_default.WHITE));
  this.intensity = defaultValue_default(options.intensity, 1);
}
var DirectionalLight_default = DirectionalLight;

// node_modules/cesium/Source/Shaders/EllipsoidFS.js
var EllipsoidFS_default = "#ifdef WRITE_DEPTH\n#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n#endif\n#endif\n\nuniform vec3 u_radii;\nuniform vec3 u_oneOverEllipsoidRadiiSquared;\n\nvarying vec3 v_positionEC;\n\nvec4 computeEllipsoidColor(czm_ray ray, float intersection, float side)\n{\n    vec3 positionEC = czm_pointAlongRay(ray, intersection);\n    vec3 positionMC = (czm_inverseModelView * vec4(positionEC, 1.0)).xyz;\n    vec3 geodeticNormal = normalize(czm_geodeticSurfaceNormal(positionMC, vec3(0.0), u_oneOverEllipsoidRadiiSquared));\n    vec3 sphericalNormal = normalize(positionMC / u_radii);\n    vec3 normalMC = geodeticNormal * side;              // normalized surface normal (always facing the viewer) in model coordinates\n    vec3 normalEC = normalize(czm_normal * normalMC);   // normalized surface normal in eye coordiantes\n\n    vec2 st = czm_ellipsoidWgs84TextureCoordinates(sphericalNormal);\n    vec3 positionToEyeEC = -positionEC;\n\n    czm_materialInput materialInput;\n    materialInput.s = st.s;\n    materialInput.st = st;\n    materialInput.str = (positionMC + u_radii) / u_radii;\n    materialInput.normalEC = normalEC;\n    materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(positionMC, normalEC);\n    materialInput.positionToEyeEC = positionToEyeEC;\n    czm_material material = czm_getMaterial(materialInput);\n\n#ifdef ONLY_SUN_LIGHTING\n    return czm_private_phong(normalize(positionToEyeEC), material, czm_sunDirectionEC);\n#else\n    return czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n#endif\n}\n\nvoid main()\n{\n    // PERFORMANCE_TODO: When dynamic branching is available, compute ratio of maximum and minimum radii\n    // in the vertex shader. Only when it is larger than some constant, march along the ray.\n    // Otherwise perform one intersection test which will be the common case.\n\n    // Test if the ray intersects a sphere with the ellipsoid's maximum radius.\n    // For very oblate ellipsoids, using the ellipsoid's radii for an intersection test\n    // may cause false negatives. This will discard fragments before marching the ray forward.\n    float maxRadius = max(u_radii.x, max(u_radii.y, u_radii.z)) * 1.5;\n    vec3 direction = normalize(v_positionEC);\n    vec3 ellipsoidCenter = czm_modelView[3].xyz;\n\n    float t1 = -1.0;\n    float t2 = -1.0;\n\n    float b = -2.0 * dot(direction, ellipsoidCenter);\n    float c = dot(ellipsoidCenter, ellipsoidCenter) - maxRadius * maxRadius;\n\n    float discriminant = b * b - 4.0 * c;\n    if (discriminant >= 0.0) {\n        t1 = (-b - sqrt(discriminant)) * 0.5;\n        t2 = (-b + sqrt(discriminant)) * 0.5;\n    }\n\n    if (t1 < 0.0 && t2 < 0.0) {\n        discard;\n    }\n\n    float t = min(t1, t2);\n    if (t < 0.0) {\n        t = 0.0;\n    }\n\n    // March ray forward to intersection with larger sphere and find\n    czm_ray ray = czm_ray(t * direction, direction);\n\n    vec3 ellipsoid_inverseRadii = vec3(1.0 / u_radii.x, 1.0 / u_radii.y, 1.0 / u_radii.z);\n\n    czm_raySegment intersection = czm_rayEllipsoidIntersectionInterval(ray, ellipsoidCenter, ellipsoid_inverseRadii);\n\n    if (czm_isEmpty(intersection))\n    {\n        discard;\n    }\n\n    // If the viewer is outside, compute outsideFaceColor, with normals facing outward.\n    vec4 outsideFaceColor = (intersection.start != 0.0) ? computeEllipsoidColor(ray, intersection.start, 1.0) : vec4(0.0);\n\n    // If the viewer either is inside or can see inside, compute insideFaceColor, with normals facing inward.\n    vec4 insideFaceColor = (outsideFaceColor.a < 1.0) ? computeEllipsoidColor(ray, intersection.stop, -1.0) : vec4(0.0);\n\n    gl_FragColor = mix(insideFaceColor, outsideFaceColor, outsideFaceColor.a);\n    gl_FragColor.a = 1.0 - (1.0 - insideFaceColor.a) * (1.0 - outsideFaceColor.a);\n\n#ifdef WRITE_DEPTH\n#ifdef GL_EXT_frag_depth\n    t = (intersection.start != 0.0) ? intersection.start : intersection.stop;\n    vec3 positionEC = czm_pointAlongRay(ray, t);\n    vec4 positionCC = czm_projection * vec4(positionEC, 1.0);\n#ifdef LOG_DEPTH\n    czm_writeLogDepth(1.0 + positionCC.w);\n#else\n    float z = positionCC.z / positionCC.w;\n\n    float n = czm_depthRange.near;\n    float f = czm_depthRange.far;\n\n    gl_FragDepthEXT = (z * (f - n) + f + n) * 0.5;\n#endif\n#endif\n#endif\n}\n";

// node_modules/cesium/Source/Shaders/EllipsoidVS.js
var EllipsoidVS_default = "attribute vec3 position;\n\nuniform vec3 u_radii;\n\nvarying vec3 v_positionEC;\n\nvoid main()\n{\n    // In the vertex data, the cube goes from (-1.0, -1.0, -1.0) to (1.0, 1.0, 1.0) in model coordinates.\n    // Scale to consider the radii.  We could also do this once on the CPU when using the BoxGeometry,\n    // but doing it here allows us to change the radii without rewriting the vertex data, and\n    // allows all ellipsoids to reuse the same vertex data.\n    vec4 p = vec4(u_radii * position, 1.0);\n\n    v_positionEC = (czm_modelView * p).xyz;     // position in eye coordinates\n    gl_Position = czm_modelViewProjection * p;  // position in clip coordinates\n\n    // With multi-frustum, when the ellipsoid primitive is positioned on the intersection of two frustums\n    // and close to terrain, the terrain (writes depth) in the closest frustum can overwrite part of the\n    // ellipsoid (does not write depth) that was rendered in the farther frustum.\n    //\n    // Here, we clamp the depth in the vertex shader to avoid being overwritten; however, this creates\n    // artifacts since some fragments can be alpha blended twice.  This is solved by only rendering\n    // the ellipsoid in the closest frustum to the viewer.\n    gl_Position.z = clamp(gl_Position.z, czm_depthRange.near, czm_depthRange.far);\n\n    czm_vertexLogDepth();\n}\n";

// node_modules/cesium/Source/Scene/EllipsoidPrimitive.js
var attributeLocations7 = {
  position: 0
};
function EllipsoidPrimitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.center = Cartesian3_default.clone(defaultValue_default(options.center, Cartesian3_default.ZERO));
  this._center = new Cartesian3_default();
  this.radii = Cartesian3_default.clone(options.radii);
  this._radii = new Cartesian3_default();
  this._oneOverEllipsoidRadiiSquared = new Cartesian3_default();
  this._boundingSphere = new BoundingSphere_default();
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._modelMatrix = new Matrix4_default();
  this._computedModelMatrix = new Matrix4_default();
  this.show = defaultValue_default(options.show, true);
  this.material = defaultValue_default(
    options.material,
    Material_default.fromType(Material_default.ColorType)
  );
  this._material = void 0;
  this._translucent = void 0;
  this.id = options.id;
  this._id = void 0;
  this.debugShowBoundingVolume = defaultValue_default(
    options.debugShowBoundingVolume,
    false
  );
  this.onlySunLighting = defaultValue_default(options.onlySunLighting, false);
  this._onlySunLighting = false;
  this._depthTestEnabled = defaultValue_default(options.depthTestEnabled, true);
  this._useLogDepth = false;
  this._sp = void 0;
  this._rs = void 0;
  this._va = void 0;
  this._pickSP = void 0;
  this._pickId = void 0;
  this._colorCommand = new DrawCommand_default({
    owner: defaultValue_default(options._owner, this)
  });
  this._pickCommand = new DrawCommand_default({
    owner: defaultValue_default(options._owner, this),
    pickOnly: true
  });
  const that = this;
  this._uniforms = {
    u_radii: function() {
      return that.radii;
    },
    u_oneOverEllipsoidRadiiSquared: function() {
      return that._oneOverEllipsoidRadiiSquared;
    }
  };
  this._pickUniforms = {
    czm_pickColor: function() {
      return that._pickId.color;
    }
  };
}
function getVertexArray(context) {
  let vertexArray = context.cache.ellipsoidPrimitive_vertexArray;
  if (defined_default(vertexArray)) {
    return vertexArray;
  }
  const geometry = BoxGeometry_default.createGeometry(
    BoxGeometry_default.fromDimensions({
      dimensions: new Cartesian3_default(2, 2, 2),
      vertexFormat: VertexFormat_default.POSITION_ONLY
    })
  );
  vertexArray = VertexArray_default.fromGeometry({
    context,
    geometry,
    attributeLocations: attributeLocations7,
    bufferUsage: BufferUsage_default.STATIC_DRAW,
    interleave: true
  });
  context.cache.ellipsoidPrimitive_vertexArray = vertexArray;
  return vertexArray;
}
var logDepthExtension = "#ifdef GL_EXT_frag_depth \n#extension GL_EXT_frag_depth : enable \n#endif \n\n";
EllipsoidPrimitive.prototype.update = function(frameState) {
  if (!this.show || frameState.mode !== SceneMode_default.SCENE3D || !defined_default(this.center) || !defined_default(this.radii)) {
    return;
  }
  if (!defined_default(this.material)) {
    throw new DeveloperError_default("this.material must be defined.");
  }
  const context = frameState.context;
  const translucent = this.material.isTranslucent();
  const translucencyChanged = this._translucent !== translucent;
  if (!defined_default(this._rs) || translucencyChanged) {
    this._translucent = translucent;
    this._rs = RenderState_default.fromCache({
      cull: {
        enabled: true,
        face: CullFace_default.FRONT
      },
      depthTest: {
        enabled: this._depthTestEnabled
      },
      depthMask: !translucent && context.fragmentDepth,
      blending: translucent ? BlendingState_default.ALPHA_BLEND : void 0
    });
  }
  if (!defined_default(this._va)) {
    this._va = getVertexArray(context);
  }
  let boundingSphereDirty = false;
  const radii = this.radii;
  if (!Cartesian3_default.equals(this._radii, radii)) {
    Cartesian3_default.clone(radii, this._radii);
    const r2 = this._oneOverEllipsoidRadiiSquared;
    r2.x = 1 / (radii.x * radii.x);
    r2.y = 1 / (radii.y * radii.y);
    r2.z = 1 / (radii.z * radii.z);
    boundingSphereDirty = true;
  }
  if (!Matrix4_default.equals(this.modelMatrix, this._modelMatrix) || !Cartesian3_default.equals(this.center, this._center)) {
    Matrix4_default.clone(this.modelMatrix, this._modelMatrix);
    Cartesian3_default.clone(this.center, this._center);
    Matrix4_default.multiplyByTranslation(
      this.modelMatrix,
      this.center,
      this._computedModelMatrix
    );
    boundingSphereDirty = true;
  }
  if (boundingSphereDirty) {
    Cartesian3_default.clone(Cartesian3_default.ZERO, this._boundingSphere.center);
    this._boundingSphere.radius = Cartesian3_default.maximumComponent(radii);
    BoundingSphere_default.transform(
      this._boundingSphere,
      this._computedModelMatrix,
      this._boundingSphere
    );
  }
  const materialChanged = this._material !== this.material;
  this._material = this.material;
  this._material.update(context);
  const lightingChanged = this.onlySunLighting !== this._onlySunLighting;
  this._onlySunLighting = this.onlySunLighting;
  const useLogDepth = frameState.useLogDepth;
  const useLogDepthChanged = this._useLogDepth !== useLogDepth;
  this._useLogDepth = useLogDepth;
  const colorCommand = this._colorCommand;
  let vs;
  let fs;
  if (materialChanged || lightingChanged || translucencyChanged || useLogDepthChanged) {
    vs = new ShaderSource_default({
      sources: [EllipsoidVS_default]
    });
    fs = new ShaderSource_default({
      sources: [this.material.shaderSource, EllipsoidFS_default]
    });
    if (this.onlySunLighting) {
      fs.defines.push("ONLY_SUN_LIGHTING");
    }
    if (!translucent && context.fragmentDepth) {
      fs.defines.push("WRITE_DEPTH");
    }
    if (this._useLogDepth) {
      vs.defines.push("LOG_DEPTH");
      fs.defines.push("LOG_DEPTH");
      fs.sources.push(logDepthExtension);
    }
    this._sp = ShaderProgram_default.replaceCache({
      context,
      shaderProgram: this._sp,
      vertexShaderSource: vs,
      fragmentShaderSource: fs,
      attributeLocations: attributeLocations7
    });
    colorCommand.vertexArray = this._va;
    colorCommand.renderState = this._rs;
    colorCommand.shaderProgram = this._sp;
    colorCommand.uniformMap = combine_default(this._uniforms, this.material._uniforms);
    colorCommand.executeInClosestFrustum = translucent;
  }
  const commandList = frameState.commandList;
  const passes = frameState.passes;
  if (passes.render) {
    colorCommand.boundingVolume = this._boundingSphere;
    colorCommand.debugShowBoundingVolume = this.debugShowBoundingVolume;
    colorCommand.modelMatrix = this._computedModelMatrix;
    colorCommand.pass = translucent ? Pass_default.TRANSLUCENT : Pass_default.OPAQUE;
    commandList.push(colorCommand);
  }
  if (passes.pick) {
    const pickCommand = this._pickCommand;
    if (!defined_default(this._pickId) || this._id !== this.id) {
      this._id = this.id;
      this._pickId = this._pickId && this._pickId.destroy();
      this._pickId = context.createPickId({
        primitive: this,
        id: this.id
      });
    }
    if (materialChanged || lightingChanged || !defined_default(this._pickSP) || useLogDepthChanged) {
      vs = new ShaderSource_default({
        sources: [EllipsoidVS_default]
      });
      fs = new ShaderSource_default({
        sources: [this.material.shaderSource, EllipsoidFS_default],
        pickColorQualifier: "uniform"
      });
      if (this.onlySunLighting) {
        fs.defines.push("ONLY_SUN_LIGHTING");
      }
      if (!translucent && context.fragmentDepth) {
        fs.defines.push("WRITE_DEPTH");
      }
      if (this._useLogDepth) {
        vs.defines.push("LOG_DEPTH");
        fs.defines.push("LOG_DEPTH");
        fs.sources.push(logDepthExtension);
      }
      this._pickSP = ShaderProgram_default.replaceCache({
        context,
        shaderProgram: this._pickSP,
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations7
      });
      pickCommand.vertexArray = this._va;
      pickCommand.renderState = this._rs;
      pickCommand.shaderProgram = this._pickSP;
      pickCommand.uniformMap = combine_default(
        combine_default(this._uniforms, this._pickUniforms),
        this.material._uniforms
      );
      pickCommand.executeInClosestFrustum = translucent;
    }
    pickCommand.boundingVolume = this._boundingSphere;
    pickCommand.modelMatrix = this._computedModelMatrix;
    pickCommand.pass = translucent ? Pass_default.TRANSLUCENT : Pass_default.OPAQUE;
    commandList.push(pickCommand);
  }
};
EllipsoidPrimitive.prototype.isDestroyed = function() {
  return false;
};
EllipsoidPrimitive.prototype.destroy = function() {
  this._sp = this._sp && this._sp.destroy();
  this._pickSP = this._pickSP && this._pickSP.destroy();
  this._pickId = this._pickId && this._pickId.destroy();
  return destroyObject_default(this);
};
var EllipsoidPrimitive_default = EllipsoidPrimitive;

// node_modules/cesium/Source/Shaders/Appearances/EllipsoidSurfaceAppearanceFS.js
var EllipsoidSurfaceAppearanceFS_default = "varying vec3 v_positionMC;\nvarying vec3 v_positionEC;\nvarying vec2 v_st;\n\nvoid main()\n{\n    czm_materialInput materialInput;\n\n    vec3 normalEC = normalize(czm_normal3D * czm_geodeticSurfaceNormal(v_positionMC, vec3(0.0), vec3(1.0)));\n#ifdef FACE_FORWARD\n    normalEC = faceforward(normalEC, vec3(0.0, 0.0, 1.0), -normalEC);\n#endif\n\n    materialInput.s = v_st.s;\n    materialInput.st = v_st;\n    materialInput.str = vec3(v_st, 0.0);\n\n    // Convert tangent space material normal to eye space\n    materialInput.normalEC = normalEC;\n    materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(v_positionMC, materialInput.normalEC);\n\n    // Convert view vector to world space\n    vec3 positionToEyeEC = -v_positionEC;\n    materialInput.positionToEyeEC = positionToEyeEC;\n\n    czm_material material = czm_getMaterial(materialInput);\n\n#ifdef FLAT\n    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n#else\n    gl_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n#endif\n}\n";

// node_modules/cesium/Source/Shaders/Appearances/EllipsoidSurfaceAppearanceVS.js
var EllipsoidSurfaceAppearanceVS_default = "attribute vec3 position3DHigh;\nattribute vec3 position3DLow;\nattribute vec2 st;\nattribute float batchId;\n\nvarying vec3 v_positionMC;\nvarying vec3 v_positionEC;\nvarying vec2 v_st;\n\nvoid main()\n{\n    vec4 p = czm_computePosition();\n\n    v_positionMC = position3DHigh + position3DLow;           // position in model coordinates\n    v_positionEC = (czm_modelViewRelativeToEye * p).xyz;     // position in eye coordinates\n    v_st = st;\n\n    gl_Position = czm_modelViewProjectionRelativeToEye * p;\n}\n";

// node_modules/cesium/Source/Scene/EllipsoidSurfaceAppearance.js
function EllipsoidSurfaceAppearance(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const translucent = defaultValue_default(options.translucent, true);
  const aboveGround = defaultValue_default(options.aboveGround, false);
  this.material = defined_default(options.material) ? options.material : Material_default.fromType(Material_default.ColorType);
  this.translucent = defaultValue_default(options.translucent, true);
  this._vertexShaderSource = defaultValue_default(
    options.vertexShaderSource,
    EllipsoidSurfaceAppearanceVS_default
  );
  this._fragmentShaderSource = defaultValue_default(
    options.fragmentShaderSource,
    EllipsoidSurfaceAppearanceFS_default
  );
  this._renderState = Appearance_default.getDefaultRenderState(
    translucent,
    !aboveGround,
    options.renderState
  );
  this._closed = false;
  this._flat = defaultValue_default(options.flat, false);
  this._faceForward = defaultValue_default(options.faceForward, aboveGround);
  this._aboveGround = aboveGround;
}
Object.defineProperties(EllipsoidSurfaceAppearance.prototype, {
  vertexShaderSource: {
    get: function() {
      return this._vertexShaderSource;
    }
  },
  fragmentShaderSource: {
    get: function() {
      return this._fragmentShaderSource;
    }
  },
  renderState: {
    get: function() {
      return this._renderState;
    }
  },
  closed: {
    get: function() {
      return this._closed;
    }
  },
  vertexFormat: {
    get: function() {
      return EllipsoidSurfaceAppearance.VERTEX_FORMAT;
    }
  },
  flat: {
    get: function() {
      return this._flat;
    }
  },
  faceForward: {
    get: function() {
      return this._faceForward;
    }
  },
  aboveGround: {
    get: function() {
      return this._aboveGround;
    }
  }
});
EllipsoidSurfaceAppearance.VERTEX_FORMAT = VertexFormat_default.POSITION_AND_ST;
EllipsoidSurfaceAppearance.prototype.getFragmentShaderSource = Appearance_default.prototype.getFragmentShaderSource;
EllipsoidSurfaceAppearance.prototype.isTranslucent = Appearance_default.prototype.isTranslucent;
EllipsoidSurfaceAppearance.prototype.getRenderState = Appearance_default.prototype.getRenderState;
var EllipsoidSurfaceAppearance_default = EllipsoidSurfaceAppearance;

// node_modules/cesium/Source/Scene/Fog.js
function Fog() {
  this.enabled = true;
  this.renderable = true;
  this.density = 2e-4;
  this.screenSpaceErrorFactor = 2;
  this.minimumBrightness = 0.03;
}
var heightsTable = [
  359.393,
  800.749,
  1275.6501,
  2151.1192,
  3141.7763,
  4777.5198,
  6281.2493,
  12364.307,
  15900.765,
  49889.0549,
  78026.8259,
  99260.7344,
  120036.3873,
  151011.0158,
  156091.1953,
  203849.3112,
  274866.9803,
  319916.3149,
  493552.0528,
  628733.5874
];
var densityTable = [
  2e-5,
  2e-4,
  1e-4,
  7e-5,
  5e-5,
  4e-5,
  3e-5,
  19e-6,
  1e-5,
  85e-7,
  62e-7,
  58e-7,
  53e-7,
  52e-7,
  51e-7,
  42e-7,
  4e-6,
  34e-7,
  26e-7,
  22e-7
];
for (let i2 = 0; i2 < densityTable.length; ++i2) {
  densityTable[i2] *= 1e6;
}
var tableStartDensity = densityTable[1];
var tableEndDensity = densityTable[densityTable.length - 1];
for (let j = 0; j < densityTable.length; ++j) {
  densityTable[j] = (densityTable[j] - tableEndDensity) / (tableStartDensity - tableEndDensity);
}
var tableLastIndex = 0;
function findInterval(height) {
  const heights = heightsTable;
  const length3 = heights.length;
  if (height < heights[0]) {
    tableLastIndex = 0;
    return tableLastIndex;
  } else if (height > heights[length3 - 1]) {
    tableLastIndex = length3 - 2;
    return tableLastIndex;
  }
  if (height >= heights[tableLastIndex]) {
    if (tableLastIndex + 1 < length3 && height < heights[tableLastIndex + 1]) {
      return tableLastIndex;
    } else if (tableLastIndex + 2 < length3 && height < heights[tableLastIndex + 2]) {
      ++tableLastIndex;
      return tableLastIndex;
    }
  } else if (tableLastIndex - 1 >= 0 && height >= heights[tableLastIndex - 1]) {
    --tableLastIndex;
    return tableLastIndex;
  }
  let i2;
  for (i2 = 0; i2 < length3 - 2; ++i2) {
    if (height >= heights[i2] && height < heights[i2 + 1]) {
      break;
    }
  }
  tableLastIndex = i2;
  return tableLastIndex;
}
var scratchPositionNormal2 = new Cartesian3_default();
Fog.prototype.update = function(frameState) {
  const enabled = frameState.fog.enabled = this.enabled;
  if (!enabled) {
    return;
  }
  frameState.fog.renderable = this.renderable;
  const camera = frameState.camera;
  const positionCartographic = camera.positionCartographic;
  if (!defined_default(positionCartographic) || positionCartographic.height > 8e5 || frameState.mode !== SceneMode_default.SCENE3D) {
    frameState.fog.enabled = false;
    return;
  }
  const height = positionCartographic.height;
  const i2 = findInterval(height);
  const t = Math_default.clamp(
    (height - heightsTable[i2]) / (heightsTable[i2 + 1] - heightsTable[i2]),
    0,
    1
  );
  let density = Math_default.lerp(densityTable[i2], densityTable[i2 + 1], t);
  const startDensity = this.density * 1e6;
  const endDensity = startDensity / tableStartDensity * tableEndDensity;
  density = density * (startDensity - endDensity) * 1e-6;
  const positionNormal = Cartesian3_default.normalize(
    camera.positionWC,
    scratchPositionNormal2
  );
  const dot2 = Math.abs(Cartesian3_default.dot(camera.directionWC, positionNormal));
  density *= 1 - dot2;
  frameState.fog.density = density;
  frameState.fog.sse = this.screenSpaceErrorFactor;
  frameState.fog.minimumBrightness = this.minimumBrightness;
};
var Fog_default = Fog;

// node_modules/cesium/Source/Scene/FrameRateMonitor.js
function FrameRateMonitor(options) {
  if (!defined_default(options) || !defined_default(options.scene)) {
    throw new DeveloperError_default("options.scene is required.");
  }
  this._scene = options.scene;
  this.samplingWindow = defaultValue_default(
    options.samplingWindow,
    FrameRateMonitor.defaultSettings.samplingWindow
  );
  this.quietPeriod = defaultValue_default(
    options.quietPeriod,
    FrameRateMonitor.defaultSettings.quietPeriod
  );
  this.warmupPeriod = defaultValue_default(
    options.warmupPeriod,
    FrameRateMonitor.defaultSettings.warmupPeriod
  );
  this.minimumFrameRateDuringWarmup = defaultValue_default(
    options.minimumFrameRateDuringWarmup,
    FrameRateMonitor.defaultSettings.minimumFrameRateDuringWarmup
  );
  this.minimumFrameRateAfterWarmup = defaultValue_default(
    options.minimumFrameRateAfterWarmup,
    FrameRateMonitor.defaultSettings.minimumFrameRateAfterWarmup
  );
  this._lowFrameRate = new Event_default();
  this._nominalFrameRate = new Event_default();
  this._frameTimes = [];
  this._needsQuietPeriod = true;
  this._quietPeriodEndTime = 0;
  this._warmupPeriodEndTime = 0;
  this._frameRateIsLow = false;
  this._lastFramesPerSecond = void 0;
  this._pauseCount = 0;
  const that = this;
  this._preUpdateRemoveListener = this._scene.preUpdate.addEventListener(
    function(scene, time) {
      update6(that, time);
    }
  );
  this._hiddenPropertyName = document.hidden !== void 0 ? "hidden" : document.mozHidden !== void 0 ? "mozHidden" : document.msHidden !== void 0 ? "msHidden" : document.webkitHidden !== void 0 ? "webkitHidden" : void 0;
  const visibilityChangeEventName = document.hidden !== void 0 ? "visibilitychange" : document.mozHidden !== void 0 ? "mozvisibilitychange" : document.msHidden !== void 0 ? "msvisibilitychange" : document.webkitHidden !== void 0 ? "webkitvisibilitychange" : void 0;
  function visibilityChangeListener() {
    visibilityChanged(that);
  }
  this._visibilityChangeRemoveListener = void 0;
  if (defined_default(visibilityChangeEventName)) {
    document.addEventListener(
      visibilityChangeEventName,
      visibilityChangeListener,
      false
    );
    this._visibilityChangeRemoveListener = function() {
      document.removeEventListener(
        visibilityChangeEventName,
        visibilityChangeListener,
        false
      );
    };
  }
}
FrameRateMonitor.defaultSettings = {
  samplingWindow: 5,
  quietPeriod: 2,
  warmupPeriod: 5,
  minimumFrameRateDuringWarmup: 4,
  minimumFrameRateAfterWarmup: 8
};
FrameRateMonitor.fromScene = function(scene) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  if (!defined_default(scene._frameRateMonitor) || scene._frameRateMonitor.isDestroyed()) {
    scene._frameRateMonitor = new FrameRateMonitor({
      scene
    });
  }
  return scene._frameRateMonitor;
};
Object.defineProperties(FrameRateMonitor.prototype, {
  scene: {
    get: function() {
      return this._scene;
    }
  },
  lowFrameRate: {
    get: function() {
      return this._lowFrameRate;
    }
  },
  nominalFrameRate: {
    get: function() {
      return this._nominalFrameRate;
    }
  },
  lastFramesPerSecond: {
    get: function() {
      return this._lastFramesPerSecond;
    }
  }
});
FrameRateMonitor.prototype.pause = function() {
  ++this._pauseCount;
  if (this._pauseCount === 1) {
    this._frameTimes.length = 0;
    this._lastFramesPerSecond = void 0;
  }
};
FrameRateMonitor.prototype.unpause = function() {
  --this._pauseCount;
  if (this._pauseCount <= 0) {
    this._pauseCount = 0;
    this._needsQuietPeriod = true;
  }
};
FrameRateMonitor.prototype.isDestroyed = function() {
  return false;
};
FrameRateMonitor.prototype.destroy = function() {
  this._preUpdateRemoveListener();
  if (defined_default(this._visibilityChangeRemoveListener)) {
    this._visibilityChangeRemoveListener();
  }
  return destroyObject_default(this);
};
function update6(monitor, time) {
  if (monitor._pauseCount > 0) {
    return;
  }
  const timeStamp = getTimestamp_default();
  if (monitor._needsQuietPeriod) {
    monitor._needsQuietPeriod = false;
    monitor._frameTimes.length = 0;
    monitor._quietPeriodEndTime = timeStamp + monitor.quietPeriod / TimeConstants_default.SECONDS_PER_MILLISECOND;
    monitor._warmupPeriodEndTime = monitor._quietPeriodEndTime + (monitor.warmupPeriod + monitor.samplingWindow) / TimeConstants_default.SECONDS_PER_MILLISECOND;
  } else if (timeStamp >= monitor._quietPeriodEndTime) {
    monitor._frameTimes.push(timeStamp);
    const beginningOfWindow = timeStamp - monitor.samplingWindow / TimeConstants_default.SECONDS_PER_MILLISECOND;
    if (monitor._frameTimes.length >= 2 && monitor._frameTimes[0] <= beginningOfWindow) {
      while (monitor._frameTimes.length >= 2 && monitor._frameTimes[1] < beginningOfWindow) {
        monitor._frameTimes.shift();
      }
      const averageTimeBetweenFrames = (timeStamp - monitor._frameTimes[0]) / (monitor._frameTimes.length - 1);
      monitor._lastFramesPerSecond = 1e3 / averageTimeBetweenFrames;
      const maximumFrameTime = 1e3 / (timeStamp > monitor._warmupPeriodEndTime ? monitor.minimumFrameRateAfterWarmup : monitor.minimumFrameRateDuringWarmup);
      if (averageTimeBetweenFrames > maximumFrameTime) {
        if (!monitor._frameRateIsLow) {
          monitor._frameRateIsLow = true;
          monitor._needsQuietPeriod = true;
          monitor.lowFrameRate.raiseEvent(
            monitor.scene,
            monitor._lastFramesPerSecond
          );
        }
      } else if (monitor._frameRateIsLow) {
        monitor._frameRateIsLow = false;
        monitor._needsQuietPeriod = true;
        monitor.nominalFrameRate.raiseEvent(
          monitor.scene,
          monitor._lastFramesPerSecond
        );
      }
    }
  }
}
function visibilityChanged(monitor) {
  if (document[monitor._hiddenPropertyName]) {
    monitor.pause();
  } else {
    monitor.unpause();
  }
}
var FrameRateMonitor_default = FrameRateMonitor;

// node_modules/cesium/Source/Scene/FrameState.js
function FrameState(context, creditDisplay, jobScheduler) {
  this.context = context;
  this.commandList = [];
  this.shadowMaps = [];
  this.brdfLutGenerator = void 0;
  this.environmentMap = void 0;
  this.sphericalHarmonicCoefficients = void 0;
  this.specularEnvironmentMaps = void 0;
  this.specularEnvironmentMapsMaximumLOD = void 0;
  this.mode = SceneMode_default.SCENE3D;
  this.morphTime = SceneMode_default.getMorphTime(SceneMode_default.SCENE3D);
  this.frameNumber = 0;
  this.newFrame = false;
  this.time = void 0;
  this.jobScheduler = jobScheduler;
  this.mapProjection = void 0;
  this.camera = void 0;
  this.cameraUnderground = false;
  this.globeTranslucencyState = void 0;
  this.cullingVolume = void 0;
  this.occluder = void 0;
  this.maximumScreenSpaceError = void 0;
  this.pixelRatio = 1;
  this.passes = {
    render: false,
    pick: false,
    depth: false,
    postProcess: false,
    offscreen: false
  };
  this.creditDisplay = creditDisplay;
  this.afterRender = [];
  this.scene3DOnly = false;
  this.fog = {
    enabled: false,
    density: void 0,
    sse: void 0,
    minimumBrightness: void 0
  };
  this.terrainExaggeration = 1;
  this.terrainExaggerationRelativeHeight = 0;
  this.shadowState = {
    shadowsEnabled: true,
    shadowMaps: [],
    lightShadowMaps: [],
    nearPlane: 1,
    farPlane: 5e3,
    closestObjectSize: 1e3,
    lastDirtyTime: 0,
    outOfView: true
  };
  this.splitPosition = 0;
  this.frustumSplits = [];
  this.backgroundColor = void 0;
  this.light = void 0;
  this.minimumDisableDepthTestDistance = void 0;
  this.invertClassification = false;
  this.invertClassificationColor = void 0;
  this.useLogDepth = false;
  this.tilesetPassState = void 0;
  this.minimumTerrainHeight = 0;
}
var FrameState_default = FrameState;

// node_modules/cesium/Source/Scene/FrustumCommands.js
function FrustumCommands(near, far) {
  this.near = defaultValue_default(near, 0);
  this.far = defaultValue_default(far, 0);
  const numPasses = Pass_default.NUMBER_OF_PASSES;
  const commands = new Array(numPasses);
  const indices2 = new Array(numPasses);
  for (let i2 = 0; i2 < numPasses; ++i2) {
    commands[i2] = [];
    indices2[i2] = 0;
  }
  this.commands = commands;
  this.indices = indices2;
}
var FrustumCommands_default = FrustumCommands;

// node_modules/cesium/Source/Scene/GetFeatureInfoFormat.js
function GetFeatureInfoFormat(type, format, callback) {
  if (!defined_default(type)) {
    throw new DeveloperError_default("type is required.");
  }
  this.type = type;
  if (!defined_default(format)) {
    if (type === "json") {
      format = "application/json";
    } else if (type === "xml") {
      format = "text/xml";
    } else if (type === "html") {
      format = "text/html";
    } else if (type === "text") {
      format = "text/plain";
    } else {
      throw new DeveloperError_default(
        'format is required when type is not "json", "xml", "html", or "text".'
      );
    }
  }
  this.format = format;
  if (!defined_default(callback)) {
    if (type === "json") {
      callback = geoJsonToFeatureInfo;
    } else if (type === "xml") {
      callback = xmlToFeatureInfo;
    } else if (type === "html") {
      callback = textToFeatureInfo;
    } else if (type === "text") {
      callback = textToFeatureInfo;
    } else {
      throw new DeveloperError_default(
        'callback is required when type is not "json", "xml", "html", or "text".'
      );
    }
  }
  this.callback = callback;
}
function geoJsonToFeatureInfo(json) {
  const result = [];
  const features = json.features;
  for (let i2 = 0; i2 < features.length; ++i2) {
    const feature2 = features[i2];
    const featureInfo = new ImageryLayerFeatureInfo_default();
    featureInfo.data = feature2;
    featureInfo.properties = feature2.properties;
    featureInfo.configureNameFromProperties(feature2.properties);
    featureInfo.configureDescriptionFromProperties(feature2.properties);
    if (defined_default(feature2.geometry) && feature2.geometry.type === "Point") {
      const longitude = feature2.geometry.coordinates[0];
      const latitude = feature2.geometry.coordinates[1];
      featureInfo.position = Cartographic_default.fromDegrees(longitude, latitude);
    }
    result.push(featureInfo);
  }
  return result;
}
var mapInfoMxpNamespace = "http://www.mapinfo.com/mxp";
var esriWmsNamespace = "http://www.esri.com/wms";
var wfsNamespace = "http://www.opengis.net/wfs";
var gmlNamespace = "http://www.opengis.net/gml";
function xmlToFeatureInfo(xml2) {
  const documentElement = xml2.documentElement;
  if (documentElement.localName === "MultiFeatureCollection" && documentElement.namespaceURI === mapInfoMxpNamespace) {
    return mapInfoXmlToFeatureInfo(xml2);
  } else if (documentElement.localName === "FeatureInfoResponse" && documentElement.namespaceURI === esriWmsNamespace) {
    return esriXmlToFeatureInfo(xml2);
  } else if (documentElement.localName === "FeatureCollection" && documentElement.namespaceURI === wfsNamespace) {
    return gmlToFeatureInfo(xml2);
  } else if (documentElement.localName === "ServiceExceptionReport") {
    throw new RuntimeError_default(
      new XMLSerializer().serializeToString(documentElement)
    );
  } else if (documentElement.localName === "msGMLOutput") {
    return msGmlToFeatureInfo(xml2);
  } else {
    return unknownXmlToFeatureInfo(xml2);
  }
}
function mapInfoXmlToFeatureInfo(xml2) {
  const result = [];
  const multiFeatureCollection = xml2.documentElement;
  const features = multiFeatureCollection.getElementsByTagNameNS(
    mapInfoMxpNamespace,
    "Feature"
  );
  for (let featureIndex = 0; featureIndex < features.length; ++featureIndex) {
    const feature2 = features[featureIndex];
    const properties = {};
    const propertyElements = feature2.getElementsByTagNameNS(
      mapInfoMxpNamespace,
      "Val"
    );
    for (let propertyIndex = 0; propertyIndex < propertyElements.length; ++propertyIndex) {
      const propertyElement = propertyElements[propertyIndex];
      if (propertyElement.hasAttribute("ref")) {
        const name = propertyElement.getAttribute("ref");
        const value = propertyElement.textContent.trim();
        properties[name] = value;
      }
    }
    const featureInfo = new ImageryLayerFeatureInfo_default();
    featureInfo.data = feature2;
    featureInfo.properties = properties;
    featureInfo.configureNameFromProperties(properties);
    featureInfo.configureDescriptionFromProperties(properties);
    result.push(featureInfo);
  }
  return result;
}
function esriXmlToFeatureInfo(xml2) {
  const featureInfoResponse = xml2.documentElement;
  const result = [];
  let properties;
  const features = featureInfoResponse.getElementsByTagNameNS("*", "FIELDS");
  if (features.length > 0) {
    for (let featureIndex = 0; featureIndex < features.length; ++featureIndex) {
      const feature2 = features[featureIndex];
      properties = {};
      const propertyAttributes = feature2.attributes;
      for (let attributeIndex = 0; attributeIndex < propertyAttributes.length; ++attributeIndex) {
        const attribute = propertyAttributes[attributeIndex];
        properties[attribute.name] = attribute.value;
      }
      result.push(
        imageryLayerFeatureInfoFromDataAndProperties(feature2, properties)
      );
    }
  } else {
    const featureInfoElements = featureInfoResponse.getElementsByTagNameNS(
      "*",
      "FeatureInfo"
    );
    for (let featureInfoElementIndex = 0; featureInfoElementIndex < featureInfoElements.length; ++featureInfoElementIndex) {
      const featureInfoElement = featureInfoElements[featureInfoElementIndex];
      properties = {};
      const featureInfoChildren = featureInfoElement.childNodes;
      for (let childIndex = 0; childIndex < featureInfoChildren.length; ++childIndex) {
        const child = featureInfoChildren[childIndex];
        if (child.nodeType === Node.ELEMENT_NODE) {
          properties[child.localName] = child.textContent;
        }
      }
      result.push(
        imageryLayerFeatureInfoFromDataAndProperties(
          featureInfoElement,
          properties
        )
      );
    }
  }
  return result;
}
function gmlToFeatureInfo(xml2) {
  const result = [];
  const featureCollection = xml2.documentElement;
  const featureMembers = featureCollection.getElementsByTagNameNS(
    gmlNamespace,
    "featureMember"
  );
  for (let featureIndex = 0; featureIndex < featureMembers.length; ++featureIndex) {
    const featureMember = featureMembers[featureIndex];
    const properties = {};
    getGmlPropertiesRecursively(featureMember, properties);
    result.push(
      imageryLayerFeatureInfoFromDataAndProperties(featureMember, properties)
    );
  }
  return result;
}
function msGmlToFeatureInfo(xml2) {
  const result = [];
  let layer;
  const children = xml2.documentElement.childNodes;
  for (let i2 = 0; i2 < children.length; i2++) {
    if (children[i2].nodeType === Node.ELEMENT_NODE) {
      layer = children[i2];
      break;
    }
  }
  if (!defined_default(layer)) {
    throw new RuntimeError_default(
      "Unable to find first child of the feature info xml document"
    );
  }
  const featureMembers = layer.childNodes;
  for (let featureIndex = 0; featureIndex < featureMembers.length; ++featureIndex) {
    const featureMember = featureMembers[featureIndex];
    if (featureMember.nodeType === Node.ELEMENT_NODE) {
      const properties = {};
      getGmlPropertiesRecursively(featureMember, properties);
      result.push(
        imageryLayerFeatureInfoFromDataAndProperties(featureMember, properties)
      );
    }
  }
  return result;
}
function getGmlPropertiesRecursively(gmlNode, properties) {
  let isSingleValue = true;
  for (let i2 = 0; i2 < gmlNode.childNodes.length; ++i2) {
    const child = gmlNode.childNodes[i2];
    if (child.nodeType === Node.ELEMENT_NODE) {
      isSingleValue = false;
    }
    if (child.localName === "Point" || child.localName === "LineString" || child.localName === "Polygon" || child.localName === "boundedBy") {
      continue;
    }
    if (child.hasChildNodes() && getGmlPropertiesRecursively(child, properties)) {
      properties[child.localName] = child.textContent;
    }
  }
  return isSingleValue;
}
function imageryLayerFeatureInfoFromDataAndProperties(data, properties) {
  const featureInfo = new ImageryLayerFeatureInfo_default();
  featureInfo.data = data;
  featureInfo.properties = properties;
  featureInfo.configureNameFromProperties(properties);
  featureInfo.configureDescriptionFromProperties(properties);
  return featureInfo;
}
function unknownXmlToFeatureInfo(xml2) {
  const xmlText = new XMLSerializer().serializeToString(xml2);
  const element = document.createElement("div");
  const pre = document.createElement("pre");
  pre.textContent = xmlText;
  element.appendChild(pre);
  const featureInfo = new ImageryLayerFeatureInfo_default();
  featureInfo.data = xml2;
  featureInfo.description = element.innerHTML;
  return [featureInfo];
}
var emptyBodyRegex = /<body>\s*<\/body>/im;
var wmsServiceExceptionReportRegex = /<ServiceExceptionReport([\s\S]*)<\/ServiceExceptionReport>/im;
var titleRegex = /<title>([\s\S]*)<\/title>/im;
function textToFeatureInfo(text2) {
  if (emptyBodyRegex.test(text2)) {
    return void 0;
  }
  if (wmsServiceExceptionReportRegex.test(text2)) {
    return void 0;
  }
  let name;
  const title = titleRegex.exec(text2);
  if (title && title.length > 1) {
    name = title[1];
  }
  const featureInfo = new ImageryLayerFeatureInfo_default();
  featureInfo.name = name;
  featureInfo.description = text2;
  featureInfo.data = text2;
  return [featureInfo];
}
var GetFeatureInfoFormat_default = GetFeatureInfoFormat;

// node_modules/cesium/Source/Shaders/GlobeFS.js
var GlobeFS_default = `uniform vec4 u_initialColor;

#if TEXTURE_UNITS > 0
uniform sampler2D u_dayTextures[TEXTURE_UNITS];
uniform vec4 u_dayTextureTranslationAndScale[TEXTURE_UNITS];
uniform bool u_dayTextureUseWebMercatorT[TEXTURE_UNITS];

#ifdef APPLY_ALPHA
uniform float u_dayTextureAlpha[TEXTURE_UNITS];
#endif

#ifdef APPLY_DAY_NIGHT_ALPHA
uniform float u_dayTextureNightAlpha[TEXTURE_UNITS];
uniform float u_dayTextureDayAlpha[TEXTURE_UNITS];
#endif

#ifdef APPLY_SPLIT
uniform float u_dayTextureSplit[TEXTURE_UNITS];
#endif

#ifdef APPLY_BRIGHTNESS
uniform float u_dayTextureBrightness[TEXTURE_UNITS];
#endif

#ifdef APPLY_CONTRAST
uniform float u_dayTextureContrast[TEXTURE_UNITS];
#endif

#ifdef APPLY_HUE
uniform float u_dayTextureHue[TEXTURE_UNITS];
#endif

#ifdef APPLY_SATURATION
uniform float u_dayTextureSaturation[TEXTURE_UNITS];
#endif

#ifdef APPLY_GAMMA
uniform float u_dayTextureOneOverGamma[TEXTURE_UNITS];
#endif

#ifdef APPLY_IMAGERY_CUTOUT
uniform vec4 u_dayTextureCutoutRectangles[TEXTURE_UNITS];
#endif

#ifdef APPLY_COLOR_TO_ALPHA
uniform vec4 u_colorsToAlpha[TEXTURE_UNITS];
#endif

uniform vec4 u_dayTextureTexCoordsRectangle[TEXTURE_UNITS];
#endif

#ifdef SHOW_REFLECTIVE_OCEAN
uniform sampler2D u_waterMask;
uniform vec4 u_waterMaskTranslationAndScale;
uniform float u_zoomedOutOceanSpecularIntensity;
#endif

#ifdef SHOW_OCEAN_WAVES
uniform sampler2D u_oceanNormalMap;
#endif

#if defined(ENABLE_DAYNIGHT_SHADING) || defined(GROUND_ATMOSPHERE)
uniform vec2 u_lightingFadeDistance;
#endif

#ifdef TILE_LIMIT_RECTANGLE
uniform vec4 u_cartographicLimitRectangle;
#endif

#ifdef GROUND_ATMOSPHERE
uniform vec2 u_nightFadeDistance;
#endif

#ifdef ENABLE_CLIPPING_PLANES
uniform highp sampler2D u_clippingPlanes;
uniform mat4 u_clippingPlanesMatrix;
uniform vec4 u_clippingPlanesEdgeStyle;
#endif

#if defined(GROUND_ATMOSPHERE) || defined(FOG) && defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))
uniform float u_minimumBrightness;
#endif

#ifdef COLOR_CORRECT
uniform vec3 u_hsbShift; // Hue, saturation, brightness
#endif

#ifdef HIGHLIGHT_FILL_TILE
uniform vec4 u_fillHighlightColor;
#endif

#ifdef TRANSLUCENT
uniform vec4 u_frontFaceAlphaByDistance;
uniform vec4 u_backFaceAlphaByDistance;
uniform vec4 u_translucencyRectangle;
#endif

#ifdef UNDERGROUND_COLOR
uniform vec4 u_undergroundColor;
uniform vec4 u_undergroundColorAlphaByDistance;
#endif

#ifdef ENABLE_VERTEX_LIGHTING
uniform float u_lambertDiffuseMultiplier;
#endif

varying vec3 v_positionMC;
varying vec3 v_positionEC;
varying vec3 v_textureCoordinates;
varying vec3 v_normalMC;
varying vec3 v_normalEC;

#ifdef APPLY_MATERIAL
varying float v_height;
varying float v_slope;
varying float v_aspect;
#endif

#if defined(FOG) || defined(GROUND_ATMOSPHERE) || defined(UNDERGROUND_COLOR) || defined(TRANSLUCENT)
varying float v_distance;
#endif

#if defined(GROUND_ATMOSPHERE) || defined(FOG)
varying vec3 v_atmosphereRayleighColor;
varying vec3 v_atmosphereMieColor;
varying float v_atmosphereOpacity;
#endif

#if defined(UNDERGROUND_COLOR) || defined(TRANSLUCENT)
float interpolateByDistance(vec4 nearFarScalar, float distance)
{
    float startDistance = nearFarScalar.x;
    float startValue = nearFarScalar.y;
    float endDistance = nearFarScalar.z;
    float endValue = nearFarScalar.w;
    float t = clamp((distance - startDistance) / (endDistance - startDistance), 0.0, 1.0);
    return mix(startValue, endValue, t);
}
#endif

#if defined(UNDERGROUND_COLOR) || defined(TRANSLUCENT) || defined(APPLY_MATERIAL)
vec4 alphaBlend(vec4 sourceColor, vec4 destinationColor)
{
    return sourceColor * vec4(sourceColor.aaa, 1.0) + destinationColor * (1.0 - sourceColor.a);
}
#endif

#ifdef TRANSLUCENT
bool inTranslucencyRectangle()
{
    return
        v_textureCoordinates.x > u_translucencyRectangle.x &&
        v_textureCoordinates.x < u_translucencyRectangle.z &&
        v_textureCoordinates.y > u_translucencyRectangle.y &&
        v_textureCoordinates.y < u_translucencyRectangle.w;
}
#endif

vec4 sampleAndBlend(
    vec4 previousColor,
    sampler2D textureToSample,
    vec2 tileTextureCoordinates,
    vec4 textureCoordinateRectangle,
    vec4 textureCoordinateTranslationAndScale,
    float textureAlpha,
    float textureNightAlpha,
    float textureDayAlpha,
    float textureBrightness,
    float textureContrast,
    float textureHue,
    float textureSaturation,
    float textureOneOverGamma,
    float split,
    vec4 colorToAlpha,
    float nightBlend)
{
    // This crazy step stuff sets the alpha to 0.0 if this following condition is true:
    //    tileTextureCoordinates.s < textureCoordinateRectangle.s ||
    //    tileTextureCoordinates.s > textureCoordinateRectangle.p ||
    //    tileTextureCoordinates.t < textureCoordinateRectangle.t ||
    //    tileTextureCoordinates.t > textureCoordinateRectangle.q
    // In other words, the alpha is zero if the fragment is outside the rectangle
    // covered by this texture.  Would an actual 'if' yield better performance?
    vec2 alphaMultiplier = step(textureCoordinateRectangle.st, tileTextureCoordinates);
    textureAlpha = textureAlpha * alphaMultiplier.x * alphaMultiplier.y;

    alphaMultiplier = step(vec2(0.0), textureCoordinateRectangle.pq - tileTextureCoordinates);
    textureAlpha = textureAlpha * alphaMultiplier.x * alphaMultiplier.y;

#if defined(APPLY_DAY_NIGHT_ALPHA) && defined(ENABLE_DAYNIGHT_SHADING)
    textureAlpha *= mix(textureDayAlpha, textureNightAlpha, nightBlend);
#endif

    vec2 translation = textureCoordinateTranslationAndScale.xy;
    vec2 scale = textureCoordinateTranslationAndScale.zw;
    vec2 textureCoordinates = tileTextureCoordinates * scale + translation;
    vec4 value = texture2D(textureToSample, textureCoordinates);
    vec3 color = value.rgb;
    float alpha = value.a;

#ifdef APPLY_COLOR_TO_ALPHA
    vec3 colorDiff = abs(color.rgb - colorToAlpha.rgb);
    colorDiff.r = max(max(colorDiff.r, colorDiff.g), colorDiff.b);
    alpha = czm_branchFreeTernary(colorDiff.r < colorToAlpha.a, 0.0, alpha);
#endif

#if !defined(APPLY_GAMMA)
    vec4 tempColor = czm_gammaCorrect(vec4(color, alpha));
    color = tempColor.rgb;
    alpha = tempColor.a;
#else
    color = pow(color, vec3(textureOneOverGamma));
#endif

#ifdef APPLY_SPLIT
    float splitPosition = czm_splitPosition;
    // Split to the left
    if (split < 0.0 && gl_FragCoord.x > splitPosition) {
       alpha = 0.0;
    }
    // Split to the right
    else if (split > 0.0 && gl_FragCoord.x < splitPosition) {
       alpha = 0.0;
    }
#endif

#ifdef APPLY_BRIGHTNESS
    color = mix(vec3(0.0), color, textureBrightness);
#endif

#ifdef APPLY_CONTRAST
    color = mix(vec3(0.5), color, textureContrast);
#endif

#ifdef APPLY_HUE
    color = czm_hue(color, textureHue);
#endif

#ifdef APPLY_SATURATION
    color = czm_saturation(color, textureSaturation);
#endif

    float sourceAlpha = alpha * textureAlpha;
    float outAlpha = mix(previousColor.a, 1.0, sourceAlpha);
    outAlpha += sign(outAlpha) - 1.0;

    vec3 outColor = mix(previousColor.rgb * previousColor.a, color, sourceAlpha) / outAlpha;

    // When rendering imagery for a tile in multiple passes,
    // some GPU/WebGL implementation combinations will not blend fragments in
    // additional passes correctly if their computation includes an unmasked
    // divide-by-zero operation,
    // even if it's not in the output or if the output has alpha zero.
    //
    // For example, without sanitization for outAlpha,
    // this renders without artifacts:
    //   if (outAlpha == 0.0) { outColor = vec3(0.0); }
    //
    // but using czm_branchFreeTernary will cause portions of the tile that are
    // alpha-zero in the additional pass to render as black instead of blending
    // with the previous pass:
    //   outColor = czm_branchFreeTernary(outAlpha == 0.0, vec3(0.0), outColor);
    //
    // So instead, sanitize against divide-by-zero,
    // store this state on the sign of outAlpha, and correct on return.

    return vec4(outColor, max(outAlpha, 0.0));
}

vec3 colorCorrect(vec3 rgb) {
#ifdef COLOR_CORRECT
    // Convert rgb color to hsb
    vec3 hsb = czm_RGBToHSB(rgb);
    // Perform hsb shift
    hsb.x += u_hsbShift.x; // hue
    hsb.y = clamp(hsb.y + u_hsbShift.y, 0.0, 1.0); // saturation
    hsb.z = hsb.z > czm_epsilon7 ? hsb.z + u_hsbShift.z : 0.0; // brightness
    // Convert shifted hsb back to rgb
    rgb = czm_HSBToRGB(hsb);
#endif
    return rgb;
}

vec4 computeDayColor(vec4 initialColor, vec3 textureCoordinates, float nightBlend);
vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat3 enuToEye, vec4 imageryColor, float specularMapValue, float fade);

const float fExposure = 2.0;

vec3 computeEllipsoidPosition()
{
    float mpp = czm_metersPerPixel(vec4(0.0, 0.0, -czm_currentFrustum.x, 1.0), 1.0);
    vec2 xy = gl_FragCoord.xy / czm_viewport.zw * 2.0 - vec2(1.0);
    xy *= czm_viewport.zw * mpp * 0.5;

    vec3 direction = normalize(vec3(xy, -czm_currentFrustum.x));
    czm_ray ray = czm_ray(vec3(0.0), direction);

    vec3 ellipsoid_center = czm_view[3].xyz;

    czm_raySegment intersection = czm_rayEllipsoidIntersectionInterval(ray, ellipsoid_center, czm_ellipsoidInverseRadii);

    vec3 ellipsoidPosition = czm_pointAlongRay(ray, intersection.start);
    return (czm_inverseView * vec4(ellipsoidPosition, 1.0)).xyz;
}

void main()
{
#ifdef TILE_LIMIT_RECTANGLE
    if (v_textureCoordinates.x < u_cartographicLimitRectangle.x || u_cartographicLimitRectangle.z < v_textureCoordinates.x ||
        v_textureCoordinates.y < u_cartographicLimitRectangle.y || u_cartographicLimitRectangle.w < v_textureCoordinates.y)
        {
            discard;
        }
#endif

#ifdef ENABLE_CLIPPING_PLANES
    float clipDistance = clip(gl_FragCoord, u_clippingPlanes, u_clippingPlanesMatrix);
#endif

#if defined(SHOW_REFLECTIVE_OCEAN) || defined(ENABLE_DAYNIGHT_SHADING) || defined(HDR)
    vec3 normalMC = czm_geodeticSurfaceNormal(v_positionMC, vec3(0.0), vec3(1.0));   // normalized surface normal in model coordinates
    vec3 normalEC = czm_normal3D * normalMC;                                         // normalized surface normal in eye coordiantes
#endif

#if defined(APPLY_DAY_NIGHT_ALPHA) && defined(ENABLE_DAYNIGHT_SHADING)
    float nightBlend = 1.0 - clamp(czm_getLambertDiffuse(czm_lightDirectionEC, normalEC) * 5.0, 0.0, 1.0);
#else
    float nightBlend = 0.0;
#endif

    // The clamp below works around an apparent bug in Chrome Canary v23.0.1241.0
    // where the fragment shader sees textures coordinates < 0.0 and > 1.0 for the
    // fragments on the edges of tiles even though the vertex shader is outputting
    // coordinates strictly in the 0-1 range.
    vec4 color = computeDayColor(u_initialColor, clamp(v_textureCoordinates, 0.0, 1.0), nightBlend);

#ifdef SHOW_TILE_BOUNDARIES
    if (v_textureCoordinates.x < (1.0/256.0) || v_textureCoordinates.x > (255.0/256.0) ||
        v_textureCoordinates.y < (1.0/256.0) || v_textureCoordinates.y > (255.0/256.0))
    {
        color = vec4(1.0, 0.0, 0.0, 1.0);
    }
#endif

#if defined(ENABLE_DAYNIGHT_SHADING) || defined(GROUND_ATMOSPHERE)
    float cameraDist;
    if (czm_sceneMode == czm_sceneMode2D)
    {
        cameraDist = max(czm_frustumPlanes.x - czm_frustumPlanes.y, czm_frustumPlanes.w - czm_frustumPlanes.z) * 0.5;
    }
    else if (czm_sceneMode == czm_sceneModeColumbusView)
    {
        cameraDist = -czm_view[3].z;
    }
    else
    {
        cameraDist = length(czm_view[3]);
    }
    float fadeOutDist = u_lightingFadeDistance.x;
    float fadeInDist = u_lightingFadeDistance.y;
    if (czm_sceneMode != czm_sceneMode3D) {
        vec3 radii = czm_ellipsoidRadii;
        float maxRadii = max(radii.x, max(radii.y, radii.z));
        fadeOutDist -= maxRadii;
        fadeInDist -= maxRadii;
    }
    float fade = clamp((cameraDist - fadeOutDist) / (fadeInDist - fadeOutDist), 0.0, 1.0);
#else
    float fade = 0.0;
#endif

#ifdef SHOW_REFLECTIVE_OCEAN
    vec2 waterMaskTranslation = u_waterMaskTranslationAndScale.xy;
    vec2 waterMaskScale = u_waterMaskTranslationAndScale.zw;
    vec2 waterMaskTextureCoordinates = v_textureCoordinates.xy * waterMaskScale + waterMaskTranslation;
    waterMaskTextureCoordinates.y = 1.0 - waterMaskTextureCoordinates.y;

    float mask = texture2D(u_waterMask, waterMaskTextureCoordinates).r;

    if (mask > 0.0)
    {
        mat3 enuToEye = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalEC);

        vec2 ellipsoidTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC);
        vec2 ellipsoidFlippedTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC.zyx);

        vec2 textureCoordinates = mix(ellipsoidTextureCoordinates, ellipsoidFlippedTextureCoordinates, czm_morphTime * smoothstep(0.9, 0.95, normalMC.z));

        color = computeWaterColor(v_positionEC, textureCoordinates, enuToEye, color, mask, fade);
    }
#endif

#ifdef APPLY_MATERIAL
    czm_materialInput materialInput;
    materialInput.st = v_textureCoordinates.st;
    materialInput.normalEC = normalize(v_normalEC);
    materialInput.positionToEyeEC = -v_positionEC;
    materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalize(v_normalEC));     
    materialInput.slope = v_slope;
    materialInput.height = v_height;
    materialInput.aspect = v_aspect;
    czm_material material = czm_getMaterial(materialInput);
    vec4 materialColor = vec4(material.diffuse, material.alpha);
    color = alphaBlend(materialColor, color);
#endif

#ifdef ENABLE_VERTEX_LIGHTING
    float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_lightDirectionEC, normalize(v_normalEC)) * u_lambertDiffuseMultiplier + 0.3, 0.0, 1.0);
    vec4 finalColor = vec4(color.rgb * czm_lightColor * diffuseIntensity, color.a);
#elif defined(ENABLE_DAYNIGHT_SHADING)
    float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_lightDirectionEC, normalEC) * 5.0 + 0.3, 0.0, 1.0);
    diffuseIntensity = mix(1.0, diffuseIntensity, fade);
    vec4 finalColor = vec4(color.rgb * czm_lightColor * diffuseIntensity, color.a);
#else
    vec4 finalColor = color;
#endif

#ifdef ENABLE_CLIPPING_PLANES
    vec4 clippingPlanesEdgeColor = vec4(1.0);
    clippingPlanesEdgeColor.rgb = u_clippingPlanesEdgeStyle.rgb;
    float clippingPlanesEdgeWidth = u_clippingPlanesEdgeStyle.a;

    if (clipDistance < clippingPlanesEdgeWidth)
    {
        finalColor = clippingPlanesEdgeColor;
    }
#endif

#ifdef HIGHLIGHT_FILL_TILE
    finalColor = vec4(mix(finalColor.rgb, u_fillHighlightColor.rgb, u_fillHighlightColor.a), finalColor.a);
#endif

#if defined(DYNAMIC_ATMOSPHERE_LIGHTING_FROM_SUN)
    vec3 atmosphereLightDirection = czm_sunDirectionWC;
#else
    vec3 atmosphereLightDirection = czm_lightDirectionWC;
#endif

#if defined(GROUND_ATMOSPHERE) || defined(FOG)
    if (!czm_backFacing())
    {
        bool dynamicLighting = false;
        #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_DAYNIGHT_SHADING) || defined(ENABLE_VERTEX_LIGHTING))
            dynamicLighting = true;     
        #endif

        vec3 rayleighColor;
        vec3 mieColor;
        float opacity;

        vec3 positionWC;
        vec3 lightDirection;

        // When the camera is far away (camera distance > nightFadeOutDistance), the scattering is computed in the fragment shader.
        // Otherwise, the scattering is computed in the vertex shader.
        #ifdef PER_FRAGMENT_GROUND_ATMOSPHERE
            positionWC = computeEllipsoidPosition();
            lightDirection = czm_branchFreeTernary(dynamicLighting, atmosphereLightDirection, normalize(positionWC));
            computeAtmosphereScattering(
                positionWC,
                lightDirection,
                rayleighColor,
                mieColor,
                opacity
            );
        #else
            positionWC = v_positionMC;
            lightDirection = czm_branchFreeTernary(dynamicLighting, atmosphereLightDirection, normalize(positionWC));
            rayleighColor = v_atmosphereRayleighColor;
            mieColor = v_atmosphereMieColor;
            opacity = v_atmosphereOpacity;
        #endif

        rayleighColor = colorCorrect(rayleighColor);
        mieColor = colorCorrect(mieColor);

        vec4 groundAtmosphereColor = computeAtmosphereColor(positionWC, lightDirection, rayleighColor, mieColor, opacity);

        // Fog is applied to tiles selected for fog, close to the Earth.
        #ifdef FOG
            vec3 fogColor = groundAtmosphereColor.rgb;
            
            // If there is lighting, apply that to the fog.
            #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))
                float darken = clamp(dot(normalize(czm_viewerPositionWC), atmosphereLightDirection), u_minimumBrightness, 1.0);
                fogColor *= darken;                
            #endif

            #ifndef HDR
                fogColor.rgb = czm_acesTonemapping(fogColor.rgb);
                fogColor.rgb = czm_inverseGamma(fogColor.rgb);
            #endif
            
            const float modifier = 0.15;
            finalColor = vec4(czm_fog(v_distance, finalColor.rgb, fogColor.rgb, modifier), finalColor.a);

        #else
            // The transmittance is based on optical depth i.e. the length of segment of the ray inside the atmosphere.
            // This value is larger near the "circumference", as it is further away from the camera. We use it to
            // brighten up that area of the ground atmosphere.
            const float transmittanceModifier = 0.5;
            float transmittance = transmittanceModifier + clamp(1.0 - groundAtmosphereColor.a, 0.0, 1.0);

            vec3 finalAtmosphereColor = finalColor.rgb + groundAtmosphereColor.rgb * transmittance;

            #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))
                float fadeInDist = u_nightFadeDistance.x;
                float fadeOutDist = u_nightFadeDistance.y;
            
                float sunlitAtmosphereIntensity = clamp((cameraDist - fadeOutDist) / (fadeInDist - fadeOutDist), 0.05, 1.0);
                float darken = clamp(dot(normalize(positionWC), atmosphereLightDirection), 0.0, 1.0);
                vec3 darkenendGroundAtmosphereColor = mix(groundAtmosphereColor.rgb, finalAtmosphereColor.rgb, darken);

                finalAtmosphereColor = mix(darkenendGroundAtmosphereColor, finalAtmosphereColor, sunlitAtmosphereIntensity);
            #endif
            
            #ifndef HDR
                finalAtmosphereColor.rgb = vec3(1.0) - exp(-fExposure * finalAtmosphereColor.rgb);
            #else
                finalAtmosphereColor.rgb = czm_saturation(finalAtmosphereColor.rgb, 1.6);
            #endif
            
            finalColor.rgb = mix(finalColor.rgb, finalAtmosphereColor.rgb, fade);
        #endif
    }
#endif

#ifdef UNDERGROUND_COLOR
    if (czm_backFacing())
    {
        float distanceFromEllipsoid = max(czm_eyeHeight, 0.0);
        float distance = max(v_distance - distanceFromEllipsoid, 0.0);
        float blendAmount = interpolateByDistance(u_undergroundColorAlphaByDistance, distance);
        vec4 undergroundColor = vec4(u_undergroundColor.rgb, u_undergroundColor.a * blendAmount);
        finalColor = alphaBlend(undergroundColor, finalColor);
    }
#endif

#ifdef TRANSLUCENT
    if (inTranslucencyRectangle())
    {
      vec4 alphaByDistance = gl_FrontFacing ? u_frontFaceAlphaByDistance : u_backFaceAlphaByDistance;
      finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);
    }
#endif
    
    gl_FragColor =  finalColor;
}


#ifdef SHOW_REFLECTIVE_OCEAN

float waveFade(float edge0, float edge1, float x)
{
    float y = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
    return pow(1.0 - y, 5.0);
}

float linearFade(float edge0, float edge1, float x)
{
    return clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
}

// Based on water rendering by Jonas Wagner:
// http://29a.ch/2012/7/19/webgl-terrain-rendering-water-fog

// low altitude wave settings
const float oceanFrequencyLowAltitude = 825000.0;
const float oceanAnimationSpeedLowAltitude = 0.004;
const float oceanOneOverAmplitudeLowAltitude = 1.0 / 2.0;
const float oceanSpecularIntensity = 0.5;

// high altitude wave settings
const float oceanFrequencyHighAltitude = 125000.0;
const float oceanAnimationSpeedHighAltitude = 0.008;
const float oceanOneOverAmplitudeHighAltitude = 1.0 / 2.0;

vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat3 enuToEye, vec4 imageryColor, float maskValue, float fade)
{
    vec3 positionToEyeEC = -positionEyeCoordinates;
    float positionToEyeECLength = length(positionToEyeEC);

    // The double normalize below works around a bug in Firefox on Android devices.
    vec3 normalizedPositionToEyeEC = normalize(normalize(positionToEyeEC));

    // Fade out the waves as the camera moves far from the surface.
    float waveIntensity = waveFade(70000.0, 1000000.0, positionToEyeECLength);

#ifdef SHOW_OCEAN_WAVES
    // high altitude waves
    float time = czm_frameNumber * oceanAnimationSpeedHighAltitude;
    vec4 noise = czm_getWaterNoise(u_oceanNormalMap, textureCoordinates * oceanFrequencyHighAltitude, time, 0.0);
    vec3 normalTangentSpaceHighAltitude = vec3(noise.xy, noise.z * oceanOneOverAmplitudeHighAltitude);

    // low altitude waves
    time = czm_frameNumber * oceanAnimationSpeedLowAltitude;
    noise = czm_getWaterNoise(u_oceanNormalMap, textureCoordinates * oceanFrequencyLowAltitude, time, 0.0);
    vec3 normalTangentSpaceLowAltitude = vec3(noise.xy, noise.z * oceanOneOverAmplitudeLowAltitude);

    // blend the 2 wave layers based on distance to surface
    float highAltitudeFade = linearFade(0.0, 60000.0, positionToEyeECLength);
    float lowAltitudeFade = 1.0 - linearFade(20000.0, 60000.0, positionToEyeECLength);
    vec3 normalTangentSpace =
        (highAltitudeFade * normalTangentSpaceHighAltitude) +
        (lowAltitudeFade * normalTangentSpaceLowAltitude);
    normalTangentSpace = normalize(normalTangentSpace);

    // fade out the normal perturbation as we move farther from the water surface
    normalTangentSpace.xy *= waveIntensity;
    normalTangentSpace = normalize(normalTangentSpace);
#else
    vec3 normalTangentSpace = vec3(0.0, 0.0, 1.0);
#endif

    vec3 normalEC = enuToEye * normalTangentSpace;

    const vec3 waveHighlightColor = vec3(0.3, 0.45, 0.6);

    // Use diffuse light to highlight the waves
    float diffuseIntensity = czm_getLambertDiffuse(czm_lightDirectionEC, normalEC) * maskValue;
    vec3 diffuseHighlight = waveHighlightColor * diffuseIntensity * (1.0 - fade);

#ifdef SHOW_OCEAN_WAVES
    // Where diffuse light is low or non-existent, use wave highlights based solely on
    // the wave bumpiness and no particular light direction.
    float tsPerturbationRatio = normalTangentSpace.z;
    vec3 nonDiffuseHighlight = mix(waveHighlightColor * 5.0 * (1.0 - tsPerturbationRatio), vec3(0.0), diffuseIntensity);
#else
    vec3 nonDiffuseHighlight = vec3(0.0);
#endif

    // Add specular highlights in 3D, and in all modes when zoomed in.
    float specularIntensity = czm_getSpecular(czm_lightDirectionEC, normalizedPositionToEyeEC, normalEC, 10.0);
    float surfaceReflectance = mix(0.0, mix(u_zoomedOutOceanSpecularIntensity, oceanSpecularIntensity, waveIntensity), maskValue);
    float specular = specularIntensity * surfaceReflectance;

#ifdef HDR
    specular *= 1.4;

    float e = 0.2;
    float d = 3.3;
    float c = 1.7;

    vec3 color = imageryColor.rgb + (c * (vec3(e) + imageryColor.rgb * d) * (diffuseHighlight + nonDiffuseHighlight + specular));
#else
    vec3 color = imageryColor.rgb + diffuseHighlight + nonDiffuseHighlight + specular;
#endif

    return vec4(color, imageryColor.a);
}

#endif // #ifdef SHOW_REFLECTIVE_OCEAN
`;

// node_modules/cesium/Source/Shaders/GlobeVS.js
var GlobeVS_default = "#ifdef QUANTIZATION_BITS12\nattribute vec4 compressed0;\nattribute float compressed1;\n#else\nattribute vec4 position3DAndHeight;\nattribute vec4 textureCoordAndEncodedNormals;\n#endif\n\n#ifdef GEODETIC_SURFACE_NORMALS\nattribute vec3 geodeticSurfaceNormal;\n#endif\n\n#ifdef EXAGGERATION\nuniform vec2 u_terrainExaggerationAndRelativeHeight;\n#endif\n\nuniform vec3 u_center3D;\nuniform mat4 u_modifiedModelView;\nuniform mat4 u_modifiedModelViewProjection;\nuniform vec4 u_tileRectangle;\n\n// Uniforms for 2D Mercator projection\nuniform vec2 u_southAndNorthLatitude;\nuniform vec2 u_southMercatorYAndOneOverHeight;\n\nvarying vec3 v_positionMC;\nvarying vec3 v_positionEC;\n\nvarying vec3 v_textureCoordinates;\nvarying vec3 v_normalMC;\nvarying vec3 v_normalEC;\n\n#ifdef APPLY_MATERIAL\nvarying float v_slope;\nvarying float v_aspect;\nvarying float v_height;\n#endif\n\n#if defined(FOG) || defined(GROUND_ATMOSPHERE) || defined(UNDERGROUND_COLOR) || defined(TRANSLUCENT)\nvarying float v_distance;\n#endif\n\n#if defined(FOG) || defined(GROUND_ATMOSPHERE)\nvarying vec3 v_atmosphereRayleighColor;\nvarying vec3 v_atmosphereMieColor;\nvarying float v_atmosphereOpacity;\n#endif\n\n// These functions are generated at runtime.\nvec4 getPosition(vec3 position, float height, vec2 textureCoordinates);\nfloat get2DYPositionFraction(vec2 textureCoordinates);\n\nvec4 getPosition3DMode(vec3 position, float height, vec2 textureCoordinates)\n{\n    return u_modifiedModelViewProjection * vec4(position, 1.0);\n}\n\nfloat get2DMercatorYPositionFraction(vec2 textureCoordinates)\n{\n    // The width of a tile at level 11, in radians and assuming a single root tile, is\n    //   2.0 * czm_pi / pow(2.0, 11.0)\n    // We want to just linearly interpolate the 2D position from the texture coordinates\n    // when we're at this level or higher.  The constant below is the expression\n    // above evaluated and then rounded up at the 4th significant digit.\n    const float maxTileWidth = 0.003068;\n    float positionFraction = textureCoordinates.y;\n    float southLatitude = u_southAndNorthLatitude.x;\n    float northLatitude = u_southAndNorthLatitude.y;\n    if (northLatitude - southLatitude > maxTileWidth)\n    {\n        float southMercatorY = u_southMercatorYAndOneOverHeight.x;\n        float oneOverMercatorHeight = u_southMercatorYAndOneOverHeight.y;\n\n        float currentLatitude = mix(southLatitude, northLatitude, textureCoordinates.y);\n        currentLatitude = clamp(currentLatitude, -czm_webMercatorMaxLatitude, czm_webMercatorMaxLatitude);\n        positionFraction = czm_latitudeToWebMercatorFraction(currentLatitude, southMercatorY, oneOverMercatorHeight);\n    }\n    return positionFraction;\n}\n\nfloat get2DGeographicYPositionFraction(vec2 textureCoordinates)\n{\n    return textureCoordinates.y;\n}\n\nvec4 getPositionPlanarEarth(vec3 position, float height, vec2 textureCoordinates)\n{\n    float yPositionFraction = get2DYPositionFraction(textureCoordinates);\n    vec4 rtcPosition2D = vec4(height, mix(u_tileRectangle.st, u_tileRectangle.pq, vec2(textureCoordinates.x, yPositionFraction)), 1.0);\n    return u_modifiedModelViewProjection * rtcPosition2D;\n}\n\nvec4 getPosition2DMode(vec3 position, float height, vec2 textureCoordinates)\n{\n    return getPositionPlanarEarth(position, 0.0, textureCoordinates);\n}\n\nvec4 getPositionColumbusViewMode(vec3 position, float height, vec2 textureCoordinates)\n{\n    return getPositionPlanarEarth(position, height, textureCoordinates);\n}\n\nvec4 getPositionMorphingMode(vec3 position, float height, vec2 textureCoordinates)\n{\n    // We do not do RTC while morphing, so there is potential for jitter.\n    // This is unlikely to be noticeable, though.\n    vec3 position3DWC = position + u_center3D;\n    float yPositionFraction = get2DYPositionFraction(textureCoordinates);\n    vec4 position2DWC = vec4(height, mix(u_tileRectangle.st, u_tileRectangle.pq, vec2(textureCoordinates.x, yPositionFraction)), 1.0);\n    vec4 morphPosition = czm_columbusViewMorph(position2DWC, vec4(position3DWC, 1.0), czm_morphTime);\n    return czm_modelViewProjection * morphPosition;\n}\n\n#ifdef QUANTIZATION_BITS12\nuniform vec2 u_minMaxHeight;\nuniform mat4 u_scaleAndBias;\n#endif\n\nvoid main()\n{\n#ifdef QUANTIZATION_BITS12\n    vec2 xy = czm_decompressTextureCoordinates(compressed0.x);\n    vec2 zh = czm_decompressTextureCoordinates(compressed0.y);\n    vec3 position = vec3(xy, zh.x);\n    float height = zh.y;\n    vec2 textureCoordinates = czm_decompressTextureCoordinates(compressed0.z);\n\n    height = height * (u_minMaxHeight.y - u_minMaxHeight.x) + u_minMaxHeight.x;\n    position = (u_scaleAndBias * vec4(position, 1.0)).xyz;\n\n#if (defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)) && defined(INCLUDE_WEB_MERCATOR_Y)\n    float webMercatorT = czm_decompressTextureCoordinates(compressed0.w).x;\n    float encodedNormal = compressed1;\n#elif defined(INCLUDE_WEB_MERCATOR_Y)\n    float webMercatorT = czm_decompressTextureCoordinates(compressed0.w).x;\n    float encodedNormal = 0.0;\n#elif defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)\n    float webMercatorT = textureCoordinates.y;\n    float encodedNormal = compressed0.w;\n#else\n    float webMercatorT = textureCoordinates.y;\n    float encodedNormal = 0.0;\n#endif\n\n#else\n    // A single float per element\n    vec3 position = position3DAndHeight.xyz;\n    float height = position3DAndHeight.w;\n    vec2 textureCoordinates = textureCoordAndEncodedNormals.xy;\n\n#if (defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL) || defined(APPLY_MATERIAL)) && defined(INCLUDE_WEB_MERCATOR_Y)\n    float webMercatorT = textureCoordAndEncodedNormals.z;\n    float encodedNormal = textureCoordAndEncodedNormals.w;\n#elif defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL) || defined(APPLY_MATERIAL)\n    float webMercatorT = textureCoordinates.y;\n    float encodedNormal = textureCoordAndEncodedNormals.z;\n#elif defined(INCLUDE_WEB_MERCATOR_Y)\n    float webMercatorT = textureCoordAndEncodedNormals.z;\n    float encodedNormal = 0.0;\n#else\n    float webMercatorT = textureCoordinates.y;\n    float encodedNormal = 0.0;\n#endif\n\n#endif\n\n    vec3 position3DWC = position + u_center3D;\n\n#ifdef GEODETIC_SURFACE_NORMALS\n    vec3 ellipsoidNormal = geodeticSurfaceNormal;\n#else\n    vec3 ellipsoidNormal = normalize(position3DWC);\n#endif\n\n#if defined(EXAGGERATION) && defined(GEODETIC_SURFACE_NORMALS)\n    float exaggeration = u_terrainExaggerationAndRelativeHeight.x;\n    float relativeHeight = u_terrainExaggerationAndRelativeHeight.y;\n    float newHeight = (height - relativeHeight) * exaggeration + relativeHeight;\n\n    // stop from going through center of earth\n    float minRadius = min(min(czm_ellipsoidRadii.x, czm_ellipsoidRadii.y), czm_ellipsoidRadii.z);\n    newHeight = max(newHeight, -minRadius);\n\n    vec3 offset = ellipsoidNormal * (newHeight - height);\n    position += offset;\n    position3DWC += offset;\n    height = newHeight;\n#endif\n\n    gl_Position = getPosition(position, height, textureCoordinates);\n\n    v_positionEC = (u_modifiedModelView * vec4(position, 1.0)).xyz;\n    v_positionMC = position3DWC;  // position in model coordinates\n\n    v_textureCoordinates = vec3(textureCoordinates, webMercatorT);\n\n#if defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL) || defined(APPLY_MATERIAL)\n    vec3 normalMC = czm_octDecode(encodedNormal);\n\n#if defined(EXAGGERATION) && defined(GEODETIC_SURFACE_NORMALS)\n    vec3 projection = dot(normalMC, ellipsoidNormal) * ellipsoidNormal;\n    vec3 rejection = normalMC - projection;\n    normalMC = normalize(projection + rejection * exaggeration);\n#endif\n\n    v_normalMC = normalMC;\n    v_normalEC = czm_normal3D * v_normalMC;\n#endif\n\n#if defined(FOG) || (defined(GROUND_ATMOSPHERE) && !defined(PER_FRAGMENT_GROUND_ATMOSPHERE))\n\n    bool dynamicLighting = false;\n\n    #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_DAYNIGHT_SHADING) || defined(ENABLE_VERTEX_LIGHTING))\n        dynamicLighting = true;\n    #endif\n\n#if defined(DYNAMIC_ATMOSPHERE_LIGHTING_FROM_SUN)\n    vec3 atmosphereLightDirection = czm_sunDirectionWC;\n#else\n    vec3 atmosphereLightDirection = czm_lightDirectionWC;\n#endif\n\n    vec3 lightDirection = czm_branchFreeTernary(dynamicLighting, atmosphereLightDirection, normalize(position3DWC));\n\n    computeAtmosphereScattering(\n        position3DWC,\n        lightDirection,\n        v_atmosphereRayleighColor,\n        v_atmosphereMieColor,\n        v_atmosphereOpacity\n    );\n#endif\n\n#if defined(FOG) || defined(GROUND_ATMOSPHERE) || defined(UNDERGROUND_COLOR) || defined(TRANSLUCENT)\n    v_distance = length((czm_modelView3D * vec4(position3DWC, 1.0)).xyz);\n#endif\n\n#ifdef APPLY_MATERIAL\n    float northPoleZ = czm_ellipsoidRadii.z;\n    vec3 northPolePositionMC = vec3(0.0, 0.0, northPoleZ);\n    vec3 vectorEastMC = normalize(cross(northPolePositionMC - v_positionMC, ellipsoidNormal));\n    float dotProd = abs(dot(ellipsoidNormal, v_normalMC));\n    v_slope = acos(dotProd);\n    vec3 normalRejected = ellipsoidNormal * dotProd;\n    vec3 normalProjected = v_normalMC - normalRejected;\n    vec3 aspectVector = normalize(normalProjected);\n    v_aspect = acos(dot(aspectVector, vectorEastMC));\n    float determ = dot(cross(vectorEastMC, aspectVector), ellipsoidNormal);\n    v_aspect = czm_branchFreeTernary(determ < 0.0, 2.0 * czm_pi - v_aspect, v_aspect);\n    v_height = height;\n#endif\n}\n";

// node_modules/cesium/Source/Shaders/AtmosphereCommon.js
var AtmosphereCommon_default = "uniform vec3 u_radiiAndDynamicAtmosphereColor;\n\nuniform float u_atmosphereLightIntensity;\nuniform float u_atmosphereRayleighScaleHeight;\nuniform float u_atmosphereMieScaleHeight;\nuniform float u_atmosphereMieAnisotropy;\nuniform vec3 u_atmosphereRayleighCoefficient;\nuniform vec3 u_atmosphereMieCoefficient;\n\nconst float ATMOSPHERE_THICKNESS = 111e3; // The thickness of the atmosphere in meters.\nconst int PRIMARY_STEPS = 16; // Number of times the ray from the camera to the world position (primary ray) is sampled.\nconst int LIGHT_STEPS = 4; // Number of times the light is sampled from the light source's intersection with the atmosphere to a sample position on the primary ray.\n\n/**\n * This function computes the colors contributed by Rayliegh and Mie scattering on a given ray, as well as\n * the transmittance value for the ray.\n *\n * @param {czm_ray} primaryRay The ray from the camera to the position.\n * @param {float} primaryRayLength The length of the primary ray.\n * @param {vec3} lightDirection The direction of the light to calculate the scattering from.\n * @param {vec3} rayleighColor The variable the Rayleigh scattering will be written to.\n * @param {vec3} mieColor The variable the Mie scattering will be written to.\n * @param {float} opacity The variable the transmittance will be written to.\n * @glslFunction\n */\nvoid computeScattering(\n    czm_ray primaryRay,\n    float primaryRayLength,\n    vec3 lightDirection,\n    float atmosphereInnerRadius,\n    out vec3 rayleighColor,\n    out vec3 mieColor,\n    out float opacity\n) {\n\n    // Initialize the default scattering amounts to 0.\n    rayleighColor = vec3(0.0);\n    mieColor = vec3(0.0);\n    opacity = 0.0;\n\n    float atmosphereOuterRadius = atmosphereInnerRadius + ATMOSPHERE_THICKNESS;\n\n    vec3 origin = vec3(0.0);\n\n    // Calculate intersection from the camera to the outer ring of the atmosphere.\n    czm_raySegment primaryRayAtmosphereIntersect = czm_raySphereIntersectionInterval(primaryRay, origin, atmosphereOuterRadius);\n\n    // Return empty colors if no intersection with the atmosphere geometry.\n    if (primaryRayAtmosphereIntersect == czm_emptyRaySegment) {\n        return;\n    }\n\n    // The ray should start from the first intersection with the outer atmopshere, or from the camera position, if it is inside the atmosphere.\n    primaryRayAtmosphereIntersect.start = max(primaryRayAtmosphereIntersect.start, 0.0);\n    // The ray should end at the exit from the atmosphere or at the distance to the vertex, whichever is smaller.\n    primaryRayAtmosphereIntersect.stop = min(primaryRayAtmosphereIntersect.stop, length(primaryRayLength));\n\n    // Setup for sampling positions along the ray - starting from the intersection with the outer ring of the atmosphere.\n    float rayStepLength = (primaryRayAtmosphereIntersect.stop - primaryRayAtmosphereIntersect.start) / float(PRIMARY_STEPS);\n    float rayPositionLength = primaryRayAtmosphereIntersect.start;\n\n    vec3 rayleighAccumulation = vec3(0.0);\n    vec3 mieAccumulation = vec3(0.0);\n    vec2 opticalDepth = vec2(0.0);\n    vec2 heightScale = vec2(u_atmosphereRayleighScaleHeight, u_atmosphereMieScaleHeight);\n\n    // Sample positions on the primary ray.\n    for (int i = 0; i < PRIMARY_STEPS; i++) {\n        // Calculate sample position along viewpoint ray.\n        vec3 samplePosition = primaryRay.origin + primaryRay.direction * (rayPositionLength + rayStepLength);\n        \n        // Calculate height of sample position above ellipsoid.\n        float sampleHeight = length(samplePosition) - atmosphereInnerRadius;\n\n        // Calculate and accumulate density of particles at the sample position.\n        vec2 sampleDensity = exp(-sampleHeight / heightScale) * rayStepLength;\n        opticalDepth += sampleDensity;\n\n        // Generate ray from the sample position segment to the light source, up to the outer ring of the atmosphere.\n        czm_ray lightRay = czm_ray(samplePosition, lightDirection);\n        czm_raySegment lightRayAtmosphereIntersect = czm_raySphereIntersectionInterval(lightRay, origin, atmosphereOuterRadius);\n        \n        float lightStepLength = lightRayAtmosphereIntersect.stop / float(LIGHT_STEPS);\n        float lightPositionLength = 0.0;\n\n        vec2 lightOpticalDepth = vec2(0.0);\n\n        // Sample positions along the light ray, to accumulate incidence of light on the latest sample segment.\n        for (int j = 0; j < LIGHT_STEPS; j++) {\n\n            // Calculate sample position along light ray.\n            vec3 lightPosition = samplePosition + lightDirection * (lightPositionLength + lightStepLength * 0.5);\n\n            // Calculate height of the light sample position above ellipsoid.\n            float lightHeight = length(lightPosition) - atmosphereInnerRadius;\n\n            // Calculate density of photons at the light sample position.\n            lightOpticalDepth += exp(-lightHeight / heightScale) * lightStepLength;\n\n            // Increment distance on light ray.\n            lightPositionLength += lightStepLength;\n        }\n\n        // Compute attenuation via the primary ray and the light ray.\n        vec3 attenuation = exp(-((u_atmosphereMieCoefficient * (opticalDepth.y + lightOpticalDepth.y)) + (u_atmosphereRayleighCoefficient * (opticalDepth.x + lightOpticalDepth.x))));\n\n        // Accumulate the scattering.\n        rayleighAccumulation += sampleDensity.x * attenuation;\n        mieAccumulation += sampleDensity.y * attenuation;\n\n        // Increment distance on primary ray.\n        rayPositionLength += rayStepLength;\n    }\n\n    // Compute the scattering amount.\n    rayleighColor = u_atmosphereRayleighCoefficient * rayleighAccumulation;\n    mieColor = u_atmosphereMieCoefficient * mieAccumulation;\n\n    // Compute the transmittance i.e. how much light is passing through the atmosphere.\n    opacity = length(exp(-((u_atmosphereMieCoefficient * opticalDepth.y) + (u_atmosphereRayleighCoefficient * opticalDepth.x))));\n}\n\nvec4 computeAtmosphereColor(\n    vec3 positionWC,\n    vec3 lightDirection,\n    vec3 rayleighColor,\n    vec3 mieColor,\n    float opacity\n) {\n    // Setup the primary ray: from the camera position to the vertex position.\n    vec3 cameraToPositionWC = positionWC - czm_viewerPositionWC;\n    vec3 cameraToPositionWCDirection = normalize(cameraToPositionWC);\n\n    float cosAngle = dot(cameraToPositionWCDirection, lightDirection);\n    float cosAngleSq = cosAngle * cosAngle;\n\n    float G = u_atmosphereMieAnisotropy;\n    float GSq = G * G;\n\n    // The Rayleigh phase function.\n    float rayleighPhase = 3.0 / (50.2654824574) * (1.0 + cosAngleSq);\n    // The Mie phase function.\n    float miePhase = 3.0 / (25.1327412287) * ((1.0 - GSq) * (cosAngleSq + 1.0)) / (pow(1.0 + GSq - 2.0 * cosAngle * G, 1.5) * (2.0 + GSq));\n\n    // The final color is generated by combining the effects of the Rayleigh and Mie scattering.\n    vec3 rayleigh = rayleighPhase * rayleighColor;\n    vec3 mie = miePhase * mieColor;\n\n    vec3 color = (rayleigh + mie) * u_atmosphereLightIntensity;\n\n    return vec4(color, opacity);\n}\n";

// node_modules/cesium/Source/Shaders/GroundAtmosphere.js
var GroundAtmosphere_default = "void computeAtmosphereScattering(vec3 positionWC, vec3 lightDirection, out vec3 rayleighColor, out vec3 mieColor, out float opacity) {\n\n    vec3 cameraToPositionWC = positionWC - czm_viewerPositionWC;\n    vec3 cameraToPositionWCDirection = normalize(cameraToPositionWC);\n    czm_ray primaryRay = czm_ray(czm_viewerPositionWC, cameraToPositionWCDirection);\n    \n    float atmosphereInnerRadius = length(positionWC);\n\n    computeScattering(\n        primaryRay,\n        length(cameraToPositionWC),\n        lightDirection,\n        atmosphereInnerRadius,\n        rayleighColor,\n        mieColor,\n        opacity\n    );\n}\n";

// node_modules/cesium/Source/Scene/GlobeSurfaceShaderSet.js
function GlobeSurfaceShader(numberOfDayTextures, flags, material, shaderProgram, clippingShaderState) {
  this.numberOfDayTextures = numberOfDayTextures;
  this.flags = flags;
  this.material = material;
  this.shaderProgram = shaderProgram;
  this.clippingShaderState = clippingShaderState;
}
function GlobeSurfaceShaderSet() {
  this.baseVertexShaderSource = void 0;
  this.baseFragmentShaderSource = void 0;
  this._shadersByTexturesFlags = [];
  this.material = void 0;
}
function getPositionMode(sceneMode) {
  const getPosition3DMode = "vec4 getPosition(vec3 position, float height, vec2 textureCoordinates) { return getPosition3DMode(position, height, textureCoordinates); }";
  const getPositionColumbusViewAnd2DMode = "vec4 getPosition(vec3 position, float height, vec2 textureCoordinates) { return getPositionColumbusViewMode(position, height, textureCoordinates); }";
  const getPositionMorphingMode = "vec4 getPosition(vec3 position, float height, vec2 textureCoordinates) { return getPositionMorphingMode(position, height, textureCoordinates); }";
  let positionMode;
  switch (sceneMode) {
    case SceneMode_default.SCENE3D:
      positionMode = getPosition3DMode;
      break;
    case SceneMode_default.SCENE2D:
    case SceneMode_default.COLUMBUS_VIEW:
      positionMode = getPositionColumbusViewAnd2DMode;
      break;
    case SceneMode_default.MORPHING:
      positionMode = getPositionMorphingMode;
      break;
  }
  return positionMode;
}
function get2DYPositionFraction(useWebMercatorProjection) {
  const get2DYPositionFractionGeographicProjection = "float get2DYPositionFraction(vec2 textureCoordinates) { return get2DGeographicYPositionFraction(textureCoordinates); }";
  const get2DYPositionFractionMercatorProjection = "float get2DYPositionFraction(vec2 textureCoordinates) { return get2DMercatorYPositionFraction(textureCoordinates); }";
  return useWebMercatorProjection ? get2DYPositionFractionMercatorProjection : get2DYPositionFractionGeographicProjection;
}
GlobeSurfaceShaderSet.prototype.getShaderProgram = function(options) {
  const frameState = options.frameState;
  const surfaceTile = options.surfaceTile;
  const numberOfDayTextures = options.numberOfDayTextures;
  const applyBrightness = options.applyBrightness;
  const applyContrast = options.applyContrast;
  const applyHue = options.applyHue;
  const applySaturation = options.applySaturation;
  const applyGamma = options.applyGamma;
  const applyAlpha = options.applyAlpha;
  const applyDayNightAlpha = options.applyDayNightAlpha;
  const applySplit = options.applySplit;
  const showReflectiveOcean = options.showReflectiveOcean;
  const showOceanWaves = options.showOceanWaves;
  const enableLighting = options.enableLighting;
  const dynamicAtmosphereLighting = options.dynamicAtmosphereLighting;
  const dynamicAtmosphereLightingFromSun = options.dynamicAtmosphereLightingFromSun;
  const showGroundAtmosphere = options.showGroundAtmosphere;
  const perFragmentGroundAtmosphere = options.perFragmentGroundAtmosphere;
  const hasVertexNormals = options.hasVertexNormals;
  const useWebMercatorProjection = options.useWebMercatorProjection;
  const enableFog = options.enableFog;
  const enableClippingPlanes = options.enableClippingPlanes;
  const clippingPlanes = options.clippingPlanes;
  const clippedByBoundaries = options.clippedByBoundaries;
  const hasImageryLayerCutout = options.hasImageryLayerCutout;
  const colorCorrect = options.colorCorrect;
  const highlightFillTile = options.highlightFillTile;
  const colorToAlpha = options.colorToAlpha;
  const hasGeodeticSurfaceNormals = options.hasGeodeticSurfaceNormals;
  const hasExaggeration = options.hasExaggeration;
  const showUndergroundColor = options.showUndergroundColor;
  const translucent = options.translucent;
  let quantization = 0;
  let quantizationDefine = "";
  const mesh2 = surfaceTile.renderedMesh;
  const terrainEncoding = mesh2.encoding;
  const quantizationMode = terrainEncoding.quantization;
  if (quantizationMode === TerrainQuantization_default.BITS12) {
    quantization = 1;
    quantizationDefine = "QUANTIZATION_BITS12";
  }
  let cartographicLimitRectangleFlag = 0;
  let cartographicLimitRectangleDefine = "";
  if (clippedByBoundaries) {
    cartographicLimitRectangleFlag = 1;
    cartographicLimitRectangleDefine = "TILE_LIMIT_RECTANGLE";
  }
  let imageryCutoutFlag = 0;
  let imageryCutoutDefine = "";
  if (hasImageryLayerCutout) {
    imageryCutoutFlag = 1;
    imageryCutoutDefine = "APPLY_IMAGERY_CUTOUT";
  }
  const sceneMode = frameState.mode;
  const flags = sceneMode | applyBrightness << 2 | applyContrast << 3 | applyHue << 4 | applySaturation << 5 | applyGamma << 6 | applyAlpha << 7 | showReflectiveOcean << 8 | showOceanWaves << 9 | enableLighting << 10 | dynamicAtmosphereLighting << 11 | dynamicAtmosphereLightingFromSun << 12 | showGroundAtmosphere << 13 | perFragmentGroundAtmosphere << 14 | hasVertexNormals << 15 | useWebMercatorProjection << 16 | enableFog << 17 | quantization << 18 | applySplit << 19 | enableClippingPlanes << 20 | cartographicLimitRectangleFlag << 21 | imageryCutoutFlag << 22 | colorCorrect << 23 | highlightFillTile << 24 | colorToAlpha << 25 | hasGeodeticSurfaceNormals << 26 | hasExaggeration << 27 | showUndergroundColor << 28 | translucent << 29 | applyDayNightAlpha << 30;
  let currentClippingShaderState = 0;
  if (defined_default(clippingPlanes) && clippingPlanes.length > 0) {
    currentClippingShaderState = enableClippingPlanes ? clippingPlanes.clippingPlanesState : 0;
  }
  let surfaceShader = surfaceTile.surfaceShader;
  if (defined_default(surfaceShader) && surfaceShader.numberOfDayTextures === numberOfDayTextures && surfaceShader.flags === flags && surfaceShader.material === this.material && surfaceShader.clippingShaderState === currentClippingShaderState) {
    return surfaceShader.shaderProgram;
  }
  let shadersByFlags = this._shadersByTexturesFlags[numberOfDayTextures];
  if (!defined_default(shadersByFlags)) {
    shadersByFlags = this._shadersByTexturesFlags[numberOfDayTextures] = [];
  }
  surfaceShader = shadersByFlags[flags];
  if (!defined_default(surfaceShader) || surfaceShader.material !== this.material || surfaceShader.clippingShaderState !== currentClippingShaderState) {
    const vs = this.baseVertexShaderSource.clone();
    const fs = this.baseFragmentShaderSource.clone();
    if (currentClippingShaderState !== 0) {
      fs.sources.unshift(
        getClippingFunction_default(clippingPlanes, frameState.context)
      );
    }
    vs.defines.push(quantizationDefine);
    fs.defines.push(
      `TEXTURE_UNITS ${numberOfDayTextures}`,
      cartographicLimitRectangleDefine,
      imageryCutoutDefine
    );
    if (applyBrightness) {
      fs.defines.push("APPLY_BRIGHTNESS");
    }
    if (applyContrast) {
      fs.defines.push("APPLY_CONTRAST");
    }
    if (applyHue) {
      fs.defines.push("APPLY_HUE");
    }
    if (applySaturation) {
      fs.defines.push("APPLY_SATURATION");
    }
    if (applyGamma) {
      fs.defines.push("APPLY_GAMMA");
    }
    if (applyAlpha) {
      fs.defines.push("APPLY_ALPHA");
    }
    if (applyDayNightAlpha) {
      fs.defines.push("APPLY_DAY_NIGHT_ALPHA");
    }
    if (showReflectiveOcean) {
      fs.defines.push("SHOW_REFLECTIVE_OCEAN");
      vs.defines.push("SHOW_REFLECTIVE_OCEAN");
    }
    if (showOceanWaves) {
      fs.defines.push("SHOW_OCEAN_WAVES");
    }
    if (colorToAlpha) {
      fs.defines.push("APPLY_COLOR_TO_ALPHA");
    }
    if (showUndergroundColor) {
      vs.defines.push("UNDERGROUND_COLOR");
      fs.defines.push("UNDERGROUND_COLOR");
    }
    if (translucent) {
      vs.defines.push("TRANSLUCENT");
      fs.defines.push("TRANSLUCENT");
    }
    if (enableLighting) {
      if (hasVertexNormals) {
        vs.defines.push("ENABLE_VERTEX_LIGHTING");
        fs.defines.push("ENABLE_VERTEX_LIGHTING");
      } else {
        vs.defines.push("ENABLE_DAYNIGHT_SHADING");
        fs.defines.push("ENABLE_DAYNIGHT_SHADING");
      }
    }
    if (dynamicAtmosphereLighting) {
      vs.defines.push("DYNAMIC_ATMOSPHERE_LIGHTING");
      fs.defines.push("DYNAMIC_ATMOSPHERE_LIGHTING");
      if (dynamicAtmosphereLightingFromSun) {
        vs.defines.push("DYNAMIC_ATMOSPHERE_LIGHTING_FROM_SUN");
        fs.defines.push("DYNAMIC_ATMOSPHERE_LIGHTING_FROM_SUN");
      }
    }
    if (showGroundAtmosphere) {
      vs.defines.push("GROUND_ATMOSPHERE");
      fs.defines.push("GROUND_ATMOSPHERE");
      if (perFragmentGroundAtmosphere) {
        vs.defines.push("PER_FRAGMENT_GROUND_ATMOSPHERE");
        fs.defines.push("PER_FRAGMENT_GROUND_ATMOSPHERE");
      }
    }
    vs.defines.push("INCLUDE_WEB_MERCATOR_Y");
    fs.defines.push("INCLUDE_WEB_MERCATOR_Y");
    if (enableFog) {
      vs.defines.push("FOG");
      fs.defines.push("FOG");
    }
    if (applySplit) {
      fs.defines.push("APPLY_SPLIT");
    }
    if (enableClippingPlanes) {
      fs.defines.push("ENABLE_CLIPPING_PLANES");
    }
    if (colorCorrect) {
      fs.defines.push("COLOR_CORRECT");
    }
    if (highlightFillTile) {
      fs.defines.push("HIGHLIGHT_FILL_TILE");
    }
    if (hasGeodeticSurfaceNormals) {
      vs.defines.push("GEODETIC_SURFACE_NORMALS");
    }
    if (hasExaggeration) {
      vs.defines.push("EXAGGERATION");
    }
    let computeDayColor = "    vec4 computeDayColor(vec4 initialColor, vec3 textureCoordinates, float nightBlend)\n    {\n        vec4 color = initialColor;\n";
    if (hasImageryLayerCutout) {
      computeDayColor += "        vec4 cutoutAndColorResult;\n        bool texelUnclipped;\n";
    }
    for (let i2 = 0; i2 < numberOfDayTextures; ++i2) {
      if (hasImageryLayerCutout) {
        computeDayColor += `        cutoutAndColorResult = u_dayTextureCutoutRectangles[${i2}];
        texelUnclipped = v_textureCoordinates.x < cutoutAndColorResult.x || cutoutAndColorResult.z < v_textureCoordinates.x || v_textureCoordinates.y < cutoutAndColorResult.y || cutoutAndColorResult.w < v_textureCoordinates.y;
        cutoutAndColorResult = sampleAndBlend(
`;
      } else {
        computeDayColor += "        color = sampleAndBlend(\n";
      }
      computeDayColor += `            color,
            u_dayTextures[${i2}],
            u_dayTextureUseWebMercatorT[${i2}] ? textureCoordinates.xz : textureCoordinates.xy,
            u_dayTextureTexCoordsRectangle[${i2}],
            u_dayTextureTranslationAndScale[${i2}],
            ${applyAlpha ? `u_dayTextureAlpha[${i2}]` : "1.0"},
            ${applyDayNightAlpha ? `u_dayTextureNightAlpha[${i2}]` : "1.0"},
${applyDayNightAlpha ? `u_dayTextureDayAlpha[${i2}]` : "1.0"},
${applyBrightness ? `u_dayTextureBrightness[${i2}]` : "0.0"},
            ${applyContrast ? `u_dayTextureContrast[${i2}]` : "0.0"},
            ${applyHue ? `u_dayTextureHue[${i2}]` : "0.0"},
            ${applySaturation ? `u_dayTextureSaturation[${i2}]` : "0.0"},
            ${applyGamma ? `u_dayTextureOneOverGamma[${i2}]` : "0.0"},
            ${applySplit ? `u_dayTextureSplit[${i2}]` : "0.0"},
            ${colorToAlpha ? `u_colorsToAlpha[${i2}]` : "vec4(0.0)"},
        nightBlend        );
`;
      if (hasImageryLayerCutout) {
        computeDayColor += "        color = czm_branchFreeTernary(texelUnclipped, cutoutAndColorResult, color);\n";
      }
    }
    computeDayColor += "        return color;\n    }";
    fs.sources.push(computeDayColor);
    vs.sources.push(getPositionMode(sceneMode));
    vs.sources.push(get2DYPositionFraction(useWebMercatorProjection));
    const shader = ShaderProgram_default.fromCache({
      context: frameState.context,
      vertexShaderSource: vs,
      fragmentShaderSource: fs,
      attributeLocations: terrainEncoding.getAttributeLocations()
    });
    surfaceShader = shadersByFlags[flags] = new GlobeSurfaceShader(
      numberOfDayTextures,
      flags,
      this.material,
      shader,
      currentClippingShaderState
    );
  }
  surfaceTile.surfaceShader = surfaceShader;
  return surfaceShader.shaderProgram;
};
GlobeSurfaceShaderSet.prototype.destroy = function() {
  let flags;
  let shader;
  const shadersByTexturesFlags = this._shadersByTexturesFlags;
  for (const textureCount in shadersByTexturesFlags) {
    if (shadersByTexturesFlags.hasOwnProperty(textureCount)) {
      const shadersByFlags = shadersByTexturesFlags[textureCount];
      if (!defined_default(shadersByFlags)) {
        continue;
      }
      for (flags in shadersByFlags) {
        if (shadersByFlags.hasOwnProperty(flags)) {
          shader = shadersByFlags[flags];
          if (defined_default(shader)) {
            shader.shaderProgram.destroy();
          }
        }
      }
    }
  }
  return destroyObject_default(this);
};
var GlobeSurfaceShaderSet_default = GlobeSurfaceShaderSet;

// node_modules/cesium/Source/Scene/ImageryState.js
var ImageryState = {
  UNLOADED: 0,
  TRANSITIONING: 1,
  RECEIVED: 2,
  TEXTURE_LOADED: 3,
  READY: 4,
  FAILED: 5,
  INVALID: 6,
  PLACEHOLDER: 7
};
var ImageryState_default = Object.freeze(ImageryState);

// node_modules/cesium/Source/Scene/QuadtreeTileLoadState.js
var QuadtreeTileLoadState = {
  START: 0,
  LOADING: 1,
  DONE: 2,
  FAILED: 3
};
var QuadtreeTileLoadState_default = Object.freeze(QuadtreeTileLoadState);

// node_modules/cesium/Source/Scene/TerrainState.js
var TerrainState2 = {
  FAILED: 0,
  UNLOADED: 1,
  RECEIVING: 2,
  RECEIVED: 3,
  TRANSFORMING: 4,
  TRANSFORMED: 5,
  READY: 6
};
var TerrainState_default = Object.freeze(TerrainState2);

// node_modules/cesium/Source/Scene/GlobeSurfaceTile.js
function GlobeSurfaceTile() {
  this.imagery = [];
  this.waterMaskTexture = void 0;
  this.waterMaskTranslationAndScale = new Cartesian4_default(0, 0, 1, 1);
  this.terrainData = void 0;
  this.vertexArray = void 0;
  this.tileBoundingRegion = void 0;
  this.occludeePointInScaledSpace = new Cartesian3_default();
  this.boundingVolumeSourceTile = void 0;
  this.boundingVolumeIsFromMesh = false;
  this.terrainState = TerrainState_default.UNLOADED;
  this.mesh = void 0;
  this.fill = void 0;
  this.pickBoundingSphere = new BoundingSphere_default();
  this.surfaceShader = void 0;
  this.isClipped = true;
  this.clippedByBoundaries = false;
}
Object.defineProperties(GlobeSurfaceTile.prototype, {
  eligibleForUnloading: {
    get: function() {
      const terrainState = this.terrainState;
      const loadingIsTransitioning = terrainState === TerrainState_default.RECEIVING || terrainState === TerrainState_default.TRANSFORMING;
      let shouldRemoveTile = !loadingIsTransitioning;
      const imagery = this.imagery;
      for (let i2 = 0, len = imagery.length; shouldRemoveTile && i2 < len; ++i2) {
        const tileImagery = imagery[i2];
        shouldRemoveTile = !defined_default(tileImagery.loadingImagery) || tileImagery.loadingImagery.state !== ImageryState_default.TRANSITIONING;
      }
      return shouldRemoveTile;
    }
  },
  renderedMesh: {
    get: function() {
      if (defined_default(this.vertexArray)) {
        return this.mesh;
      } else if (defined_default(this.fill)) {
        return this.fill.mesh;
      }
      return void 0;
    }
  }
});
var scratchCartographic17 = new Cartographic_default();
function getPosition3(encoding, mode2, projection, vertices, index2, result) {
  let position = encoding.getExaggeratedPosition(vertices, index2, result);
  if (defined_default(mode2) && mode2 !== SceneMode_default.SCENE3D) {
    const ellipsoid = projection.ellipsoid;
    const positionCartographic = ellipsoid.cartesianToCartographic(
      position,
      scratchCartographic17
    );
    position = projection.project(positionCartographic, result);
    position = Cartesian3_default.fromElements(
      position.z,
      position.x,
      position.y,
      result
    );
  }
  return position;
}
var scratchV0 = new Cartesian3_default();
var scratchV1 = new Cartesian3_default();
var scratchV2 = new Cartesian3_default();
GlobeSurfaceTile.prototype.pick = function(ray, mode2, projection, cullBackFaces, result) {
  const mesh2 = this.renderedMesh;
  if (!defined_default(mesh2)) {
    return void 0;
  }
  const vertices = mesh2.vertices;
  const indices2 = mesh2.indices;
  const encoding = mesh2.encoding;
  const indicesLength = indices2.length;
  let minT = Number.MAX_VALUE;
  for (let i2 = 0; i2 < indicesLength; i2 += 3) {
    const i0 = indices2[i2];
    const i1 = indices2[i2 + 1];
    const i22 = indices2[i2 + 2];
    const v02 = getPosition3(encoding, mode2, projection, vertices, i0, scratchV0);
    const v13 = getPosition3(encoding, mode2, projection, vertices, i1, scratchV1);
    const v23 = getPosition3(encoding, mode2, projection, vertices, i22, scratchV2);
    const t = IntersectionTests_default.rayTriangleParametric(
      ray,
      v02,
      v13,
      v23,
      cullBackFaces
    );
    if (defined_default(t) && t < minT && t >= 0) {
      minT = t;
    }
  }
  return minT !== Number.MAX_VALUE ? Ray_default.getPoint(ray, minT, result) : void 0;
};
GlobeSurfaceTile.prototype.freeResources = function() {
  if (defined_default(this.waterMaskTexture)) {
    --this.waterMaskTexture.referenceCount;
    if (this.waterMaskTexture.referenceCount === 0) {
      this.waterMaskTexture.destroy();
    }
    this.waterMaskTexture = void 0;
  }
  this.terrainData = void 0;
  this.terrainState = TerrainState_default.UNLOADED;
  this.mesh = void 0;
  this.fill = this.fill && this.fill.destroy();
  const imageryList = this.imagery;
  for (let i2 = 0, len = imageryList.length; i2 < len; ++i2) {
    imageryList[i2].freeResources();
  }
  this.imagery.length = 0;
  this.freeVertexArray();
};
GlobeSurfaceTile.prototype.freeVertexArray = function() {
  GlobeSurfaceTile._freeVertexArray(this.vertexArray);
  this.vertexArray = void 0;
  GlobeSurfaceTile._freeVertexArray(this.wireframeVertexArray);
  this.wireframeVertexArray = void 0;
};
GlobeSurfaceTile.initialize = function(tile, terrainProvider, imageryLayerCollection) {
  let surfaceTile = tile.data;
  if (!defined_default(surfaceTile)) {
    surfaceTile = tile.data = new GlobeSurfaceTile();
  }
  if (tile.state === QuadtreeTileLoadState_default.START) {
    prepareNewTile(tile, terrainProvider, imageryLayerCollection);
    tile.state = QuadtreeTileLoadState_default.LOADING;
  }
};
GlobeSurfaceTile.processStateMachine = function(tile, frameState, terrainProvider, imageryLayerCollection, quadtree, vertexArraysToDestroy, terrainOnly) {
  GlobeSurfaceTile.initialize(tile, terrainProvider, imageryLayerCollection);
  const surfaceTile = tile.data;
  if (tile.state === QuadtreeTileLoadState_default.LOADING) {
    processTerrainStateMachine(
      tile,
      frameState,
      terrainProvider,
      imageryLayerCollection,
      quadtree,
      vertexArraysToDestroy
    );
  }
  if (terrainOnly) {
    return;
  }
  const wasAlreadyRenderable = tile.renderable;
  tile.renderable = defined_default(surfaceTile.vertexArray);
  const isTerrainDoneLoading = surfaceTile.terrainState === TerrainState_default.READY;
  tile.upsampledFromParent = defined_default(surfaceTile.terrainData) && surfaceTile.terrainData.wasCreatedByUpsampling();
  const isImageryDoneLoading = surfaceTile.processImagery(
    tile,
    terrainProvider,
    frameState
  );
  if (isTerrainDoneLoading && isImageryDoneLoading) {
    const callbacks = tile._loadedCallbacks;
    const newCallbacks = {};
    for (const layerId in callbacks) {
      if (callbacks.hasOwnProperty(layerId)) {
        if (!callbacks[layerId](tile)) {
          newCallbacks[layerId] = callbacks[layerId];
        }
      }
    }
    tile._loadedCallbacks = newCallbacks;
    tile.state = QuadtreeTileLoadState_default.DONE;
  }
  if (wasAlreadyRenderable) {
    tile.renderable = true;
  }
};
GlobeSurfaceTile.prototype.processImagery = function(tile, terrainProvider, frameState, skipLoading) {
  const surfaceTile = tile.data;
  let isUpsampledOnly = tile.upsampledFromParent;
  let isAnyTileLoaded = false;
  let isDoneLoading = true;
  const tileImageryCollection = surfaceTile.imagery;
  let i2, len;
  for (i2 = 0, len = tileImageryCollection.length; i2 < len; ++i2) {
    const tileImagery = tileImageryCollection[i2];
    if (!defined_default(tileImagery.loadingImagery)) {
      isUpsampledOnly = false;
      continue;
    }
    if (tileImagery.loadingImagery.state === ImageryState_default.PLACEHOLDER) {
      const imageryLayer = tileImagery.loadingImagery.imageryLayer;
      if (imageryLayer.imageryProvider.ready) {
        tileImagery.freeResources();
        tileImageryCollection.splice(i2, 1);
        imageryLayer._createTileImagerySkeletons(tile, terrainProvider, i2);
        --i2;
        len = tileImageryCollection.length;
        continue;
      } else {
        isUpsampledOnly = false;
      }
    }
    const thisTileDoneLoading = tileImagery.processStateMachine(
      tile,
      frameState,
      skipLoading
    );
    isDoneLoading = isDoneLoading && thisTileDoneLoading;
    isAnyTileLoaded = isAnyTileLoaded || thisTileDoneLoading || defined_default(tileImagery.readyImagery);
    isUpsampledOnly = isUpsampledOnly && defined_default(tileImagery.loadingImagery) && (tileImagery.loadingImagery.state === ImageryState_default.FAILED || tileImagery.loadingImagery.state === ImageryState_default.INVALID);
  }
  tile.upsampledFromParent = isUpsampledOnly;
  tile.renderable = tile.renderable && (isAnyTileLoaded || isDoneLoading);
  return isDoneLoading;
};
function toggleGeodeticSurfaceNormals(surfaceTile, enabled, ellipsoid, frameState) {
  const renderedMesh = surfaceTile.renderedMesh;
  const vertexBuffer = renderedMesh.vertices;
  const encoding = renderedMesh.encoding;
  const vertexCount = vertexBuffer.length / encoding.stride;
  let newEncoding = TerrainEncoding_default.clone(encoding);
  newEncoding.hasGeodeticSurfaceNormals = enabled;
  newEncoding = TerrainEncoding_default.clone(newEncoding);
  const newStride = newEncoding.stride;
  const newVertexBuffer = new Float32Array(vertexCount * newStride);
  if (enabled) {
    encoding.addGeodeticSurfaceNormals(
      vertexBuffer,
      newVertexBuffer,
      ellipsoid
    );
  } else {
    encoding.removeGeodeticSurfaceNormals(vertexBuffer, newVertexBuffer);
  }
  renderedMesh.vertices = newVertexBuffer;
  renderedMesh.stride = newStride;
  const isFill = renderedMesh !== surfaceTile.mesh;
  if (isFill) {
    GlobeSurfaceTile._freeVertexArray(surfaceTile.fill.vertexArray);
    surfaceTile.fill.vertexArray = GlobeSurfaceTile._createVertexArrayForMesh(
      frameState.context,
      renderedMesh
    );
  } else {
    GlobeSurfaceTile._freeVertexArray(surfaceTile.vertexArray);
    surfaceTile.vertexArray = GlobeSurfaceTile._createVertexArrayForMesh(
      frameState.context,
      renderedMesh
    );
  }
  GlobeSurfaceTile._freeVertexArray(surfaceTile.wireframeVertexArray);
  surfaceTile.wireframeVertexArray = void 0;
}
GlobeSurfaceTile.prototype.addGeodeticSurfaceNormals = function(ellipsoid, frameState) {
  toggleGeodeticSurfaceNormals(this, true, ellipsoid, frameState);
};
GlobeSurfaceTile.prototype.removeGeodeticSurfaceNormals = function(frameState) {
  toggleGeodeticSurfaceNormals(this, false, void 0, frameState);
};
GlobeSurfaceTile.prototype.updateExaggeration = function(tile, frameState, quadtree) {
  const surfaceTile = this;
  const mesh2 = surfaceTile.renderedMesh;
  if (mesh2 === void 0) {
    return;
  }
  const exaggeration = frameState.terrainExaggeration;
  const exaggerationRelativeHeight = frameState.terrainExaggerationRelativeHeight;
  const hasExaggerationScale = exaggeration !== 1;
  const encoding = mesh2.encoding;
  const encodingExaggerationScaleChanged = encoding.exaggeration !== exaggeration;
  const encodingRelativeHeightChanged = encoding.exaggerationRelativeHeight !== exaggerationRelativeHeight;
  if (encodingExaggerationScaleChanged || encodingRelativeHeightChanged) {
    if (encodingExaggerationScaleChanged) {
      if (hasExaggerationScale && !encoding.hasGeodeticSurfaceNormals) {
        const ellipsoid = tile.tilingScheme.ellipsoid;
        surfaceTile.addGeodeticSurfaceNormals(ellipsoid, frameState);
      } else if (!hasExaggerationScale && encoding.hasGeodeticSurfaceNormals) {
        surfaceTile.removeGeodeticSurfaceNormals(frameState);
      }
    }
    encoding.exaggeration = exaggeration;
    encoding.exaggerationRelativeHeight = exaggerationRelativeHeight;
    if (quadtree !== void 0) {
      quadtree._tileToUpdateHeights.push(tile);
      const customData = tile.customData;
      const customDataLength = customData.length;
      for (let i2 = 0; i2 < customDataLength; i2++) {
        const data = customData[i2];
        data.level = -1;
      }
    }
  }
};
function prepareNewTile(tile, terrainProvider, imageryLayerCollection) {
  let available = terrainProvider.getTileDataAvailable(
    tile.x,
    tile.y,
    tile.level
  );
  if (!defined_default(available) && defined_default(tile.parent)) {
    const parent = tile.parent;
    const parentSurfaceTile = parent.data;
    if (defined_default(parentSurfaceTile) && defined_default(parentSurfaceTile.terrainData)) {
      available = parentSurfaceTile.terrainData.isChildAvailable(
        parent.x,
        parent.y,
        tile.x,
        tile.y
      );
    }
  }
  if (available === false) {
    tile.data.terrainState = TerrainState_default.FAILED;
  }
  for (let i2 = 0, len = imageryLayerCollection.length; i2 < len; ++i2) {
    const layer = imageryLayerCollection.get(i2);
    if (layer.show) {
      layer._createTileImagerySkeletons(tile, terrainProvider);
    }
  }
}
function processTerrainStateMachine(tile, frameState, terrainProvider, imageryLayerCollection, quadtree, vertexArraysToDestroy) {
  const surfaceTile = tile.data;
  const parent = tile.parent;
  if (surfaceTile.terrainState === TerrainState_default.FAILED && parent !== void 0) {
    const parentReady = parent.data !== void 0 && parent.data.terrainData !== void 0 && parent.data.terrainData.canUpsample !== false;
    if (!parentReady) {
      GlobeSurfaceTile.processStateMachine(
        parent,
        frameState,
        terrainProvider,
        imageryLayerCollection,
        quadtree,
        vertexArraysToDestroy,
        true
      );
    }
  }
  if (surfaceTile.terrainState === TerrainState_default.FAILED) {
    upsample(
      surfaceTile,
      tile,
      frameState,
      terrainProvider,
      tile.x,
      tile.y,
      tile.level
    );
  }
  if (surfaceTile.terrainState === TerrainState_default.UNLOADED) {
    requestTileGeometry2(
      surfaceTile,
      terrainProvider,
      tile.x,
      tile.y,
      tile.level
    );
  }
  if (surfaceTile.terrainState === TerrainState_default.RECEIVED) {
    transform3(
      surfaceTile,
      frameState,
      terrainProvider,
      tile.x,
      tile.y,
      tile.level
    );
  }
  if (surfaceTile.terrainState === TerrainState_default.TRANSFORMED) {
    createResources5(
      surfaceTile,
      frameState.context,
      terrainProvider,
      tile.x,
      tile.y,
      tile.level,
      vertexArraysToDestroy
    );
    surfaceTile.updateExaggeration(tile, frameState, quadtree);
  }
  if (surfaceTile.terrainState >= TerrainState_default.RECEIVED && surfaceTile.waterMaskTexture === void 0 && terrainProvider.hasWaterMask) {
    const terrainData = surfaceTile.terrainData;
    if (terrainData.waterMask !== void 0) {
      createWaterMaskTextureIfNeeded(frameState.context, surfaceTile);
    } else {
      const sourceTile = surfaceTile._findAncestorTileWithTerrainData(tile);
      if (defined_default(sourceTile) && defined_default(sourceTile.data.waterMaskTexture)) {
        surfaceTile.waterMaskTexture = sourceTile.data.waterMaskTexture;
        ++surfaceTile.waterMaskTexture.referenceCount;
        surfaceTile._computeWaterMaskTranslationAndScale(
          tile,
          sourceTile,
          surfaceTile.waterMaskTranslationAndScale
        );
      }
    }
  }
}
function upsample(surfaceTile, tile, frameState, terrainProvider, x, y, level) {
  const parent = tile.parent;
  if (!parent) {
    tile.state = QuadtreeTileLoadState_default.FAILED;
    return;
  }
  const sourceData = parent.data.terrainData;
  const sourceX = parent.x;
  const sourceY = parent.y;
  const sourceLevel = parent.level;
  if (!defined_default(sourceData)) {
    return;
  }
  const terrainDataPromise = sourceData.upsample(
    terrainProvider.tilingScheme,
    sourceX,
    sourceY,
    sourceLevel,
    x,
    y,
    level
  );
  if (!defined_default(terrainDataPromise)) {
    return;
  }
  surfaceTile.terrainState = TerrainState_default.RECEIVING;
  Promise.resolve(terrainDataPromise).then(function(terrainData) {
    surfaceTile.terrainData = terrainData;
    surfaceTile.terrainState = TerrainState_default.RECEIVED;
  }).catch(function() {
    surfaceTile.terrainState = TerrainState_default.FAILED;
  });
}
function requestTileGeometry2(surfaceTile, terrainProvider, x, y, level) {
  function success(terrainData) {
    surfaceTile.terrainData = terrainData;
    surfaceTile.terrainState = TerrainState_default.RECEIVED;
    surfaceTile.request = void 0;
  }
  function failure(error) {
    if (surfaceTile.request.state === RequestState_default.CANCELLED) {
      surfaceTile.terrainData = void 0;
      surfaceTile.terrainState = TerrainState_default.UNLOADED;
      surfaceTile.request = void 0;
      return;
    }
    surfaceTile.terrainState = TerrainState_default.FAILED;
    surfaceTile.request = void 0;
    const message = `Failed to obtain terrain tile X: ${x} Y: ${y} Level: ${level}. Error message: "${error}"`;
    terrainProvider._requestError = TileProviderError_default.handleError(
      terrainProvider._requestError,
      terrainProvider,
      terrainProvider.errorEvent,
      message,
      x,
      y,
      level,
      doRequest
    );
  }
  function doRequest() {
    const request = new Request_default({
      throttle: false,
      throttleByServer: true,
      type: RequestType_default.TERRAIN
    });
    surfaceTile.request = request;
    const requestPromise = terrainProvider.requestTileGeometry(
      x,
      y,
      level,
      request
    );
    if (defined_default(requestPromise)) {
      surfaceTile.terrainState = TerrainState_default.RECEIVING;
      Promise.resolve(requestPromise).then(function(terrainData) {
        success(terrainData);
      }).catch(function(e2) {
        failure(e2);
      });
    } else {
      surfaceTile.terrainState = TerrainState_default.UNLOADED;
      surfaceTile.request = void 0;
    }
  }
  doRequest();
}
var scratchCreateMeshOptions = {
  tilingScheme: void 0,
  x: 0,
  y: 0,
  level: 0,
  exaggeration: 1,
  exaggerationRelativeHeight: 0,
  throttle: true
};
function transform3(surfaceTile, frameState, terrainProvider, x, y, level) {
  const tilingScheme2 = terrainProvider.tilingScheme;
  const createMeshOptions = scratchCreateMeshOptions;
  createMeshOptions.tilingScheme = tilingScheme2;
  createMeshOptions.x = x;
  createMeshOptions.y = y;
  createMeshOptions.level = level;
  createMeshOptions.exaggeration = frameState.terrainExaggeration;
  createMeshOptions.exaggerationRelativeHeight = frameState.terrainExaggerationRelativeHeight;
  createMeshOptions.throttle = true;
  const terrainData = surfaceTile.terrainData;
  const meshPromise = terrainData.createMesh(createMeshOptions);
  if (!defined_default(meshPromise)) {
    return;
  }
  surfaceTile.terrainState = TerrainState_default.TRANSFORMING;
  Promise.resolve(meshPromise).then(function(mesh2) {
    surfaceTile.mesh = mesh2;
    surfaceTile.terrainState = TerrainState_default.TRANSFORMED;
  }).catch(function() {
    surfaceTile.terrainState = TerrainState_default.FAILED;
  });
}
GlobeSurfaceTile._createVertexArrayForMesh = function(context, mesh2) {
  const typedArray = mesh2.vertices;
  const buffer = Buffer_default.createVertexBuffer({
    context,
    typedArray,
    usage: BufferUsage_default.STATIC_DRAW
  });
  const attributes = mesh2.encoding.getAttributes(buffer);
  const indexBuffers = mesh2.indices.indexBuffers || {};
  let indexBuffer = indexBuffers[context.id];
  if (!defined_default(indexBuffer) || indexBuffer.isDestroyed()) {
    const indices2 = mesh2.indices;
    indexBuffer = Buffer_default.createIndexBuffer({
      context,
      typedArray: indices2,
      usage: BufferUsage_default.STATIC_DRAW,
      indexDatatype: IndexDatatype_default.fromSizeInBytes(indices2.BYTES_PER_ELEMENT)
    });
    indexBuffer.vertexArrayDestroyable = false;
    indexBuffer.referenceCount = 1;
    indexBuffers[context.id] = indexBuffer;
    mesh2.indices.indexBuffers = indexBuffers;
  } else {
    ++indexBuffer.referenceCount;
  }
  return new VertexArray_default({
    context,
    attributes,
    indexBuffer
  });
};
GlobeSurfaceTile._freeVertexArray = function(vertexArray) {
  if (defined_default(vertexArray)) {
    const indexBuffer = vertexArray.indexBuffer;
    if (!vertexArray.isDestroyed()) {
      vertexArray.destroy();
    }
    if (defined_default(indexBuffer) && !indexBuffer.isDestroyed() && defined_default(indexBuffer.referenceCount)) {
      --indexBuffer.referenceCount;
      if (indexBuffer.referenceCount === 0) {
        indexBuffer.destroy();
      }
    }
  }
};
function createResources5(surfaceTile, context, terrainProvider, x, y, level, vertexArraysToDestroy) {
  surfaceTile.vertexArray = GlobeSurfaceTile._createVertexArrayForMesh(
    context,
    surfaceTile.mesh
  );
  surfaceTile.terrainState = TerrainState_default.READY;
  surfaceTile.fill = surfaceTile.fill && surfaceTile.fill.destroy(vertexArraysToDestroy);
}
function getContextWaterMaskData(context) {
  let data = context.cache.tile_waterMaskData;
  if (!defined_default(data)) {
    const allWaterTexture = Texture_default.create({
      context,
      pixelFormat: PixelFormat_default.LUMINANCE,
      pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
      source: {
        arrayBufferView: new Uint8Array([255]),
        width: 1,
        height: 1
      }
    });
    allWaterTexture.referenceCount = 1;
    const sampler = new Sampler_default({
      wrapS: TextureWrap_default.CLAMP_TO_EDGE,
      wrapT: TextureWrap_default.CLAMP_TO_EDGE,
      minificationFilter: TextureMinificationFilter_default.LINEAR,
      magnificationFilter: TextureMagnificationFilter_default.LINEAR
    });
    data = {
      allWaterTexture,
      sampler,
      destroy: function() {
        this.allWaterTexture.destroy();
      }
    };
    context.cache.tile_waterMaskData = data;
  }
  return data;
}
function createWaterMaskTextureIfNeeded(context, surfaceTile) {
  const waterMask = surfaceTile.terrainData.waterMask;
  const waterMaskData = getContextWaterMaskData(context);
  let texture;
  const waterMaskLength = waterMask.length;
  if (waterMaskLength === 1) {
    if (waterMask[0] !== 0) {
      texture = waterMaskData.allWaterTexture;
    } else {
      return;
    }
  } else {
    const textureSize = Math.sqrt(waterMaskLength);
    texture = Texture_default.create({
      context,
      pixelFormat: PixelFormat_default.LUMINANCE,
      pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
      source: {
        width: textureSize,
        height: textureSize,
        arrayBufferView: waterMask
      },
      sampler: waterMaskData.sampler,
      flipY: false
    });
    texture.referenceCount = 0;
  }
  ++texture.referenceCount;
  surfaceTile.waterMaskTexture = texture;
  Cartesian4_default.fromElements(
    0,
    0,
    1,
    1,
    surfaceTile.waterMaskTranslationAndScale
  );
}
GlobeSurfaceTile.prototype._findAncestorTileWithTerrainData = function(tile) {
  let sourceTile = tile.parent;
  while (defined_default(sourceTile) && (!defined_default(sourceTile.data) || !defined_default(sourceTile.data.terrainData) || sourceTile.data.terrainData.wasCreatedByUpsampling())) {
    sourceTile = sourceTile.parent;
  }
  return sourceTile;
};
GlobeSurfaceTile.prototype._computeWaterMaskTranslationAndScale = function(tile, sourceTile, result) {
  const sourceTileRectangle = sourceTile.rectangle;
  const tileRectangle = tile.rectangle;
  const tileWidth = tileRectangle.width;
  const tileHeight = tileRectangle.height;
  const scaleX = tileWidth / sourceTileRectangle.width;
  const scaleY = tileHeight / sourceTileRectangle.height;
  result.x = scaleX * (tileRectangle.west - sourceTileRectangle.west) / tileWidth;
  result.y = scaleY * (tileRectangle.south - sourceTileRectangle.south) / tileHeight;
  result.z = scaleX;
  result.w = scaleY;
  return result;
};
var GlobeSurfaceTile_default = GlobeSurfaceTile;

// node_modules/cesium/Source/Shaders/ReprojectWebMercatorFS.js
var ReprojectWebMercatorFS_default = "uniform sampler2D u_texture;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    gl_FragColor = texture2D(u_texture, v_textureCoordinates);\n}\n";

// node_modules/cesium/Source/Shaders/ReprojectWebMercatorVS.js
var ReprojectWebMercatorVS_default = "attribute vec4 position;\nattribute float webMercatorT;\n\nuniform vec2 u_textureDimensions;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    v_textureCoordinates = vec2(position.x, webMercatorT);\n    gl_Position = czm_viewportOrthographic * (position * vec4(u_textureDimensions, 1.0, 1.0));\n}\n";

// node_modules/cesium/Source/Scene/Imagery.js
function Imagery(imageryLayer, x, y, level, rectangle) {
  this.imageryLayer = imageryLayer;
  this.x = x;
  this.y = y;
  this.level = level;
  this.request = void 0;
  if (level !== 0) {
    const parentX = x / 2 | 0;
    const parentY = y / 2 | 0;
    const parentLevel = level - 1;
    this.parent = imageryLayer.getImageryFromCache(
      parentX,
      parentY,
      parentLevel
    );
  }
  this.state = ImageryState_default.UNLOADED;
  this.imageUrl = void 0;
  this.image = void 0;
  this.texture = void 0;
  this.textureWebMercator = void 0;
  this.credits = void 0;
  this.referenceCount = 0;
  if (!defined_default(rectangle) && imageryLayer.imageryProvider.ready) {
    const tilingScheme2 = imageryLayer.imageryProvider.tilingScheme;
    rectangle = tilingScheme2.tileXYToRectangle(x, y, level);
  }
  this.rectangle = rectangle;
}
Imagery.createPlaceholder = function(imageryLayer) {
  const result = new Imagery(imageryLayer, 0, 0, 0);
  result.addReference();
  result.state = ImageryState_default.PLACEHOLDER;
  return result;
};
Imagery.prototype.addReference = function() {
  ++this.referenceCount;
};
Imagery.prototype.releaseReference = function() {
  --this.referenceCount;
  if (this.referenceCount === 0) {
    this.imageryLayer.removeImageryFromCache(this);
    if (defined_default(this.parent)) {
      this.parent.releaseReference();
    }
    if (defined_default(this.image) && defined_default(this.image.destroy)) {
      this.image.destroy();
    }
    if (defined_default(this.texture)) {
      this.texture.destroy();
    }
    if (defined_default(this.textureWebMercator) && this.texture !== this.textureWebMercator) {
      this.textureWebMercator.destroy();
    }
    destroyObject_default(this);
    return 0;
  }
  return this.referenceCount;
};
Imagery.prototype.processStateMachine = function(frameState, needGeographicProjection, skipLoading) {
  if (this.state === ImageryState_default.UNLOADED && !skipLoading) {
    this.state = ImageryState_default.TRANSITIONING;
    this.imageryLayer._requestImagery(this);
  }
  if (this.state === ImageryState_default.RECEIVED) {
    this.state = ImageryState_default.TRANSITIONING;
    this.imageryLayer._createTexture(frameState.context, this);
  }
  const needsReprojection = this.state === ImageryState_default.READY && needGeographicProjection && !this.texture;
  if (this.state === ImageryState_default.TEXTURE_LOADED || needsReprojection) {
    this.state = ImageryState_default.TRANSITIONING;
    this.imageryLayer._reprojectTexture(
      frameState,
      this,
      needGeographicProjection
    );
  }
};
var Imagery_default = Imagery;

// node_modules/cesium/Source/Scene/TileImagery.js
function TileImagery(imagery, textureCoordinateRectangle, useWebMercatorT) {
  this.readyImagery = void 0;
  this.loadingImagery = imagery;
  this.textureCoordinateRectangle = textureCoordinateRectangle;
  this.textureTranslationAndScale = void 0;
  this.useWebMercatorT = useWebMercatorT;
}
TileImagery.prototype.freeResources = function() {
  if (defined_default(this.readyImagery)) {
    this.readyImagery.releaseReference();
  }
  if (defined_default(this.loadingImagery)) {
    this.loadingImagery.releaseReference();
  }
};
TileImagery.prototype.processStateMachine = function(tile, frameState, skipLoading) {
  const loadingImagery = this.loadingImagery;
  const imageryLayer = loadingImagery.imageryLayer;
  loadingImagery.processStateMachine(
    frameState,
    !this.useWebMercatorT,
    skipLoading
  );
  if (loadingImagery.state === ImageryState_default.READY) {
    if (defined_default(this.readyImagery)) {
      this.readyImagery.releaseReference();
    }
    this.readyImagery = this.loadingImagery;
    this.loadingImagery = void 0;
    this.textureTranslationAndScale = imageryLayer._calculateTextureTranslationAndScale(
      tile,
      this
    );
    return true;
  }
  let ancestor = loadingImagery.parent;
  let closestAncestorThatNeedsLoading;
  while (defined_default(ancestor) && (ancestor.state !== ImageryState_default.READY || !this.useWebMercatorT && !defined_default(ancestor.texture))) {
    if (ancestor.state !== ImageryState_default.FAILED && ancestor.state !== ImageryState_default.INVALID) {
      closestAncestorThatNeedsLoading = closestAncestorThatNeedsLoading || ancestor;
    }
    ancestor = ancestor.parent;
  }
  if (this.readyImagery !== ancestor) {
    if (defined_default(this.readyImagery)) {
      this.readyImagery.releaseReference();
    }
    this.readyImagery = ancestor;
    if (defined_default(ancestor)) {
      ancestor.addReference();
      this.textureTranslationAndScale = imageryLayer._calculateTextureTranslationAndScale(
        tile,
        this
      );
    }
  }
  if (loadingImagery.state === ImageryState_default.FAILED || loadingImagery.state === ImageryState_default.INVALID) {
    if (defined_default(closestAncestorThatNeedsLoading)) {
      closestAncestorThatNeedsLoading.processStateMachine(
        frameState,
        !this.useWebMercatorT,
        skipLoading
      );
      return false;
    }
    return true;
  }
  return false;
};
var TileImagery_default = TileImagery;

// node_modules/cesium/Source/Scene/ImageryLayer.js
function ImageryLayer(imageryProvider, options) {
  this._imageryProvider = imageryProvider;
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.alpha = defaultValue_default(
    options.alpha,
    defaultValue_default(imageryProvider.defaultAlpha, 1)
  );
  this.nightAlpha = defaultValue_default(
    options.nightAlpha,
    defaultValue_default(imageryProvider.defaultNightAlpha, 1)
  );
  this.dayAlpha = defaultValue_default(
    options.dayAlpha,
    defaultValue_default(imageryProvider.defaultDayAlpha, 1)
  );
  this.brightness = defaultValue_default(
    options.brightness,
    defaultValue_default(
      imageryProvider.defaultBrightness,
      ImageryLayer.DEFAULT_BRIGHTNESS
    )
  );
  this.contrast = defaultValue_default(
    options.contrast,
    defaultValue_default(imageryProvider.defaultContrast, ImageryLayer.DEFAULT_CONTRAST)
  );
  this.hue = defaultValue_default(
    options.hue,
    defaultValue_default(imageryProvider.defaultHue, ImageryLayer.DEFAULT_HUE)
  );
  this.saturation = defaultValue_default(
    options.saturation,
    defaultValue_default(
      imageryProvider.defaultSaturation,
      ImageryLayer.DEFAULT_SATURATION
    )
  );
  this.gamma = defaultValue_default(
    options.gamma,
    defaultValue_default(imageryProvider.defaultGamma, ImageryLayer.DEFAULT_GAMMA)
  );
  this.splitDirection = defaultValue_default(
    options.splitDirection,
    defaultValue_default(imageryProvider.defaultSplit, ImageryLayer.DEFAULT_SPLIT)
  );
  this.minificationFilter = defaultValue_default(
    options.minificationFilter,
    defaultValue_default(
      imageryProvider.defaultMinificationFilter,
      ImageryLayer.DEFAULT_MINIFICATION_FILTER
    )
  );
  this.magnificationFilter = defaultValue_default(
    options.magnificationFilter,
    defaultValue_default(
      imageryProvider.defaultMagnificationFilter,
      ImageryLayer.DEFAULT_MAGNIFICATION_FILTER
    )
  );
  this.show = defaultValue_default(options.show, true);
  this._minimumTerrainLevel = options.minimumTerrainLevel;
  this._maximumTerrainLevel = options.maximumTerrainLevel;
  this._rectangle = defaultValue_default(options.rectangle, Rectangle_default.MAX_VALUE);
  this._maximumAnisotropy = options.maximumAnisotropy;
  this._imageryCache = {};
  this._skeletonPlaceholder = new TileImagery_default(Imagery_default.createPlaceholder(this));
  this._show = true;
  this._layerIndex = -1;
  this._isBaseLayer = false;
  this._requestImageError = void 0;
  this._reprojectComputeCommands = [];
  this.cutoutRectangle = options.cutoutRectangle;
  this.colorToAlpha = options.colorToAlpha;
  this.colorToAlphaThreshold = defaultValue_default(
    options.colorToAlphaThreshold,
    ImageryLayer.DEFAULT_APPLY_COLOR_TO_ALPHA_THRESHOLD
  );
}
Object.defineProperties(ImageryLayer.prototype, {
  imageryProvider: {
    get: function() {
      return this._imageryProvider;
    }
  },
  rectangle: {
    get: function() {
      return this._rectangle;
    }
  }
});
ImageryLayer.DEFAULT_BRIGHTNESS = 1;
ImageryLayer.DEFAULT_CONTRAST = 1;
ImageryLayer.DEFAULT_HUE = 0;
ImageryLayer.DEFAULT_SATURATION = 1;
ImageryLayer.DEFAULT_GAMMA = 1;
ImageryLayer.DEFAULT_SPLIT = SplitDirection_default.NONE;
ImageryLayer.DEFAULT_MINIFICATION_FILTER = TextureMinificationFilter_default.LINEAR;
ImageryLayer.DEFAULT_MAGNIFICATION_FILTER = TextureMagnificationFilter_default.LINEAR;
ImageryLayer.DEFAULT_APPLY_COLOR_TO_ALPHA_THRESHOLD = 4e-3;
ImageryLayer.prototype.isBaseLayer = function() {
  return this._isBaseLayer;
};
ImageryLayer.prototype.isDestroyed = function() {
  return false;
};
ImageryLayer.prototype.destroy = function() {
  return destroyObject_default(this);
};
var imageryBoundsScratch = new Rectangle_default();
var tileImageryBoundsScratch = new Rectangle_default();
var clippedRectangleScratch = new Rectangle_default();
var terrainRectangleScratch = new Rectangle_default();
ImageryLayer.prototype.getViewableRectangle = function() {
  const imageryProvider = this._imageryProvider;
  const rectangle = this._rectangle;
  return imageryProvider.readyPromise.then(function() {
    return Rectangle_default.intersection(imageryProvider.rectangle, rectangle);
  });
};
ImageryLayer.prototype._createTileImagerySkeletons = function(tile, terrainProvider, insertionPoint) {
  const surfaceTile = tile.data;
  if (defined_default(this._minimumTerrainLevel) && tile.level < this._minimumTerrainLevel) {
    return false;
  }
  if (defined_default(this._maximumTerrainLevel) && tile.level > this._maximumTerrainLevel) {
    return false;
  }
  const imageryProvider = this._imageryProvider;
  if (!defined_default(insertionPoint)) {
    insertionPoint = surfaceTile.imagery.length;
  }
  if (!imageryProvider.ready) {
    this._skeletonPlaceholder.loadingImagery.addReference();
    surfaceTile.imagery.splice(insertionPoint, 0, this._skeletonPlaceholder);
    return true;
  }
  const useWebMercatorT = imageryProvider.tilingScheme.projection instanceof WebMercatorProjection_default && tile.rectangle.north < WebMercatorProjection_default.MaximumLatitude && tile.rectangle.south > -WebMercatorProjection_default.MaximumLatitude;
  const imageryBounds = Rectangle_default.intersection(
    imageryProvider.rectangle,
    this._rectangle,
    imageryBoundsScratch
  );
  let rectangle = Rectangle_default.intersection(
    tile.rectangle,
    imageryBounds,
    tileImageryBoundsScratch
  );
  if (!defined_default(rectangle)) {
    if (!this.isBaseLayer()) {
      return false;
    }
    const baseImageryRectangle = imageryBounds;
    const baseTerrainRectangle = tile.rectangle;
    rectangle = tileImageryBoundsScratch;
    if (baseTerrainRectangle.south >= baseImageryRectangle.north) {
      rectangle.north = rectangle.south = baseImageryRectangle.north;
    } else if (baseTerrainRectangle.north <= baseImageryRectangle.south) {
      rectangle.north = rectangle.south = baseImageryRectangle.south;
    } else {
      rectangle.south = Math.max(
        baseTerrainRectangle.south,
        baseImageryRectangle.south
      );
      rectangle.north = Math.min(
        baseTerrainRectangle.north,
        baseImageryRectangle.north
      );
    }
    if (baseTerrainRectangle.west >= baseImageryRectangle.east) {
      rectangle.west = rectangle.east = baseImageryRectangle.east;
    } else if (baseTerrainRectangle.east <= baseImageryRectangle.west) {
      rectangle.west = rectangle.east = baseImageryRectangle.west;
    } else {
      rectangle.west = Math.max(
        baseTerrainRectangle.west,
        baseImageryRectangle.west
      );
      rectangle.east = Math.min(
        baseTerrainRectangle.east,
        baseImageryRectangle.east
      );
    }
  }
  let latitudeClosestToEquator = 0;
  if (rectangle.south > 0) {
    latitudeClosestToEquator = rectangle.south;
  } else if (rectangle.north < 0) {
    latitudeClosestToEquator = rectangle.north;
  }
  const errorRatio = 1;
  const targetGeometricError = errorRatio * terrainProvider.getLevelMaximumGeometricError(tile.level);
  let imageryLevel = getLevelWithMaximumTexelSpacing(
    this,
    targetGeometricError,
    latitudeClosestToEquator
  );
  imageryLevel = Math.max(0, imageryLevel);
  const maximumLevel = imageryProvider.maximumLevel;
  if (imageryLevel > maximumLevel) {
    imageryLevel = maximumLevel;
  }
  if (defined_default(imageryProvider.minimumLevel)) {
    const minimumLevel = imageryProvider.minimumLevel;
    if (imageryLevel < minimumLevel) {
      imageryLevel = minimumLevel;
    }
  }
  const imageryTilingScheme = imageryProvider.tilingScheme;
  const northwestTileCoordinates = imageryTilingScheme.positionToTileXY(
    Rectangle_default.northwest(rectangle),
    imageryLevel
  );
  const southeastTileCoordinates = imageryTilingScheme.positionToTileXY(
    Rectangle_default.southeast(rectangle),
    imageryLevel
  );
  let veryCloseX = tile.rectangle.width / 512;
  let veryCloseY = tile.rectangle.height / 512;
  const northwestTileRectangle = imageryTilingScheme.tileXYToRectangle(
    northwestTileCoordinates.x,
    northwestTileCoordinates.y,
    imageryLevel
  );
  if (Math.abs(northwestTileRectangle.south - tile.rectangle.north) < veryCloseY && northwestTileCoordinates.y < southeastTileCoordinates.y) {
    ++northwestTileCoordinates.y;
  }
  if (Math.abs(northwestTileRectangle.east - tile.rectangle.west) < veryCloseX && northwestTileCoordinates.x < southeastTileCoordinates.x) {
    ++northwestTileCoordinates.x;
  }
  const southeastTileRectangle = imageryTilingScheme.tileXYToRectangle(
    southeastTileCoordinates.x,
    southeastTileCoordinates.y,
    imageryLevel
  );
  if (Math.abs(southeastTileRectangle.north - tile.rectangle.south) < veryCloseY && southeastTileCoordinates.y > northwestTileCoordinates.y) {
    --southeastTileCoordinates.y;
  }
  if (Math.abs(southeastTileRectangle.west - tile.rectangle.east) < veryCloseX && southeastTileCoordinates.x > northwestTileCoordinates.x) {
    --southeastTileCoordinates.x;
  }
  const terrainRectangle = Rectangle_default.clone(
    tile.rectangle,
    terrainRectangleScratch
  );
  let imageryRectangle = imageryTilingScheme.tileXYToRectangle(
    northwestTileCoordinates.x,
    northwestTileCoordinates.y,
    imageryLevel
  );
  let clippedImageryRectangle = Rectangle_default.intersection(
    imageryRectangle,
    imageryBounds,
    clippedRectangleScratch
  );
  let imageryTileXYToRectangle;
  if (useWebMercatorT) {
    imageryTilingScheme.rectangleToNativeRectangle(
      terrainRectangle,
      terrainRectangle
    );
    imageryTilingScheme.rectangleToNativeRectangle(
      imageryRectangle,
      imageryRectangle
    );
    imageryTilingScheme.rectangleToNativeRectangle(
      clippedImageryRectangle,
      clippedImageryRectangle
    );
    imageryTilingScheme.rectangleToNativeRectangle(
      imageryBounds,
      imageryBounds
    );
    imageryTileXYToRectangle = imageryTilingScheme.tileXYToNativeRectangle.bind(
      imageryTilingScheme
    );
    veryCloseX = terrainRectangle.width / 512;
    veryCloseY = terrainRectangle.height / 512;
  } else {
    imageryTileXYToRectangle = imageryTilingScheme.tileXYToRectangle.bind(
      imageryTilingScheme
    );
  }
  let minU;
  let maxU = 0;
  let minV = 1;
  let maxV;
  if (!this.isBaseLayer() && Math.abs(clippedImageryRectangle.west - terrainRectangle.west) >= veryCloseX) {
    maxU = Math.min(
      1,
      (clippedImageryRectangle.west - terrainRectangle.west) / terrainRectangle.width
    );
  }
  if (!this.isBaseLayer() && Math.abs(clippedImageryRectangle.north - terrainRectangle.north) >= veryCloseY) {
    minV = Math.max(
      0,
      (clippedImageryRectangle.north - terrainRectangle.south) / terrainRectangle.height
    );
  }
  const initialMinV = minV;
  for (let i2 = northwestTileCoordinates.x; i2 <= southeastTileCoordinates.x; i2++) {
    minU = maxU;
    imageryRectangle = imageryTileXYToRectangle(
      i2,
      northwestTileCoordinates.y,
      imageryLevel
    );
    clippedImageryRectangle = Rectangle_default.simpleIntersection(
      imageryRectangle,
      imageryBounds,
      clippedRectangleScratch
    );
    if (!defined_default(clippedImageryRectangle)) {
      continue;
    }
    maxU = Math.min(
      1,
      (clippedImageryRectangle.east - terrainRectangle.west) / terrainRectangle.width
    );
    if (i2 === southeastTileCoordinates.x && (this.isBaseLayer() || Math.abs(clippedImageryRectangle.east - terrainRectangle.east) < veryCloseX)) {
      maxU = 1;
    }
    minV = initialMinV;
    for (let j = northwestTileCoordinates.y; j <= southeastTileCoordinates.y; j++) {
      maxV = minV;
      imageryRectangle = imageryTileXYToRectangle(i2, j, imageryLevel);
      clippedImageryRectangle = Rectangle_default.simpleIntersection(
        imageryRectangle,
        imageryBounds,
        clippedRectangleScratch
      );
      if (!defined_default(clippedImageryRectangle)) {
        continue;
      }
      minV = Math.max(
        0,
        (clippedImageryRectangle.south - terrainRectangle.south) / terrainRectangle.height
      );
      if (j === southeastTileCoordinates.y && (this.isBaseLayer() || Math.abs(clippedImageryRectangle.south - terrainRectangle.south) < veryCloseY)) {
        minV = 0;
      }
      const texCoordsRectangle = new Cartesian4_default(minU, minV, maxU, maxV);
      const imagery = this.getImageryFromCache(i2, j, imageryLevel);
      surfaceTile.imagery.splice(
        insertionPoint,
        0,
        new TileImagery_default(imagery, texCoordsRectangle, useWebMercatorT)
      );
      ++insertionPoint;
    }
  }
  return true;
};
ImageryLayer.prototype._calculateTextureTranslationAndScale = function(tile, tileImagery) {
  let imageryRectangle = tileImagery.readyImagery.rectangle;
  let terrainRectangle = tile.rectangle;
  if (tileImagery.useWebMercatorT) {
    const tilingScheme2 = tileImagery.readyImagery.imageryLayer.imageryProvider.tilingScheme;
    imageryRectangle = tilingScheme2.rectangleToNativeRectangle(
      imageryRectangle,
      imageryBoundsScratch
    );
    terrainRectangle = tilingScheme2.rectangleToNativeRectangle(
      terrainRectangle,
      terrainRectangleScratch
    );
  }
  const terrainWidth = terrainRectangle.width;
  const terrainHeight = terrainRectangle.height;
  const scaleX = terrainWidth / imageryRectangle.width;
  const scaleY = terrainHeight / imageryRectangle.height;
  return new Cartesian4_default(
    scaleX * (terrainRectangle.west - imageryRectangle.west) / terrainWidth,
    scaleY * (terrainRectangle.south - imageryRectangle.south) / terrainHeight,
    scaleX,
    scaleY
  );
};
ImageryLayer.prototype._requestImagery = function(imagery) {
  const imageryProvider = this._imageryProvider;
  const that = this;
  function success(image) {
    if (!defined_default(image)) {
      return failure();
    }
    imagery.image = image;
    imagery.state = ImageryState_default.RECEIVED;
    imagery.request = void 0;
    TileProviderError_default.handleSuccess(that._requestImageError);
  }
  function failure(e2) {
    if (imagery.request.state === RequestState_default.CANCELLED) {
      imagery.state = ImageryState_default.UNLOADED;
      imagery.request = void 0;
      return;
    }
    imagery.state = ImageryState_default.FAILED;
    imagery.request = void 0;
    const message = `Failed to obtain image tile X: ${imagery.x} Y: ${imagery.y} Level: ${imagery.level}.`;
    that._requestImageError = TileProviderError_default.handleError(
      that._requestImageError,
      imageryProvider,
      imageryProvider.errorEvent,
      message,
      imagery.x,
      imagery.y,
      imagery.level,
      doRequest,
      e2
    );
  }
  function doRequest() {
    const request = new Request_default({
      throttle: false,
      throttleByServer: true,
      type: RequestType_default.IMAGERY
    });
    imagery.request = request;
    imagery.state = ImageryState_default.TRANSITIONING;
    const imagePromise = imageryProvider.requestImage(
      imagery.x,
      imagery.y,
      imagery.level,
      request
    );
    if (!defined_default(imagePromise)) {
      imagery.state = ImageryState_default.UNLOADED;
      imagery.request = void 0;
      return;
    }
    if (defined_default(imageryProvider.getTileCredits)) {
      imagery.credits = imageryProvider.getTileCredits(
        imagery.x,
        imagery.y,
        imagery.level
      );
    }
    imagePromise.then(function(image) {
      success(image);
    }).catch(function(e2) {
      failure(e2);
    });
  }
  doRequest();
};
ImageryLayer.prototype._createTextureWebGL = function(context, imagery) {
  const sampler = new Sampler_default({
    minificationFilter: this.minificationFilter,
    magnificationFilter: this.magnificationFilter
  });
  const image = imagery.image;
  if (defined_default(image.internalFormat)) {
    return new Texture_default({
      context,
      pixelFormat: image.internalFormat,
      width: image.width,
      height: image.height,
      source: {
        arrayBufferView: image.bufferView
      },
      sampler
    });
  }
  return new Texture_default({
    context,
    source: image,
    pixelFormat: this._imageryProvider.hasAlphaChannel ? PixelFormat_default.RGBA : PixelFormat_default.RGB,
    sampler
  });
};
ImageryLayer.prototype._createTexture = function(context, imagery) {
  const imageryProvider = this._imageryProvider;
  const image = imagery.image;
  if (defined_default(imageryProvider.tileDiscardPolicy)) {
    const discardPolicy = imageryProvider.tileDiscardPolicy;
    if (defined_default(discardPolicy)) {
      if (!discardPolicy.isReady()) {
        imagery.state = ImageryState_default.RECEIVED;
        return;
      }
      if (discardPolicy.shouldDiscardImage(image)) {
        imagery.state = ImageryState_default.INVALID;
        return;
      }
    }
  }
  if (this.minificationFilter !== TextureMinificationFilter_default.NEAREST && this.minificationFilter !== TextureMinificationFilter_default.LINEAR) {
    throw new DeveloperError_default(
      "ImageryLayer minification filter must be NEAREST or LINEAR"
    );
  }
  const texture = this._createTextureWebGL(context, imagery);
  if (imageryProvider.tilingScheme.projection instanceof WebMercatorProjection_default) {
    imagery.textureWebMercator = texture;
  } else {
    imagery.texture = texture;
  }
  imagery.image = void 0;
  imagery.state = ImageryState_default.TEXTURE_LOADED;
};
function getSamplerKey(minificationFilter, magnificationFilter, maximumAnisotropy) {
  return `${minificationFilter}:${magnificationFilter}:${maximumAnisotropy}`;
}
ImageryLayer.prototype._finalizeReprojectTexture = function(context, texture) {
  let minificationFilter = this.minificationFilter;
  const magnificationFilter = this.magnificationFilter;
  const usesLinearTextureFilter = minificationFilter === TextureMinificationFilter_default.LINEAR && magnificationFilter === TextureMagnificationFilter_default.LINEAR;
  if (usesLinearTextureFilter && !PixelFormat_default.isCompressedFormat(texture.pixelFormat) && Math_default.isPowerOfTwo(texture.width) && Math_default.isPowerOfTwo(texture.height)) {
    minificationFilter = TextureMinificationFilter_default.LINEAR_MIPMAP_LINEAR;
    const maximumSupportedAnisotropy = ContextLimits_default.maximumTextureFilterAnisotropy;
    const maximumAnisotropy = Math.min(
      maximumSupportedAnisotropy,
      defaultValue_default(this._maximumAnisotropy, maximumSupportedAnisotropy)
    );
    const mipmapSamplerKey = getSamplerKey(
      minificationFilter,
      magnificationFilter,
      maximumAnisotropy
    );
    let mipmapSamplers = context.cache.imageryLayerMipmapSamplers;
    if (!defined_default(mipmapSamplers)) {
      mipmapSamplers = {};
      context.cache.imageryLayerMipmapSamplers = mipmapSamplers;
    }
    let mipmapSampler = mipmapSamplers[mipmapSamplerKey];
    if (!defined_default(mipmapSampler)) {
      mipmapSampler = mipmapSamplers[mipmapSamplerKey] = new Sampler_default({
        wrapS: TextureWrap_default.CLAMP_TO_EDGE,
        wrapT: TextureWrap_default.CLAMP_TO_EDGE,
        minificationFilter,
        magnificationFilter,
        maximumAnisotropy
      });
    }
    texture.generateMipmap(MipmapHint_default.NICEST);
    texture.sampler = mipmapSampler;
  } else {
    const nonMipmapSamplerKey = getSamplerKey(
      minificationFilter,
      magnificationFilter,
      0
    );
    let nonMipmapSamplers = context.cache.imageryLayerNonMipmapSamplers;
    if (!defined_default(nonMipmapSamplers)) {
      nonMipmapSamplers = {};
      context.cache.imageryLayerNonMipmapSamplers = nonMipmapSamplers;
    }
    let nonMipmapSampler = nonMipmapSamplers[nonMipmapSamplerKey];
    if (!defined_default(nonMipmapSampler)) {
      nonMipmapSampler = nonMipmapSamplers[nonMipmapSamplerKey] = new Sampler_default({
        wrapS: TextureWrap_default.CLAMP_TO_EDGE,
        wrapT: TextureWrap_default.CLAMP_TO_EDGE,
        minificationFilter,
        magnificationFilter
      });
    }
    texture.sampler = nonMipmapSampler;
  }
};
ImageryLayer.prototype._reprojectTexture = function(frameState, imagery, needGeographicProjection) {
  const texture = imagery.textureWebMercator || imagery.texture;
  const rectangle = imagery.rectangle;
  const context = frameState.context;
  needGeographicProjection = defaultValue_default(needGeographicProjection, true);
  if (needGeographicProjection && !(this._imageryProvider.tilingScheme.projection instanceof GeographicProjection_default) && rectangle.width / texture.width > 1e-5) {
    const that = this;
    imagery.addReference();
    const computeCommand = new ComputeCommand_default({
      persists: true,
      owner: this,
      preExecute: function(command) {
        reprojectToGeographic(command, context, texture, imagery.rectangle);
      },
      postExecute: function(outputTexture) {
        imagery.texture = outputTexture;
        that._finalizeReprojectTexture(context, outputTexture);
        imagery.state = ImageryState_default.READY;
        imagery.releaseReference();
      },
      canceled: function() {
        imagery.state = ImageryState_default.TEXTURE_LOADED;
        imagery.releaseReference();
      }
    });
    this._reprojectComputeCommands.push(computeCommand);
  } else {
    if (needGeographicProjection) {
      imagery.texture = texture;
    }
    this._finalizeReprojectTexture(context, texture);
    imagery.state = ImageryState_default.READY;
  }
};
ImageryLayer.prototype.queueReprojectionCommands = function(frameState) {
  const computeCommands = this._reprojectComputeCommands;
  const length3 = computeCommands.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    frameState.commandList.push(computeCommands[i2]);
  }
  computeCommands.length = 0;
};
ImageryLayer.prototype.cancelReprojections = function() {
  this._reprojectComputeCommands.forEach(function(command) {
    if (defined_default(command.canceled)) {
      command.canceled();
    }
  });
  this._reprojectComputeCommands.length = 0;
};
ImageryLayer.prototype.getImageryFromCache = function(x, y, level, imageryRectangle) {
  const cacheKey = getImageryCacheKey(x, y, level);
  let imagery = this._imageryCache[cacheKey];
  if (!defined_default(imagery)) {
    imagery = new Imagery_default(this, x, y, level, imageryRectangle);
    this._imageryCache[cacheKey] = imagery;
  }
  imagery.addReference();
  return imagery;
};
ImageryLayer.prototype.removeImageryFromCache = function(imagery) {
  const cacheKey = getImageryCacheKey(imagery.x, imagery.y, imagery.level);
  delete this._imageryCache[cacheKey];
};
function getImageryCacheKey(x, y, level) {
  return JSON.stringify([x, y, level]);
}
var uniformMap = {
  u_textureDimensions: function() {
    return this.textureDimensions;
  },
  u_texture: function() {
    return this.texture;
  },
  textureDimensions: new Cartesian2_default(),
  texture: void 0
};
var float32ArrayScratch = FeatureDetection_default.supportsTypedArrays() ? new Float32Array(2 * 64) : void 0;
function reprojectToGeographic(command, context, texture, rectangle) {
  let reproject = context.cache.imageryLayer_reproject;
  if (!defined_default(reproject)) {
    reproject = context.cache.imageryLayer_reproject = {
      vertexArray: void 0,
      shaderProgram: void 0,
      sampler: void 0,
      destroy: function() {
        if (defined_default(this.framebuffer)) {
          this.framebuffer.destroy();
        }
        if (defined_default(this.vertexArray)) {
          this.vertexArray.destroy();
        }
        if (defined_default(this.shaderProgram)) {
          this.shaderProgram.destroy();
        }
      }
    };
    const positions = new Float32Array(2 * 64 * 2);
    let index2 = 0;
    for (let j = 0; j < 64; ++j) {
      const y = j / 63;
      positions[index2++] = 0;
      positions[index2++] = y;
      positions[index2++] = 1;
      positions[index2++] = y;
    }
    const reprojectAttributeIndices = {
      position: 0,
      webMercatorT: 1
    };
    const indices2 = TerrainProvider_default.getRegularGridIndices(2, 64);
    const indexBuffer = Buffer_default.createIndexBuffer({
      context,
      typedArray: indices2,
      usage: BufferUsage_default.STATIC_DRAW,
      indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
    });
    reproject.vertexArray = new VertexArray_default({
      context,
      attributes: [
        {
          index: reprojectAttributeIndices.position,
          vertexBuffer: Buffer_default.createVertexBuffer({
            context,
            typedArray: positions,
            usage: BufferUsage_default.STATIC_DRAW
          }),
          componentsPerAttribute: 2
        },
        {
          index: reprojectAttributeIndices.webMercatorT,
          vertexBuffer: Buffer_default.createVertexBuffer({
            context,
            sizeInBytes: 64 * 2 * 4,
            usage: BufferUsage_default.STREAM_DRAW
          }),
          componentsPerAttribute: 1
        }
      ],
      indexBuffer
    });
    const vs = new ShaderSource_default({
      sources: [ReprojectWebMercatorVS_default]
    });
    reproject.shaderProgram = ShaderProgram_default.fromCache({
      context,
      vertexShaderSource: vs,
      fragmentShaderSource: ReprojectWebMercatorFS_default,
      attributeLocations: reprojectAttributeIndices
    });
    reproject.sampler = new Sampler_default({
      wrapS: TextureWrap_default.CLAMP_TO_EDGE,
      wrapT: TextureWrap_default.CLAMP_TO_EDGE,
      minificationFilter: TextureMinificationFilter_default.LINEAR,
      magnificationFilter: TextureMagnificationFilter_default.LINEAR
    });
  }
  texture.sampler = reproject.sampler;
  const width = texture.width;
  const height = texture.height;
  uniformMap.textureDimensions.x = width;
  uniformMap.textureDimensions.y = height;
  uniformMap.texture = texture;
  let sinLatitude = Math.sin(rectangle.south);
  const southMercatorY = 0.5 * Math.log((1 + sinLatitude) / (1 - sinLatitude));
  sinLatitude = Math.sin(rectangle.north);
  const northMercatorY = 0.5 * Math.log((1 + sinLatitude) / (1 - sinLatitude));
  const oneOverMercatorHeight = 1 / (northMercatorY - southMercatorY);
  const outputTexture = new Texture_default({
    context,
    width,
    height,
    pixelFormat: texture.pixelFormat,
    pixelDatatype: texture.pixelDatatype,
    preMultiplyAlpha: texture.preMultiplyAlpha
  });
  if (Math_default.isPowerOfTwo(width) && Math_default.isPowerOfTwo(height)) {
    outputTexture.generateMipmap(MipmapHint_default.NICEST);
  }
  const south = rectangle.south;
  const north = rectangle.north;
  const webMercatorT = float32ArrayScratch;
  let outputIndex = 0;
  for (let webMercatorTIndex = 0; webMercatorTIndex < 64; ++webMercatorTIndex) {
    const fraction = webMercatorTIndex / 63;
    const latitude = Math_default.lerp(south, north, fraction);
    sinLatitude = Math.sin(latitude);
    const mercatorY = 0.5 * Math.log((1 + sinLatitude) / (1 - sinLatitude));
    const mercatorFraction = (mercatorY - southMercatorY) * oneOverMercatorHeight;
    webMercatorT[outputIndex++] = mercatorFraction;
    webMercatorT[outputIndex++] = mercatorFraction;
  }
  reproject.vertexArray.getAttribute(1).vertexBuffer.copyFromArrayView(webMercatorT);
  command.shaderProgram = reproject.shaderProgram;
  command.outputTexture = outputTexture;
  command.uniformMap = uniformMap;
  command.vertexArray = reproject.vertexArray;
}
function getLevelWithMaximumTexelSpacing(layer, texelSpacing, latitudeClosestToEquator) {
  const imageryProvider = layer._imageryProvider;
  const tilingScheme2 = imageryProvider.tilingScheme;
  const ellipsoid = tilingScheme2.ellipsoid;
  const latitudeFactor = !(layer._imageryProvider.tilingScheme.projection instanceof GeographicProjection_default) ? Math.cos(latitudeClosestToEquator) : 1;
  const tilingSchemeRectangle = tilingScheme2.rectangle;
  const levelZeroMaximumTexelSpacing = ellipsoid.maximumRadius * tilingSchemeRectangle.width * latitudeFactor / (imageryProvider.tileWidth * tilingScheme2.getNumberOfXTilesAtLevel(0));
  const twoToTheLevelPower = levelZeroMaximumTexelSpacing / texelSpacing;
  const level = Math.log(twoToTheLevelPower) / Math.log(2);
  const rounded = Math.round(level);
  return rounded | 0;
}
var ImageryLayer_default = ImageryLayer;

// node_modules/cesium/Source/Scene/TileSelectionResult.js
var TileSelectionResult = {
  NONE: 0,
  CULLED: 1,
  RENDERED: 2,
  REFINED: 3,
  RENDERED_AND_KICKED: 2 | 4,
  REFINED_AND_KICKED: 3 | 4,
  CULLED_BUT_NEEDED: 1 | 8,
  wasKicked: function(value) {
    return value >= TileSelectionResult.RENDERED_AND_KICKED;
  },
  originalResult: function(value) {
    return value & 3;
  },
  kick: function(value) {
    return value | 4;
  }
};
var TileSelectionResult_default = TileSelectionResult;

// node_modules/cesium/Source/Scene/TerrainFillMesh.js
function TerrainFillMesh(tile) {
  this.tile = tile;
  this.frameLastUpdated = void 0;
  this.westMeshes = [];
  this.westTiles = [];
  this.southMeshes = [];
  this.southTiles = [];
  this.eastMeshes = [];
  this.eastTiles = [];
  this.northMeshes = [];
  this.northTiles = [];
  this.southwestMesh = void 0;
  this.southwestTile = void 0;
  this.southeastMesh = void 0;
  this.southeastTile = void 0;
  this.northwestMesh = void 0;
  this.northwestTile = void 0;
  this.northeastMesh = void 0;
  this.northeastTile = void 0;
  this.changedThisFrame = true;
  this.visitedFrame = void 0;
  this.enqueuedFrame = void 0;
  this.mesh = void 0;
  this.vertexArray = void 0;
  this.waterMaskTexture = void 0;
  this.waterMaskTranslationAndScale = new Cartesian4_default();
}
TerrainFillMesh.prototype.update = function(tileProvider, frameState, vertexArraysToDestroy) {
  if (this.changedThisFrame) {
    createFillMesh(tileProvider, frameState, this.tile, vertexArraysToDestroy);
    this.changedThisFrame = false;
  }
};
TerrainFillMesh.prototype.destroy = function(vertexArraysToDestroy) {
  this._destroyVertexArray(vertexArraysToDestroy);
  if (defined_default(this.waterMaskTexture)) {
    --this.waterMaskTexture.referenceCount;
    if (this.waterMaskTexture.referenceCount === 0) {
      this.waterMaskTexture.destroy();
    }
    this.waterMaskTexture = void 0;
  }
  return void 0;
};
TerrainFillMesh.prototype._destroyVertexArray = function(vertexArraysToDestroy) {
  if (defined_default(this.vertexArray)) {
    if (defined_default(vertexArraysToDestroy)) {
      vertexArraysToDestroy.push(this.vertexArray);
    } else {
      GlobeSurfaceTile_default._freeVertexArray(this.vertexArray);
    }
    this.vertexArray = void 0;
  }
};
var traversalQueueScratch = new Queue_default();
TerrainFillMesh.updateFillTiles = function(tileProvider, renderedTiles, frameState, vertexArraysToDestroy) {
  const quadtree = tileProvider._quadtree;
  const levelZeroTiles = quadtree._levelZeroTiles;
  const lastSelectionFrameNumber = quadtree._lastSelectionFrameNumber;
  const traversalQueue = traversalQueueScratch;
  traversalQueue.clear();
  for (let i2 = 0; i2 < renderedTiles.length; ++i2) {
    const renderedTile = renderedTiles[i2];
    if (defined_default(renderedTile.data.vertexArray)) {
      traversalQueue.enqueue(renderedTiles[i2]);
    }
  }
  let tile = traversalQueue.dequeue();
  while (tile !== void 0) {
    const tileToWest = tile.findTileToWest(levelZeroTiles);
    const tileToSouth = tile.findTileToSouth(levelZeroTiles);
    const tileToEast = tile.findTileToEast(levelZeroTiles);
    const tileToNorth = tile.findTileToNorth(levelZeroTiles);
    visitRenderedTiles(
      tileProvider,
      frameState,
      tile,
      tileToWest,
      lastSelectionFrameNumber,
      TileEdge_default.EAST,
      false,
      traversalQueue,
      vertexArraysToDestroy
    );
    visitRenderedTiles(
      tileProvider,
      frameState,
      tile,
      tileToSouth,
      lastSelectionFrameNumber,
      TileEdge_default.NORTH,
      false,
      traversalQueue,
      vertexArraysToDestroy
    );
    visitRenderedTiles(
      tileProvider,
      frameState,
      tile,
      tileToEast,
      lastSelectionFrameNumber,
      TileEdge_default.WEST,
      false,
      traversalQueue,
      vertexArraysToDestroy
    );
    visitRenderedTiles(
      tileProvider,
      frameState,
      tile,
      tileToNorth,
      lastSelectionFrameNumber,
      TileEdge_default.SOUTH,
      false,
      traversalQueue,
      vertexArraysToDestroy
    );
    const tileToNorthwest = tileToWest.findTileToNorth(levelZeroTiles);
    const tileToSouthwest = tileToWest.findTileToSouth(levelZeroTiles);
    const tileToNortheast = tileToEast.findTileToNorth(levelZeroTiles);
    const tileToSoutheast = tileToEast.findTileToSouth(levelZeroTiles);
    visitRenderedTiles(
      tileProvider,
      frameState,
      tile,
      tileToNorthwest,
      lastSelectionFrameNumber,
      TileEdge_default.SOUTHEAST,
      false,
      traversalQueue,
      vertexArraysToDestroy
    );
    visitRenderedTiles(
      tileProvider,
      frameState,
      tile,
      tileToNortheast,
      lastSelectionFrameNumber,
      TileEdge_default.SOUTHWEST,
      false,
      traversalQueue,
      vertexArraysToDestroy
    );
    visitRenderedTiles(
      tileProvider,
      frameState,
      tile,
      tileToSouthwest,
      lastSelectionFrameNumber,
      TileEdge_default.NORTHEAST,
      false,
      traversalQueue,
      vertexArraysToDestroy
    );
    visitRenderedTiles(
      tileProvider,
      frameState,
      tile,
      tileToSoutheast,
      lastSelectionFrameNumber,
      TileEdge_default.NORTHWEST,
      false,
      traversalQueue,
      vertexArraysToDestroy
    );
    tile = traversalQueue.dequeue();
  }
};
function visitRenderedTiles(tileProvider, frameState, sourceTile, startTile, currentFrameNumber, tileEdge, downOnly, traversalQueue, vertexArraysToDestroy) {
  if (startTile === void 0) {
    return;
  }
  let tile = startTile;
  while (tile && (tile._lastSelectionResultFrame !== currentFrameNumber || TileSelectionResult_default.wasKicked(tile._lastSelectionResult) || TileSelectionResult_default.originalResult(tile._lastSelectionResult) === TileSelectionResult_default.CULLED)) {
    if (downOnly) {
      return;
    }
    const parent = tile.parent;
    if (tileEdge >= TileEdge_default.NORTHWEST && parent !== void 0) {
      switch (tileEdge) {
        case TileEdge_default.NORTHWEST:
          tile = tile === parent.northwestChild ? parent : void 0;
          break;
        case TileEdge_default.NORTHEAST:
          tile = tile === parent.northeastChild ? parent : void 0;
          break;
        case TileEdge_default.SOUTHWEST:
          tile = tile === parent.southwestChild ? parent : void 0;
          break;
        case TileEdge_default.SOUTHEAST:
          tile = tile === parent.southeastChild ? parent : void 0;
          break;
      }
    } else {
      tile = parent;
    }
  }
  if (tile === void 0) {
    return;
  }
  if (tile._lastSelectionResult === TileSelectionResult_default.RENDERED) {
    if (defined_default(tile.data.vertexArray)) {
      return;
    }
    visitTile3(
      tileProvider,
      frameState,
      sourceTile,
      tile,
      tileEdge,
      currentFrameNumber,
      traversalQueue,
      vertexArraysToDestroy
    );
    return;
  }
  if (TileSelectionResult_default.originalResult(startTile._lastSelectionResult) === TileSelectionResult_default.CULLED) {
    return;
  }
  switch (tileEdge) {
    case TileEdge_default.WEST:
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.northwestChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.southwestChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      break;
    case TileEdge_default.EAST:
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.southeastChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.northeastChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      break;
    case TileEdge_default.SOUTH:
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.southwestChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.southeastChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      break;
    case TileEdge_default.NORTH:
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.northeastChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.northwestChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      break;
    case TileEdge_default.NORTHWEST:
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.northwestChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      break;
    case TileEdge_default.NORTHEAST:
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.northeastChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      break;
    case TileEdge_default.SOUTHWEST:
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.southwestChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      break;
    case TileEdge_default.SOUTHEAST:
      visitRenderedTiles(
        tileProvider,
        frameState,
        sourceTile,
        startTile.southeastChild,
        currentFrameNumber,
        tileEdge,
        true,
        traversalQueue,
        vertexArraysToDestroy
      );
      break;
    default:
      throw new DeveloperError_default("Invalid edge");
  }
}
function visitTile3(tileProvider, frameState, sourceTile, destinationTile, tileEdge, frameNumber, traversalQueue, vertexArraysToDestroy) {
  const destinationSurfaceTile = destinationTile.data;
  if (destinationSurfaceTile.fill === void 0) {
    destinationSurfaceTile.fill = new TerrainFillMesh(destinationTile);
  } else if (destinationSurfaceTile.fill.visitedFrame === frameNumber) {
    return;
  }
  if (destinationSurfaceTile.fill.enqueuedFrame !== frameNumber) {
    destinationSurfaceTile.fill.enqueuedFrame = frameNumber;
    destinationSurfaceTile.fill.changedThisFrame = false;
    traversalQueue.enqueue(destinationTile);
  }
  propagateEdge(
    tileProvider,
    frameState,
    sourceTile,
    destinationTile,
    tileEdge,
    vertexArraysToDestroy
  );
}
function propagateEdge(tileProvider, frameState, sourceTile, destinationTile, tileEdge, vertexArraysToDestroy) {
  const destinationFill = destinationTile.data.fill;
  let sourceMesh;
  const sourceFill = sourceTile.data.fill;
  if (defined_default(sourceFill)) {
    sourceFill.visitedFrame = frameState.frameNumber;
    if (sourceFill.changedThisFrame) {
      createFillMesh(
        tileProvider,
        frameState,
        sourceTile,
        vertexArraysToDestroy
      );
      sourceFill.changedThisFrame = false;
    }
    sourceMesh = sourceTile.data.fill.mesh;
  } else {
    sourceMesh = sourceTile.data.mesh;
  }
  let edgeMeshes;
  let edgeTiles;
  switch (tileEdge) {
    case TileEdge_default.WEST:
      edgeMeshes = destinationFill.westMeshes;
      edgeTiles = destinationFill.westTiles;
      break;
    case TileEdge_default.SOUTH:
      edgeMeshes = destinationFill.southMeshes;
      edgeTiles = destinationFill.southTiles;
      break;
    case TileEdge_default.EAST:
      edgeMeshes = destinationFill.eastMeshes;
      edgeTiles = destinationFill.eastTiles;
      break;
    case TileEdge_default.NORTH:
      edgeMeshes = destinationFill.northMeshes;
      edgeTiles = destinationFill.northTiles;
      break;
    case TileEdge_default.NORTHWEST:
      destinationFill.changedThisFrame = destinationFill.changedThisFrame || destinationFill.northwestMesh !== sourceMesh;
      destinationFill.northwestMesh = sourceMesh;
      destinationFill.northwestTile = sourceTile;
      return;
    case TileEdge_default.NORTHEAST:
      destinationFill.changedThisFrame = destinationFill.changedThisFrame || destinationFill.northeastMesh !== sourceMesh;
      destinationFill.northeastMesh = sourceMesh;
      destinationFill.northeastTile = sourceTile;
      return;
    case TileEdge_default.SOUTHWEST:
      destinationFill.changedThisFrame = destinationFill.changedThisFrame || destinationFill.southwestMesh !== sourceMesh;
      destinationFill.southwestMesh = sourceMesh;
      destinationFill.southwestTile = sourceTile;
      return;
    case TileEdge_default.SOUTHEAST:
      destinationFill.changedThisFrame = destinationFill.changedThisFrame || destinationFill.southeastMesh !== sourceMesh;
      destinationFill.southeastMesh = sourceMesh;
      destinationFill.southeastTile = sourceTile;
      return;
  }
  if (sourceTile.level <= destinationTile.level) {
    destinationFill.changedThisFrame = destinationFill.changedThisFrame || edgeMeshes[0] !== sourceMesh || edgeMeshes.length !== 1;
    edgeMeshes[0] = sourceMesh;
    edgeTiles[0] = sourceTile;
    edgeMeshes.length = 1;
    edgeTiles.length = 1;
    return;
  }
  let startIndex, endIndex, existingTile, existingRectangle;
  const sourceRectangle = sourceTile.rectangle;
  let epsilon;
  const destinationRectangle = destinationTile.rectangle;
  switch (tileEdge) {
    case TileEdge_default.WEST:
      epsilon = (destinationRectangle.north - destinationRectangle.south) * Math_default.EPSILON5;
      for (startIndex = 0; startIndex < edgeTiles.length; ++startIndex) {
        existingTile = edgeTiles[startIndex];
        existingRectangle = existingTile.rectangle;
        if (Math_default.greaterThan(
          sourceRectangle.north,
          existingRectangle.south,
          epsilon
        )) {
          break;
        }
      }
      for (endIndex = startIndex; endIndex < edgeTiles.length; ++endIndex) {
        existingTile = edgeTiles[endIndex];
        existingRectangle = existingTile.rectangle;
        if (Math_default.greaterThanOrEquals(
          sourceRectangle.south,
          existingRectangle.north,
          epsilon
        )) {
          break;
        }
      }
      break;
    case TileEdge_default.SOUTH:
      epsilon = (destinationRectangle.east - destinationRectangle.west) * Math_default.EPSILON5;
      for (startIndex = 0; startIndex < edgeTiles.length; ++startIndex) {
        existingTile = edgeTiles[startIndex];
        existingRectangle = existingTile.rectangle;
        if (Math_default.lessThan(
          sourceRectangle.west,
          existingRectangle.east,
          epsilon
        )) {
          break;
        }
      }
      for (endIndex = startIndex; endIndex < edgeTiles.length; ++endIndex) {
        existingTile = edgeTiles[endIndex];
        existingRectangle = existingTile.rectangle;
        if (Math_default.lessThanOrEquals(
          sourceRectangle.east,
          existingRectangle.west,
          epsilon
        )) {
          break;
        }
      }
      break;
    case TileEdge_default.EAST:
      epsilon = (destinationRectangle.north - destinationRectangle.south) * Math_default.EPSILON5;
      for (startIndex = 0; startIndex < edgeTiles.length; ++startIndex) {
        existingTile = edgeTiles[startIndex];
        existingRectangle = existingTile.rectangle;
        if (Math_default.lessThan(
          sourceRectangle.south,
          existingRectangle.north,
          epsilon
        )) {
          break;
        }
      }
      for (endIndex = startIndex; endIndex < edgeTiles.length; ++endIndex) {
        existingTile = edgeTiles[endIndex];
        existingRectangle = existingTile.rectangle;
        if (Math_default.lessThanOrEquals(
          sourceRectangle.north,
          existingRectangle.south,
          epsilon
        )) {
          break;
        }
      }
      break;
    case TileEdge_default.NORTH:
      epsilon = (destinationRectangle.east - destinationRectangle.west) * Math_default.EPSILON5;
      for (startIndex = 0; startIndex < edgeTiles.length; ++startIndex) {
        existingTile = edgeTiles[startIndex];
        existingRectangle = existingTile.rectangle;
        if (Math_default.greaterThan(
          sourceRectangle.east,
          existingRectangle.west,
          epsilon
        )) {
          break;
        }
      }
      for (endIndex = startIndex; endIndex < edgeTiles.length; ++endIndex) {
        existingTile = edgeTiles[endIndex];
        existingRectangle = existingTile.rectangle;
        if (Math_default.greaterThanOrEquals(
          sourceRectangle.west,
          existingRectangle.east,
          epsilon
        )) {
          break;
        }
      }
      break;
  }
  if (endIndex - startIndex === 1) {
    destinationFill.changedThisFrame = destinationFill.changedThisFrame || edgeMeshes[startIndex] !== sourceMesh;
    edgeMeshes[startIndex] = sourceMesh;
    edgeTiles[startIndex] = sourceTile;
  } else {
    destinationFill.changedThisFrame = true;
    edgeMeshes.splice(startIndex, endIndex - startIndex, sourceMesh);
    edgeTiles.splice(startIndex, endIndex - startIndex, sourceTile);
  }
}
var cartographicScratch4 = new Cartographic_default();
var centerCartographicScratch2 = new Cartographic_default();
var cartesianScratch = new Cartesian3_default();
var normalScratch6 = new Cartesian3_default();
var octEncodedNormalScratch = new Cartesian2_default();
var uvScratch2 = new Cartesian2_default();
var uvScratch = new Cartesian2_default();
function HeightAndNormal() {
  this.height = 0;
  this.encodedNormal = new Cartesian2_default();
}
function fillMissingCorner(fill, ellipsoid, u3, v7, corner, adjacentCorner1, adjacentCorner2, oppositeCorner, vertex) {
  if (defined_default(corner)) {
    return corner;
  }
  let height;
  if (defined_default(adjacentCorner1) && defined_default(adjacentCorner2)) {
    height = (adjacentCorner1.height + adjacentCorner2.height) * 0.5;
  } else if (defined_default(adjacentCorner1)) {
    height = adjacentCorner1.height;
  } else if (defined_default(adjacentCorner2)) {
    height = adjacentCorner2.height;
  } else if (defined_default(oppositeCorner)) {
    height = oppositeCorner.height;
  } else {
    const surfaceTile = fill.tile.data;
    const tileBoundingRegion = surfaceTile.tileBoundingRegion;
    let minimumHeight = 0;
    let maximumHeight = 0;
    if (defined_default(tileBoundingRegion)) {
      minimumHeight = tileBoundingRegion.minimumHeight;
      maximumHeight = tileBoundingRegion.maximumHeight;
    }
    height = (minimumHeight + maximumHeight) * 0.5;
  }
  getVertexWithHeightAtCorner(fill, ellipsoid, u3, v7, height, vertex);
  return vertex;
}
var heightRangeScratch = {
  minimumHeight: 0,
  maximumHeight: 0
};
var scratchCenter7 = new Cartesian3_default();
var swVertexScratch = new HeightAndNormal();
var seVertexScratch = new HeightAndNormal();
var nwVertexScratch = new HeightAndNormal();
var neVertexScratch = new HeightAndNormal();
var heightmapBuffer = typeof Uint8Array !== "undefined" ? new Uint8Array(9 * 9) : void 0;
var scratchCreateMeshSyncOptions = {
  tilingScheme: void 0,
  x: 0,
  y: 0,
  level: 0,
  exaggeration: 1,
  exaggerationRelativeHeight: 0
};
function createFillMesh(tileProvider, frameState, tile, vertexArraysToDestroy) {
  GlobeSurfaceTile_default.initialize(
    tile,
    tileProvider.terrainProvider,
    tileProvider._imageryLayers
  );
  const surfaceTile = tile.data;
  const fill = surfaceTile.fill;
  const rectangle = tile.rectangle;
  const exaggeration = frameState.terrainExaggeration;
  const exaggerationRelativeHeight = frameState.terrainExaggerationRelativeHeight;
  const hasExaggeration = exaggeration !== 1;
  const ellipsoid = tile.tilingScheme.ellipsoid;
  let nwCorner = getCorner(
    fill,
    ellipsoid,
    0,
    1,
    fill.northwestTile,
    fill.northwestMesh,
    fill.northTiles,
    fill.northMeshes,
    fill.westTiles,
    fill.westMeshes,
    nwVertexScratch
  );
  let swCorner = getCorner(
    fill,
    ellipsoid,
    0,
    0,
    fill.southwestTile,
    fill.southwestMesh,
    fill.westTiles,
    fill.westMeshes,
    fill.southTiles,
    fill.southMeshes,
    swVertexScratch
  );
  let seCorner = getCorner(
    fill,
    ellipsoid,
    1,
    0,
    fill.southeastTile,
    fill.southeastMesh,
    fill.southTiles,
    fill.southMeshes,
    fill.eastTiles,
    fill.eastMeshes,
    seVertexScratch
  );
  let neCorner = getCorner(
    fill,
    ellipsoid,
    1,
    1,
    fill.northeastTile,
    fill.northeastMesh,
    fill.eastTiles,
    fill.eastMeshes,
    fill.northTiles,
    fill.northMeshes,
    neVertexScratch
  );
  nwCorner = fillMissingCorner(
    fill,
    ellipsoid,
    0,
    1,
    nwCorner,
    swCorner,
    neCorner,
    seCorner,
    nwVertexScratch
  );
  swCorner = fillMissingCorner(
    fill,
    ellipsoid,
    0,
    0,
    swCorner,
    nwCorner,
    seCorner,
    neCorner,
    swVertexScratch
  );
  seCorner = fillMissingCorner(
    fill,
    ellipsoid,
    1,
    1,
    seCorner,
    swCorner,
    neCorner,
    nwCorner,
    seVertexScratch
  );
  neCorner = fillMissingCorner(
    fill,
    ellipsoid,
    1,
    1,
    neCorner,
    seCorner,
    nwCorner,
    swCorner,
    neVertexScratch
  );
  const southwestHeight = swCorner.height;
  const southeastHeight = seCorner.height;
  const northwestHeight = nwCorner.height;
  const northeastHeight = neCorner.height;
  let minimumHeight = Math.min(
    southwestHeight,
    southeastHeight,
    northwestHeight,
    northeastHeight
  );
  let maximumHeight = Math.max(
    southwestHeight,
    southeastHeight,
    northwestHeight,
    northeastHeight
  );
  const middleHeight = (minimumHeight + maximumHeight) * 0.5;
  let i2;
  let len;
  const geometricError = tileProvider.getLevelMaximumGeometricError(tile.level);
  const minCutThroughRadius = ellipsoid.maximumRadius - geometricError;
  let maxTileWidth = Math.acos(minCutThroughRadius / ellipsoid.maximumRadius) * 4;
  maxTileWidth *= 1.5;
  if (rectangle.width > maxTileWidth && maximumHeight - minimumHeight <= geometricError) {
    const terrainData = new HeightmapTerrainData_default({
      width: 9,
      height: 9,
      buffer: heightmapBuffer,
      structure: {
        heightOffset: maximumHeight
      }
    });
    const createMeshSyncOptions = scratchCreateMeshSyncOptions;
    createMeshSyncOptions.tilingScheme = tile.tilingScheme;
    createMeshSyncOptions.x = tile.x;
    createMeshSyncOptions.y = tile.y;
    createMeshSyncOptions.level = tile.level;
    createMeshSyncOptions.exaggeration = exaggeration;
    createMeshSyncOptions.exaggerationRelativeHeight = exaggerationRelativeHeight;
    fill.mesh = terrainData._createMeshSync(createMeshSyncOptions);
  } else {
    const hasGeodeticSurfaceNormals = hasExaggeration;
    const centerCartographic = Rectangle_default.center(
      rectangle,
      centerCartographicScratch2
    );
    centerCartographic.height = middleHeight;
    const center = ellipsoid.cartographicToCartesian(
      centerCartographic,
      scratchCenter7
    );
    const encoding = new TerrainEncoding_default(
      center,
      void 0,
      void 0,
      void 0,
      void 0,
      true,
      true,
      hasGeodeticSurfaceNormals,
      exaggeration,
      exaggerationRelativeHeight
    );
    let maxVertexCount = 5;
    let meshes;
    meshes = fill.westMeshes;
    for (i2 = 0, len = meshes.length; i2 < len; ++i2) {
      maxVertexCount += meshes[i2].eastIndicesNorthToSouth.length;
    }
    meshes = fill.southMeshes;
    for (i2 = 0, len = meshes.length; i2 < len; ++i2) {
      maxVertexCount += meshes[i2].northIndicesWestToEast.length;
    }
    meshes = fill.eastMeshes;
    for (i2 = 0, len = meshes.length; i2 < len; ++i2) {
      maxVertexCount += meshes[i2].westIndicesSouthToNorth.length;
    }
    meshes = fill.northMeshes;
    for (i2 = 0, len = meshes.length; i2 < len; ++i2) {
      maxVertexCount += meshes[i2].southIndicesEastToWest.length;
    }
    const heightRange = heightRangeScratch;
    heightRange.minimumHeight = minimumHeight;
    heightRange.maximumHeight = maximumHeight;
    const stride = encoding.stride;
    let typedArray = new Float32Array(maxVertexCount * stride);
    let nextIndex = 0;
    const northwestIndex = nextIndex;
    nextIndex = addVertexWithComputedPosition(
      ellipsoid,
      rectangle,
      encoding,
      typedArray,
      nextIndex,
      0,
      1,
      nwCorner.height,
      nwCorner.encodedNormal,
      1,
      heightRange
    );
    nextIndex = addEdge(
      fill,
      ellipsoid,
      encoding,
      typedArray,
      nextIndex,
      fill.westTiles,
      fill.westMeshes,
      TileEdge_default.EAST,
      heightRange
    );
    const southwestIndex = nextIndex;
    nextIndex = addVertexWithComputedPosition(
      ellipsoid,
      rectangle,
      encoding,
      typedArray,
      nextIndex,
      0,
      0,
      swCorner.height,
      swCorner.encodedNormal,
      0,
      heightRange
    );
    nextIndex = addEdge(
      fill,
      ellipsoid,
      encoding,
      typedArray,
      nextIndex,
      fill.southTiles,
      fill.southMeshes,
      TileEdge_default.NORTH,
      heightRange
    );
    const southeastIndex = nextIndex;
    nextIndex = addVertexWithComputedPosition(
      ellipsoid,
      rectangle,
      encoding,
      typedArray,
      nextIndex,
      1,
      0,
      seCorner.height,
      seCorner.encodedNormal,
      0,
      heightRange
    );
    nextIndex = addEdge(
      fill,
      ellipsoid,
      encoding,
      typedArray,
      nextIndex,
      fill.eastTiles,
      fill.eastMeshes,
      TileEdge_default.WEST,
      heightRange
    );
    const northeastIndex = nextIndex;
    nextIndex = addVertexWithComputedPosition(
      ellipsoid,
      rectangle,
      encoding,
      typedArray,
      nextIndex,
      1,
      1,
      neCorner.height,
      neCorner.encodedNormal,
      1,
      heightRange
    );
    nextIndex = addEdge(
      fill,
      ellipsoid,
      encoding,
      typedArray,
      nextIndex,
      fill.northTiles,
      fill.northMeshes,
      TileEdge_default.SOUTH,
      heightRange
    );
    minimumHeight = heightRange.minimumHeight;
    maximumHeight = heightRange.maximumHeight;
    const obb = OrientedBoundingBox_default.fromRectangle(
      rectangle,
      minimumHeight,
      maximumHeight,
      tile.tilingScheme.ellipsoid
    );
    const southMercatorY = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(
      rectangle.south
    );
    const oneOverMercatorHeight = 1 / (WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(rectangle.north) - southMercatorY);
    const centerWebMercatorT = (WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(
      centerCartographic.latitude
    ) - southMercatorY) * oneOverMercatorHeight;
    const geodeticSurfaceNormal = ellipsoid.geodeticSurfaceNormalCartographic(
      cartographicScratch4,
      normalScratch6
    );
    const centerEncodedNormal = AttributeCompression_default.octEncode(
      geodeticSurfaceNormal,
      octEncodedNormalScratch
    );
    const centerIndex = nextIndex;
    encoding.encode(
      typedArray,
      nextIndex * stride,
      obb.center,
      Cartesian2_default.fromElements(0.5, 0.5, uvScratch),
      middleHeight,
      centerEncodedNormal,
      centerWebMercatorT,
      geodeticSurfaceNormal
    );
    ++nextIndex;
    const vertexCount = nextIndex;
    const bytesPerIndex = vertexCount < 256 ? 1 : 2;
    const indexCount = (vertexCount - 1) * 3;
    const indexDataBytes = indexCount * bytesPerIndex;
    const availableBytesInBuffer = (typedArray.length - vertexCount * stride) * Float32Array.BYTES_PER_ELEMENT;
    let indices2;
    if (availableBytesInBuffer >= indexDataBytes) {
      const startIndex = vertexCount * stride * Float32Array.BYTES_PER_ELEMENT;
      indices2 = vertexCount < 256 ? new Uint8Array(typedArray.buffer, startIndex, indexCount) : new Uint16Array(typedArray.buffer, startIndex, indexCount);
    } else {
      indices2 = vertexCount < 256 ? new Uint8Array(indexCount) : new Uint16Array(indexCount);
    }
    typedArray = new Float32Array(typedArray.buffer, 0, vertexCount * stride);
    let indexOut = 0;
    for (i2 = 0; i2 < vertexCount - 2; ++i2) {
      indices2[indexOut++] = centerIndex;
      indices2[indexOut++] = i2;
      indices2[indexOut++] = i2 + 1;
    }
    indices2[indexOut++] = centerIndex;
    indices2[indexOut++] = i2;
    indices2[indexOut++] = 0;
    const westIndicesSouthToNorth = [];
    for (i2 = southwestIndex; i2 >= northwestIndex; --i2) {
      westIndicesSouthToNorth.push(i2);
    }
    const southIndicesEastToWest = [];
    for (i2 = southeastIndex; i2 >= southwestIndex; --i2) {
      southIndicesEastToWest.push(i2);
    }
    const eastIndicesNorthToSouth = [];
    for (i2 = northeastIndex; i2 >= southeastIndex; --i2) {
      eastIndicesNorthToSouth.push(i2);
    }
    const northIndicesWestToEast = [];
    northIndicesWestToEast.push(0);
    for (i2 = centerIndex - 1; i2 >= northeastIndex; --i2) {
      northIndicesWestToEast.push(i2);
    }
    fill.mesh = new TerrainMesh_default(
      encoding.center,
      typedArray,
      indices2,
      indexCount,
      vertexCount,
      minimumHeight,
      maximumHeight,
      BoundingSphere_default.fromOrientedBoundingBox(obb),
      computeOccludeePoint(
        tileProvider,
        obb.center,
        rectangle,
        minimumHeight,
        maximumHeight
      ),
      encoding.stride,
      obb,
      encoding,
      westIndicesSouthToNorth,
      southIndicesEastToWest,
      eastIndicesNorthToSouth,
      northIndicesWestToEast
    );
  }
  const context = frameState.context;
  fill._destroyVertexArray(vertexArraysToDestroy);
  fill.vertexArray = GlobeSurfaceTile_default._createVertexArrayForMesh(
    context,
    fill.mesh
  );
  surfaceTile.processImagery(
    tile,
    tileProvider.terrainProvider,
    frameState,
    true
  );
  const oldTexture = fill.waterMaskTexture;
  fill.waterMaskTexture = void 0;
  if (tileProvider.terrainProvider.hasWaterMask) {
    const waterSourceTile = surfaceTile._findAncestorTileWithTerrainData(tile);
    if (defined_default(waterSourceTile) && defined_default(waterSourceTile.data.waterMaskTexture)) {
      fill.waterMaskTexture = waterSourceTile.data.waterMaskTexture;
      ++fill.waterMaskTexture.referenceCount;
      surfaceTile._computeWaterMaskTranslationAndScale(
        tile,
        waterSourceTile,
        fill.waterMaskTranslationAndScale
      );
    }
  }
  if (defined_default(oldTexture)) {
    --oldTexture.referenceCount;
    if (oldTexture.referenceCount === 0) {
      oldTexture.destroy();
    }
  }
}
function addVertexWithComputedPosition(ellipsoid, rectangle, encoding, buffer, index2, u3, v7, height, encodedNormal, webMercatorT, heightRange) {
  const cartographic2 = cartographicScratch4;
  cartographic2.longitude = Math_default.lerp(rectangle.west, rectangle.east, u3);
  cartographic2.latitude = Math_default.lerp(rectangle.south, rectangle.north, v7);
  cartographic2.height = height;
  const position = ellipsoid.cartographicToCartesian(
    cartographic2,
    cartesianScratch
  );
  let geodeticSurfaceNormal;
  if (encoding.hasGeodeticSurfaceNormals) {
    geodeticSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
      position,
      normalScratch6
    );
  }
  const uv = uvScratch2;
  uv.x = u3;
  uv.y = v7;
  encoding.encode(
    buffer,
    index2 * encoding.stride,
    position,
    uv,
    height,
    encodedNormal,
    webMercatorT,
    geodeticSurfaceNormal
  );
  heightRange.minimumHeight = Math.min(heightRange.minimumHeight, height);
  heightRange.maximumHeight = Math.max(heightRange.maximumHeight, height);
  return index2 + 1;
}
var sourceRectangleScratch = new Rectangle_default();
function transformTextureCoordinates(sourceTile, targetTile, coordinates, result) {
  let sourceRectangle = sourceTile.rectangle;
  const targetRectangle = targetTile.rectangle;
  if (targetTile.x === 0 && coordinates.x === 1 && sourceTile.x === sourceTile.tilingScheme.getNumberOfXTilesAtLevel(sourceTile.level) - 1) {
    sourceRectangle = Rectangle_default.clone(
      sourceTile.rectangle,
      sourceRectangleScratch
    );
    sourceRectangle.west -= Math_default.TWO_PI;
    sourceRectangle.east -= Math_default.TWO_PI;
  } else if (sourceTile.x === 0 && coordinates.x === 0 && targetTile.x === targetTile.tilingScheme.getNumberOfXTilesAtLevel(targetTile.level) - 1) {
    sourceRectangle = Rectangle_default.clone(
      sourceTile.rectangle,
      sourceRectangleScratch
    );
    sourceRectangle.west += Math_default.TWO_PI;
    sourceRectangle.east += Math_default.TWO_PI;
  }
  const sourceWidth = sourceRectangle.east - sourceRectangle.west;
  const umin = (targetRectangle.west - sourceRectangle.west) / sourceWidth;
  const umax = (targetRectangle.east - sourceRectangle.west) / sourceWidth;
  const sourceHeight = sourceRectangle.north - sourceRectangle.south;
  const vmin = (targetRectangle.south - sourceRectangle.south) / sourceHeight;
  const vmax = (targetRectangle.north - sourceRectangle.south) / sourceHeight;
  let u3 = (coordinates.x - umin) / (umax - umin);
  let v7 = (coordinates.y - vmin) / (vmax - vmin);
  if (Math.abs(u3) < Math.EPSILON5) {
    u3 = 0;
  } else if (Math.abs(u3 - 1) < Math.EPSILON5) {
    u3 = 1;
  }
  if (Math.abs(v7) < Math.EPSILON5) {
    v7 = 0;
  } else if (Math.abs(v7 - 1) < Math.EPSILON5) {
    v7 = 1;
  }
  result.x = u3;
  result.y = v7;
  return result;
}
var encodedNormalScratch = new Cartesian2_default();
function getVertexFromTileAtCorner(sourceMesh, sourceIndex, u3, v7, vertex) {
  const sourceEncoding = sourceMesh.encoding;
  const sourceVertices = sourceMesh.vertices;
  vertex.height = sourceEncoding.decodeHeight(sourceVertices, sourceIndex);
  if (sourceEncoding.hasVertexNormals) {
    sourceEncoding.getOctEncodedNormal(
      sourceVertices,
      sourceIndex,
      vertex.encodedNormal
    );
  } else {
    const normal2 = vertex.encodedNormal;
    normal2.x = 0;
    normal2.y = 0;
  }
}
var encodedNormalScratch2 = new Cartesian2_default();
var cartesianScratch2 = new Cartesian3_default();
function getInterpolatedVertexAtCorner(ellipsoid, sourceTile, targetTile, sourceMesh, previousIndex, nextIndex, u3, v7, interpolateU, vertex) {
  const sourceEncoding = sourceMesh.encoding;
  const sourceVertices = sourceMesh.vertices;
  const previousUv = transformTextureCoordinates(
    sourceTile,
    targetTile,
    sourceEncoding.decodeTextureCoordinates(
      sourceVertices,
      previousIndex,
      uvScratch
    ),
    uvScratch
  );
  const nextUv = transformTextureCoordinates(
    sourceTile,
    targetTile,
    sourceEncoding.decodeTextureCoordinates(
      sourceVertices,
      nextIndex,
      uvScratch2
    ),
    uvScratch2
  );
  let ratio;
  if (interpolateU) {
    ratio = (u3 - previousUv.x) / (nextUv.x - previousUv.x);
  } else {
    ratio = (v7 - previousUv.y) / (nextUv.y - previousUv.y);
  }
  const height1 = sourceEncoding.decodeHeight(sourceVertices, previousIndex);
  const height2 = sourceEncoding.decodeHeight(sourceVertices, nextIndex);
  const targetRectangle = targetTile.rectangle;
  cartographicScratch4.longitude = Math_default.lerp(
    targetRectangle.west,
    targetRectangle.east,
    u3
  );
  cartographicScratch4.latitude = Math_default.lerp(
    targetRectangle.south,
    targetRectangle.north,
    v7
  );
  vertex.height = cartographicScratch4.height = Math_default.lerp(
    height1,
    height2,
    ratio
  );
  let normal2;
  if (sourceEncoding.hasVertexNormals) {
    const encodedNormal1 = sourceEncoding.getOctEncodedNormal(
      sourceVertices,
      previousIndex,
      encodedNormalScratch
    );
    const encodedNormal2 = sourceEncoding.getOctEncodedNormal(
      sourceVertices,
      nextIndex,
      encodedNormalScratch2
    );
    const normal1 = AttributeCompression_default.octDecode(
      encodedNormal1.x,
      encodedNormal1.y,
      cartesianScratch
    );
    const normal22 = AttributeCompression_default.octDecode(
      encodedNormal2.x,
      encodedNormal2.y,
      cartesianScratch2
    );
    normal2 = Cartesian3_default.lerp(normal1, normal22, ratio, cartesianScratch);
    Cartesian3_default.normalize(normal2, normal2);
    AttributeCompression_default.octEncode(normal2, vertex.encodedNormal);
  } else {
    normal2 = ellipsoid.geodeticSurfaceNormalCartographic(
      cartographicScratch4,
      cartesianScratch
    );
    AttributeCompression_default.octEncode(normal2, vertex.encodedNormal);
  }
}
function getVertexWithHeightAtCorner(terrainFillMesh, ellipsoid, u3, v7, height, vertex) {
  vertex.height = height;
  const normal2 = ellipsoid.geodeticSurfaceNormalCartographic(
    cartographicScratch4,
    cartesianScratch
  );
  AttributeCompression_default.octEncode(normal2, vertex.encodedNormal);
}
function getCorner(terrainFillMesh, ellipsoid, u3, v7, cornerTile, cornerMesh, previousEdgeTiles, previousEdgeMeshes, nextEdgeTiles, nextEdgeMeshes, vertex) {
  const gotCorner = getCornerFromEdge(
    terrainFillMesh,
    ellipsoid,
    previousEdgeMeshes,
    previousEdgeTiles,
    false,
    u3,
    v7,
    vertex
  ) || getCornerFromEdge(
    terrainFillMesh,
    ellipsoid,
    nextEdgeMeshes,
    nextEdgeTiles,
    true,
    u3,
    v7,
    vertex
  );
  if (gotCorner) {
    return vertex;
  }
  let vertexIndex;
  if (meshIsUsable(cornerTile, cornerMesh)) {
    if (u3 === 0) {
      if (v7 === 0) {
        vertexIndex = cornerMesh.eastIndicesNorthToSouth[0];
      } else {
        vertexIndex = cornerMesh.southIndicesEastToWest[0];
      }
    } else if (v7 === 0) {
      vertexIndex = cornerMesh.northIndicesWestToEast[0];
    } else {
      vertexIndex = cornerMesh.westIndicesSouthToNorth[0];
    }
    getVertexFromTileAtCorner(cornerMesh, vertexIndex, u3, v7, vertex);
    return vertex;
  }
  let height;
  if (u3 === 0) {
    if (v7 === 0) {
      height = getClosestHeightToCorner(
        terrainFillMesh.westMeshes,
        terrainFillMesh.westTiles,
        TileEdge_default.EAST,
        terrainFillMesh.southMeshes,
        terrainFillMesh.southTiles,
        TileEdge_default.NORTH,
        u3,
        v7
      );
    } else {
      height = getClosestHeightToCorner(
        terrainFillMesh.northMeshes,
        terrainFillMesh.northTiles,
        TileEdge_default.SOUTH,
        terrainFillMesh.westMeshes,
        terrainFillMesh.westTiles,
        TileEdge_default.EAST,
        u3,
        v7
      );
    }
  } else if (v7 === 0) {
    height = getClosestHeightToCorner(
      terrainFillMesh.southMeshes,
      terrainFillMesh.southTiles,
      TileEdge_default.NORTH,
      terrainFillMesh.eastMeshes,
      terrainFillMesh.eastTiles,
      TileEdge_default.WEST,
      u3,
      v7
    );
  } else {
    height = getClosestHeightToCorner(
      terrainFillMesh.eastMeshes,
      terrainFillMesh.eastTiles,
      TileEdge_default.WEST,
      terrainFillMesh.northMeshes,
      terrainFillMesh.northTiles,
      TileEdge_default.SOUTH,
      u3,
      v7
    );
  }
  if (defined_default(height)) {
    getVertexWithHeightAtCorner(
      terrainFillMesh,
      ellipsoid,
      u3,
      v7,
      height,
      vertex
    );
    return vertex;
  }
  return void 0;
}
function getClosestHeightToCorner(previousMeshes, previousTiles, previousEdge, nextMeshes, nextTiles, nextEdge, u3, v7) {
  const height1 = getNearestHeightOnEdge(
    previousMeshes,
    previousTiles,
    false,
    previousEdge,
    u3,
    v7
  );
  const height2 = getNearestHeightOnEdge(
    nextMeshes,
    nextTiles,
    true,
    nextEdge,
    u3,
    v7
  );
  if (defined_default(height1) && defined_default(height2)) {
    return (height1 + height2) * 0.5;
  } else if (defined_default(height1)) {
    return height1;
  }
  return height2;
}
function addEdge(terrainFillMesh, ellipsoid, encoding, typedArray, nextIndex, edgeTiles, edgeMeshes, tileEdge, heightRange) {
  for (let i2 = 0; i2 < edgeTiles.length; ++i2) {
    nextIndex = addEdgeMesh(
      terrainFillMesh,
      ellipsoid,
      encoding,
      typedArray,
      nextIndex,
      edgeTiles[i2],
      edgeMeshes[i2],
      tileEdge,
      heightRange
    );
  }
  return nextIndex;
}
function addEdgeMesh(terrainFillMesh, ellipsoid, encoding, typedArray, nextIndex, edgeTile, edgeMesh, tileEdge, heightRange) {
  let sourceRectangle = edgeTile.rectangle;
  if (tileEdge === TileEdge_default.EAST && terrainFillMesh.tile.x === 0) {
    sourceRectangle = Rectangle_default.clone(
      edgeTile.rectangle,
      sourceRectangleScratch
    );
    sourceRectangle.west -= Math_default.TWO_PI;
    sourceRectangle.east -= Math_default.TWO_PI;
  } else if (tileEdge === TileEdge_default.WEST && edgeTile.x === 0) {
    sourceRectangle = Rectangle_default.clone(
      edgeTile.rectangle,
      sourceRectangleScratch
    );
    sourceRectangle.west += Math_default.TWO_PI;
    sourceRectangle.east += Math_default.TWO_PI;
  }
  const targetRectangle = terrainFillMesh.tile.rectangle;
  let lastU;
  let lastV;
  if (nextIndex > 0) {
    encoding.decodeTextureCoordinates(typedArray, nextIndex - 1, uvScratch);
    lastU = uvScratch.x;
    lastV = uvScratch.y;
  }
  let indices2;
  let compareU;
  switch (tileEdge) {
    case TileEdge_default.WEST:
      indices2 = edgeMesh.westIndicesSouthToNorth;
      compareU = false;
      break;
    case TileEdge_default.NORTH:
      indices2 = edgeMesh.northIndicesWestToEast;
      compareU = true;
      break;
    case TileEdge_default.EAST:
      indices2 = edgeMesh.eastIndicesNorthToSouth;
      compareU = false;
      break;
    case TileEdge_default.SOUTH:
      indices2 = edgeMesh.southIndicesEastToWest;
      compareU = true;
      break;
  }
  const sourceTile = edgeTile;
  const targetTile = terrainFillMesh.tile;
  const sourceEncoding = edgeMesh.encoding;
  const sourceVertices = edgeMesh.vertices;
  const targetStride = encoding.stride;
  let southMercatorY;
  let oneOverMercatorHeight;
  if (sourceEncoding.hasWebMercatorT) {
    southMercatorY = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(
      targetRectangle.south
    );
    oneOverMercatorHeight = 1 / (WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(
      targetRectangle.north
    ) - southMercatorY);
  }
  for (let i2 = 0; i2 < indices2.length; ++i2) {
    const index2 = indices2[i2];
    const uv = sourceEncoding.decodeTextureCoordinates(
      sourceVertices,
      index2,
      uvScratch
    );
    transformTextureCoordinates(sourceTile, targetTile, uv, uv);
    const u3 = uv.x;
    const v7 = uv.y;
    const uOrV = compareU ? u3 : v7;
    if (uOrV < 0 || uOrV > 1) {
      continue;
    }
    if (Math.abs(u3 - lastU) < Math_default.EPSILON5 && Math.abs(v7 - lastV) < Math_default.EPSILON5) {
      continue;
    }
    const nearlyEdgeU = Math.abs(u3) < Math_default.EPSILON5 || Math.abs(u3 - 1) < Math_default.EPSILON5;
    const nearlyEdgeV = Math.abs(v7) < Math_default.EPSILON5 || Math.abs(v7 - 1) < Math_default.EPSILON5;
    if (nearlyEdgeU && nearlyEdgeV) {
      continue;
    }
    const position = sourceEncoding.decodePosition(
      sourceVertices,
      index2,
      cartesianScratch
    );
    const height = sourceEncoding.decodeHeight(sourceVertices, index2);
    let normal2;
    if (sourceEncoding.hasVertexNormals) {
      normal2 = sourceEncoding.getOctEncodedNormal(
        sourceVertices,
        index2,
        octEncodedNormalScratch
      );
    } else {
      normal2 = octEncodedNormalScratch;
      normal2.x = 0;
      normal2.y = 0;
    }
    let webMercatorT = v7;
    if (sourceEncoding.hasWebMercatorT) {
      const latitude = Math_default.lerp(
        targetRectangle.south,
        targetRectangle.north,
        v7
      );
      webMercatorT = (WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(latitude) - southMercatorY) * oneOverMercatorHeight;
    }
    let geodeticSurfaceNormal;
    if (encoding.hasGeodeticSurfaceNormals) {
      geodeticSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
        position,
        normalScratch6
      );
    }
    encoding.encode(
      typedArray,
      nextIndex * targetStride,
      position,
      uv,
      height,
      normal2,
      webMercatorT,
      geodeticSurfaceNormal
    );
    heightRange.minimumHeight = Math.min(heightRange.minimumHeight, height);
    heightRange.maximumHeight = Math.max(heightRange.maximumHeight, height);
    ++nextIndex;
  }
  return nextIndex;
}
function getNearestHeightOnEdge(meshes, tiles, isNext, edge, u3, v7) {
  let meshStart;
  let meshEnd;
  let meshStep;
  if (isNext) {
    meshStart = 0;
    meshEnd = meshes.length;
    meshStep = 1;
  } else {
    meshStart = meshes.length - 1;
    meshEnd = -1;
    meshStep = -1;
  }
  for (let meshIndex = meshStart; meshIndex !== meshEnd; meshIndex += meshStep) {
    const mesh2 = meshes[meshIndex];
    const tile = tiles[meshIndex];
    if (!meshIsUsable(tile, mesh2)) {
      continue;
    }
    let indices2;
    switch (edge) {
      case TileEdge_default.WEST:
        indices2 = mesh2.westIndicesSouthToNorth;
        break;
      case TileEdge_default.SOUTH:
        indices2 = mesh2.southIndicesEastToWest;
        break;
      case TileEdge_default.EAST:
        indices2 = mesh2.eastIndicesNorthToSouth;
        break;
      case TileEdge_default.NORTH:
        indices2 = mesh2.northIndicesWestToEast;
        break;
    }
    const index2 = indices2[isNext ? 0 : indices2.length - 1];
    if (defined_default(index2)) {
      return mesh2.encoding.decodeHeight(mesh2.vertices, index2);
    }
  }
  return void 0;
}
function meshIsUsable(tile, mesh2) {
  return defined_default(mesh2) && (!defined_default(tile.data.fill) || !tile.data.fill.changedThisFrame);
}
function getCornerFromEdge(terrainFillMesh, ellipsoid, edgeMeshes, edgeTiles, isNext, u3, v7, vertex) {
  let edgeVertices;
  let compareU;
  let increasing;
  let vertexIndexIndex;
  let vertexIndex;
  const sourceTile = edgeTiles[isNext ? 0 : edgeMeshes.length - 1];
  const sourceMesh = edgeMeshes[isNext ? 0 : edgeMeshes.length - 1];
  if (meshIsUsable(sourceTile, sourceMesh)) {
    if (u3 === 0) {
      if (v7 === 0) {
        edgeVertices = isNext ? sourceMesh.northIndicesWestToEast : sourceMesh.eastIndicesNorthToSouth;
        compareU = isNext;
        increasing = isNext;
      } else {
        edgeVertices = isNext ? sourceMesh.eastIndicesNorthToSouth : sourceMesh.southIndicesEastToWest;
        compareU = !isNext;
        increasing = false;
      }
    } else if (v7 === 0) {
      edgeVertices = isNext ? sourceMesh.westIndicesSouthToNorth : sourceMesh.northIndicesWestToEast;
      compareU = !isNext;
      increasing = true;
    } else {
      edgeVertices = isNext ? sourceMesh.southIndicesEastToWest : sourceMesh.westIndicesSouthToNorth;
      compareU = isNext;
      increasing = !isNext;
    }
    if (edgeVertices.length > 0) {
      vertexIndexIndex = isNext ? 0 : edgeVertices.length - 1;
      vertexIndex = edgeVertices[vertexIndexIndex];
      sourceMesh.encoding.decodeTextureCoordinates(
        sourceMesh.vertices,
        vertexIndex,
        uvScratch
      );
      const targetUv = transformTextureCoordinates(
        sourceTile,
        terrainFillMesh.tile,
        uvScratch,
        uvScratch
      );
      if (targetUv.x === u3 && targetUv.y === v7) {
        getVertexFromTileAtCorner(sourceMesh, vertexIndex, u3, v7, vertex);
        return true;
      }
      vertexIndexIndex = binarySearch_default(edgeVertices, compareU ? u3 : v7, function(vertexIndex2, textureCoordinate) {
        sourceMesh.encoding.decodeTextureCoordinates(
          sourceMesh.vertices,
          vertexIndex2,
          uvScratch
        );
        const targetUv2 = transformTextureCoordinates(
          sourceTile,
          terrainFillMesh.tile,
          uvScratch,
          uvScratch
        );
        if (increasing) {
          if (compareU) {
            return targetUv2.x - u3;
          }
          return targetUv2.y - v7;
        } else if (compareU) {
          return u3 - targetUv2.x;
        }
        return v7 - targetUv2.y;
      });
      if (vertexIndexIndex < 0) {
        vertexIndexIndex = ~vertexIndexIndex;
        if (vertexIndexIndex > 0 && vertexIndexIndex < edgeVertices.length) {
          getInterpolatedVertexAtCorner(
            ellipsoid,
            sourceTile,
            terrainFillMesh.tile,
            sourceMesh,
            edgeVertices[vertexIndexIndex - 1],
            edgeVertices[vertexIndexIndex],
            u3,
            v7,
            compareU,
            vertex
          );
          return true;
        }
      } else {
        getVertexFromTileAtCorner(
          sourceMesh,
          edgeVertices[vertexIndexIndex],
          u3,
          v7,
          vertex
        );
        return true;
      }
    }
  }
  return false;
}
var cornerPositionsScratch = [
  new Cartesian3_default(),
  new Cartesian3_default(),
  new Cartesian3_default(),
  new Cartesian3_default()
];
function computeOccludeePoint(tileProvider, center, rectangle, minimumHeight, maximumHeight, result) {
  const ellipsoidalOccluder = tileProvider.quadtree._occluders.ellipsoid;
  const ellipsoid = ellipsoidalOccluder.ellipsoid;
  const cornerPositions = cornerPositionsScratch;
  Cartesian3_default.fromRadians(
    rectangle.west,
    rectangle.south,
    maximumHeight,
    ellipsoid,
    cornerPositions[0]
  );
  Cartesian3_default.fromRadians(
    rectangle.east,
    rectangle.south,
    maximumHeight,
    ellipsoid,
    cornerPositions[1]
  );
  Cartesian3_default.fromRadians(
    rectangle.west,
    rectangle.north,
    maximumHeight,
    ellipsoid,
    cornerPositions[2]
  );
  Cartesian3_default.fromRadians(
    rectangle.east,
    rectangle.north,
    maximumHeight,
    ellipsoid,
    cornerPositions[3]
  );
  return ellipsoidalOccluder.computeHorizonCullingPointPossiblyUnderEllipsoid(
    center,
    cornerPositions,
    minimumHeight,
    result
  );
}
var TerrainFillMesh_default = TerrainFillMesh;

// node_modules/cesium/Source/Scene/GlobeSurfaceTileProvider.js
function GlobeSurfaceTileProvider(options) {
  if (!defined_default(options)) {
    throw new DeveloperError_default("options is required.");
  }
  if (!defined_default(options.terrainProvider)) {
    throw new DeveloperError_default("options.terrainProvider is required.");
  } else if (!defined_default(options.imageryLayers)) {
    throw new DeveloperError_default("options.imageryLayers is required.");
  } else if (!defined_default(options.surfaceShaderSet)) {
    throw new DeveloperError_default("options.surfaceShaderSet is required.");
  }
  this.lightingFadeOutDistance = 65e5;
  this.lightingFadeInDistance = 9e6;
  this.hasWaterMask = false;
  this.oceanNormalMap = void 0;
  this.zoomedOutOceanSpecularIntensity = 0.5;
  this.enableLighting = false;
  this.dynamicAtmosphereLighting = false;
  this.dynamicAtmosphereLightingFromSun = false;
  this.showGroundAtmosphere = false;
  this.shadows = ShadowMode_default.RECEIVE_ONLY;
  this.fillHighlightColor = void 0;
  this.hueShift = 0;
  this.saturationShift = 0;
  this.brightnessShift = 0;
  this.showSkirts = true;
  this.backFaceCulling = true;
  this.undergroundColor = void 0;
  this.undergroundColorAlphaByDistance = void 0;
  this.lambertDiffuseMultiplier = 0;
  this.materialUniformMap = void 0;
  this._materialUniformMap = void 0;
  this._quadtree = void 0;
  this._terrainProvider = options.terrainProvider;
  this._imageryLayers = options.imageryLayers;
  this._surfaceShaderSet = options.surfaceShaderSet;
  this._renderState = void 0;
  this._blendRenderState = void 0;
  this._disableCullingRenderState = void 0;
  this._disableCullingBlendRenderState = void 0;
  this._errorEvent = new Event_default();
  this._imageryLayers.layerAdded.addEventListener(
    GlobeSurfaceTileProvider.prototype._onLayerAdded,
    this
  );
  this._imageryLayers.layerRemoved.addEventListener(
    GlobeSurfaceTileProvider.prototype._onLayerRemoved,
    this
  );
  this._imageryLayers.layerMoved.addEventListener(
    GlobeSurfaceTileProvider.prototype._onLayerMoved,
    this
  );
  this._imageryLayers.layerShownOrHidden.addEventListener(
    GlobeSurfaceTileProvider.prototype._onLayerShownOrHidden,
    this
  );
  this._imageryLayersUpdatedEvent = new Event_default();
  this._layerOrderChanged = false;
  this._tilesToRenderByTextureCount = [];
  this._drawCommands = [];
  this._uniformMaps = [];
  this._usedDrawCommands = 0;
  this._vertexArraysToDestroy = [];
  this._debug = {
    wireframe: false,
    boundingSphereTile: void 0
  };
  this._baseColor = void 0;
  this._firstPassInitialColor = void 0;
  this.baseColor = new Color_default(0, 0, 0.5, 1);
  this._clippingPlanes = void 0;
  this.cartographicLimitRectangle = Rectangle_default.clone(Rectangle_default.MAX_VALUE);
  this._hasLoadedTilesThisFrame = false;
  this._hasFillTilesThisFrame = false;
  this._oldTerrainExaggeration = void 0;
  this._oldTerrainExaggerationRelativeHeight = void 0;
}
Object.defineProperties(GlobeSurfaceTileProvider.prototype, {
  baseColor: {
    get: function() {
      return this._baseColor;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      this._baseColor = value;
      this._firstPassInitialColor = Cartesian4_default.fromColor(
        value,
        this._firstPassInitialColor
      );
    }
  },
  quadtree: {
    get: function() {
      return this._quadtree;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      this._quadtree = value;
    }
  },
  ready: {
    get: function() {
      return this._terrainProvider.ready && (this._imageryLayers.length === 0 || this._imageryLayers.get(0).imageryProvider.ready);
    }
  },
  tilingScheme: {
    get: function() {
      return this._terrainProvider.tilingScheme;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  imageryLayersUpdatedEvent: {
    get: function() {
      return this._imageryLayersUpdatedEvent;
    }
  },
  terrainProvider: {
    get: function() {
      return this._terrainProvider;
    },
    set: function(terrainProvider) {
      if (this._terrainProvider === terrainProvider) {
        return;
      }
      if (!defined_default(terrainProvider)) {
        throw new DeveloperError_default("terrainProvider is required.");
      }
      this._terrainProvider = terrainProvider;
      if (defined_default(this._quadtree)) {
        this._quadtree.invalidateAllTiles();
      }
    }
  },
  clippingPlanes: {
    get: function() {
      return this._clippingPlanes;
    },
    set: function(value) {
      ClippingPlaneCollection_default.setOwner(value, this, "_clippingPlanes");
    }
  }
});
function sortTileImageryByLayerIndex(a4, b) {
  let aImagery = a4.loadingImagery;
  if (!defined_default(aImagery)) {
    aImagery = a4.readyImagery;
  }
  let bImagery = b.loadingImagery;
  if (!defined_default(bImagery)) {
    bImagery = b.readyImagery;
  }
  return aImagery.imageryLayer._layerIndex - bImagery.imageryLayer._layerIndex;
}
GlobeSurfaceTileProvider.prototype.update = function(frameState) {
  this._imageryLayers._update();
};
function updateCredits(surface, frameState) {
  const creditDisplay = frameState.creditDisplay;
  if (surface._terrainProvider.ready && defined_default(surface._terrainProvider.credit)) {
    creditDisplay.addCredit(surface._terrainProvider.credit);
  }
  const imageryLayers = surface._imageryLayers;
  for (let i2 = 0, len = imageryLayers.length; i2 < len; ++i2) {
    const imageryProvider = imageryLayers.get(i2).imageryProvider;
    if (imageryProvider.ready && defined_default(imageryProvider.credit)) {
      creditDisplay.addCredit(imageryProvider.credit);
    }
  }
}
GlobeSurfaceTileProvider.prototype.initialize = function(frameState) {
  this._imageryLayers.queueReprojectionCommands(frameState);
  if (this._layerOrderChanged) {
    this._layerOrderChanged = false;
    this._quadtree.forEachLoadedTile(function(tile) {
      tile.data.imagery.sort(sortTileImageryByLayerIndex);
    });
  }
  updateCredits(this, frameState);
  const vertexArraysToDestroy = this._vertexArraysToDestroy;
  const length3 = vertexArraysToDestroy.length;
  for (let j = 0; j < length3; ++j) {
    GlobeSurfaceTile_default._freeVertexArray(vertexArraysToDestroy[j]);
  }
  vertexArraysToDestroy.length = 0;
};
GlobeSurfaceTileProvider.prototype.beginUpdate = function(frameState) {
  const tilesToRenderByTextureCount = this._tilesToRenderByTextureCount;
  for (let i2 = 0, len = tilesToRenderByTextureCount.length; i2 < len; ++i2) {
    const tiles = tilesToRenderByTextureCount[i2];
    if (defined_default(tiles)) {
      tiles.length = 0;
    }
  }
  const clippingPlanes = this._clippingPlanes;
  if (defined_default(clippingPlanes) && clippingPlanes.enabled) {
    clippingPlanes.update(frameState);
  }
  this._usedDrawCommands = 0;
  this._hasLoadedTilesThisFrame = false;
  this._hasFillTilesThisFrame = false;
};
GlobeSurfaceTileProvider.prototype.endUpdate = function(frameState) {
  if (!defined_default(this._renderState)) {
    this._renderState = RenderState_default.fromCache({
      cull: {
        enabled: true
      },
      depthTest: {
        enabled: true,
        func: DepthFunction_default.LESS
      }
    });
    this._blendRenderState = RenderState_default.fromCache({
      cull: {
        enabled: true
      },
      depthTest: {
        enabled: true,
        func: DepthFunction_default.LESS_OR_EQUAL
      },
      blending: BlendingState_default.ALPHA_BLEND
    });
    let rs = clone_default(this._renderState, true);
    rs.cull.enabled = false;
    this._disableCullingRenderState = RenderState_default.fromCache(rs);
    rs = clone_default(this._blendRenderState, true);
    rs.cull.enabled = false;
    this._disableCullingBlendRenderState = RenderState_default.fromCache(rs);
  }
  if (this._hasFillTilesThisFrame && this._hasLoadedTilesThisFrame) {
    TerrainFillMesh_default.updateFillTiles(
      this,
      this._quadtree._tilesToRender,
      frameState,
      this._vertexArraysToDestroy
    );
  }
  const quadtree = this.quadtree;
  const exaggeration = frameState.terrainExaggeration;
  const exaggerationRelativeHeight = frameState.terrainExaggerationRelativeHeight;
  const exaggerationChanged = this._oldTerrainExaggeration !== exaggeration || this._oldTerrainExaggerationRelativeHeight !== exaggerationRelativeHeight;
  this._oldTerrainExaggeration = exaggeration;
  this._oldTerrainExaggerationRelativeHeight = exaggerationRelativeHeight;
  if (exaggerationChanged) {
    quadtree.forEachLoadedTile(function(tile) {
      const surfaceTile = tile.data;
      surfaceTile.updateExaggeration(tile, frameState, quadtree);
    });
  }
  const tilesToRenderByTextureCount = this._tilesToRenderByTextureCount;
  for (let textureCountIndex = 0, textureCountLength = tilesToRenderByTextureCount.length; textureCountIndex < textureCountLength; ++textureCountIndex) {
    const tilesToRender = tilesToRenderByTextureCount[textureCountIndex];
    if (!defined_default(tilesToRender)) {
      continue;
    }
    for (let tileIndex = 0, tileLength = tilesToRender.length; tileIndex < tileLength; ++tileIndex) {
      const tile = tilesToRender[tileIndex];
      const tileBoundingRegion = tile.data.tileBoundingRegion;
      addDrawCommandsForTile(this, tile, frameState);
      frameState.minimumTerrainHeight = Math.min(
        frameState.minimumTerrainHeight,
        tileBoundingRegion.minimumHeight
      );
    }
  }
};
function pushCommand(command, frameState) {
  const globeTranslucencyState = frameState.globeTranslucencyState;
  if (globeTranslucencyState.translucent) {
    const isBlendCommand = command.renderState.blending.enabled;
    globeTranslucencyState.pushDerivedCommands(
      command,
      isBlendCommand,
      frameState
    );
  } else {
    frameState.commandList.push(command);
  }
}
GlobeSurfaceTileProvider.prototype.updateForPick = function(frameState) {
  const drawCommands = this._drawCommands;
  for (let i2 = 0, length3 = this._usedDrawCommands; i2 < length3; ++i2) {
    pushCommand(drawCommands[i2], frameState);
  }
};
GlobeSurfaceTileProvider.prototype.cancelReprojections = function() {
  this._imageryLayers.cancelReprojections();
};
GlobeSurfaceTileProvider.prototype.getLevelMaximumGeometricError = function(level) {
  return this._terrainProvider.getLevelMaximumGeometricError(level);
};
GlobeSurfaceTileProvider.prototype.loadTile = function(frameState, tile) {
  let surfaceTile = tile.data;
  let terrainOnly = true;
  let terrainStateBefore;
  if (defined_default(surfaceTile)) {
    terrainOnly = surfaceTile.boundingVolumeSourceTile !== tile || tile._lastSelectionResult === TileSelectionResult_default.CULLED_BUT_NEEDED;
    terrainStateBefore = surfaceTile.terrainState;
  }
  GlobeSurfaceTile_default.processStateMachine(
    tile,
    frameState,
    this.terrainProvider,
    this._imageryLayers,
    this.quadtree,
    this._vertexArraysToDestroy,
    terrainOnly
  );
  surfaceTile = tile.data;
  if (terrainOnly && terrainStateBefore !== tile.data.terrainState) {
    if (this.computeTileVisibility(tile, frameState, this.quadtree.occluders) !== Visibility_default.NONE && surfaceTile.boundingVolumeSourceTile === tile) {
      terrainOnly = false;
      GlobeSurfaceTile_default.processStateMachine(
        tile,
        frameState,
        this.terrainProvider,
        this._imageryLayers,
        this.quadtree,
        this._vertexArraysToDestroy,
        terrainOnly
      );
    }
  }
};
var boundingSphereScratch3 = new BoundingSphere_default();
var rectangleIntersectionScratch = new Rectangle_default();
var splitCartographicLimitRectangleScratch = new Rectangle_default();
var rectangleCenterScratch4 = new Cartographic_default();
function clipRectangleAntimeridian(tileRectangle, cartographicLimitRectangle) {
  if (cartographicLimitRectangle.west < cartographicLimitRectangle.east) {
    return cartographicLimitRectangle;
  }
  const splitRectangle = Rectangle_default.clone(
    cartographicLimitRectangle,
    splitCartographicLimitRectangleScratch
  );
  const tileCenter = Rectangle_default.center(tileRectangle, rectangleCenterScratch4);
  if (tileCenter.longitude > 0) {
    splitRectangle.east = Math_default.PI;
  } else {
    splitRectangle.west = -Math_default.PI;
  }
  return splitRectangle;
}
function isUndergroundVisible(tileProvider, frameState) {
  if (frameState.cameraUnderground) {
    return true;
  }
  if (frameState.globeTranslucencyState.translucent) {
    return true;
  }
  if (tileProvider.backFaceCulling) {
    return false;
  }
  const clippingPlanes = tileProvider._clippingPlanes;
  if (defined_default(clippingPlanes) && clippingPlanes.enabled) {
    return true;
  }
  if (!Rectangle_default.equals(
    tileProvider.cartographicLimitRectangle,
    Rectangle_default.MAX_VALUE
  )) {
    return true;
  }
  return false;
}
GlobeSurfaceTileProvider.prototype.computeTileVisibility = function(tile, frameState, occluders) {
  const distance2 = this.computeDistanceToTile(tile, frameState);
  tile._distance = distance2;
  const undergroundVisible = isUndergroundVisible(this, frameState);
  if (frameState.fog.enabled && !undergroundVisible) {
    if (Math_default.fog(distance2, frameState.fog.density) >= 1) {
      return Visibility_default.NONE;
    }
  }
  const surfaceTile = tile.data;
  const tileBoundingRegion = surfaceTile.tileBoundingRegion;
  if (surfaceTile.boundingVolumeSourceTile === void 0) {
    return Visibility_default.PARTIAL;
  }
  const cullingVolume = frameState.cullingVolume;
  let boundingVolume = tileBoundingRegion.boundingVolume;
  if (!defined_default(boundingVolume)) {
    boundingVolume = tileBoundingRegion.boundingSphere;
  }
  surfaceTile.clippedByBoundaries = false;
  const clippedCartographicLimitRectangle = clipRectangleAntimeridian(
    tile.rectangle,
    this.cartographicLimitRectangle
  );
  const areaLimitIntersection = Rectangle_default.simpleIntersection(
    clippedCartographicLimitRectangle,
    tile.rectangle,
    rectangleIntersectionScratch
  );
  if (!defined_default(areaLimitIntersection)) {
    return Visibility_default.NONE;
  }
  if (!Rectangle_default.equals(areaLimitIntersection, tile.rectangle)) {
    surfaceTile.clippedByBoundaries = true;
  }
  if (frameState.mode !== SceneMode_default.SCENE3D) {
    boundingVolume = boundingSphereScratch3;
    BoundingSphere_default.fromRectangleWithHeights2D(
      tile.rectangle,
      frameState.mapProjection,
      tileBoundingRegion.minimumHeight,
      tileBoundingRegion.maximumHeight,
      boundingVolume
    );
    Cartesian3_default.fromElements(
      boundingVolume.center.z,
      boundingVolume.center.x,
      boundingVolume.center.y,
      boundingVolume.center
    );
    if (frameState.mode === SceneMode_default.MORPHING && defined_default(surfaceTile.renderedMesh)) {
      boundingVolume = BoundingSphere_default.union(
        tileBoundingRegion.boundingSphere,
        boundingVolume,
        boundingVolume
      );
    }
  }
  if (!defined_default(boundingVolume)) {
    return Visibility_default.PARTIAL;
  }
  const clippingPlanes = this._clippingPlanes;
  if (defined_default(clippingPlanes) && clippingPlanes.enabled) {
    const planeIntersection = clippingPlanes.computeIntersectionWithBoundingVolume(
      boundingVolume
    );
    tile.isClipped = planeIntersection !== Intersect_default.INSIDE;
    if (planeIntersection === Intersect_default.OUTSIDE) {
      return Visibility_default.NONE;
    }
  }
  let visibility;
  const intersection = cullingVolume.computeVisibility(boundingVolume);
  if (intersection === Intersect_default.OUTSIDE) {
    visibility = Visibility_default.NONE;
  } else if (intersection === Intersect_default.INTERSECTING) {
    visibility = Visibility_default.PARTIAL;
  } else if (intersection === Intersect_default.INSIDE) {
    visibility = Visibility_default.FULL;
  }
  if (visibility === Visibility_default.NONE) {
    return visibility;
  }
  const ortho3D = frameState.mode === SceneMode_default.SCENE3D && frameState.camera.frustum instanceof OrthographicFrustum_default;
  if (frameState.mode === SceneMode_default.SCENE3D && !ortho3D && defined_default(occluders) && !undergroundVisible) {
    const occludeePointInScaledSpace = surfaceTile.occludeePointInScaledSpace;
    if (!defined_default(occludeePointInScaledSpace)) {
      return visibility;
    }
    if (occluders.ellipsoid.isScaledSpacePointVisiblePossiblyUnderEllipsoid(
      occludeePointInScaledSpace,
      tileBoundingRegion.minimumHeight
    )) {
      return visibility;
    }
    return Visibility_default.NONE;
  }
  return visibility;
};
GlobeSurfaceTileProvider.prototype.canRefine = function(tile) {
  if (defined_default(tile.data.terrainData)) {
    return true;
  }
  const childAvailable = this.terrainProvider.getTileDataAvailable(
    tile.x * 2,
    tile.y * 2,
    tile.level + 1
  );
  return childAvailable !== void 0;
};
var readyImageryScratch = [];
var canRenderTraversalStack = [];
GlobeSurfaceTileProvider.prototype.canRenderWithoutLosingDetail = function(tile, frameState) {
  const surfaceTile = tile.data;
  const readyImagery = readyImageryScratch;
  readyImagery.length = this._imageryLayers.length;
  let terrainReady = false;
  let initialImageryState = false;
  let imagery;
  if (defined_default(surfaceTile)) {
    terrainReady = surfaceTile.terrainState === TerrainState_default.READY;
    initialImageryState = true;
    imagery = surfaceTile.imagery;
  }
  let i2;
  let len;
  for (i2 = 0, len = readyImagery.length; i2 < len; ++i2) {
    readyImagery[i2] = initialImageryState;
  }
  if (defined_default(imagery)) {
    for (i2 = 0, len = imagery.length; i2 < len; ++i2) {
      const tileImagery = imagery[i2];
      const loadingImagery = tileImagery.loadingImagery;
      const isReady = !defined_default(loadingImagery) || loadingImagery.state === ImageryState_default.FAILED || loadingImagery.state === ImageryState_default.INVALID;
      const layerIndex = (tileImagery.loadingImagery || tileImagery.readyImagery).imageryLayer._layerIndex;
      readyImagery[layerIndex] = isReady && readyImagery[layerIndex];
    }
  }
  const lastFrame = this.quadtree._lastSelectionFrameNumber;
  const stack = canRenderTraversalStack;
  stack.length = 0;
  stack.push(
    tile.southwestChild,
    tile.southeastChild,
    tile.northwestChild,
    tile.northeastChild
  );
  while (stack.length > 0) {
    const descendant = stack.pop();
    const lastFrameSelectionResult = descendant._lastSelectionResultFrame === lastFrame ? descendant._lastSelectionResult : TileSelectionResult_default.NONE;
    if (lastFrameSelectionResult === TileSelectionResult_default.RENDERED) {
      const descendantSurface = descendant.data;
      if (!defined_default(descendantSurface)) {
        continue;
      }
      if (!terrainReady && descendant.data.terrainState === TerrainState_default.READY) {
        return false;
      }
      const descendantImagery = descendant.data.imagery;
      for (i2 = 0, len = descendantImagery.length; i2 < len; ++i2) {
        const descendantTileImagery = descendantImagery[i2];
        const descendantLoadingImagery = descendantTileImagery.loadingImagery;
        const descendantIsReady = !defined_default(descendantLoadingImagery) || descendantLoadingImagery.state === ImageryState_default.FAILED || descendantLoadingImagery.state === ImageryState_default.INVALID;
        const descendantLayerIndex = (descendantTileImagery.loadingImagery || descendantTileImagery.readyImagery).imageryLayer._layerIndex;
        if (descendantIsReady && !readyImagery[descendantLayerIndex]) {
          return false;
        }
      }
    } else if (lastFrameSelectionResult === TileSelectionResult_default.REFINED) {
      stack.push(
        descendant.southwestChild,
        descendant.southeastChild,
        descendant.northwestChild,
        descendant.northeastChild
      );
    }
  }
  return true;
};
var tileDirectionScratch = new Cartesian3_default();
GlobeSurfaceTileProvider.prototype.computeTileLoadPriority = function(tile, frameState) {
  const surfaceTile = tile.data;
  if (surfaceTile === void 0) {
    return 0;
  }
  const obb = surfaceTile.tileBoundingRegion.boundingVolume;
  if (obb === void 0) {
    return 0;
  }
  const cameraPosition = frameState.camera.positionWC;
  const cameraDirection = frameState.camera.directionWC;
  const tileDirection = Cartesian3_default.subtract(
    obb.center,
    cameraPosition,
    tileDirectionScratch
  );
  const magnitude = Cartesian3_default.magnitude(tileDirection);
  if (magnitude < Math_default.EPSILON5) {
    return 0;
  }
  Cartesian3_default.divideByScalar(tileDirection, magnitude, tileDirection);
  return (1 - Cartesian3_default.dot(tileDirection, cameraDirection)) * tile._distance;
};
var modifiedModelViewScratch5 = new Matrix4_default();
var modifiedModelViewProjectionScratch = new Matrix4_default();
var tileRectangleScratch = new Cartesian4_default();
var localizedCartographicLimitRectangleScratch = new Cartesian4_default();
var localizedTranslucencyRectangleScratch = new Cartesian4_default();
var rtcScratch5 = new Cartesian3_default();
var centerEyeScratch = new Cartesian3_default();
var southwestScratch = new Cartesian3_default();
var northeastScratch = new Cartesian3_default();
GlobeSurfaceTileProvider.prototype.showTileThisFrame = function(tile, frameState) {
  let readyTextureCount = 0;
  const tileImageryCollection = tile.data.imagery;
  for (let i2 = 0, len = tileImageryCollection.length; i2 < len; ++i2) {
    const tileImagery = tileImageryCollection[i2];
    if (defined_default(tileImagery.readyImagery) && tileImagery.readyImagery.imageryLayer.alpha !== 0) {
      ++readyTextureCount;
    }
  }
  let tileSet = this._tilesToRenderByTextureCount[readyTextureCount];
  if (!defined_default(tileSet)) {
    tileSet = [];
    this._tilesToRenderByTextureCount[readyTextureCount] = tileSet;
  }
  tileSet.push(tile);
  const surfaceTile = tile.data;
  if (!defined_default(surfaceTile.vertexArray)) {
    this._hasFillTilesThisFrame = true;
  } else {
    this._hasLoadedTilesThisFrame = true;
  }
  const debug = this._debug;
  ++debug.tilesRendered;
  debug.texturesRendered += readyTextureCount;
};
var cornerPositionsScratch2 = [
  new Cartesian3_default(),
  new Cartesian3_default(),
  new Cartesian3_default(),
  new Cartesian3_default()
];
function computeOccludeePoint2(tileProvider, center, rectangle, minimumHeight, maximumHeight, result) {
  const ellipsoidalOccluder = tileProvider.quadtree._occluders.ellipsoid;
  const ellipsoid = ellipsoidalOccluder.ellipsoid;
  const cornerPositions = cornerPositionsScratch2;
  Cartesian3_default.fromRadians(
    rectangle.west,
    rectangle.south,
    maximumHeight,
    ellipsoid,
    cornerPositions[0]
  );
  Cartesian3_default.fromRadians(
    rectangle.east,
    rectangle.south,
    maximumHeight,
    ellipsoid,
    cornerPositions[1]
  );
  Cartesian3_default.fromRadians(
    rectangle.west,
    rectangle.north,
    maximumHeight,
    ellipsoid,
    cornerPositions[2]
  );
  Cartesian3_default.fromRadians(
    rectangle.east,
    rectangle.north,
    maximumHeight,
    ellipsoid,
    cornerPositions[3]
  );
  return ellipsoidalOccluder.computeHorizonCullingPointPossiblyUnderEllipsoid(
    center,
    cornerPositions,
    minimumHeight,
    result
  );
}
GlobeSurfaceTileProvider.prototype.computeDistanceToTile = function(tile, frameState) {
  updateTileBoundingRegion(tile, this, frameState);
  const surfaceTile = tile.data;
  const boundingVolumeSourceTile = surfaceTile.boundingVolumeSourceTile;
  if (boundingVolumeSourceTile === void 0) {
    return 9999999999;
  }
  const tileBoundingRegion = surfaceTile.tileBoundingRegion;
  const min3 = tileBoundingRegion.minimumHeight;
  const max3 = tileBoundingRegion.maximumHeight;
  if (surfaceTile.boundingVolumeSourceTile !== tile) {
    const cameraHeight = frameState.camera.positionCartographic.height;
    const distanceToMin = Math.abs(cameraHeight - min3);
    const distanceToMax = Math.abs(cameraHeight - max3);
    if (distanceToMin > distanceToMax) {
      tileBoundingRegion.minimumHeight = min3;
      tileBoundingRegion.maximumHeight = min3;
    } else {
      tileBoundingRegion.minimumHeight = max3;
      tileBoundingRegion.maximumHeight = max3;
    }
  }
  const result = tileBoundingRegion.distanceToCamera(frameState);
  tileBoundingRegion.minimumHeight = min3;
  tileBoundingRegion.maximumHeight = max3;
  return result;
};
function updateTileBoundingRegion(tile, tileProvider, frameState) {
  let surfaceTile = tile.data;
  if (surfaceTile === void 0) {
    surfaceTile = tile.data = new GlobeSurfaceTile_default();
  }
  const ellipsoid = tile.tilingScheme.ellipsoid;
  if (surfaceTile.tileBoundingRegion === void 0) {
    surfaceTile.tileBoundingRegion = new TileBoundingRegion_default({
      computeBoundingVolumes: false,
      rectangle: tile.rectangle,
      ellipsoid,
      minimumHeight: 0,
      maximumHeight: 0
    });
  }
  const tileBoundingRegion = surfaceTile.tileBoundingRegion;
  const oldMinimumHeight = tileBoundingRegion.minimumHeight;
  const oldMaximumHeight = tileBoundingRegion.maximumHeight;
  let hasBoundingVolumesFromMesh = false;
  let sourceTile = tile;
  const mesh2 = surfaceTile.mesh;
  const terrainData = surfaceTile.terrainData;
  if (mesh2 !== void 0 && mesh2.minimumHeight !== void 0 && mesh2.maximumHeight !== void 0) {
    tileBoundingRegion.minimumHeight = mesh2.minimumHeight;
    tileBoundingRegion.maximumHeight = mesh2.maximumHeight;
    hasBoundingVolumesFromMesh = true;
  } else if (terrainData !== void 0 && terrainData._minimumHeight !== void 0 && terrainData._maximumHeight !== void 0) {
    tileBoundingRegion.minimumHeight = terrainData._minimumHeight;
    tileBoundingRegion.maximumHeight = terrainData._maximumHeight;
  } else {
    tileBoundingRegion.minimumHeight = Number.NaN;
    tileBoundingRegion.maximumHeight = Number.NaN;
    let ancestorTile = tile.parent;
    while (ancestorTile !== void 0) {
      const ancestorSurfaceTile = ancestorTile.data;
      if (ancestorSurfaceTile !== void 0) {
        const ancestorMesh = ancestorSurfaceTile.mesh;
        const ancestorTerrainData = ancestorSurfaceTile.terrainData;
        if (ancestorMesh !== void 0 && ancestorMesh.minimumHeight !== void 0 && ancestorMesh.maximumHeight !== void 0) {
          tileBoundingRegion.minimumHeight = ancestorMesh.minimumHeight;
          tileBoundingRegion.maximumHeight = ancestorMesh.maximumHeight;
          break;
        } else if (ancestorTerrainData !== void 0 && ancestorTerrainData._minimumHeight !== void 0 && ancestorTerrainData._maximumHeight !== void 0) {
          tileBoundingRegion.minimumHeight = ancestorTerrainData._minimumHeight;
          tileBoundingRegion.maximumHeight = ancestorTerrainData._maximumHeight;
          break;
        }
      }
      ancestorTile = ancestorTile.parent;
    }
    sourceTile = ancestorTile;
  }
  if (sourceTile !== void 0) {
    const exaggeration = frameState.terrainExaggeration;
    const exaggerationRelativeHeight = frameState.terrainExaggerationRelativeHeight;
    const hasExaggeration = exaggeration !== 1;
    if (hasExaggeration) {
      hasBoundingVolumesFromMesh = false;
      tileBoundingRegion.minimumHeight = TerrainExaggeration_default.getHeight(
        tileBoundingRegion.minimumHeight,
        exaggeration,
        exaggerationRelativeHeight
      );
      tileBoundingRegion.maximumHeight = TerrainExaggeration_default.getHeight(
        tileBoundingRegion.maximumHeight,
        exaggeration,
        exaggerationRelativeHeight
      );
    }
    if (hasBoundingVolumesFromMesh) {
      if (!surfaceTile.boundingVolumeIsFromMesh) {
        tileBoundingRegion._orientedBoundingBox = OrientedBoundingBox_default.clone(
          mesh2.orientedBoundingBox,
          tileBoundingRegion._orientedBoundingBox
        );
        tileBoundingRegion._boundingSphere = BoundingSphere_default.clone(
          mesh2.boundingSphere3D,
          tileBoundingRegion._boundingSphere
        );
        surfaceTile.occludeePointInScaledSpace = Cartesian3_default.clone(
          mesh2.occludeePointInScaledSpace,
          surfaceTile.occludeePointInScaledSpace
        );
        if (!defined_default(surfaceTile.occludeePointInScaledSpace)) {
          surfaceTile.occludeePointInScaledSpace = computeOccludeePoint2(
            tileProvider,
            tileBoundingRegion._orientedBoundingBox.center,
            tile.rectangle,
            tileBoundingRegion.minimumHeight,
            tileBoundingRegion.maximumHeight,
            surfaceTile.occludeePointInScaledSpace
          );
        }
      }
    } else {
      const needsBounds = tileBoundingRegion._orientedBoundingBox === void 0 || tileBoundingRegion._boundingSphere === void 0;
      const heightChanged = tileBoundingRegion.minimumHeight !== oldMinimumHeight || tileBoundingRegion.maximumHeight !== oldMaximumHeight;
      if (heightChanged || needsBounds) {
        tileBoundingRegion.computeBoundingVolumes(ellipsoid);
        surfaceTile.occludeePointInScaledSpace = computeOccludeePoint2(
          tileProvider,
          tileBoundingRegion._orientedBoundingBox.center,
          tile.rectangle,
          tileBoundingRegion.minimumHeight,
          tileBoundingRegion.maximumHeight,
          surfaceTile.occludeePointInScaledSpace
        );
      }
    }
    surfaceTile.boundingVolumeSourceTile = sourceTile;
    surfaceTile.boundingVolumeIsFromMesh = hasBoundingVolumesFromMesh;
  } else {
    surfaceTile.boundingVolumeSourceTile = void 0;
    surfaceTile.boundingVolumeIsFromMesh = false;
  }
}
GlobeSurfaceTileProvider.prototype.isDestroyed = function() {
  return false;
};
GlobeSurfaceTileProvider.prototype.destroy = function() {
  this._tileProvider = this._tileProvider && this._tileProvider.destroy();
  this._clippingPlanes = this._clippingPlanes && this._clippingPlanes.destroy();
  return destroyObject_default(this);
};
function getTileReadyCallback(tileImageriesToFree, layer, terrainProvider) {
  return function(tile) {
    let tileImagery;
    let imagery;
    let startIndex = -1;
    const tileImageryCollection = tile.data.imagery;
    const length3 = tileImageryCollection.length;
    let i2;
    for (i2 = 0; i2 < length3; ++i2) {
      tileImagery = tileImageryCollection[i2];
      imagery = defaultValue_default(
        tileImagery.readyImagery,
        tileImagery.loadingImagery
      );
      if (imagery.imageryLayer === layer) {
        startIndex = i2;
        break;
      }
    }
    if (startIndex !== -1) {
      const endIndex = startIndex + tileImageriesToFree;
      tileImagery = tileImageryCollection[endIndex];
      imagery = defined_default(tileImagery) ? defaultValue_default(tileImagery.readyImagery, tileImagery.loadingImagery) : void 0;
      if (!defined_default(imagery) || imagery.imageryLayer !== layer) {
        return !layer._createTileImagerySkeletons(
          tile,
          terrainProvider,
          endIndex
        );
      }
      for (i2 = startIndex; i2 < endIndex; ++i2) {
        tileImageryCollection[i2].freeResources();
      }
      tileImageryCollection.splice(startIndex, tileImageriesToFree);
    }
    return true;
  };
}
GlobeSurfaceTileProvider.prototype._onLayerAdded = function(layer, index2) {
  if (layer.show) {
    const terrainProvider = this._terrainProvider;
    const that = this;
    const imageryProvider = layer.imageryProvider;
    const tileImageryUpdatedEvent = this._imageryLayersUpdatedEvent;
    imageryProvider._reload = function() {
      layer._imageryCache = {};
      that._quadtree.forEachLoadedTile(function(tile) {
        if (defined_default(tile._loadedCallbacks[layer._layerIndex])) {
          return;
        }
        let i2;
        const tileImageryCollection = tile.data.imagery;
        const length3 = tileImageryCollection.length;
        let startIndex = -1;
        let tileImageriesToFree = 0;
        for (i2 = 0; i2 < length3; ++i2) {
          const tileImagery = tileImageryCollection[i2];
          const imagery = defaultValue_default(
            tileImagery.readyImagery,
            tileImagery.loadingImagery
          );
          if (imagery.imageryLayer === layer) {
            if (startIndex === -1) {
              startIndex = i2;
            }
            ++tileImageriesToFree;
          } else if (startIndex !== -1) {
            break;
          }
        }
        if (startIndex === -1) {
          return;
        }
        const insertionPoint = startIndex + tileImageriesToFree;
        if (layer._createTileImagerySkeletons(
          tile,
          terrainProvider,
          insertionPoint
        )) {
          tile._loadedCallbacks[layer._layerIndex] = getTileReadyCallback(
            tileImageriesToFree,
            layer,
            terrainProvider
          );
          tile.state = QuadtreeTileLoadState_default.LOADING;
        }
      });
    };
    this._quadtree.forEachLoadedTile(function(tile) {
      if (layer._createTileImagerySkeletons(tile, terrainProvider)) {
        tile.state = QuadtreeTileLoadState_default.LOADING;
        if (tile.level !== 0 && (tile._lastSelectionResultFrame !== that.quadtree._lastSelectionFrameNumber || tile._lastSelectionResult !== TileSelectionResult_default.RENDERED)) {
          tile.renderable = false;
        }
      }
    });
    this._layerOrderChanged = true;
    tileImageryUpdatedEvent.raiseEvent();
  }
};
GlobeSurfaceTileProvider.prototype._onLayerRemoved = function(layer, index2) {
  this._quadtree.forEachLoadedTile(function(tile) {
    const tileImageryCollection = tile.data.imagery;
    let startIndex = -1;
    let numDestroyed = 0;
    for (let i2 = 0, len = tileImageryCollection.length; i2 < len; ++i2) {
      const tileImagery = tileImageryCollection[i2];
      let imagery = tileImagery.loadingImagery;
      if (!defined_default(imagery)) {
        imagery = tileImagery.readyImagery;
      }
      if (imagery.imageryLayer === layer) {
        if (startIndex === -1) {
          startIndex = i2;
        }
        tileImagery.freeResources();
        ++numDestroyed;
      } else if (startIndex !== -1) {
        break;
      }
    }
    if (startIndex !== -1) {
      tileImageryCollection.splice(startIndex, numDestroyed);
    }
  });
  if (defined_default(layer.imageryProvider)) {
    layer.imageryProvider._reload = void 0;
  }
  this._imageryLayersUpdatedEvent.raiseEvent();
};
GlobeSurfaceTileProvider.prototype._onLayerMoved = function(layer, newIndex, oldIndex) {
  this._layerOrderChanged = true;
  this._imageryLayersUpdatedEvent.raiseEvent();
};
GlobeSurfaceTileProvider.prototype._onLayerShownOrHidden = function(layer, index2, show) {
  if (show) {
    this._onLayerAdded(layer, index2);
  } else {
    this._onLayerRemoved(layer, index2);
  }
};
var scratchClippingPlanesMatrix4 = new Matrix4_default();
var scratchInverseTransposeClippingPlanesMatrix2 = new Matrix4_default();
function createTileUniformMap(frameState, globeSurfaceTileProvider) {
  const uniformMap2 = {
    u_initialColor: function() {
      return this.properties.initialColor;
    },
    u_fillHighlightColor: function() {
      return this.properties.fillHighlightColor;
    },
    u_zoomedOutOceanSpecularIntensity: function() {
      return this.properties.zoomedOutOceanSpecularIntensity;
    },
    u_oceanNormalMap: function() {
      return this.properties.oceanNormalMap;
    },
    u_atmosphereLightIntensity: function() {
      return this.properties.atmosphereLightIntensity;
    },
    u_atmosphereRayleighCoefficient: function() {
      return this.properties.atmosphereRayleighCoefficient;
    },
    u_atmosphereMieCoefficient: function() {
      return this.properties.atmosphereMieCoefficient;
    },
    u_atmosphereRayleighScaleHeight: function() {
      return this.properties.atmosphereRayleighScaleHeight;
    },
    u_atmosphereMieScaleHeight: function() {
      return this.properties.atmosphereMieScaleHeight;
    },
    u_atmosphereMieAnisotropy: function() {
      return this.properties.atmosphereMieAnisotropy;
    },
    u_lightingFadeDistance: function() {
      return this.properties.lightingFadeDistance;
    },
    u_nightFadeDistance: function() {
      return this.properties.nightFadeDistance;
    },
    u_center3D: function() {
      return this.properties.center3D;
    },
    u_terrainExaggerationAndRelativeHeight: function() {
      return this.properties.terrainExaggerationAndRelativeHeight;
    },
    u_tileRectangle: function() {
      return this.properties.tileRectangle;
    },
    u_modifiedModelView: function() {
      const viewMatrix = frameState.context.uniformState.view;
      const centerEye = Matrix4_default.multiplyByPoint(
        viewMatrix,
        this.properties.rtc,
        centerEyeScratch
      );
      Matrix4_default.setTranslation(viewMatrix, centerEye, modifiedModelViewScratch5);
      return modifiedModelViewScratch5;
    },
    u_modifiedModelViewProjection: function() {
      const viewMatrix = frameState.context.uniformState.view;
      const projectionMatrix = frameState.context.uniformState.projection;
      const centerEye = Matrix4_default.multiplyByPoint(
        viewMatrix,
        this.properties.rtc,
        centerEyeScratch
      );
      Matrix4_default.setTranslation(
        viewMatrix,
        centerEye,
        modifiedModelViewProjectionScratch
      );
      Matrix4_default.multiply(
        projectionMatrix,
        modifiedModelViewProjectionScratch,
        modifiedModelViewProjectionScratch
      );
      return modifiedModelViewProjectionScratch;
    },
    u_dayTextures: function() {
      return this.properties.dayTextures;
    },
    u_dayTextureTranslationAndScale: function() {
      return this.properties.dayTextureTranslationAndScale;
    },
    u_dayTextureTexCoordsRectangle: function() {
      return this.properties.dayTextureTexCoordsRectangle;
    },
    u_dayTextureUseWebMercatorT: function() {
      return this.properties.dayTextureUseWebMercatorT;
    },
    u_dayTextureAlpha: function() {
      return this.properties.dayTextureAlpha;
    },
    u_dayTextureNightAlpha: function() {
      return this.properties.dayTextureNightAlpha;
    },
    u_dayTextureDayAlpha: function() {
      return this.properties.dayTextureDayAlpha;
    },
    u_dayTextureBrightness: function() {
      return this.properties.dayTextureBrightness;
    },
    u_dayTextureContrast: function() {
      return this.properties.dayTextureContrast;
    },
    u_dayTextureHue: function() {
      return this.properties.dayTextureHue;
    },
    u_dayTextureSaturation: function() {
      return this.properties.dayTextureSaturation;
    },
    u_dayTextureOneOverGamma: function() {
      return this.properties.dayTextureOneOverGamma;
    },
    u_dayIntensity: function() {
      return this.properties.dayIntensity;
    },
    u_southAndNorthLatitude: function() {
      return this.properties.southAndNorthLatitude;
    },
    u_southMercatorYAndOneOverHeight: function() {
      return this.properties.southMercatorYAndOneOverHeight;
    },
    u_waterMask: function() {
      return this.properties.waterMask;
    },
    u_waterMaskTranslationAndScale: function() {
      return this.properties.waterMaskTranslationAndScale;
    },
    u_minMaxHeight: function() {
      return this.properties.minMaxHeight;
    },
    u_scaleAndBias: function() {
      return this.properties.scaleAndBias;
    },
    u_dayTextureSplit: function() {
      return this.properties.dayTextureSplit;
    },
    u_dayTextureCutoutRectangles: function() {
      return this.properties.dayTextureCutoutRectangles;
    },
    u_clippingPlanes: function() {
      const clippingPlanes = globeSurfaceTileProvider._clippingPlanes;
      if (defined_default(clippingPlanes) && defined_default(clippingPlanes.texture)) {
        return clippingPlanes.texture;
      }
      return frameState.context.defaultTexture;
    },
    u_cartographicLimitRectangle: function() {
      return this.properties.localizedCartographicLimitRectangle;
    },
    u_clippingPlanesMatrix: function() {
      const clippingPlanes = globeSurfaceTileProvider._clippingPlanes;
      const transform4 = defined_default(clippingPlanes) ? Matrix4_default.multiply(
        frameState.context.uniformState.view,
        clippingPlanes.modelMatrix,
        scratchClippingPlanesMatrix4
      ) : Matrix4_default.IDENTITY;
      return Matrix4_default.inverseTranspose(
        transform4,
        scratchInverseTransposeClippingPlanesMatrix2
      );
    },
    u_clippingPlanesEdgeStyle: function() {
      const style = this.properties.clippingPlanesEdgeColor;
      style.alpha = this.properties.clippingPlanesEdgeWidth;
      return style;
    },
    u_minimumBrightness: function() {
      return frameState.fog.minimumBrightness;
    },
    u_hsbShift: function() {
      return this.properties.hsbShift;
    },
    u_colorsToAlpha: function() {
      return this.properties.colorsToAlpha;
    },
    u_frontFaceAlphaByDistance: function() {
      return this.properties.frontFaceAlphaByDistance;
    },
    u_backFaceAlphaByDistance: function() {
      return this.properties.backFaceAlphaByDistance;
    },
    u_translucencyRectangle: function() {
      return this.properties.localizedTranslucencyRectangle;
    },
    u_undergroundColor: function() {
      return this.properties.undergroundColor;
    },
    u_undergroundColorAlphaByDistance: function() {
      return this.properties.undergroundColorAlphaByDistance;
    },
    u_lambertDiffuseMultiplier: function() {
      return this.properties.lambertDiffuseMultiplier;
    },
    properties: {
      initialColor: new Cartesian4_default(0, 0, 0.5, 1),
      fillHighlightColor: new Color_default(0, 0, 0, 0),
      zoomedOutOceanSpecularIntensity: 0.5,
      oceanNormalMap: void 0,
      lightingFadeDistance: new Cartesian2_default(65e5, 9e6),
      nightFadeDistance: new Cartesian2_default(1e7, 4e7),
      atmosphereLightIntensity: 10,
      atmosphereRayleighCoefficient: new Cartesian3_default(55e-7, 13e-6, 284e-7),
      atmosphereMieCoefficient: new Cartesian3_default(21e-6, 21e-6, 21e-6),
      atmosphereRayleighScaleHeight: 1e4,
      atmosphereMieScaleHeight: 3200,
      atmosphereMieAnisotropy: 0.9,
      hsbShift: new Cartesian3_default(),
      center3D: void 0,
      rtc: new Cartesian3_default(),
      modifiedModelView: new Matrix4_default(),
      tileRectangle: new Cartesian4_default(),
      terrainExaggerationAndRelativeHeight: new Cartesian2_default(1, 0),
      dayTextures: [],
      dayTextureTranslationAndScale: [],
      dayTextureTexCoordsRectangle: [],
      dayTextureUseWebMercatorT: [],
      dayTextureAlpha: [],
      dayTextureNightAlpha: [],
      dayTextureDayAlpha: [],
      dayTextureBrightness: [],
      dayTextureContrast: [],
      dayTextureHue: [],
      dayTextureSaturation: [],
      dayTextureOneOverGamma: [],
      dayTextureSplit: [],
      dayTextureCutoutRectangles: [],
      dayIntensity: 0,
      colorsToAlpha: [],
      southAndNorthLatitude: new Cartesian2_default(),
      southMercatorYAndOneOverHeight: new Cartesian2_default(),
      waterMask: void 0,
      waterMaskTranslationAndScale: new Cartesian4_default(),
      minMaxHeight: new Cartesian2_default(),
      scaleAndBias: new Matrix4_default(),
      clippingPlanesEdgeColor: Color_default.clone(Color_default.WHITE),
      clippingPlanesEdgeWidth: 0,
      localizedCartographicLimitRectangle: new Cartesian4_default(),
      frontFaceAlphaByDistance: new Cartesian4_default(),
      backFaceAlphaByDistance: new Cartesian4_default(),
      localizedTranslucencyRectangle: new Cartesian4_default(),
      undergroundColor: Color_default.clone(Color_default.TRANSPARENT),
      undergroundColorAlphaByDistance: new Cartesian4_default(),
      lambertDiffuseMultiplier: 0
    }
  };
  if (defined_default(globeSurfaceTileProvider.materialUniformMap)) {
    return combine_default(uniformMap2, globeSurfaceTileProvider.materialUniformMap);
  }
  return uniformMap2;
}
function createWireframeVertexArrayIfNecessary(context, provider, tile) {
  const surfaceTile = tile.data;
  let mesh2;
  let vertexArray;
  if (defined_default(surfaceTile.vertexArray)) {
    mesh2 = surfaceTile.mesh;
    vertexArray = surfaceTile.vertexArray;
  } else if (defined_default(surfaceTile.fill) && defined_default(surfaceTile.fill.vertexArray)) {
    mesh2 = surfaceTile.fill.mesh;
    vertexArray = surfaceTile.fill.vertexArray;
  }
  if (!defined_default(mesh2) || !defined_default(vertexArray)) {
    return;
  }
  if (defined_default(surfaceTile.wireframeVertexArray)) {
    if (surfaceTile.wireframeVertexArray.mesh === mesh2) {
      return;
    }
    surfaceTile.wireframeVertexArray.destroy();
    surfaceTile.wireframeVertexArray = void 0;
  }
  surfaceTile.wireframeVertexArray = createWireframeVertexArray(
    context,
    vertexArray,
    mesh2
  );
  surfaceTile.wireframeVertexArray.mesh = mesh2;
}
function createWireframeVertexArray(context, vertexArray, terrainMesh) {
  const indices2 = terrainMesh.indices;
  const geometry = {
    indices: indices2,
    primitiveType: PrimitiveType_default.TRIANGLES
  };
  GeometryPipeline_default.toWireframe(geometry);
  const wireframeIndices = geometry.indices;
  const wireframeIndexBuffer = Buffer_default.createIndexBuffer({
    context,
    typedArray: wireframeIndices,
    usage: BufferUsage_default.STATIC_DRAW,
    indexDatatype: IndexDatatype_default.fromSizeInBytes(
      wireframeIndices.BYTES_PER_ELEMENT
    )
  });
  return new VertexArray_default({
    context,
    attributes: vertexArray._attributes,
    indexBuffer: wireframeIndexBuffer
  });
}
var getDebugOrientedBoundingBox;
var getDebugBoundingSphere;
var debugDestroyPrimitive;
(function() {
  const instanceOBB = new GeometryInstance_default({
    geometry: BoxOutlineGeometry_default.fromDimensions({
      dimensions: new Cartesian3_default(2, 2, 2)
    })
  });
  const instanceSphere = new GeometryInstance_default({
    geometry: new SphereOutlineGeometry_default({ radius: 1 })
  });
  let modelMatrix = new Matrix4_default();
  let previousVolume;
  let primitive;
  function createDebugPrimitive(instance) {
    return new Primitive_default({
      geometryInstances: instance,
      appearance: new PerInstanceColorAppearance_default({
        translucent: false,
        flat: true
      }),
      asynchronous: false
    });
  }
  getDebugOrientedBoundingBox = function(obb, color) {
    if (obb === previousVolume) {
      return primitive;
    }
    debugDestroyPrimitive();
    previousVolume = obb;
    modelMatrix = Matrix4_default.fromRotationTranslation(
      obb.halfAxes,
      obb.center,
      modelMatrix
    );
    instanceOBB.modelMatrix = modelMatrix;
    instanceOBB.attributes.color = ColorGeometryInstanceAttribute_default.fromColor(
      color
    );
    primitive = createDebugPrimitive(instanceOBB);
    return primitive;
  };
  getDebugBoundingSphere = function(sphere, color) {
    if (sphere === previousVolume) {
      return primitive;
    }
    debugDestroyPrimitive();
    previousVolume = sphere;
    modelMatrix = Matrix4_default.fromTranslation(sphere.center, modelMatrix);
    modelMatrix = Matrix4_default.multiplyByUniformScale(
      modelMatrix,
      sphere.radius,
      modelMatrix
    );
    instanceSphere.modelMatrix = modelMatrix;
    instanceSphere.attributes.color = ColorGeometryInstanceAttribute_default.fromColor(
      color
    );
    primitive = createDebugPrimitive(instanceSphere);
    return primitive;
  };
  debugDestroyPrimitive = function() {
    if (defined_default(primitive)) {
      primitive.destroy();
      primitive = void 0;
      previousVolume = void 0;
    }
  };
})();
var otherPassesInitialColor = new Cartesian4_default(0, 0, 0, 0);
var surfaceShaderSetOptionsScratch = {
  frameState: void 0,
  surfaceTile: void 0,
  numberOfDayTextures: void 0,
  applyBrightness: void 0,
  applyContrast: void 0,
  applyHue: void 0,
  applySaturation: void 0,
  applyGamma: void 0,
  applyAlpha: void 0,
  applyDayNightAlpha: void 0,
  applySplit: void 0,
  showReflectiveOcean: void 0,
  showOceanWaves: void 0,
  enableLighting: void 0,
  dynamicAtmosphereLighting: void 0,
  dynamicAtmosphereLightingFromSun: void 0,
  showGroundAtmosphere: void 0,
  perFragmentGroundAtmosphere: void 0,
  hasVertexNormals: void 0,
  useWebMercatorProjection: void 0,
  enableFog: void 0,
  enableClippingPlanes: void 0,
  clippingPlanes: void 0,
  clippedByBoundaries: void 0,
  hasImageryLayerCutout: void 0,
  colorCorrect: void 0,
  colorToAlpha: void 0,
  hasGeodeticSurfaceNormals: void 0,
  hasExaggeration: void 0
};
var defaultUndergroundColor = Color_default.TRANSPARENT;
var defaultUndergroundColorAlphaByDistance = new NearFarScalar_default();
function addDrawCommandsForTile(tileProvider, tile, frameState) {
  const surfaceTile = tile.data;
  if (!defined_default(surfaceTile.vertexArray)) {
    if (surfaceTile.fill === void 0) {
      surfaceTile.fill = new TerrainFillMesh_default(tile);
    }
    surfaceTile.fill.update(tileProvider, frameState);
  }
  const creditDisplay = frameState.creditDisplay;
  const terrainData = surfaceTile.terrainData;
  if (defined_default(terrainData) && defined_default(terrainData.credits)) {
    const tileCredits = terrainData.credits;
    for (let tileCreditIndex = 0, tileCreditLength = tileCredits.length; tileCreditIndex < tileCreditLength; ++tileCreditIndex) {
      creditDisplay.addCredit(tileCredits[tileCreditIndex]);
    }
  }
  let maxTextures = ContextLimits_default.maximumTextureImageUnits;
  let waterMaskTexture = surfaceTile.waterMaskTexture;
  let waterMaskTranslationAndScale = surfaceTile.waterMaskTranslationAndScale;
  if (!defined_default(waterMaskTexture) && defined_default(surfaceTile.fill)) {
    waterMaskTexture = surfaceTile.fill.waterMaskTexture;
    waterMaskTranslationAndScale = surfaceTile.fill.waterMaskTranslationAndScale;
  }
  const cameraUnderground = frameState.cameraUnderground;
  const globeTranslucencyState = frameState.globeTranslucencyState;
  const translucent = globeTranslucencyState.translucent;
  const frontFaceAlphaByDistance = globeTranslucencyState.frontFaceAlphaByDistance;
  const backFaceAlphaByDistance = globeTranslucencyState.backFaceAlphaByDistance;
  const translucencyRectangle = globeTranslucencyState.rectangle;
  const undergroundColor = defaultValue_default(
    tileProvider.undergroundColor,
    defaultUndergroundColor
  );
  const undergroundColorAlphaByDistance = defaultValue_default(
    tileProvider.undergroundColorAlphaByDistance,
    defaultUndergroundColorAlphaByDistance
  );
  const showUndergroundColor = isUndergroundVisible(tileProvider, frameState) && frameState.mode === SceneMode_default.SCENE3D && undergroundColor.alpha > 0 && (undergroundColorAlphaByDistance.nearValue > 0 || undergroundColorAlphaByDistance.farValue > 0);
  const lambertDiffuseMultiplier = tileProvider.lambertDiffuseMultiplier;
  const showReflectiveOcean = tileProvider.hasWaterMask && defined_default(waterMaskTexture);
  const oceanNormalMap = tileProvider.oceanNormalMap;
  const showOceanWaves = showReflectiveOcean && defined_default(oceanNormalMap);
  const hasVertexNormals = tileProvider.terrainProvider.ready && tileProvider.terrainProvider.hasVertexNormals;
  const enableFog = frameState.fog.enabled && frameState.fog.renderable && !cameraUnderground;
  const showGroundAtmosphere = tileProvider.showGroundAtmosphere && frameState.mode === SceneMode_default.SCENE3D;
  const castShadows = ShadowMode_default.castShadows(tileProvider.shadows) && !translucent;
  const receiveShadows = ShadowMode_default.receiveShadows(tileProvider.shadows) && !translucent;
  const hueShift = tileProvider.hueShift;
  const saturationShift = tileProvider.saturationShift;
  const brightnessShift = tileProvider.brightnessShift;
  let colorCorrect = !(Math_default.equalsEpsilon(hueShift, 0, Math_default.EPSILON7) && Math_default.equalsEpsilon(saturationShift, 0, Math_default.EPSILON7) && Math_default.equalsEpsilon(brightnessShift, 0, Math_default.EPSILON7));
  let perFragmentGroundAtmosphere = false;
  if (showGroundAtmosphere) {
    const cameraDistance = Cartesian3_default.magnitude(frameState.camera.positionWC);
    const fadeOutDistance = tileProvider.nightFadeOutDistance;
    perFragmentGroundAtmosphere = cameraDistance > fadeOutDistance;
  }
  if (showReflectiveOcean) {
    --maxTextures;
  }
  if (showOceanWaves) {
    --maxTextures;
  }
  if (defined_default(frameState.shadowState) && frameState.shadowState.shadowsEnabled) {
    --maxTextures;
  }
  if (defined_default(tileProvider.clippingPlanes) && tileProvider.clippingPlanes.enabled) {
    --maxTextures;
  }
  maxTextures -= globeTranslucencyState.numberOfTextureUniforms;
  const mesh2 = surfaceTile.renderedMesh;
  let rtc = mesh2.center;
  const encoding = mesh2.encoding;
  const tileBoundingRegion = surfaceTile.tileBoundingRegion;
  const exaggeration = frameState.terrainExaggeration;
  const exaggerationRelativeHeight = frameState.terrainExaggerationRelativeHeight;
  const hasExaggeration = exaggeration !== 1;
  const hasGeodeticSurfaceNormals = encoding.hasGeodeticSurfaceNormals;
  const tileRectangle = tileRectangleScratch;
  let southLatitude = 0;
  let northLatitude = 0;
  let southMercatorY = 0;
  let oneOverMercatorHeight = 0;
  let useWebMercatorProjection = false;
  if (frameState.mode !== SceneMode_default.SCENE3D) {
    const projection = frameState.mapProjection;
    const southwest = projection.project(
      Rectangle_default.southwest(tile.rectangle),
      southwestScratch
    );
    const northeast = projection.project(
      Rectangle_default.northeast(tile.rectangle),
      northeastScratch
    );
    tileRectangle.x = southwest.x;
    tileRectangle.y = southwest.y;
    tileRectangle.z = northeast.x;
    tileRectangle.w = northeast.y;
    if (frameState.mode !== SceneMode_default.MORPHING) {
      rtc = rtcScratch5;
      rtc.x = 0;
      rtc.y = (tileRectangle.z + tileRectangle.x) * 0.5;
      rtc.z = (tileRectangle.w + tileRectangle.y) * 0.5;
      tileRectangle.x -= rtc.y;
      tileRectangle.y -= rtc.z;
      tileRectangle.z -= rtc.y;
      tileRectangle.w -= rtc.z;
    }
    if (frameState.mode === SceneMode_default.SCENE2D && encoding.quantization === TerrainQuantization_default.BITS12) {
      const epsilon = 1 / (Math.pow(2, 12) - 1) * 0.5;
      const widthEpsilon = (tileRectangle.z - tileRectangle.x) * epsilon;
      const heightEpsilon = (tileRectangle.w - tileRectangle.y) * epsilon;
      tileRectangle.x -= widthEpsilon;
      tileRectangle.y -= heightEpsilon;
      tileRectangle.z += widthEpsilon;
      tileRectangle.w += heightEpsilon;
    }
    if (projection instanceof WebMercatorProjection_default) {
      southLatitude = tile.rectangle.south;
      northLatitude = tile.rectangle.north;
      southMercatorY = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(
        southLatitude
      );
      oneOverMercatorHeight = 1 / (WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(northLatitude) - southMercatorY);
      useWebMercatorProjection = true;
    }
  }
  const surfaceShaderSetOptions = surfaceShaderSetOptionsScratch;
  surfaceShaderSetOptions.frameState = frameState;
  surfaceShaderSetOptions.surfaceTile = surfaceTile;
  surfaceShaderSetOptions.showReflectiveOcean = showReflectiveOcean;
  surfaceShaderSetOptions.showOceanWaves = showOceanWaves;
  surfaceShaderSetOptions.enableLighting = tileProvider.enableLighting;
  surfaceShaderSetOptions.dynamicAtmosphereLighting = tileProvider.dynamicAtmosphereLighting;
  surfaceShaderSetOptions.dynamicAtmosphereLightingFromSun = tileProvider.dynamicAtmosphereLightingFromSun;
  surfaceShaderSetOptions.showGroundAtmosphere = showGroundAtmosphere;
  surfaceShaderSetOptions.atmosphereLightIntensity = tileProvider.atmosphereLightIntensity;
  surfaceShaderSetOptions.atmosphereRayleighCoefficient = tileProvider.atmosphereRayleighCoefficient;
  surfaceShaderSetOptions.atmosphereMieCoefficient = tileProvider.atmosphereMieCoefficient;
  surfaceShaderSetOptions.atmosphereRayleighScaleHeight = tileProvider.atmosphereRayleighScaleHeight;
  surfaceShaderSetOptions.atmosphereMieScaleHeight = tileProvider.atmosphereMieScaleHeight;
  surfaceShaderSetOptions.atmosphereMieAnisotropy = tileProvider.atmosphereMieAnisotropy;
  surfaceShaderSetOptions.perFragmentGroundAtmosphere = perFragmentGroundAtmosphere;
  surfaceShaderSetOptions.hasVertexNormals = hasVertexNormals;
  surfaceShaderSetOptions.useWebMercatorProjection = useWebMercatorProjection;
  surfaceShaderSetOptions.clippedByBoundaries = surfaceTile.clippedByBoundaries;
  surfaceShaderSetOptions.hasGeodeticSurfaceNormals = hasGeodeticSurfaceNormals;
  surfaceShaderSetOptions.hasExaggeration = hasExaggeration;
  const tileImageryCollection = surfaceTile.imagery;
  let imageryIndex = 0;
  const imageryLen = tileImageryCollection.length;
  const showSkirts = tileProvider.showSkirts && !cameraUnderground && !translucent;
  const backFaceCulling = tileProvider.backFaceCulling && !cameraUnderground && !translucent;
  const firstPassRenderState = backFaceCulling ? tileProvider._renderState : tileProvider._disableCullingRenderState;
  const otherPassesRenderState = backFaceCulling ? tileProvider._blendRenderState : tileProvider._disableCullingBlendRenderState;
  let renderState = firstPassRenderState;
  let initialColor = tileProvider._firstPassInitialColor;
  const context = frameState.context;
  if (!defined_default(tileProvider._debug.boundingSphereTile)) {
    debugDestroyPrimitive();
  }
  const materialUniformMapChanged = tileProvider._materialUniformMap !== tileProvider.materialUniformMap;
  if (materialUniformMapChanged) {
    tileProvider._materialUniformMap = tileProvider.materialUniformMap;
    const drawCommandsLength = tileProvider._drawCommands.length;
    for (let i2 = 0; i2 < drawCommandsLength; ++i2) {
      tileProvider._uniformMaps[i2] = createTileUniformMap(
        frameState,
        tileProvider
      );
    }
  }
  do {
    let numberOfDayTextures = 0;
    let command;
    let uniformMap2;
    if (tileProvider._drawCommands.length <= tileProvider._usedDrawCommands) {
      command = new DrawCommand_default();
      command.owner = tile;
      command.cull = false;
      command.boundingVolume = new BoundingSphere_default();
      command.orientedBoundingBox = void 0;
      uniformMap2 = createTileUniformMap(frameState, tileProvider);
      tileProvider._drawCommands.push(command);
      tileProvider._uniformMaps.push(uniformMap2);
    } else {
      command = tileProvider._drawCommands[tileProvider._usedDrawCommands];
      uniformMap2 = tileProvider._uniformMaps[tileProvider._usedDrawCommands];
    }
    command.owner = tile;
    ++tileProvider._usedDrawCommands;
    if (tile === tileProvider._debug.boundingSphereTile) {
      const obb = tileBoundingRegion.boundingVolume;
      const boundingSphere = tileBoundingRegion.boundingSphere;
      if (defined_default(obb)) {
        getDebugOrientedBoundingBox(obb, Color_default.RED).update(frameState);
      } else if (defined_default(boundingSphere)) {
        getDebugBoundingSphere(boundingSphere, Color_default.RED).update(frameState);
      }
    }
    const uniformMapProperties = uniformMap2.properties;
    Cartesian4_default.clone(initialColor, uniformMapProperties.initialColor);
    uniformMapProperties.oceanNormalMap = oceanNormalMap;
    uniformMapProperties.lightingFadeDistance.x = tileProvider.lightingFadeOutDistance;
    uniformMapProperties.lightingFadeDistance.y = tileProvider.lightingFadeInDistance;
    uniformMapProperties.nightFadeDistance.x = tileProvider.nightFadeOutDistance;
    uniformMapProperties.nightFadeDistance.y = tileProvider.nightFadeInDistance;
    uniformMapProperties.atmosphereLightIntensity = tileProvider.atmosphereLightIntensity;
    uniformMapProperties.atmosphereRayleighCoefficient = tileProvider.atmosphereRayleighCoefficient;
    uniformMapProperties.atmosphereMieCoefficient = tileProvider.atmosphereMieCoefficient;
    uniformMapProperties.atmosphereRayleighScaleHeight = tileProvider.atmosphereRayleighScaleHeight;
    uniformMapProperties.atmosphereMieScaleHeight = tileProvider.atmosphereMieScaleHeight;
    uniformMapProperties.atmosphereMieAnisotropy = tileProvider.atmosphereMieAnisotropy;
    uniformMapProperties.zoomedOutOceanSpecularIntensity = tileProvider.zoomedOutOceanSpecularIntensity;
    const frontFaceAlphaByDistanceFinal = cameraUnderground ? backFaceAlphaByDistance : frontFaceAlphaByDistance;
    const backFaceAlphaByDistanceFinal = cameraUnderground ? frontFaceAlphaByDistance : backFaceAlphaByDistance;
    if (defined_default(frontFaceAlphaByDistanceFinal)) {
      Cartesian4_default.fromElements(
        frontFaceAlphaByDistanceFinal.near,
        frontFaceAlphaByDistanceFinal.nearValue,
        frontFaceAlphaByDistanceFinal.far,
        frontFaceAlphaByDistanceFinal.farValue,
        uniformMapProperties.frontFaceAlphaByDistance
      );
      Cartesian4_default.fromElements(
        backFaceAlphaByDistanceFinal.near,
        backFaceAlphaByDistanceFinal.nearValue,
        backFaceAlphaByDistanceFinal.far,
        backFaceAlphaByDistanceFinal.farValue,
        uniformMapProperties.backFaceAlphaByDistance
      );
    }
    Cartesian4_default.fromElements(
      undergroundColorAlphaByDistance.near,
      undergroundColorAlphaByDistance.nearValue,
      undergroundColorAlphaByDistance.far,
      undergroundColorAlphaByDistance.farValue,
      uniformMapProperties.undergroundColorAlphaByDistance
    );
    Color_default.clone(undergroundColor, uniformMapProperties.undergroundColor);
    uniformMapProperties.lambertDiffuseMultiplier = lambertDiffuseMultiplier;
    const highlightFillTile = !defined_default(surfaceTile.vertexArray) && defined_default(tileProvider.fillHighlightColor) && tileProvider.fillHighlightColor.alpha > 0;
    if (highlightFillTile) {
      Color_default.clone(
        tileProvider.fillHighlightColor,
        uniformMapProperties.fillHighlightColor
      );
    }
    uniformMapProperties.terrainExaggerationAndRelativeHeight.x = exaggeration;
    uniformMapProperties.terrainExaggerationAndRelativeHeight.y = exaggerationRelativeHeight;
    uniformMapProperties.center3D = mesh2.center;
    Cartesian3_default.clone(rtc, uniformMapProperties.rtc);
    Cartesian4_default.clone(tileRectangle, uniformMapProperties.tileRectangle);
    uniformMapProperties.southAndNorthLatitude.x = southLatitude;
    uniformMapProperties.southAndNorthLatitude.y = northLatitude;
    uniformMapProperties.southMercatorYAndOneOverHeight.x = southMercatorY;
    uniformMapProperties.southMercatorYAndOneOverHeight.y = oneOverMercatorHeight;
    const localizedCartographicLimitRectangle = localizedCartographicLimitRectangleScratch;
    const cartographicLimitRectangle = clipRectangleAntimeridian(
      tile.rectangle,
      tileProvider.cartographicLimitRectangle
    );
    const localizedTranslucencyRectangle = localizedTranslucencyRectangleScratch;
    const clippedTranslucencyRectangle = clipRectangleAntimeridian(
      tile.rectangle,
      translucencyRectangle
    );
    Cartesian3_default.fromElements(
      hueShift,
      saturationShift,
      brightnessShift,
      uniformMapProperties.hsbShift
    );
    const cartographicTileRectangle = tile.rectangle;
    const inverseTileWidth = 1 / cartographicTileRectangle.width;
    const inverseTileHeight = 1 / cartographicTileRectangle.height;
    localizedCartographicLimitRectangle.x = (cartographicLimitRectangle.west - cartographicTileRectangle.west) * inverseTileWidth;
    localizedCartographicLimitRectangle.y = (cartographicLimitRectangle.south - cartographicTileRectangle.south) * inverseTileHeight;
    localizedCartographicLimitRectangle.z = (cartographicLimitRectangle.east - cartographicTileRectangle.west) * inverseTileWidth;
    localizedCartographicLimitRectangle.w = (cartographicLimitRectangle.north - cartographicTileRectangle.south) * inverseTileHeight;
    Cartesian4_default.clone(
      localizedCartographicLimitRectangle,
      uniformMapProperties.localizedCartographicLimitRectangle
    );
    localizedTranslucencyRectangle.x = (clippedTranslucencyRectangle.west - cartographicTileRectangle.west) * inverseTileWidth;
    localizedTranslucencyRectangle.y = (clippedTranslucencyRectangle.south - cartographicTileRectangle.south) * inverseTileHeight;
    localizedTranslucencyRectangle.z = (clippedTranslucencyRectangle.east - cartographicTileRectangle.west) * inverseTileWidth;
    localizedTranslucencyRectangle.w = (clippedTranslucencyRectangle.north - cartographicTileRectangle.south) * inverseTileHeight;
    Cartesian4_default.clone(
      localizedTranslucencyRectangle,
      uniformMapProperties.localizedTranslucencyRectangle
    );
    const applyFog = enableFog && Math_default.fog(tile._distance, frameState.fog.density) > Math_default.EPSILON3;
    colorCorrect = colorCorrect && (applyFog || showGroundAtmosphere);
    let applyBrightness = false;
    let applyContrast = false;
    let applyHue = false;
    let applySaturation = false;
    let applyGamma = false;
    let applyAlpha = false;
    let applyDayNightAlpha = false;
    let applySplit = false;
    let applyCutout = false;
    let applyColorToAlpha = false;
    while (numberOfDayTextures < maxTextures && imageryIndex < imageryLen) {
      const tileImagery = tileImageryCollection[imageryIndex];
      const imagery = tileImagery.readyImagery;
      ++imageryIndex;
      if (!defined_default(imagery) || imagery.imageryLayer.alpha === 0) {
        continue;
      }
      const texture = tileImagery.useWebMercatorT ? imagery.textureWebMercator : imagery.texture;
      if (!defined_default(texture)) {
        throw new DeveloperError_default("readyImagery is not actually ready!");
      }
      const imageryLayer = imagery.imageryLayer;
      if (!defined_default(tileImagery.textureTranslationAndScale)) {
        tileImagery.textureTranslationAndScale = imageryLayer._calculateTextureTranslationAndScale(
          tile,
          tileImagery
        );
      }
      uniformMapProperties.dayTextures[numberOfDayTextures] = texture;
      uniformMapProperties.dayTextureTranslationAndScale[numberOfDayTextures] = tileImagery.textureTranslationAndScale;
      uniformMapProperties.dayTextureTexCoordsRectangle[numberOfDayTextures] = tileImagery.textureCoordinateRectangle;
      uniformMapProperties.dayTextureUseWebMercatorT[numberOfDayTextures] = tileImagery.useWebMercatorT;
      uniformMapProperties.dayTextureAlpha[numberOfDayTextures] = imageryLayer.alpha;
      applyAlpha = applyAlpha || uniformMapProperties.dayTextureAlpha[numberOfDayTextures] !== 1;
      uniformMapProperties.dayTextureNightAlpha[numberOfDayTextures] = imageryLayer.nightAlpha;
      applyDayNightAlpha = applyDayNightAlpha || uniformMapProperties.dayTextureNightAlpha[numberOfDayTextures] !== 1;
      uniformMapProperties.dayTextureDayAlpha[numberOfDayTextures] = imageryLayer.dayAlpha;
      applyDayNightAlpha = applyDayNightAlpha || uniformMapProperties.dayTextureDayAlpha[numberOfDayTextures] !== 1;
      uniformMapProperties.dayTextureBrightness[numberOfDayTextures] = imageryLayer.brightness;
      applyBrightness = applyBrightness || uniformMapProperties.dayTextureBrightness[numberOfDayTextures] !== ImageryLayer_default.DEFAULT_BRIGHTNESS;
      uniformMapProperties.dayTextureContrast[numberOfDayTextures] = imageryLayer.contrast;
      applyContrast = applyContrast || uniformMapProperties.dayTextureContrast[numberOfDayTextures] !== ImageryLayer_default.DEFAULT_CONTRAST;
      uniformMapProperties.dayTextureHue[numberOfDayTextures] = imageryLayer.hue;
      applyHue = applyHue || uniformMapProperties.dayTextureHue[numberOfDayTextures] !== ImageryLayer_default.DEFAULT_HUE;
      uniformMapProperties.dayTextureSaturation[numberOfDayTextures] = imageryLayer.saturation;
      applySaturation = applySaturation || uniformMapProperties.dayTextureSaturation[numberOfDayTextures] !== ImageryLayer_default.DEFAULT_SATURATION;
      uniformMapProperties.dayTextureOneOverGamma[numberOfDayTextures] = 1 / imageryLayer.gamma;
      applyGamma = applyGamma || uniformMapProperties.dayTextureOneOverGamma[numberOfDayTextures] !== 1 / ImageryLayer_default.DEFAULT_GAMMA;
      uniformMapProperties.dayTextureSplit[numberOfDayTextures] = imageryLayer.splitDirection;
      applySplit = applySplit || uniformMapProperties.dayTextureSplit[numberOfDayTextures] !== 0;
      let dayTextureCutoutRectangle = uniformMapProperties.dayTextureCutoutRectangles[numberOfDayTextures];
      if (!defined_default(dayTextureCutoutRectangle)) {
        dayTextureCutoutRectangle = uniformMapProperties.dayTextureCutoutRectangles[numberOfDayTextures] = new Cartesian4_default();
      }
      Cartesian4_default.clone(Cartesian4_default.ZERO, dayTextureCutoutRectangle);
      if (defined_default(imageryLayer.cutoutRectangle)) {
        const cutoutRectangle = clipRectangleAntimeridian(
          cartographicTileRectangle,
          imageryLayer.cutoutRectangle
        );
        const intersection = Rectangle_default.simpleIntersection(
          cutoutRectangle,
          cartographicTileRectangle,
          rectangleIntersectionScratch
        );
        applyCutout = defined_default(intersection) || applyCutout;
        dayTextureCutoutRectangle.x = (cutoutRectangle.west - cartographicTileRectangle.west) * inverseTileWidth;
        dayTextureCutoutRectangle.y = (cutoutRectangle.south - cartographicTileRectangle.south) * inverseTileHeight;
        dayTextureCutoutRectangle.z = (cutoutRectangle.east - cartographicTileRectangle.west) * inverseTileWidth;
        dayTextureCutoutRectangle.w = (cutoutRectangle.north - cartographicTileRectangle.south) * inverseTileHeight;
      }
      let colorToAlpha = uniformMapProperties.colorsToAlpha[numberOfDayTextures];
      if (!defined_default(colorToAlpha)) {
        colorToAlpha = uniformMapProperties.colorsToAlpha[numberOfDayTextures] = new Cartesian4_default();
      }
      const hasColorToAlpha = defined_default(imageryLayer.colorToAlpha) && imageryLayer.colorToAlphaThreshold > 0;
      applyColorToAlpha = applyColorToAlpha || hasColorToAlpha;
      if (hasColorToAlpha) {
        const color = imageryLayer.colorToAlpha;
        colorToAlpha.x = color.red;
        colorToAlpha.y = color.green;
        colorToAlpha.z = color.blue;
        colorToAlpha.w = imageryLayer.colorToAlphaThreshold;
      } else {
        colorToAlpha.w = -1;
      }
      if (defined_default(imagery.credits)) {
        const credits = imagery.credits;
        for (let creditIndex = 0, creditLength = credits.length; creditIndex < creditLength; ++creditIndex) {
          creditDisplay.addCredit(credits[creditIndex]);
        }
      }
      ++numberOfDayTextures;
    }
    uniformMapProperties.dayTextures.length = numberOfDayTextures;
    uniformMapProperties.waterMask = waterMaskTexture;
    Cartesian4_default.clone(
      waterMaskTranslationAndScale,
      uniformMapProperties.waterMaskTranslationAndScale
    );
    uniformMapProperties.minMaxHeight.x = encoding.minimumHeight;
    uniformMapProperties.minMaxHeight.y = encoding.maximumHeight;
    Matrix4_default.clone(encoding.matrix, uniformMapProperties.scaleAndBias);
    const clippingPlanes = tileProvider._clippingPlanes;
    const clippingPlanesEnabled = defined_default(clippingPlanes) && clippingPlanes.enabled && tile.isClipped;
    if (clippingPlanesEnabled) {
      uniformMapProperties.clippingPlanesEdgeColor = Color_default.clone(
        clippingPlanes.edgeColor,
        uniformMapProperties.clippingPlanesEdgeColor
      );
      uniformMapProperties.clippingPlanesEdgeWidth = clippingPlanes.edgeWidth;
    }
    surfaceShaderSetOptions.numberOfDayTextures = numberOfDayTextures;
    surfaceShaderSetOptions.applyBrightness = applyBrightness;
    surfaceShaderSetOptions.applyContrast = applyContrast;
    surfaceShaderSetOptions.applyHue = applyHue;
    surfaceShaderSetOptions.applySaturation = applySaturation;
    surfaceShaderSetOptions.applyGamma = applyGamma;
    surfaceShaderSetOptions.applyAlpha = applyAlpha;
    surfaceShaderSetOptions.applyDayNightAlpha = applyDayNightAlpha;
    surfaceShaderSetOptions.applySplit = applySplit;
    surfaceShaderSetOptions.enableFog = applyFog;
    surfaceShaderSetOptions.enableClippingPlanes = clippingPlanesEnabled;
    surfaceShaderSetOptions.clippingPlanes = clippingPlanes;
    surfaceShaderSetOptions.hasImageryLayerCutout = applyCutout;
    surfaceShaderSetOptions.colorCorrect = colorCorrect;
    surfaceShaderSetOptions.highlightFillTile = highlightFillTile;
    surfaceShaderSetOptions.colorToAlpha = applyColorToAlpha;
    surfaceShaderSetOptions.showUndergroundColor = showUndergroundColor;
    surfaceShaderSetOptions.translucent = translucent;
    let count = surfaceTile.renderedMesh.indices.length;
    if (!showSkirts) {
      count = surfaceTile.renderedMesh.indexCountWithoutSkirts;
    }
    command.shaderProgram = tileProvider._surfaceShaderSet.getShaderProgram(
      surfaceShaderSetOptions
    );
    command.castShadows = castShadows;
    command.receiveShadows = receiveShadows;
    command.renderState = renderState;
    command.primitiveType = PrimitiveType_default.TRIANGLES;
    command.vertexArray = surfaceTile.vertexArray || surfaceTile.fill.vertexArray;
    command.count = count;
    command.uniformMap = uniformMap2;
    command.pass = Pass_default.GLOBE;
    if (tileProvider._debug.wireframe) {
      createWireframeVertexArrayIfNecessary(context, tileProvider, tile);
      if (defined_default(surfaceTile.wireframeVertexArray)) {
        command.vertexArray = surfaceTile.wireframeVertexArray;
        command.primitiveType = PrimitiveType_default.LINES;
        command.count = count * 2;
      }
    }
    let boundingVolume = command.boundingVolume;
    const orientedBoundingBox = command.orientedBoundingBox;
    if (frameState.mode !== SceneMode_default.SCENE3D) {
      BoundingSphere_default.fromRectangleWithHeights2D(
        tile.rectangle,
        frameState.mapProjection,
        tileBoundingRegion.minimumHeight,
        tileBoundingRegion.maximumHeight,
        boundingVolume
      );
      Cartesian3_default.fromElements(
        boundingVolume.center.z,
        boundingVolume.center.x,
        boundingVolume.center.y,
        boundingVolume.center
      );
      if (frameState.mode === SceneMode_default.MORPHING) {
        boundingVolume = BoundingSphere_default.union(
          tileBoundingRegion.boundingSphere,
          boundingVolume,
          boundingVolume
        );
      }
    } else {
      command.boundingVolume = BoundingSphere_default.clone(
        tileBoundingRegion.boundingSphere,
        boundingVolume
      );
      command.orientedBoundingBox = OrientedBoundingBox_default.clone(
        tileBoundingRegion.boundingVolume,
        orientedBoundingBox
      );
    }
    command.dirty = true;
    if (translucent) {
      globeTranslucencyState.updateDerivedCommands(command, frameState);
    }
    pushCommand(command, frameState);
    renderState = otherPassesRenderState;
    initialColor = otherPassesInitialColor;
  } while (imageryIndex < imageryLen);
}
var GlobeSurfaceTileProvider_default = GlobeSurfaceTileProvider;

// node_modules/cesium/Source/Scene/GlobeTranslucency.js
function GlobeTranslucency() {
  this._enabled = false;
  this._frontFaceAlpha = 1;
  this._frontFaceAlphaByDistance = void 0;
  this._backFaceAlpha = 1;
  this._backFaceAlphaByDistance = void 0;
  this._rectangle = Rectangle_default.clone(Rectangle_default.MAX_VALUE);
}
Object.defineProperties(GlobeTranslucency.prototype, {
  enabled: {
    get: function() {
      return this._enabled;
    },
    set: function(value) {
      Check_default.typeOf.bool("enabled", value);
      this._enabled = value;
    }
  },
  frontFaceAlpha: {
    get: function() {
      return this._frontFaceAlpha;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("frontFaceAlpha", value, 0);
      Check_default.typeOf.number.lessThanOrEquals("frontFaceAlpha", value, 1);
      this._frontFaceAlpha = value;
    }
  },
  frontFaceAlphaByDistance: {
    get: function() {
      return this._frontFaceAlphaByDistance;
    },
    set: function(value) {
      if (defined_default(value) && value.far < value.near) {
        throw new DeveloperError_default(
          "far distance must be greater than near distance."
        );
      }
      this._frontFaceAlphaByDistance = NearFarScalar_default.clone(
        value,
        this._frontFaceAlphaByDistance
      );
    }
  },
  backFaceAlpha: {
    get: function() {
      return this._backFaceAlpha;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("backFaceAlpha", value, 0);
      Check_default.typeOf.number.lessThanOrEquals("backFaceAlpha", value, 1);
      this._backFaceAlpha = value;
    }
  },
  backFaceAlphaByDistance: {
    get: function() {
      return this._backFaceAlphaByDistance;
    },
    set: function(value) {
      if (defined_default(value) && value.far < value.near) {
        throw new DeveloperError_default(
          "far distance must be greater than near distance."
        );
      }
      this._backFaceAlphaByDistance = NearFarScalar_default.clone(
        value,
        this._backFaceAlphaByDistance
      );
    }
  },
  rectangle: {
    get: function() {
      return this._rectangle;
    },
    set: function(value) {
      if (!defined_default(value)) {
        value = Rectangle_default.clone(Rectangle_default.MAX_VALUE);
      }
      Rectangle_default.clone(value, this._rectangle);
    }
  }
});
var GlobeTranslucency_default = GlobeTranslucency;

// node_modules/cesium/Source/Scene/ImageryLayerCollection.js
function ImageryLayerCollection() {
  this._layers = [];
  this.layerAdded = new Event_default();
  this.layerRemoved = new Event_default();
  this.layerMoved = new Event_default();
  this.layerShownOrHidden = new Event_default();
}
Object.defineProperties(ImageryLayerCollection.prototype, {
  length: {
    get: function() {
      return this._layers.length;
    }
  }
});
ImageryLayerCollection.prototype.add = function(layer, index2) {
  const hasIndex = defined_default(index2);
  if (!defined_default(layer)) {
    throw new DeveloperError_default("layer is required.");
  }
  if (hasIndex) {
    if (index2 < 0) {
      throw new DeveloperError_default("index must be greater than or equal to zero.");
    } else if (index2 > this._layers.length) {
      throw new DeveloperError_default(
        "index must be less than or equal to the number of layers."
      );
    }
  }
  if (!hasIndex) {
    index2 = this._layers.length;
    this._layers.push(layer);
  } else {
    this._layers.splice(index2, 0, layer);
  }
  this._update();
  this.layerAdded.raiseEvent(layer, index2);
};
ImageryLayerCollection.prototype.addImageryProvider = function(imageryProvider, index2) {
  if (!defined_default(imageryProvider)) {
    throw new DeveloperError_default("imageryProvider is required.");
  }
  const layer = new ImageryLayer_default(imageryProvider);
  this.add(layer, index2);
  return layer;
};
ImageryLayerCollection.prototype.remove = function(layer, destroy2) {
  destroy2 = defaultValue_default(destroy2, true);
  const index2 = this._layers.indexOf(layer);
  if (index2 !== -1) {
    this._layers.splice(index2, 1);
    this._update();
    this.layerRemoved.raiseEvent(layer, index2);
    if (destroy2) {
      layer.destroy();
    }
    return true;
  }
  return false;
};
ImageryLayerCollection.prototype.removeAll = function(destroy2) {
  destroy2 = defaultValue_default(destroy2, true);
  const layers = this._layers;
  for (let i2 = 0, len = layers.length; i2 < len; i2++) {
    const layer = layers[i2];
    this.layerRemoved.raiseEvent(layer, i2);
    if (destroy2) {
      layer.destroy();
    }
  }
  this._layers = [];
};
ImageryLayerCollection.prototype.contains = function(layer) {
  return this.indexOf(layer) !== -1;
};
ImageryLayerCollection.prototype.indexOf = function(layer) {
  return this._layers.indexOf(layer);
};
ImageryLayerCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.", "index");
  }
  return this._layers[index2];
};
function getLayerIndex(layers, layer) {
  if (!defined_default(layer)) {
    throw new DeveloperError_default("layer is required.");
  }
  const index2 = layers.indexOf(layer);
  if (index2 === -1) {
    throw new DeveloperError_default("layer is not in this collection.");
  }
  return index2;
}
function swapLayers(collection, i2, j) {
  const arr = collection._layers;
  i2 = Math_default.clamp(i2, 0, arr.length - 1);
  j = Math_default.clamp(j, 0, arr.length - 1);
  if (i2 === j) {
    return;
  }
  const temp = arr[i2];
  arr[i2] = arr[j];
  arr[j] = temp;
  collection._update();
  collection.layerMoved.raiseEvent(temp, j, i2);
}
ImageryLayerCollection.prototype.raise = function(layer) {
  const index2 = getLayerIndex(this._layers, layer);
  swapLayers(this, index2, index2 + 1);
};
ImageryLayerCollection.prototype.lower = function(layer) {
  const index2 = getLayerIndex(this._layers, layer);
  swapLayers(this, index2, index2 - 1);
};
ImageryLayerCollection.prototype.raiseToTop = function(layer) {
  const index2 = getLayerIndex(this._layers, layer);
  if (index2 === this._layers.length - 1) {
    return;
  }
  this._layers.splice(index2, 1);
  this._layers.push(layer);
  this._update();
  this.layerMoved.raiseEvent(layer, this._layers.length - 1, index2);
};
ImageryLayerCollection.prototype.lowerToBottom = function(layer) {
  const index2 = getLayerIndex(this._layers, layer);
  if (index2 === 0) {
    return;
  }
  this._layers.splice(index2, 1);
  this._layers.splice(0, 0, layer);
  this._update();
  this.layerMoved.raiseEvent(layer, 0, index2);
};
var applicableRectangleScratch = new Rectangle_default();
function pickImageryHelper(scene, pickedLocation, pickFeatures2, callback) {
  const tilesToRender = scene.globe._surface._tilesToRender;
  let pickedTile;
  for (let textureIndex = 0; !defined_default(pickedTile) && textureIndex < tilesToRender.length; ++textureIndex) {
    const tile = tilesToRender[textureIndex];
    if (Rectangle_default.contains(tile.rectangle, pickedLocation)) {
      pickedTile = tile;
    }
  }
  if (!defined_default(pickedTile)) {
    return;
  }
  const imageryTiles = pickedTile.data.imagery;
  for (let i2 = imageryTiles.length - 1; i2 >= 0; --i2) {
    const terrainImagery = imageryTiles[i2];
    const imagery = terrainImagery.readyImagery;
    if (!defined_default(imagery)) {
      continue;
    }
    const provider = imagery.imageryLayer.imageryProvider;
    if (pickFeatures2 && !defined_default(provider.pickFeatures)) {
      continue;
    }
    if (!Rectangle_default.contains(imagery.rectangle, pickedLocation)) {
      continue;
    }
    const applicableRectangle = applicableRectangleScratch;
    const epsilon = 1 / 1024;
    applicableRectangle.west = Math_default.lerp(
      pickedTile.rectangle.west,
      pickedTile.rectangle.east,
      terrainImagery.textureCoordinateRectangle.x - epsilon
    );
    applicableRectangle.east = Math_default.lerp(
      pickedTile.rectangle.west,
      pickedTile.rectangle.east,
      terrainImagery.textureCoordinateRectangle.z + epsilon
    );
    applicableRectangle.south = Math_default.lerp(
      pickedTile.rectangle.south,
      pickedTile.rectangle.north,
      terrainImagery.textureCoordinateRectangle.y - epsilon
    );
    applicableRectangle.north = Math_default.lerp(
      pickedTile.rectangle.south,
      pickedTile.rectangle.north,
      terrainImagery.textureCoordinateRectangle.w + epsilon
    );
    if (!Rectangle_default.contains(applicableRectangle, pickedLocation)) {
      continue;
    }
    callback(imagery);
  }
}
ImageryLayerCollection.prototype.pickImageryLayers = function(ray, scene) {
  const pickedPosition = scene.globe.pick(ray, scene);
  if (!defined_default(pickedPosition)) {
    return;
  }
  const pickedLocation = scene.globe.ellipsoid.cartesianToCartographic(
    pickedPosition
  );
  const imageryLayers = [];
  pickImageryHelper(scene, pickedLocation, false, function(imagery) {
    imageryLayers.push(imagery.imageryLayer);
  });
  if (imageryLayers.length === 0) {
    return void 0;
  }
  return imageryLayers;
};
ImageryLayerCollection.prototype.pickImageryLayerFeatures = function(ray, scene) {
  const pickedPosition = scene.globe.pick(ray, scene);
  if (!defined_default(pickedPosition)) {
    return;
  }
  const pickedLocation = scene.globe.ellipsoid.cartesianToCartographic(
    pickedPosition
  );
  const promises = [];
  const imageryLayers = [];
  pickImageryHelper(scene, pickedLocation, true, function(imagery) {
    const provider = imagery.imageryLayer.imageryProvider;
    const promise = provider.pickFeatures(
      imagery.x,
      imagery.y,
      imagery.level,
      pickedLocation.longitude,
      pickedLocation.latitude
    );
    if (defined_default(promise)) {
      promises.push(promise);
      imageryLayers.push(imagery.imageryLayer);
    }
  });
  if (promises.length === 0) {
    return void 0;
  }
  return Promise.all(promises).then(function(results) {
    const features = [];
    for (let resultIndex = 0; resultIndex < results.length; ++resultIndex) {
      const result = results[resultIndex];
      const image = imageryLayers[resultIndex];
      if (defined_default(result) && result.length > 0) {
        for (let featureIndex = 0; featureIndex < result.length; ++featureIndex) {
          const feature2 = result[featureIndex];
          feature2.imageryLayer = image;
          if (!defined_default(feature2.position)) {
            feature2.position = pickedLocation;
          }
          features.push(feature2);
        }
      }
    }
    return features;
  });
};
ImageryLayerCollection.prototype.queueReprojectionCommands = function(frameState) {
  const layers = this._layers;
  for (let i2 = 0, len = layers.length; i2 < len; ++i2) {
    layers[i2].queueReprojectionCommands(frameState);
  }
};
ImageryLayerCollection.prototype.cancelReprojections = function() {
  const layers = this._layers;
  for (let i2 = 0, len = layers.length; i2 < len; ++i2) {
    layers[i2].cancelReprojections();
  }
};
ImageryLayerCollection.prototype.isDestroyed = function() {
  return false;
};
ImageryLayerCollection.prototype.destroy = function() {
  this.removeAll(true);
  return destroyObject_default(this);
};
ImageryLayerCollection.prototype._update = function() {
  let isBaseLayer = true;
  const layers = this._layers;
  let layersShownOrHidden;
  let layer;
  let i2, len;
  for (i2 = 0, len = layers.length; i2 < len; ++i2) {
    layer = layers[i2];
    layer._layerIndex = i2;
    if (layer.show) {
      layer._isBaseLayer = isBaseLayer;
      isBaseLayer = false;
    } else {
      layer._isBaseLayer = false;
    }
    if (layer.show !== layer._show) {
      if (defined_default(layer._show)) {
        if (!defined_default(layersShownOrHidden)) {
          layersShownOrHidden = [];
        }
        layersShownOrHidden.push(layer);
      }
      layer._show = layer.show;
    }
  }
  if (defined_default(layersShownOrHidden)) {
    for (i2 = 0, len = layersShownOrHidden.length; i2 < len; ++i2) {
      layer = layersShownOrHidden[i2];
      this.layerShownOrHidden.raiseEvent(layer, layer._layerIndex, layer.show);
    }
  }
};
var ImageryLayerCollection_default = ImageryLayerCollection;

// node_modules/cesium/Source/Scene/QuadtreeOccluders.js
function QuadtreeOccluders(options) {
  this._ellipsoid = new EllipsoidalOccluder_default(options.ellipsoid, Cartesian3_default.ZERO);
}
Object.defineProperties(QuadtreeOccluders.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  }
});
var QuadtreeOccluders_default = QuadtreeOccluders;

// node_modules/cesium/Source/Scene/QuadtreeTile.js
function QuadtreeTile(options) {
  if (!defined_default(options)) {
    throw new DeveloperError_default("options is required.");
  }
  if (!defined_default(options.x)) {
    throw new DeveloperError_default("options.x is required.");
  } else if (!defined_default(options.y)) {
    throw new DeveloperError_default("options.y is required.");
  } else if (options.x < 0 || options.y < 0) {
    throw new DeveloperError_default(
      "options.x and options.y must be greater than or equal to zero."
    );
  }
  if (!defined_default(options.level)) {
    throw new DeveloperError_default(
      "options.level is required and must be greater than or equal to zero."
    );
  }
  if (!defined_default(options.tilingScheme)) {
    throw new DeveloperError_default("options.tilingScheme is required.");
  }
  this._tilingScheme = options.tilingScheme;
  this._x = options.x;
  this._y = options.y;
  this._level = options.level;
  this._parent = options.parent;
  this._rectangle = this._tilingScheme.tileXYToRectangle(
    this._x,
    this._y,
    this._level
  );
  this._southwestChild = void 0;
  this._southeastChild = void 0;
  this._northwestChild = void 0;
  this._northeastChild = void 0;
  this.replacementPrevious = void 0;
  this.replacementNext = void 0;
  this._distance = 0;
  this._loadPriority = 0;
  this._customData = [];
  this._frameUpdated = void 0;
  this._lastSelectionResult = TileSelectionResult_default.NONE;
  this._lastSelectionResultFrame = void 0;
  this._loadedCallbacks = {};
  this.state = QuadtreeTileLoadState_default.START;
  this.renderable = false;
  this.upsampledFromParent = false;
  this.data = void 0;
}
QuadtreeTile.createLevelZeroTiles = function(tilingScheme2) {
  if (!defined_default(tilingScheme2)) {
    throw new DeveloperError_default("tilingScheme is required.");
  }
  const numberOfLevelZeroTilesX = tilingScheme2.getNumberOfXTilesAtLevel(0);
  const numberOfLevelZeroTilesY = tilingScheme2.getNumberOfYTilesAtLevel(0);
  const result = new Array(numberOfLevelZeroTilesX * numberOfLevelZeroTilesY);
  let index2 = 0;
  for (let y = 0; y < numberOfLevelZeroTilesY; ++y) {
    for (let x = 0; x < numberOfLevelZeroTilesX; ++x) {
      result[index2++] = new QuadtreeTile({
        tilingScheme: tilingScheme2,
        x,
        y,
        level: 0
      });
    }
  }
  return result;
};
QuadtreeTile.prototype._updateCustomData = function(frameNumber, added, removed) {
  let customData = this.customData;
  let i2;
  let data;
  let rectangle;
  if (defined_default(added) && defined_default(removed)) {
    customData = customData.filter(function(value) {
      return removed.indexOf(value) === -1;
    });
    this._customData = customData;
    rectangle = this._rectangle;
    for (i2 = 0; i2 < added.length; ++i2) {
      data = added[i2];
      if (Rectangle_default.contains(rectangle, data.positionCartographic)) {
        customData.push(data);
      }
    }
    this._frameUpdated = frameNumber;
  } else {
    const parent = this._parent;
    if (defined_default(parent) && this._frameUpdated !== parent._frameUpdated) {
      customData.length = 0;
      rectangle = this._rectangle;
      const parentCustomData = parent.customData;
      for (i2 = 0; i2 < parentCustomData.length; ++i2) {
        data = parentCustomData[i2];
        if (Rectangle_default.contains(rectangle, data.positionCartographic)) {
          customData.push(data);
        }
      }
      this._frameUpdated = parent._frameUpdated;
    }
  }
};
Object.defineProperties(QuadtreeTile.prototype, {
  tilingScheme: {
    get: function() {
      return this._tilingScheme;
    }
  },
  x: {
    get: function() {
      return this._x;
    }
  },
  y: {
    get: function() {
      return this._y;
    }
  },
  level: {
    get: function() {
      return this._level;
    }
  },
  parent: {
    get: function() {
      return this._parent;
    }
  },
  rectangle: {
    get: function() {
      return this._rectangle;
    }
  },
  children: {
    get: function() {
      return [
        this.northwestChild,
        this.northeastChild,
        this.southwestChild,
        this.southeastChild
      ];
    }
  },
  southwestChild: {
    get: function() {
      if (!defined_default(this._southwestChild)) {
        this._southwestChild = new QuadtreeTile({
          tilingScheme: this.tilingScheme,
          x: this.x * 2,
          y: this.y * 2 + 1,
          level: this.level + 1,
          parent: this
        });
      }
      return this._southwestChild;
    }
  },
  southeastChild: {
    get: function() {
      if (!defined_default(this._southeastChild)) {
        this._southeastChild = new QuadtreeTile({
          tilingScheme: this.tilingScheme,
          x: this.x * 2 + 1,
          y: this.y * 2 + 1,
          level: this.level + 1,
          parent: this
        });
      }
      return this._southeastChild;
    }
  },
  northwestChild: {
    get: function() {
      if (!defined_default(this._northwestChild)) {
        this._northwestChild = new QuadtreeTile({
          tilingScheme: this.tilingScheme,
          x: this.x * 2,
          y: this.y * 2,
          level: this.level + 1,
          parent: this
        });
      }
      return this._northwestChild;
    }
  },
  northeastChild: {
    get: function() {
      if (!defined_default(this._northeastChild)) {
        this._northeastChild = new QuadtreeTile({
          tilingScheme: this.tilingScheme,
          x: this.x * 2 + 1,
          y: this.y * 2,
          level: this.level + 1,
          parent: this
        });
      }
      return this._northeastChild;
    }
  },
  customData: {
    get: function() {
      return this._customData;
    }
  },
  needsLoading: {
    get: function() {
      return this.state < QuadtreeTileLoadState_default.DONE;
    }
  },
  eligibleForUnloading: {
    get: function() {
      let result = true;
      if (defined_default(this.data)) {
        result = this.data.eligibleForUnloading;
        if (!defined_default(result)) {
          result = true;
        }
      }
      return result;
    }
  }
});
QuadtreeTile.prototype.findLevelZeroTile = function(levelZeroTiles, x, y) {
  const xTiles = this.tilingScheme.getNumberOfXTilesAtLevel(0);
  if (x < 0) {
    x += xTiles;
  } else if (x >= xTiles) {
    x -= xTiles;
  }
  if (y < 0 || y >= this.tilingScheme.getNumberOfYTilesAtLevel(0)) {
    return void 0;
  }
  return levelZeroTiles.filter(function(tile) {
    return tile.x === x && tile.y === y;
  })[0];
};
QuadtreeTile.prototype.findTileToWest = function(levelZeroTiles) {
  const parent = this.parent;
  if (parent === void 0) {
    return this.findLevelZeroTile(levelZeroTiles, this.x - 1, this.y);
  }
  if (parent.southeastChild === this) {
    return parent.southwestChild;
  } else if (parent.northeastChild === this) {
    return parent.northwestChild;
  }
  const westOfParent = parent.findTileToWest(levelZeroTiles);
  if (westOfParent === void 0) {
    return void 0;
  } else if (parent.southwestChild === this) {
    return westOfParent.southeastChild;
  }
  return westOfParent.northeastChild;
};
QuadtreeTile.prototype.findTileToEast = function(levelZeroTiles) {
  const parent = this.parent;
  if (parent === void 0) {
    return this.findLevelZeroTile(levelZeroTiles, this.x + 1, this.y);
  }
  if (parent.southwestChild === this) {
    return parent.southeastChild;
  } else if (parent.northwestChild === this) {
    return parent.northeastChild;
  }
  const eastOfParent = parent.findTileToEast(levelZeroTiles);
  if (eastOfParent === void 0) {
    return void 0;
  } else if (parent.southeastChild === this) {
    return eastOfParent.southwestChild;
  }
  return eastOfParent.northwestChild;
};
QuadtreeTile.prototype.findTileToSouth = function(levelZeroTiles) {
  const parent = this.parent;
  if (parent === void 0) {
    return this.findLevelZeroTile(levelZeroTiles, this.x, this.y + 1);
  }
  if (parent.northwestChild === this) {
    return parent.southwestChild;
  } else if (parent.northeastChild === this) {
    return parent.southeastChild;
  }
  const southOfParent = parent.findTileToSouth(levelZeroTiles);
  if (southOfParent === void 0) {
    return void 0;
  } else if (parent.southwestChild === this) {
    return southOfParent.northwestChild;
  }
  return southOfParent.northeastChild;
};
QuadtreeTile.prototype.findTileToNorth = function(levelZeroTiles) {
  const parent = this.parent;
  if (parent === void 0) {
    return this.findLevelZeroTile(levelZeroTiles, this.x, this.y - 1);
  }
  if (parent.southwestChild === this) {
    return parent.northwestChild;
  } else if (parent.southeastChild === this) {
    return parent.northeastChild;
  }
  const northOfParent = parent.findTileToNorth(levelZeroTiles);
  if (northOfParent === void 0) {
    return void 0;
  } else if (parent.northwestChild === this) {
    return northOfParent.southwestChild;
  }
  return northOfParent.southeastChild;
};
QuadtreeTile.prototype.freeResources = function() {
  this.state = QuadtreeTileLoadState_default.START;
  this.renderable = false;
  this.upsampledFromParent = false;
  if (defined_default(this.data) && defined_default(this.data.freeResources)) {
    this.data.freeResources();
  }
  freeTile(this._southwestChild);
  this._southwestChild = void 0;
  freeTile(this._southeastChild);
  this._southeastChild = void 0;
  freeTile(this._northwestChild);
  this._northwestChild = void 0;
  freeTile(this._northeastChild);
  this._northeastChild = void 0;
};
function freeTile(tile) {
  if (defined_default(tile)) {
    tile.freeResources();
  }
}
var QuadtreeTile_default = QuadtreeTile;

// node_modules/cesium/Source/Scene/TileReplacementQueue.js
function TileReplacementQueue() {
  this.head = void 0;
  this.tail = void 0;
  this.count = 0;
  this._lastBeforeStartOfFrame = void 0;
}
TileReplacementQueue.prototype.markStartOfRenderFrame = function() {
  this._lastBeforeStartOfFrame = this.head;
};
TileReplacementQueue.prototype.trimTiles = function(maximumTiles) {
  let tileToTrim = this.tail;
  let keepTrimming = true;
  while (keepTrimming && defined_default(this._lastBeforeStartOfFrame) && this.count > maximumTiles && defined_default(tileToTrim)) {
    keepTrimming = tileToTrim !== this._lastBeforeStartOfFrame;
    const previous = tileToTrim.replacementPrevious;
    if (tileToTrim.eligibleForUnloading) {
      tileToTrim.freeResources();
      remove3(this, tileToTrim);
    }
    tileToTrim = previous;
  }
};
function remove3(tileReplacementQueue, item) {
  const previous = item.replacementPrevious;
  const next = item.replacementNext;
  if (item === tileReplacementQueue._lastBeforeStartOfFrame) {
    tileReplacementQueue._lastBeforeStartOfFrame = next;
  }
  if (item === tileReplacementQueue.head) {
    tileReplacementQueue.head = next;
  } else {
    previous.replacementNext = next;
  }
  if (item === tileReplacementQueue.tail) {
    tileReplacementQueue.tail = previous;
  } else {
    next.replacementPrevious = previous;
  }
  item.replacementPrevious = void 0;
  item.replacementNext = void 0;
  --tileReplacementQueue.count;
}
TileReplacementQueue.prototype.markTileRendered = function(item) {
  const head = this.head;
  if (head === item) {
    if (item === this._lastBeforeStartOfFrame) {
      this._lastBeforeStartOfFrame = item.replacementNext;
    }
    return;
  }
  ++this.count;
  if (!defined_default(head)) {
    item.replacementPrevious = void 0;
    item.replacementNext = void 0;
    this.head = item;
    this.tail = item;
    return;
  }
  if (defined_default(item.replacementPrevious) || defined_default(item.replacementNext)) {
    remove3(this, item);
  }
  item.replacementPrevious = void 0;
  item.replacementNext = head;
  head.replacementPrevious = item;
  this.head = item;
};
var TileReplacementQueue_default = TileReplacementQueue;

// node_modules/cesium/Source/Scene/QuadtreePrimitive.js
function QuadtreePrimitive(options) {
  if (!defined_default(options) || !defined_default(options.tileProvider)) {
    throw new DeveloperError_default("options.tileProvider is required.");
  }
  if (defined_default(options.tileProvider.quadtree)) {
    throw new DeveloperError_default(
      "A QuadtreeTileProvider can only be used with a single QuadtreePrimitive"
    );
  }
  this._tileProvider = options.tileProvider;
  this._tileProvider.quadtree = this;
  this._debug = {
    enableDebugOutput: false,
    maxDepth: 0,
    maxDepthVisited: 0,
    tilesVisited: 0,
    tilesCulled: 0,
    tilesRendered: 0,
    tilesWaitingForChildren: 0,
    lastMaxDepth: -1,
    lastMaxDepthVisited: -1,
    lastTilesVisited: -1,
    lastTilesCulled: -1,
    lastTilesRendered: -1,
    lastTilesWaitingForChildren: -1,
    suspendLodUpdate: false
  };
  const tilingScheme2 = this._tileProvider.tilingScheme;
  const ellipsoid = tilingScheme2.ellipsoid;
  this._tilesToRender = [];
  this._tileLoadQueueHigh = [];
  this._tileLoadQueueMedium = [];
  this._tileLoadQueueLow = [];
  this._tileReplacementQueue = new TileReplacementQueue_default();
  this._levelZeroTiles = void 0;
  this._loadQueueTimeSlice = 5;
  this._tilesInvalidated = false;
  this._addHeightCallbacks = [];
  this._removeHeightCallbacks = [];
  this._tileToUpdateHeights = [];
  this._lastTileIndex = 0;
  this._updateHeightsTimeSlice = 2;
  this._cameraPositionCartographic = void 0;
  this._cameraReferenceFrameOriginCartographic = void 0;
  this.maximumScreenSpaceError = defaultValue_default(
    options.maximumScreenSpaceError,
    2
  );
  this.tileCacheSize = defaultValue_default(options.tileCacheSize, 100);
  this.loadingDescendantLimit = 20;
  this.preloadAncestors = true;
  this.preloadSiblings = false;
  this._occluders = new QuadtreeOccluders_default({
    ellipsoid
  });
  this._tileLoadProgressEvent = new Event_default();
  this._lastTileLoadQueueLength = 0;
  this._lastSelectionFrameNumber = void 0;
}
Object.defineProperties(QuadtreePrimitive.prototype, {
  tileProvider: {
    get: function() {
      return this._tileProvider;
    }
  },
  tileLoadProgressEvent: {
    get: function() {
      return this._tileLoadProgressEvent;
    }
  },
  occluders: {
    get: function() {
      return this._occluders;
    }
  }
});
QuadtreePrimitive.prototype.invalidateAllTiles = function() {
  this._tilesInvalidated = true;
};
function invalidateAllTiles(primitive) {
  const replacementQueue = primitive._tileReplacementQueue;
  replacementQueue.head = void 0;
  replacementQueue.tail = void 0;
  replacementQueue.count = 0;
  clearTileLoadQueue(primitive);
  const levelZeroTiles = primitive._levelZeroTiles;
  if (defined_default(levelZeroTiles)) {
    for (let i2 = 0; i2 < levelZeroTiles.length; ++i2) {
      const tile = levelZeroTiles[i2];
      const customData = tile.customData;
      const customDataLength = customData.length;
      for (let j = 0; j < customDataLength; ++j) {
        const data = customData[j];
        data.level = 0;
        primitive._addHeightCallbacks.push(data);
      }
      levelZeroTiles[i2].freeResources();
    }
  }
  primitive._levelZeroTiles = void 0;
  primitive._tileProvider.cancelReprojections();
}
QuadtreePrimitive.prototype.forEachLoadedTile = function(tileFunction) {
  let tile = this._tileReplacementQueue.head;
  while (defined_default(tile)) {
    if (tile.state !== QuadtreeTileLoadState_default.START) {
      tileFunction(tile);
    }
    tile = tile.replacementNext;
  }
};
QuadtreePrimitive.prototype.forEachRenderedTile = function(tileFunction) {
  const tilesRendered = this._tilesToRender;
  for (let i2 = 0, len = tilesRendered.length; i2 < len; ++i2) {
    tileFunction(tilesRendered[i2]);
  }
};
QuadtreePrimitive.prototype.updateHeight = function(cartographic2, callback) {
  const primitive = this;
  const object2 = {
    positionOnEllipsoidSurface: void 0,
    positionCartographic: cartographic2,
    level: -1,
    callback
  };
  object2.removeFunc = function() {
    const addedCallbacks = primitive._addHeightCallbacks;
    const length3 = addedCallbacks.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      if (addedCallbacks[i2] === object2) {
        addedCallbacks.splice(i2, 1);
        break;
      }
    }
    primitive._removeHeightCallbacks.push(object2);
    if (object2.callback) {
      object2.callback = void 0;
    }
  };
  primitive._addHeightCallbacks.push(object2);
  return object2.removeFunc;
};
QuadtreePrimitive.prototype.update = function(frameState) {
  if (defined_default(this._tileProvider.update)) {
    this._tileProvider.update(frameState);
  }
};
function clearTileLoadQueue(primitive) {
  const debug = primitive._debug;
  debug.maxDepth = 0;
  debug.maxDepthVisited = 0;
  debug.tilesVisited = 0;
  debug.tilesCulled = 0;
  debug.tilesRendered = 0;
  debug.tilesWaitingForChildren = 0;
  primitive._tileLoadQueueHigh.length = 0;
  primitive._tileLoadQueueMedium.length = 0;
  primitive._tileLoadQueueLow.length = 0;
}
QuadtreePrimitive.prototype.beginFrame = function(frameState) {
  const passes = frameState.passes;
  if (!passes.render) {
    return;
  }
  if (this._tilesInvalidated) {
    invalidateAllTiles(this);
    this._tilesInvalidated = false;
  }
  this._tileProvider.initialize(frameState);
  clearTileLoadQueue(this);
  if (this._debug.suspendLodUpdate) {
    return;
  }
  this._tileReplacementQueue.markStartOfRenderFrame();
};
QuadtreePrimitive.prototype.render = function(frameState) {
  const passes = frameState.passes;
  const tileProvider = this._tileProvider;
  if (passes.render) {
    tileProvider.beginUpdate(frameState);
    selectTilesForRendering(this, frameState);
    createRenderCommandsForSelectedTiles(this, frameState);
    tileProvider.endUpdate(frameState);
  }
  if (passes.pick && this._tilesToRender.length > 0) {
    tileProvider.updateForPick(frameState);
  }
};
function updateTileLoadProgress(primitive, frameState) {
  const currentLoadQueueLength = primitive._tileLoadQueueHigh.length + primitive._tileLoadQueueMedium.length + primitive._tileLoadQueueLow.length;
  if (currentLoadQueueLength !== primitive._lastTileLoadQueueLength || primitive._tilesInvalidated) {
    frameState.afterRender.push(
      Event_default.prototype.raiseEvent.bind(
        primitive._tileLoadProgressEvent,
        currentLoadQueueLength
      )
    );
    primitive._lastTileLoadQueueLength = currentLoadQueueLength;
  }
  const debug = primitive._debug;
  if (debug.enableDebugOutput && !debug.suspendLodUpdate) {
    debug.maxDepth = primitive._tilesToRender.reduce(function(max3, tile) {
      return Math.max(max3, tile.level);
    }, -1);
    debug.tilesRendered = primitive._tilesToRender.length;
    if (debug.tilesVisited !== debug.lastTilesVisited || debug.tilesRendered !== debug.lastTilesRendered || debug.tilesCulled !== debug.lastTilesCulled || debug.maxDepth !== debug.lastMaxDepth || debug.tilesWaitingForChildren !== debug.lastTilesWaitingForChildren || debug.maxDepthVisited !== debug.lastMaxDepthVisited) {
      console.log(
        `Visited ${debug.tilesVisited}, Rendered: ${debug.tilesRendered}, Culled: ${debug.tilesCulled}, Max Depth Rendered: ${debug.maxDepth}, Max Depth Visited: ${debug.maxDepthVisited}, Waiting for children: ${debug.tilesWaitingForChildren}`
      );
      debug.lastTilesVisited = debug.tilesVisited;
      debug.lastTilesRendered = debug.tilesRendered;
      debug.lastTilesCulled = debug.tilesCulled;
      debug.lastMaxDepth = debug.maxDepth;
      debug.lastTilesWaitingForChildren = debug.tilesWaitingForChildren;
      debug.lastMaxDepthVisited = debug.maxDepthVisited;
    }
  }
}
QuadtreePrimitive.prototype.endFrame = function(frameState) {
  const passes = frameState.passes;
  if (!passes.render || frameState.mode === SceneMode_default.MORPHING) {
    return;
  }
  processTileLoadQueue(this, frameState);
  updateHeights2(this, frameState);
  updateTileLoadProgress(this, frameState);
};
QuadtreePrimitive.prototype.isDestroyed = function() {
  return false;
};
QuadtreePrimitive.prototype.destroy = function() {
  this._tileProvider = this._tileProvider && this._tileProvider.destroy();
};
var comparisonPoint;
var centerScratch6 = new Cartographic_default();
function compareDistanceToPoint(a4, b) {
  let center = Rectangle_default.center(a4.rectangle, centerScratch6);
  const alon = center.longitude - comparisonPoint.longitude;
  const alat = center.latitude - comparisonPoint.latitude;
  center = Rectangle_default.center(b.rectangle, centerScratch6);
  const blon = center.longitude - comparisonPoint.longitude;
  const blat = center.latitude - comparisonPoint.latitude;
  return alon * alon + alat * alat - (blon * blon + blat * blat);
}
var cameraOriginScratch = new Cartesian3_default();
var rootTraversalDetails = [];
function selectTilesForRendering(primitive, frameState) {
  const debug = primitive._debug;
  if (debug.suspendLodUpdate) {
    return;
  }
  const tilesToRender = primitive._tilesToRender;
  tilesToRender.length = 0;
  let i2;
  const tileProvider = primitive._tileProvider;
  if (!defined_default(primitive._levelZeroTiles)) {
    if (tileProvider.ready) {
      const tilingScheme2 = tileProvider.tilingScheme;
      primitive._levelZeroTiles = QuadtreeTile_default.createLevelZeroTiles(
        tilingScheme2
      );
      const numberOfRootTiles = primitive._levelZeroTiles.length;
      if (rootTraversalDetails.length < numberOfRootTiles) {
        rootTraversalDetails = new Array(numberOfRootTiles);
        for (i2 = 0; i2 < numberOfRootTiles; ++i2) {
          if (rootTraversalDetails[i2] === void 0) {
            rootTraversalDetails[i2] = new TraversalDetails();
          }
        }
      }
    } else {
      return;
    }
  }
  primitive._occluders.ellipsoid.cameraPosition = frameState.camera.positionWC;
  let tile;
  const levelZeroTiles = primitive._levelZeroTiles;
  const occluders = levelZeroTiles.length > 1 ? primitive._occluders : void 0;
  comparisonPoint = frameState.camera.positionCartographic;
  levelZeroTiles.sort(compareDistanceToPoint);
  const customDataAdded = primitive._addHeightCallbacks;
  const customDataRemoved = primitive._removeHeightCallbacks;
  const frameNumber = frameState.frameNumber;
  let len;
  if (customDataAdded.length > 0 || customDataRemoved.length > 0) {
    for (i2 = 0, len = levelZeroTiles.length; i2 < len; ++i2) {
      tile = levelZeroTiles[i2];
      tile._updateCustomData(frameNumber, customDataAdded, customDataRemoved);
    }
    customDataAdded.length = 0;
    customDataRemoved.length = 0;
  }
  const camera = frameState.camera;
  primitive._cameraPositionCartographic = camera.positionCartographic;
  const cameraFrameOrigin = Matrix4_default.getTranslation(
    camera.transform,
    cameraOriginScratch
  );
  primitive._cameraReferenceFrameOriginCartographic = primitive.tileProvider.tilingScheme.ellipsoid.cartesianToCartographic(
    cameraFrameOrigin,
    primitive._cameraReferenceFrameOriginCartographic
  );
  for (i2 = 0, len = levelZeroTiles.length; i2 < len; ++i2) {
    tile = levelZeroTiles[i2];
    primitive._tileReplacementQueue.markTileRendered(tile);
    if (!tile.renderable) {
      queueTileLoad(primitive, primitive._tileLoadQueueHigh, tile, frameState);
      ++debug.tilesWaitingForChildren;
    } else {
      visitIfVisible(
        primitive,
        tile,
        tileProvider,
        frameState,
        occluders,
        false,
        rootTraversalDetails[i2]
      );
    }
  }
  primitive._lastSelectionFrameNumber = frameNumber;
}
function queueTileLoad(primitive, queue, tile, frameState) {
  if (!tile.needsLoading) {
    return;
  }
  if (primitive.tileProvider.computeTileLoadPriority !== void 0) {
    tile._loadPriority = primitive.tileProvider.computeTileLoadPriority(
      tile,
      frameState
    );
  }
  queue.push(tile);
}
function TraversalDetails() {
  this.allAreRenderable = true;
  this.anyWereRenderedLastFrame = false;
  this.notYetRenderableCount = 0;
}
function TraversalQuadDetails() {
  this.southwest = new TraversalDetails();
  this.southeast = new TraversalDetails();
  this.northwest = new TraversalDetails();
  this.northeast = new TraversalDetails();
}
TraversalQuadDetails.prototype.combine = function(result) {
  const southwest = this.southwest;
  const southeast = this.southeast;
  const northwest = this.northwest;
  const northeast = this.northeast;
  result.allAreRenderable = southwest.allAreRenderable && southeast.allAreRenderable && northwest.allAreRenderable && northeast.allAreRenderable;
  result.anyWereRenderedLastFrame = southwest.anyWereRenderedLastFrame || southeast.anyWereRenderedLastFrame || northwest.anyWereRenderedLastFrame || northeast.anyWereRenderedLastFrame;
  result.notYetRenderableCount = southwest.notYetRenderableCount + southeast.notYetRenderableCount + northwest.notYetRenderableCount + northeast.notYetRenderableCount;
};
var traversalQuadsByLevel = new Array(31);
for (let i2 = 0; i2 < traversalQuadsByLevel.length; ++i2) {
  traversalQuadsByLevel[i2] = new TraversalQuadDetails();
}
function visitTile4(primitive, frameState, tile, ancestorMeetsSse, traversalDetails) {
  const debug = primitive._debug;
  ++debug.tilesVisited;
  primitive._tileReplacementQueue.markTileRendered(tile);
  tile._updateCustomData(frameState.frameNumber);
  if (tile.level > debug.maxDepthVisited) {
    debug.maxDepthVisited = tile.level;
  }
  const meetsSse = screenSpaceError(primitive, frameState, tile) < primitive.maximumScreenSpaceError;
  const southwestChild = tile.southwestChild;
  const southeastChild = tile.southeastChild;
  const northwestChild = tile.northwestChild;
  const northeastChild = tile.northeastChild;
  const lastFrame = primitive._lastSelectionFrameNumber;
  const lastFrameSelectionResult = tile._lastSelectionResultFrame === lastFrame ? tile._lastSelectionResult : TileSelectionResult_default.NONE;
  const tileProvider = primitive.tileProvider;
  if (meetsSse || ancestorMeetsSse) {
    const oneRenderedLastFrame = TileSelectionResult_default.originalResult(lastFrameSelectionResult) === TileSelectionResult_default.RENDERED;
    const twoCulledOrNotVisited = TileSelectionResult_default.originalResult(lastFrameSelectionResult) === TileSelectionResult_default.CULLED || lastFrameSelectionResult === TileSelectionResult_default.NONE;
    const threeCompletelyLoaded = tile.state === QuadtreeTileLoadState_default.DONE;
    let renderable = oneRenderedLastFrame || twoCulledOrNotVisited || threeCompletelyLoaded;
    if (!renderable) {
      if (defined_default(tileProvider.canRenderWithoutLosingDetail)) {
        renderable = tileProvider.canRenderWithoutLosingDetail(tile);
      }
    }
    if (renderable) {
      if (meetsSse) {
        queueTileLoad(
          primitive,
          primitive._tileLoadQueueMedium,
          tile,
          frameState
        );
      }
      addTileToRenderList(primitive, tile);
      traversalDetails.allAreRenderable = tile.renderable;
      traversalDetails.anyWereRenderedLastFrame = lastFrameSelectionResult === TileSelectionResult_default.RENDERED;
      traversalDetails.notYetRenderableCount = tile.renderable ? 0 : 1;
      tile._lastSelectionResultFrame = frameState.frameNumber;
      tile._lastSelectionResult = TileSelectionResult_default.RENDERED;
      if (!traversalDetails.anyWereRenderedLastFrame) {
        primitive._tileToUpdateHeights.push(tile);
      }
      return;
    }
    ancestorMeetsSse = true;
    if (meetsSse) {
      queueTileLoad(primitive, primitive._tileLoadQueueHigh, tile, frameState);
    }
  }
  if (tileProvider.canRefine(tile)) {
    const allAreUpsampled = southwestChild.upsampledFromParent && southeastChild.upsampledFromParent && northwestChild.upsampledFromParent && northeastChild.upsampledFromParent;
    if (allAreUpsampled) {
      addTileToRenderList(primitive, tile);
      queueTileLoad(
        primitive,
        primitive._tileLoadQueueMedium,
        tile,
        frameState
      );
      primitive._tileReplacementQueue.markTileRendered(southwestChild);
      primitive._tileReplacementQueue.markTileRendered(southeastChild);
      primitive._tileReplacementQueue.markTileRendered(northwestChild);
      primitive._tileReplacementQueue.markTileRendered(northeastChild);
      traversalDetails.allAreRenderable = tile.renderable;
      traversalDetails.anyWereRenderedLastFrame = lastFrameSelectionResult === TileSelectionResult_default.RENDERED;
      traversalDetails.notYetRenderableCount = tile.renderable ? 0 : 1;
      tile._lastSelectionResultFrame = frameState.frameNumber;
      tile._lastSelectionResult = TileSelectionResult_default.RENDERED;
      if (!traversalDetails.anyWereRenderedLastFrame) {
        primitive._tileToUpdateHeights.push(tile);
      }
      return;
    }
    tile._lastSelectionResultFrame = frameState.frameNumber;
    tile._lastSelectionResult = TileSelectionResult_default.REFINED;
    const firstRenderedDescendantIndex = primitive._tilesToRender.length;
    const loadIndexLow = primitive._tileLoadQueueLow.length;
    const loadIndexMedium = primitive._tileLoadQueueMedium.length;
    const loadIndexHigh = primitive._tileLoadQueueHigh.length;
    const tilesToUpdateHeightsIndex = primitive._tileToUpdateHeights.length;
    visitVisibleChildrenNearToFar(
      primitive,
      southwestChild,
      southeastChild,
      northwestChild,
      northeastChild,
      frameState,
      ancestorMeetsSse,
      traversalDetails
    );
    if (firstRenderedDescendantIndex !== primitive._tilesToRender.length) {
      const allAreRenderable = traversalDetails.allAreRenderable;
      const anyWereRenderedLastFrame = traversalDetails.anyWereRenderedLastFrame;
      const notYetRenderableCount = traversalDetails.notYetRenderableCount;
      let queuedForLoad = false;
      if (!allAreRenderable && !anyWereRenderedLastFrame) {
        const renderList = primitive._tilesToRender;
        for (let i2 = firstRenderedDescendantIndex; i2 < renderList.length; ++i2) {
          let workTile = renderList[i2];
          while (workTile !== void 0 && workTile._lastSelectionResult !== TileSelectionResult_default.KICKED && workTile !== tile) {
            workTile._lastSelectionResult = TileSelectionResult_default.kick(
              workTile._lastSelectionResult
            );
            workTile = workTile.parent;
          }
        }
        primitive._tilesToRender.length = firstRenderedDescendantIndex;
        primitive._tileToUpdateHeights.length = tilesToUpdateHeightsIndex;
        addTileToRenderList(primitive, tile);
        tile._lastSelectionResult = TileSelectionResult_default.RENDERED;
        const wasRenderedLastFrame = lastFrameSelectionResult === TileSelectionResult_default.RENDERED;
        if (!wasRenderedLastFrame && notYetRenderableCount > primitive.loadingDescendantLimit) {
          primitive._tileLoadQueueLow.length = loadIndexLow;
          primitive._tileLoadQueueMedium.length = loadIndexMedium;
          primitive._tileLoadQueueHigh.length = loadIndexHigh;
          queueTileLoad(
            primitive,
            primitive._tileLoadQueueMedium,
            tile,
            frameState
          );
          traversalDetails.notYetRenderableCount = tile.renderable ? 0 : 1;
          queuedForLoad = true;
        }
        traversalDetails.allAreRenderable = tile.renderable;
        traversalDetails.anyWereRenderedLastFrame = wasRenderedLastFrame;
        if (!wasRenderedLastFrame) {
          primitive._tileToUpdateHeights.push(tile);
        }
        ++debug.tilesWaitingForChildren;
      }
      if (primitive.preloadAncestors && !queuedForLoad) {
        queueTileLoad(primitive, primitive._tileLoadQueueLow, tile, frameState);
      }
    }
    return;
  }
  tile._lastSelectionResultFrame = frameState.frameNumber;
  tile._lastSelectionResult = TileSelectionResult_default.RENDERED;
  addTileToRenderList(primitive, tile);
  queueTileLoad(primitive, primitive._tileLoadQueueHigh, tile, frameState);
  traversalDetails.allAreRenderable = tile.renderable;
  traversalDetails.anyWereRenderedLastFrame = lastFrameSelectionResult === TileSelectionResult_default.RENDERED;
  traversalDetails.notYetRenderableCount = tile.renderable ? 0 : 1;
}
function visitVisibleChildrenNearToFar(primitive, southwest, southeast, northwest, northeast, frameState, ancestorMeetsSse, traversalDetails) {
  const cameraPosition = frameState.camera.positionCartographic;
  const tileProvider = primitive._tileProvider;
  const occluders = primitive._occluders;
  const quadDetails = traversalQuadsByLevel[southwest.level];
  const southwestDetails = quadDetails.southwest;
  const southeastDetails = quadDetails.southeast;
  const northwestDetails = quadDetails.northwest;
  const northeastDetails = quadDetails.northeast;
  if (cameraPosition.longitude < southwest.rectangle.east) {
    if (cameraPosition.latitude < southwest.rectangle.north) {
      visitIfVisible(
        primitive,
        southwest,
        tileProvider,
        frameState,
        occluders,
        ancestorMeetsSse,
        southwestDetails
      );
      visitIfVisible(
        primitive,
        southeast,
        tileProvider,
        frameState,
        occluders,
        ancestorMeetsSse,
        southeastDetails
      );
      visitIfVisible(
        primitive,
        northwest,
        tileProvider,
        frameState,
        occluders,
        ancestorMeetsSse,
        northwestDetails
      );
      visitIfVisible(
        primitive,
        northeast,
        tileProvider,
        frameState,
        occluders,
        ancestorMeetsSse,
        northeastDetails
      );
    } else {
      visitIfVisible(
        primitive,
        northwest,
        tileProvider,
        frameState,
        occluders,
        ancestorMeetsSse,
        northwestDetails
      );
      visitIfVisible(
        primitive,
        southwest,
        tileProvider,
        frameState,
        occluders,
        ancestorMeetsSse,
        southwestDetails
      );
      visitIfVisible(
        primitive,
        northeast,
        tileProvider,
        frameState,
        occluders,
        ancestorMeetsSse,
        northeastDetails
      );
      visitIfVisible(
        primitive,
        southeast,
        tileProvider,
        frameState,
        occluders,
        ancestorMeetsSse,
        southeastDetails
      );
    }
  } else if (cameraPosition.latitude < southwest.rectangle.north) {
    visitIfVisible(
      primitive,
      southeast,
      tileProvider,
      frameState,
      occluders,
      ancestorMeetsSse,
      southeastDetails
    );
    visitIfVisible(
      primitive,
      southwest,
      tileProvider,
      frameState,
      occluders,
      ancestorMeetsSse,
      southwestDetails
    );
    visitIfVisible(
      primitive,
      northeast,
      tileProvider,
      frameState,
      occluders,
      ancestorMeetsSse,
      northeastDetails
    );
    visitIfVisible(
      primitive,
      northwest,
      tileProvider,
      frameState,
      occluders,
      ancestorMeetsSse,
      northwestDetails
    );
  } else {
    visitIfVisible(
      primitive,
      northeast,
      tileProvider,
      frameState,
      occluders,
      ancestorMeetsSse,
      northeastDetails
    );
    visitIfVisible(
      primitive,
      northwest,
      tileProvider,
      frameState,
      occluders,
      ancestorMeetsSse,
      northwestDetails
    );
    visitIfVisible(
      primitive,
      southeast,
      tileProvider,
      frameState,
      occluders,
      ancestorMeetsSse,
      southeastDetails
    );
    visitIfVisible(
      primitive,
      southwest,
      tileProvider,
      frameState,
      occluders,
      ancestorMeetsSse,
      southwestDetails
    );
  }
  quadDetails.combine(traversalDetails);
}
function containsNeededPosition(primitive, tile) {
  const rectangle = tile.rectangle;
  return defined_default(primitive._cameraPositionCartographic) && Rectangle_default.contains(rectangle, primitive._cameraPositionCartographic) || defined_default(primitive._cameraReferenceFrameOriginCartographic) && Rectangle_default.contains(
    rectangle,
    primitive._cameraReferenceFrameOriginCartographic
  );
}
function visitIfVisible(primitive, tile, tileProvider, frameState, occluders, ancestorMeetsSse, traversalDetails) {
  if (tileProvider.computeTileVisibility(tile, frameState, occluders) !== Visibility_default.NONE) {
    return visitTile4(
      primitive,
      frameState,
      tile,
      ancestorMeetsSse,
      traversalDetails
    );
  }
  ++primitive._debug.tilesCulled;
  primitive._tileReplacementQueue.markTileRendered(tile);
  traversalDetails.allAreRenderable = true;
  traversalDetails.anyWereRenderedLastFrame = false;
  traversalDetails.notYetRenderableCount = 0;
  if (containsNeededPosition(primitive, tile)) {
    if (!defined_default(tile.data) || !defined_default(tile.data.vertexArray)) {
      queueTileLoad(
        primitive,
        primitive._tileLoadQueueMedium,
        tile,
        frameState
      );
    }
    const lastFrame = primitive._lastSelectionFrameNumber;
    const lastFrameSelectionResult = tile._lastSelectionResultFrame === lastFrame ? tile._lastSelectionResult : TileSelectionResult_default.NONE;
    if (lastFrameSelectionResult !== TileSelectionResult_default.CULLED_BUT_NEEDED && lastFrameSelectionResult !== TileSelectionResult_default.RENDERED) {
      primitive._tileToUpdateHeights.push(tile);
    }
    tile._lastSelectionResult = TileSelectionResult_default.CULLED_BUT_NEEDED;
  } else if (primitive.preloadSiblings || tile.level === 0) {
    queueTileLoad(primitive, primitive._tileLoadQueueLow, tile, frameState);
    tile._lastSelectionResult = TileSelectionResult_default.CULLED;
  } else {
    tile._lastSelectionResult = TileSelectionResult_default.CULLED;
  }
  tile._lastSelectionResultFrame = frameState.frameNumber;
}
function screenSpaceError(primitive, frameState, tile) {
  if (frameState.mode === SceneMode_default.SCENE2D || frameState.camera.frustum instanceof OrthographicFrustum_default || frameState.camera.frustum instanceof OrthographicOffCenterFrustum_default) {
    return screenSpaceError2D(primitive, frameState, tile);
  }
  const maxGeometricError = primitive._tileProvider.getLevelMaximumGeometricError(
    tile.level
  );
  const distance2 = tile._distance;
  const height = frameState.context.drawingBufferHeight;
  const sseDenominator = frameState.camera.frustum.sseDenominator;
  let error = maxGeometricError * height / (distance2 * sseDenominator);
  if (frameState.fog.enabled) {
    error -= Math_default.fog(distance2, frameState.fog.density) * frameState.fog.sse;
  }
  error /= frameState.pixelRatio;
  return error;
}
function screenSpaceError2D(primitive, frameState, tile) {
  const camera = frameState.camera;
  let frustum = camera.frustum;
  if (defined_default(frustum._offCenterFrustum)) {
    frustum = frustum._offCenterFrustum;
  }
  const context = frameState.context;
  const width = context.drawingBufferWidth;
  const height = context.drawingBufferHeight;
  const maxGeometricError = primitive._tileProvider.getLevelMaximumGeometricError(
    tile.level
  );
  const pixelSize = Math.max(frustum.top - frustum.bottom, frustum.right - frustum.left) / Math.max(width, height);
  let error = maxGeometricError / pixelSize;
  if (frameState.fog.enabled && frameState.mode !== SceneMode_default.SCENE2D) {
    error -= Math_default.fog(tile._distance, frameState.fog.density) * frameState.fog.sse;
  }
  error /= frameState.pixelRatio;
  return error;
}
function addTileToRenderList(primitive, tile) {
  primitive._tilesToRender.push(tile);
}
function processTileLoadQueue(primitive, frameState) {
  const tileLoadQueueHigh = primitive._tileLoadQueueHigh;
  const tileLoadQueueMedium = primitive._tileLoadQueueMedium;
  const tileLoadQueueLow = primitive._tileLoadQueueLow;
  if (tileLoadQueueHigh.length === 0 && tileLoadQueueMedium.length === 0 && tileLoadQueueLow.length === 0) {
    return;
  }
  primitive._tileReplacementQueue.trimTiles(primitive.tileCacheSize);
  const endTime = getTimestamp_default() + primitive._loadQueueTimeSlice;
  const tileProvider = primitive._tileProvider;
  let didSomeLoading = processSinglePriorityLoadQueue(
    primitive,
    frameState,
    tileProvider,
    endTime,
    tileLoadQueueHigh,
    false
  );
  didSomeLoading = processSinglePriorityLoadQueue(
    primitive,
    frameState,
    tileProvider,
    endTime,
    tileLoadQueueMedium,
    didSomeLoading
  );
  processSinglePriorityLoadQueue(
    primitive,
    frameState,
    tileProvider,
    endTime,
    tileLoadQueueLow,
    didSomeLoading
  );
}
function sortByLoadPriority(a4, b) {
  return a4._loadPriority - b._loadPriority;
}
function processSinglePriorityLoadQueue(primitive, frameState, tileProvider, endTime, loadQueue, didSomeLoading) {
  if (tileProvider.computeTileLoadPriority !== void 0) {
    loadQueue.sort(sortByLoadPriority);
  }
  for (let i2 = 0, len = loadQueue.length; i2 < len && (getTimestamp_default() < endTime || !didSomeLoading); ++i2) {
    const tile = loadQueue[i2];
    primitive._tileReplacementQueue.markTileRendered(tile);
    tileProvider.loadTile(frameState, tile);
    didSomeLoading = true;
  }
  return didSomeLoading;
}
var scratchRay = new Ray_default();
var scratchCartographic18 = new Cartographic_default();
var scratchPosition14 = new Cartesian3_default();
var scratchArray = [];
function updateHeights2(primitive, frameState) {
  if (!primitive.tileProvider.ready) {
    return;
  }
  const tryNextFrame = scratchArray;
  tryNextFrame.length = 0;
  const tilesToUpdateHeights = primitive._tileToUpdateHeights;
  const startTime = getTimestamp_default();
  const timeSlice = primitive._updateHeightsTimeSlice;
  const endTime = startTime + timeSlice;
  const mode2 = frameState.mode;
  const projection = frameState.mapProjection;
  const ellipsoid = primitive.tileProvider.tilingScheme.ellipsoid;
  let i2;
  while (tilesToUpdateHeights.length > 0) {
    const tile = tilesToUpdateHeights[0];
    if (!defined_default(tile.data) || !defined_default(tile.data.mesh)) {
      const selectionResult = tile._lastSelectionResultFrame === primitive._lastSelectionFrameNumber ? tile._lastSelectionResult : TileSelectionResult_default.NONE;
      if (selectionResult === TileSelectionResult_default.RENDERED || selectionResult === TileSelectionResult_default.CULLED_BUT_NEEDED) {
        tryNextFrame.push(tile);
      }
      tilesToUpdateHeights.shift();
      primitive._lastTileIndex = 0;
      continue;
    }
    const customData = tile.customData;
    const customDataLength = customData.length;
    let timeSliceMax = false;
    for (i2 = primitive._lastTileIndex; i2 < customDataLength; ++i2) {
      const data = customData[i2];
      const terrainData = tile.data.terrainData;
      const upsampledGeometryFromParent = defined_default(terrainData) && terrainData.wasCreatedByUpsampling();
      if (tile.level > data.level && !upsampledGeometryFromParent) {
        if (!defined_default(data.positionOnEllipsoidSurface)) {
          data.positionOnEllipsoidSurface = Cartesian3_default.fromRadians(
            data.positionCartographic.longitude,
            data.positionCartographic.latitude,
            0,
            ellipsoid
          );
        }
        if (mode2 === SceneMode_default.SCENE3D) {
          const surfaceNormal = ellipsoid.geodeticSurfaceNormal(
            data.positionOnEllipsoidSurface,
            scratchRay.direction
          );
          const rayOrigin = ellipsoid.getSurfaceNormalIntersectionWithZAxis(
            data.positionOnEllipsoidSurface,
            11500,
            scratchRay.origin
          );
          if (!defined_default(rayOrigin)) {
            let minimumHeight = 0;
            if (defined_default(tile.data.tileBoundingRegion)) {
              minimumHeight = tile.data.tileBoundingRegion.minimumHeight;
            }
            const magnitude = Math.min(minimumHeight, -11500);
            const vectorToMinimumPoint = Cartesian3_default.multiplyByScalar(
              surfaceNormal,
              Math.abs(magnitude) + 1,
              scratchPosition14
            );
            Cartesian3_default.subtract(
              data.positionOnEllipsoidSurface,
              vectorToMinimumPoint,
              scratchRay.origin
            );
          }
        } else {
          Cartographic_default.clone(data.positionCartographic, scratchCartographic18);
          scratchCartographic18.height = -11500;
          projection.project(scratchCartographic18, scratchPosition14);
          Cartesian3_default.fromElements(
            scratchPosition14.z,
            scratchPosition14.x,
            scratchPosition14.y,
            scratchPosition14
          );
          Cartesian3_default.clone(scratchPosition14, scratchRay.origin);
          Cartesian3_default.clone(Cartesian3_default.UNIT_X, scratchRay.direction);
        }
        const position = tile.data.pick(
          scratchRay,
          mode2,
          projection,
          false,
          scratchPosition14
        );
        if (defined_default(position)) {
          if (defined_default(data.callback)) {
            data.callback(position);
          }
          data.level = tile.level;
        }
      }
      if (getTimestamp_default() >= endTime) {
        timeSliceMax = true;
        break;
      }
    }
    if (timeSliceMax) {
      primitive._lastTileIndex = i2;
      break;
    } else {
      primitive._lastTileIndex = 0;
      tilesToUpdateHeights.shift();
    }
  }
  for (i2 = 0; i2 < tryNextFrame.length; i2++) {
    tilesToUpdateHeights.push(tryNextFrame[i2]);
  }
}
function createRenderCommandsForSelectedTiles(primitive, frameState) {
  const tileProvider = primitive._tileProvider;
  const tilesToRender = primitive._tilesToRender;
  for (let i2 = 0, len = tilesToRender.length; i2 < len; ++i2) {
    const tile = tilesToRender[i2];
    tileProvider.showTileThisFrame(tile, frameState);
  }
}
var QuadtreePrimitive_default = QuadtreePrimitive;

// node_modules/cesium/Source/Scene/Globe.js
function Globe(ellipsoid) {
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  const terrainProvider = new EllipsoidTerrainProvider_default({
    ellipsoid
  });
  const imageryLayerCollection = new ImageryLayerCollection_default();
  this._ellipsoid = ellipsoid;
  this._imageryLayerCollection = imageryLayerCollection;
  this._surfaceShaderSet = new GlobeSurfaceShaderSet_default();
  this._material = void 0;
  this._surface = new QuadtreePrimitive_default({
    tileProvider: new GlobeSurfaceTileProvider_default({
      terrainProvider,
      imageryLayers: imageryLayerCollection,
      surfaceShaderSet: this._surfaceShaderSet
    })
  });
  this._terrainProvider = terrainProvider;
  this._terrainProviderChanged = new Event_default();
  this._undergroundColor = Color_default.clone(Color_default.BLACK);
  this._undergroundColorAlphaByDistance = new NearFarScalar_default(
    ellipsoid.maximumRadius / 1e3,
    0,
    ellipsoid.maximumRadius / 5,
    1
  );
  this._translucency = new GlobeTranslucency_default();
  makeShadersDirty(this);
  this.show = true;
  this._oceanNormalMapResourceDirty = true;
  this._oceanNormalMapResource = new Resource_default({
    url: buildModuleUrl_default("Assets/Textures/waterNormalsSmall.jpg")
  });
  this.maximumScreenSpaceError = 2;
  this.tileCacheSize = 100;
  this.loadingDescendantLimit = 20;
  this.preloadAncestors = true;
  this.preloadSiblings = false;
  this.fillHighlightColor = void 0;
  this.enableLighting = false;
  this.lambertDiffuseMultiplier = 0.9;
  this.dynamicAtmosphereLighting = true;
  this.dynamicAtmosphereLightingFromSun = false;
  this.showGroundAtmosphere = true;
  this.atmosphereLightIntensity = 10;
  this.atmosphereRayleighCoefficient = new Cartesian3_default(55e-7, 13e-6, 284e-7);
  this.atmosphereMieCoefficient = new Cartesian3_default(21e-6, 21e-6, 21e-6);
  this.atmosphereRayleighScaleHeight = 1e4;
  this.atmosphereMieScaleHeight = 3200;
  this.atmosphereMieAnisotropy = 0.9;
  this.lightingFadeOutDistance = 1e7;
  this.lightingFadeInDistance = 2e7;
  this.nightFadeOutDistance = 1e7;
  this.nightFadeInDistance = 5e7;
  this.showWaterEffect = true;
  this.depthTestAgainstTerrain = false;
  this.shadows = ShadowMode_default.RECEIVE_ONLY;
  this.atmosphereHueShift = 0;
  this.atmosphereSaturationShift = 0;
  this.atmosphereBrightnessShift = 0;
  this.terrainExaggeration = 1;
  this.terrainExaggerationRelativeHeight = 0;
  this.showSkirts = true;
  this.backFaceCulling = true;
  this._oceanNormalMap = void 0;
  this._zoomedOutOceanSpecularIntensity = void 0;
}
Object.defineProperties(Globe.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  },
  imageryLayers: {
    get: function() {
      return this._imageryLayerCollection;
    }
  },
  imageryLayersUpdatedEvent: {
    get: function() {
      return this._surface.tileProvider.imageryLayersUpdatedEvent;
    }
  },
  tilesLoaded: {
    get: function() {
      if (!defined_default(this._surface)) {
        return true;
      }
      return this._surface.tileProvider.ready && this._surface._tileLoadQueueHigh.length === 0 && this._surface._tileLoadQueueMedium.length === 0 && this._surface._tileLoadQueueLow.length === 0;
    }
  },
  baseColor: {
    get: function() {
      return this._surface.tileProvider.baseColor;
    },
    set: function(value) {
      this._surface.tileProvider.baseColor = value;
    }
  },
  clippingPlanes: {
    get: function() {
      return this._surface.tileProvider.clippingPlanes;
    },
    set: function(value) {
      this._surface.tileProvider.clippingPlanes = value;
    }
  },
  cartographicLimitRectangle: {
    get: function() {
      return this._surface.tileProvider.cartographicLimitRectangle;
    },
    set: function(value) {
      if (!defined_default(value)) {
        value = Rectangle_default.clone(Rectangle_default.MAX_VALUE);
      }
      this._surface.tileProvider.cartographicLimitRectangle = value;
    }
  },
  oceanNormalMapUrl: {
    get: function() {
      return this._oceanNormalMapResource.url;
    },
    set: function(value) {
      this._oceanNormalMapResource.url = value;
      this._oceanNormalMapResourceDirty = true;
    }
  },
  terrainProvider: {
    get: function() {
      return this._terrainProvider;
    },
    set: function(value) {
      if (value !== this._terrainProvider) {
        this._terrainProvider = value;
        this._terrainProviderChanged.raiseEvent(value);
        if (defined_default(this._material)) {
          makeShadersDirty(this);
        }
      }
    }
  },
  terrainProviderChanged: {
    get: function() {
      return this._terrainProviderChanged;
    }
  },
  tileLoadProgressEvent: {
    get: function() {
      return this._surface.tileLoadProgressEvent;
    }
  },
  material: {
    get: function() {
      return this._material;
    },
    set: function(material) {
      if (this._material !== material) {
        this._material = material;
        makeShadersDirty(this);
      }
    }
  },
  undergroundColor: {
    get: function() {
      return this._undergroundColor;
    },
    set: function(value) {
      this._undergroundColor = Color_default.clone(value, this._undergroundColor);
    }
  },
  undergroundColorAlphaByDistance: {
    get: function() {
      return this._undergroundColorAlphaByDistance;
    },
    set: function(value) {
      if (defined_default(value) && value.far < value.near) {
        throw new DeveloperError_default(
          "far distance must be greater than near distance."
        );
      }
      this._undergroundColorAlphaByDistance = NearFarScalar_default.clone(
        value,
        this._undergroundColorAlphaByDistance
      );
    }
  },
  translucency: {
    get: function() {
      return this._translucency;
    }
  }
});
function makeShadersDirty(globe) {
  const defines = [];
  const requireNormals = defined_default(globe._material) && (globe._material.shaderSource.match(/slope/) || globe._material.shaderSource.match("normalEC"));
  const fragmentSources = [AtmosphereCommon_default, GroundAtmosphere_default];
  if (defined_default(globe._material) && (!requireNormals || globe._terrainProvider.requestVertexNormals)) {
    fragmentSources.push(globe._material.shaderSource);
    defines.push("APPLY_MATERIAL");
    globe._surface._tileProvider.materialUniformMap = globe._material._uniforms;
  } else {
    globe._surface._tileProvider.materialUniformMap = void 0;
  }
  fragmentSources.push(GlobeFS_default);
  globe._surfaceShaderSet.baseVertexShaderSource = new ShaderSource_default({
    sources: [AtmosphereCommon_default, GroundAtmosphere_default, GlobeVS_default],
    defines
  });
  globe._surfaceShaderSet.baseFragmentShaderSource = new ShaderSource_default({
    sources: fragmentSources,
    defines
  });
  globe._surfaceShaderSet.material = globe._material;
}
function createComparePickTileFunction(rayOrigin) {
  return function(a4, b) {
    const aDist = BoundingSphere_default.distanceSquaredTo(
      a4.pickBoundingSphere,
      rayOrigin
    );
    const bDist = BoundingSphere_default.distanceSquaredTo(
      b.pickBoundingSphere,
      rayOrigin
    );
    return aDist - bDist;
  };
}
var scratchArray3 = [];
var scratchSphereIntersectionResult = {
  start: 0,
  stop: 0
};
Globe.prototype.pickWorldCoordinates = function(ray, scene, cullBackFaces, result) {
  if (!defined_default(ray)) {
    throw new DeveloperError_default("ray is required");
  }
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required");
  }
  cullBackFaces = defaultValue_default(cullBackFaces, true);
  const mode2 = scene.mode;
  const projection = scene.mapProjection;
  const sphereIntersections = scratchArray3;
  sphereIntersections.length = 0;
  const tilesToRender = this._surface._tilesToRender;
  let length3 = tilesToRender.length;
  let tile;
  let i2;
  for (i2 = 0; i2 < length3; ++i2) {
    tile = tilesToRender[i2];
    const surfaceTile = tile.data;
    if (!defined_default(surfaceTile)) {
      continue;
    }
    let boundingVolume = surfaceTile.pickBoundingSphere;
    if (mode2 !== SceneMode_default.SCENE3D) {
      surfaceTile.pickBoundingSphere = boundingVolume = BoundingSphere_default.fromRectangleWithHeights2D(
        tile.rectangle,
        projection,
        surfaceTile.tileBoundingRegion.minimumHeight,
        surfaceTile.tileBoundingRegion.maximumHeight,
        boundingVolume
      );
      Cartesian3_default.fromElements(
        boundingVolume.center.z,
        boundingVolume.center.x,
        boundingVolume.center.y,
        boundingVolume.center
      );
    } else if (defined_default(surfaceTile.renderedMesh)) {
      BoundingSphere_default.clone(
        surfaceTile.tileBoundingRegion.boundingSphere,
        boundingVolume
      );
    } else {
      continue;
    }
    const boundingSphereIntersection = IntersectionTests_default.raySphere(
      ray,
      boundingVolume,
      scratchSphereIntersectionResult
    );
    if (defined_default(boundingSphereIntersection)) {
      sphereIntersections.push(surfaceTile);
    }
  }
  sphereIntersections.sort(createComparePickTileFunction(ray.origin));
  let intersection;
  length3 = sphereIntersections.length;
  for (i2 = 0; i2 < length3; ++i2) {
    intersection = sphereIntersections[i2].pick(
      ray,
      scene.mode,
      scene.mapProjection,
      cullBackFaces,
      result
    );
    if (defined_default(intersection)) {
      break;
    }
  }
  return intersection;
};
var cartoScratch3 = new Cartographic_default();
Globe.prototype.pick = function(ray, scene, result) {
  result = this.pickWorldCoordinates(ray, scene, true, result);
  if (defined_default(result) && scene.mode !== SceneMode_default.SCENE3D) {
    result = Cartesian3_default.fromElements(result.y, result.z, result.x, result);
    const carto = scene.mapProjection.unproject(result, cartoScratch3);
    result = scene.globe.ellipsoid.cartographicToCartesian(carto, result);
  }
  return result;
};
var scratchGetHeightCartesian = new Cartesian3_default();
var scratchGetHeightIntersection = new Cartesian3_default();
var scratchGetHeightCartographic = new Cartographic_default();
var scratchGetHeightRay = new Ray_default();
function tileIfContainsCartographic(tile, cartographic2) {
  return defined_default(tile) && Rectangle_default.contains(tile.rectangle, cartographic2) ? tile : void 0;
}
Globe.prototype.getHeight = function(cartographic2) {
  if (!defined_default(cartographic2)) {
    throw new DeveloperError_default("cartographic is required");
  }
  const levelZeroTiles = this._surface._levelZeroTiles;
  if (!defined_default(levelZeroTiles)) {
    return;
  }
  let tile;
  let i2;
  const length3 = levelZeroTiles.length;
  for (i2 = 0; i2 < length3; ++i2) {
    tile = levelZeroTiles[i2];
    if (Rectangle_default.contains(tile.rectangle, cartographic2)) {
      break;
    }
  }
  if (i2 >= length3) {
    return void 0;
  }
  let tileWithMesh = tile;
  while (defined_default(tile)) {
    tile = tileIfContainsCartographic(tile._southwestChild, cartographic2) || tileIfContainsCartographic(tile._southeastChild, cartographic2) || tileIfContainsCartographic(tile._northwestChild, cartographic2) || tile._northeastChild;
    if (defined_default(tile) && defined_default(tile.data) && defined_default(tile.data.renderedMesh)) {
      tileWithMesh = tile;
    }
  }
  tile = tileWithMesh;
  if (!defined_default(tile) || !defined_default(tile.data) || !defined_default(tile.data.renderedMesh)) {
    return void 0;
  }
  const projection = this._surface._tileProvider.tilingScheme.projection;
  const ellipsoid = this._surface._tileProvider.tilingScheme.ellipsoid;
  const cartesian11 = Cartesian3_default.fromRadians(
    cartographic2.longitude,
    cartographic2.latitude,
    0,
    ellipsoid,
    scratchGetHeightCartesian
  );
  const ray = scratchGetHeightRay;
  const surfaceNormal = ellipsoid.geodeticSurfaceNormal(
    cartesian11,
    ray.direction
  );
  const rayOrigin = ellipsoid.getSurfaceNormalIntersectionWithZAxis(
    cartesian11,
    11500,
    ray.origin
  );
  if (!defined_default(rayOrigin)) {
    let minimumHeight;
    if (defined_default(tile.data.tileBoundingRegion)) {
      minimumHeight = tile.data.tileBoundingRegion.minimumHeight;
    }
    const magnitude = Math.min(defaultValue_default(minimumHeight, 0), -11500);
    const vectorToMinimumPoint = Cartesian3_default.multiplyByScalar(
      surfaceNormal,
      Math.abs(magnitude) + 1,
      scratchGetHeightIntersection
    );
    Cartesian3_default.subtract(cartesian11, vectorToMinimumPoint, ray.origin);
  }
  const intersection = tile.data.pick(
    ray,
    void 0,
    projection,
    false,
    scratchGetHeightIntersection
  );
  if (!defined_default(intersection)) {
    return void 0;
  }
  return ellipsoid.cartesianToCartographic(
    intersection,
    scratchGetHeightCartographic
  ).height;
};
Globe.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  if (frameState.passes.render) {
    this._surface.update(frameState);
  }
};
Globe.prototype.beginFrame = function(frameState) {
  const surface = this._surface;
  const tileProvider = surface.tileProvider;
  const terrainProvider = this.terrainProvider;
  const hasWaterMask = this.showWaterEffect && terrainProvider.ready && terrainProvider.hasWaterMask;
  if (hasWaterMask && this._oceanNormalMapResourceDirty) {
    this._oceanNormalMapResourceDirty = false;
    const oceanNormalMapResource = this._oceanNormalMapResource;
    const oceanNormalMapUrl = oceanNormalMapResource.url;
    if (defined_default(oceanNormalMapUrl)) {
      const that = this;
      oceanNormalMapResource.fetchImage().then(function(image) {
        if (oceanNormalMapUrl !== that._oceanNormalMapResource.url) {
          return;
        }
        that._oceanNormalMap = that._oceanNormalMap && that._oceanNormalMap.destroy();
        that._oceanNormalMap = new Texture_default({
          context: frameState.context,
          source: image
        });
      });
    } else {
      this._oceanNormalMap = this._oceanNormalMap && this._oceanNormalMap.destroy();
    }
  }
  const pass = frameState.passes;
  const mode2 = frameState.mode;
  if (pass.render) {
    if (this.showGroundAtmosphere) {
      this._zoomedOutOceanSpecularIntensity = 0.4;
    } else {
      this._zoomedOutOceanSpecularIntensity = 0.5;
    }
    surface.maximumScreenSpaceError = this.maximumScreenSpaceError;
    surface.tileCacheSize = this.tileCacheSize;
    surface.loadingDescendantLimit = this.loadingDescendantLimit;
    surface.preloadAncestors = this.preloadAncestors;
    surface.preloadSiblings = this.preloadSiblings;
    tileProvider.terrainProvider = this.terrainProvider;
    tileProvider.lightingFadeOutDistance = this.lightingFadeOutDistance;
    tileProvider.lightingFadeInDistance = this.lightingFadeInDistance;
    tileProvider.nightFadeOutDistance = this.nightFadeOutDistance;
    tileProvider.nightFadeInDistance = this.nightFadeInDistance;
    tileProvider.zoomedOutOceanSpecularIntensity = mode2 === SceneMode_default.SCENE3D ? this._zoomedOutOceanSpecularIntensity : 0;
    tileProvider.hasWaterMask = hasWaterMask;
    tileProvider.oceanNormalMap = this._oceanNormalMap;
    tileProvider.enableLighting = this.enableLighting;
    tileProvider.dynamicAtmosphereLighting = this.dynamicAtmosphereLighting;
    tileProvider.dynamicAtmosphereLightingFromSun = this.dynamicAtmosphereLightingFromSun;
    tileProvider.showGroundAtmosphere = this.showGroundAtmosphere;
    tileProvider.atmosphereLightIntensity = this.atmosphereLightIntensity;
    tileProvider.atmosphereRayleighCoefficient = this.atmosphereRayleighCoefficient;
    tileProvider.atmosphereMieCoefficient = this.atmosphereMieCoefficient;
    tileProvider.atmosphereRayleighScaleHeight = this.atmosphereRayleighScaleHeight;
    tileProvider.atmosphereMieScaleHeight = this.atmosphereMieScaleHeight;
    tileProvider.atmosphereMieAnisotropy = this.atmosphereMieAnisotropy;
    tileProvider.shadows = this.shadows;
    tileProvider.hueShift = this.atmosphereHueShift;
    tileProvider.saturationShift = this.atmosphereSaturationShift;
    tileProvider.brightnessShift = this.atmosphereBrightnessShift;
    tileProvider.fillHighlightColor = this.fillHighlightColor;
    tileProvider.showSkirts = this.showSkirts;
    tileProvider.backFaceCulling = this.backFaceCulling;
    tileProvider.undergroundColor = this._undergroundColor;
    tileProvider.undergroundColorAlphaByDistance = this._undergroundColorAlphaByDistance;
    tileProvider.lambertDiffuseMultiplier = this.lambertDiffuseMultiplier;
    surface.beginFrame(frameState);
  }
};
Globe.prototype.render = function(frameState) {
  if (!this.show) {
    return;
  }
  if (defined_default(this._material)) {
    this._material.update(frameState.context);
  }
  this._surface.render(frameState);
};
Globe.prototype.endFrame = function(frameState) {
  if (!this.show) {
    return;
  }
  if (frameState.passes.render) {
    this._surface.endFrame(frameState);
  }
};
Globe.prototype.isDestroyed = function() {
  return false;
};
Globe.prototype.destroy = function() {
  this._surfaceShaderSet = this._surfaceShaderSet && this._surfaceShaderSet.destroy();
  this._surface = this._surface && this._surface.destroy();
  this._oceanNormalMap = this._oceanNormalMap && this._oceanNormalMap.destroy();
  return destroyObject_default(this);
};
var Globe_default = Globe;

// node_modules/cesium/Source/Shaders/PostProcessStages/PassThrough.js
var PassThrough_default = "uniform sampler2D colorTexture;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    gl_FragColor = texture2D(colorTexture, v_textureCoordinates);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/PassThroughDepth.js
var PassThroughDepth_default = "uniform highp sampler2D u_depthTexture;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    gl_FragColor = czm_packDepth(texture2D(u_depthTexture, v_textureCoordinates).r);\n}\n";

// node_modules/cesium/Source/Scene/GlobeDepth.js
function GlobeDepth() {
  this._picking = false;
  this._numSamples = 1;
  this._tempCopyDepthTexture = void 0;
  this._pickColorFramebuffer = new FramebufferManager_default({
    depthStencil: true,
    supportsDepthTexture: true
  });
  this._outputFramebuffer = new FramebufferManager_default({
    depthStencil: true,
    supportsDepthTexture: true
  });
  this._copyDepthFramebuffer = new FramebufferManager_default();
  this._tempCopyDepthFramebuffer = new FramebufferManager_default();
  this._updateDepthFramebuffer = new FramebufferManager_default({
    createColorAttachments: false,
    createDepthAttachments: false,
    depthStencil: true
  });
  this._clearGlobeColorCommand = void 0;
  this._copyColorCommand = void 0;
  this._copyDepthCommand = void 0;
  this._tempCopyDepthCommand = void 0;
  this._updateDepthCommand = void 0;
  this._viewport = new BoundingRectangle_default();
  this._rs = void 0;
  this._rsBlend = void 0;
  this._rsUpdate = void 0;
  this._useScissorTest = false;
  this._scissorRectangle = void 0;
  this._useHdr = void 0;
  this._clearGlobeDepth = void 0;
}
Object.defineProperties(GlobeDepth.prototype, {
  colorFramebufferManager: {
    get: function() {
      return this._picking ? this._pickColorFramebuffer : this._outputFramebuffer;
    }
  },
  framebuffer: {
    get: function() {
      return this.colorFramebufferManager.framebuffer;
    }
  },
  depthStencilTexture: {
    get: function() {
      return this.colorFramebufferManager.getDepthStencilTexture();
    }
  },
  picking: {
    get: function() {
      return this._picking;
    },
    set: function(value) {
      this._picking = value;
    }
  }
});
function destroyFramebuffers2(globeDepth) {
  globeDepth._pickColorFramebuffer.destroy();
  globeDepth._outputFramebuffer.destroy();
  globeDepth._copyDepthFramebuffer.destroy();
  globeDepth._tempCopyDepthFramebuffer.destroy();
  globeDepth._updateDepthFramebuffer.destroy();
}
function updateCopyCommands(globeDepth, context, width, height, passState) {
  globeDepth._viewport.width = width;
  globeDepth._viewport.height = height;
  const useScissorTest = !BoundingRectangle_default.equals(
    globeDepth._viewport,
    passState.viewport
  );
  let updateScissor = useScissorTest !== globeDepth._useScissorTest;
  globeDepth._useScissorTest = useScissorTest;
  if (!BoundingRectangle_default.equals(globeDepth._scissorRectangle, passState.viewport)) {
    globeDepth._scissorRectangle = BoundingRectangle_default.clone(
      passState.viewport,
      globeDepth._scissorRectangle
    );
    updateScissor = true;
  }
  if (!defined_default(globeDepth._rs) || !BoundingRectangle_default.equals(globeDepth._viewport, globeDepth._rs.viewport) || updateScissor) {
    globeDepth._rs = RenderState_default.fromCache({
      viewport: globeDepth._viewport,
      scissorTest: {
        enabled: globeDepth._useScissorTest,
        rectangle: globeDepth._scissorRectangle
      }
    });
    globeDepth._rsBlend = RenderState_default.fromCache({
      viewport: globeDepth._viewport,
      scissorTest: {
        enabled: globeDepth._useScissorTest,
        rectangle: globeDepth._scissorRectangle
      },
      blending: BlendingState_default.ALPHA_BLEND
    });
    globeDepth._rsUpdate = RenderState_default.fromCache({
      viewport: globeDepth._viewport,
      scissorTest: {
        enabled: globeDepth._useScissorTest,
        rectangle: globeDepth._scissorRectangle
      },
      stencilTest: {
        enabled: true,
        frontFunction: StencilFunction_default.EQUAL,
        frontOperation: {
          fail: StencilOperation_default.KEEP,
          zFail: StencilOperation_default.KEEP,
          zPass: StencilOperation_default.KEEP
        },
        backFunction: StencilFunction_default.NEVER,
        reference: StencilConstants_default.CESIUM_3D_TILE_MASK,
        mask: StencilConstants_default.CESIUM_3D_TILE_MASK
      }
    });
  }
  if (!defined_default(globeDepth._copyDepthCommand)) {
    globeDepth._copyDepthCommand = context.createViewportQuadCommand(
      PassThroughDepth_default,
      {
        uniformMap: {
          u_depthTexture: function() {
            return globeDepth.colorFramebufferManager.getDepthStencilTexture();
          }
        },
        owner: globeDepth
      }
    );
  }
  globeDepth._copyDepthCommand.framebuffer = globeDepth._copyDepthFramebuffer.framebuffer;
  globeDepth._copyDepthCommand.renderState = globeDepth._rs;
  if (!defined_default(globeDepth._copyColorCommand)) {
    globeDepth._copyColorCommand = context.createViewportQuadCommand(
      PassThrough_default,
      {
        uniformMap: {
          colorTexture: function() {
            return globeDepth.colorFramebufferManager.getColorTexture();
          }
        },
        owner: globeDepth
      }
    );
  }
  globeDepth._copyColorCommand.renderState = globeDepth._rs;
  if (!defined_default(globeDepth._tempCopyDepthCommand)) {
    globeDepth._tempCopyDepthCommand = context.createViewportQuadCommand(
      PassThroughDepth_default,
      {
        uniformMap: {
          u_depthTexture: function() {
            return globeDepth._tempCopyDepthTexture;
          }
        },
        owner: globeDepth
      }
    );
  }
  globeDepth._tempCopyDepthCommand.framebuffer = globeDepth._tempCopyDepthFramebuffer.framebuffer;
  globeDepth._tempCopyDepthCommand.renderState = globeDepth._rs;
  if (!defined_default(globeDepth._updateDepthCommand)) {
    globeDepth._updateDepthCommand = context.createViewportQuadCommand(
      PassThrough_default,
      {
        uniformMap: {
          colorTexture: function() {
            return globeDepth._tempCopyDepthFramebuffer.getColorTexture();
          }
        },
        owner: globeDepth
      }
    );
  }
  globeDepth._updateDepthCommand.framebuffer = globeDepth._updateDepthFramebuffer.framebuffer;
  globeDepth._updateDepthCommand.renderState = globeDepth._rsUpdate;
  if (!defined_default(globeDepth._clearGlobeColorCommand)) {
    globeDepth._clearGlobeColorCommand = new ClearCommand_default({
      color: new Color_default(0, 0, 0, 0),
      stencil: 0,
      owner: globeDepth
    });
  }
  globeDepth._clearGlobeColorCommand.framebuffer = globeDepth.framebuffer;
}
GlobeDepth.prototype.update = function(context, passState, viewport, numSamples, hdr, clearGlobeDepth) {
  const width = viewport.width;
  const height = viewport.height;
  const pixelDatatype = hdr ? context.halfFloatingPointTexture ? PixelDatatype_default.HALF_FLOAT : PixelDatatype_default.FLOAT : PixelDatatype_default.UNSIGNED_BYTE;
  this._numSamples = numSamples;
  if (this.picking) {
    this._pickColorFramebuffer.update(context, width, height);
  } else {
    this._outputFramebuffer.update(
      context,
      width,
      height,
      numSamples,
      pixelDatatype
    );
  }
  this._copyDepthFramebuffer.update(context, width, height);
  updateCopyCommands(this, context, width, height, passState);
  context.uniformState.globeDepthTexture = void 0;
  this._useHdr = hdr;
  this._clearGlobeDepth = clearGlobeDepth;
};
GlobeDepth.prototype.prepareColorTextures = function(context, blitStencil) {
  if (!this.picking && this._numSamples > 1) {
    this._outputFramebuffer.prepareTextures(context, blitStencil);
  }
};
GlobeDepth.prototype.executeCopyDepth = function(context, passState) {
  if (defined_default(this._copyDepthCommand)) {
    this.prepareColorTextures(context);
    this._copyDepthCommand.execute(context, passState);
    context.uniformState.globeDepthTexture = this._copyDepthFramebuffer.getColorTexture();
  }
};
GlobeDepth.prototype.executeUpdateDepth = function(context, passState, clearGlobeDepth, depthTexture) {
  const depthTextureToCopy = defined_default(depthTexture) ? depthTexture : passState.framebuffer.depthStencilTexture;
  if (clearGlobeDepth || depthTextureToCopy !== this.colorFramebufferManager.getDepthStencilTexture()) {
    if (defined_default(this._updateDepthCommand)) {
      if (!defined_default(this._updateDepthFramebuffer.framebuffer) || this._updateDepthFramebuffer.getDepthStencilTexture() !== depthTextureToCopy || this._updateDepthFramebuffer.getColorTexture() !== this._copyDepthFramebuffer.getColorTexture()) {
        const width = this._copyDepthFramebuffer.getColorTexture().width;
        const height = this._copyDepthFramebuffer.getColorTexture().height;
        this._tempCopyDepthFramebuffer.destroy();
        this._tempCopyDepthFramebuffer.update(context, width, height);
        const colorTexture = this._copyDepthFramebuffer.getColorTexture();
        this._updateDepthFramebuffer.setColorTexture(colorTexture, 0);
        this._updateDepthFramebuffer.setDepthStencilTexture(depthTextureToCopy);
        this._updateDepthFramebuffer.update(context, width, height);
        updateCopyCommands(this, context, width, height, passState);
      }
      this._tempCopyDepthTexture = depthTextureToCopy;
      this._tempCopyDepthCommand.execute(context, passState);
      this._updateDepthCommand.execute(context, passState);
    }
    return;
  }
  if (defined_default(this._copyDepthCommand)) {
    this._copyDepthCommand.execute(context, passState);
  }
};
GlobeDepth.prototype.executeCopyColor = function(context, passState) {
  if (defined_default(this._copyColorCommand)) {
    this._copyColorCommand.execute(context, passState);
  }
};
GlobeDepth.prototype.clear = function(context, passState, clearColor) {
  const clear2 = this._clearGlobeColorCommand;
  if (defined_default(clear2)) {
    Color_default.clone(clearColor, clear2.color);
    this.colorFramebufferManager.clear(context, clear2, passState);
  }
};
GlobeDepth.prototype.isDestroyed = function() {
  return false;
};
GlobeDepth.prototype.destroy = function() {
  destroyFramebuffers2(this);
  if (defined_default(this._copyColorCommand)) {
    this._copyColorCommand.shaderProgram = this._copyColorCommand.shaderProgram.destroy();
  }
  if (defined_default(this._copyDepthCommand)) {
    this._copyDepthCommand.shaderProgram = this._copyDepthCommand.shaderProgram.destroy();
  }
  if (defined_default(this._tempCopyDepthCommand)) {
    this._tempCopyDepthCommand.shaderProgram = this._tempCopyDepthCommand.shaderProgram.destroy();
  }
  if (defined_default(this._updateDepthCommand)) {
    this._updateDepthCommand.shaderProgram = this._updateDepthCommand.shaderProgram.destroy();
  }
  return destroyObject_default(this);
};
var GlobeDepth_default = GlobeDepth;

// node_modules/cesium/Source/Scene/GlobeTranslucencyFramebuffer.js
function GlobeTranslucencyFramebuffer() {
  this._framebuffer = new FramebufferManager_default({
    depthStencil: true,
    supportsDepthTexture: true
  });
  this._packedDepthFramebuffer = new FramebufferManager_default();
  this._renderState = void 0;
  this._packedDepthCommand = void 0;
  this._clearCommand = void 0;
  this._viewport = new BoundingRectangle_default();
  this._useScissorTest = false;
  this._scissorRectangle = void 0;
  this._useHdr = void 0;
}
Object.defineProperties(GlobeTranslucencyFramebuffer.prototype, {
  classificationTexture: {
    get: function() {
      return this._framebuffer.getColorTexture();
    }
  },
  classificationFramebuffer: {
    get: function() {
      return this._framebuffer.framebuffer;
    }
  },
  packedDepthFramebuffer: {
    get: function() {
      return this._packedDepthFramebuffer.framebuffer;
    }
  },
  depthStencilTexture: {
    get: function() {
      return this._framebuffer.getDepthStencilTexture();
    }
  },
  depthStencilRenderbuffer: {
    get: function() {
      return this._framebuffer.getDepthStencilRenderbuffer();
    }
  },
  packedDepthTexture: {
    get: function() {
      return this._packedDepthFramebuffer.getColorTexture();
    }
  }
});
function destroyResources(globeTranslucency) {
  globeTranslucency._framebuffer.destroy();
  globeTranslucency._packedDepthFramebuffer.destroy();
}
function updateResources(globeTranslucency, context, width, height, hdr) {
  const pixelDatatype = hdr ? context.halfFloatingPointTexture ? PixelDatatype_default.HALF_FLOAT : PixelDatatype_default.FLOAT : PixelDatatype_default.UNSIGNED_BYTE;
  globeTranslucency._framebuffer.update(
    context,
    width,
    height,
    1,
    pixelDatatype
  );
  globeTranslucency._packedDepthFramebuffer.update(context, width, height);
}
function updateCommands(globeTranslucency, context, width, height, passState) {
  globeTranslucency._viewport.width = width;
  globeTranslucency._viewport.height = height;
  const useScissorTest = !BoundingRectangle_default.equals(
    globeTranslucency._viewport,
    passState.viewport
  );
  let updateScissor = useScissorTest !== globeTranslucency._useScissorTest;
  globeTranslucency._useScissorTest = useScissorTest;
  if (!BoundingRectangle_default.equals(
    globeTranslucency._scissorRectangle,
    passState.viewport
  )) {
    globeTranslucency._scissorRectangle = BoundingRectangle_default.clone(
      passState.viewport,
      globeTranslucency._scissorRectangle
    );
    updateScissor = true;
  }
  if (!defined_default(globeTranslucency._renderState) || !BoundingRectangle_default.equals(
    globeTranslucency._viewport,
    globeTranslucency._renderState.viewport
  ) || updateScissor) {
    globeTranslucency._renderState = RenderState_default.fromCache({
      viewport: globeTranslucency._viewport,
      scissorTest: {
        enabled: globeTranslucency._useScissorTest,
        rectangle: globeTranslucency._scissorRectangle
      }
    });
  }
  if (!defined_default(globeTranslucency._packedDepthCommand)) {
    globeTranslucency._packedDepthCommand = context.createViewportQuadCommand(
      PassThroughDepth_default,
      {
        uniformMap: {
          u_depthTexture: function() {
            return globeTranslucency.depthStencilTexture;
          }
        },
        owner: globeTranslucency
      }
    );
  }
  if (!defined_default(globeTranslucency._clearCommand)) {
    globeTranslucency._clearCommand = new ClearCommand_default({
      color: new Color_default(0, 0, 0, 0),
      depth: 1,
      stencil: 0,
      owner: globeTranslucency
    });
  }
  globeTranslucency._packedDepthCommand.framebuffer = globeTranslucency._packedDepthFramebuffer.framebuffer;
  globeTranslucency._packedDepthCommand.renderState = globeTranslucency._renderState;
  globeTranslucency._clearCommand.framebuffer = globeTranslucency.classificationFramebuffer;
  globeTranslucency._clearCommand.renderState = globeTranslucency._renderState;
}
GlobeTranslucencyFramebuffer.prototype.updateAndClear = function(hdr, viewport, context, passState) {
  const width = viewport.width;
  const height = viewport.height;
  updateResources(this, context, width, height, hdr);
  updateCommands(this, context, width, height, passState);
  this._useHdr = hdr;
};
GlobeTranslucencyFramebuffer.prototype.clearClassification = function(context, passState) {
  this._clearCommand.execute(context, passState);
};
GlobeTranslucencyFramebuffer.prototype.packDepth = function(context, passState) {
  this._packedDepthCommand.execute(context, passState);
  return this.packedDepthTexture;
};
GlobeTranslucencyFramebuffer.prototype.isDestroyed = function() {
  return false;
};
GlobeTranslucencyFramebuffer.prototype.destroy = function() {
  destroyResources(this);
  return destroyObject_default(this);
};
var GlobeTranslucencyFramebuffer_default = GlobeTranslucencyFramebuffer;

// node_modules/cesium/Source/Scene/GlobeTranslucencyState.js
var DerivedCommandType = {
  OPAQUE_FRONT_FACE: 0,
  OPAQUE_BACK_FACE: 1,
  DEPTH_ONLY_FRONT_FACE: 2,
  DEPTH_ONLY_BACK_FACE: 3,
  DEPTH_ONLY_FRONT_AND_BACK_FACE: 4,
  TRANSLUCENT_FRONT_FACE: 5,
  TRANSLUCENT_BACK_FACE: 6,
  TRANSLUCENT_FRONT_FACE_MANUAL_DEPTH_TEST: 7,
  TRANSLUCENT_BACK_FACE_MANUAL_DEPTH_TEST: 8,
  PICK_FRONT_FACE: 9,
  PICK_BACK_FACE: 10,
  DERIVED_COMMANDS_MAXIMUM_LENGTH: 11
};
var derivedCommandsMaximumLength = DerivedCommandType.DERIVED_COMMANDS_MAXIMUM_LENGTH;
var DerivedCommandNames = [
  "opaqueFrontFaceCommand",
  "opaqueBackFaceCommand",
  "depthOnlyFrontFaceCommand",
  "depthOnlyBackFaceCommand",
  "depthOnlyFrontAndBackFaceCommand",
  "translucentFrontFaceCommand",
  "translucentBackFaceCommand",
  "translucentFrontFaceManualDepthTestCommand",
  "translucentBackFaceManualDepthTestCommand",
  "pickFrontFaceCommand",
  "pickBackFaceCommand"
];
function GlobeTranslucencyState() {
  this._frontFaceAlphaByDistance = new NearFarScalar_default(0, 1, 0, 1);
  this._backFaceAlphaByDistance = new NearFarScalar_default(0, 1, 0, 1);
  this._frontFaceTranslucent = false;
  this._backFaceTranslucent = false;
  this._requiresManualDepthTest = false;
  this._sunVisibleThroughGlobe = false;
  this._environmentVisible = false;
  this._useDepthPlane = false;
  this._numberOfTextureUniforms = 0;
  this._globeTranslucencyFramebuffer = void 0;
  this._rectangle = Rectangle_default.clone(Rectangle_default.MAX_VALUE);
  this._derivedCommandKey = 0;
  this._derivedCommandsDirty = false;
  this._derivedCommandPacks = void 0;
  this._derivedCommandTypes = new Array(derivedCommandsMaximumLength);
  this._derivedBlendCommandTypes = new Array(derivedCommandsMaximumLength);
  this._derivedPickCommandTypes = new Array(derivedCommandsMaximumLength);
  this._derivedCommandTypesToUpdate = new Array(derivedCommandsMaximumLength);
  this._derivedCommandsLength = 0;
  this._derivedBlendCommandsLength = 0;
  this._derivedPickCommandsLength = 0;
  this._derivedCommandsToUpdateLength = 0;
}
Object.defineProperties(GlobeTranslucencyState.prototype, {
  frontFaceAlphaByDistance: {
    get: function() {
      return this._frontFaceAlphaByDistance;
    }
  },
  backFaceAlphaByDistance: {
    get: function() {
      return this._backFaceAlphaByDistance;
    }
  },
  translucent: {
    get: function() {
      return this._frontFaceTranslucent;
    }
  },
  sunVisibleThroughGlobe: {
    get: function() {
      return this._sunVisibleThroughGlobe;
    }
  },
  environmentVisible: {
    get: function() {
      return this._environmentVisible;
    }
  },
  useDepthPlane: {
    get: function() {
      return this._useDepthPlane;
    }
  },
  numberOfTextureUniforms: {
    get: function() {
      return this._numberOfTextureUniforms;
    }
  },
  rectangle: {
    get: function() {
      return this._rectangle;
    }
  }
});
GlobeTranslucencyState.prototype.update = function(scene) {
  const globe = scene.globe;
  if (!defined_default(globe) || !globe.show) {
    this._frontFaceTranslucent = false;
    this._backFaceTranslucent = false;
    this._sunVisibleThroughGlobe = true;
    this._environmentVisible = true;
    this._useDepthPlane = false;
    return;
  }
  this._frontFaceAlphaByDistance = updateAlphaByDistance(
    globe.translucency.enabled,
    globe.translucency.frontFaceAlpha,
    globe.translucency.frontFaceAlphaByDistance,
    this._frontFaceAlphaByDistance
  );
  this._backFaceAlphaByDistance = updateAlphaByDistance(
    globe.translucency.enabled,
    globe.translucency.backFaceAlpha,
    globe.translucency.backFaceAlphaByDistance,
    this._backFaceAlphaByDistance
  );
  this._frontFaceTranslucent = isFaceTranslucent(
    globe.translucency.enabled,
    this._frontFaceAlphaByDistance,
    globe
  );
  this._backFaceTranslucent = isFaceTranslucent(
    globe.translucency.enabled,
    this._backFaceAlphaByDistance,
    globe
  );
  this._requiresManualDepthTest = requiresManualDepthTest(this, scene, globe);
  this._sunVisibleThroughGlobe = isSunVisibleThroughGlobe(this, scene);
  this._environmentVisible = isEnvironmentVisible(this, scene);
  this._useDepthPlane = useDepthPlane(this, scene);
  this._numberOfTextureUniforms = getNumberOfTextureUniforms(this);
  this._rectangle = Rectangle_default.clone(
    globe.translucency.rectangle,
    this._rectangle
  );
  gatherDerivedCommandRequirements(this, scene);
};
function updateAlphaByDistance(enabled, alpha, alphaByDistance, result) {
  if (!enabled) {
    result.nearValue = 1;
    result.farValue = 1;
    return result;
  }
  if (!defined_default(alphaByDistance)) {
    result.nearValue = alpha;
    result.farValue = alpha;
    return result;
  }
  NearFarScalar_default.clone(alphaByDistance, result);
  result.nearValue *= alpha;
  result.farValue *= alpha;
  return result;
}
function isFaceTranslucent(translucencyEnabled, alphaByDistance, globe) {
  return translucencyEnabled && (globe.baseColor.alpha < 1 || alphaByDistance.nearValue < 1 || alphaByDistance.farValue < 1);
}
function isSunVisibleThroughGlobe(state, scene) {
  const frontTranslucent = state._frontFaceTranslucent;
  const backTranslucent = state._backFaceTranslucent;
  return frontTranslucent && (scene.cameraUnderground || backTranslucent);
}
function isEnvironmentVisible(state, scene) {
  return !scene.cameraUnderground || state._frontFaceTranslucent;
}
function useDepthPlane(state, scene) {
  return !scene.cameraUnderground && !state._frontFaceTranslucent;
}
function requiresManualDepthTest(state, scene, globe) {
  return state._frontFaceTranslucent && !state._backFaceTranslucent && !globe.depthTestAgainstTerrain && scene.mode !== SceneMode_default.SCENE2D && scene.context.depthTexture;
}
function getNumberOfTextureUniforms(state) {
  let numberOfTextureUniforms = 0;
  if (state._frontFaceTranslucent) {
    ++numberOfTextureUniforms;
  }
  if (state._requiresManualDepthTest) {
    ++numberOfTextureUniforms;
  }
  return numberOfTextureUniforms;
}
function gatherDerivedCommandRequirements(state, scene) {
  state._derivedCommandsLength = getDerivedCommandTypes(
    state,
    scene,
    false,
    false,
    state._derivedCommandTypes
  );
  state._derivedBlendCommandsLength = getDerivedCommandTypes(
    state,
    scene,
    true,
    false,
    state._derivedBlendCommandTypes
  );
  state._derivedPickCommandsLength = getDerivedCommandTypes(
    state,
    scene,
    false,
    true,
    state._derivedPickCommandTypes
  );
  let i2;
  let derivedCommandKey = 0;
  for (i2 = 0; i2 < state._derivedCommandsLength; ++i2) {
    derivedCommandKey |= 1 << state._derivedCommandTypes[i2];
  }
  for (i2 = 0; i2 < state._derivedBlendCommandsLength; ++i2) {
    derivedCommandKey |= 1 << state._derivedBlendCommandTypes[i2];
  }
  for (i2 = 0; i2 < state._derivedPickCommandsLength; ++i2) {
    derivedCommandKey |= 1 << state._derivedPickCommandTypes[i2];
  }
  let derivedCommandsToUpdateLength = 0;
  for (i2 = 0; i2 < derivedCommandsMaximumLength; ++i2) {
    if ((derivedCommandKey & 1 << i2) > 0) {
      state._derivedCommandTypesToUpdate[derivedCommandsToUpdateLength++] = i2;
    }
  }
  state._derivedCommandsToUpdateLength = derivedCommandsToUpdateLength;
  const derivedCommandsDirty = derivedCommandKey !== state._derivedCommandKey;
  state._derivedCommandKey = derivedCommandKey;
  state._derivedCommandsDirty = derivedCommandsDirty;
  if (!defined_default(state._derivedCommandPacks) && state._frontFaceTranslucent) {
    state._derivedCommandPacks = createDerivedCommandPacks();
  }
}
function getDerivedCommandTypes(state, scene, isBlendCommand, isPickCommand, types) {
  let length3 = 0;
  const frontTranslucent = state._frontFaceTranslucent;
  const backTranslucent = state._backFaceTranslucent;
  if (!frontTranslucent) {
    return length3;
  }
  const cameraUnderground = scene.cameraUnderground;
  const requiresManualDepthTest2 = state._requiresManualDepthTest;
  const translucentFrontFaceCommandType = isPickCommand ? DerivedCommandType.PICK_FRONT_FACE : requiresManualDepthTest2 ? DerivedCommandType.TRANSLUCENT_FRONT_FACE_MANUAL_DEPTH_TEST : DerivedCommandType.TRANSLUCENT_FRONT_FACE;
  const translucentBackFaceCommandType = isPickCommand ? DerivedCommandType.PICK_BACK_FACE : requiresManualDepthTest2 ? DerivedCommandType.TRANSLUCENT_BACK_FACE_MANUAL_DEPTH_TEST : DerivedCommandType.TRANSLUCENT_BACK_FACE;
  if (scene.mode === SceneMode_default.SCENE2D) {
    types[length3++] = DerivedCommandType.DEPTH_ONLY_FRONT_FACE;
    types[length3++] = translucentFrontFaceCommandType;
    return length3;
  }
  if (backTranslucent) {
    if (!isBlendCommand) {
      types[length3++] = DerivedCommandType.DEPTH_ONLY_FRONT_AND_BACK_FACE;
    }
    if (cameraUnderground) {
      types[length3++] = translucentFrontFaceCommandType;
      types[length3++] = translucentBackFaceCommandType;
    } else {
      types[length3++] = translucentBackFaceCommandType;
      types[length3++] = translucentFrontFaceCommandType;
    }
  } else {
    if (cameraUnderground) {
      if (!isBlendCommand) {
        types[length3++] = DerivedCommandType.DEPTH_ONLY_BACK_FACE;
      }
      types[length3++] = DerivedCommandType.OPAQUE_FRONT_FACE;
      types[length3++] = translucentBackFaceCommandType;
    } else {
      if (!isBlendCommand) {
        types[length3++] = DerivedCommandType.DEPTH_ONLY_FRONT_FACE;
      }
      types[length3++] = DerivedCommandType.OPAQUE_BACK_FACE;
      types[length3++] = translucentFrontFaceCommandType;
    }
  }
  return length3;
}
function removeDefine(defines, defineToRemove) {
  const index2 = defines.indexOf(defineToRemove);
  if (index2 > -1) {
    defines.splice(index2, 1);
  }
}
function hasDefine(defines, define2) {
  return defines.indexOf(define2) > -1;
}
function getOpaqueFrontFaceShaderProgram(vs, fs) {
  removeDefine(vs.defines, "TRANSLUCENT");
  removeDefine(fs.defines, "TRANSLUCENT");
}
function getOpaqueBackFaceShaderProgram(vs, fs) {
  removeDefine(vs.defines, "GROUND_ATMOSPHERE");
  removeDefine(fs.defines, "GROUND_ATMOSPHERE");
  removeDefine(vs.defines, "FOG");
  removeDefine(fs.defines, "FOG");
  removeDefine(vs.defines, "TRANSLUCENT");
  removeDefine(fs.defines, "TRANSLUCENT");
}
function getDepthOnlyShaderProgram2(vs, fs) {
  if (hasDefine(fs.defines, "TILE_LIMIT_RECTANGLE") || hasDefine(fs.defines, "ENABLE_CLIPPING_PLANES")) {
    return;
  }
  const depthOnlyShader = "void main() \n{ \n    gl_FragColor = vec4(1.0); \n} \n";
  fs.sources = [depthOnlyShader];
}
function getTranslucentShaderProgram(vs, fs) {
  const sources = fs.sources;
  const length3 = sources.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    sources[i2] = ShaderSource_default.replaceMain(
      sources[i2],
      "czm_globe_translucency_main"
    );
  }
  const globeTranslucencyMain = "\n\nuniform sampler2D u_classificationTexture; \nvoid main() \n{ \n    vec2 st = gl_FragCoord.xy / czm_viewport.zw; \n#ifdef MANUAL_DEPTH_TEST \n    float logDepthOrDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, st)); \n    if (logDepthOrDepth != 0.0) \n    { \n        vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth); \n        float depthEC = eyeCoordinate.z / eyeCoordinate.w; \n        if (v_positionEC.z < depthEC) \n        { \n            discard; \n        } \n    } \n#endif \n    czm_globe_translucency_main(); \n    vec4 classificationColor = texture2D(u_classificationTexture, st); \n    if (classificationColor.a > 0.0) \n    { \n        // Reverse premultiplication process to get the correct composited result of the classification primitives \n        classificationColor.rgb /= classificationColor.a; \n    } \n    gl_FragColor = classificationColor * vec4(classificationColor.aaa, 1.0) + gl_FragColor * (1.0 - classificationColor.a); \n} \n";
  sources.push(globeTranslucencyMain);
}
function getTranslucentBackFaceShaderProgram(vs, fs) {
  getTranslucentShaderProgram(vs, fs);
  removeDefine(vs.defines, "GROUND_ATMOSPHERE");
  removeDefine(fs.defines, "GROUND_ATMOSPHERE");
  removeDefine(vs.defines, "FOG");
  removeDefine(fs.defines, "FOG");
}
function getTranslucentFrontFaceManualDepthTestShaderProgram(vs, fs) {
  getTranslucentShaderProgram(vs, fs);
  vs.defines.push("GENERATE_POSITION");
  fs.defines.push("MANUAL_DEPTH_TEST");
}
function getTranslucentBackFaceManualDepthTestShaderProgram(vs, fs) {
  getTranslucentBackFaceShaderProgram(vs, fs);
  vs.defines.push("GENERATE_POSITION");
  fs.defines.push("MANUAL_DEPTH_TEST");
}
function getPickShaderProgram2(vs, fs) {
  const pickShader = "uniform sampler2D u_classificationTexture; \nvoid main() \n{ \n    vec2 st = gl_FragCoord.xy / czm_viewport.zw; \n    vec4 pickColor = texture2D(u_classificationTexture, st); \n    if (pickColor == vec4(0.0)) \n    { \n        discard; \n    } \n    gl_FragColor = pickColor; \n} \n";
  fs.sources = [pickShader];
}
function getDerivedShaderProgram(context, shaderProgram, derivedShaderProgram, shaderProgramDirty, getShaderProgramFunction, cacheName) {
  if (!defined_default(getShaderProgramFunction)) {
    return shaderProgram;
  }
  if (!shaderProgramDirty && defined_default(derivedShaderProgram)) {
    return derivedShaderProgram;
  }
  let shader = context.shaderCache.getDerivedShaderProgram(
    shaderProgram,
    cacheName
  );
  if (!defined_default(shader)) {
    const attributeLocations8 = shaderProgram._attributeLocations;
    const vs = shaderProgram.vertexShaderSource.clone();
    const fs = shaderProgram.fragmentShaderSource.clone();
    vs.defines = defined_default(vs.defines) ? vs.defines.slice(0) : [];
    fs.defines = defined_default(fs.defines) ? fs.defines.slice(0) : [];
    getShaderProgramFunction(vs, fs);
    shader = context.shaderCache.createDerivedShaderProgram(
      shaderProgram,
      cacheName,
      {
        vertexShaderSource: vs,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations8
      }
    );
  }
  return shader;
}
function getOpaqueFrontFaceRenderState(renderState) {
  renderState.cull.face = CullFace_default.BACK;
  renderState.cull.enabled = true;
}
function getOpaqueBackFaceRenderState(renderState) {
  renderState.cull.face = CullFace_default.FRONT;
  renderState.cull.enabled = true;
}
function getDepthOnlyFrontFaceRenderState(renderState) {
  renderState.cull.face = CullFace_default.BACK;
  renderState.cull.enabled = true;
  renderState.colorMask = {
    red: false,
    green: false,
    blue: false,
    alpha: false
  };
}
function getDepthOnlyBackFaceRenderState(renderState) {
  renderState.cull.face = CullFace_default.FRONT;
  renderState.cull.enabled = true;
  renderState.colorMask = {
    red: false,
    green: false,
    blue: false,
    alpha: false
  };
}
function getDepthOnlyFrontAndBackFaceRenderState(renderState) {
  renderState.cull.enabled = false;
  renderState.colorMask = {
    red: false,
    green: false,
    blue: false,
    alpha: false
  };
}
function getTranslucentFrontFaceRenderState(renderState) {
  renderState.cull.face = CullFace_default.BACK;
  renderState.cull.enabled = true;
  renderState.depthMask = false;
  renderState.blending = BlendingState_default.ALPHA_BLEND;
}
function getTranslucentBackFaceRenderState(renderState) {
  renderState.cull.face = CullFace_default.FRONT;
  renderState.cull.enabled = true;
  renderState.depthMask = false;
  renderState.blending = BlendingState_default.ALPHA_BLEND;
}
function getPickFrontFaceRenderState(renderState) {
  renderState.cull.face = CullFace_default.BACK;
  renderState.cull.enabled = true;
  renderState.blending.enabled = false;
}
function getPickBackFaceRenderState(renderState) {
  renderState.cull.face = CullFace_default.FRONT;
  renderState.cull.enabled = true;
  renderState.blending.enabled = false;
}
function getDerivedRenderState(renderState, derivedRenderState, renderStateDirty, getRenderStateFunction, cache) {
  if (!defined_default(getRenderStateFunction)) {
    return renderState;
  }
  if (!renderStateDirty && defined_default(derivedRenderState)) {
    return derivedRenderState;
  }
  let cachedRenderState = cache[renderState.id];
  if (!defined_default(cachedRenderState)) {
    const rs = RenderState_default.getState(renderState);
    getRenderStateFunction(rs);
    cachedRenderState = RenderState_default.fromCache(rs);
    cache[renderState.id] = cachedRenderState;
  }
  return cachedRenderState;
}
function getTranslucencyUniformMap(state) {
  return {
    u_classificationTexture: function() {
      return state._globeTranslucencyFramebuffer.classificationTexture;
    }
  };
}
function getDerivedUniformMap(state, uniformMap2, derivedUniformMap, uniformMapDirty, getDerivedUniformMapFunction) {
  if (!defined_default(getDerivedUniformMapFunction)) {
    return uniformMap2;
  }
  if (!uniformMapDirty && defined_default(derivedUniformMap)) {
    return derivedUniformMap;
  }
  return combine_default(uniformMap2, getDerivedUniformMapFunction(state), false);
}
function DerivedCommandPack(options) {
  this.pass = options.pass;
  this.pickOnly = options.pickOnly;
  this.getShaderProgramFunction = options.getShaderProgramFunction;
  this.getRenderStateFunction = options.getRenderStateFunction;
  this.getUniformMapFunction = options.getUniformMapFunction;
  this.renderStateCache = {};
}
function createDerivedCommandPacks() {
  return [
    new DerivedCommandPack({
      pass: Pass_default.GLOBE,
      pickOnly: false,
      getShaderProgramFunction: getOpaqueFrontFaceShaderProgram,
      getRenderStateFunction: getOpaqueFrontFaceRenderState,
      getUniformMapFunction: void 0
    }),
    new DerivedCommandPack({
      pass: Pass_default.GLOBE,
      pickOnly: false,
      getShaderProgramFunction: getOpaqueBackFaceShaderProgram,
      getRenderStateFunction: getOpaqueBackFaceRenderState,
      getUniformMapFunction: void 0
    }),
    new DerivedCommandPack({
      pass: Pass_default.GLOBE,
      pickOnly: false,
      getShaderProgramFunction: getDepthOnlyShaderProgram2,
      getRenderStateFunction: getDepthOnlyFrontFaceRenderState,
      getUniformMapFunction: void 0
    }),
    new DerivedCommandPack({
      pass: Pass_default.GLOBE,
      pickOnly: false,
      getShaderProgramFunction: getDepthOnlyShaderProgram2,
      getRenderStateFunction: getDepthOnlyBackFaceRenderState,
      getUniformMapFunction: void 0
    }),
    new DerivedCommandPack({
      pass: Pass_default.GLOBE,
      pickOnly: false,
      getShaderProgramFunction: getDepthOnlyShaderProgram2,
      getRenderStateFunction: getDepthOnlyFrontAndBackFaceRenderState,
      getUniformMapFunction: void 0
    }),
    new DerivedCommandPack({
      pass: Pass_default.TRANSLUCENT,
      pickOnly: false,
      getShaderProgramFunction: getTranslucentShaderProgram,
      getRenderStateFunction: getTranslucentFrontFaceRenderState,
      getUniformMapFunction: getTranslucencyUniformMap
    }),
    new DerivedCommandPack({
      pass: Pass_default.TRANSLUCENT,
      pickOnly: false,
      getShaderProgramFunction: getTranslucentBackFaceShaderProgram,
      getRenderStateFunction: getTranslucentBackFaceRenderState,
      getUniformMapFunction: getTranslucencyUniformMap
    }),
    new DerivedCommandPack({
      pass: Pass_default.TRANSLUCENT,
      pickOnly: false,
      getShaderProgramFunction: getTranslucentFrontFaceManualDepthTestShaderProgram,
      getRenderStateFunction: getTranslucentFrontFaceRenderState,
      getUniformMapFunction: getTranslucencyUniformMap
    }),
    new DerivedCommandPack({
      pass: Pass_default.TRANSLUCENT,
      pickOnly: false,
      getShaderProgramFunction: getTranslucentBackFaceManualDepthTestShaderProgram,
      getRenderStateFunction: getTranslucentBackFaceRenderState,
      getUniformMapFunction: getTranslucencyUniformMap
    }),
    new DerivedCommandPack({
      pass: Pass_default.TRANSLUCENT,
      pickOnly: true,
      getShaderProgramFunction: getPickShaderProgram2,
      getRenderStateFunction: getPickFrontFaceRenderState,
      getUniformMapFunction: getTranslucencyUniformMap
    }),
    new DerivedCommandPack({
      pass: Pass_default.TRANSLUCENT,
      pickOnly: true,
      getShaderProgramFunction: getPickShaderProgram2,
      getRenderStateFunction: getPickBackFaceRenderState,
      getUniformMapFunction: getTranslucencyUniformMap
    })
  ];
}
var derivedCommandNames = new Array(derivedCommandsMaximumLength);
var derivedCommandPacks = new Array(derivedCommandsMaximumLength);
GlobeTranslucencyState.prototype.updateDerivedCommands = function(command, frameState) {
  const derivedCommandTypes = this._derivedCommandTypesToUpdate;
  const derivedCommandsLength = this._derivedCommandsToUpdateLength;
  if (derivedCommandsLength === 0) {
    return;
  }
  for (let i2 = 0; i2 < derivedCommandsLength; ++i2) {
    derivedCommandPacks[i2] = this._derivedCommandPacks[derivedCommandTypes[i2]];
    derivedCommandNames[i2] = DerivedCommandNames[derivedCommandTypes[i2]];
  }
  updateDerivedCommands(
    this,
    command,
    derivedCommandsLength,
    derivedCommandTypes,
    derivedCommandNames,
    derivedCommandPacks,
    frameState
  );
};
function updateDerivedCommands(state, command, derivedCommandsLength, derivedCommandTypes, derivedCommandNames2, derivedCommandPacks2, frameState) {
  let derivedCommandsObject = command.derivedCommands.globeTranslucency;
  const derivedCommandsDirty = state._derivedCommandsDirty;
  if (command.dirty || !defined_default(derivedCommandsObject) || derivedCommandsDirty) {
    command.dirty = false;
    if (!defined_default(derivedCommandsObject)) {
      derivedCommandsObject = {};
      command.derivedCommands.globeTranslucency = derivedCommandsObject;
    }
    const frameNumber = frameState.frameNumber;
    const uniformMapDirtyFrame = defaultValue_default(
      derivedCommandsObject.uniformMapDirtyFrame,
      0
    );
    const shaderProgramDirtyFrame = defaultValue_default(
      derivedCommandsObject.shaderProgramDirtyFrame,
      0
    );
    const renderStateDirtyFrame = defaultValue_default(
      derivedCommandsObject.renderStateDirtyFrame,
      0
    );
    const uniformMapDirty = derivedCommandsObject.uniformMap !== command.uniformMap;
    const shaderProgramDirty = derivedCommandsObject.shaderProgramId !== command.shaderProgram.id;
    const renderStateDirty = derivedCommandsObject.renderStateId !== command.renderState.id;
    if (uniformMapDirty) {
      derivedCommandsObject.uniformMapDirtyFrame = frameNumber;
    }
    if (shaderProgramDirty) {
      derivedCommandsObject.shaderProgramDirtyFrame = frameNumber;
    }
    if (renderStateDirty) {
      derivedCommandsObject.renderStateDirtyFrame = frameNumber;
    }
    derivedCommandsObject.uniformMap = command.uniformMap;
    derivedCommandsObject.shaderProgramId = command.shaderProgram.id;
    derivedCommandsObject.renderStateId = command.renderState.id;
    for (let i2 = 0; i2 < derivedCommandsLength; ++i2) {
      const derivedCommandPack = derivedCommandPacks2[i2];
      const derivedCommandType = derivedCommandTypes[i2];
      const derivedCommandName = derivedCommandNames2[i2];
      let derivedCommand = derivedCommandsObject[derivedCommandName];
      let derivedUniformMap;
      let derivedShaderProgram;
      let derivedRenderState;
      if (defined_default(derivedCommand)) {
        derivedUniformMap = derivedCommand.uniformMap;
        derivedShaderProgram = derivedCommand.shaderProgram;
        derivedRenderState = derivedCommand.renderState;
      } else {
        derivedUniformMap = void 0;
        derivedShaderProgram = void 0;
        derivedRenderState = void 0;
      }
      derivedCommand = DrawCommand_default.shallowClone(command, derivedCommand);
      derivedCommandsObject[derivedCommandName] = derivedCommand;
      const derivedUniformMapDirtyFrame = defaultValue_default(
        derivedCommand.derivedCommands.uniformMapDirtyFrame,
        0
      );
      const derivedShaderProgramDirtyFrame = defaultValue_default(
        derivedCommand.derivedCommands.shaderProgramDirtyFrame,
        0
      );
      const derivedRenderStateDirtyFrame = defaultValue_default(
        derivedCommand.derivedCommands.renderStateDirtyFrame,
        0
      );
      const derivedUniformMapDirty = uniformMapDirty || derivedUniformMapDirtyFrame < uniformMapDirtyFrame;
      const derivedShaderProgramDirty = shaderProgramDirty || derivedShaderProgramDirtyFrame < shaderProgramDirtyFrame;
      const derivedRenderStateDirty = renderStateDirty || derivedRenderStateDirtyFrame < renderStateDirtyFrame;
      if (derivedUniformMapDirty) {
        derivedCommand.derivedCommands.uniformMapDirtyFrame = frameNumber;
      }
      if (derivedShaderProgramDirty) {
        derivedCommand.derivedCommands.shaderProgramDirtyFrame = frameNumber;
      }
      if (derivedRenderStateDirty) {
        derivedCommand.derivedCommands.renderStateDirtyFrame = frameNumber;
      }
      derivedCommand.derivedCommands.type = derivedCommandType;
      derivedCommand.pass = derivedCommandPack.pass;
      derivedCommand.pickOnly = derivedCommandPack.pickOnly;
      derivedCommand.uniformMap = getDerivedUniformMap(
        state,
        command.uniformMap,
        derivedUniformMap,
        derivedUniformMapDirty,
        derivedCommandPack.getUniformMapFunction
      );
      derivedCommand.shaderProgram = getDerivedShaderProgram(
        frameState.context,
        command.shaderProgram,
        derivedShaderProgram,
        derivedShaderProgramDirty,
        derivedCommandPack.getShaderProgramFunction,
        derivedCommandName
      );
      derivedCommand.renderState = getDerivedRenderState(
        command.renderState,
        derivedRenderState,
        derivedRenderStateDirty,
        derivedCommandPack.getRenderStateFunction,
        derivedCommandPack.renderStateCache
      );
    }
  }
}
GlobeTranslucencyState.prototype.pushDerivedCommands = function(command, isBlendCommand, frameState) {
  const picking = frameState.passes.pick;
  if (picking && isBlendCommand) {
    return;
  }
  let derivedCommandTypes = this._derivedCommandTypes;
  let derivedCommandsLength = this._derivedCommandsLength;
  if (picking) {
    derivedCommandTypes = this._derivedPickCommandTypes;
    derivedCommandsLength = this._derivedPickCommandsLength;
  } else if (isBlendCommand) {
    derivedCommandTypes = this._derivedBlendCommandTypes;
    derivedCommandsLength = this._derivedBlendCommandsLength;
  }
  if (derivedCommandsLength === 0) {
    frameState.commandList.push(command);
    return;
  }
  const derivedCommands = command.derivedCommands.globeTranslucency;
  for (let i2 = 0; i2 < derivedCommandsLength; ++i2) {
    const derivedCommandName = DerivedCommandNames[derivedCommandTypes[i2]];
    frameState.commandList.push(derivedCommands[derivedCommandName]);
  }
};
function executeCommandsMatchingType(commands, commandsLength, executeCommandFunction, scene, context, passState, types) {
  for (let i2 = 0; i2 < commandsLength; ++i2) {
    const command = commands[i2];
    const type = command.derivedCommands.type;
    if (!defined_default(types) || types.indexOf(type) > -1) {
      executeCommandFunction(command, scene, context, passState);
    }
  }
}
function executeCommands(commands, commandsLength, executeCommandFunction, scene, context, passState) {
  for (let i2 = 0; i2 < commandsLength; ++i2) {
    executeCommandFunction(commands[i2], scene, context, passState);
  }
}
var opaqueTypes = [
  DerivedCommandType.OPAQUE_FRONT_FACE,
  DerivedCommandType.OPAQUE_BACK_FACE
];
var depthOnlyTypes = [
  DerivedCommandType.DEPTH_ONLY_FRONT_FACE,
  DerivedCommandType.DEPTH_ONLY_BACK_FACE,
  DerivedCommandType.DEPTH_ONLY_FRONT_AND_BACK_FACE
];
GlobeTranslucencyState.prototype.executeGlobeCommands = function(frustumCommands, executeCommandFunction, globeTranslucencyFramebuffer, scene, passState) {
  const context = scene.context;
  const globeCommands = frustumCommands.commands[Pass_default.GLOBE];
  const globeCommandsLength = frustumCommands.indices[Pass_default.GLOBE];
  if (globeCommandsLength === 0) {
    return;
  }
  this._globeTranslucencyFramebuffer = globeTranslucencyFramebuffer;
  globeTranslucencyFramebuffer.clearClassification(context, passState);
  executeCommandsMatchingType(
    globeCommands,
    globeCommandsLength,
    executeCommandFunction,
    scene,
    context,
    passState,
    opaqueTypes
  );
};
GlobeTranslucencyState.prototype.executeGlobeClassificationCommands = function(frustumCommands, executeCommandFunction, globeTranslucencyFramebuffer, scene, passState) {
  const context = scene.context;
  const globeCommands = frustumCommands.commands[Pass_default.GLOBE];
  const globeCommandsLength = frustumCommands.indices[Pass_default.GLOBE];
  const classificationCommands = frustumCommands.commands[Pass_default.TERRAIN_CLASSIFICATION];
  const classificationCommandsLength = frustumCommands.indices[Pass_default.TERRAIN_CLASSIFICATION];
  if (globeCommandsLength === 0 || classificationCommandsLength === 0) {
    return;
  }
  const frontTranslucent = this._frontFaceTranslucent;
  const backTranslucent = this._backFaceTranslucent;
  if (!frontTranslucent || !backTranslucent) {
    executeCommands(
      classificationCommands,
      classificationCommandsLength,
      executeCommandFunction,
      scene,
      context,
      passState
    );
  }
  if (!frontTranslucent && !backTranslucent) {
    return;
  }
  this._globeTranslucencyFramebuffer = globeTranslucencyFramebuffer;
  const originalGlobeDepthTexture = context.uniformState.globeDepthTexture;
  const originalFramebuffer = passState.framebuffer;
  passState.framebuffer = globeTranslucencyFramebuffer.classificationFramebuffer;
  executeCommandsMatchingType(
    globeCommands,
    globeCommandsLength,
    executeCommandFunction,
    scene,
    context,
    passState,
    depthOnlyTypes
  );
  if (context.depthTexture) {
    const packedDepthTexture = globeTranslucencyFramebuffer.packDepth(
      context,
      passState
    );
    context.uniformState.globeDepthTexture = packedDepthTexture;
  }
  executeCommands(
    classificationCommands,
    classificationCommandsLength,
    executeCommandFunction,
    scene,
    context,
    passState
  );
  context.uniformState.globeDepthTexture = originalGlobeDepthTexture;
  passState.framebuffer = originalFramebuffer;
};
var GlobeTranslucencyState_default = GlobeTranslucencyState;

// node_modules/cesium/Source/Scene/GoogleEarthEnterpriseImageryProvider.js
function GoogleEarthEnterpriseDiscardPolicy() {
  this._image = new Image();
}
GoogleEarthEnterpriseDiscardPolicy.prototype.isReady = function() {
  return true;
};
GoogleEarthEnterpriseDiscardPolicy.prototype.shouldDiscardImage = function(image) {
  return image === this._image;
};
function GoogleEarthEnterpriseImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!(defined_default(options.url) || defined_default(options.metadata))) {
    throw new DeveloperError_default("options.url or options.metadata is required.");
  }
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  let metadata;
  if (defined_default(options.metadata)) {
    metadata = options.metadata;
  } else {
    const resource = Resource_default.createIfNeeded(options.url);
    metadata = new GoogleEarthEnterpriseMetadata_default(resource);
  }
  this._metadata = metadata;
  this._tileDiscardPolicy = options.tileDiscardPolicy;
  this._tilingScheme = new GeographicTilingScheme_default({
    numberOfLevelZeroTilesX: 2,
    numberOfLevelZeroTilesY: 2,
    rectangle: new Rectangle_default(
      -Math_default.PI,
      -Math_default.PI,
      Math_default.PI,
      Math_default.PI
    ),
    ellipsoid: options.ellipsoid
  });
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  this._credit = credit;
  this._tileWidth = 256;
  this._tileHeight = 256;
  this._maximumLevel = 23;
  if (!defined_default(this._tileDiscardPolicy)) {
    this._tileDiscardPolicy = new GoogleEarthEnterpriseDiscardPolicy();
  }
  this._errorEvent = new Event_default();
  this._ready = false;
  const that = this;
  let metadataError;
  this._readyPromise = metadata.readyPromise.then(function(result) {
    if (!metadata.imageryPresent) {
      const e2 = new RuntimeError_default(
        `The server ${metadata.url} doesn't have imagery`
      );
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        e2.message,
        void 0,
        void 0,
        void 0,
        e2
      );
      return Promise.reject(e2);
    }
    TileProviderError_default.handleSuccess(metadataError);
    that._ready = result;
    return result;
  }).catch(function(e2) {
    metadataError = TileProviderError_default.handleError(
      metadataError,
      that,
      that._errorEvent,
      e2.message,
      void 0,
      void 0,
      void 0,
      e2
    );
    return Promise.reject(e2);
  });
}
Object.defineProperties(GoogleEarthEnterpriseImageryProvider.prototype, {
  url: {
    get: function() {
      return this._metadata.url;
    }
  },
  proxy: {
    get: function() {
      return this._metadata.proxy;
    }
  },
  tileWidth: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileWidth must not be called before the imagery provider is ready."
        );
      }
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileHeight must not be called before the imagery provider is ready."
        );
      }
      return this._tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "maximumLevel must not be called before the imagery provider is ready."
        );
      }
      return this._maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "minimumLevel must not be called before the imagery provider is ready."
        );
      }
      return 0;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "rectangle must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme.rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileDiscardPolicy must not be called before the imagery provider is ready."
        );
      }
      return this._tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return false;
    }
  }
});
GoogleEarthEnterpriseImageryProvider.prototype.getTileCredits = function(x, y, level) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "getTileCredits must not be called before the imagery provider is ready."
    );
  }
  const metadata = this._metadata;
  const info = metadata.getTileInformation(x, y, level);
  if (defined_default(info)) {
    const credit = metadata.providers[info.imageryProvider];
    if (defined_default(credit)) {
      return [credit];
    }
  }
  return void 0;
};
GoogleEarthEnterpriseImageryProvider.prototype.requestImage = function(x, y, level, request) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "requestImage must not be called before the imagery provider is ready."
    );
  }
  const invalidImage = this._tileDiscardPolicy._image;
  const metadata = this._metadata;
  const quadKey = GoogleEarthEnterpriseMetadata_default.tileXYToQuadKey(x, y, level);
  const info = metadata.getTileInformation(x, y, level);
  if (!defined_default(info)) {
    if (metadata.isValid(quadKey)) {
      const metadataRequest = new Request_default({
        throttle: request.throttle,
        throttleByServer: request.throttleByServer,
        type: request.type,
        priorityFunction: request.priorityFunction
      });
      metadata.populateSubtree(x, y, level, metadataRequest);
      return void 0;
    }
    return Promise.resolve(invalidImage);
  }
  if (!info.hasImagery()) {
    return Promise.resolve(invalidImage);
  }
  const promise = buildImageResource3(
    this,
    info,
    x,
    y,
    level,
    request
  ).fetchArrayBuffer();
  if (!defined_default(promise)) {
    return void 0;
  }
  return promise.then(function(image) {
    decodeGoogleEarthEnterpriseData_default(metadata.key, image);
    let a4 = new Uint8Array(image);
    let type;
    const protoImagery = metadata.protoImagery;
    if (!defined_default(protoImagery) || !protoImagery) {
      type = getImageType(a4);
    }
    if (!defined_default(type) && (!defined_default(protoImagery) || protoImagery)) {
      const message = decodeEarthImageryPacket(a4);
      type = message.imageType;
      a4 = message.imageData;
    }
    if (!defined_default(type) || !defined_default(a4)) {
      return invalidImage;
    }
    return loadImageFromTypedArray_default({
      uint8Array: a4,
      format: type,
      flipY: true
    });
  });
};
GoogleEarthEnterpriseImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  return void 0;
};
function buildImageResource3(imageryProvider, info, x, y, level, request) {
  const quadKey = GoogleEarthEnterpriseMetadata_default.tileXYToQuadKey(x, y, level);
  let version = info.imageryVersion;
  version = defined_default(version) && version > 0 ? version : 1;
  return imageryProvider._metadata.resource.getDerivedResource({
    url: `flatfile?f1-0${quadKey}-i.${version.toString()}`,
    request
  });
}
function getImageType(image) {
  const jpeg = "JFIF";
  if (image[6] === jpeg.charCodeAt(0) && image[7] === jpeg.charCodeAt(1) && image[8] === jpeg.charCodeAt(2) && image[9] === jpeg.charCodeAt(3)) {
    return "image/jpeg";
  }
  const png = "PNG";
  if (image[1] === png.charCodeAt(0) && image[2] === png.charCodeAt(1) && image[3] === png.charCodeAt(2)) {
    return "image/png";
  }
  return void 0;
}
function decodeEarthImageryPacket(data) {
  const reader = protobuf$1.Reader.create(data);
  const end = reader.len;
  const message = {};
  while (reader.pos < end) {
    const tag = reader.uint32();
    let copyrightIds;
    switch (tag >>> 3) {
      case 1:
        message.imageType = reader.uint32();
        break;
      case 2:
        message.imageData = reader.bytes();
        break;
      case 3:
        message.alphaType = reader.uint32();
        break;
      case 4:
        message.imageAlpha = reader.bytes();
        break;
      case 5:
        copyrightIds = message.copyrightIds;
        if (!defined_default(copyrightIds)) {
          copyrightIds = message.copyrightIds = [];
        }
        if ((tag & 7) === 2) {
          const end2 = reader.uint32() + reader.pos;
          while (reader.pos < end2) {
            copyrightIds.push(reader.uint32());
          }
        } else {
          copyrightIds.push(reader.uint32());
        }
        break;
      default:
        reader.skipType(tag & 7);
        break;
    }
  }
  const imageType = message.imageType;
  if (defined_default(imageType)) {
    switch (imageType) {
      case 0:
        message.imageType = "image/jpeg";
        break;
      case 4:
        message.imageType = "image/png";
        break;
      default:
        throw new RuntimeError_default(
          "GoogleEarthEnterpriseImageryProvider: Unsupported image type."
        );
    }
  }
  const alphaType = message.alphaType;
  if (defined_default(alphaType) && alphaType !== 0) {
    console.log(
      "GoogleEarthEnterpriseImageryProvider: External alpha not supported."
    );
    delete message.alphaType;
    delete message.imageAlpha;
  }
  return message;
}
var GoogleEarthEnterpriseImageryProvider_default = GoogleEarthEnterpriseImageryProvider;

// node_modules/cesium/Source/Scene/GoogleEarthEnterpriseMapsProvider.js
function GoogleEarthEnterpriseMapsProvider(options) {
  options = defaultValue_default(options, {});
  if (!defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  if (!defined_default(options.channel)) {
    throw new DeveloperError_default("options.channel is required.");
  }
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = 1.9;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  const url2 = options.url;
  const path = defaultValue_default(options.path, "/default_map");
  const resource = Resource_default.createIfNeeded(url2).getDerivedResource({
    url: path[0] === "/" ? path.substring(1) : path
  });
  resource.appendForwardSlash();
  this._resource = resource;
  this._url = url2;
  this._path = path;
  this._tileDiscardPolicy = options.tileDiscardPolicy;
  this._channel = options.channel;
  this._requestType = "ImageryMaps";
  this._credit = new Credit_default(
    `<a href="http://www.google.com/enterprise/mapsearth/products/earthenterprise.html"><img src="${GoogleEarthEnterpriseMapsProvider.logoUrl}" title="Google Imagery"/></a>`
  );
  this._tilingScheme = void 0;
  this._version = void 0;
  this._tileWidth = 256;
  this._tileHeight = 256;
  this._maximumLevel = options.maximumLevel;
  this._errorEvent = new Event_default();
  this._ready = false;
  this._readyPromise = defer_default();
  const metadataResource = resource.getDerivedResource({
    url: "query",
    queryParameters: {
      request: "Json",
      vars: "geeServerDefs",
      is2d: "t"
    }
  });
  const that = this;
  let metadataError;
  function metadataSuccess(text2) {
    let data;
    try {
      data = JSON.parse(text2);
    } catch (e2) {
      data = JSON.parse(
        text2.replace(/([\[\{,])[\n\r ]*([A-Za-z0-9]+)[\n\r ]*:/g, '$1"$2":')
      );
    }
    let layer;
    for (let i2 = 0; i2 < data.layers.length; i2++) {
      if (data.layers[i2].id === that._channel) {
        layer = data.layers[i2];
        break;
      }
    }
    let message;
    if (!defined_default(layer)) {
      message = `Could not find layer with channel (id) of ${that._channel}.`;
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        message,
        void 0,
        void 0,
        void 0,
        requestMetadata
      );
      throw new RuntimeError_default(message);
    }
    if (!defined_default(layer.version)) {
      message = `Could not find a version in channel (id) ${that._channel}.`;
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        message,
        void 0,
        void 0,
        void 0,
        requestMetadata
      );
      throw new RuntimeError_default(message);
    }
    that._version = layer.version;
    if (defined_default(data.projection) && data.projection === "flat") {
      that._tilingScheme = new GeographicTilingScheme_default({
        numberOfLevelZeroTilesX: 2,
        numberOfLevelZeroTilesY: 2,
        rectangle: new Rectangle_default(-Math.PI, -Math.PI, Math.PI, Math.PI),
        ellipsoid: options.ellipsoid
      });
    } else if (!defined_default(data.projection) || data.projection === "mercator") {
      that._tilingScheme = new WebMercatorTilingScheme_default({
        numberOfLevelZeroTilesX: 2,
        numberOfLevelZeroTilesY: 2,
        ellipsoid: options.ellipsoid
      });
    } else {
      message = `Unsupported projection ${data.projection}.`;
      metadataError = TileProviderError_default.handleError(
        metadataError,
        that,
        that._errorEvent,
        message,
        void 0,
        void 0,
        void 0,
        requestMetadata
      );
      throw new RuntimeError_default(message);
    }
    that._ready = true;
    that._readyPromise.resolve(true);
    TileProviderError_default.handleSuccess(metadataError);
  }
  function metadataFailure(e2) {
    const message = defaultValue_default(
      e2.message,
      `An error occurred while accessing ${metadataResource.url}.`
    );
    metadataError = TileProviderError_default.handleError(
      metadataError,
      that,
      that._errorEvent,
      message,
      void 0,
      void 0,
      void 0,
      requestMetadata
    );
    that._readyPromise.reject(new RuntimeError_default(message));
  }
  function requestMetadata() {
    metadataResource.fetchText().then(function(text2) {
      metadataSuccess(text2);
    }).catch(function(e2) {
      metadataFailure(e2);
    });
  }
  requestMetadata();
}
Object.defineProperties(GoogleEarthEnterpriseMapsProvider.prototype, {
  url: {
    get: function() {
      return this._url;
    }
  },
  path: {
    get: function() {
      return this._path;
    }
  },
  proxy: {
    get: function() {
      return this._resource.proxy;
    }
  },
  channel: {
    get: function() {
      return this._channel;
    }
  },
  tileWidth: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileWidth must not be called before the imagery provider is ready."
        );
      }
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileHeight must not be called before the imagery provider is ready."
        );
      }
      return this._tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "maximumLevel must not be called before the imagery provider is ready."
        );
      }
      return this._maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "minimumLevel must not be called before the imagery provider is ready."
        );
      }
      return 0;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme;
    }
  },
  version: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "version must not be called before the imagery provider is ready."
        );
      }
      return this._version;
    }
  },
  requestType: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "requestType must not be called before the imagery provider is ready."
        );
      }
      return this._requestType;
    }
  },
  rectangle: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "rectangle must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme.rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileDiscardPolicy must not be called before the imagery provider is ready."
        );
      }
      return this._tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return true;
    }
  }
});
GoogleEarthEnterpriseMapsProvider.prototype.getTileCredits = function(x, y, level) {
  return void 0;
};
GoogleEarthEnterpriseMapsProvider.prototype.requestImage = function(x, y, level, request) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "requestImage must not be called before the imagery provider is ready."
    );
  }
  const resource = this._resource.getDerivedResource({
    url: "query",
    request,
    queryParameters: {
      request: this._requestType,
      channel: this._channel,
      version: this._version,
      x,
      y,
      z: level + 1
    }
  });
  return ImageryProvider_default.loadImage(this, resource);
};
GoogleEarthEnterpriseMapsProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  return void 0;
};
GoogleEarthEnterpriseMapsProvider._logoUrl = void 0;
Object.defineProperties(GoogleEarthEnterpriseMapsProvider, {
  logoUrl: {
    get: function() {
      if (!defined_default(GoogleEarthEnterpriseMapsProvider._logoUrl)) {
        GoogleEarthEnterpriseMapsProvider._logoUrl = buildModuleUrl_default(
          "Assets/Images/google_earth_credit.png"
        );
      }
      return GoogleEarthEnterpriseMapsProvider._logoUrl;
    },
    set: function(value) {
      Check_default.defined("value", value);
      GoogleEarthEnterpriseMapsProvider._logoUrl = value;
    }
  }
});
var GoogleEarthEnterpriseMapsProvider_default = GoogleEarthEnterpriseMapsProvider;

// node_modules/cesium/Source/Scene/GridImageryProvider.js
var defaultColor9 = new Color_default(1, 1, 1, 0.4);
var defaultGlowColor = new Color_default(0, 1, 0, 0.05);
var defaultBackgroundColor3 = new Color_default(0, 0.5, 0, 0.2);
function GridImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  this._tilingScheme = defined_default(options.tilingScheme) ? options.tilingScheme : new GeographicTilingScheme_default({ ellipsoid: options.ellipsoid });
  this._cells = defaultValue_default(options.cells, 8);
  this._color = defaultValue_default(options.color, defaultColor9);
  this._glowColor = defaultValue_default(options.glowColor, defaultGlowColor);
  this._glowWidth = defaultValue_default(options.glowWidth, 6);
  this._backgroundColor = defaultValue_default(
    options.backgroundColor,
    defaultBackgroundColor3
  );
  this._errorEvent = new Event_default();
  this._tileWidth = defaultValue_default(options.tileWidth, 256);
  this._tileHeight = defaultValue_default(options.tileHeight, 256);
  this._canvasSize = defaultValue_default(options.canvasSize, 256);
  this._canvas = this._createGridCanvas();
  this._readyPromise = Promise.resolve(true);
}
Object.defineProperties(GridImageryProvider.prototype, {
  proxy: {
    get: function() {
      return void 0;
    }
  },
  tileWidth: {
    get: function() {
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      return this._tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      return void 0;
    }
  },
  minimumLevel: {
    get: function() {
      return void 0;
    }
  },
  tilingScheme: {
    get: function() {
      return this._tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      return this._tilingScheme.rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      return void 0;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  ready: {
    get: function() {
      return true;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  credit: {
    get: function() {
      return void 0;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return true;
    }
  }
});
GridImageryProvider.prototype._drawGrid = function(context) {
  const minPixel = 0;
  const maxPixel = this._canvasSize;
  for (let x = 0; x <= this._cells; ++x) {
    const nx = x / this._cells;
    const val = 1 + nx * (maxPixel - 1);
    context.moveTo(val, minPixel);
    context.lineTo(val, maxPixel);
    context.moveTo(minPixel, val);
    context.lineTo(maxPixel, val);
  }
  context.stroke();
};
GridImageryProvider.prototype._createGridCanvas = function() {
  const canvas = document.createElement("canvas");
  canvas.width = this._canvasSize;
  canvas.height = this._canvasSize;
  const minPixel = 0;
  const maxPixel = this._canvasSize;
  const context = canvas.getContext("2d");
  const cssBackgroundColor = this._backgroundColor.toCssColorString();
  context.fillStyle = cssBackgroundColor;
  context.fillRect(minPixel, minPixel, maxPixel, maxPixel);
  const cssGlowColor = this._glowColor.toCssColorString();
  context.strokeStyle = cssGlowColor;
  context.lineWidth = this._glowWidth;
  context.strokeRect(minPixel, minPixel, maxPixel, maxPixel);
  this._drawGrid(context);
  context.lineWidth = this._glowWidth * 0.5;
  context.strokeRect(minPixel, minPixel, maxPixel, maxPixel);
  this._drawGrid(context);
  const cssColor = this._color.toCssColorString();
  context.strokeStyle = cssColor;
  context.lineWidth = 2;
  context.strokeRect(minPixel, minPixel, maxPixel, maxPixel);
  context.lineWidth = 1;
  this._drawGrid(context);
  return canvas;
};
GridImageryProvider.prototype.getTileCredits = function(x, y, level) {
  return void 0;
};
GridImageryProvider.prototype.requestImage = function(x, y, level, request) {
  return Promise.resolve(this._canvas);
};
GridImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  return void 0;
};
var GridImageryProvider_default = GridImageryProvider;

// node_modules/cesium/Source/Scene/ImagerySplitDirection.js
var ImagerySplitDirection = {};
function warnDeprecated() {
  deprecationWarning_default(
    "ImagerySplitDirection",
    "ImagerySplitDirection was deprecated in Cesium 1.92. It will be removed in 1.94. Use SplitDirection instead."
  );
}
Object.defineProperties(ImagerySplitDirection, {
  LEFT: {
    get: function() {
      warnDeprecated();
      return SplitDirection_default.LEFT;
    }
  },
  NONE: {
    get: function() {
      warnDeprecated();
      return SplitDirection_default.NONE;
    }
  },
  RIGHT: {
    get: function() {
      warnDeprecated();
      return SplitDirection_default.RIGHT;
    }
  }
});
var ImagerySplitDirection_default = Object.freeze(ImagerySplitDirection);

// node_modules/cesium/Source/Scene/InvertClassification.js
function InvertClassification() {
  this._numSamples = 1;
  this.previousFramebuffer = void 0;
  this._previousFramebuffer = void 0;
  this._depthStencilTexture = void 0;
  this._depthStencilRenderbuffer = void 0;
  this._fbo = new FramebufferManager_default({
    depthStencil: true,
    createDepthAttachments: false
  });
  this._fboClassified = new FramebufferManager_default({
    depthStencil: true,
    createDepthAttachments: false
  });
  this._rsUnclassified = void 0;
  this._rsClassified = void 0;
  this._unclassifiedCommand = void 0;
  this._classifiedCommand = void 0;
  this._translucentCommand = void 0;
  this._clearColorCommand = new ClearCommand_default({
    color: new Color_default(0, 0, 0, 0),
    owner: this
  });
  this._clearCommand = new ClearCommand_default({
    color: new Color_default(0, 0, 0, 0),
    depth: 1,
    stencil: 0
  });
  const that = this;
  this._uniformMap = {
    colorTexture: function() {
      return that._fbo.getColorTexture();
    },
    depthTexture: function() {
      return that._depthStencilTexture;
    },
    classifiedTexture: function() {
      return that._fboClassified.getColorTexture();
    }
  };
}
Object.defineProperties(InvertClassification.prototype, {
  unclassifiedCommand: {
    get: function() {
      return this._unclassifiedCommand;
    }
  }
});
InvertClassification.isTranslucencySupported = function(context) {
  return context.depthTexture && context.fragmentDepth;
};
var rsUnclassified = {
  depthMask: false,
  stencilTest: {
    enabled: true,
    frontFunction: StencilFunction_default.EQUAL,
    frontOperation: {
      fail: StencilOperation_default.KEEP,
      zFail: StencilOperation_default.KEEP,
      zPass: StencilOperation_default.KEEP
    },
    backFunction: StencilFunction_default.NEVER,
    reference: 0,
    mask: StencilConstants_default.CLASSIFICATION_MASK
  },
  blending: BlendingState_default.ALPHA_BLEND
};
var rsClassified = {
  depthMask: false,
  stencilTest: {
    enabled: true,
    frontFunction: StencilFunction_default.NOT_EQUAL,
    frontOperation: {
      fail: StencilOperation_default.KEEP,
      zFail: StencilOperation_default.KEEP,
      zPass: StencilOperation_default.KEEP
    },
    backFunction: StencilFunction_default.NEVER,
    reference: 0,
    mask: StencilConstants_default.CLASSIFICATION_MASK
  },
  blending: BlendingState_default.ALPHA_BLEND
};
var rsDefault = {
  depthMask: true,
  depthTest: {
    enabled: true
  },
  stencilTest: StencilConstants_default.setCesium3DTileBit(),
  stencilMask: StencilConstants_default.CESIUM_3D_TILE_MASK,
  blending: BlendingState_default.ALPHA_BLEND
};
var translucentFS = "#extension GL_EXT_frag_depth : enable\nuniform sampler2D colorTexture;\nuniform sampler2D depthTexture;\nuniform sampler2D classifiedTexture;\nvarying vec2 v_textureCoordinates;\nvoid main()\n{\n    vec4 color = texture2D(colorTexture, v_textureCoordinates);\n    if (color.a == 0.0)\n    {\n        discard;\n    }\n    bool isClassified = all(equal(texture2D(classifiedTexture, v_textureCoordinates), vec4(0.0)));\n#ifdef UNCLASSIFIED\n    vec4 highlightColor = czm_invertClassificationColor;\n    if (isClassified)\n    {\n        discard;\n    }\n#else\n    vec4 highlightColor = vec4(1.0);\n    if (!isClassified)\n    {\n        discard;\n    }\n#endif\n    gl_FragColor = color * highlightColor;\n    gl_FragDepthEXT = texture2D(depthTexture, v_textureCoordinates).r;\n}\n";
var opaqueFS = "uniform sampler2D colorTexture;\nvarying vec2 v_textureCoordinates;\nvoid main()\n{\n    vec4 color = texture2D(colorTexture, v_textureCoordinates);\n    if (color.a == 0.0)\n    {\n        discard;\n    }\n#ifdef UNCLASSIFIED\n    gl_FragColor = color * czm_invertClassificationColor;\n#else\n    gl_FragColor = color;\n#endif\n}\n";
InvertClassification.prototype.update = function(context, numSamples, globeFramebuffer) {
  const texture = this._fbo.getColorTexture();
  const previousFramebufferChanged = this.previousFramebuffer !== this._previousFramebuffer;
  this._previousFramebuffer = this.previousFramebuffer;
  const samplesChanged = this._numSamples !== numSamples;
  const width = context.drawingBufferWidth;
  const height = context.drawingBufferHeight;
  const textureChanged = !defined_default(texture) || texture.width !== width || texture.height !== height;
  if (textureChanged || previousFramebufferChanged || samplesChanged) {
    this._numSamples = numSamples;
    this._depthStencilTexture = this._depthStencilTexture && this._depthStencilTexture.destroy();
    this._depthStencilRenderbuffer = this._depthStencilRenderbuffer && this._depthStencilRenderbuffer.destroy();
    if (!defined_default(this._previousFramebuffer)) {
      this._depthStencilTexture = new Texture_default({
        context,
        width,
        height,
        pixelFormat: PixelFormat_default.DEPTH_STENCIL,
        pixelDatatype: PixelDatatype_default.UNSIGNED_INT_24_8
      });
      if (numSamples > 1) {
        this._depthStencilRenderbuffer = new Renderbuffer_default({
          context,
          width,
          height,
          format: RenderbufferFormat_default.DEPTH24_STENCIL8,
          numSamples
        });
      }
    }
  }
  if (!defined_default(this._fbo.framebuffer) || textureChanged || previousFramebufferChanged || samplesChanged) {
    this._fbo.destroy();
    this._fboClassified.destroy();
    let depthStencilTexture;
    let depthStencilRenderbuffer;
    if (defined_default(this._previousFramebuffer)) {
      depthStencilTexture = globeFramebuffer.getDepthStencilTexture();
      depthStencilRenderbuffer = globeFramebuffer.getDepthStencilRenderbuffer();
    } else {
      depthStencilTexture = this._depthStencilTexture;
      depthStencilRenderbuffer = this._depthStencilRenderbuffer;
    }
    this._fbo.setDepthStencilTexture(depthStencilTexture);
    if (defined_default(depthStencilRenderbuffer)) {
      this._fbo.setDepthStencilRenderbuffer(depthStencilRenderbuffer);
    }
    this._fbo.update(context, width, height, numSamples);
    if (!defined_default(this._previousFramebuffer)) {
      this._fboClassified.setDepthStencilTexture(depthStencilTexture);
      this._fboClassified.update(context, width, height);
    }
  }
  if (!defined_default(this._rsUnclassified)) {
    this._rsUnclassified = RenderState_default.fromCache(rsUnclassified);
    this._rsClassified = RenderState_default.fromCache(rsClassified);
    this._rsDefault = RenderState_default.fromCache(rsDefault);
  }
  if (!defined_default(this._unclassifiedCommand) || previousFramebufferChanged || samplesChanged) {
    if (defined_default(this._unclassifiedCommand)) {
      this._unclassifiedCommand.shaderProgram = this._unclassifiedCommand.shaderProgram && this._unclassifiedCommand.shaderProgram.destroy();
      this._classifiedCommand.shaderProgram = this._classifiedCommand.shaderProgram && this._classifiedCommand.shaderProgram.destroy();
    }
    const fs = defined_default(this._previousFramebuffer) ? opaqueFS : translucentFS;
    const unclassifiedFSSource = new ShaderSource_default({
      defines: ["UNCLASSIFIED"],
      sources: [fs]
    });
    const classifiedFSSource = new ShaderSource_default({
      sources: [fs]
    });
    this._unclassifiedCommand = context.createViewportQuadCommand(
      unclassifiedFSSource,
      {
        renderState: defined_default(this._previousFramebuffer) ? this._rsUnclassified : this._rsDefault,
        uniformMap: this._uniformMap,
        owner: this
      }
    );
    this._classifiedCommand = context.createViewportQuadCommand(
      classifiedFSSource,
      {
        renderState: defined_default(this._previousFramebuffer) ? this._rsClassified : this._rsDefault,
        uniformMap: this._uniformMap,
        owner: this
      }
    );
    if (defined_default(this._translucentCommand)) {
      this._translucentCommand.shaderProgram = this._translucentCommand.shaderProgram && this._translucentCommand.shaderProgram.destroy();
    }
    if (!defined_default(this._previousFramebuffer)) {
      this._translucentCommand = context.createViewportQuadCommand(
        PassThrough_default,
        {
          renderState: this._rsUnclassified,
          uniformMap: this._uniformMap,
          owner: this
        }
      );
    }
  }
};
InvertClassification.prototype.prepareTextures = function(context, blitStencil) {
  if (this._fbo._numSamples > 1) {
    this._fbo.prepareTextures(context, blitStencil);
  }
};
InvertClassification.prototype.clear = function(context, passState) {
  if (defined_default(this._previousFramebuffer)) {
    this._fbo.clear(context, this._clearColorCommand, passState);
  } else {
    this._fbo.clear(context, this._clearCommand, passState);
    this._fboClassified.clear(context, this._clearCommand, passState);
  }
};
InvertClassification.prototype.executeClassified = function(context, passState) {
  if (!defined_default(this._previousFramebuffer)) {
    const framebuffer = passState.framebuffer;
    this.prepareTextures(context, true);
    passState.framebuffer = this._fboClassified.framebuffer;
    this._translucentCommand.execute(context, passState);
    passState.framebuffer = framebuffer;
  }
  this._classifiedCommand.execute(context, passState);
};
InvertClassification.prototype.executeUnclassified = function(context, passState) {
  this._unclassifiedCommand.execute(context, passState);
};
InvertClassification.prototype.isDestroyed = function() {
  return false;
};
InvertClassification.prototype.destroy = function() {
  this._fbo.destroy();
  this._fboClassified.destroy();
  this._depthStencilTexture = this._depthStencilTexture && this._depthStencilTexture.destroy();
  this._depthStencilRenderbuffer = this._depthStencilRenderbuffer && this._depthStencilRenderbuffer.destroy();
  if (defined_default(this._unclassifiedCommand)) {
    this._unclassifiedCommand.shaderProgram = this._unclassifiedCommand.shaderProgram && this._unclassifiedCommand.shaderProgram.destroy();
    this._classifiedCommand.shaderProgram = this._classifiedCommand.shaderProgram && this._classifiedCommand.shaderProgram.destroy();
  }
  return destroyObject_default(this);
};
var InvertClassification_default = InvertClassification;

// node_modules/cesium/Source/Scene/UrlTemplateImageryProvider.js
var templateRegex = /{[^}]+}/g;
var tags = {
  x: xTag,
  y: yTag,
  z: zTag,
  s: sTag,
  reverseX: reverseXTag,
  reverseY: reverseYTag,
  reverseZ: reverseZTag,
  westDegrees: westDegreesTag,
  southDegrees: southDegreesTag,
  eastDegrees: eastDegreesTag,
  northDegrees: northDegreesTag,
  westProjected: westProjectedTag,
  southProjected: southProjectedTag,
  eastProjected: eastProjectedTag,
  northProjected: northProjectedTag,
  width: widthTag,
  height: heightTag
};
var pickFeaturesTags = combine_default(tags, {
  i: iTag,
  j: jTag,
  reverseI: reverseITag,
  reverseJ: reverseJTag,
  longitudeDegrees: longitudeDegreesTag,
  latitudeDegrees: latitudeDegreesTag,
  longitudeProjected: longitudeProjectedTag,
  latitudeProjected: latitudeProjectedTag,
  format: formatTag
});
function UrlTemplateImageryProvider(options) {
  if (!defined_default(options)) {
    throw new DeveloperError_default("options is required.");
  }
  if (!defined_default(options.then) && !defined_default(options.url)) {
    throw new DeveloperError_default("options is required.");
  }
  this._errorEvent = new Event_default();
  this._resource = void 0;
  this._urlSchemeZeroPadding = void 0;
  this._pickFeaturesResource = void 0;
  this._tileWidth = void 0;
  this._tileHeight = void 0;
  this._maximumLevel = void 0;
  this._minimumLevel = void 0;
  this._tilingScheme = void 0;
  this._rectangle = void 0;
  this._tileDiscardPolicy = void 0;
  this._credit = void 0;
  this._hasAlphaChannel = void 0;
  this._readyPromise = void 0;
  this._tags = void 0;
  this._pickFeaturesTags = void 0;
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  this.enablePickFeatures = true;
  this.reinitialize(options);
}
Object.defineProperties(UrlTemplateImageryProvider.prototype, {
  url: {
    get: function() {
      return this._resource.url;
    }
  },
  urlSchemeZeroPadding: {
    get: function() {
      return this._urlSchemeZeroPadding;
    }
  },
  pickFeaturesUrl: {
    get: function() {
      return this._pickFeaturesResource.url;
    }
  },
  proxy: {
    get: function() {
      return this._resource.proxy;
    }
  },
  tileWidth: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "tileWidth must not be called before the imagery provider is ready."
        );
      }
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "tileHeight must not be called before the imagery provider is ready."
        );
      }
      return this._tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "maximumLevel must not be called before the imagery provider is ready."
        );
      }
      return this._maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "minimumLevel must not be called before the imagery provider is ready."
        );
      }
      return this._minimumLevel;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "rectangle must not be called before the imagery provider is ready."
        );
      }
      return this._rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "tileDiscardPolicy must not be called before the imagery provider is ready."
        );
      }
      return this._tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  ready: {
    get: function() {
      return defined_default(this._resource);
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  credit: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "credit must not be called before the imagery provider is ready."
        );
      }
      return this._credit;
    }
  },
  hasAlphaChannel: {
    get: function() {
      if (!this.ready) {
        throw new DeveloperError_default(
          "hasAlphaChannel must not be called before the imagery provider is ready."
        );
      }
      return this._hasAlphaChannel;
    }
  }
});
UrlTemplateImageryProvider.prototype.reinitialize = function(options) {
  const that = this;
  that._readyPromise = Promise.resolve(options).then(function(properties) {
    if (!defined_default(properties)) {
      throw new DeveloperError_default("options is required.");
    }
    if (!defined_default(properties.url)) {
      throw new DeveloperError_default("options.url is required.");
    }
    const customTags = properties.customTags;
    const allTags = combine_default(tags, customTags);
    const allPickFeaturesTags = combine_default(pickFeaturesTags, customTags);
    const resource = Resource_default.createIfNeeded(properties.url);
    const pickFeaturesResource = Resource_default.createIfNeeded(
      properties.pickFeaturesUrl
    );
    that.enablePickFeatures = defaultValue_default(
      properties.enablePickFeatures,
      that.enablePickFeatures
    );
    that._urlSchemeZeroPadding = defaultValue_default(
      properties.urlSchemeZeroPadding,
      that.urlSchemeZeroPadding
    );
    that._tileDiscardPolicy = properties.tileDiscardPolicy;
    that._getFeatureInfoFormats = properties.getFeatureInfoFormats;
    that._subdomains = properties.subdomains;
    if (Array.isArray(that._subdomains)) {
      that._subdomains = that._subdomains.slice();
    } else if (defined_default(that._subdomains) && that._subdomains.length > 0) {
      that._subdomains = that._subdomains.split("");
    } else {
      that._subdomains = ["a", "b", "c"];
    }
    that._tileWidth = defaultValue_default(properties.tileWidth, 256);
    that._tileHeight = defaultValue_default(properties.tileHeight, 256);
    that._minimumLevel = defaultValue_default(properties.minimumLevel, 0);
    that._maximumLevel = properties.maximumLevel;
    that._tilingScheme = defaultValue_default(
      properties.tilingScheme,
      new WebMercatorTilingScheme_default({ ellipsoid: properties.ellipsoid })
    );
    that._rectangle = defaultValue_default(
      properties.rectangle,
      that._tilingScheme.rectangle
    );
    that._rectangle = Rectangle_default.intersection(
      that._rectangle,
      that._tilingScheme.rectangle
    );
    that._hasAlphaChannel = defaultValue_default(properties.hasAlphaChannel, true);
    let credit = properties.credit;
    if (typeof credit === "string") {
      credit = new Credit_default(credit);
    }
    that._credit = credit;
    that._resource = resource;
    that._tags = allTags;
    that._pickFeaturesResource = pickFeaturesResource;
    that._pickFeaturesTags = allPickFeaturesTags;
    return true;
  });
};
UrlTemplateImageryProvider.prototype.getTileCredits = function(x, y, level) {
  if (!this.ready) {
    throw new DeveloperError_default(
      "getTileCredits must not be called before the imagery provider is ready."
    );
  }
  return void 0;
};
UrlTemplateImageryProvider.prototype.requestImage = function(x, y, level, request) {
  if (!this.ready) {
    throw new DeveloperError_default(
      "requestImage must not be called before the imagery provider is ready."
    );
  }
  return ImageryProvider_default.loadImage(
    this,
    buildImageResource4(this, x, y, level, request)
  );
};
UrlTemplateImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  if (!this.ready) {
    throw new DeveloperError_default(
      "pickFeatures must not be called before the imagery provider is ready."
    );
  }
  if (!this.enablePickFeatures || !defined_default(this._pickFeaturesResource) || this._getFeatureInfoFormats.length === 0) {
    return void 0;
  }
  let formatIndex = 0;
  const that = this;
  function handleResponse(format, data) {
    return format.callback(data);
  }
  function doRequest() {
    if (formatIndex >= that._getFeatureInfoFormats.length) {
      return Promise.resolve([]);
    }
    const format = that._getFeatureInfoFormats[formatIndex];
    const resource = buildPickFeaturesResource(
      that,
      x,
      y,
      level,
      longitude,
      latitude,
      format.format
    );
    ++formatIndex;
    if (format.type === "json") {
      return resource.fetchJson().then(format.callback).catch(doRequest);
    } else if (format.type === "xml") {
      return resource.fetchXML().then(format.callback).catch(doRequest);
    } else if (format.type === "text" || format.type === "html") {
      return resource.fetchText().then(format.callback).catch(doRequest);
    }
    return resource.fetch({
      responseType: format.format
    }).then(handleResponse.bind(void 0, format)).catch(doRequest);
  }
  return doRequest();
};
var degreesScratchComputed = false;
var degreesScratch = new Rectangle_default();
var projectedScratchComputed = false;
var projectedScratch = new Rectangle_default();
function buildImageResource4(imageryProvider, x, y, level, request) {
  degreesScratchComputed = false;
  projectedScratchComputed = false;
  const resource = imageryProvider._resource;
  const url2 = resource.getUrlComponent(true);
  const allTags = imageryProvider._tags;
  const templateValues = {};
  const match = url2.match(templateRegex);
  if (defined_default(match)) {
    match.forEach(function(tag) {
      const key = tag.substring(1, tag.length - 1);
      if (defined_default(allTags[key])) {
        templateValues[key] = allTags[key](imageryProvider, x, y, level);
      }
    });
  }
  return resource.getDerivedResource({
    request,
    templateValues
  });
}
var ijScratchComputed = false;
var ijScratch = new Cartesian2_default();
var longitudeLatitudeProjectedScratchComputed = false;
function buildPickFeaturesResource(imageryProvider, x, y, level, longitude, latitude, format) {
  degreesScratchComputed = false;
  projectedScratchComputed = false;
  ijScratchComputed = false;
  longitudeLatitudeProjectedScratchComputed = false;
  const resource = imageryProvider._pickFeaturesResource;
  const url2 = resource.getUrlComponent(true);
  const allTags = imageryProvider._pickFeaturesTags;
  const templateValues = {};
  const match = url2.match(templateRegex);
  if (defined_default(match)) {
    match.forEach(function(tag) {
      const key = tag.substring(1, tag.length - 1);
      if (defined_default(allTags[key])) {
        templateValues[key] = allTags[key](
          imageryProvider,
          x,
          y,
          level,
          longitude,
          latitude,
          format
        );
      }
    });
  }
  return resource.getDerivedResource({
    templateValues
  });
}
function padWithZerosIfNecessary(imageryProvider, key, value) {
  if (imageryProvider && imageryProvider.urlSchemeZeroPadding && imageryProvider.urlSchemeZeroPadding.hasOwnProperty(key)) {
    const paddingTemplate = imageryProvider.urlSchemeZeroPadding[key];
    if (typeof paddingTemplate === "string") {
      const paddingTemplateWidth = paddingTemplate.length;
      if (paddingTemplateWidth > 1) {
        value = value.length >= paddingTemplateWidth ? value : new Array(
          paddingTemplateWidth - value.toString().length + 1
        ).join("0") + value;
      }
    }
  }
  return value;
}
function xTag(imageryProvider, x, y, level) {
  return padWithZerosIfNecessary(imageryProvider, "{x}", x);
}
function reverseXTag(imageryProvider, x, y, level) {
  const reverseX = imageryProvider.tilingScheme.getNumberOfXTilesAtLevel(level) - x - 1;
  return padWithZerosIfNecessary(imageryProvider, "{reverseX}", reverseX);
}
function yTag(imageryProvider, x, y, level) {
  return padWithZerosIfNecessary(imageryProvider, "{y}", y);
}
function reverseYTag(imageryProvider, x, y, level) {
  const reverseY = imageryProvider.tilingScheme.getNumberOfYTilesAtLevel(level) - y - 1;
  return padWithZerosIfNecessary(imageryProvider, "{reverseY}", reverseY);
}
function reverseZTag(imageryProvider, x, y, level) {
  const maximumLevel = imageryProvider.maximumLevel;
  const reverseZ = defined_default(maximumLevel) && level < maximumLevel ? maximumLevel - level - 1 : level;
  return padWithZerosIfNecessary(imageryProvider, "{reverseZ}", reverseZ);
}
function zTag(imageryProvider, x, y, level) {
  return padWithZerosIfNecessary(imageryProvider, "{z}", level);
}
function sTag(imageryProvider, x, y, level) {
  const index2 = (x + y + level) % imageryProvider._subdomains.length;
  return imageryProvider._subdomains[index2];
}
function computeDegrees(imageryProvider, x, y, level) {
  if (degreesScratchComputed) {
    return;
  }
  imageryProvider.tilingScheme.tileXYToRectangle(x, y, level, degreesScratch);
  degreesScratch.west = Math_default.toDegrees(degreesScratch.west);
  degreesScratch.south = Math_default.toDegrees(degreesScratch.south);
  degreesScratch.east = Math_default.toDegrees(degreesScratch.east);
  degreesScratch.north = Math_default.toDegrees(degreesScratch.north);
  degreesScratchComputed = true;
}
function westDegreesTag(imageryProvider, x, y, level) {
  computeDegrees(imageryProvider, x, y, level);
  return degreesScratch.west;
}
function southDegreesTag(imageryProvider, x, y, level) {
  computeDegrees(imageryProvider, x, y, level);
  return degreesScratch.south;
}
function eastDegreesTag(imageryProvider, x, y, level) {
  computeDegrees(imageryProvider, x, y, level);
  return degreesScratch.east;
}
function northDegreesTag(imageryProvider, x, y, level) {
  computeDegrees(imageryProvider, x, y, level);
  return degreesScratch.north;
}
function computeProjected(imageryProvider, x, y, level) {
  if (projectedScratchComputed) {
    return;
  }
  imageryProvider.tilingScheme.tileXYToNativeRectangle(
    x,
    y,
    level,
    projectedScratch
  );
  projectedScratchComputed = true;
}
function westProjectedTag(imageryProvider, x, y, level) {
  computeProjected(imageryProvider, x, y, level);
  return projectedScratch.west;
}
function southProjectedTag(imageryProvider, x, y, level) {
  computeProjected(imageryProvider, x, y, level);
  return projectedScratch.south;
}
function eastProjectedTag(imageryProvider, x, y, level) {
  computeProjected(imageryProvider, x, y, level);
  return projectedScratch.east;
}
function northProjectedTag(imageryProvider, x, y, level) {
  computeProjected(imageryProvider, x, y, level);
  return projectedScratch.north;
}
function widthTag(imageryProvider, x, y, level) {
  return imageryProvider.tileWidth;
}
function heightTag(imageryProvider, x, y, level) {
  return imageryProvider.tileHeight;
}
function iTag(imageryProvider, x, y, level, longitude, latitude, format) {
  computeIJ(imageryProvider, x, y, level, longitude, latitude);
  return ijScratch.x;
}
function jTag(imageryProvider, x, y, level, longitude, latitude, format) {
  computeIJ(imageryProvider, x, y, level, longitude, latitude);
  return ijScratch.y;
}
function reverseITag(imageryProvider, x, y, level, longitude, latitude, format) {
  computeIJ(imageryProvider, x, y, level, longitude, latitude);
  return imageryProvider.tileWidth - ijScratch.x - 1;
}
function reverseJTag(imageryProvider, x, y, level, longitude, latitude, format) {
  computeIJ(imageryProvider, x, y, level, longitude, latitude);
  return imageryProvider.tileHeight - ijScratch.y - 1;
}
var rectangleScratch7 = new Rectangle_default();
var longitudeLatitudeProjectedScratch = new Cartesian3_default();
function computeIJ(imageryProvider, x, y, level, longitude, latitude, format) {
  if (ijScratchComputed) {
    return;
  }
  computeLongitudeLatitudeProjected(
    imageryProvider,
    x,
    y,
    level,
    longitude,
    latitude
  );
  const projected = longitudeLatitudeProjectedScratch;
  const rectangle = imageryProvider.tilingScheme.tileXYToNativeRectangle(
    x,
    y,
    level,
    rectangleScratch7
  );
  ijScratch.x = imageryProvider.tileWidth * (projected.x - rectangle.west) / rectangle.width | 0;
  ijScratch.y = imageryProvider.tileHeight * (rectangle.north - projected.y) / rectangle.height | 0;
  ijScratchComputed = true;
}
function longitudeDegreesTag(imageryProvider, x, y, level, longitude, latitude, format) {
  return Math_default.toDegrees(longitude);
}
function latitudeDegreesTag(imageryProvider, x, y, level, longitude, latitude, format) {
  return Math_default.toDegrees(latitude);
}
function longitudeProjectedTag(imageryProvider, x, y, level, longitude, latitude, format) {
  computeLongitudeLatitudeProjected(
    imageryProvider,
    x,
    y,
    level,
    longitude,
    latitude
  );
  return longitudeLatitudeProjectedScratch.x;
}
function latitudeProjectedTag(imageryProvider, x, y, level, longitude, latitude, format) {
  computeLongitudeLatitudeProjected(
    imageryProvider,
    x,
    y,
    level,
    longitude,
    latitude
  );
  return longitudeLatitudeProjectedScratch.y;
}
var cartographicScratch5 = new Cartographic_default();
function computeLongitudeLatitudeProjected(imageryProvider, x, y, level, longitude, latitude, format) {
  if (longitudeLatitudeProjectedScratchComputed) {
    return;
  }
  if (imageryProvider.tilingScheme.projection instanceof GeographicProjection_default) {
    longitudeLatitudeProjectedScratch.x = Math_default.toDegrees(longitude);
    longitudeLatitudeProjectedScratch.y = Math_default.toDegrees(latitude);
  } else {
    const cartographic2 = cartographicScratch5;
    cartographic2.longitude = longitude;
    cartographic2.latitude = latitude;
    imageryProvider.tilingScheme.projection.project(
      cartographic2,
      longitudeLatitudeProjectedScratch
    );
  }
  longitudeLatitudeProjectedScratchComputed = true;
}
function formatTag(imageryProvider, x, y, level, longitude, latitude, format) {
  return format;
}
var UrlTemplateImageryProvider_default = UrlTemplateImageryProvider;

// node_modules/cesium/Source/Scene/TileMapServiceImageryProvider.js
function TileMapServiceImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  const deferred = defer_default();
  UrlTemplateImageryProvider_default.call(this, deferred.promise);
  this._tmsResource = void 0;
  this._xmlResource = void 0;
  this._options = options;
  this._deferred = deferred;
  this._metadataError = void 0;
  this._metadataSuccess = this._metadataSuccess.bind(this);
  this._metadataFailure = this._metadataFailure.bind(this);
  this._requestMetadata = this._requestMetadata.bind(this);
  let resource;
  const that = this;
  Promise.resolve(options.url).then(function(url2) {
    resource = Resource_default.createIfNeeded(url2);
    resource.appendForwardSlash();
    that._tmsResource = resource;
    that._xmlResource = resource.getDerivedResource({
      url: "tilemapresource.xml"
    });
    that._requestMetadata();
  }).catch(function(e2) {
    deferred.reject(e2);
  });
}
if (defined_default(Object.create)) {
  TileMapServiceImageryProvider.prototype = Object.create(
    UrlTemplateImageryProvider_default.prototype
  );
  TileMapServiceImageryProvider.prototype.constructor = TileMapServiceImageryProvider;
}
TileMapServiceImageryProvider.prototype._requestMetadata = function() {
  this._xmlResource.fetchXML().then(this._metadataSuccess).catch(this._metadataFailure);
};
function confineRectangleToTilingScheme(rectangle, tilingScheme2) {
  if (rectangle.west < tilingScheme2.rectangle.west) {
    rectangle.west = tilingScheme2.rectangle.west;
  }
  if (rectangle.east > tilingScheme2.rectangle.east) {
    rectangle.east = tilingScheme2.rectangle.east;
  }
  if (rectangle.south < tilingScheme2.rectangle.south) {
    rectangle.south = tilingScheme2.rectangle.south;
  }
  if (rectangle.north > tilingScheme2.rectangle.north) {
    rectangle.north = tilingScheme2.rectangle.north;
  }
  return rectangle;
}
function calculateSafeMinimumDetailLevel(tilingScheme2, rectangle, minimumLevel) {
  const swTile = tilingScheme2.positionToTileXY(
    Rectangle_default.southwest(rectangle),
    minimumLevel
  );
  const neTile = tilingScheme2.positionToTileXY(
    Rectangle_default.northeast(rectangle),
    minimumLevel
  );
  const tileCount = (Math.abs(neTile.x - swTile.x) + 1) * (Math.abs(neTile.y - swTile.y) + 1);
  if (tileCount > 4) {
    return 0;
  }
  return minimumLevel;
}
TileMapServiceImageryProvider.prototype._metadataSuccess = function(xml2) {
  const tileFormatRegex = /tileformat/i;
  const tileSetRegex = /tileset/i;
  const tileSetsRegex = /tilesets/i;
  const bboxRegex = /boundingbox/i;
  let format, bbox2, tilesets;
  const tilesetsList = [];
  const xmlResource = this._xmlResource;
  let metadataError = this._metadataError;
  const deferred = this._deferred;
  const requestMetadata = this._requestMetadata;
  const nodeList = xml2.childNodes[0].childNodes;
  for (let i2 = 0; i2 < nodeList.length; i2++) {
    if (tileFormatRegex.test(nodeList.item(i2).nodeName)) {
      format = nodeList.item(i2);
    } else if (tileSetsRegex.test(nodeList.item(i2).nodeName)) {
      tilesets = nodeList.item(i2);
      const tileSetNodes = nodeList.item(i2).childNodes;
      for (let j = 0; j < tileSetNodes.length; j++) {
        if (tileSetRegex.test(tileSetNodes.item(j).nodeName)) {
          tilesetsList.push(tileSetNodes.item(j));
        }
      }
    } else if (bboxRegex.test(nodeList.item(i2).nodeName)) {
      bbox2 = nodeList.item(i2);
    }
  }
  let message;
  if (!defined_default(tilesets) || !defined_default(bbox2)) {
    message = `Unable to find expected tilesets or bbox attributes in ${xmlResource.url}.`;
    metadataError = TileProviderError_default.handleError(
      metadataError,
      this,
      this.errorEvent,
      message,
      void 0,
      void 0,
      void 0,
      requestMetadata
    );
    if (!metadataError.retry) {
      deferred.reject(new RuntimeError_default(message));
    }
    this._metadataError = metadataError;
    return;
  }
  const options = this._options;
  const fileExtension = defaultValue_default(
    options.fileExtension,
    format.getAttribute("extension")
  );
  const tileWidth = defaultValue_default(
    options.tileWidth,
    parseInt(format.getAttribute("width"), 10)
  );
  const tileHeight = defaultValue_default(
    options.tileHeight,
    parseInt(format.getAttribute("height"), 10)
  );
  let minimumLevel = defaultValue_default(
    options.minimumLevel,
    parseInt(tilesetsList[0].getAttribute("order"), 10)
  );
  const maximumLevel = defaultValue_default(
    options.maximumLevel,
    parseInt(tilesetsList[tilesetsList.length - 1].getAttribute("order"), 10)
  );
  const tilingSchemeName = tilesets.getAttribute("profile");
  let tilingScheme2 = options.tilingScheme;
  if (!defined_default(tilingScheme2)) {
    if (tilingSchemeName === "geodetic" || tilingSchemeName === "global-geodetic") {
      tilingScheme2 = new GeographicTilingScheme_default({
        ellipsoid: options.ellipsoid
      });
    } else if (tilingSchemeName === "mercator" || tilingSchemeName === "global-mercator") {
      tilingScheme2 = new WebMercatorTilingScheme_default({
        ellipsoid: options.ellipsoid
      });
    } else {
      message = `${xmlResource.url}specifies an unsupported profile attribute, ${tilingSchemeName}.`;
      metadataError = TileProviderError_default.handleError(
        metadataError,
        this,
        this.errorEvent,
        message,
        void 0,
        void 0,
        void 0,
        requestMetadata
      );
      if (!metadataError.retry) {
        deferred.reject(new RuntimeError_default(message));
      }
      this._metadataError = metadataError;
      return;
    }
  }
  let rectangle = Rectangle_default.clone(options.rectangle);
  if (!defined_default(rectangle)) {
    let sw;
    let ne;
    let swXY;
    let neXY;
    const flipXY = defaultValue_default(options.flipXY, false);
    if (flipXY) {
      swXY = new Cartesian2_default(
        parseFloat(bbox2.getAttribute("miny")),
        parseFloat(bbox2.getAttribute("minx"))
      );
      neXY = new Cartesian2_default(
        parseFloat(bbox2.getAttribute("maxy")),
        parseFloat(bbox2.getAttribute("maxx"))
      );
    } else {
      swXY = new Cartesian2_default(
        parseFloat(bbox2.getAttribute("minx")),
        parseFloat(bbox2.getAttribute("miny"))
      );
      neXY = new Cartesian2_default(
        parseFloat(bbox2.getAttribute("maxx")),
        parseFloat(bbox2.getAttribute("maxy"))
      );
    }
    const isGdal2tiles = tilingSchemeName === "geodetic" || tilingSchemeName === "mercator";
    if (tilingScheme2.projection instanceof GeographicProjection_default || isGdal2tiles) {
      sw = Cartographic_default.fromDegrees(swXY.x, swXY.y);
      ne = Cartographic_default.fromDegrees(neXY.x, neXY.y);
    } else {
      const projection = tilingScheme2.projection;
      sw = projection.unproject(swXY);
      ne = projection.unproject(neXY);
    }
    rectangle = new Rectangle_default(
      sw.longitude,
      sw.latitude,
      ne.longitude,
      ne.latitude
    );
  }
  rectangle = confineRectangleToTilingScheme(rectangle, tilingScheme2);
  minimumLevel = calculateSafeMinimumDetailLevel(
    tilingScheme2,
    rectangle,
    minimumLevel
  );
  const templateResource = this._tmsResource.getDerivedResource({
    url: `{z}/{x}/{reverseY}.${fileExtension}`
  });
  deferred.resolve({
    url: templateResource,
    tilingScheme: tilingScheme2,
    rectangle,
    tileWidth,
    tileHeight,
    minimumLevel,
    maximumLevel,
    tileDiscardPolicy: options.tileDiscardPolicy,
    credit: options.credit
  });
};
TileMapServiceImageryProvider.prototype._metadataFailure = function(error) {
  const options = this._options;
  const fileExtension = defaultValue_default(options.fileExtension, "png");
  const tileWidth = defaultValue_default(options.tileWidth, 256);
  const tileHeight = defaultValue_default(options.tileHeight, 256);
  const maximumLevel = options.maximumLevel;
  const tilingScheme2 = defined_default(options.tilingScheme) ? options.tilingScheme : new WebMercatorTilingScheme_default({ ellipsoid: options.ellipsoid });
  let rectangle = defaultValue_default(options.rectangle, tilingScheme2.rectangle);
  rectangle = confineRectangleToTilingScheme(rectangle, tilingScheme2);
  const minimumLevel = calculateSafeMinimumDetailLevel(
    tilingScheme2,
    rectangle,
    options.minimumLevel
  );
  const templateResource = this._tmsResource.getDerivedResource({
    url: `{z}/{x}/{reverseY}.${fileExtension}`
  });
  this._deferred.resolve({
    url: templateResource,
    tilingScheme: tilingScheme2,
    rectangle,
    tileWidth,
    tileHeight,
    minimumLevel,
    maximumLevel,
    tileDiscardPolicy: options.tileDiscardPolicy,
    credit: options.credit
  });
};
var TileMapServiceImageryProvider_default = TileMapServiceImageryProvider;

// node_modules/cesium/Source/Scene/MapboxImageryProvider.js
var trailingSlashRegex = /\/$/;
var defaultCredit2 = new Credit_default(
  '&copy; <a href="https://www.mapbox.com/about/maps/">Mapbox</a> &copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> <strong><a href="https://www.mapbox.com/map-feedback/">Improve this map</a></strong>'
);
function MapboxImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const mapId = options.mapId;
  if (!defined_default(mapId)) {
    throw new DeveloperError_default("options.mapId is required.");
  }
  const accessToken = options.accessToken;
  if (!defined_default(accessToken)) {
    throw new DeveloperError_default("options.accessToken is required.");
  }
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  const resource = Resource_default.createIfNeeded(
    defaultValue_default(options.url, "https://{s}.tiles.mapbox.com/v4/")
  );
  this._mapId = mapId;
  this._accessToken = accessToken;
  let format = defaultValue_default(options.format, "png");
  if (!/\./.test(format)) {
    format = `.${format}`;
  }
  this._format = format;
  let templateUrl = resource.getUrlComponent();
  if (!trailingSlashRegex.test(templateUrl)) {
    templateUrl += "/";
  }
  templateUrl += `${mapId}/{z}/{x}/{y}${this._format}`;
  resource.url = templateUrl;
  resource.setQueryParameters({
    access_token: accessToken
  });
  let credit;
  if (defined_default(options.credit)) {
    credit = options.credit;
    if (typeof credit === "string") {
      credit = new Credit_default(credit);
    }
  } else {
    credit = defaultCredit2;
  }
  this._resource = resource;
  this._imageryProvider = new UrlTemplateImageryProvider_default({
    url: resource,
    credit,
    ellipsoid: options.ellipsoid,
    minimumLevel: options.minimumLevel,
    maximumLevel: options.maximumLevel,
    rectangle: options.rectangle
  });
}
Object.defineProperties(MapboxImageryProvider.prototype, {
  url: {
    get: function() {
      return this._imageryProvider.url;
    }
  },
  ready: {
    get: function() {
      return this._imageryProvider.ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._imageryProvider.readyPromise;
    }
  },
  rectangle: {
    get: function() {
      return this._imageryProvider.rectangle;
    }
  },
  tileWidth: {
    get: function() {
      return this._imageryProvider.tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      return this._imageryProvider.tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      return this._imageryProvider.maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      return this._imageryProvider.minimumLevel;
    }
  },
  tilingScheme: {
    get: function() {
      return this._imageryProvider.tilingScheme;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      return this._imageryProvider.tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._imageryProvider.errorEvent;
    }
  },
  credit: {
    get: function() {
      return this._imageryProvider.credit;
    }
  },
  proxy: {
    get: function() {
      return this._imageryProvider.proxy;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return this._imageryProvider.hasAlphaChannel;
    }
  }
});
MapboxImageryProvider.prototype.getTileCredits = function(x, y, level) {
  return void 0;
};
MapboxImageryProvider.prototype.requestImage = function(x, y, level, request) {
  return this._imageryProvider.requestImage(x, y, level, request);
};
MapboxImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  return this._imageryProvider.pickFeatures(x, y, level, longitude, latitude);
};
MapboxImageryProvider._defaultCredit = defaultCredit2;
var MapboxImageryProvider_default = MapboxImageryProvider;

// node_modules/cesium/Source/Scene/SingleTileImageryProvider.js
function SingleTileImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  const resource = Resource_default.createIfNeeded(options.url);
  const rectangle = defaultValue_default(options.rectangle, Rectangle_default.MAX_VALUE);
  const tilingScheme2 = new GeographicTilingScheme_default({
    rectangle,
    numberOfLevelZeroTilesX: 1,
    numberOfLevelZeroTilesY: 1,
    ellipsoid: options.ellipsoid
  });
  this._tilingScheme = tilingScheme2;
  this._resource = resource;
  this._image = void 0;
  this._texture = void 0;
  this._tileWidth = 0;
  this._tileHeight = 0;
  this._errorEvent = new Event_default();
  this._ready = false;
  this._readyPromise = defer_default();
  let credit = options.credit;
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  this._credit = credit;
  const that = this;
  let error;
  function success(image) {
    that._image = image;
    that._tileWidth = image.width;
    that._tileHeight = image.height;
    that._ready = true;
    that._readyPromise.resolve(true);
    TileProviderError_default.handleSuccess(that._errorEvent);
  }
  function failure(e2) {
    const message = `Failed to load image ${resource.url}.`;
    error = TileProviderError_default.handleError(
      error,
      that,
      that._errorEvent,
      message,
      0,
      0,
      0,
      doRequest,
      e2
    );
    if (!error.retry) {
      that._readyPromise.reject(new RuntimeError_default(message));
    }
  }
  function doRequest() {
    ImageryProvider_default.loadImage(null, resource).then(success).catch(failure);
  }
  doRequest();
}
Object.defineProperties(SingleTileImageryProvider.prototype, {
  url: {
    get: function() {
      return this._resource.url;
    }
  },
  proxy: {
    get: function() {
      return this._resource.proxy;
    }
  },
  tileWidth: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileWidth must not be called before the imagery provider is ready."
        );
      }
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileHeight must not be called before the imagery provider is ready."
        );
      }
      return this._tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "maximumLevel must not be called before the imagery provider is ready."
        );
      }
      return 0;
    }
  },
  minimumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "minimumLevel must not be called before the imagery provider is ready."
        );
      }
      return 0;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before the imagery provider is ready."
        );
      }
      return this._tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      return this._tilingScheme.rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileDiscardPolicy must not be called before the imagery provider is ready."
        );
      }
      return void 0;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return true;
    }
  }
});
SingleTileImageryProvider.prototype.getTileCredits = function(x, y, level) {
  return void 0;
};
SingleTileImageryProvider.prototype.requestImage = function(x, y, level, request) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "requestImage must not be called before the imagery provider is ready."
    );
  }
  if (!defined_default(this._image)) {
    return;
  }
  return Promise.resolve(this._image);
};
SingleTileImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  return void 0;
};
var SingleTileImageryProvider_default = SingleTileImageryProvider;

// node_modules/cesium/Source/Scene/TimeDynamicImagery.js
function TimeDynamicImagery(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.clock", options.clock);
  Check_default.typeOf.object("options.times", options.times);
  Check_default.typeOf.func(
    "options.requestImageFunction",
    options.requestImageFunction
  );
  Check_default.typeOf.func("options.reloadFunction", options.reloadFunction);
  this._tileCache = {};
  this._tilesRequestedForInterval = [];
  const clock = this._clock = options.clock;
  this._times = options.times;
  this._requestImageFunction = options.requestImageFunction;
  this._reloadFunction = options.reloadFunction;
  this._currentIntervalIndex = -1;
  clock.onTick.addEventListener(this._clockOnTick, this);
  this._clockOnTick(clock);
}
Object.defineProperties(TimeDynamicImagery.prototype, {
  clock: {
    get: function() {
      return this._clock;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._clock !== value) {
        this._clock = value;
        this._clockOnTick(value);
        this._reloadFunction();
      }
    }
  },
  times: {
    get: function() {
      return this._times;
    },
    set: function(value) {
      if (!defined_default(value)) {
        throw new DeveloperError_default("value is required.");
      }
      if (this._times !== value) {
        this._times = value;
        this._clockOnTick(this._clock);
        this._reloadFunction();
      }
    }
  },
  currentInterval: {
    get: function() {
      return this._times.get(this._currentIntervalIndex);
    }
  }
});
TimeDynamicImagery.prototype.getFromCache = function(x, y, level, request) {
  const key = getKey2(x, y, level);
  let result;
  const cache = this._tileCache[this._currentIntervalIndex];
  if (defined_default(cache) && defined_default(cache[key])) {
    const item = cache[key];
    result = item.promise.catch(function(e2) {
      request.state = item.request.state;
      throw e2;
    });
    delete cache[key];
  }
  return result;
};
TimeDynamicImagery.prototype.checkApproachingInterval = function(x, y, level, request) {
  const key = getKey2(x, y, level);
  const tilesRequestedForInterval = this._tilesRequestedForInterval;
  const approachingInterval = getApproachingInterval(this);
  const tile = {
    key,
    priorityFunction: request.priorityFunction
  };
  if (!defined_default(approachingInterval) || !addToCache(this, tile, approachingInterval)) {
    tilesRequestedForInterval.push(tile);
  }
  if (tilesRequestedForInterval.length >= 512) {
    tilesRequestedForInterval.splice(0, 256);
  }
};
TimeDynamicImagery.prototype._clockOnTick = function(clock) {
  const time = clock.currentTime;
  const times = this._times;
  const index2 = times.indexOf(time);
  const currentIntervalIndex = this._currentIntervalIndex;
  if (index2 !== currentIntervalIndex) {
    const currentCache = this._tileCache[currentIntervalIndex];
    for (const t in currentCache) {
      if (currentCache.hasOwnProperty(t)) {
        currentCache[t].request.cancel();
      }
    }
    delete this._tileCache[currentIntervalIndex];
    this._tilesRequestedForInterval = [];
    this._currentIntervalIndex = index2;
    this._reloadFunction();
    return;
  }
  const approachingInterval = getApproachingInterval(this);
  if (defined_default(approachingInterval)) {
    const tilesRequested = this._tilesRequestedForInterval;
    let success = true;
    while (success) {
      if (tilesRequested.length === 0) {
        break;
      }
      const tile = tilesRequested.pop();
      success = addToCache(this, tile, approachingInterval);
      if (!success) {
        tilesRequested.push(tile);
      }
    }
  }
};
function getKey2(x, y, level) {
  return `${x}-${y}-${level}`;
}
function getKeyElements(key) {
  const s2 = key.split("-");
  if (s2.length !== 3) {
    return void 0;
  }
  return {
    x: Number(s2[0]),
    y: Number(s2[1]),
    level: Number(s2[2])
  };
}
function getApproachingInterval(that) {
  const times = that._times;
  if (!defined_default(times)) {
    return void 0;
  }
  const clock = that._clock;
  const time = clock.currentTime;
  const isAnimating = clock.canAnimate && clock.shouldAnimate;
  const multiplier = clock.multiplier;
  if (!isAnimating && multiplier !== 0) {
    return void 0;
  }
  let seconds;
  let index2 = times.indexOf(time);
  if (index2 < 0) {
    return void 0;
  }
  const interval = times.get(index2);
  if (multiplier > 0) {
    seconds = JulianDate_default.secondsDifference(interval.stop, time);
    ++index2;
  } else {
    seconds = JulianDate_default.secondsDifference(interval.start, time);
    --index2;
  }
  seconds /= multiplier;
  return index2 >= 0 && seconds <= 5 ? times.get(index2) : void 0;
}
function addToCache(that, tile, interval) {
  const index2 = that._times.indexOf(interval.start);
  const tileCache = that._tileCache;
  let intervalTileCache = tileCache[index2];
  if (!defined_default(intervalTileCache)) {
    intervalTileCache = tileCache[index2] = {};
  }
  const key = tile.key;
  if (defined_default(intervalTileCache[key])) {
    return true;
  }
  const keyElements = getKeyElements(key);
  const request = new Request_default({
    throttle: false,
    throttleByServer: true,
    type: RequestType_default.IMAGERY,
    priorityFunction: tile.priorityFunction
  });
  const promise = that._requestImageFunction(
    keyElements.x,
    keyElements.y,
    keyElements.level,
    request,
    interval
  );
  if (!defined_default(promise)) {
    return false;
  }
  intervalTileCache[key] = {
    promise,
    request
  };
  return true;
}
var TimeDynamicImagery_default = TimeDynamicImagery;

// node_modules/cesium/Source/Scene/WebMapServiceImageryProvider.js
var includesReverseAxis = [
  3034,
  3035,
  3042,
  3043,
  3044
];
var excludesReverseAxis = [
  4471,
  4559
];
function WebMapServiceImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  if (!defined_default(options.layers)) {
    throw new DeveloperError_default("options.layers is required.");
  }
  if (defined_default(options.times) && !defined_default(options.clock)) {
    throw new DeveloperError_default(
      "options.times was specified, so options.clock is required."
    );
  }
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  this._getFeatureInfoUrl = defaultValue_default(
    options.getFeatureInfoUrl,
    options.url
  );
  const resource = Resource_default.createIfNeeded(options.url);
  const pickFeatureResource = Resource_default.createIfNeeded(this._getFeatureInfoUrl);
  resource.setQueryParameters(
    WebMapServiceImageryProvider.DefaultParameters,
    true
  );
  pickFeatureResource.setQueryParameters(
    WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters,
    true
  );
  if (defined_default(options.parameters)) {
    resource.setQueryParameters(objectToLowercase(options.parameters));
  }
  if (defined_default(options.getFeatureInfoParameters)) {
    pickFeatureResource.setQueryParameters(
      objectToLowercase(options.getFeatureInfoParameters)
    );
  }
  const that = this;
  this._reload = void 0;
  if (defined_default(options.times)) {
    this._timeDynamicImagery = new TimeDynamicImagery_default({
      clock: options.clock,
      times: options.times,
      requestImageFunction: function(x, y, level, request, interval) {
        return requestImage(that, x, y, level, request, interval);
      },
      reloadFunction: function() {
        if (defined_default(that._reload)) {
          that._reload();
        }
      }
    });
  }
  const parameters = {};
  parameters.layers = options.layers;
  parameters.bbox = "{westProjected},{southProjected},{eastProjected},{northProjected}";
  parameters.width = "{width}";
  parameters.height = "{height}";
  if (parseFloat(resource.queryParameters.version) >= 1.3) {
    parameters.crs = defaultValue_default(
      options.crs,
      options.tilingScheme && options.tilingScheme.projection instanceof WebMercatorProjection_default ? "EPSG:3857" : "CRS:84"
    );
    const parts = parameters.crs.split(":");
    if (parts[0] === "EPSG" && parts.length === 2) {
      const code = Number(parts[1]);
      if (code >= 4e3 && code < 5e3 && !excludesReverseAxis.includes(code) || includesReverseAxis.includes(code)) {
        parameters.bbox = "{southProjected},{westProjected},{northProjected},{eastProjected}";
      }
    }
  } else {
    parameters.srs = defaultValue_default(
      options.srs,
      options.tilingScheme && options.tilingScheme.projection instanceof WebMercatorProjection_default ? "EPSG:3857" : "EPSG:4326"
    );
  }
  resource.setQueryParameters(parameters, true);
  pickFeatureResource.setQueryParameters(parameters, true);
  const pickFeatureParams = {
    query_layers: options.layers,
    info_format: "{format}"
  };
  if (parseFloat(pickFeatureResource.queryParameters.version) >= 1.3) {
    pickFeatureParams.i = "{i}";
    pickFeatureParams.j = "{j}";
  } else {
    pickFeatureParams.x = "{i}";
    pickFeatureParams.y = "{j}";
  }
  pickFeatureResource.setQueryParameters(pickFeatureParams, true);
  this._resource = resource;
  this._pickFeaturesResource = pickFeatureResource;
  this._layers = options.layers;
  this._tileProvider = new UrlTemplateImageryProvider_default({
    url: resource,
    pickFeaturesUrl: pickFeatureResource,
    tilingScheme: defaultValue_default(
      options.tilingScheme,
      new GeographicTilingScheme_default({ ellipsoid: options.ellipsoid })
    ),
    rectangle: options.rectangle,
    tileWidth: options.tileWidth,
    tileHeight: options.tileHeight,
    minimumLevel: options.minimumLevel,
    maximumLevel: options.maximumLevel,
    subdomains: options.subdomains,
    tileDiscardPolicy: options.tileDiscardPolicy,
    credit: options.credit,
    getFeatureInfoFormats: defaultValue_default(
      options.getFeatureInfoFormats,
      WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats
    ),
    enablePickFeatures: options.enablePickFeatures
  });
}
function requestImage(imageryProvider, col, row, level, request, interval) {
  const dynamicIntervalData = defined_default(interval) ? interval.data : void 0;
  const tileProvider = imageryProvider._tileProvider;
  if (defined_default(dynamicIntervalData)) {
    tileProvider._resource.setQueryParameters(dynamicIntervalData);
  }
  return tileProvider.requestImage(col, row, level, request);
}
function pickFeatures(imageryProvider, x, y, level, longitude, latitude, interval) {
  const dynamicIntervalData = defined_default(interval) ? interval.data : void 0;
  const tileProvider = imageryProvider._tileProvider;
  if (defined_default(dynamicIntervalData)) {
    tileProvider._pickFeaturesResource.setQueryParameters(dynamicIntervalData);
  }
  return tileProvider.pickFeatures(x, y, level, longitude, latitude);
}
Object.defineProperties(WebMapServiceImageryProvider.prototype, {
  url: {
    get: function() {
      return this._resource._url;
    }
  },
  proxy: {
    get: function() {
      return this._resource.proxy;
    }
  },
  layers: {
    get: function() {
      return this._layers;
    }
  },
  tileWidth: {
    get: function() {
      return this._tileProvider.tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      return this._tileProvider.tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      return this._tileProvider.maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      return this._tileProvider.minimumLevel;
    }
  },
  tilingScheme: {
    get: function() {
      return this._tileProvider.tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      return this._tileProvider.rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      return this._tileProvider.tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._tileProvider.errorEvent;
    }
  },
  ready: {
    get: function() {
      return this._tileProvider.ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._tileProvider.readyPromise;
    }
  },
  credit: {
    get: function() {
      return this._tileProvider.credit;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return this._tileProvider.hasAlphaChannel;
    }
  },
  enablePickFeatures: {
    get: function() {
      return this._tileProvider.enablePickFeatures;
    },
    set: function(enablePickFeatures) {
      this._tileProvider.enablePickFeatures = enablePickFeatures;
    }
  },
  clock: {
    get: function() {
      return this._timeDynamicImagery.clock;
    },
    set: function(value) {
      this._timeDynamicImagery.clock = value;
    }
  },
  times: {
    get: function() {
      return this._timeDynamicImagery.times;
    },
    set: function(value) {
      this._timeDynamicImagery.times = value;
    }
  },
  getFeatureInfoUrl: {
    get: function() {
      return this._getFeatureInfoUrl;
    }
  }
});
WebMapServiceImageryProvider.prototype.getTileCredits = function(x, y, level) {
  return this._tileProvider.getTileCredits(x, y, level);
};
WebMapServiceImageryProvider.prototype.requestImage = function(x, y, level, request) {
  let result;
  const timeDynamicImagery = this._timeDynamicImagery;
  let currentInterval;
  if (defined_default(timeDynamicImagery)) {
    currentInterval = timeDynamicImagery.currentInterval;
    result = timeDynamicImagery.getFromCache(x, y, level, request);
  }
  if (!defined_default(result)) {
    result = requestImage(this, x, y, level, request, currentInterval);
  }
  if (defined_default(result) && defined_default(timeDynamicImagery)) {
    timeDynamicImagery.checkApproachingInterval(x, y, level, request);
  }
  return result;
};
WebMapServiceImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  const timeDynamicImagery = this._timeDynamicImagery;
  const currentInterval = defined_default(timeDynamicImagery) ? timeDynamicImagery.currentInterval : void 0;
  return pickFeatures(this, x, y, level, longitude, latitude, currentInterval);
};
WebMapServiceImageryProvider.DefaultParameters = Object.freeze({
  service: "WMS",
  version: "1.1.1",
  request: "GetMap",
  styles: "",
  format: "image/jpeg"
});
WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters = Object.freeze({
  service: "WMS",
  version: "1.1.1",
  request: "GetFeatureInfo"
});
WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats = Object.freeze([
  Object.freeze(new GetFeatureInfoFormat_default("json", "application/json")),
  Object.freeze(new GetFeatureInfoFormat_default("xml", "text/xml")),
  Object.freeze(new GetFeatureInfoFormat_default("text", "text/html"))
]);
function objectToLowercase(obj) {
  const result = {};
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      result[key.toLowerCase()] = obj[key];
    }
  }
  return result;
}
var WebMapServiceImageryProvider_default = WebMapServiceImageryProvider;

// node_modules/cesium/Source/Scene/WebMapTileServiceImageryProvider.js
var defaultParameters = Object.freeze({
  service: "WMTS",
  version: "1.0.0",
  request: "GetTile"
});
function WebMapTileServiceImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.url)) {
    throw new DeveloperError_default("options.url is required.");
  }
  if (!defined_default(options.layer)) {
    throw new DeveloperError_default("options.layer is required.");
  }
  if (!defined_default(options.style)) {
    throw new DeveloperError_default("options.style is required.");
  }
  if (!defined_default(options.tileMatrixSetID)) {
    throw new DeveloperError_default("options.tileMatrixSetID is required.");
  }
  if (defined_default(options.times) && !defined_default(options.clock)) {
    throw new DeveloperError_default(
      "options.times was specified, so options.clock is required."
    );
  }
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  const resource = Resource_default.createIfNeeded(options.url);
  const style = options.style;
  const tileMatrixSetID = options.tileMatrixSetID;
  const url2 = resource.url;
  const bracketMatch = url2.match(/{/g);
  if (!defined_default(bracketMatch) || bracketMatch.length === 1 && /{s}/.test(url2)) {
    resource.setQueryParameters(defaultParameters);
    this._useKvp = true;
  } else {
    const templateValues = {
      style,
      Style: style,
      TileMatrixSet: tileMatrixSetID
    };
    resource.setTemplateValues(templateValues);
    this._useKvp = false;
  }
  this._resource = resource;
  this._layer = options.layer;
  this._style = style;
  this._tileMatrixSetID = tileMatrixSetID;
  this._tileMatrixLabels = options.tileMatrixLabels;
  this._format = defaultValue_default(options.format, "image/jpeg");
  this._tileDiscardPolicy = options.tileDiscardPolicy;
  this._tilingScheme = defined_default(options.tilingScheme) ? options.tilingScheme : new WebMercatorTilingScheme_default({ ellipsoid: options.ellipsoid });
  this._tileWidth = defaultValue_default(options.tileWidth, 256);
  this._tileHeight = defaultValue_default(options.tileHeight, 256);
  this._minimumLevel = defaultValue_default(options.minimumLevel, 0);
  this._maximumLevel = options.maximumLevel;
  this._rectangle = defaultValue_default(
    options.rectangle,
    this._tilingScheme.rectangle
  );
  this._dimensions = options.dimensions;
  const that = this;
  this._reload = void 0;
  if (defined_default(options.times)) {
    this._timeDynamicImagery = new TimeDynamicImagery_default({
      clock: options.clock,
      times: options.times,
      requestImageFunction: function(x, y, level, request, interval) {
        return requestImage2(that, x, y, level, request, interval);
      },
      reloadFunction: function() {
        if (defined_default(that._reload)) {
          that._reload();
        }
      }
    });
  }
  this._readyPromise = Promise.resolve(true);
  const swTile = this._tilingScheme.positionToTileXY(
    Rectangle_default.southwest(this._rectangle),
    this._minimumLevel
  );
  const neTile = this._tilingScheme.positionToTileXY(
    Rectangle_default.northeast(this._rectangle),
    this._minimumLevel
  );
  const tileCount = (Math.abs(neTile.x - swTile.x) + 1) * (Math.abs(neTile.y - swTile.y) + 1);
  if (tileCount > 4) {
    throw new DeveloperError_default(
      `The imagery provider's rectangle and minimumLevel indicate that there are ${tileCount} tiles at the minimum level. Imagery providers with more than four tiles at the minimum level are not supported.`
    );
  }
  this._errorEvent = new Event_default();
  const credit = options.credit;
  this._credit = typeof credit === "string" ? new Credit_default(credit) : credit;
  this._subdomains = options.subdomains;
  if (Array.isArray(this._subdomains)) {
    this._subdomains = this._subdomains.slice();
  } else if (defined_default(this._subdomains) && this._subdomains.length > 0) {
    this._subdomains = this._subdomains.split("");
  } else {
    this._subdomains = ["a", "b", "c"];
  }
}
function requestImage2(imageryProvider, col, row, level, request, interval) {
  const labels = imageryProvider._tileMatrixLabels;
  const tileMatrix = defined_default(labels) ? labels[level] : level.toString();
  const subdomains = imageryProvider._subdomains;
  const staticDimensions = imageryProvider._dimensions;
  const dynamicIntervalData = defined_default(interval) ? interval.data : void 0;
  let resource;
  let templateValues;
  if (!imageryProvider._useKvp) {
    templateValues = {
      TileMatrix: tileMatrix,
      TileRow: row.toString(),
      TileCol: col.toString(),
      s: subdomains[(col + row + level) % subdomains.length]
    };
    resource = imageryProvider._resource.getDerivedResource({
      request
    });
    resource.setTemplateValues(templateValues);
    if (defined_default(staticDimensions)) {
      resource.setTemplateValues(staticDimensions);
    }
    if (defined_default(dynamicIntervalData)) {
      resource.setTemplateValues(dynamicIntervalData);
    }
  } else {
    let query = {};
    query.tilematrix = tileMatrix;
    query.layer = imageryProvider._layer;
    query.style = imageryProvider._style;
    query.tilerow = row;
    query.tilecol = col;
    query.tilematrixset = imageryProvider._tileMatrixSetID;
    query.format = imageryProvider._format;
    if (defined_default(staticDimensions)) {
      query = combine_default(query, staticDimensions);
    }
    if (defined_default(dynamicIntervalData)) {
      query = combine_default(query, dynamicIntervalData);
    }
    templateValues = {
      s: subdomains[(col + row + level) % subdomains.length]
    };
    resource = imageryProvider._resource.getDerivedResource({
      queryParameters: query,
      request
    });
    resource.setTemplateValues(templateValues);
  }
  return ImageryProvider_default.loadImage(imageryProvider, resource);
}
Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
  url: {
    get: function() {
      return this._resource.url;
    }
  },
  proxy: {
    get: function() {
      return this._resource.proxy;
    }
  },
  tileWidth: {
    get: function() {
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      return this._tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      return this._maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      return this._minimumLevel;
    }
  },
  tilingScheme: {
    get: function() {
      return this._tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      return this._rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      return this._tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  format: {
    get: function() {
      return this._format;
    }
  },
  ready: {
    value: true
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  credit: {
    get: function() {
      return this._credit;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return true;
    }
  },
  clock: {
    get: function() {
      return this._timeDynamicImagery.clock;
    },
    set: function(value) {
      this._timeDynamicImagery.clock = value;
    }
  },
  times: {
    get: function() {
      return this._timeDynamicImagery.times;
    },
    set: function(value) {
      this._timeDynamicImagery.times = value;
    }
  },
  dimensions: {
    get: function() {
      return this._dimensions;
    },
    set: function(value) {
      if (this._dimensions !== value) {
        this._dimensions = value;
        if (defined_default(this._reload)) {
          this._reload();
        }
      }
    }
  }
});
WebMapTileServiceImageryProvider.prototype.getTileCredits = function(x, y, level) {
  return void 0;
};
WebMapTileServiceImageryProvider.prototype.requestImage = function(x, y, level, request) {
  let result;
  const timeDynamicImagery = this._timeDynamicImagery;
  let currentInterval;
  if (defined_default(timeDynamicImagery)) {
    currentInterval = timeDynamicImagery.currentInterval;
    result = timeDynamicImagery.getFromCache(x, y, level, request);
  }
  if (!defined_default(result)) {
    result = requestImage2(this, x, y, level, request, currentInterval);
  }
  if (defined_default(result) && defined_default(timeDynamicImagery)) {
    timeDynamicImagery.checkApproachingInterval(x, y, level, request);
  }
  return result;
};
WebMapTileServiceImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  return void 0;
};
var WebMapTileServiceImageryProvider_default = WebMapTileServiceImageryProvider;

// node_modules/cesium/Source/Scene/IonImageryProvider.js
function createFactory(Type) {
  return function(options) {
    return new Type(options);
  };
}
var ImageryProviderMapping = {
  ARCGIS_MAPSERVER: createFactory(ArcGisMapServerImageryProvider_default),
  BING: createFactory(BingMapsImageryProvider_default),
  GOOGLE_EARTH: createFactory(GoogleEarthEnterpriseMapsProvider_default),
  MAPBOX: createFactory(MapboxImageryProvider_default),
  SINGLE_TILE: createFactory(SingleTileImageryProvider_default),
  TMS: createFactory(TileMapServiceImageryProvider_default),
  URL_TEMPLATE: createFactory(UrlTemplateImageryProvider_default),
  WMS: createFactory(WebMapServiceImageryProvider_default),
  WMTS: createFactory(WebMapTileServiceImageryProvider_default)
};
function IonImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const assetId = options.assetId;
  Check_default.typeOf.number("options.assetId", assetId);
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  this._ready = false;
  this._tileCredits = void 0;
  this._errorEvent = new Event_default();
  const that = this;
  const endpointResource = IonResource_default._createEndpointResource(
    assetId,
    options
  );
  const cacheKey = options.assetId.toString() + options.accessToken + options.server;
  let promise = IonImageryProvider._endpointCache[cacheKey];
  if (!defined_default(promise)) {
    promise = endpointResource.fetchJson();
    IonImageryProvider._endpointCache[cacheKey] = promise;
  }
  this._readyPromise = promise.then(function(endpoint) {
    if (endpoint.type !== "IMAGERY") {
      return Promise.reject(
        new RuntimeError_default(`Cesium ion asset ${assetId} is not an imagery asset.`)
      );
    }
    let imageryProvider;
    const externalType = endpoint.externalType;
    if (!defined_default(externalType)) {
      imageryProvider = new TileMapServiceImageryProvider_default({
        url: new IonResource_default(endpoint, endpointResource)
      });
    } else {
      const factory = ImageryProviderMapping[externalType];
      if (!defined_default(factory)) {
        return Promise.reject(
          new RuntimeError_default(
            `Unrecognized Cesium ion imagery type: ${externalType}`
          )
        );
      }
      imageryProvider = factory(endpoint.options);
    }
    that._tileCredits = IonResource_default.getCreditsFromEndpoint(
      endpoint,
      endpointResource
    );
    imageryProvider.errorEvent.addEventListener(function(tileProviderError) {
      tileProviderError.provider = that;
      that._errorEvent.raiseEvent(tileProviderError);
    });
    that._imageryProvider = imageryProvider;
    return imageryProvider.readyPromise.then(function() {
      that._ready = true;
      return true;
    });
  });
}
Object.defineProperties(IonImageryProvider.prototype, {
  ready: {
    get: function() {
      return this._ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  rectangle: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileHeight must not be called before the imagery provider is ready."
        );
      }
      return this._imageryProvider.rectangle;
    }
  },
  tileWidth: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileWidth must not be called before the imagery provider is ready."
        );
      }
      return this._imageryProvider.tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileHeight must not be called before the imagery provider is ready."
        );
      }
      return this._imageryProvider.tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "maximumLevel must not be called before the imagery provider is ready."
        );
      }
      return this._imageryProvider.maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "minimumLevel must not be called before the imagery provider is ready."
        );
      }
      return this._imageryProvider.minimumLevel;
    }
  },
  tilingScheme: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tilingScheme must not be called before the imagery provider is ready."
        );
      }
      return this._imageryProvider.tilingScheme;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "tileDiscardPolicy must not be called before the imagery provider is ready."
        );
      }
      return this._imageryProvider.tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  credit: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "credit must not be called before the imagery provider is ready."
        );
      }
      return this._imageryProvider.credit;
    }
  },
  hasAlphaChannel: {
    get: function() {
      if (!this._ready) {
        throw new DeveloperError_default(
          "hasAlphaChannel must not be called before the imagery provider is ready."
        );
      }
      return this._imageryProvider.hasAlphaChannel;
    },
    proxy: {
      get: function() {
        return void 0;
      }
    }
  }
});
IonImageryProvider.prototype.getTileCredits = function(x, y, level) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "getTileCredits must not be called before the imagery provider is ready."
    );
  }
  const innerCredits = this._imageryProvider.getTileCredits(x, y, level);
  if (!defined_default(innerCredits)) {
    return this._tileCredits;
  }
  return this._tileCredits.concat(innerCredits);
};
IonImageryProvider.prototype.requestImage = function(x, y, level, request) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "requestImage must not be called before the imagery provider is ready."
    );
  }
  return this._imageryProvider.requestImage(x, y, level, request);
};
IonImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  if (!this._ready) {
    throw new DeveloperError_default(
      "pickFeatures must not be called before the imagery provider is ready."
    );
  }
  return this._imageryProvider.pickFeatures(x, y, level, longitude, latitude);
};
IonImageryProvider._endpointCache = {};
var IonImageryProvider_default = IonImageryProvider;

// node_modules/cesium/Source/Scene/IonWorldImageryStyle.js
var IonWorldImageryStyle = {
  AERIAL: 2,
  AERIAL_WITH_LABELS: 3,
  ROAD: 4
};
var IonWorldImageryStyle_default = Object.freeze(IonWorldImageryStyle);

// node_modules/cesium/Source/Scene/JobScheduler.js
function JobTypeBudget(total) {
  this._total = total;
  this.usedThisFrame = 0;
  this.stolenFromMeThisFrame = 0;
  this.starvedThisFrame = false;
  this.starvedLastFrame = false;
}
Object.defineProperties(JobTypeBudget.prototype, {
  total: {
    get: function() {
      return this._total;
    }
  }
});
function JobScheduler(budgets) {
  if (defined_default(budgets) && budgets.length !== JobType_default.NUMBER_OF_JOB_TYPES) {
    throw new DeveloperError_default(
      "A budget must be specified for each job type; budgets.length should equal JobType.NUMBER_OF_JOB_TYPES."
    );
  }
  const jobBudgets = new Array(JobType_default.NUMBER_OF_JOB_TYPES);
  jobBudgets[JobType_default.TEXTURE] = new JobTypeBudget(
    defined_default(budgets) ? budgets[JobType_default.TEXTURE] : 10
  );
  jobBudgets[JobType_default.PROGRAM] = new JobTypeBudget(
    defined_default(budgets) ? budgets[JobType_default.PROGRAM] : 10
  );
  jobBudgets[JobType_default.BUFFER] = new JobTypeBudget(
    defined_default(budgets) ? budgets[JobType_default.BUFFER] : 30
  );
  const length3 = jobBudgets.length;
  let i2;
  let totalBudget = 0;
  for (i2 = 0; i2 < length3; ++i2) {
    totalBudget += jobBudgets[i2].total;
  }
  const executedThisFrame = new Array(length3);
  for (i2 = 0; i2 < length3; ++i2) {
    executedThisFrame[i2] = false;
  }
  this._totalBudget = totalBudget;
  this._totalUsedThisFrame = 0;
  this._budgets = jobBudgets;
  this._executedThisFrame = executedThisFrame;
}
JobScheduler.getTimestamp = getTimestamp_default;
Object.defineProperties(JobScheduler.prototype, {
  totalBudget: {
    get: function() {
      return this._totalBudget;
    }
  }
});
JobScheduler.prototype.disableThisFrame = function() {
  this._totalUsedThisFrame = this._totalBudget;
};
JobScheduler.prototype.resetBudgets = function() {
  const budgets = this._budgets;
  const length3 = budgets.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const budget = budgets[i2];
    budget.starvedLastFrame = budget.starvedThisFrame;
    budget.starvedThisFrame = false;
    budget.usedThisFrame = 0;
    budget.stolenFromMeThisFrame = 0;
  }
  this._totalUsedThisFrame = 0;
};
JobScheduler.prototype.execute = function(job, jobType) {
  const budgets = this._budgets;
  const budget = budgets[jobType];
  const progressThisFrame = this._executedThisFrame[jobType];
  if (this._totalUsedThisFrame >= this._totalBudget && progressThisFrame) {
    budget.starvedThisFrame = true;
    return false;
  }
  let stolenBudget;
  if (budget.usedThisFrame + budget.stolenFromMeThisFrame >= budget.total) {
    const length3 = budgets.length;
    let i2;
    for (i2 = 0; i2 < length3; ++i2) {
      stolenBudget = budgets[i2];
      if (stolenBudget.usedThisFrame + stolenBudget.stolenFromMeThisFrame < stolenBudget.total && !stolenBudget.starvedLastFrame) {
        break;
      }
    }
    if (i2 === length3 && progressThisFrame) {
      return false;
    }
    if (progressThisFrame) {
      budget.starvedThisFrame = true;
    }
  }
  const startTime = JobScheduler.getTimestamp();
  job.execute();
  const duration = JobScheduler.getTimestamp() - startTime;
  this._totalUsedThisFrame += duration;
  if (stolenBudget) {
    stolenBudget.stolenFromMeThisFrame += duration;
  } else {
    budget.usedThisFrame += duration;
  }
  this._executedThisFrame[jobType] = true;
  return true;
};
var JobScheduler_default = JobScheduler;

// node_modules/cesium/Source/Scene/Light.js
function Light() {
}
Object.defineProperties(Light.prototype, {
  color: {
    get: DeveloperError_default.throwInstantiationError
  },
  intensity: {
    get: DeveloperError_default.throwInstantiationError
  }
});
var Light_default = Light;

// node_modules/cesium/Source/Scene/MapboxStyleImageryProvider.js
var trailingSlashRegex2 = /\/$/;
var defaultCredit3 = new Credit_default(
  '&copy; <a href="https://www.mapbox.com/about/maps/">Mapbox</a> &copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> <strong><a href="https://www.mapbox.com/map-feedback/">Improve this map</a></strong>'
);
function MapboxStyleImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const styleId = options.styleId;
  if (!defined_default(styleId)) {
    throw new DeveloperError_default("options.styleId is required.");
  }
  const accessToken = options.accessToken;
  if (!defined_default(accessToken)) {
    throw new DeveloperError_default("options.accessToken is required.");
  }
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
  const resource = Resource_default.createIfNeeded(
    defaultValue_default(options.url, "https://api.mapbox.com/styles/v1/")
  );
  this._styleId = styleId;
  this._accessToken = accessToken;
  const tilesize = defaultValue_default(options.tilesize, 512);
  this._tilesize = tilesize;
  const username = defaultValue_default(options.username, "mapbox");
  this._username = username;
  const scaleFactor = defined_default(options.scaleFactor) ? "@2x" : "";
  let templateUrl = resource.getUrlComponent();
  if (!trailingSlashRegex2.test(templateUrl)) {
    templateUrl += "/";
  }
  templateUrl += `${this._username}/${styleId}/tiles/${this._tilesize}/{z}/{x}/{y}${scaleFactor}`;
  resource.url = templateUrl;
  resource.setQueryParameters({
    access_token: accessToken
  });
  let credit;
  if (defined_default(options.credit)) {
    credit = options.credit;
    if (typeof credit === "string") {
      credit = new Credit_default(credit);
    }
  } else {
    credit = defaultCredit3;
  }
  this._resource = resource;
  this._imageryProvider = new UrlTemplateImageryProvider_default({
    url: resource,
    credit,
    ellipsoid: options.ellipsoid,
    minimumLevel: options.minimumLevel,
    maximumLevel: options.maximumLevel,
    rectangle: options.rectangle
  });
}
Object.defineProperties(MapboxStyleImageryProvider.prototype, {
  url: {
    get: function() {
      return this._imageryProvider.url;
    }
  },
  ready: {
    get: function() {
      return this._imageryProvider.ready;
    }
  },
  readyPromise: {
    get: function() {
      return this._imageryProvider.readyPromise;
    }
  },
  rectangle: {
    get: function() {
      return this._imageryProvider.rectangle;
    }
  },
  tileWidth: {
    get: function() {
      return this._imageryProvider.tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      return this._imageryProvider.tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      return this._imageryProvider.maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      return this._imageryProvider.minimumLevel;
    }
  },
  tilingScheme: {
    get: function() {
      return this._imageryProvider.tilingScheme;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      return this._imageryProvider.tileDiscardPolicy;
    }
  },
  errorEvent: {
    get: function() {
      return this._imageryProvider.errorEvent;
    }
  },
  credit: {
    get: function() {
      return this._imageryProvider.credit;
    }
  },
  proxy: {
    get: function() {
      return this._imageryProvider.proxy;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return this._imageryProvider.hasAlphaChannel;
    }
  }
});
MapboxStyleImageryProvider.prototype.getTileCredits = function(x, y, level) {
  return void 0;
};
MapboxStyleImageryProvider.prototype.requestImage = function(x, y, level, request) {
  return this._imageryProvider.requestImage(x, y, level, request);
};
MapboxStyleImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  return this._imageryProvider.pickFeatures(x, y, level, longitude, latitude);
};
MapboxStyleImageryProvider._defaultCredit = defaultCredit3;
var MapboxStyleImageryProvider_default = MapboxStyleImageryProvider;

// node_modules/cesium/Source/Scene/Moon.js
function Moon(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let url2 = options.textureUrl;
  if (!defined_default(url2)) {
    url2 = buildModuleUrl_default("Assets/Textures/moonSmall.jpg");
  }
  this.show = defaultValue_default(options.show, true);
  this.textureUrl = url2;
  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.MOON);
  this.onlySunLighting = defaultValue_default(options.onlySunLighting, true);
  this._ellipsoidPrimitive = new EllipsoidPrimitive_default({
    radii: this.ellipsoid.radii,
    material: Material_default.fromType(Material_default.ImageType),
    depthTestEnabled: false,
    _owner: this
  });
  this._ellipsoidPrimitive.material.translucent = false;
  this._axes = new IauOrientationAxes_default();
}
Object.defineProperties(Moon.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  }
});
var icrfToFixed = new Matrix3_default();
var rotationScratch3 = new Matrix3_default();
var translationScratch2 = new Cartesian3_default();
var scratchCommandList2 = [];
Moon.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  const ellipsoidPrimitive = this._ellipsoidPrimitive;
  ellipsoidPrimitive.material.uniforms.image = this.textureUrl;
  ellipsoidPrimitive.onlySunLighting = this.onlySunLighting;
  const date = frameState.time;
  if (!defined_default(Transforms_default.computeIcrfToFixedMatrix(date, icrfToFixed))) {
    Transforms_default.computeTemeToPseudoFixedMatrix(date, icrfToFixed);
  }
  const rotation = this._axes.evaluate(date, rotationScratch3);
  Matrix3_default.transpose(rotation, rotation);
  Matrix3_default.multiply(icrfToFixed, rotation, rotation);
  const translation3 = Simon1994PlanetaryPositions_default.computeMoonPositionInEarthInertialFrame(
    date,
    translationScratch2
  );
  Matrix3_default.multiplyByVector(icrfToFixed, translation3, translation3);
  Matrix4_default.fromRotationTranslation(
    rotation,
    translation3,
    ellipsoidPrimitive.modelMatrix
  );
  const savedCommandList = frameState.commandList;
  frameState.commandList = scratchCommandList2;
  scratchCommandList2.length = 0;
  ellipsoidPrimitive.update(frameState);
  frameState.commandList = savedCommandList;
  return scratchCommandList2.length === 1 ? scratchCommandList2[0] : void 0;
};
Moon.prototype.isDestroyed = function() {
  return false;
};
Moon.prototype.destroy = function() {
  this._ellipsoidPrimitive = this._ellipsoidPrimitive && this._ellipsoidPrimitive.destroy();
  return destroyObject_default(this);
};
var Moon_default = Moon;

// node_modules/cesium/Source/Scene/NeverTileDiscardPolicy.js
function NeverTileDiscardPolicy(options) {
}
NeverTileDiscardPolicy.prototype.isReady = function() {
  return true;
};
NeverTileDiscardPolicy.prototype.shouldDiscardImage = function(image) {
  return false;
};
var NeverTileDiscardPolicy_default = NeverTileDiscardPolicy;

// node_modules/cesium/Source/Shaders/AdjustTranslucentFS.js
var AdjustTranslucentFS_default = "#ifdef MRT\n#extension GL_EXT_draw_buffers : enable\n#endif\n\nuniform vec4 u_bgColor;\nuniform sampler2D u_depthTexture;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    if (texture2D(u_depthTexture, v_textureCoordinates).r < 1.0)\n    {\n#ifdef MRT\n        gl_FragData[0] = u_bgColor;\n        gl_FragData[1] = vec4(u_bgColor.a);\n#else\n        gl_FragColor = u_bgColor;\n#endif\n        return;\n    }\n    \n    discard;\n}\n";

// node_modules/cesium/Source/Shaders/CompositeOITFS.js
var CompositeOITFS_default = "/**\n * Compositing for Weighted Blended Order-Independent Transparency. See:\n * - http://jcgt.org/published/0002/02/09/\n * - http://casual-effects.blogspot.com/2014/03/weighted-blended-order-independent.html\n */\n\nuniform sampler2D u_opaque;\nuniform sampler2D u_accumulation;\nuniform sampler2D u_revealage;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    vec4 opaque = texture2D(u_opaque, v_textureCoordinates);\n    vec4 accum = texture2D(u_accumulation, v_textureCoordinates);\n    float r = texture2D(u_revealage, v_textureCoordinates).r;\n\n#ifdef MRT\n    vec4 transparent = vec4(accum.rgb / clamp(r, 1e-4, 5e4), accum.a);\n#else\n    vec4 transparent = vec4(accum.rgb / clamp(accum.a, 1e-4, 5e4), r);\n#endif\n\n    gl_FragColor = (1.0 - transparent.a) * transparent + transparent.a * opaque;\n\n    if (opaque != czm_backgroundColor)\n    {\n        gl_FragColor.a = 1.0;\n    }\n}\n";

// node_modules/cesium/Source/Scene/OIT.js
function OIT(context) {
  this._numSamples = 1;
  this._translucentMultipassSupport = false;
  this._translucentMRTSupport = false;
  const extensionsSupported = context.colorBufferFloat && context.depthTexture;
  this._translucentMRTSupport = context.drawBuffers && extensionsSupported;
  this._translucentMultipassSupport = !this._translucentMRTSupport && extensionsSupported;
  this._opaqueFBO = void 0;
  this._opaqueTexture = void 0;
  this._depthStencilTexture = void 0;
  this._accumulationTexture = void 0;
  this._translucentFBO = new FramebufferManager_default({
    colorAttachmentsLength: this._translucentMRTSupport ? 2 : 1,
    createColorAttachments: false,
    createDepthAttachments: false,
    depth: true
  });
  this._alphaFBO = new FramebufferManager_default({
    createColorAttachments: false,
    createDepthAttachments: false,
    depth: true
  });
  this._adjustTranslucentFBO = new FramebufferManager_default({
    colorAttachmentsLength: this._translucentMRTSupport ? 2 : 1,
    createColorAttachments: false
  });
  this._adjustAlphaFBO = new FramebufferManager_default({
    createColorAttachments: false
  });
  this._opaqueClearCommand = new ClearCommand_default({
    color: new Color_default(0, 0, 0, 0),
    owner: this
  });
  this._translucentMRTClearCommand = new ClearCommand_default({
    color: new Color_default(0, 0, 0, 1),
    owner: this
  });
  this._translucentMultipassClearCommand = new ClearCommand_default({
    color: new Color_default(0, 0, 0, 0),
    owner: this
  });
  this._alphaClearCommand = new ClearCommand_default({
    color: new Color_default(1, 1, 1, 1),
    owner: this
  });
  this._translucentRenderStateCache = {};
  this._alphaRenderStateCache = {};
  this._compositeCommand = void 0;
  this._adjustTranslucentCommand = void 0;
  this._adjustAlphaCommand = void 0;
  this._viewport = new BoundingRectangle_default();
  this._rs = void 0;
  this._useScissorTest = false;
  this._scissorRectangle = void 0;
  this._useHDR = false;
}
function destroyTextures(oit) {
  oit._accumulationTexture = oit._accumulationTexture && !oit._accumulationTexture.isDestroyed() && oit._accumulationTexture.destroy();
  oit._revealageTexture = oit._revealageTexture && !oit._revealageTexture.isDestroyed() && oit._revealageTexture.destroy();
}
function destroyFramebuffers3(oit) {
  oit._translucentFBO.destroy();
  oit._alphaFBO.destroy();
  oit._adjustTranslucentFBO.destroy();
  oit._adjustAlphaFBO.destroy();
}
function destroyResources2(oit) {
  destroyTextures(oit);
  destroyFramebuffers3(oit);
}
function updateTextures(oit, context, width, height) {
  destroyTextures(oit);
  oit._accumulationTexture = new Texture_default({
    context,
    width,
    height,
    pixelFormat: PixelFormat_default.RGBA,
    pixelDatatype: PixelDatatype_default.FLOAT
  });
  const source = new Float32Array(width * height * 4);
  oit._revealageTexture = new Texture_default({
    context,
    pixelFormat: PixelFormat_default.RGBA,
    pixelDatatype: PixelDatatype_default.FLOAT,
    source: {
      arrayBufferView: source,
      width,
      height
    },
    flipY: false
  });
}
function updateFramebuffers(oit, context) {
  destroyFramebuffers3(oit);
  const completeFBO = WebGLConstants_default.FRAMEBUFFER_COMPLETE;
  let supported = true;
  const width = oit._accumulationTexture.width;
  const height = oit._accumulationTexture.height;
  if (oit._translucentMRTSupport) {
    oit._translucentFBO.setColorTexture(oit._accumulationTexture, 0);
    oit._translucentFBO.setColorTexture(oit._revealageTexture, 1);
    oit._translucentFBO.setDepthStencilTexture(oit._depthStencilTexture);
    oit._translucentFBO.update(context, width, height);
    oit._adjustTranslucentFBO.setColorTexture(oit._accumulationTexture, 0);
    oit._adjustTranslucentFBO.setColorTexture(oit._revealageTexture, 1);
    oit._adjustTranslucentFBO.update(context, width, height);
    if (oit._translucentFBO.status !== completeFBO || oit._adjustTranslucentFBO.status !== completeFBO) {
      destroyFramebuffers3(oit);
      oit._translucentMRTSupport = false;
    }
  }
  if (!oit._translucentMRTSupport) {
    oit._translucentFBO.setColorTexture(oit._accumulationTexture);
    oit._translucentFBO.setDepthStencilTexture(oit._depthStencilTexture);
    oit._translucentFBO.update(context, width, height);
    oit._alphaFBO.setColorTexture(oit._revealageTexture);
    oit._alphaFBO.setDepthStencilTexture(oit._depthStencilTexture);
    oit._alphaFBO.update(context, width, height);
    oit._adjustTranslucentFBO.setColorTexture(oit._accumulationTexture);
    oit._adjustTranslucentFBO.update(context, width, height);
    oit._adjustAlphaFBO.setColorTexture(oit._revealageTexture);
    oit._adjustAlphaFBO.update(context, width, height);
    const translucentComplete = oit._translucentFBO.status === completeFBO;
    const alphaComplete = oit._alphaFBO.status === completeFBO;
    const adjustTranslucentComplete = oit._adjustTranslucentFBO.status === completeFBO;
    const adjustAlphaComplete = oit._adjustAlphaFBO.status === completeFBO;
    if (!translucentComplete || !alphaComplete || !adjustTranslucentComplete || !adjustAlphaComplete) {
      destroyResources2(oit);
      oit._translucentMultipassSupport = false;
      supported = false;
    }
  }
  return supported;
}
OIT.prototype.update = function(context, passState, framebuffer, useHDR, numSamples) {
  if (!this.isSupported()) {
    return;
  }
  this._opaqueFBO = framebuffer;
  this._opaqueTexture = framebuffer.getColorTexture(0);
  this._depthStencilTexture = framebuffer.getDepthStencilTexture();
  const width = this._opaqueTexture.width;
  const height = this._opaqueTexture.height;
  const accumulationTexture = this._accumulationTexture;
  const textureChanged = !defined_default(accumulationTexture) || accumulationTexture.width !== width || accumulationTexture.height !== height || useHDR !== this._useHDR;
  const samplesChanged = this._numSamples !== numSamples;
  if (textureChanged || samplesChanged) {
    this._numSamples = numSamples;
    updateTextures(this, context, width, height);
  }
  if (!defined_default(this._translucentFBO.framebuffer) || textureChanged || samplesChanged) {
    if (!updateFramebuffers(this, context)) {
      return;
    }
  }
  this._useHDR = useHDR;
  const that = this;
  let fs;
  let uniformMap2;
  if (!defined_default(this._compositeCommand)) {
    fs = new ShaderSource_default({
      sources: [CompositeOITFS_default]
    });
    if (this._translucentMRTSupport) {
      fs.defines.push("MRT");
    }
    uniformMap2 = {
      u_opaque: function() {
        return that._opaqueTexture;
      },
      u_accumulation: function() {
        return that._accumulationTexture;
      },
      u_revealage: function() {
        return that._revealageTexture;
      }
    };
    this._compositeCommand = context.createViewportQuadCommand(fs, {
      uniformMap: uniformMap2,
      owner: this
    });
  }
  if (!defined_default(this._adjustTranslucentCommand)) {
    if (this._translucentMRTSupport) {
      fs = new ShaderSource_default({
        defines: ["MRT"],
        sources: [AdjustTranslucentFS_default]
      });
      uniformMap2 = {
        u_bgColor: function() {
          return that._translucentMRTClearCommand.color;
        },
        u_depthTexture: function() {
          return that._depthStencilTexture;
        }
      };
      this._adjustTranslucentCommand = context.createViewportQuadCommand(fs, {
        uniformMap: uniformMap2,
        owner: this
      });
    } else if (this._translucentMultipassSupport) {
      fs = new ShaderSource_default({
        sources: [AdjustTranslucentFS_default]
      });
      uniformMap2 = {
        u_bgColor: function() {
          return that._translucentMultipassClearCommand.color;
        },
        u_depthTexture: function() {
          return that._depthStencilTexture;
        }
      };
      this._adjustTranslucentCommand = context.createViewportQuadCommand(fs, {
        uniformMap: uniformMap2,
        owner: this
      });
      uniformMap2 = {
        u_bgColor: function() {
          return that._alphaClearCommand.color;
        },
        u_depthTexture: function() {
          return that._depthStencilTexture;
        }
      };
      this._adjustAlphaCommand = context.createViewportQuadCommand(fs, {
        uniformMap: uniformMap2,
        owner: this
      });
    }
  }
  this._viewport.width = width;
  this._viewport.height = height;
  const useScissorTest = !BoundingRectangle_default.equals(
    this._viewport,
    passState.viewport
  );
  let updateScissor = useScissorTest !== this._useScissorTest;
  this._useScissorTest = useScissorTest;
  if (!BoundingRectangle_default.equals(this._scissorRectangle, passState.viewport)) {
    this._scissorRectangle = BoundingRectangle_default.clone(
      passState.viewport,
      this._scissorRectangle
    );
    updateScissor = true;
  }
  if (!defined_default(this._rs) || !BoundingRectangle_default.equals(this._viewport, this._rs.viewport) || updateScissor) {
    this._rs = RenderState_default.fromCache({
      viewport: this._viewport,
      scissorTest: {
        enabled: this._useScissorTest,
        rectangle: this._scissorRectangle
      }
    });
  }
  if (defined_default(this._compositeCommand)) {
    this._compositeCommand.renderState = this._rs;
  }
  if (this._adjustTranslucentCommand) {
    this._adjustTranslucentCommand.renderState = this._rs;
  }
  if (defined_default(this._adjustAlphaCommand)) {
    this._adjustAlphaCommand.renderState = this._rs;
  }
};
var translucentMRTBlend = {
  enabled: true,
  color: new Color_default(0, 0, 0, 0),
  equationRgb: BlendEquation_default.ADD,
  equationAlpha: BlendEquation_default.ADD,
  functionSourceRgb: BlendFunction_default.ONE,
  functionDestinationRgb: BlendFunction_default.ONE,
  functionSourceAlpha: BlendFunction_default.ZERO,
  functionDestinationAlpha: BlendFunction_default.ONE_MINUS_SOURCE_ALPHA
};
var translucentColorBlend = {
  enabled: true,
  color: new Color_default(0, 0, 0, 0),
  equationRgb: BlendEquation_default.ADD,
  equationAlpha: BlendEquation_default.ADD,
  functionSourceRgb: BlendFunction_default.ONE,
  functionDestinationRgb: BlendFunction_default.ONE,
  functionSourceAlpha: BlendFunction_default.ONE,
  functionDestinationAlpha: BlendFunction_default.ONE
};
var translucentAlphaBlend = {
  enabled: true,
  color: new Color_default(0, 0, 0, 0),
  equationRgb: BlendEquation_default.ADD,
  equationAlpha: BlendEquation_default.ADD,
  functionSourceRgb: BlendFunction_default.ZERO,
  functionDestinationRgb: BlendFunction_default.ONE_MINUS_SOURCE_ALPHA,
  functionSourceAlpha: BlendFunction_default.ZERO,
  functionDestinationAlpha: BlendFunction_default.ONE_MINUS_SOURCE_ALPHA
};
function getTranslucentRenderState3(context, translucentBlending, cache, renderState) {
  let translucentState = cache[renderState.id];
  if (!defined_default(translucentState)) {
    const rs = RenderState_default.getState(renderState);
    rs.depthMask = false;
    rs.blending = translucentBlending;
    translucentState = RenderState_default.fromCache(rs);
    cache[renderState.id] = translucentState;
  }
  return translucentState;
}
function getTranslucentMRTRenderState(oit, context, renderState) {
  return getTranslucentRenderState3(
    context,
    translucentMRTBlend,
    oit._translucentRenderStateCache,
    renderState
  );
}
function getTranslucentColorRenderState(oit, context, renderState) {
  return getTranslucentRenderState3(
    context,
    translucentColorBlend,
    oit._translucentRenderStateCache,
    renderState
  );
}
function getTranslucentAlphaRenderState(oit, context, renderState) {
  return getTranslucentRenderState3(
    context,
    translucentAlphaBlend,
    oit._alphaRenderStateCache,
    renderState
  );
}
var mrtShaderSource = "    vec3 Ci = czm_gl_FragColor.rgb * czm_gl_FragColor.a;\n    float ai = czm_gl_FragColor.a;\n    float wzi = czm_alphaWeight(ai);\n    gl_FragData[0] = vec4(Ci * wzi, ai);\n    gl_FragData[1] = vec4(ai * wzi);\n";
var colorShaderSource = "    vec3 Ci = czm_gl_FragColor.rgb * czm_gl_FragColor.a;\n    float ai = czm_gl_FragColor.a;\n    float wzi = czm_alphaWeight(ai);\n    gl_FragColor = vec4(Ci, ai) * wzi;\n";
var alphaShaderSource = "    float ai = czm_gl_FragColor.a;\n    gl_FragColor = vec4(ai);\n";
function getTranslucentShaderProgram2(context, shaderProgram, keyword, source) {
  let shader = context.shaderCache.getDerivedShaderProgram(
    shaderProgram,
    keyword
  );
  if (!defined_default(shader)) {
    const attributeLocations8 = shaderProgram._attributeLocations;
    const fs = shaderProgram.fragmentShaderSource.clone();
    fs.sources = fs.sources.map(function(source2) {
      source2 = ShaderSource_default.replaceMain(source2, "czm_translucent_main");
      source2 = source2.replace(/gl_FragColor/g, "czm_gl_FragColor");
      source2 = source2.replace(/\bdiscard\b/g, "czm_discard = true");
      source2 = source2.replace(/czm_phong/g, "czm_translucentPhong");
      return source2;
    });
    fs.sources.splice(
      0,
      0,
      `${source.indexOf("gl_FragData") !== -1 ? "#extension GL_EXT_draw_buffers : enable \n" : ""}vec4 czm_gl_FragColor;
bool czm_discard = false;
`
    );
    fs.sources.push(
      `${"void main()\n{\n    czm_translucent_main();\n    if (czm_discard)\n    {\n        discard;\n    }\n"}${source}}
`
    );
    shader = context.shaderCache.createDerivedShaderProgram(
      shaderProgram,
      keyword,
      {
        vertexShaderSource: shaderProgram.vertexShaderSource,
        fragmentShaderSource: fs,
        attributeLocations: attributeLocations8
      }
    );
  }
  return shader;
}
function getTranslucentMRTShaderProgram(context, shaderProgram) {
  return getTranslucentShaderProgram2(
    context,
    shaderProgram,
    "translucentMRT",
    mrtShaderSource
  );
}
function getTranslucentColorShaderProgram(context, shaderProgram) {
  return getTranslucentShaderProgram2(
    context,
    shaderProgram,
    "translucentMultipass",
    colorShaderSource
  );
}
function getTranslucentAlphaShaderProgram(context, shaderProgram) {
  return getTranslucentShaderProgram2(
    context,
    shaderProgram,
    "alphaMultipass",
    alphaShaderSource
  );
}
OIT.prototype.createDerivedCommands = function(command, context, result) {
  if (!defined_default(result)) {
    result = {};
  }
  if (this._translucentMRTSupport) {
    let translucentShader;
    let translucentRenderState;
    if (defined_default(result.translucentCommand)) {
      translucentShader = result.translucentCommand.shaderProgram;
      translucentRenderState = result.translucentCommand.renderState;
    }
    result.translucentCommand = DrawCommand_default.shallowClone(
      command,
      result.translucentCommand
    );
    if (!defined_default(translucentShader) || result.shaderProgramId !== command.shaderProgram.id) {
      result.translucentCommand.shaderProgram = getTranslucentMRTShaderProgram(
        context,
        command.shaderProgram
      );
      result.translucentCommand.renderState = getTranslucentMRTRenderState(
        this,
        context,
        command.renderState
      );
      result.shaderProgramId = command.shaderProgram.id;
    } else {
      result.translucentCommand.shaderProgram = translucentShader;
      result.translucentCommand.renderState = translucentRenderState;
    }
  } else {
    let colorShader;
    let colorRenderState2;
    let alphaShader;
    let alphaRenderState;
    if (defined_default(result.translucentCommand)) {
      colorShader = result.translucentCommand.shaderProgram;
      colorRenderState2 = result.translucentCommand.renderState;
      alphaShader = result.alphaCommand.shaderProgram;
      alphaRenderState = result.alphaCommand.renderState;
    }
    result.translucentCommand = DrawCommand_default.shallowClone(
      command,
      result.translucentCommand
    );
    result.alphaCommand = DrawCommand_default.shallowClone(
      command,
      result.alphaCommand
    );
    if (!defined_default(colorShader) || result.shaderProgramId !== command.shaderProgram.id) {
      result.translucentCommand.shaderProgram = getTranslucentColorShaderProgram(
        context,
        command.shaderProgram
      );
      result.translucentCommand.renderState = getTranslucentColorRenderState(
        this,
        context,
        command.renderState
      );
      result.alphaCommand.shaderProgram = getTranslucentAlphaShaderProgram(
        context,
        command.shaderProgram
      );
      result.alphaCommand.renderState = getTranslucentAlphaRenderState(
        this,
        context,
        command.renderState
      );
      result.shaderProgramId = command.shaderProgram.id;
    } else {
      result.translucentCommand.shaderProgram = colorShader;
      result.translucentCommand.renderState = colorRenderState2;
      result.alphaCommand.shaderProgram = alphaShader;
      result.alphaCommand.renderState = alphaRenderState;
    }
  }
  return result;
};
function executeTranslucentCommandsSortedMultipass(oit, scene, executeFunction, passState, commands, invertClassification) {
  let command;
  let derivedCommand;
  let j;
  const context = scene.context;
  const useLogDepth = scene.frameState.useLogDepth;
  const useHdr = scene._hdr;
  const framebuffer = passState.framebuffer;
  const length3 = commands.length;
  const lightShadowsEnabled = scene.frameState.shadowState.lightShadowsEnabled;
  passState.framebuffer = oit._adjustTranslucentFBO.framebuffer;
  oit._adjustTranslucentCommand.execute(context, passState);
  passState.framebuffer = oit._adjustAlphaFBO.framebuffer;
  oit._adjustAlphaCommand.execute(context, passState);
  const debugFramebuffer = oit._opaqueFBO.framebuffer;
  passState.framebuffer = oit._translucentFBO.framebuffer;
  for (j = 0; j < length3; ++j) {
    command = commands[j];
    command = useLogDepth ? command.derivedCommands.logDepth.command : command;
    command = useHdr ? command.derivedCommands.hdr.command : command;
    derivedCommand = lightShadowsEnabled && command.receiveShadows ? command.derivedCommands.oit.shadows.translucentCommand : command.derivedCommands.oit.translucentCommand;
    executeFunction(
      derivedCommand,
      scene,
      context,
      passState,
      debugFramebuffer
    );
  }
  if (defined_default(invertClassification)) {
    command = invertClassification.unclassifiedCommand;
    derivedCommand = lightShadowsEnabled && command.receiveShadows ? command.derivedCommands.oit.shadows.translucentCommand : command.derivedCommands.oit.translucentCommand;
    executeFunction(
      derivedCommand,
      scene,
      context,
      passState,
      debugFramebuffer
    );
  }
  passState.framebuffer = oit._alphaFBO.framebuffer;
  for (j = 0; j < length3; ++j) {
    command = commands[j];
    command = useLogDepth ? command.derivedCommands.logDepth.command : command;
    command = useHdr ? command.derivedCommands.hdr.command : command;
    derivedCommand = lightShadowsEnabled && command.receiveShadows ? command.derivedCommands.oit.shadows.alphaCommand : command.derivedCommands.oit.alphaCommand;
    executeFunction(
      derivedCommand,
      scene,
      context,
      passState,
      debugFramebuffer
    );
  }
  if (defined_default(invertClassification)) {
    command = invertClassification.unclassifiedCommand;
    derivedCommand = lightShadowsEnabled && command.receiveShadows ? command.derivedCommands.oit.shadows.alphaCommand : command.derivedCommands.oit.alphaCommand;
    executeFunction(
      derivedCommand,
      scene,
      context,
      passState,
      debugFramebuffer
    );
  }
  passState.framebuffer = framebuffer;
}
function executeTranslucentCommandsSortedMRT(oit, scene, executeFunction, passState, commands, invertClassification) {
  const context = scene.context;
  const useLogDepth = scene.frameState.useLogDepth;
  const useHdr = scene._hdr;
  const framebuffer = passState.framebuffer;
  const length3 = commands.length;
  const lightShadowsEnabled = scene.frameState.shadowState.lightShadowsEnabled;
  passState.framebuffer = oit._adjustTranslucentFBO.framebuffer;
  oit._adjustTranslucentCommand.execute(context, passState);
  const debugFramebuffer = oit._opaqueFBO.framebuffer;
  passState.framebuffer = oit._translucentFBO.framebuffer;
  let command;
  let derivedCommand;
  for (let j = 0; j < length3; ++j) {
    command = commands[j];
    command = useLogDepth ? command.derivedCommands.logDepth.command : command;
    command = useHdr ? command.derivedCommands.hdr.command : command;
    derivedCommand = lightShadowsEnabled && command.receiveShadows ? command.derivedCommands.oit.shadows.translucentCommand : command.derivedCommands.oit.translucentCommand;
    executeFunction(
      derivedCommand,
      scene,
      context,
      passState,
      debugFramebuffer
    );
  }
  if (defined_default(invertClassification)) {
    command = invertClassification.unclassifiedCommand;
    derivedCommand = lightShadowsEnabled && command.receiveShadows ? command.derivedCommands.oit.shadows.translucentCommand : command.derivedCommands.oit.translucentCommand;
    executeFunction(
      derivedCommand,
      scene,
      context,
      passState,
      debugFramebuffer
    );
  }
  passState.framebuffer = framebuffer;
}
OIT.prototype.executeCommands = function(scene, executeFunction, passState, commands, invertClassification) {
  if (this._translucentMRTSupport) {
    executeTranslucentCommandsSortedMRT(
      this,
      scene,
      executeFunction,
      passState,
      commands,
      invertClassification
    );
    return;
  }
  executeTranslucentCommandsSortedMultipass(
    this,
    scene,
    executeFunction,
    passState,
    commands,
    invertClassification
  );
};
OIT.prototype.execute = function(context, passState) {
  this._compositeCommand.execute(context, passState);
};
OIT.prototype.clear = function(context, passState, clearColor) {
  const framebuffer = passState.framebuffer;
  passState.framebuffer = this._opaqueFBO.framebuffer;
  Color_default.clone(clearColor, this._opaqueClearCommand.color);
  this._opaqueClearCommand.execute(context, passState);
  passState.framebuffer = this._translucentFBO.framebuffer;
  const translucentClearCommand = this._translucentMRTSupport ? this._translucentMRTClearCommand : this._translucentMultipassClearCommand;
  translucentClearCommand.execute(context, passState);
  if (this._translucentMultipassSupport) {
    passState.framebuffer = this._alphaFBO.framebuffer;
    this._alphaClearCommand.execute(context, passState);
  }
  passState.framebuffer = framebuffer;
};
OIT.prototype.isSupported = function() {
  return this._translucentMRTSupport || this._translucentMultipassSupport;
};
OIT.prototype.isDestroyed = function() {
  return false;
};
OIT.prototype.destroy = function() {
  destroyResources2(this);
  if (defined_default(this._compositeCommand)) {
    this._compositeCommand.shaderProgram = this._compositeCommand.shaderProgram && this._compositeCommand.shaderProgram.destroy();
  }
  if (defined_default(this._adjustTranslucentCommand)) {
    this._adjustTranslucentCommand.shaderProgram = this._adjustTranslucentCommand.shaderProgram && this._adjustTranslucentCommand.shaderProgram.destroy();
  }
  if (defined_default(this._adjustAlphaCommand)) {
    this._adjustAlphaCommand.shaderProgram = this._adjustAlphaCommand.shaderProgram && this._adjustAlphaCommand.shaderProgram.destroy();
  }
  return destroyObject_default(this);
};
var OIT_default = OIT;

// node_modules/cesium/Source/Scene/OpenStreetMapImageryProvider.js
var defaultCredit4 = new Credit_default(
  "MapQuest, Open Street Map and contributors, CC-BY-SA"
);
function OpenStreetMapImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const resource = Resource_default.createIfNeeded(
    defaultValue_default(options.url, "https://a.tile.openstreetmap.org/")
  );
  resource.appendForwardSlash();
  resource.url += `{z}/{x}/{y}.${defaultValue_default(options.fileExtension, "png")}`;
  const tilingScheme2 = new WebMercatorTilingScheme_default({
    ellipsoid: options.ellipsoid
  });
  const tileWidth = 256;
  const tileHeight = 256;
  const minimumLevel = defaultValue_default(options.minimumLevel, 0);
  const maximumLevel = options.maximumLevel;
  const rectangle = defaultValue_default(options.rectangle, tilingScheme2.rectangle);
  const swTile = tilingScheme2.positionToTileXY(
    Rectangle_default.southwest(rectangle),
    minimumLevel
  );
  const neTile = tilingScheme2.positionToTileXY(
    Rectangle_default.northeast(rectangle),
    minimumLevel
  );
  const tileCount = (Math.abs(neTile.x - swTile.x) + 1) * (Math.abs(neTile.y - swTile.y) + 1);
  if (tileCount > 4) {
    throw new DeveloperError_default(
      `The rectangle and minimumLevel indicate that there are ${tileCount} tiles at the minimum level. Imagery providers with more than four tiles at the minimum level are not supported.`
    );
  }
  let credit = defaultValue_default(options.credit, defaultCredit4);
  if (typeof credit === "string") {
    credit = new Credit_default(credit);
  }
  UrlTemplateImageryProvider_default.call(this, {
    url: resource,
    credit,
    tilingScheme: tilingScheme2,
    tileWidth,
    tileHeight,
    minimumLevel,
    maximumLevel,
    rectangle
  });
}
if (defined_default(Object.create)) {
  OpenStreetMapImageryProvider.prototype = Object.create(
    UrlTemplateImageryProvider_default.prototype
  );
  OpenStreetMapImageryProvider.prototype.constructor = OpenStreetMapImageryProvider;
}
var OpenStreetMapImageryProvider_default = OpenStreetMapImageryProvider;

// node_modules/cesium/Source/Scene/Particle.js
var defaultSize = new Cartesian2_default(1, 1);
function Particle(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.mass = defaultValue_default(options.mass, 1);
  this.position = Cartesian3_default.clone(
    defaultValue_default(options.position, Cartesian3_default.ZERO)
  );
  this.velocity = Cartesian3_default.clone(
    defaultValue_default(options.velocity, Cartesian3_default.ZERO)
  );
  this.life = defaultValue_default(options.life, Number.MAX_VALUE);
  this.image = options.image;
  this.startColor = Color_default.clone(defaultValue_default(options.startColor, Color_default.WHITE));
  this.endColor = Color_default.clone(defaultValue_default(options.endColor, Color_default.WHITE));
  this.startScale = defaultValue_default(options.startScale, 1);
  this.endScale = defaultValue_default(options.endScale, 1);
  this.imageSize = Cartesian2_default.clone(
    defaultValue_default(options.imageSize, defaultSize)
  );
  this._age = 0;
  this._normalizedAge = 0;
  this._billboard = void 0;
}
Object.defineProperties(Particle.prototype, {
  age: {
    get: function() {
      return this._age;
    }
  },
  normalizedAge: {
    get: function() {
      return this._normalizedAge;
    }
  }
});
var deltaScratch = new Cartesian3_default();
Particle.prototype.update = function(dt, particleUpdateFunction) {
  Cartesian3_default.multiplyByScalar(this.velocity, dt, deltaScratch);
  Cartesian3_default.add(this.position, deltaScratch, this.position);
  if (defined_default(particleUpdateFunction)) {
    particleUpdateFunction(this, dt);
  }
  this._age += dt;
  if (this.life === Number.MAX_VALUE) {
    this._normalizedAge = 0;
  } else {
    this._normalizedAge = this._age / this.life;
  }
  return this._age <= this.life;
};
var Particle_default = Particle;

// node_modules/cesium/Source/Scene/ParticleBurst.js
function ParticleBurst(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.time = defaultValue_default(options.time, 0);
  this.minimum = defaultValue_default(options.minimum, 0);
  this.maximum = defaultValue_default(options.maximum, 50);
  this._complete = false;
}
Object.defineProperties(ParticleBurst.prototype, {
  complete: {
    get: function() {
      return this._complete;
    }
  }
});
var ParticleBurst_default = ParticleBurst;

// node_modules/cesium/Source/Scene/ParticleEmitter.js
function ParticleEmitter(options) {
  throw new DeveloperError_default(
    "This type should not be instantiated directly.  Instead, use BoxEmitter, CircleEmitter, ConeEmitter or SphereEmitter."
  );
}
ParticleEmitter.prototype.emit = function(particle) {
  DeveloperError_default.throwInstantiationError();
};
var ParticleEmitter_default = ParticleEmitter;

// node_modules/cesium/Source/Scene/ParticleSystem.js
var defaultImageSize = new Cartesian2_default(1, 1);
function ParticleSystem(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.show = defaultValue_default(options.show, true);
  this.updateCallback = options.updateCallback;
  this.loop = defaultValue_default(options.loop, true);
  this.image = defaultValue_default(options.image, void 0);
  let emitter = options.emitter;
  if (!defined_default(emitter)) {
    emitter = new CircleEmitter_default(0.5);
  }
  this._emitter = emitter;
  this._bursts = options.bursts;
  this._modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this._emitterModelMatrix = Matrix4_default.clone(
    defaultValue_default(options.emitterModelMatrix, Matrix4_default.IDENTITY)
  );
  this._matrixDirty = true;
  this._combinedMatrix = new Matrix4_default();
  this._startColor = Color_default.clone(
    defaultValue_default(options.color, defaultValue_default(options.startColor, Color_default.WHITE))
  );
  this._endColor = Color_default.clone(
    defaultValue_default(options.color, defaultValue_default(options.endColor, Color_default.WHITE))
  );
  this._startScale = defaultValue_default(
    options.scale,
    defaultValue_default(options.startScale, 1)
  );
  this._endScale = defaultValue_default(
    options.scale,
    defaultValue_default(options.endScale, 1)
  );
  this._emissionRate = defaultValue_default(options.emissionRate, 5);
  this._minimumSpeed = defaultValue_default(
    options.speed,
    defaultValue_default(options.minimumSpeed, 1)
  );
  this._maximumSpeed = defaultValue_default(
    options.speed,
    defaultValue_default(options.maximumSpeed, 1)
  );
  this._minimumParticleLife = defaultValue_default(
    options.particleLife,
    defaultValue_default(options.minimumParticleLife, 5)
  );
  this._maximumParticleLife = defaultValue_default(
    options.particleLife,
    defaultValue_default(options.maximumParticleLife, 5)
  );
  this._minimumMass = defaultValue_default(
    options.mass,
    defaultValue_default(options.minimumMass, 1)
  );
  this._maximumMass = defaultValue_default(
    options.mass,
    defaultValue_default(options.maximumMass, 1)
  );
  this._minimumImageSize = Cartesian2_default.clone(
    defaultValue_default(
      options.imageSize,
      defaultValue_default(options.minimumImageSize, defaultImageSize)
    )
  );
  this._maximumImageSize = Cartesian2_default.clone(
    defaultValue_default(
      options.imageSize,
      defaultValue_default(options.maximumImageSize, defaultImageSize)
    )
  );
  this._sizeInMeters = defaultValue_default(options.sizeInMeters, false);
  this._lifetime = defaultValue_default(options.lifetime, Number.MAX_VALUE);
  this._billboardCollection = void 0;
  this._particles = [];
  this._particlePool = [];
  this._previousTime = void 0;
  this._currentTime = 0;
  this._carryOver = 0;
  this._complete = new Event_default();
  this._isComplete = false;
  this._updateParticlePool = true;
  this._particleEstimate = 0;
}
Object.defineProperties(ParticleSystem.prototype, {
  emitter: {
    get: function() {
      return this._emitter;
    },
    set: function(value) {
      Check_default.defined("value", value);
      this._emitter = value;
    }
  },
  bursts: {
    get: function() {
      return this._bursts;
    },
    set: function(value) {
      this._bursts = value;
      this._updateParticlePool = true;
    }
  },
  modelMatrix: {
    get: function() {
      return this._modelMatrix;
    },
    set: function(value) {
      Check_default.defined("value", value);
      this._matrixDirty = this._matrixDirty || !Matrix4_default.equals(this._modelMatrix, value);
      Matrix4_default.clone(value, this._modelMatrix);
    }
  },
  emitterModelMatrix: {
    get: function() {
      return this._emitterModelMatrix;
    },
    set: function(value) {
      Check_default.defined("value", value);
      this._matrixDirty = this._matrixDirty || !Matrix4_default.equals(this._emitterModelMatrix, value);
      Matrix4_default.clone(value, this._emitterModelMatrix);
    }
  },
  startColor: {
    get: function() {
      return this._startColor;
    },
    set: function(value) {
      Check_default.defined("value", value);
      Color_default.clone(value, this._startColor);
    }
  },
  endColor: {
    get: function() {
      return this._endColor;
    },
    set: function(value) {
      Check_default.defined("value", value);
      Color_default.clone(value, this._endColor);
    }
  },
  startScale: {
    get: function() {
      return this._startScale;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._startScale = value;
    }
  },
  endScale: {
    get: function() {
      return this._endScale;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._endScale = value;
    }
  },
  emissionRate: {
    get: function() {
      return this._emissionRate;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._emissionRate = value;
      this._updateParticlePool = true;
    }
  },
  minimumSpeed: {
    get: function() {
      return this._minimumSpeed;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._minimumSpeed = value;
    }
  },
  maximumSpeed: {
    get: function() {
      return this._maximumSpeed;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._maximumSpeed = value;
    }
  },
  minimumParticleLife: {
    get: function() {
      return this._minimumParticleLife;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._minimumParticleLife = value;
    }
  },
  maximumParticleLife: {
    get: function() {
      return this._maximumParticleLife;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._maximumParticleLife = value;
      this._updateParticlePool = true;
    }
  },
  minimumMass: {
    get: function() {
      return this._minimumMass;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._minimumMass = value;
    }
  },
  maximumMass: {
    get: function() {
      return this._maximumMass;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._maximumMass = value;
    }
  },
  minimumImageSize: {
    get: function() {
      return this._minimumImageSize;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      Check_default.typeOf.number.greaterThanOrEquals("value.x", value.x, 0);
      Check_default.typeOf.number.greaterThanOrEquals("value.y", value.y, 0);
      this._minimumImageSize = value;
    }
  },
  maximumImageSize: {
    get: function() {
      return this._maximumImageSize;
    },
    set: function(value) {
      Check_default.typeOf.object("value", value);
      Check_default.typeOf.number.greaterThanOrEquals("value.x", value.x, 0);
      Check_default.typeOf.number.greaterThanOrEquals("value.y", value.y, 0);
      this._maximumImageSize = value;
    }
  },
  sizeInMeters: {
    get: function() {
      return this._sizeInMeters;
    },
    set: function(value) {
      Check_default.typeOf.bool("value", value);
      this._sizeInMeters = value;
    }
  },
  lifetime: {
    get: function() {
      return this._lifetime;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThanOrEquals("value", value, 0);
      this._lifetime = value;
    }
  },
  complete: {
    get: function() {
      return this._complete;
    }
  },
  isComplete: {
    get: function() {
      return this._isComplete;
    }
  }
});
function updateParticlePool(system) {
  const emissionRate = system._emissionRate;
  const life = system._maximumParticleLife;
  let burstAmount = 0;
  const bursts = system._bursts;
  if (defined_default(bursts)) {
    const length3 = bursts.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      burstAmount += bursts[i2].maximum;
    }
  }
  const billboardCollection = system._billboardCollection;
  const image = system.image;
  const particleEstimate = Math.ceil(emissionRate * life + burstAmount);
  const particles = system._particles;
  const particlePool = system._particlePool;
  const numToAdd = Math.max(
    particleEstimate - particles.length - particlePool.length,
    0
  );
  for (let j = 0; j < numToAdd; ++j) {
    const particle = new Particle_default();
    particle._billboard = billboardCollection.add({
      image
    });
    particlePool.push(particle);
  }
  system._particleEstimate = particleEstimate;
}
function getOrCreateParticle(system) {
  let particle = system._particlePool.pop();
  if (!defined_default(particle)) {
    particle = new Particle_default();
  }
  return particle;
}
function addParticleToPool(system, particle) {
  system._particlePool.push(particle);
}
function freeParticlePool(system) {
  const particles = system._particles;
  const particlePool = system._particlePool;
  const billboardCollection = system._billboardCollection;
  const numParticles = particles.length;
  const numInPool = particlePool.length;
  const estimate = system._particleEstimate;
  const start = numInPool - Math.max(estimate - numParticles - numInPool, 0);
  for (let i2 = start; i2 < numInPool; ++i2) {
    const p2 = particlePool[i2];
    billboardCollection.remove(p2._billboard);
  }
  particlePool.length = start;
}
function removeBillboard(particle) {
  if (defined_default(particle._billboard)) {
    particle._billboard.show = false;
  }
}
function updateBillboard(system, particle) {
  let billboard = particle._billboard;
  if (!defined_default(billboard)) {
    billboard = particle._billboard = system._billboardCollection.add({
      image: particle.image
    });
  }
  billboard.width = particle.imageSize.x;
  billboard.height = particle.imageSize.y;
  billboard.position = particle.position;
  billboard.sizeInMeters = system.sizeInMeters;
  billboard.show = true;
  const r2 = Math_default.lerp(
    particle.startColor.red,
    particle.endColor.red,
    particle.normalizedAge
  );
  const g = Math_default.lerp(
    particle.startColor.green,
    particle.endColor.green,
    particle.normalizedAge
  );
  const b = Math_default.lerp(
    particle.startColor.blue,
    particle.endColor.blue,
    particle.normalizedAge
  );
  const a4 = Math_default.lerp(
    particle.startColor.alpha,
    particle.endColor.alpha,
    particle.normalizedAge
  );
  billboard.color = new Color_default(r2, g, b, a4);
  billboard.scale = Math_default.lerp(
    particle.startScale,
    particle.endScale,
    particle.normalizedAge
  );
}
function addParticle(system, particle) {
  particle.startColor = Color_default.clone(system._startColor, particle.startColor);
  particle.endColor = Color_default.clone(system._endColor, particle.endColor);
  particle.startScale = system._startScale;
  particle.endScale = system._endScale;
  particle.image = system.image;
  particle.life = Math_default.randomBetween(
    system._minimumParticleLife,
    system._maximumParticleLife
  );
  particle.mass = Math_default.randomBetween(
    system._minimumMass,
    system._maximumMass
  );
  particle.imageSize.x = Math_default.randomBetween(
    system._minimumImageSize.x,
    system._maximumImageSize.x
  );
  particle.imageSize.y = Math_default.randomBetween(
    system._minimumImageSize.y,
    system._maximumImageSize.y
  );
  particle._normalizedAge = 0;
  particle._age = 0;
  const speed = Math_default.randomBetween(
    system._minimumSpeed,
    system._maximumSpeed
  );
  Cartesian3_default.multiplyByScalar(particle.velocity, speed, particle.velocity);
  system._particles.push(particle);
}
function calculateNumberToEmit(system, dt) {
  if (system._isComplete) {
    return 0;
  }
  dt = Math_default.mod(dt, system._lifetime);
  const v7 = dt * system._emissionRate;
  let numToEmit = Math.floor(v7);
  system._carryOver += v7 - numToEmit;
  if (system._carryOver > 1) {
    numToEmit++;
    system._carryOver -= 1;
  }
  if (defined_default(system.bursts)) {
    const length3 = system.bursts.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const burst = system.bursts[i2];
      const currentTime = system._currentTime;
      if (defined_default(burst) && !burst._complete && currentTime > burst.time) {
        numToEmit += Math_default.randomBetween(burst.minimum, burst.maximum);
        burst._complete = true;
      }
    }
  }
  return numToEmit;
}
var rotatedVelocityScratch = new Cartesian3_default();
ParticleSystem.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  if (!defined_default(this._billboardCollection)) {
    this._billboardCollection = new BillboardCollection_default();
  }
  if (this._updateParticlePool) {
    updateParticlePool(this);
    this._updateParticlePool = false;
  }
  let dt = 0;
  if (this._previousTime) {
    dt = JulianDate_default.secondsDifference(frameState.time, this._previousTime);
  }
  if (dt < 0) {
    dt = 0;
  }
  const particles = this._particles;
  const emitter = this._emitter;
  const updateCallback = this.updateCallback;
  let i2;
  let particle;
  let length3 = particles.length;
  for (i2 = 0; i2 < length3; ++i2) {
    particle = particles[i2];
    if (!particle.update(dt, updateCallback)) {
      removeBillboard(particle);
      addParticleToPool(this, particle);
      particles[i2] = particles[length3 - 1];
      --i2;
      --length3;
    } else {
      updateBillboard(this, particle);
    }
  }
  particles.length = length3;
  const numToEmit = calculateNumberToEmit(this, dt);
  if (numToEmit > 0 && defined_default(emitter)) {
    if (this._matrixDirty) {
      this._combinedMatrix = Matrix4_default.multiply(
        this.modelMatrix,
        this.emitterModelMatrix,
        this._combinedMatrix
      );
      this._matrixDirty = false;
    }
    const combinedMatrix = this._combinedMatrix;
    for (i2 = 0; i2 < numToEmit; i2++) {
      particle = getOrCreateParticle(this);
      this._emitter.emit(particle);
      Cartesian3_default.add(
        particle.position,
        particle.velocity,
        rotatedVelocityScratch
      );
      Matrix4_default.multiplyByPoint(
        combinedMatrix,
        rotatedVelocityScratch,
        rotatedVelocityScratch
      );
      particle.position = Matrix4_default.multiplyByPoint(
        combinedMatrix,
        particle.position,
        particle.position
      );
      Cartesian3_default.subtract(
        rotatedVelocityScratch,
        particle.position,
        particle.velocity
      );
      Cartesian3_default.normalize(particle.velocity, particle.velocity);
      addParticle(this, particle);
      updateBillboard(this, particle);
    }
  }
  this._billboardCollection.update(frameState);
  this._previousTime = JulianDate_default.clone(frameState.time, this._previousTime);
  this._currentTime += dt;
  if (this._lifetime !== Number.MAX_VALUE && this._currentTime > this._lifetime) {
    if (this.loop) {
      this._currentTime = Math_default.mod(this._currentTime, this._lifetime);
      if (this.bursts) {
        const burstLength = this.bursts.length;
        for (i2 = 0; i2 < burstLength; i2++) {
          this.bursts[i2]._complete = false;
        }
      }
    } else {
      this._isComplete = true;
      this._complete.raiseEvent(this);
    }
  }
  if (frameState.frameNumber % 120 === 0) {
    freeParticlePool(this);
  }
};
ParticleSystem.prototype.isDestroyed = function() {
  return false;
};
ParticleSystem.prototype.destroy = function() {
  this._billboardCollection = this._billboardCollection && this._billboardCollection.destroy();
  return destroyObject_default(this);
};
var ParticleSystem_default = ParticleSystem;

// node_modules/cesium/Source/Scene/PerformanceDisplay.js
function PerformanceDisplay(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const container = getElement_default(options.container);
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required");
  }
  this._container = container;
  const display = document.createElement("div");
  display.className = "cesium-performanceDisplay";
  const fpsElement = document.createElement("div");
  fpsElement.className = "cesium-performanceDisplay-fps";
  this._fpsText = document.createTextNode("");
  fpsElement.appendChild(this._fpsText);
  const msElement = document.createElement("div");
  msElement.className = "cesium-performanceDisplay-ms";
  this._msText = document.createTextNode("");
  msElement.appendChild(this._msText);
  display.appendChild(msElement);
  display.appendChild(fpsElement);
  this._container.appendChild(display);
  this._lastFpsSampleTime = getTimestamp_default();
  this._lastMsSampleTime = getTimestamp_default();
  this._fpsFrameCount = 0;
  this._msFrameCount = 0;
  this._throttled = false;
  const throttledElement = document.createElement("div");
  throttledElement.className = "cesium-performanceDisplay-throttled";
  this._throttledText = document.createTextNode("");
  throttledElement.appendChild(this._throttledText);
  display.appendChild(throttledElement);
}
Object.defineProperties(PerformanceDisplay.prototype, {
  throttled: {
    get: function() {
      return this._throttled;
    },
    set: function(value) {
      if (this._throttled === value) {
        return;
      }
      if (value) {
        this._throttledText.nodeValue = "(throttled)";
      } else {
        this._throttledText.nodeValue = "";
      }
      this._throttled = value;
    }
  }
});
PerformanceDisplay.prototype.update = function(renderedThisFrame) {
  const time = getTimestamp_default();
  const updateDisplay = defaultValue_default(renderedThisFrame, true);
  this._fpsFrameCount++;
  const fpsElapsedTime = time - this._lastFpsSampleTime;
  if (fpsElapsedTime > 1e3) {
    let fps = "N/A";
    if (updateDisplay) {
      fps = this._fpsFrameCount * 1e3 / fpsElapsedTime | 0;
    }
    this._fpsText.nodeValue = `${fps} FPS`;
    this._lastFpsSampleTime = time;
    this._fpsFrameCount = 0;
  }
  this._msFrameCount++;
  const msElapsedTime = time - this._lastMsSampleTime;
  if (msElapsedTime > 200) {
    let ms = "N/A";
    if (updateDisplay) {
      ms = (msElapsedTime / this._msFrameCount).toFixed(2);
    }
    this._msText.nodeValue = `${ms} MS`;
    this._lastMsSampleTime = time;
    this._msFrameCount = 0;
  }
};
PerformanceDisplay.prototype.destroy = function() {
  return destroyObject_default(this);
};
var PerformanceDisplay_default = PerformanceDisplay;

// node_modules/cesium/Source/Scene/PickDepth.js
function PickDepth() {
  this._framebuffer = new FramebufferManager_default();
  this._textureToCopy = void 0;
  this._copyDepthCommand = void 0;
}
Object.defineProperties(PickDepth.prototype, {
  framebuffer: {
    get: function() {
      return this._framebuffer.framebuffer;
    }
  }
});
function updateFramebuffers2(pickDepth, context, depthTexture) {
  const width = depthTexture.width;
  const height = depthTexture.height;
  pickDepth._framebuffer.update(context, width, height);
}
function updateCopyCommands2(pickDepth, context, depthTexture) {
  if (!defined_default(pickDepth._copyDepthCommand)) {
    const fs = "uniform highp sampler2D u_texture;\nvarying vec2 v_textureCoordinates;\nvoid main()\n{\n    gl_FragColor = czm_packDepth(texture2D(u_texture, v_textureCoordinates).r);\n}\n";
    pickDepth._copyDepthCommand = context.createViewportQuadCommand(fs, {
      renderState: RenderState_default.fromCache(),
      uniformMap: {
        u_texture: function() {
          return pickDepth._textureToCopy;
        }
      },
      owner: pickDepth
    });
  }
  pickDepth._textureToCopy = depthTexture;
  pickDepth._copyDepthCommand.framebuffer = pickDepth.framebuffer;
}
PickDepth.prototype.update = function(context, depthTexture) {
  updateFramebuffers2(this, context, depthTexture);
  updateCopyCommands2(this, context, depthTexture);
};
var scratchPackedDepth = new Cartesian4_default();
var packedDepthScale = new Cartesian4_default(
  1,
  1 / 255,
  1 / 65025,
  1 / 16581375
);
PickDepth.prototype.getDepth = function(context, x, y) {
  if (!defined_default(this.framebuffer)) {
    return void 0;
  }
  const pixels = context.readPixels({
    x,
    y,
    width: 1,
    height: 1,
    framebuffer: this.framebuffer
  });
  const packedDepth = Cartesian4_default.unpack(pixels, 0, scratchPackedDepth);
  Cartesian4_default.divideByScalar(packedDepth, 255, packedDepth);
  return Cartesian4_default.dot(packedDepth, packedDepthScale);
};
PickDepth.prototype.executeCopyDepth = function(context, passState) {
  this._copyDepthCommand.execute(context, passState);
};
PickDepth.prototype.isDestroyed = function() {
  return false;
};
PickDepth.prototype.destroy = function() {
  this._framebuffer.destroy();
  if (defined_default(this._copyDepthCommand)) {
    this._copyDepthCommand.shaderProgram = defined_default(this._copyDepthCommand.shaderProgram) && this._copyDepthCommand.shaderProgram.destroy();
  }
  return destroyObject_default(this);
};
var PickDepth_default = PickDepth;

// node_modules/cesium/Source/Scene/PickDepthFramebuffer.js
function PickDepthFramebuffer() {
  this._framebuffer = new FramebufferManager_default({
    color: false,
    depthStencil: true,
    supportsDepthTexture: true
  });
  this._passState = void 0;
}
Object.defineProperties(PickDepthFramebuffer.prototype, {
  framebuffer: {
    get: function() {
      return this._framebuffer.framebuffer;
    }
  }
});
function destroyResources3(pickDepth) {
  pickDepth._framebuffer.destroy();
}
function createResources6(pickDepth, context) {
  const width = context.drawingBufferWidth;
  const height = context.drawingBufferHeight;
  pickDepth._framebuffer.update(context, width, height);
  const passState = new PassState_default(context);
  passState.blendingEnabled = false;
  passState.scissorTest = {
    enabled: true,
    rectangle: new BoundingRectangle_default()
  };
  passState.viewport = new BoundingRectangle_default();
  pickDepth._passState = passState;
}
PickDepthFramebuffer.prototype.update = function(context, drawingBufferPosition, viewport) {
  const width = viewport.width;
  const height = viewport.height;
  if (this._framebuffer.isDirty(width, height)) {
    createResources6(this, context);
  }
  const framebuffer = this.framebuffer;
  const passState = this._passState;
  passState.framebuffer = framebuffer;
  passState.viewport.width = width;
  passState.viewport.height = height;
  passState.scissorTest.rectangle.x = drawingBufferPosition.x;
  passState.scissorTest.rectangle.y = height - drawingBufferPosition.y;
  passState.scissorTest.rectangle.width = 1;
  passState.scissorTest.rectangle.height = 1;
  return passState;
};
PickDepthFramebuffer.prototype.isDestroyed = function() {
  return false;
};
PickDepthFramebuffer.prototype.destroy = function() {
  destroyResources3(this);
  return destroyObject_default(this);
};
var PickDepthFramebuffer_default = PickDepthFramebuffer;

// node_modules/cesium/Source/Scene/PickFramebuffer.js
function PickFramebuffer(context) {
  const passState = new PassState_default(context);
  passState.blendingEnabled = false;
  passState.scissorTest = {
    enabled: true,
    rectangle: new BoundingRectangle_default()
  };
  passState.viewport = new BoundingRectangle_default();
  this._context = context;
  this._fb = new FramebufferManager_default({
    depthStencil: true
  });
  this._passState = passState;
  this._width = 0;
  this._height = 0;
}
PickFramebuffer.prototype.begin = function(screenSpaceRectangle, viewport) {
  const context = this._context;
  const width = viewport.width;
  const height = viewport.height;
  BoundingRectangle_default.clone(
    screenSpaceRectangle,
    this._passState.scissorTest.rectangle
  );
  this._width = width;
  this._height = height;
  this._fb.update(context, width, height);
  this._passState.framebuffer = this._fb.framebuffer;
  this._passState.viewport.width = width;
  this._passState.viewport.height = height;
  return this._passState;
};
var colorScratch8 = new Color_default();
PickFramebuffer.prototype.end = function(screenSpaceRectangle) {
  const width = defaultValue_default(screenSpaceRectangle.width, 1);
  const height = defaultValue_default(screenSpaceRectangle.height, 1);
  const context = this._context;
  const pixels = context.readPixels({
    x: screenSpaceRectangle.x,
    y: screenSpaceRectangle.y,
    width,
    height,
    framebuffer: this._fb.framebuffer
  });
  const max3 = Math.max(width, height);
  const length3 = max3 * max3;
  const halfWidth = Math.floor(width * 0.5);
  const halfHeight = Math.floor(height * 0.5);
  let x = 0;
  let y = 0;
  let dx = 0;
  let dy = -1;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (-halfWidth <= x && x <= halfWidth && -halfHeight <= y && y <= halfHeight) {
      const index2 = 4 * ((halfHeight - y) * width + x + halfWidth);
      colorScratch8.red = Color_default.byteToFloat(pixels[index2]);
      colorScratch8.green = Color_default.byteToFloat(pixels[index2 + 1]);
      colorScratch8.blue = Color_default.byteToFloat(pixels[index2 + 2]);
      colorScratch8.alpha = Color_default.byteToFloat(pixels[index2 + 3]);
      const object2 = context.getObjectByPickColor(colorScratch8);
      if (defined_default(object2)) {
        return object2;
      }
    }
    if (x === y || x < 0 && -x === y || x > 0 && x === 1 - y) {
      const temp = dx;
      dx = -dy;
      dy = temp;
    }
    x += dx;
    y += dy;
  }
  return void 0;
};
PickFramebuffer.prototype.isDestroyed = function() {
  return false;
};
PickFramebuffer.prototype.destroy = function() {
  this._fb.destroy();
  return destroyObject_default(this);
};
var PickFramebuffer_default = PickFramebuffer;

// node_modules/cesium/Source/Scene/SceneFramebuffer.js
function SceneFramebuffer() {
  this._numSamples = 1;
  this._colorFramebuffer = new FramebufferManager_default({
    depthStencil: true,
    supportsDepthTexture: true
  });
  this._idFramebuffer = new FramebufferManager_default({
    depthStencil: true,
    supportsDepthTexture: true
  });
  this._idClearColor = new Color_default(0, 0, 0, 0);
  this._clearCommand = new ClearCommand_default({
    color: new Color_default(0, 0, 0, 0),
    depth: 1,
    owner: this
  });
}
function destroyResources4(post) {
  post._colorFramebuffer.destroy();
  post._idFramebuffer.destroy();
}
Object.defineProperties(SceneFramebuffer.prototype, {
  framebuffer: {
    get: function() {
      return this._colorFramebuffer.framebuffer;
    }
  },
  idFramebuffer: {
    get: function() {
      return this._idFramebuffer.framebuffer;
    }
  },
  depthStencilTexture: {
    get: function() {
      return this._colorFramebuffer.getDepthStencilTexture();
    }
  }
});
SceneFramebuffer.prototype.update = function(context, viewport, hdr, numSamples) {
  const width = viewport.width;
  const height = viewport.height;
  const pixelDatatype = hdr ? context.halfFloatingPointTexture ? PixelDatatype_default.HALF_FLOAT : PixelDatatype_default.FLOAT : PixelDatatype_default.UNSIGNED_BYTE;
  this._numSamples = numSamples;
  this._colorFramebuffer.update(
    context,
    width,
    height,
    numSamples,
    pixelDatatype
  );
  this._idFramebuffer.update(context, width, height);
};
SceneFramebuffer.prototype.clear = function(context, passState, clearColor) {
  Color_default.clone(clearColor, this._clearCommand.color);
  Color_default.clone(this._idClearColor, this._clearCommand.color);
  this._colorFramebuffer.clear(context, this._clearCommand, passState);
  this._idFramebuffer.clear(context, this._clearCommand, passState);
};
SceneFramebuffer.prototype.getFramebuffer = function() {
  return this._colorFramebuffer.framebuffer;
};
SceneFramebuffer.prototype.getIdFramebuffer = function() {
  return this._idFramebuffer.framebuffer;
};
SceneFramebuffer.prototype.prepareColorTextures = function(context) {
  if (this._numSamples > 1) {
    this._colorFramebuffer.prepareTextures(context);
  }
};
SceneFramebuffer.prototype.isDestroyed = function() {
  return false;
};
SceneFramebuffer.prototype.destroy = function() {
  destroyResources4(this);
  return destroyObject_default(this);
};
var SceneFramebuffer_default = SceneFramebuffer;

// node_modules/cesium/Source/Scene/ShadowMapShader.js
function ShadowMapShader() {
}
ShadowMapShader.getShadowCastShaderKeyword = function(isPointLight, isTerrain, usesDepthTexture, isOpaque) {
  return `castShadow ${isPointLight} ${isTerrain} ${usesDepthTexture} ${isOpaque}`;
};
ShadowMapShader.createShadowCastVertexShader = function(vs, isPointLight, isTerrain) {
  const defines = vs.defines.slice(0);
  const sources = vs.sources.slice(0);
  defines.push("SHADOW_MAP");
  if (isTerrain) {
    defines.push("GENERATE_POSITION");
  }
  const positionVaryingName = ShaderSource_default.findPositionVarying(vs);
  const hasPositionVarying = defined_default(positionVaryingName);
  if (isPointLight && !hasPositionVarying) {
    const length3 = sources.length;
    for (let j = 0; j < length3; ++j) {
      sources[j] = ShaderSource_default.replaceMain(sources[j], "czm_shadow_cast_main");
    }
    const shadowVS = "varying vec3 v_positionEC; \nvoid main() \n{ \n    czm_shadow_cast_main(); \n    v_positionEC = (czm_inverseProjection * gl_Position).xyz; \n}";
    sources.push(shadowVS);
  }
  return new ShaderSource_default({
    defines,
    sources
  });
};
ShadowMapShader.createShadowCastFragmentShader = function(fs, isPointLight, usesDepthTexture, opaque) {
  const defines = fs.defines.slice(0);
  const sources = fs.sources.slice(0);
  defines.push("SHADOW_MAP");
  let positionVaryingName = ShaderSource_default.findPositionVarying(fs);
  const hasPositionVarying = defined_default(positionVaryingName);
  if (!hasPositionVarying) {
    positionVaryingName = "v_positionEC";
  }
  const length3 = sources.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    sources[i2] = ShaderSource_default.replaceMain(sources[i2], "czm_shadow_cast_main");
  }
  let fsSource = "";
  if (isPointLight) {
    if (!hasPositionVarying) {
      fsSource += "varying vec3 v_positionEC; \n";
    }
    fsSource += "uniform vec4 shadowMap_lightPositionEC; \n";
  }
  if (opaque) {
    fsSource += "void main() \n{ \n";
  } else {
    fsSource += "void main() \n{ \n    czm_shadow_cast_main(); \n    if (gl_FragColor.a == 0.0) \n    { \n       discard; \n    } \n";
  }
  if (isPointLight) {
    fsSource += `    float distance = length(${positionVaryingName}); 
    if (distance >= shadowMap_lightPositionEC.w) 
    { 
        discard; 
    } 
    distance /= shadowMap_lightPositionEC.w; // radius 
    gl_FragColor = czm_packDepth(distance); 
`;
  } else if (usesDepthTexture) {
    fsSource += "    gl_FragColor = vec4(1.0); \n";
  } else {
    fsSource += "    gl_FragColor = czm_packDepth(gl_FragCoord.z); \n";
  }
  fsSource += "} \n";
  sources.push(fsSource);
  return new ShaderSource_default({
    defines,
    sources
  });
};
ShadowMapShader.getShadowReceiveShaderKeyword = function(shadowMap, castShadows, isTerrain, hasTerrainNormal) {
  const usesDepthTexture = shadowMap._usesDepthTexture;
  const polygonOffsetSupported = shadowMap._polygonOffsetSupported;
  const isPointLight = shadowMap._isPointLight;
  const isSpotLight = shadowMap._isSpotLight;
  const hasCascades = shadowMap._numberOfCascades > 1;
  const debugCascadeColors = shadowMap.debugCascadeColors;
  const softShadows = shadowMap.softShadows;
  return `receiveShadow ${usesDepthTexture}${polygonOffsetSupported}${isPointLight}${isSpotLight}${hasCascades}${debugCascadeColors}${softShadows}${castShadows}${isTerrain}${hasTerrainNormal}`;
};
ShadowMapShader.createShadowReceiveVertexShader = function(vs, isTerrain, hasTerrainNormal) {
  const defines = vs.defines.slice(0);
  const sources = vs.sources.slice(0);
  defines.push("SHADOW_MAP");
  if (isTerrain) {
    if (hasTerrainNormal) {
      defines.push("GENERATE_POSITION_AND_NORMAL");
    } else {
      defines.push("GENERATE_POSITION");
    }
  }
  return new ShaderSource_default({
    defines,
    sources
  });
};
ShadowMapShader.createShadowReceiveFragmentShader = function(fs, shadowMap, castShadows, isTerrain, hasTerrainNormal) {
  const normalVaryingName = ShaderSource_default.findNormalVarying(fs);
  const hasNormalVarying = !isTerrain && defined_default(normalVaryingName) || isTerrain && hasTerrainNormal;
  const positionVaryingName = ShaderSource_default.findPositionVarying(fs);
  const hasPositionVarying = defined_default(positionVaryingName);
  const usesDepthTexture = shadowMap._usesDepthTexture;
  const polygonOffsetSupported = shadowMap._polygonOffsetSupported;
  const isPointLight = shadowMap._isPointLight;
  const isSpotLight = shadowMap._isSpotLight;
  const hasCascades = shadowMap._numberOfCascades > 1;
  const debugCascadeColors = shadowMap.debugCascadeColors;
  const softShadows = shadowMap.softShadows;
  const bias = isPointLight ? shadowMap._pointBias : isTerrain ? shadowMap._terrainBias : shadowMap._primitiveBias;
  const defines = fs.defines.slice(0);
  const sources = fs.sources.slice(0);
  const length3 = sources.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    sources[i2] = ShaderSource_default.replaceMain(
      sources[i2],
      "czm_shadow_receive_main"
    );
  }
  if (isPointLight) {
    defines.push("USE_CUBE_MAP_SHADOW");
  } else if (usesDepthTexture) {
    defines.push("USE_SHADOW_DEPTH_TEXTURE");
  }
  if (softShadows && !isPointLight) {
    defines.push("USE_SOFT_SHADOWS");
  }
  if (hasCascades && castShadows && isTerrain) {
    if (hasNormalVarying) {
      defines.push("ENABLE_VERTEX_LIGHTING");
    } else {
      defines.push("ENABLE_DAYNIGHT_SHADING");
    }
  }
  if (castShadows && bias.normalShading && hasNormalVarying) {
    defines.push("USE_NORMAL_SHADING");
    if (bias.normalShadingSmooth > 0) {
      defines.push("USE_NORMAL_SHADING_SMOOTH");
    }
  }
  let fsSource = "";
  if (isPointLight) {
    fsSource += "uniform samplerCube shadowMap_textureCube; \n";
  } else {
    fsSource += "uniform sampler2D shadowMap_texture; \n";
  }
  let returnPositionEC;
  if (hasPositionVarying) {
    returnPositionEC = `    return vec4(${positionVaryingName}, 1.0); 
`;
  } else {
    returnPositionEC = "#ifndef LOG_DEPTH \n    return czm_windowToEyeCoordinates(gl_FragCoord); \n#else \n    return vec4(v_logPositionEC, 1.0); \n#endif \n";
  }
  fsSource += `${"uniform mat4 shadowMap_matrix; \nuniform vec3 shadowMap_lightDirectionEC; \nuniform vec4 shadowMap_lightPositionEC; \nuniform vec4 shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness; \nuniform vec4 shadowMap_texelSizeDepthBiasAndNormalShadingSmooth; \n#ifdef LOG_DEPTH \nvarying vec3 v_logPositionEC; \n#endif \nvec4 getPositionEC() \n{ \n"}${returnPositionEC}} 
vec3 getNormalEC() 
{ 
${hasNormalVarying ? `    return normalize(${normalVaryingName}); 
` : "    return vec3(1.0); \n"}} 
void applyNormalOffset(inout vec4 positionEC, vec3 normalEC, float nDotL) 
{ 
${bias.normalOffset && hasNormalVarying ? "    float normalOffset = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.x; \n    float normalOffsetScale = 1.0 - nDotL; \n    vec3 offset = normalOffset * normalOffsetScale * normalEC; \n    positionEC.xyz += offset; \n" : ""}} 
`;
  fsSource += "void main() \n{ \n    czm_shadow_receive_main(); \n    vec4 positionEC = getPositionEC(); \n    vec3 normalEC = getNormalEC(); \n    float depth = -positionEC.z; \n";
  fsSource += "    czm_shadowParameters shadowParameters; \n    shadowParameters.texelStepSize = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.xy; \n    shadowParameters.depthBias = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.z; \n    shadowParameters.normalShadingSmooth = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.w; \n    shadowParameters.darkness = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.w; \n";
  if (isTerrain) {
    fsSource += "    shadowParameters.depthBias *= max(depth * 0.01, 1.0); \n";
  } else if (!polygonOffsetSupported) {
    fsSource += "    shadowParameters.depthBias *= mix(1.0, 100.0, depth * 0.0015); \n";
  }
  if (isPointLight) {
    fsSource += "    vec3 directionEC = positionEC.xyz - shadowMap_lightPositionEC.xyz; \n    float distance = length(directionEC); \n    directionEC = normalize(directionEC); \n    float radius = shadowMap_lightPositionEC.w; \n    // Stop early if the fragment is beyond the point light radius \n    if (distance > radius) \n    { \n        return; \n    } \n    vec3 directionWC  = czm_inverseViewRotation * directionEC; \n    shadowParameters.depth = distance / radius; \n    shadowParameters.nDotL = clamp(dot(normalEC, -directionEC), 0.0, 1.0); \n    shadowParameters.texCoords = directionWC; \n    float visibility = czm_shadowVisibility(shadowMap_textureCube, shadowParameters); \n";
  } else if (isSpotLight) {
    fsSource += "    vec3 directionEC = normalize(positionEC.xyz - shadowMap_lightPositionEC.xyz); \n    float nDotL = clamp(dot(normalEC, -directionEC), 0.0, 1.0); \n    applyNormalOffset(positionEC, normalEC, nDotL); \n    vec4 shadowPosition = shadowMap_matrix * positionEC; \n    // Spot light uses a perspective projection, so perform the perspective divide \n    shadowPosition /= shadowPosition.w; \n    // Stop early if the fragment is not in the shadow bounds \n    if (any(lessThan(shadowPosition.xyz, vec3(0.0))) || any(greaterThan(shadowPosition.xyz, vec3(1.0)))) \n    { \n        return; \n    } \n    shadowParameters.texCoords = shadowPosition.xy; \n    shadowParameters.depth = shadowPosition.z; \n    shadowParameters.nDotL = nDotL; \n    float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n";
  } else if (hasCascades) {
    fsSource += `${"    float maxDepth = shadowMap_cascadeSplits[1].w; \n    // Stop early if the eye depth exceeds the last cascade \n    if (depth > maxDepth) \n    { \n        return; \n    } \n    // Get the cascade based on the eye-space depth \n    vec4 weights = czm_cascadeWeights(depth); \n    // Apply normal offset \n    float nDotL = clamp(dot(normalEC, shadowMap_lightDirectionEC), 0.0, 1.0); \n    applyNormalOffset(positionEC, normalEC, nDotL); \n    // Transform position into the cascade \n    vec4 shadowPosition = czm_cascadeMatrix(weights) * positionEC; \n    // Get visibility \n    shadowParameters.texCoords = shadowPosition.xy; \n    shadowParameters.depth = shadowPosition.z; \n    shadowParameters.nDotL = nDotL; \n    float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n    // Fade out shadows that are far away \n    float shadowMapMaximumDistance = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.z; \n    float fade = max((depth - shadowMapMaximumDistance * 0.8) / (shadowMapMaximumDistance * 0.2), 0.0); \n    visibility = mix(visibility, 1.0, fade); \n"}${debugCascadeColors ? "    // Draw cascade colors for debugging \n    gl_FragColor *= czm_cascadeColor(weights); \n" : ""}`;
  } else {
    fsSource += "    float nDotL = clamp(dot(normalEC, shadowMap_lightDirectionEC), 0.0, 1.0); \n    applyNormalOffset(positionEC, normalEC, nDotL); \n    vec4 shadowPosition = shadowMap_matrix * positionEC; \n    // Stop early if the fragment is not in the shadow bounds \n    if (any(lessThan(shadowPosition.xyz, vec3(0.0))) || any(greaterThan(shadowPosition.xyz, vec3(1.0)))) \n    { \n        return; \n    } \n    shadowParameters.texCoords = shadowPosition.xy; \n    shadowParameters.depth = shadowPosition.z; \n    shadowParameters.nDotL = nDotL; \n    float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n";
  }
  fsSource += "    gl_FragColor.rgb *= visibility; \n} \n";
  sources.push(fsSource);
  return new ShaderSource_default({
    defines,
    sources
  });
};
var ShadowMapShader_default = ShadowMapShader;

// node_modules/cesium/Source/Scene/ShadowMap.js
function ShadowMap(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const context = options.context;
  if (!defined_default(context)) {
    throw new DeveloperError_default("context is required.");
  }
  if (!defined_default(options.lightCamera)) {
    throw new DeveloperError_default("lightCamera is required.");
  }
  if (defined_default(options.numberOfCascades) && options.numberOfCascades !== 1 && options.numberOfCascades !== 4) {
    throw new DeveloperError_default("Only one or four cascades are supported.");
  }
  this._enabled = defaultValue_default(options.enabled, true);
  this._softShadows = defaultValue_default(options.softShadows, false);
  this._normalOffset = defaultValue_default(options.normalOffset, true);
  this.dirty = true;
  this.fromLightSource = defaultValue_default(options.fromLightSource, true);
  this.darkness = defaultValue_default(options.darkness, 0.3);
  this._darkness = this.darkness;
  this.fadingEnabled = defaultValue_default(options.fadingEnabled, true);
  this.maximumDistance = defaultValue_default(options.maximumDistance, 5e3);
  this._outOfView = false;
  this._outOfViewPrevious = false;
  this._needsUpdate = true;
  let polygonOffsetSupported = true;
  if (FeatureDetection_default.isInternetExplorer() || FeatureDetection_default.isEdge() || (FeatureDetection_default.isChrome() || FeatureDetection_default.isFirefox()) && FeatureDetection_default.isWindows() && !context.depthTexture) {
    polygonOffsetSupported = false;
  }
  this._polygonOffsetSupported = polygonOffsetSupported;
  this._terrainBias = {
    polygonOffset: polygonOffsetSupported,
    polygonOffsetFactor: 1.1,
    polygonOffsetUnits: 4,
    normalOffset: this._normalOffset,
    normalOffsetScale: 0.5,
    normalShading: true,
    normalShadingSmooth: 0.3,
    depthBias: 1e-4
  };
  this._primitiveBias = {
    polygonOffset: polygonOffsetSupported,
    polygonOffsetFactor: 1.1,
    polygonOffsetUnits: 4,
    normalOffset: this._normalOffset,
    normalOffsetScale: 0.1,
    normalShading: true,
    normalShadingSmooth: 0.05,
    depthBias: 2e-5
  };
  this._pointBias = {
    polygonOffset: false,
    polygonOffsetFactor: 1.1,
    polygonOffsetUnits: 4,
    normalOffset: this._normalOffset,
    normalOffsetScale: 0,
    normalShading: true,
    normalShadingSmooth: 0.1,
    depthBias: 5e-4
  };
  this._depthAttachment = void 0;
  this._colorAttachment = void 0;
  this._shadowMapMatrix = new Matrix4_default();
  this._shadowMapTexture = void 0;
  this._lightDirectionEC = new Cartesian3_default();
  this._lightPositionEC = new Cartesian4_default();
  this._distance = 0;
  this._lightCamera = options.lightCamera;
  this._shadowMapCamera = new ShadowMapCamera();
  this._shadowMapCullingVolume = void 0;
  this._sceneCamera = void 0;
  this._boundingSphere = new BoundingSphere_default();
  this._isPointLight = defaultValue_default(options.isPointLight, false);
  this._pointLightRadius = defaultValue_default(options.pointLightRadius, 100);
  this._cascadesEnabled = this._isPointLight ? false : defaultValue_default(options.cascadesEnabled, true);
  this._numberOfCascades = !this._cascadesEnabled ? 0 : defaultValue_default(options.numberOfCascades, 4);
  this._fitNearFar = true;
  this._maximumCascadeDistances = [25, 150, 700, Number.MAX_VALUE];
  this._textureSize = new Cartesian2_default();
  this._isSpotLight = false;
  if (this._cascadesEnabled) {
    this._shadowMapCamera.frustum = new OrthographicOffCenterFrustum_default();
  } else if (defined_default(this._lightCamera.frustum.fov)) {
    this._isSpotLight = true;
  }
  this._cascadeSplits = [new Cartesian4_default(), new Cartesian4_default()];
  this._cascadeMatrices = [
    new Matrix4_default(),
    new Matrix4_default(),
    new Matrix4_default(),
    new Matrix4_default()
  ];
  this._cascadeDistances = new Cartesian4_default();
  let numberOfPasses;
  if (this._isPointLight) {
    numberOfPasses = 6;
  } else if (!this._cascadesEnabled) {
    numberOfPasses = 1;
  } else {
    numberOfPasses = this._numberOfCascades;
  }
  this._passes = new Array(numberOfPasses);
  for (let i2 = 0; i2 < numberOfPasses; ++i2) {
    this._passes[i2] = new ShadowPass(context);
  }
  this.debugShow = false;
  this.debugFreezeFrame = false;
  this._debugFreezeFrame = false;
  this._debugCascadeColors = false;
  this._debugLightFrustum = void 0;
  this._debugCameraFrustum = void 0;
  this._debugCascadeFrustums = new Array(this._numberOfCascades);
  this._debugShadowViewCommand = void 0;
  this._usesDepthTexture = context.depthTexture;
  if (this._isPointLight) {
    this._usesDepthTexture = false;
  }
  this._primitiveRenderState = void 0;
  this._terrainRenderState = void 0;
  this._pointRenderState = void 0;
  createRenderStates7(this);
  this._clearCommand = new ClearCommand_default({
    depth: 1,
    color: new Color_default()
  });
  this._clearPassState = new PassState_default(context);
  this._size = defaultValue_default(options.size, 2048);
  this.size = this._size;
}
ShadowMap.MAXIMUM_DISTANCE = 2e4;
function ShadowPass(context) {
  this.camera = new ShadowMapCamera();
  this.passState = new PassState_default(context);
  this.framebuffer = void 0;
  this.textureOffsets = void 0;
  this.commandList = [];
  this.cullingVolume = void 0;
}
function createRenderState2(colorMask, bias) {
  return RenderState_default.fromCache({
    cull: {
      enabled: true,
      face: CullFace_default.BACK
    },
    depthTest: {
      enabled: true
    },
    colorMask: {
      red: colorMask,
      green: colorMask,
      blue: colorMask,
      alpha: colorMask
    },
    depthMask: true,
    polygonOffset: {
      enabled: bias.polygonOffset,
      factor: bias.polygonOffsetFactor,
      units: bias.polygonOffsetUnits
    }
  });
}
function createRenderStates7(shadowMap) {
  const colorMask = !shadowMap._usesDepthTexture;
  shadowMap._primitiveRenderState = createRenderState2(
    colorMask,
    shadowMap._primitiveBias
  );
  shadowMap._terrainRenderState = createRenderState2(
    colorMask,
    shadowMap._terrainBias
  );
  shadowMap._pointRenderState = createRenderState2(
    colorMask,
    shadowMap._pointBias
  );
}
ShadowMap.prototype.debugCreateRenderStates = function() {
  createRenderStates7(this);
};
Object.defineProperties(ShadowMap.prototype, {
  enabled: {
    get: function() {
      return this._enabled;
    },
    set: function(value) {
      this.dirty = this._enabled !== value;
      this._enabled = value;
    }
  },
  normalOffset: {
    get: function() {
      return this._normalOffset;
    },
    set: function(value) {
      this.dirty = this._normalOffset !== value;
      this._normalOffset = value;
      this._terrainBias.normalOffset = value;
      this._primitiveBias.normalOffset = value;
      this._pointBias.normalOffset = value;
    }
  },
  softShadows: {
    get: function() {
      return this._softShadows;
    },
    set: function(value) {
      this.dirty = this._softShadows !== value;
      this._softShadows = value;
    }
  },
  size: {
    get: function() {
      return this._size;
    },
    set: function(value) {
      resize(this, value);
    }
  },
  outOfView: {
    get: function() {
      return this._outOfView;
    }
  },
  shadowMapCullingVolume: {
    get: function() {
      return this._shadowMapCullingVolume;
    }
  },
  passes: {
    get: function() {
      return this._passes;
    }
  },
  isPointLight: {
    get: function() {
      return this._isPointLight;
    }
  },
  debugCascadeColors: {
    get: function() {
      return this._debugCascadeColors;
    },
    set: function(value) {
      this.dirty = this._debugCascadeColors !== value;
      this._debugCascadeColors = value;
    }
  }
});
function destroyFramebuffer2(shadowMap) {
  const length3 = shadowMap._passes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const pass = shadowMap._passes[i2];
    const framebuffer = pass.framebuffer;
    if (defined_default(framebuffer) && !framebuffer.isDestroyed()) {
      framebuffer.destroy();
    }
    pass.framebuffer = void 0;
  }
  shadowMap._depthAttachment = shadowMap._depthAttachment && shadowMap._depthAttachment.destroy();
  shadowMap._colorAttachment = shadowMap._colorAttachment && shadowMap._colorAttachment.destroy();
}
function createFramebufferColor(shadowMap, context) {
  const depthRenderbuffer = new Renderbuffer_default({
    context,
    width: shadowMap._textureSize.x,
    height: shadowMap._textureSize.y,
    format: RenderbufferFormat_default.DEPTH_COMPONENT16
  });
  const colorTexture = new Texture_default({
    context,
    width: shadowMap._textureSize.x,
    height: shadowMap._textureSize.y,
    pixelFormat: PixelFormat_default.RGBA,
    pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
    sampler: Sampler_default.NEAREST
  });
  const framebuffer = new Framebuffer_default({
    context,
    depthRenderbuffer,
    colorTextures: [colorTexture],
    destroyAttachments: false
  });
  const length3 = shadowMap._passes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const pass = shadowMap._passes[i2];
    pass.framebuffer = framebuffer;
    pass.passState.framebuffer = framebuffer;
  }
  shadowMap._shadowMapTexture = colorTexture;
  shadowMap._depthAttachment = depthRenderbuffer;
  shadowMap._colorAttachment = colorTexture;
}
function createFramebufferDepth(shadowMap, context) {
  const depthStencilTexture = new Texture_default({
    context,
    width: shadowMap._textureSize.x,
    height: shadowMap._textureSize.y,
    pixelFormat: PixelFormat_default.DEPTH_STENCIL,
    pixelDatatype: PixelDatatype_default.UNSIGNED_INT_24_8,
    sampler: Sampler_default.NEAREST
  });
  const framebuffer = new Framebuffer_default({
    context,
    depthStencilTexture,
    destroyAttachments: false
  });
  const length3 = shadowMap._passes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const pass = shadowMap._passes[i2];
    pass.framebuffer = framebuffer;
    pass.passState.framebuffer = framebuffer;
  }
  shadowMap._shadowMapTexture = depthStencilTexture;
  shadowMap._depthAttachment = depthStencilTexture;
}
function createFramebufferCube(shadowMap, context) {
  const depthRenderbuffer = new Renderbuffer_default({
    context,
    width: shadowMap._textureSize.x,
    height: shadowMap._textureSize.y,
    format: RenderbufferFormat_default.DEPTH_COMPONENT16
  });
  const cubeMap = new CubeMap_default({
    context,
    width: shadowMap._textureSize.x,
    height: shadowMap._textureSize.y,
    pixelFormat: PixelFormat_default.RGBA,
    pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
    sampler: Sampler_default.NEAREST
  });
  const faces2 = [
    cubeMap.negativeX,
    cubeMap.negativeY,
    cubeMap.negativeZ,
    cubeMap.positiveX,
    cubeMap.positiveY,
    cubeMap.positiveZ
  ];
  for (let i2 = 0; i2 < 6; ++i2) {
    const framebuffer = new Framebuffer_default({
      context,
      depthRenderbuffer,
      colorTextures: [faces2[i2]],
      destroyAttachments: false
    });
    const pass = shadowMap._passes[i2];
    pass.framebuffer = framebuffer;
    pass.passState.framebuffer = framebuffer;
  }
  shadowMap._shadowMapTexture = cubeMap;
  shadowMap._depthAttachment = depthRenderbuffer;
  shadowMap._colorAttachment = cubeMap;
}
function createFramebuffer2(shadowMap, context) {
  if (shadowMap._isPointLight) {
    createFramebufferCube(shadowMap, context);
  } else if (shadowMap._usesDepthTexture) {
    createFramebufferDepth(shadowMap, context);
  } else {
    createFramebufferColor(shadowMap, context);
  }
}
function checkFramebuffer(shadowMap, context) {
  if (shadowMap._usesDepthTexture && shadowMap._passes[0].framebuffer.status !== WebGLConstants_default.FRAMEBUFFER_COMPLETE) {
    shadowMap._usesDepthTexture = false;
    createRenderStates7(shadowMap);
    destroyFramebuffer2(shadowMap);
    createFramebuffer2(shadowMap, context);
  }
}
function updateFramebuffer(shadowMap, context) {
  if (!defined_default(shadowMap._passes[0].framebuffer) || shadowMap._shadowMapTexture.width !== shadowMap._textureSize.x) {
    destroyFramebuffer2(shadowMap);
    createFramebuffer2(shadowMap, context);
    checkFramebuffer(shadowMap, context);
    clearFramebuffer(shadowMap, context);
  }
}
function clearFramebuffer(shadowMap, context, shadowPass) {
  shadowPass = defaultValue_default(shadowPass, 0);
  if (shadowMap._isPointLight || shadowPass === 0) {
    shadowMap._clearCommand.framebuffer = shadowMap._passes[shadowPass].framebuffer;
    shadowMap._clearCommand.execute(context, shadowMap._clearPassState);
  }
}
function resize(shadowMap, size) {
  shadowMap._size = size;
  const passes = shadowMap._passes;
  const numberOfPasses = passes.length;
  const textureSize = shadowMap._textureSize;
  if (shadowMap._isPointLight) {
    size = ContextLimits_default.maximumCubeMapSize >= size ? size : ContextLimits_default.maximumCubeMapSize;
    textureSize.x = size;
    textureSize.y = size;
    const faceViewport = new BoundingRectangle_default(0, 0, size, size);
    passes[0].passState.viewport = faceViewport;
    passes[1].passState.viewport = faceViewport;
    passes[2].passState.viewport = faceViewport;
    passes[3].passState.viewport = faceViewport;
    passes[4].passState.viewport = faceViewport;
    passes[5].passState.viewport = faceViewport;
  } else if (numberOfPasses === 1) {
    size = ContextLimits_default.maximumTextureSize >= size ? size : ContextLimits_default.maximumTextureSize;
    textureSize.x = size;
    textureSize.y = size;
    passes[0].passState.viewport = new BoundingRectangle_default(0, 0, size, size);
  } else if (numberOfPasses === 4) {
    size = ContextLimits_default.maximumTextureSize >= size * 2 ? size : ContextLimits_default.maximumTextureSize / 2;
    textureSize.x = size * 2;
    textureSize.y = size * 2;
    passes[0].passState.viewport = new BoundingRectangle_default(0, 0, size, size);
    passes[1].passState.viewport = new BoundingRectangle_default(size, 0, size, size);
    passes[2].passState.viewport = new BoundingRectangle_default(0, size, size, size);
    passes[3].passState.viewport = new BoundingRectangle_default(
      size,
      size,
      size,
      size
    );
  }
  shadowMap._clearPassState.viewport = new BoundingRectangle_default(
    0,
    0,
    textureSize.x,
    textureSize.y
  );
  for (let i2 = 0; i2 < numberOfPasses; ++i2) {
    const pass = passes[i2];
    const viewport = pass.passState.viewport;
    const biasX = viewport.x / textureSize.x;
    const biasY = viewport.y / textureSize.y;
    const scaleX = viewport.width / textureSize.x;
    const scaleY = viewport.height / textureSize.y;
    pass.textureOffsets = new Matrix4_default(
      scaleX,
      0,
      0,
      biasX,
      0,
      scaleY,
      0,
      biasY,
      0,
      0,
      1,
      0,
      0,
      0,
      0,
      1
    );
  }
}
var scratchViewport3 = new BoundingRectangle_default();
function createDebugShadowViewCommand(shadowMap, context) {
  let fs;
  if (shadowMap._isPointLight) {
    fs = "uniform samplerCube shadowMap_textureCube; \nvarying vec2 v_textureCoordinates; \nvoid main() \n{ \n    vec2 uv = v_textureCoordinates; \n    vec3 dir; \n \n    if (uv.y < 0.5) \n    { \n        if (uv.x < 0.333) \n        { \n            dir.x = -1.0; \n            dir.y = uv.x * 6.0 - 1.0; \n            dir.z = uv.y * 4.0 - 1.0; \n        } \n        else if (uv.x < 0.666) \n        { \n            dir.y = -1.0; \n            dir.x = uv.x * 6.0 - 3.0; \n            dir.z = uv.y * 4.0 - 1.0; \n        } \n        else \n        { \n            dir.z = -1.0; \n            dir.x = uv.x * 6.0 - 5.0; \n            dir.y = uv.y * 4.0 - 1.0; \n        } \n    } \n    else \n    { \n        if (uv.x < 0.333) \n        { \n            dir.x = 1.0; \n            dir.y = uv.x * 6.0 - 1.0; \n            dir.z = uv.y * 4.0 - 3.0; \n        } \n        else if (uv.x < 0.666) \n        { \n            dir.y = 1.0; \n            dir.x = uv.x * 6.0 - 3.0; \n            dir.z = uv.y * 4.0 - 3.0; \n        } \n        else \n        { \n            dir.z = 1.0; \n            dir.x = uv.x * 6.0 - 5.0; \n            dir.y = uv.y * 4.0 - 3.0; \n        } \n    } \n \n    float shadow = czm_unpackDepth(textureCube(shadowMap_textureCube, dir)); \n    gl_FragColor = vec4(vec3(shadow), 1.0); \n} \n";
  } else {
    fs = `${"uniform sampler2D shadowMap_texture; \nvarying vec2 v_textureCoordinates; \nvoid main() \n{ \n"}${shadowMap._usesDepthTexture ? "    float shadow = texture2D(shadowMap_texture, v_textureCoordinates).r; \n" : "    float shadow = czm_unpackDepth(texture2D(shadowMap_texture, v_textureCoordinates)); \n"}    gl_FragColor = vec4(vec3(shadow), 1.0); 
} 
`;
  }
  const drawCommand = context.createViewportQuadCommand(fs, {
    uniformMap: {
      shadowMap_texture: function() {
        return shadowMap._shadowMapTexture;
      },
      shadowMap_textureCube: function() {
        return shadowMap._shadowMapTexture;
      }
    }
  });
  drawCommand.pass = Pass_default.OVERLAY;
  return drawCommand;
}
function updateDebugShadowViewCommand(shadowMap, frameState) {
  const context = frameState.context;
  const screenWidth = frameState.context.drawingBufferWidth;
  const screenHeight = frameState.context.drawingBufferHeight;
  const size = Math.min(screenWidth, screenHeight) * 0.3;
  const viewport = scratchViewport3;
  viewport.x = screenWidth - size;
  viewport.y = 0;
  viewport.width = size;
  viewport.height = size;
  let debugCommand = shadowMap._debugShadowViewCommand;
  if (!defined_default(debugCommand)) {
    debugCommand = createDebugShadowViewCommand(shadowMap, context);
    shadowMap._debugShadowViewCommand = debugCommand;
  }
  if (!defined_default(debugCommand.renderState) || !BoundingRectangle_default.equals(debugCommand.renderState.viewport, viewport)) {
    debugCommand.renderState = RenderState_default.fromCache({
      viewport: BoundingRectangle_default.clone(viewport)
    });
  }
  frameState.commandList.push(shadowMap._debugShadowViewCommand);
}
var frustumCornersNDC2 = new Array(8);
frustumCornersNDC2[0] = new Cartesian4_default(-1, -1, -1, 1);
frustumCornersNDC2[1] = new Cartesian4_default(1, -1, -1, 1);
frustumCornersNDC2[2] = new Cartesian4_default(1, 1, -1, 1);
frustumCornersNDC2[3] = new Cartesian4_default(-1, 1, -1, 1);
frustumCornersNDC2[4] = new Cartesian4_default(-1, -1, 1, 1);
frustumCornersNDC2[5] = new Cartesian4_default(1, -1, 1, 1);
frustumCornersNDC2[6] = new Cartesian4_default(1, 1, 1, 1);
frustumCornersNDC2[7] = new Cartesian4_default(-1, 1, 1, 1);
var scratchMatrix6 = new Matrix4_default();
var scratchFrustumCorners2 = new Array(8);
for (let i2 = 0; i2 < 8; ++i2) {
  scratchFrustumCorners2[i2] = new Cartesian4_default();
}
function createDebugPointLight(modelMatrix, color) {
  const box = new GeometryInstance_default({
    geometry: new BoxOutlineGeometry_default({
      minimum: new Cartesian3_default(-0.5, -0.5, -0.5),
      maximum: new Cartesian3_default(0.5, 0.5, 0.5)
    }),
    attributes: {
      color: ColorGeometryInstanceAttribute_default.fromColor(color)
    }
  });
  const sphere = new GeometryInstance_default({
    geometry: new SphereOutlineGeometry_default({
      radius: 0.5
    }),
    attributes: {
      color: ColorGeometryInstanceAttribute_default.fromColor(color)
    }
  });
  return new Primitive_default({
    geometryInstances: [box, sphere],
    appearance: new PerInstanceColorAppearance_default({
      translucent: false,
      flat: true
    }),
    asynchronous: false,
    modelMatrix
  });
}
var debugOutlineColors = [Color_default.RED, Color_default.GREEN, Color_default.BLUE, Color_default.MAGENTA];
var scratchScale6 = new Cartesian3_default();
function applyDebugSettings2(shadowMap, frameState) {
  updateDebugShadowViewCommand(shadowMap, frameState);
  const enterFreezeFrame = shadowMap.debugFreezeFrame && !shadowMap._debugFreezeFrame;
  shadowMap._debugFreezeFrame = shadowMap.debugFreezeFrame;
  if (shadowMap.debugFreezeFrame) {
    if (enterFreezeFrame) {
      shadowMap._debugCameraFrustum = shadowMap._debugCameraFrustum && shadowMap._debugCameraFrustum.destroy();
      shadowMap._debugCameraFrustum = new DebugCameraPrimitive_default({
        camera: shadowMap._sceneCamera,
        color: Color_default.CYAN,
        updateOnChange: false
      });
    }
    shadowMap._debugCameraFrustum.update(frameState);
  }
  if (shadowMap._cascadesEnabled) {
    if (shadowMap.debugFreezeFrame) {
      if (enterFreezeFrame) {
        shadowMap._debugLightFrustum = shadowMap._debugLightFrustum && shadowMap._debugLightFrustum.destroy();
        shadowMap._debugLightFrustum = new DebugCameraPrimitive_default({
          camera: shadowMap._shadowMapCamera,
          color: Color_default.YELLOW,
          updateOnChange: false
        });
      }
      shadowMap._debugLightFrustum.update(frameState);
      for (let i2 = 0; i2 < shadowMap._numberOfCascades; ++i2) {
        if (enterFreezeFrame) {
          shadowMap._debugCascadeFrustums[i2] = shadowMap._debugCascadeFrustums[i2] && shadowMap._debugCascadeFrustums[i2].destroy();
          shadowMap._debugCascadeFrustums[i2] = new DebugCameraPrimitive_default({
            camera: shadowMap._passes[i2].camera,
            color: debugOutlineColors[i2],
            updateOnChange: false
          });
        }
        shadowMap._debugCascadeFrustums[i2].update(frameState);
      }
    }
  } else if (shadowMap._isPointLight) {
    if (!defined_default(shadowMap._debugLightFrustum) || shadowMap._needsUpdate) {
      const translation3 = shadowMap._shadowMapCamera.positionWC;
      const rotation = Quaternion_default.IDENTITY;
      const uniformScale = shadowMap._pointLightRadius * 2;
      const scale = Cartesian3_default.fromElements(
        uniformScale,
        uniformScale,
        uniformScale,
        scratchScale6
      );
      const modelMatrix = Matrix4_default.fromTranslationQuaternionRotationScale(
        translation3,
        rotation,
        scale,
        scratchMatrix6
      );
      shadowMap._debugLightFrustum = shadowMap._debugLightFrustum && shadowMap._debugLightFrustum.destroy();
      shadowMap._debugLightFrustum = createDebugPointLight(
        modelMatrix,
        Color_default.YELLOW
      );
    }
    shadowMap._debugLightFrustum.update(frameState);
  } else {
    if (!defined_default(shadowMap._debugLightFrustum) || shadowMap._needsUpdate) {
      shadowMap._debugLightFrustum = new DebugCameraPrimitive_default({
        camera: shadowMap._shadowMapCamera,
        color: Color_default.YELLOW,
        updateOnChange: false
      });
    }
    shadowMap._debugLightFrustum.update(frameState);
  }
}
function ShadowMapCamera() {
  this.viewMatrix = new Matrix4_default();
  this.inverseViewMatrix = new Matrix4_default();
  this.frustum = void 0;
  this.positionCartographic = new Cartographic_default();
  this.positionWC = new Cartesian3_default();
  this.directionWC = Cartesian3_default.clone(Cartesian3_default.UNIT_Z);
  this.upWC = Cartesian3_default.clone(Cartesian3_default.UNIT_Y);
  this.rightWC = Cartesian3_default.clone(Cartesian3_default.UNIT_X);
  this.viewProjectionMatrix = new Matrix4_default();
}
ShadowMapCamera.prototype.clone = function(camera) {
  Matrix4_default.clone(camera.viewMatrix, this.viewMatrix);
  Matrix4_default.clone(camera.inverseViewMatrix, this.inverseViewMatrix);
  this.frustum = camera.frustum.clone(this.frustum);
  Cartographic_default.clone(camera.positionCartographic, this.positionCartographic);
  Cartesian3_default.clone(camera.positionWC, this.positionWC);
  Cartesian3_default.clone(camera.directionWC, this.directionWC);
  Cartesian3_default.clone(camera.upWC, this.upWC);
  Cartesian3_default.clone(camera.rightWC, this.rightWC);
};
var scaleBiasMatrix = new Matrix4_default(
  0.5,
  0,
  0,
  0.5,
  0,
  0.5,
  0,
  0.5,
  0,
  0,
  0.5,
  0.5,
  0,
  0,
  0,
  1
);
ShadowMapCamera.prototype.getViewProjection = function() {
  const view = this.viewMatrix;
  const projection = this.frustum.projectionMatrix;
  Matrix4_default.multiply(projection, view, this.viewProjectionMatrix);
  Matrix4_default.multiply(
    scaleBiasMatrix,
    this.viewProjectionMatrix,
    this.viewProjectionMatrix
  );
  return this.viewProjectionMatrix;
};
var scratchSplits2 = new Array(5);
var scratchFrustum = new PerspectiveFrustum_default();
var scratchCascadeDistances = new Array(4);
var scratchMin5 = new Cartesian3_default();
var scratchMax5 = new Cartesian3_default();
function computeCascades(shadowMap, frameState) {
  const shadowMapCamera = shadowMap._shadowMapCamera;
  const sceneCamera = shadowMap._sceneCamera;
  const cameraNear = sceneCamera.frustum.near;
  const cameraFar = sceneCamera.frustum.far;
  const numberOfCascades = shadowMap._numberOfCascades;
  let i2;
  const range2 = cameraFar - cameraNear;
  const ratio = cameraFar / cameraNear;
  let lambda = 0.9;
  let clampCascadeDistances = false;
  if (frameState.shadowState.closestObjectSize < 200) {
    clampCascadeDistances = true;
    lambda = 0.9;
  }
  const cascadeDistances = scratchCascadeDistances;
  const splits = scratchSplits2;
  splits[0] = cameraNear;
  splits[numberOfCascades] = cameraFar;
  for (i2 = 0; i2 < numberOfCascades; ++i2) {
    const p2 = (i2 + 1) / numberOfCascades;
    const logScale = cameraNear * Math.pow(ratio, p2);
    const uniformScale = cameraNear + range2 * p2;
    const split = Math_default.lerp(uniformScale, logScale, lambda);
    splits[i2 + 1] = split;
    cascadeDistances[i2] = split - splits[i2];
  }
  if (clampCascadeDistances) {
    for (i2 = 0; i2 < numberOfCascades; ++i2) {
      cascadeDistances[i2] = Math.min(
        cascadeDistances[i2],
        shadowMap._maximumCascadeDistances[i2]
      );
    }
    let distance2 = splits[0];
    for (i2 = 0; i2 < numberOfCascades - 1; ++i2) {
      distance2 += cascadeDistances[i2];
      splits[i2 + 1] = distance2;
    }
  }
  Cartesian4_default.unpack(splits, 0, shadowMap._cascadeSplits[0]);
  Cartesian4_default.unpack(splits, 1, shadowMap._cascadeSplits[1]);
  Cartesian4_default.unpack(cascadeDistances, 0, shadowMap._cascadeDistances);
  const shadowFrustum = shadowMapCamera.frustum;
  const left = shadowFrustum.left;
  const right = shadowFrustum.right;
  const bottom = shadowFrustum.bottom;
  const top = shadowFrustum.top;
  const near = shadowFrustum.near;
  const far = shadowFrustum.far;
  const position = shadowMapCamera.positionWC;
  const direction2 = shadowMapCamera.directionWC;
  const up = shadowMapCamera.upWC;
  const cascadeSubFrustum = sceneCamera.frustum.clone(scratchFrustum);
  const shadowViewProjection = shadowMapCamera.getViewProjection();
  for (i2 = 0; i2 < numberOfCascades; ++i2) {
    cascadeSubFrustum.near = splits[i2];
    cascadeSubFrustum.far = splits[i2 + 1];
    const viewProjection = Matrix4_default.multiply(
      cascadeSubFrustum.projectionMatrix,
      sceneCamera.viewMatrix,
      scratchMatrix6
    );
    const inverseViewProjection = Matrix4_default.inverse(
      viewProjection,
      scratchMatrix6
    );
    const shadowMapMatrix = Matrix4_default.multiply(
      shadowViewProjection,
      inverseViewProjection,
      scratchMatrix6
    );
    const min3 = Cartesian3_default.fromElements(
      Number.MAX_VALUE,
      Number.MAX_VALUE,
      Number.MAX_VALUE,
      scratchMin5
    );
    const max3 = Cartesian3_default.fromElements(
      -Number.MAX_VALUE,
      -Number.MAX_VALUE,
      -Number.MAX_VALUE,
      scratchMax5
    );
    for (let k = 0; k < 8; ++k) {
      const corner = Cartesian4_default.clone(
        frustumCornersNDC2[k],
        scratchFrustumCorners2[k]
      );
      Matrix4_default.multiplyByVector(shadowMapMatrix, corner, corner);
      Cartesian3_default.divideByScalar(corner, corner.w, corner);
      Cartesian3_default.minimumByComponent(corner, min3, min3);
      Cartesian3_default.maximumByComponent(corner, max3, max3);
    }
    min3.x = Math.max(min3.x, 0);
    min3.y = Math.max(min3.y, 0);
    min3.z = 0;
    max3.x = Math.min(max3.x, 1);
    max3.y = Math.min(max3.y, 1);
    max3.z = Math.min(max3.z, 1);
    const pass = shadowMap._passes[i2];
    const cascadeCamera = pass.camera;
    cascadeCamera.clone(shadowMapCamera);
    const frustum = cascadeCamera.frustum;
    frustum.left = left + min3.x * (right - left);
    frustum.right = left + max3.x * (right - left);
    frustum.bottom = bottom + min3.y * (top - bottom);
    frustum.top = bottom + max3.y * (top - bottom);
    frustum.near = near + min3.z * (far - near);
    frustum.far = near + max3.z * (far - near);
    pass.cullingVolume = cascadeCamera.frustum.computeCullingVolume(
      position,
      direction2,
      up
    );
    const cascadeMatrix = shadowMap._cascadeMatrices[i2];
    Matrix4_default.multiply(
      cascadeCamera.getViewProjection(),
      sceneCamera.inverseViewMatrix,
      cascadeMatrix
    );
    Matrix4_default.multiply(pass.textureOffsets, cascadeMatrix, cascadeMatrix);
  }
}
var scratchLightView = new Matrix4_default();
var scratchRight3 = new Cartesian3_default();
var scratchUp2 = new Cartesian3_default();
var scratchTranslation2 = new Cartesian3_default();
function fitShadowMapToScene(shadowMap, frameState) {
  const shadowMapCamera = shadowMap._shadowMapCamera;
  const sceneCamera = shadowMap._sceneCamera;
  const viewProjection = Matrix4_default.multiply(
    sceneCamera.frustum.projectionMatrix,
    sceneCamera.viewMatrix,
    scratchMatrix6
  );
  const inverseViewProjection = Matrix4_default.inverse(viewProjection, scratchMatrix6);
  const lightDir = shadowMapCamera.directionWC;
  let lightUp = sceneCamera.directionWC;
  if (Cartesian3_default.equalsEpsilon(lightDir, lightUp, Math_default.EPSILON10)) {
    lightUp = sceneCamera.upWC;
  }
  const lightRight = Cartesian3_default.cross(lightDir, lightUp, scratchRight3);
  lightUp = Cartesian3_default.cross(lightRight, lightDir, scratchUp2);
  Cartesian3_default.normalize(lightUp, lightUp);
  Cartesian3_default.normalize(lightRight, lightRight);
  const lightPosition = Cartesian3_default.fromElements(
    0,
    0,
    0,
    scratchTranslation2
  );
  let lightView = Matrix4_default.computeView(
    lightPosition,
    lightDir,
    lightUp,
    lightRight,
    scratchLightView
  );
  const cameraToLight = Matrix4_default.multiply(
    lightView,
    inverseViewProjection,
    scratchMatrix6
  );
  const min3 = Cartesian3_default.fromElements(
    Number.MAX_VALUE,
    Number.MAX_VALUE,
    Number.MAX_VALUE,
    scratchMin5
  );
  const max3 = Cartesian3_default.fromElements(
    -Number.MAX_VALUE,
    -Number.MAX_VALUE,
    -Number.MAX_VALUE,
    scratchMax5
  );
  for (let i2 = 0; i2 < 8; ++i2) {
    const corner = Cartesian4_default.clone(
      frustumCornersNDC2[i2],
      scratchFrustumCorners2[i2]
    );
    Matrix4_default.multiplyByVector(cameraToLight, corner, corner);
    Cartesian3_default.divideByScalar(corner, corner.w, corner);
    Cartesian3_default.minimumByComponent(corner, min3, min3);
    Cartesian3_default.maximumByComponent(corner, max3, max3);
  }
  max3.z += 1e3;
  min3.z -= 10;
  const translation3 = scratchTranslation2;
  translation3.x = -(0.5 * (min3.x + max3.x));
  translation3.y = -(0.5 * (min3.y + max3.y));
  translation3.z = -max3.z;
  const translationMatrix = Matrix4_default.fromTranslation(translation3, scratchMatrix6);
  lightView = Matrix4_default.multiply(translationMatrix, lightView, lightView);
  const halfWidth = 0.5 * (max3.x - min3.x);
  const halfHeight = 0.5 * (max3.y - min3.y);
  const depth = max3.z - min3.z;
  const frustum = shadowMapCamera.frustum;
  frustum.left = -halfWidth;
  frustum.right = halfWidth;
  frustum.bottom = -halfHeight;
  frustum.top = halfHeight;
  frustum.near = 0.01;
  frustum.far = depth;
  Matrix4_default.clone(lightView, shadowMapCamera.viewMatrix);
  Matrix4_default.inverse(lightView, shadowMapCamera.inverseViewMatrix);
  Matrix4_default.getTranslation(
    shadowMapCamera.inverseViewMatrix,
    shadowMapCamera.positionWC
  );
  frameState.mapProjection.ellipsoid.cartesianToCartographic(
    shadowMapCamera.positionWC,
    shadowMapCamera.positionCartographic
  );
  Cartesian3_default.clone(lightDir, shadowMapCamera.directionWC);
  Cartesian3_default.clone(lightUp, shadowMapCamera.upWC);
  Cartesian3_default.clone(lightRight, shadowMapCamera.rightWC);
}
var directions = [
  new Cartesian3_default(-1, 0, 0),
  new Cartesian3_default(0, -1, 0),
  new Cartesian3_default(0, 0, -1),
  new Cartesian3_default(1, 0, 0),
  new Cartesian3_default(0, 1, 0),
  new Cartesian3_default(0, 0, 1)
];
var ups = [
  new Cartesian3_default(0, -1, 0),
  new Cartesian3_default(0, 0, -1),
  new Cartesian3_default(0, -1, 0),
  new Cartesian3_default(0, -1, 0),
  new Cartesian3_default(0, 0, 1),
  new Cartesian3_default(0, -1, 0)
];
var rights = [
  new Cartesian3_default(0, 0, 1),
  new Cartesian3_default(1, 0, 0),
  new Cartesian3_default(-1, 0, 0),
  new Cartesian3_default(0, 0, -1),
  new Cartesian3_default(1, 0, 0),
  new Cartesian3_default(1, 0, 0)
];
function computeOmnidirectional(shadowMap, frameState) {
  const frustum = new PerspectiveFrustum_default();
  frustum.fov = Math_default.PI_OVER_TWO;
  frustum.near = 1;
  frustum.far = shadowMap._pointLightRadius;
  frustum.aspectRatio = 1;
  for (let i2 = 0; i2 < 6; ++i2) {
    const camera = shadowMap._passes[i2].camera;
    camera.positionWC = shadowMap._shadowMapCamera.positionWC;
    camera.positionCartographic = frameState.mapProjection.ellipsoid.cartesianToCartographic(
      camera.positionWC,
      camera.positionCartographic
    );
    camera.directionWC = directions[i2];
    camera.upWC = ups[i2];
    camera.rightWC = rights[i2];
    Matrix4_default.computeView(
      camera.positionWC,
      camera.directionWC,
      camera.upWC,
      camera.rightWC,
      camera.viewMatrix
    );
    Matrix4_default.inverse(camera.viewMatrix, camera.inverseViewMatrix);
    camera.frustum = frustum;
  }
}
var scratchCartesian111 = new Cartesian3_default();
var scratchCartesian213 = new Cartesian3_default();
var scratchBoundingSphere6 = new BoundingSphere_default();
var scratchCenter8 = scratchBoundingSphere6.center;
function checkVisibility(shadowMap, frameState) {
  const sceneCamera = shadowMap._sceneCamera;
  const shadowMapCamera = shadowMap._shadowMapCamera;
  const boundingSphere = scratchBoundingSphere6;
  if (shadowMap._cascadesEnabled) {
    if (sceneCamera.frustum.near >= shadowMap.maximumDistance) {
      shadowMap._outOfView = true;
      shadowMap._needsUpdate = false;
      return;
    }
    const surfaceNormal = frameState.mapProjection.ellipsoid.geodeticSurfaceNormal(
      sceneCamera.positionWC,
      scratchCartesian111
    );
    const lightDirection = Cartesian3_default.negate(
      shadowMapCamera.directionWC,
      scratchCartesian213
    );
    const dot2 = Cartesian3_default.dot(surfaceNormal, lightDirection);
    if (shadowMap.fadingEnabled) {
      const darknessAmount = Math_default.clamp(dot2 / 0.1, 0, 1);
      shadowMap._darkness = Math_default.lerp(
        1,
        shadowMap.darkness,
        darknessAmount
      );
    } else {
      shadowMap._darkness = shadowMap.darkness;
    }
    if (dot2 < 0) {
      shadowMap._outOfView = true;
      shadowMap._needsUpdate = false;
      return;
    }
    shadowMap._needsUpdate = true;
    shadowMap._outOfView = false;
  } else if (shadowMap._isPointLight) {
    boundingSphere.center = shadowMapCamera.positionWC;
    boundingSphere.radius = shadowMap._pointLightRadius;
    shadowMap._outOfView = frameState.cullingVolume.computeVisibility(boundingSphere) === Intersect_default.OUTSIDE;
    shadowMap._needsUpdate = !shadowMap._outOfView && !shadowMap._boundingSphere.equals(boundingSphere);
    BoundingSphere_default.clone(boundingSphere, shadowMap._boundingSphere);
  } else {
    const frustumRadius = shadowMapCamera.frustum.far / 2;
    const frustumCenter = Cartesian3_default.add(
      shadowMapCamera.positionWC,
      Cartesian3_default.multiplyByScalar(
        shadowMapCamera.directionWC,
        frustumRadius,
        scratchCenter8
      ),
      scratchCenter8
    );
    boundingSphere.center = frustumCenter;
    boundingSphere.radius = frustumRadius;
    shadowMap._outOfView = frameState.cullingVolume.computeVisibility(boundingSphere) === Intersect_default.OUTSIDE;
    shadowMap._needsUpdate = !shadowMap._outOfView && !shadowMap._boundingSphere.equals(boundingSphere);
    BoundingSphere_default.clone(boundingSphere, shadowMap._boundingSphere);
  }
}
function updateCameras(shadowMap, frameState) {
  const camera = frameState.camera;
  const lightCamera = shadowMap._lightCamera;
  const sceneCamera = shadowMap._sceneCamera;
  const shadowMapCamera = shadowMap._shadowMapCamera;
  if (shadowMap._cascadesEnabled) {
    Cartesian3_default.clone(lightCamera.directionWC, shadowMapCamera.directionWC);
  } else if (shadowMap._isPointLight) {
    Cartesian3_default.clone(lightCamera.positionWC, shadowMapCamera.positionWC);
  } else {
    shadowMapCamera.clone(lightCamera);
  }
  const lightDirection = shadowMap._lightDirectionEC;
  Matrix4_default.multiplyByPointAsVector(
    camera.viewMatrix,
    shadowMapCamera.directionWC,
    lightDirection
  );
  Cartesian3_default.normalize(lightDirection, lightDirection);
  Cartesian3_default.negate(lightDirection, lightDirection);
  Matrix4_default.multiplyByPoint(
    camera.viewMatrix,
    shadowMapCamera.positionWC,
    shadowMap._lightPositionEC
  );
  shadowMap._lightPositionEC.w = shadowMap._pointLightRadius;
  let near;
  let far;
  if (shadowMap._fitNearFar) {
    near = Math.min(
      frameState.shadowState.nearPlane,
      shadowMap.maximumDistance
    );
    far = Math.min(frameState.shadowState.farPlane, shadowMap.maximumDistance);
    far = Math.max(far, near + 1);
  } else {
    near = camera.frustum.near;
    far = shadowMap.maximumDistance;
  }
  shadowMap._sceneCamera = Camera_default.clone(camera, sceneCamera);
  camera.frustum.clone(shadowMap._sceneCamera.frustum);
  shadowMap._sceneCamera.frustum.near = near;
  shadowMap._sceneCamera.frustum.far = far;
  shadowMap._distance = far - near;
  checkVisibility(shadowMap, frameState);
  if (!shadowMap._outOfViewPrevious && shadowMap._outOfView) {
    shadowMap._needsUpdate = true;
  }
  shadowMap._outOfViewPrevious = shadowMap._outOfView;
}
ShadowMap.prototype.update = function(frameState) {
  updateCameras(this, frameState);
  if (this._needsUpdate) {
    updateFramebuffer(this, frameState.context);
    if (this._isPointLight) {
      computeOmnidirectional(this, frameState);
    }
    if (this._cascadesEnabled) {
      fitShadowMapToScene(this, frameState);
      if (this._numberOfCascades > 1) {
        computeCascades(this, frameState);
      }
    }
    if (!this._isPointLight) {
      const shadowMapCamera = this._shadowMapCamera;
      const position = shadowMapCamera.positionWC;
      const direction2 = shadowMapCamera.directionWC;
      const up = shadowMapCamera.upWC;
      this._shadowMapCullingVolume = shadowMapCamera.frustum.computeCullingVolume(
        position,
        direction2,
        up
      );
      if (this._passes.length === 1) {
        this._passes[0].camera.clone(shadowMapCamera);
      }
    } else {
      this._shadowMapCullingVolume = CullingVolume_default.fromBoundingSphere(
        this._boundingSphere
      );
    }
  }
  if (this._passes.length === 1) {
    const inverseView = this._sceneCamera.inverseViewMatrix;
    Matrix4_default.multiply(
      this._shadowMapCamera.getViewProjection(),
      inverseView,
      this._shadowMapMatrix
    );
  }
  if (this.debugShow) {
    applyDebugSettings2(this, frameState);
  }
};
ShadowMap.prototype.updatePass = function(context, shadowPass) {
  clearFramebuffer(this, context, shadowPass);
};
var scratchTexelStepSize = new Cartesian2_default();
function combineUniforms(shadowMap, uniforms, isTerrain) {
  const bias = shadowMap._isPointLight ? shadowMap._pointBias : isTerrain ? shadowMap._terrainBias : shadowMap._primitiveBias;
  const mapUniforms = {
    shadowMap_texture: function() {
      return shadowMap._shadowMapTexture;
    },
    shadowMap_textureCube: function() {
      return shadowMap._shadowMapTexture;
    },
    shadowMap_matrix: function() {
      return shadowMap._shadowMapMatrix;
    },
    shadowMap_cascadeSplits: function() {
      return shadowMap._cascadeSplits;
    },
    shadowMap_cascadeMatrices: function() {
      return shadowMap._cascadeMatrices;
    },
    shadowMap_lightDirectionEC: function() {
      return shadowMap._lightDirectionEC;
    },
    shadowMap_lightPositionEC: function() {
      return shadowMap._lightPositionEC;
    },
    shadowMap_cascadeDistances: function() {
      return shadowMap._cascadeDistances;
    },
    shadowMap_texelSizeDepthBiasAndNormalShadingSmooth: function() {
      const texelStepSize = scratchTexelStepSize;
      texelStepSize.x = 1 / shadowMap._textureSize.x;
      texelStepSize.y = 1 / shadowMap._textureSize.y;
      return Cartesian4_default.fromElements(
        texelStepSize.x,
        texelStepSize.y,
        bias.depthBias,
        bias.normalShadingSmooth,
        this.combinedUniforms1
      );
    },
    shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness: function() {
      return Cartesian4_default.fromElements(
        bias.normalOffsetScale,
        shadowMap._distance,
        shadowMap.maximumDistance,
        shadowMap._darkness,
        this.combinedUniforms2
      );
    },
    combinedUniforms1: new Cartesian4_default(),
    combinedUniforms2: new Cartesian4_default()
  };
  return combine_default(uniforms, mapUniforms, false);
}
function createCastDerivedCommand(shadowMap, shadowsDirty, command, context, oldShaderId, result) {
  let castShader;
  let castRenderState;
  let castUniformMap;
  if (defined_default(result)) {
    castShader = result.shaderProgram;
    castRenderState = result.renderState;
    castUniformMap = result.uniformMap;
  }
  result = DrawCommand_default.shallowClone(command, result);
  result.castShadows = true;
  result.receiveShadows = false;
  if (!defined_default(castShader) || oldShaderId !== command.shaderProgram.id || shadowsDirty) {
    const shaderProgram = command.shaderProgram;
    const isTerrain = command.pass === Pass_default.GLOBE;
    const isOpaque = command.pass !== Pass_default.TRANSLUCENT;
    const isPointLight = shadowMap._isPointLight;
    const usesDepthTexture = shadowMap._usesDepthTexture;
    const keyword = ShadowMapShader_default.getShadowCastShaderKeyword(
      isPointLight,
      isTerrain,
      usesDepthTexture,
      isOpaque
    );
    castShader = context.shaderCache.getDerivedShaderProgram(
      shaderProgram,
      keyword
    );
    if (!defined_default(castShader)) {
      const vertexShaderSource = shaderProgram.vertexShaderSource;
      const fragmentShaderSource = shaderProgram.fragmentShaderSource;
      const castVS = ShadowMapShader_default.createShadowCastVertexShader(
        vertexShaderSource,
        isPointLight,
        isTerrain
      );
      const castFS = ShadowMapShader_default.createShadowCastFragmentShader(
        fragmentShaderSource,
        isPointLight,
        usesDepthTexture,
        isOpaque
      );
      castShader = context.shaderCache.createDerivedShaderProgram(
        shaderProgram,
        keyword,
        {
          vertexShaderSource: castVS,
          fragmentShaderSource: castFS,
          attributeLocations: shaderProgram._attributeLocations
        }
      );
    }
    castRenderState = shadowMap._primitiveRenderState;
    if (isPointLight) {
      castRenderState = shadowMap._pointRenderState;
    } else if (isTerrain) {
      castRenderState = shadowMap._terrainRenderState;
    }
    const cullEnabled = command.renderState.cull.enabled;
    if (!cullEnabled) {
      castRenderState = clone_default(castRenderState, false);
      castRenderState.cull = clone_default(castRenderState.cull, false);
      castRenderState.cull.enabled = false;
      castRenderState = RenderState_default.fromCache(castRenderState);
    }
    castUniformMap = combineUniforms(shadowMap, command.uniformMap, isTerrain);
  }
  result.shaderProgram = castShader;
  result.renderState = castRenderState;
  result.uniformMap = castUniformMap;
  return result;
}
ShadowMap.createReceiveDerivedCommand = function(lightShadowMaps, command, shadowsDirty, context, result) {
  if (!defined_default(result)) {
    result = {};
  }
  const lightShadowMapsEnabled = lightShadowMaps.length > 0;
  const shaderProgram = command.shaderProgram;
  const vertexShaderSource = shaderProgram.vertexShaderSource;
  const fragmentShaderSource = shaderProgram.fragmentShaderSource;
  const isTerrain = command.pass === Pass_default.GLOBE;
  let hasTerrainNormal = false;
  if (isTerrain) {
    hasTerrainNormal = command.owner.data.renderedMesh.encoding.hasVertexNormals;
  }
  if (command.receiveShadows && lightShadowMapsEnabled) {
    let receiveShader;
    let receiveUniformMap;
    if (defined_default(result.receiveCommand)) {
      receiveShader = result.receiveCommand.shaderProgram;
      receiveUniformMap = result.receiveCommand.uniformMap;
    }
    result.receiveCommand = DrawCommand_default.shallowClone(
      command,
      result.receiveCommand
    );
    result.castShadows = false;
    result.receiveShadows = true;
    const castShadowsDirty = result.receiveShaderCastShadows !== command.castShadows;
    const shaderDirty = result.receiveShaderProgramId !== command.shaderProgram.id;
    if (!defined_default(receiveShader) || shaderDirty || shadowsDirty || castShadowsDirty) {
      const keyword = ShadowMapShader_default.getShadowReceiveShaderKeyword(
        lightShadowMaps[0],
        command.castShadows,
        isTerrain,
        hasTerrainNormal
      );
      receiveShader = context.shaderCache.getDerivedShaderProgram(
        shaderProgram,
        keyword
      );
      if (!defined_default(receiveShader)) {
        const receiveVS = ShadowMapShader_default.createShadowReceiveVertexShader(
          vertexShaderSource,
          isTerrain,
          hasTerrainNormal
        );
        const receiveFS = ShadowMapShader_default.createShadowReceiveFragmentShader(
          fragmentShaderSource,
          lightShadowMaps[0],
          command.castShadows,
          isTerrain,
          hasTerrainNormal
        );
        receiveShader = context.shaderCache.createDerivedShaderProgram(
          shaderProgram,
          keyword,
          {
            vertexShaderSource: receiveVS,
            fragmentShaderSource: receiveFS,
            attributeLocations: shaderProgram._attributeLocations
          }
        );
      }
      receiveUniformMap = combineUniforms(
        lightShadowMaps[0],
        command.uniformMap,
        isTerrain
      );
    }
    result.receiveCommand.shaderProgram = receiveShader;
    result.receiveCommand.uniformMap = receiveUniformMap;
    result.receiveShaderProgramId = command.shaderProgram.id;
    result.receiveShaderCastShadows = command.castShadows;
  }
  return result;
};
ShadowMap.createCastDerivedCommand = function(shadowMaps, command, shadowsDirty, context, result) {
  if (!defined_default(result)) {
    result = {};
  }
  if (command.castShadows) {
    let castCommands = result.castCommands;
    if (!defined_default(castCommands)) {
      castCommands = result.castCommands = [];
    }
    const oldShaderId = result.castShaderProgramId;
    const shadowMapLength = shadowMaps.length;
    castCommands.length = shadowMapLength;
    for (let i2 = 0; i2 < shadowMapLength; ++i2) {
      castCommands[i2] = createCastDerivedCommand(
        shadowMaps[i2],
        shadowsDirty,
        command,
        context,
        oldShaderId,
        castCommands[i2]
      );
    }
    result.castShaderProgramId = command.shaderProgram.id;
  }
  return result;
};
ShadowMap.prototype.isDestroyed = function() {
  return false;
};
ShadowMap.prototype.destroy = function() {
  destroyFramebuffer2(this);
  this._debugLightFrustum = this._debugLightFrustum && this._debugLightFrustum.destroy();
  this._debugCameraFrustum = this._debugCameraFrustum && this._debugCameraFrustum.destroy();
  this._debugShadowViewCommand = this._debugShadowViewCommand && this._debugShadowViewCommand.shaderProgram && this._debugShadowViewCommand.shaderProgram.destroy();
  for (let i2 = 0; i2 < this._numberOfCascades; ++i2) {
    this._debugCascadeFrustums[i2] = this._debugCascadeFrustums[i2] && this._debugCascadeFrustums[i2].destroy();
  }
  return destroyObject_default(this);
};
var ShadowMap_default = ShadowMap;

// node_modules/cesium/Source/Shaders/CompareAndPackTranslucentDepth.js
var CompareAndPackTranslucentDepth_default = "uniform sampler2D u_opaqueDepthTexture;\nuniform sampler2D u_translucentDepthTexture;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    float opaqueDepth = texture2D(u_opaqueDepthTexture, v_textureCoordinates).r;\n    float translucentDepth = texture2D(u_translucentDepthTexture, v_textureCoordinates).r;\n    translucentDepth = czm_branchFreeTernary(translucentDepth > opaqueDepth, 1.0, translucentDepth);\n    gl_FragColor = czm_packDepth(translucentDepth);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/CompositeTranslucentClassification.js
var CompositeTranslucentClassification_default = "uniform sampler2D colorTexture;\n\n#ifdef DEBUG_SHOW_DEPTH\nuniform sampler2D u_packedTranslucentDepth;\n#endif\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n#ifdef DEBUG_SHOW_DEPTH\n    if (v_textureCoordinates.x < 0.5)\n    {\n        gl_FragColor.rgb = vec3(czm_unpackDepth(texture2D(u_packedTranslucentDepth, v_textureCoordinates)));\n        gl_FragColor.a = 1.0;\n    }\n#else\n    vec4 color = texture2D(colorTexture, v_textureCoordinates);\n\n#ifdef PICK\n    if (color == vec4(0.0))\n    {\n        discard;\n    }\n#else\n    // Reverse premultiplication process to get the correct composited result of the classification primitives\n    color.rgb /= color.a;\n#endif\n    gl_FragColor = color;\n#endif\n}\n";

// node_modules/cesium/Source/Scene/TranslucentTileClassification.js
var debugShowPackedDepth = false;
function TranslucentTileClassification(context) {
  this._drawClassificationFBO = new FramebufferManager_default({
    createDepthAttachments: false
  });
  this._accumulationFBO = new FramebufferManager_default({
    createDepthAttachments: false
  });
  this._packFBO = new FramebufferManager_default();
  this._opaqueDepthStencilTexture = void 0;
  this._textureToComposite = void 0;
  this._translucentDepthStencilTexture = void 0;
  this._packDepthCommand = void 0;
  this._accumulateCommand = void 0;
  this._compositeCommand = void 0;
  this._copyCommand = void 0;
  this._clearColorCommand = new ClearCommand_default({
    color: new Color_default(0, 0, 0, 0),
    owner: this
  });
  this._clearDepthStencilCommand = new ClearCommand_default({
    depth: 1,
    stencil: 0,
    owner: this
  });
  this._supported = context.depthTexture;
  this._viewport = new BoundingRectangle_default();
  this._rsDepth = void 0;
  this._rsAccumulate = void 0;
  this._rsComp = void 0;
  this._useScissorTest = void 0;
  this._scissorRectangle = void 0;
  this._hasTranslucentDepth = false;
  this._frustumsDrawn = 0;
}
Object.defineProperties(TranslucentTileClassification.prototype, {
  hasTranslucentDepth: {
    get: function() {
      return this._hasTranslucentDepth;
    }
  }
});
function destroyTextures2(transpClass) {
  transpClass._textureToComposite = void 0;
  transpClass._translucentDepthStencilTexture = transpClass._translucentDepthStencilTexture && !transpClass._translucentDepthStencilTexture.isDestroyed() && transpClass._translucentDepthStencilTexture.destroy();
}
function destroyFramebuffers4(transpClass) {
  transpClass._drawClassificationFBO.destroy();
  transpClass._accumulationFBO.destroy();
  transpClass._packFBO.destroy();
}
function updateTextures2(transpClass, context, width, height) {
  destroyTextures2(transpClass);
  transpClass._translucentDepthStencilTexture = new Texture_default({
    context,
    width,
    height,
    pixelFormat: PixelFormat_default.DEPTH_STENCIL,
    pixelDatatype: PixelDatatype_default.UNSIGNED_INT_24_8,
    sampler: Sampler_default.NEAREST
  });
}
function updateFramebuffers3(transpClass, context, width, height) {
  destroyFramebuffers4(transpClass);
  transpClass._drawClassificationFBO.setDepthStencilTexture(
    transpClass._translucentDepthStencilTexture
  );
  transpClass._drawClassificationFBO.update(context, width, height);
  transpClass._accumulationFBO.setDepthStencilTexture(
    transpClass._translucentDepthStencilTexture
  );
  transpClass._accumulationFBO.update(context, width, height);
  transpClass._packFBO.update(context, width, height);
}
function updateResources2(transpClass, context, passState, globeDepthStencilTexture) {
  if (!transpClass.isSupported()) {
    return;
  }
  transpClass._opaqueDepthStencilTexture = globeDepthStencilTexture;
  const width = transpClass._opaqueDepthStencilTexture.width;
  const height = transpClass._opaqueDepthStencilTexture.height;
  if (transpClass._drawClassificationFBO.isDirty(width, height)) {
    updateTextures2(transpClass, context, width, height);
    updateFramebuffers3(transpClass, context, width, height);
  }
  let fs;
  let uniformMap2;
  if (!defined_default(transpClass._packDepthCommand)) {
    fs = new ShaderSource_default({
      sources: [CompareAndPackTranslucentDepth_default]
    });
    uniformMap2 = {
      u_opaqueDepthTexture: function() {
        return transpClass._opaqueDepthStencilTexture;
      },
      u_translucentDepthTexture: function() {
        return transpClass._translucentDepthStencilTexture;
      }
    };
    transpClass._packDepthCommand = context.createViewportQuadCommand(fs, {
      uniformMap: uniformMap2,
      owner: transpClass
    });
  }
  if (!defined_default(transpClass._compositeCommand)) {
    fs = new ShaderSource_default({
      sources: [CompositeTranslucentClassification_default]
    });
    uniformMap2 = {
      colorTexture: function() {
        return transpClass._textureToComposite;
      }
    };
    if (debugShowPackedDepth) {
      fs.defines = ["DEBUG_SHOW_DEPTH"];
      uniformMap2.u_packedTranslucentDepth = function() {
        return transpClass._packFBO.getColorTexture();
      };
    }
    transpClass._compositeCommand = context.createViewportQuadCommand(fs, {
      uniformMap: uniformMap2,
      owner: transpClass
    });
    const compositeCommand = transpClass._compositeCommand;
    const compositeProgram = compositeCommand.shaderProgram;
    const compositePickProgram = context.shaderCache.createDerivedShaderProgram(
      compositeProgram,
      "pick",
      {
        vertexShaderSource: compositeProgram.vertexShaderSource,
        fragmentShaderSource: new ShaderSource_default({
          sources: fs.sources,
          defines: ["PICK"]
        }),
        attributeLocations: compositeProgram._attributeLocations
      }
    );
    const compositePickCommand = DrawCommand_default.shallowClone(compositeCommand);
    compositePickCommand.shaderProgram = compositePickProgram;
    compositeCommand.derivedCommands.pick = compositePickCommand;
  }
  if (!defined_default(transpClass._copyCommand)) {
    fs = new ShaderSource_default({
      sources: [CompositeTranslucentClassification_default]
    });
    uniformMap2 = {
      colorTexture: function() {
        return transpClass._drawClassificationFBO.getColorTexture();
      }
    };
    transpClass._copyCommand = context.createViewportQuadCommand(fs, {
      uniformMap: uniformMap2,
      owner: transpClass
    });
  }
  if (!defined_default(transpClass._accumulateCommand)) {
    fs = new ShaderSource_default({
      sources: [CompositeTranslucentClassification_default]
    });
    uniformMap2 = {
      colorTexture: function() {
        return transpClass._drawClassificationFBO.getColorTexture();
      }
    };
    transpClass._accumulateCommand = context.createViewportQuadCommand(fs, {
      uniformMap: uniformMap2,
      owner: transpClass
    });
  }
  transpClass._viewport.width = width;
  transpClass._viewport.height = height;
  const useScissorTest = !BoundingRectangle_default.equals(
    transpClass._viewport,
    passState.viewport
  );
  let updateScissor = useScissorTest !== transpClass._useScissorTest;
  transpClass._useScissorTest = useScissorTest;
  if (!BoundingRectangle_default.equals(transpClass._scissorRectangle, passState.viewport)) {
    transpClass._scissorRectangle = BoundingRectangle_default.clone(
      passState.viewport,
      transpClass._scissorRectangle
    );
    updateScissor = true;
  }
  if (!defined_default(transpClass._rsDepth) || !BoundingRectangle_default.equals(
    transpClass._viewport,
    transpClass._rsDepth.viewport
  ) || updateScissor) {
    transpClass._rsDepth = RenderState_default.fromCache({
      viewport: transpClass._viewport,
      scissorTest: {
        enabled: transpClass._useScissorTest,
        rectangle: transpClass._scissorRectangle
      }
    });
  }
  if (defined_default(transpClass._packDepthCommand)) {
    transpClass._packDepthCommand.renderState = transpClass._rsDepth;
  }
  if (!defined_default(transpClass._rsAccumulate) || !BoundingRectangle_default.equals(
    transpClass._viewport,
    transpClass._rsAccumulate.viewport
  ) || updateScissor) {
    transpClass._rsAccumulate = RenderState_default.fromCache({
      viewport: transpClass._viewport,
      scissorTest: {
        enabled: transpClass._useScissorTest,
        rectangle: transpClass._scissorRectangle
      },
      stencilTest: {
        enabled: true,
        frontFunction: StencilFunction_default.EQUAL,
        reference: StencilConstants_default.CESIUM_3D_TILE_MASK
      }
    });
  }
  if (defined_default(transpClass._accumulateCommand)) {
    transpClass._accumulateCommand.renderState = transpClass._rsAccumulate;
  }
  if (!defined_default(transpClass._rsComp) || !BoundingRectangle_default.equals(
    transpClass._viewport,
    transpClass._rsComp.viewport
  ) || updateScissor) {
    transpClass._rsComp = RenderState_default.fromCache({
      viewport: transpClass._viewport,
      scissorTest: {
        enabled: transpClass._useScissorTest,
        rectangle: transpClass._scissorRectangle
      },
      blending: BlendingState_default.ALPHA_BLEND
    });
  }
  if (defined_default(transpClass._compositeCommand)) {
    transpClass._compositeCommand.renderState = transpClass._rsComp;
    transpClass._compositeCommand.derivedCommands.pick.renderState = transpClass._rsComp;
  }
}
TranslucentTileClassification.prototype.executeTranslucentCommands = function(scene, executeCommand2, passState, commands, globeDepthStencilTexture) {
  const length3 = commands.length;
  let command;
  let i2;
  const useLogDepth = scene.frameState.useLogDepth;
  const context = scene.context;
  const framebuffer = passState.framebuffer;
  for (i2 = 0; i2 < length3; ++i2) {
    command = commands[i2];
    command = useLogDepth ? command.derivedCommands.logDepth.command : command;
    if (command.depthForTranslucentClassification) {
      this._hasTranslucentDepth = true;
      break;
    }
  }
  if (!this._hasTranslucentDepth) {
    return;
  }
  updateResources2(this, context, passState, globeDepthStencilTexture);
  passState.framebuffer = this._drawClassificationFBO.framebuffer;
  this._clearDepthStencilCommand.execute(context, passState);
  for (i2 = 0; i2 < length3; ++i2) {
    command = commands[i2];
    command = useLogDepth ? command.derivedCommands.logDepth.command : command;
    if (!command.depthForTranslucentClassification) {
      continue;
    }
    const depthOnlyCommand = command.derivedCommands.depth.depthOnlyCommand;
    executeCommand2(depthOnlyCommand, scene, context, passState);
  }
  this._frustumsDrawn += this._hasTranslucentDepth ? 1 : 0;
  if (this._hasTranslucentDepth) {
    passState.framebuffer = this._packFBO.framebuffer;
    this._packDepthCommand.execute(context, passState);
  }
  passState.framebuffer = framebuffer;
};
TranslucentTileClassification.prototype.executeClassificationCommands = function(scene, executeCommand2, passState, frustumCommands) {
  if (!this._hasTranslucentDepth) {
    return;
  }
  const context = scene.context;
  const us = context.uniformState;
  const framebuffer = passState.framebuffer;
  if (this._frustumsDrawn === 2) {
    passState.framebuffer = this._accumulationFBO.framebuffer;
    this._copyCommand.execute(context, passState);
  }
  passState.framebuffer = this._drawClassificationFBO.framebuffer;
  if (this._frustumsDrawn > 1) {
    this._clearColorCommand.execute(context, passState);
  }
  us.updatePass(Pass_default.CESIUM_3D_TILE_CLASSIFICATION);
  const swapGlobeDepth = us.globeDepthTexture;
  us.globeDepthTexture = this._packFBO.getColorTexture();
  const commands = frustumCommands.commands[Pass_default.CESIUM_3D_TILE_CLASSIFICATION];
  const length3 = frustumCommands.indices[Pass_default.CESIUM_3D_TILE_CLASSIFICATION];
  for (let i2 = 0; i2 < length3; ++i2) {
    executeCommand2(commands[i2], scene, context, passState);
  }
  us.globeDepthTexture = swapGlobeDepth;
  passState.framebuffer = framebuffer;
  if (this._frustumsDrawn === 1) {
    return;
  }
  passState.framebuffer = this._accumulationFBO.framebuffer;
  this._accumulateCommand.execute(context, passState);
  passState.framebuffer = framebuffer;
};
TranslucentTileClassification.prototype.execute = function(scene, passState) {
  if (!this._hasTranslucentDepth) {
    return;
  }
  if (this._frustumsDrawn === 1) {
    this._textureToComposite = this._drawClassificationFBO.getColorTexture();
  } else {
    this._textureToComposite = this._accumulationFBO.getColorTexture();
  }
  const command = scene.frameState.passes.pick ? this._compositeCommand.derivedCommands.pick : this._compositeCommand;
  command.execute(scene.context, passState);
  clear(this, scene, passState);
};
function clear(translucentTileClassification, scene, passState) {
  if (!translucentTileClassification._hasTranslucentDepth) {
    return;
  }
  const framebuffer = passState.framebuffer;
  passState.framebuffer = translucentTileClassification._drawClassificationFBO.framebuffer;
  translucentTileClassification._clearColorCommand.execute(
    scene._context,
    passState
  );
  passState.framebuffer = framebuffer;
  if (translucentTileClassification._frustumsDrawn > 1) {
    passState.framebuffer = translucentTileClassification._accumulationFBO.framebuffer;
    translucentTileClassification._clearColorCommand.execute(
      scene._context,
      passState
    );
  }
  translucentTileClassification._hasTranslucentDepth = false;
  translucentTileClassification._frustumsDrawn = 0;
}
TranslucentTileClassification.prototype.isSupported = function() {
  return this._supported;
};
TranslucentTileClassification.prototype.isDestroyed = function() {
  return false;
};
TranslucentTileClassification.prototype.destroy = function() {
  destroyTextures2(this);
  destroyFramebuffers4(this);
  if (defined_default(this._compositeCommand)) {
    this._compositeCommand.shaderProgram = this._compositeCommand.shaderProgram && this._compositeCommand.shaderProgram.destroy();
  }
  if (defined_default(this._packDepthCommand)) {
    this._packDepthCommand.shaderProgram = this._packDepthCommand.shaderProgram && this._packDepthCommand.shaderProgram.destroy();
  }
  return destroyObject_default(this);
};
var TranslucentTileClassification_default = TranslucentTileClassification;

// node_modules/cesium/Source/Scene/View.js
function CommandExtent() {
  this.command = void 0;
  this.near = void 0;
  this.far = void 0;
}
function View(scene, camera, viewport) {
  const context = scene.context;
  let globeDepth;
  if (context.depthTexture) {
    globeDepth = new GlobeDepth_default();
  }
  let oit;
  if (scene._useOIT && context.depthTexture) {
    oit = new OIT_default(context);
  }
  const passState = new PassState_default(context);
  passState.viewport = BoundingRectangle_default.clone(viewport);
  this.camera = camera;
  this._cameraClone = Camera_default.clone(camera);
  this._cameraStartFired = false;
  this._cameraMovedTime = void 0;
  this.viewport = viewport;
  this.passState = passState;
  this.pickFramebuffer = new PickFramebuffer_default(context);
  this.pickDepthFramebuffer = new PickDepthFramebuffer_default();
  this.sceneFramebuffer = new SceneFramebuffer_default();
  this.globeDepth = globeDepth;
  this.globeTranslucencyFramebuffer = new GlobeTranslucencyFramebuffer_default();
  this.oit = oit;
  this.translucentTileClassification = new TranslucentTileClassification_default(
    context
  );
  this.pickDepths = [];
  this.frustumCommandsList = [];
  this.debugFrustumStatistics = void 0;
  this._commandExtents = [];
}
var scratchPosition0 = new Cartesian3_default();
var scratchPosition1 = new Cartesian3_default();
function maxComponent(a4, b) {
  const x = Math.max(Math.abs(a4.x), Math.abs(b.x));
  const y = Math.max(Math.abs(a4.y), Math.abs(b.y));
  const z = Math.max(Math.abs(a4.z), Math.abs(b.z));
  return Math.max(Math.max(x, y), z);
}
function cameraEqual(camera0, camera1, epsilon) {
  const scalar = 1 / Math.max(1, maxComponent(camera0.position, camera1.position));
  Cartesian3_default.multiplyByScalar(camera0.position, scalar, scratchPosition0);
  Cartesian3_default.multiplyByScalar(camera1.position, scalar, scratchPosition1);
  return Cartesian3_default.equalsEpsilon(scratchPosition0, scratchPosition1, epsilon) && Cartesian3_default.equalsEpsilon(camera0.direction, camera1.direction, epsilon) && Cartesian3_default.equalsEpsilon(camera0.up, camera1.up, epsilon) && Cartesian3_default.equalsEpsilon(camera0.right, camera1.right, epsilon) && Matrix4_default.equalsEpsilon(camera0.transform, camera1.transform, epsilon) && camera0.frustum.equalsEpsilon(camera1.frustum, epsilon);
}
View.prototype.checkForCameraUpdates = function(scene) {
  const camera = this.camera;
  const cameraClone = this._cameraClone;
  if (!cameraEqual(camera, cameraClone, Math_default.EPSILON15)) {
    if (!this._cameraStartFired) {
      camera.moveStart.raiseEvent();
      this._cameraStartFired = true;
    }
    this._cameraMovedTime = getTimestamp_default();
    Camera_default.clone(camera, cameraClone);
    return true;
  }
  if (this._cameraStartFired && getTimestamp_default() - this._cameraMovedTime > scene.cameraEventWaitTime) {
    camera.moveEnd.raiseEvent();
    this._cameraStartFired = false;
  }
  return false;
};
function updateFrustums(view, scene, near, far) {
  const frameState = scene.frameState;
  const camera = frameState.camera;
  const farToNearRatio = frameState.useLogDepth ? scene.logarithmicDepthFarToNearRatio : scene.farToNearRatio;
  const is2D = scene.mode === SceneMode_default.SCENE2D;
  const nearToFarDistance2D = scene.nearToFarDistance2D;
  far *= 1 + Math_default.EPSILON2;
  near = Math.min(Math.max(near, camera.frustum.near), camera.frustum.far);
  far = Math.max(Math.min(far, camera.frustum.far), near);
  let numFrustums;
  if (is2D) {
    far = Math.min(far, camera.position.z + scene.nearToFarDistance2D);
    near = Math.min(near, far);
    numFrustums = Math.ceil(
      Math.max(1, far - near) / scene.nearToFarDistance2D
    );
  } else {
    numFrustums = Math.ceil(Math.log(far / near) / Math.log(farToNearRatio));
  }
  const frustumCommandsList = view.frustumCommandsList;
  frustumCommandsList.length = numFrustums;
  for (let m = 0; m < numFrustums; ++m) {
    let curNear;
    let curFar;
    if (is2D) {
      curNear = Math.min(
        far - nearToFarDistance2D,
        near + m * nearToFarDistance2D
      );
      curFar = Math.min(far, curNear + nearToFarDistance2D);
    } else {
      curNear = Math.max(near, Math.pow(farToNearRatio, m) * near);
      curFar = Math.min(far, farToNearRatio * curNear);
    }
    let frustumCommands = frustumCommandsList[m];
    if (!defined_default(frustumCommands)) {
      frustumCommands = frustumCommandsList[m] = new FrustumCommands_default(
        curNear,
        curFar
      );
    } else {
      frustumCommands.near = curNear;
      frustumCommands.far = curFar;
    }
  }
}
function insertIntoBin(view, scene, command, commandNear, commandFar) {
  if (scene.debugShowFrustums) {
    command.debugOverlappingFrustums = 0;
  }
  const frustumCommandsList = view.frustumCommandsList;
  const length3 = frustumCommandsList.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const frustumCommands = frustumCommandsList[i2];
    const curNear = frustumCommands.near;
    const curFar = frustumCommands.far;
    if (commandNear > curFar) {
      continue;
    }
    if (commandFar < curNear) {
      break;
    }
    const pass = command.pass;
    const index2 = frustumCommands.indices[pass]++;
    frustumCommands.commands[pass][index2] = command;
    if (scene.debugShowFrustums) {
      command.debugOverlappingFrustums |= 1 << i2;
    }
    if (command.executeInClosestFrustum) {
      break;
    }
  }
  if (scene.debugShowFrustums) {
    const cf = view.debugFrustumStatistics.commandsInFrustums;
    cf[command.debugOverlappingFrustums] = defined_default(
      cf[command.debugOverlappingFrustums]
    ) ? cf[command.debugOverlappingFrustums] + 1 : 1;
    ++view.debugFrustumStatistics.totalCommands;
  }
  scene.updateDerivedCommands(command);
}
var scratchCullingVolume = new CullingVolume_default();
var scratchNearFarInterval = new Interval_default();
View.prototype.createPotentiallyVisibleSet = function(scene) {
  const frameState = scene.frameState;
  const camera = frameState.camera;
  const direction2 = camera.directionWC;
  const position = camera.positionWC;
  const computeList = scene._computeCommandList;
  const overlayList = scene._overlayCommandList;
  const commandList = frameState.commandList;
  if (scene.debugShowFrustums) {
    this.debugFrustumStatistics = {
      totalCommands: 0,
      commandsInFrustums: {}
    };
  }
  const frustumCommandsList = this.frustumCommandsList;
  const numberOfFrustums = frustumCommandsList.length;
  const numberOfPasses = Pass_default.NUMBER_OF_PASSES;
  for (let n2 = 0; n2 < numberOfFrustums; ++n2) {
    for (let p2 = 0; p2 < numberOfPasses; ++p2) {
      frustumCommandsList[n2].indices[p2] = 0;
    }
  }
  computeList.length = 0;
  overlayList.length = 0;
  const commandExtents = this._commandExtents;
  const commandExtentCapacity = commandExtents.length;
  let commandExtentCount = 0;
  let near = +Number.MAX_VALUE;
  let far = -Number.MAX_VALUE;
  const shadowsEnabled = frameState.shadowState.shadowsEnabled;
  let shadowNear = +Number.MAX_VALUE;
  let shadowFar = -Number.MAX_VALUE;
  let shadowClosestObjectSize = Number.MAX_VALUE;
  const occluder = frameState.mode === SceneMode_default.SCENE3D ? frameState.occluder : void 0;
  let cullingVolume = frameState.cullingVolume;
  const planes = scratchCullingVolume.planes;
  for (let k = 0; k < 5; ++k) {
    planes[k] = cullingVolume.planes[k];
  }
  cullingVolume = scratchCullingVolume;
  const length3 = commandList.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const command = commandList[i2];
    const pass = command.pass;
    if (pass === Pass_default.COMPUTE) {
      computeList.push(command);
    } else if (pass === Pass_default.OVERLAY) {
      overlayList.push(command);
    } else {
      let commandNear;
      let commandFar;
      const boundingVolume = command.boundingVolume;
      if (defined_default(boundingVolume)) {
        if (!scene.isVisible(command, cullingVolume, occluder)) {
          continue;
        }
        const nearFarInterval = boundingVolume.computePlaneDistances(
          position,
          direction2,
          scratchNearFarInterval
        );
        commandNear = nearFarInterval.start;
        commandFar = nearFarInterval.stop;
        near = Math.min(near, commandNear);
        far = Math.max(far, commandFar);
        if (shadowsEnabled && command.receiveShadows && commandNear < ShadowMap_default.MAXIMUM_DISTANCE && !(pass === Pass_default.GLOBE && commandNear < -100 && commandFar > 100)) {
          const size = commandFar - commandNear;
          if (pass !== Pass_default.GLOBE && commandNear < 100) {
            shadowClosestObjectSize = Math.min(shadowClosestObjectSize, size);
          }
          shadowNear = Math.min(shadowNear, commandNear);
          shadowFar = Math.max(shadowFar, commandFar);
        }
      } else if (command instanceof ClearCommand_default) {
        commandNear = camera.frustum.near;
        commandFar = camera.frustum.far;
      } else {
        commandNear = camera.frustum.near;
        commandFar = camera.frustum.far;
        near = Math.min(near, commandNear);
        far = Math.max(far, commandFar);
      }
      let extent = commandExtents[commandExtentCount];
      if (!defined_default(extent)) {
        extent = commandExtents[commandExtentCount] = new CommandExtent();
      }
      extent.command = command;
      extent.near = commandNear;
      extent.far = commandFar;
      commandExtentCount++;
    }
  }
  if (shadowsEnabled) {
    shadowNear = Math.min(
      Math.max(shadowNear, camera.frustum.near),
      camera.frustum.far
    );
    shadowFar = Math.max(Math.min(shadowFar, camera.frustum.far), shadowNear);
  }
  if (shadowsEnabled) {
    frameState.shadowState.nearPlane = shadowNear;
    frameState.shadowState.farPlane = shadowFar;
    frameState.shadowState.closestObjectSize = shadowClosestObjectSize;
  }
  updateFrustums(this, scene, near, far);
  let c14;
  let ce;
  for (c14 = 0; c14 < commandExtentCount; c14++) {
    ce = commandExtents[c14];
    insertIntoBin(this, scene, ce.command, ce.near, ce.far);
  }
  if (commandExtentCount < commandExtentCapacity) {
    for (c14 = commandExtentCount; c14 < commandExtentCapacity; c14++) {
      ce = commandExtents[c14];
      if (!defined_default(ce.command)) {
        break;
      }
      ce.command = void 0;
    }
  }
  const numFrustums = frustumCommandsList.length;
  const frustumSplits2 = frameState.frustumSplits;
  frustumSplits2.length = numFrustums + 1;
  for (let j = 0; j < numFrustums; ++j) {
    frustumSplits2[j] = frustumCommandsList[j].near;
    if (j === numFrustums - 1) {
      frustumSplits2[j + 1] = frustumCommandsList[j].far;
    }
  }
};
View.prototype.destroy = function() {
  this.pickFramebuffer = this.pickFramebuffer && this.pickFramebuffer.destroy();
  this.pickDepthFramebuffer = this.pickDepthFramebuffer && this.pickDepthFramebuffer.destroy();
  this.sceneFramebuffer = this.sceneFramebuffer && this.sceneFramebuffer.destroy();
  this.globeDepth = this.globeDepth && this.globeDepth.destroy();
  this.oit = this.oit && this.oit.destroy();
  this.translucentTileClassification = this.translucentTileClassification && this.translucentTileClassification.destroy();
  this.globeTranslucencyFramebuffer = this.globeTranslucencyFramebuffer && this.globeTranslucencyFramebuffer.destroy();
  let i2;
  const pickDepths = this.pickDepths;
  const length3 = pickDepths.length;
  for (i2 = 0; i2 < length3; ++i2) {
    pickDepths[i2].destroy();
  }
};
var View_default = View;

// node_modules/cesium/Source/Scene/Picking.js
var offscreenDefaultWidth = 0.1;
var mostDetailedPreloadTilesetPassState = new Cesium3DTilePassState_default({
  pass: Cesium3DTilePass_default.MOST_DETAILED_PRELOAD
});
var mostDetailedPickTilesetPassState = new Cesium3DTilePassState_default({
  pass: Cesium3DTilePass_default.MOST_DETAILED_PICK
});
var pickTilesetPassState = new Cesium3DTilePassState_default({
  pass: Cesium3DTilePass_default.PICK
});
function Picking(scene) {
  this._mostDetailedRayPicks = [];
  this.pickRenderStateCache = {};
  this._pickPositionCache = {};
  this._pickPositionCacheDirty = false;
  const pickOffscreenViewport = new BoundingRectangle_default(0, 0, 1, 1);
  const pickOffscreenCamera = new Camera_default(scene);
  pickOffscreenCamera.frustum = new OrthographicFrustum_default({
    width: offscreenDefaultWidth,
    aspectRatio: 1,
    near: 0.1
  });
  this._pickOffscreenView = new View_default(
    scene,
    pickOffscreenCamera,
    pickOffscreenViewport
  );
}
Picking.prototype.update = function() {
  this._pickPositionCacheDirty = true;
};
Picking.prototype.getPickDepth = function(scene, index2) {
  const pickDepths = scene.view.pickDepths;
  let pickDepth = pickDepths[index2];
  if (!defined_default(pickDepth)) {
    pickDepth = new PickDepth_default();
    pickDepths[index2] = pickDepth;
  }
  return pickDepth;
};
var scratchOrthoPickingFrustum = new OrthographicOffCenterFrustum_default();
var scratchOrthoOrigin = new Cartesian3_default();
var scratchOrthoDirection = new Cartesian3_default();
var scratchOrthoPixelSize = new Cartesian2_default();
var scratchOrthoPickVolumeMatrix4 = new Matrix4_default();
function getPickOrthographicCullingVolume(scene, drawingBufferPosition, width, height, viewport) {
  const camera = scene.camera;
  let frustum = camera.frustum;
  if (defined_default(frustum._offCenterFrustum)) {
    frustum = frustum._offCenterFrustum;
  }
  let x = 2 * (drawingBufferPosition.x - viewport.x) / viewport.width - 1;
  x *= (frustum.right - frustum.left) * 0.5;
  let y = 2 * (viewport.height - drawingBufferPosition.y - viewport.y) / viewport.height - 1;
  y *= (frustum.top - frustum.bottom) * 0.5;
  const transform4 = Matrix4_default.clone(
    camera.transform,
    scratchOrthoPickVolumeMatrix4
  );
  camera._setTransform(Matrix4_default.IDENTITY);
  const origin = Cartesian3_default.clone(camera.position, scratchOrthoOrigin);
  Cartesian3_default.multiplyByScalar(camera.right, x, scratchOrthoDirection);
  Cartesian3_default.add(scratchOrthoDirection, origin, origin);
  Cartesian3_default.multiplyByScalar(camera.up, y, scratchOrthoDirection);
  Cartesian3_default.add(scratchOrthoDirection, origin, origin);
  camera._setTransform(transform4);
  if (scene.mode === SceneMode_default.SCENE2D) {
    Cartesian3_default.fromElements(origin.z, origin.x, origin.y, origin);
  }
  const pixelSize = frustum.getPixelDimensions(
    viewport.width,
    viewport.height,
    1,
    1,
    scratchOrthoPixelSize
  );
  const ortho = scratchOrthoPickingFrustum;
  ortho.right = pixelSize.x * 0.5;
  ortho.left = -ortho.right;
  ortho.top = pixelSize.y * 0.5;
  ortho.bottom = -ortho.top;
  ortho.near = frustum.near;
  ortho.far = frustum.far;
  return ortho.computeCullingVolume(origin, camera.directionWC, camera.upWC);
}
var scratchPerspPickingFrustum = new PerspectiveOffCenterFrustum_default();
var scratchPerspPixelSize = new Cartesian2_default();
function getPickPerspectiveCullingVolume(scene, drawingBufferPosition, width, height, viewport) {
  const camera = scene.camera;
  const frustum = camera.frustum;
  const near = frustum.near;
  const tanPhi = Math.tan(frustum.fovy * 0.5);
  const tanTheta = frustum.aspectRatio * tanPhi;
  const x = 2 * (drawingBufferPosition.x - viewport.x) / viewport.width - 1;
  const y = 2 * (viewport.height - drawingBufferPosition.y - viewport.y) / viewport.height - 1;
  const xDir = x * near * tanTheta;
  const yDir = y * near * tanPhi;
  const pixelSize = frustum.getPixelDimensions(
    viewport.width,
    viewport.height,
    1,
    1,
    scratchPerspPixelSize
  );
  const pickWidth = pixelSize.x * width * 0.5;
  const pickHeight = pixelSize.y * height * 0.5;
  const offCenter = scratchPerspPickingFrustum;
  offCenter.top = yDir + pickHeight;
  offCenter.bottom = yDir - pickHeight;
  offCenter.right = xDir + pickWidth;
  offCenter.left = xDir - pickWidth;
  offCenter.near = near;
  offCenter.far = frustum.far;
  return offCenter.computeCullingVolume(
    camera.positionWC,
    camera.directionWC,
    camera.upWC
  );
}
function getPickCullingVolume(scene, drawingBufferPosition, width, height, viewport) {
  const frustum = scene.camera.frustum;
  if (frustum instanceof OrthographicFrustum_default || frustum instanceof OrthographicOffCenterFrustum_default) {
    return getPickOrthographicCullingVolume(
      scene,
      drawingBufferPosition,
      width,
      height,
      viewport
    );
  }
  return getPickPerspectiveCullingVolume(
    scene,
    drawingBufferPosition,
    width,
    height,
    viewport
  );
}
var scratchRectangleWidth = 3;
var scratchRectangleHeight = 3;
var scratchRectangle9 = new BoundingRectangle_default(
  0,
  0,
  scratchRectangleWidth,
  scratchRectangleHeight
);
var scratchPosition15 = new Cartesian2_default();
var scratchColorZero = new Color_default(0, 0, 0, 0);
Picking.prototype.pick = function(scene, windowPosition, width, height) {
  if (!defined_default(windowPosition)) {
    throw new DeveloperError_default("windowPosition is undefined.");
  }
  scratchRectangleWidth = defaultValue_default(width, 3);
  scratchRectangleHeight = defaultValue_default(height, scratchRectangleWidth);
  const context = scene.context;
  const us = context.uniformState;
  const frameState = scene.frameState;
  const view = scene.defaultView;
  scene.view = view;
  const viewport = view.viewport;
  viewport.x = 0;
  viewport.y = 0;
  viewport.width = context.drawingBufferWidth;
  viewport.height = context.drawingBufferHeight;
  let passState = view.passState;
  passState.viewport = BoundingRectangle_default.clone(viewport, passState.viewport);
  const drawingBufferPosition = SceneTransforms_default.transformWindowToDrawingBuffer(
    scene,
    windowPosition,
    scratchPosition15
  );
  scene.jobScheduler.disableThisFrame();
  scene.updateFrameState();
  frameState.cullingVolume = getPickCullingVolume(
    scene,
    drawingBufferPosition,
    scratchRectangleWidth,
    scratchRectangleHeight,
    viewport
  );
  frameState.invertClassification = false;
  frameState.passes.pick = true;
  frameState.tilesetPassState = pickTilesetPassState;
  us.update(frameState);
  scene.updateEnvironment();
  scratchRectangle9.x = drawingBufferPosition.x - (scratchRectangleWidth - 1) * 0.5;
  scratchRectangle9.y = scene.drawingBufferHeight - drawingBufferPosition.y - (scratchRectangleHeight - 1) * 0.5;
  scratchRectangle9.width = scratchRectangleWidth;
  scratchRectangle9.height = scratchRectangleHeight;
  passState = view.pickFramebuffer.begin(scratchRectangle9, view.viewport);
  scene.updateAndExecuteCommands(passState, scratchColorZero);
  scene.resolveFramebuffers(passState);
  const object2 = view.pickFramebuffer.end(scratchRectangle9);
  context.endFrame();
  return object2;
};
function renderTranslucentDepthForPick(scene, drawingBufferPosition) {
  const context = scene.context;
  const frameState = scene.frameState;
  const environmentState = scene.environmentState;
  const view = scene.defaultView;
  scene.view = view;
  const viewport = view.viewport;
  viewport.x = 0;
  viewport.y = 0;
  viewport.width = context.drawingBufferWidth;
  viewport.height = context.drawingBufferHeight;
  let passState = view.passState;
  passState.viewport = BoundingRectangle_default.clone(viewport, passState.viewport);
  scene.clearPasses(frameState.passes);
  frameState.passes.pick = true;
  frameState.passes.depth = true;
  frameState.cullingVolume = getPickCullingVolume(
    scene,
    drawingBufferPosition,
    1,
    1,
    viewport
  );
  frameState.tilesetPassState = pickTilesetPassState;
  scene.updateEnvironment();
  environmentState.renderTranslucentDepthForPick = true;
  passState = view.pickDepthFramebuffer.update(
    context,
    drawingBufferPosition,
    viewport
  );
  scene.updateAndExecuteCommands(passState, scratchColorZero);
  scene.resolveFramebuffers(passState);
  context.endFrame();
}
var scratchPerspectiveFrustum = new PerspectiveFrustum_default();
var scratchPerspectiveOffCenterFrustum = new PerspectiveOffCenterFrustum_default();
var scratchOrthographicFrustum = new OrthographicFrustum_default();
var scratchOrthographicOffCenterFrustum = new OrthographicOffCenterFrustum_default();
Picking.prototype.pickPositionWorldCoordinates = function(scene, windowPosition, result) {
  if (!scene.useDepthPicking) {
    return void 0;
  }
  if (!defined_default(windowPosition)) {
    throw new DeveloperError_default("windowPosition is undefined.");
  }
  if (!scene.context.depthTexture) {
    throw new DeveloperError_default(
      "Picking from the depth buffer is not supported. Check pickPositionSupported."
    );
  }
  const cacheKey = windowPosition.toString();
  if (this._pickPositionCacheDirty) {
    this._pickPositionCache = {};
    this._pickPositionCacheDirty = false;
  } else if (this._pickPositionCache.hasOwnProperty(cacheKey)) {
    return Cartesian3_default.clone(this._pickPositionCache[cacheKey], result);
  }
  const frameState = scene.frameState;
  const context = scene.context;
  const uniformState = context.uniformState;
  const view = scene.defaultView;
  scene.view = view;
  const drawingBufferPosition = SceneTransforms_default.transformWindowToDrawingBuffer(
    scene,
    windowPosition,
    scratchPosition15
  );
  if (scene.pickTranslucentDepth) {
    renderTranslucentDepthForPick(scene, drawingBufferPosition);
  } else {
    scene.updateFrameState();
    uniformState.update(frameState);
    scene.updateEnvironment();
  }
  drawingBufferPosition.y = scene.drawingBufferHeight - drawingBufferPosition.y;
  const camera = scene.camera;
  let frustum;
  if (defined_default(camera.frustum.fov)) {
    frustum = camera.frustum.clone(scratchPerspectiveFrustum);
  } else if (defined_default(camera.frustum.infiniteProjectionMatrix)) {
    frustum = camera.frustum.clone(scratchPerspectiveOffCenterFrustum);
  } else if (defined_default(camera.frustum.width)) {
    frustum = camera.frustum.clone(scratchOrthographicFrustum);
  } else {
    frustum = camera.frustum.clone(scratchOrthographicOffCenterFrustum);
  }
  const frustumCommandsList = view.frustumCommandsList;
  const numFrustums = frustumCommandsList.length;
  for (let i2 = 0; i2 < numFrustums; ++i2) {
    const pickDepth = this.getPickDepth(scene, i2);
    const depth = pickDepth.getDepth(
      context,
      drawingBufferPosition.x,
      drawingBufferPosition.y
    );
    if (!defined_default(depth)) {
      continue;
    }
    if (depth > 0 && depth < 1) {
      const renderedFrustum = frustumCommandsList[i2];
      let height2D;
      if (scene.mode === SceneMode_default.SCENE2D) {
        height2D = camera.position.z;
        camera.position.z = height2D - renderedFrustum.near + 1;
        frustum.far = Math.max(1, renderedFrustum.far - renderedFrustum.near);
        frustum.near = 1;
        uniformState.update(frameState);
        uniformState.updateFrustum(frustum);
      } else {
        frustum.near = renderedFrustum.near * (i2 !== 0 ? scene.opaqueFrustumNearOffset : 1);
        frustum.far = renderedFrustum.far;
        uniformState.updateFrustum(frustum);
      }
      result = SceneTransforms_default.drawingBufferToWgs84Coordinates(
        scene,
        drawingBufferPosition,
        depth,
        result
      );
      if (scene.mode === SceneMode_default.SCENE2D) {
        camera.position.z = height2D;
        uniformState.update(frameState);
      }
      this._pickPositionCache[cacheKey] = Cartesian3_default.clone(result);
      return result;
    }
  }
  this._pickPositionCache[cacheKey] = void 0;
  return void 0;
};
var scratchPickPositionCartographic = new Cartographic_default();
Picking.prototype.pickPosition = function(scene, windowPosition, result) {
  result = this.pickPositionWorldCoordinates(scene, windowPosition, result);
  if (defined_default(result) && scene.mode !== SceneMode_default.SCENE3D) {
    Cartesian3_default.fromElements(result.y, result.z, result.x, result);
    const projection = scene.mapProjection;
    const ellipsoid = projection.ellipsoid;
    const cart = projection.unproject(result, scratchPickPositionCartographic);
    ellipsoid.cartographicToCartesian(cart, result);
  }
  return result;
};
function drillPick(limit, pickCallback) {
  let i2;
  let attributes;
  const result = [];
  const pickedPrimitives = [];
  const pickedAttributes = [];
  const pickedFeatures = [];
  if (!defined_default(limit)) {
    limit = Number.MAX_VALUE;
  }
  let pickedResult = pickCallback();
  while (defined_default(pickedResult)) {
    const object2 = pickedResult.object;
    const position = pickedResult.position;
    const exclude = pickedResult.exclude;
    if (defined_default(position) && !defined_default(object2)) {
      result.push(pickedResult);
      break;
    }
    if (!defined_default(object2) || !defined_default(object2.primitive)) {
      break;
    }
    if (!exclude) {
      result.push(pickedResult);
      if (0 >= --limit) {
        break;
      }
    }
    const primitive = object2.primitive;
    let hasShowAttribute = false;
    if (typeof primitive.getGeometryInstanceAttributes === "function") {
      if (defined_default(object2.id)) {
        attributes = primitive.getGeometryInstanceAttributes(object2.id);
        if (defined_default(attributes) && defined_default(attributes.show)) {
          hasShowAttribute = true;
          attributes.show = ShowGeometryInstanceAttribute_default.toValue(
            false,
            attributes.show
          );
          pickedAttributes.push(attributes);
        }
      }
    }
    if (object2 instanceof Cesium3DTileFeature_default) {
      hasShowAttribute = true;
      object2.show = false;
      pickedFeatures.push(object2);
    }
    if (!hasShowAttribute) {
      primitive.show = false;
      pickedPrimitives.push(primitive);
    }
    pickedResult = pickCallback();
  }
  for (i2 = 0; i2 < pickedPrimitives.length; ++i2) {
    pickedPrimitives[i2].show = true;
  }
  for (i2 = 0; i2 < pickedAttributes.length; ++i2) {
    attributes = pickedAttributes[i2];
    attributes.show = ShowGeometryInstanceAttribute_default.toValue(
      true,
      attributes.show
    );
  }
  for (i2 = 0; i2 < pickedFeatures.length; ++i2) {
    pickedFeatures[i2].show = true;
  }
  return result;
}
Picking.prototype.drillPick = function(scene, windowPosition, limit, width, height) {
  const that = this;
  const pickCallback = function() {
    const object2 = that.pick(scene, windowPosition, width, height);
    if (defined_default(object2)) {
      return {
        object: object2,
        position: void 0,
        exclude: false
      };
    }
  };
  const objects = drillPick(limit, pickCallback);
  return objects.map(function(element) {
    return element.object;
  });
};
var scratchRight4 = new Cartesian3_default();
var scratchUp3 = new Cartesian3_default();
function MostDetailedRayPick(ray, width, tilesets) {
  this.ray = ray;
  this.width = width;
  this.tilesets = tilesets;
  this.ready = false;
  this.deferred = defer_default();
  this.promise = this.deferred.promise;
}
function updateOffscreenCameraFromRay(picking, ray, width, camera) {
  const direction2 = ray.direction;
  const orthogonalAxis = Cartesian3_default.mostOrthogonalAxis(direction2, scratchRight4);
  const right = Cartesian3_default.cross(direction2, orthogonalAxis, scratchRight4);
  const up = Cartesian3_default.cross(direction2, right, scratchUp3);
  camera.position = ray.origin;
  camera.direction = direction2;
  camera.up = up;
  camera.right = right;
  camera.frustum.width = defaultValue_default(width, offscreenDefaultWidth);
  return camera.frustum.computeCullingVolume(
    camera.positionWC,
    camera.directionWC,
    camera.upWC
  );
}
function updateMostDetailedRayPick(picking, scene, rayPick) {
  const frameState = scene.frameState;
  const ray = rayPick.ray;
  const width = rayPick.width;
  const tilesets = rayPick.tilesets;
  const camera = picking._pickOffscreenView.camera;
  const cullingVolume = updateOffscreenCameraFromRay(
    picking,
    ray,
    width,
    camera
  );
  const tilesetPassState = mostDetailedPreloadTilesetPassState;
  tilesetPassState.camera = camera;
  tilesetPassState.cullingVolume = cullingVolume;
  let ready = true;
  const tilesetsLength = tilesets.length;
  for (let i2 = 0; i2 < tilesetsLength; ++i2) {
    const tileset = tilesets[i2];
    if (tileset.show && scene.primitives.contains(tileset)) {
      tileset.updateForPass(frameState, tilesetPassState);
      ready = ready && tilesetPassState.ready;
    }
  }
  if (ready) {
    rayPick.deferred.resolve();
  }
  return ready;
}
Picking.prototype.updateMostDetailedRayPicks = function(scene) {
  const rayPicks = this._mostDetailedRayPicks;
  for (let i2 = 0; i2 < rayPicks.length; ++i2) {
    if (updateMostDetailedRayPick(this, scene, rayPicks[i2])) {
      rayPicks.splice(i2--, 1);
    }
  }
};
function getTilesets(primitives, objectsToExclude, tilesets) {
  const length3 = primitives.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const primitive = primitives.get(i2);
    if (primitive.show) {
      if (defined_default(primitive.isCesium3DTileset)) {
        if (!defined_default(objectsToExclude) || objectsToExclude.indexOf(primitive) === -1) {
          tilesets.push(primitive);
        }
      } else if (primitive instanceof PrimitiveCollection_default) {
        getTilesets(primitive, objectsToExclude, tilesets);
      }
    }
  }
}
function launchMostDetailedRayPick(picking, scene, ray, objectsToExclude, width, callback) {
  const tilesets = [];
  getTilesets(scene.primitives, objectsToExclude, tilesets);
  if (tilesets.length === 0) {
    return Promise.resolve(callback());
  }
  const rayPick = new MostDetailedRayPick(ray, width, tilesets);
  picking._mostDetailedRayPicks.push(rayPick);
  return rayPick.promise.then(function() {
    return callback();
  });
}
function isExcluded(object2, objectsToExclude) {
  if (!defined_default(object2) || !defined_default(objectsToExclude) || objectsToExclude.length === 0) {
    return false;
  }
  return objectsToExclude.indexOf(object2) > -1 || objectsToExclude.indexOf(object2.primitive) > -1 || objectsToExclude.indexOf(object2.id) > -1;
}
function getRayIntersection(picking, scene, ray, objectsToExclude, width, requirePosition, mostDetailed) {
  const context = scene.context;
  const uniformState = context.uniformState;
  const frameState = scene.frameState;
  const view = picking._pickOffscreenView;
  scene.view = view;
  updateOffscreenCameraFromRay(picking, ray, width, view.camera);
  scratchRectangle9 = BoundingRectangle_default.clone(view.viewport, scratchRectangle9);
  const passState = view.pickFramebuffer.begin(scratchRectangle9, view.viewport);
  scene.jobScheduler.disableThisFrame();
  scene.updateFrameState();
  frameState.invertClassification = false;
  frameState.passes.pick = true;
  frameState.passes.offscreen = true;
  if (mostDetailed) {
    frameState.tilesetPassState = mostDetailedPickTilesetPassState;
  } else {
    frameState.tilesetPassState = pickTilesetPassState;
  }
  uniformState.update(frameState);
  scene.updateEnvironment();
  scene.updateAndExecuteCommands(passState, scratchColorZero);
  scene.resolveFramebuffers(passState);
  let position;
  const object2 = view.pickFramebuffer.end(scratchRectangle9);
  if (scene.context.depthTexture) {
    const numFrustums = view.frustumCommandsList.length;
    for (let i2 = 0; i2 < numFrustums; ++i2) {
      const pickDepth = picking.getPickDepth(scene, i2);
      const depth = pickDepth.getDepth(context, 0, 0);
      if (!defined_default(depth)) {
        continue;
      }
      if (depth > 0 && depth < 1) {
        const renderedFrustum = view.frustumCommandsList[i2];
        const near = renderedFrustum.near * (i2 !== 0 ? scene.opaqueFrustumNearOffset : 1);
        const far = renderedFrustum.far;
        const distance2 = near + depth * (far - near);
        position = Ray_default.getPoint(ray, distance2);
        break;
      }
    }
  }
  scene.view = scene.defaultView;
  context.endFrame();
  if (defined_default(object2) || defined_default(position)) {
    return {
      object: object2,
      position,
      exclude: !defined_default(position) && requirePosition || isExcluded(object2, objectsToExclude)
    };
  }
}
function getRayIntersections(picking, scene, ray, limit, objectsToExclude, width, requirePosition, mostDetailed) {
  const pickCallback = function() {
    return getRayIntersection(
      picking,
      scene,
      ray,
      objectsToExclude,
      width,
      requirePosition,
      mostDetailed
    );
  };
  return drillPick(limit, pickCallback);
}
function pickFromRay(picking, scene, ray, objectsToExclude, width, requirePosition, mostDetailed) {
  const results = getRayIntersections(
    picking,
    scene,
    ray,
    1,
    objectsToExclude,
    width,
    requirePosition,
    mostDetailed
  );
  if (results.length > 0) {
    return results[0];
  }
}
function drillPickFromRay(picking, scene, ray, limit, objectsToExclude, width, requirePosition, mostDetailed) {
  return getRayIntersections(
    picking,
    scene,
    ray,
    limit,
    objectsToExclude,
    width,
    requirePosition,
    mostDetailed
  );
}
function deferPromiseUntilPostRender(scene, promise) {
  const deferred = defer_default();
  promise.then(function(result) {
    const removeCallback = scene.postRender.addEventListener(function() {
      deferred.resolve(result);
      removeCallback();
    });
    scene.requestRender();
  }).catch(function(error) {
    deferred.reject(error);
  });
  return deferred.promise;
}
Picking.prototype.pickFromRay = function(scene, ray, objectsToExclude, width) {
  Check_default.defined("ray", ray);
  if (scene.mode !== SceneMode_default.SCENE3D) {
    throw new DeveloperError_default(
      "Ray intersections are only supported in 3D mode."
    );
  }
  return pickFromRay(this, scene, ray, objectsToExclude, width, false, false);
};
Picking.prototype.drillPickFromRay = function(scene, ray, limit, objectsToExclude, width) {
  Check_default.defined("ray", ray);
  if (scene.mode !== SceneMode_default.SCENE3D) {
    throw new DeveloperError_default(
      "Ray intersections are only supported in 3D mode."
    );
  }
  return drillPickFromRay(
    this,
    scene,
    ray,
    limit,
    objectsToExclude,
    width,
    false,
    false
  );
};
Picking.prototype.pickFromRayMostDetailed = function(scene, ray, objectsToExclude, width) {
  Check_default.defined("ray", ray);
  if (scene.mode !== SceneMode_default.SCENE3D) {
    throw new DeveloperError_default(
      "Ray intersections are only supported in 3D mode."
    );
  }
  const that = this;
  ray = Ray_default.clone(ray);
  objectsToExclude = defined_default(objectsToExclude) ? objectsToExclude.slice() : objectsToExclude;
  return deferPromiseUntilPostRender(
    scene,
    launchMostDetailedRayPick(
      that,
      scene,
      ray,
      objectsToExclude,
      width,
      function() {
        return pickFromRay(
          that,
          scene,
          ray,
          objectsToExclude,
          width,
          false,
          true
        );
      }
    )
  );
};
Picking.prototype.drillPickFromRayMostDetailed = function(scene, ray, limit, objectsToExclude, width) {
  Check_default.defined("ray", ray);
  if (scene.mode !== SceneMode_default.SCENE3D) {
    throw new DeveloperError_default(
      "Ray intersections are only supported in 3D mode."
    );
  }
  const that = this;
  ray = Ray_default.clone(ray);
  objectsToExclude = defined_default(objectsToExclude) ? objectsToExclude.slice() : objectsToExclude;
  return deferPromiseUntilPostRender(
    scene,
    launchMostDetailedRayPick(
      that,
      scene,
      ray,
      objectsToExclude,
      width,
      function() {
        return drillPickFromRay(
          that,
          scene,
          ray,
          limit,
          objectsToExclude,
          width,
          false,
          true
        );
      }
    )
  );
};
var scratchSurfacePosition = new Cartesian3_default();
var scratchSurfaceNormal = new Cartesian3_default();
var scratchSurfaceRay = new Ray_default();
var scratchCartographic19 = new Cartographic_default();
function getRayForSampleHeight(scene, cartographic2) {
  const globe = scene.globe;
  const ellipsoid = defined_default(globe) ? globe.ellipsoid : scene.mapProjection.ellipsoid;
  const height = ApproximateTerrainHeights_default._defaultMaxTerrainHeight;
  const surfaceNormal = ellipsoid.geodeticSurfaceNormalCartographic(
    cartographic2,
    scratchSurfaceNormal
  );
  const surfacePosition = Cartographic_default.toCartesian(
    cartographic2,
    ellipsoid,
    scratchSurfacePosition
  );
  const surfaceRay = scratchSurfaceRay;
  surfaceRay.origin = surfacePosition;
  surfaceRay.direction = surfaceNormal;
  const ray = new Ray_default();
  Ray_default.getPoint(surfaceRay, height, ray.origin);
  Cartesian3_default.negate(surfaceNormal, ray.direction);
  return ray;
}
function getRayForClampToHeight(scene, cartesian11) {
  const globe = scene.globe;
  const ellipsoid = defined_default(globe) ? globe.ellipsoid : scene.mapProjection.ellipsoid;
  const cartographic2 = Cartographic_default.fromCartesian(
    cartesian11,
    ellipsoid,
    scratchCartographic19
  );
  return getRayForSampleHeight(scene, cartographic2);
}
function getHeightFromCartesian(scene, cartesian11) {
  const globe = scene.globe;
  const ellipsoid = defined_default(globe) ? globe.ellipsoid : scene.mapProjection.ellipsoid;
  const cartographic2 = Cartographic_default.fromCartesian(
    cartesian11,
    ellipsoid,
    scratchCartographic19
  );
  return cartographic2.height;
}
function sampleHeightMostDetailed(picking, scene, cartographic2, objectsToExclude, width) {
  const ray = getRayForSampleHeight(scene, cartographic2);
  return launchMostDetailedRayPick(
    picking,
    scene,
    ray,
    objectsToExclude,
    width,
    function() {
      const pickResult = pickFromRay(
        picking,
        scene,
        ray,
        objectsToExclude,
        width,
        true,
        true
      );
      if (defined_default(pickResult)) {
        return getHeightFromCartesian(scene, pickResult.position);
      }
    }
  );
}
function clampToHeightMostDetailed(picking, scene, cartesian11, objectsToExclude, width, result) {
  const ray = getRayForClampToHeight(scene, cartesian11);
  return launchMostDetailedRayPick(
    picking,
    scene,
    ray,
    objectsToExclude,
    width,
    function() {
      const pickResult = pickFromRay(
        picking,
        scene,
        ray,
        objectsToExclude,
        width,
        true,
        true
      );
      if (defined_default(pickResult)) {
        return Cartesian3_default.clone(pickResult.position, result);
      }
    }
  );
}
Picking.prototype.sampleHeight = function(scene, position, objectsToExclude, width) {
  Check_default.defined("position", position);
  if (scene.mode !== SceneMode_default.SCENE3D) {
    throw new DeveloperError_default("sampleHeight is only supported in 3D mode.");
  }
  if (!scene.sampleHeightSupported) {
    throw new DeveloperError_default(
      "sampleHeight requires depth texture support. Check sampleHeightSupported."
    );
  }
  const ray = getRayForSampleHeight(scene, position);
  const pickResult = pickFromRay(
    this,
    scene,
    ray,
    objectsToExclude,
    width,
    true,
    false
  );
  if (defined_default(pickResult)) {
    return getHeightFromCartesian(scene, pickResult.position);
  }
};
Picking.prototype.clampToHeight = function(scene, cartesian11, objectsToExclude, width, result) {
  Check_default.defined("cartesian", cartesian11);
  if (scene.mode !== SceneMode_default.SCENE3D) {
    throw new DeveloperError_default("clampToHeight is only supported in 3D mode.");
  }
  if (!scene.clampToHeightSupported) {
    throw new DeveloperError_default(
      "clampToHeight requires depth texture support. Check clampToHeightSupported."
    );
  }
  const ray = getRayForClampToHeight(scene, cartesian11);
  const pickResult = pickFromRay(
    this,
    scene,
    ray,
    objectsToExclude,
    width,
    true,
    false
  );
  if (defined_default(pickResult)) {
    return Cartesian3_default.clone(pickResult.position, result);
  }
};
Picking.prototype.sampleHeightMostDetailed = function(scene, positions, objectsToExclude, width) {
  Check_default.defined("positions", positions);
  if (scene.mode !== SceneMode_default.SCENE3D) {
    throw new DeveloperError_default(
      "sampleHeightMostDetailed is only supported in 3D mode."
    );
  }
  if (!scene.sampleHeightSupported) {
    throw new DeveloperError_default(
      "sampleHeightMostDetailed requires depth texture support. Check sampleHeightSupported."
    );
  }
  objectsToExclude = defined_default(objectsToExclude) ? objectsToExclude.slice() : objectsToExclude;
  const length3 = positions.length;
  const promises = new Array(length3);
  for (let i2 = 0; i2 < length3; ++i2) {
    promises[i2] = sampleHeightMostDetailed(
      this,
      scene,
      positions[i2],
      objectsToExclude,
      width
    );
  }
  return deferPromiseUntilPostRender(
    scene,
    Promise.all(promises).then(function(heights) {
      const length4 = heights.length;
      for (let i2 = 0; i2 < length4; ++i2) {
        positions[i2].height = heights[i2];
      }
      return positions;
    })
  );
};
Picking.prototype.clampToHeightMostDetailed = function(scene, cartesians, objectsToExclude, width) {
  Check_default.defined("cartesians", cartesians);
  if (scene.mode !== SceneMode_default.SCENE3D) {
    throw new DeveloperError_default(
      "clampToHeightMostDetailed is only supported in 3D mode."
    );
  }
  if (!scene.clampToHeightSupported) {
    throw new DeveloperError_default(
      "clampToHeightMostDetailed requires depth texture support. Check clampToHeightSupported."
    );
  }
  objectsToExclude = defined_default(objectsToExclude) ? objectsToExclude.slice() : objectsToExclude;
  const length3 = cartesians.length;
  const promises = new Array(length3);
  for (let i2 = 0; i2 < length3; ++i2) {
    promises[i2] = clampToHeightMostDetailed(
      this,
      scene,
      cartesians[i2],
      objectsToExclude,
      width,
      cartesians[i2]
    );
  }
  return deferPromiseUntilPostRender(
    scene,
    Promise.all(promises).then(function(clampedCartesians) {
      const length4 = clampedCartesians.length;
      for (let i2 = 0; i2 < length4; ++i2) {
        cartesians[i2] = clampedCartesians[i2];
      }
      return cartesians;
    })
  );
};
Picking.prototype.destroy = function() {
  this._pickOffscreenView = this._pickOffscreenView && this._pickOffscreenView.destroy();
};
var Picking_default = Picking;

// node_modules/cesium/Source/Scene/PostProcessStageSampleMode.js
var PostProcessStageSampleMode = {
  NEAREST: 0,
  LINEAR: 1
};
var PostProcessStageSampleMode_default = PostProcessStageSampleMode;

// node_modules/cesium/Source/Scene/PostProcessStage.js
function PostProcessStage(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const fragmentShader = options.fragmentShader;
  const textureScale = defaultValue_default(options.textureScale, 1);
  const pixelFormat = defaultValue_default(options.pixelFormat, PixelFormat_default.RGBA);
  Check_default.typeOf.string("options.fragmentShader", fragmentShader);
  Check_default.typeOf.number.greaterThan("options.textureScale", textureScale, 0);
  Check_default.typeOf.number.lessThanOrEquals(
    "options.textureScale",
    textureScale,
    1
  );
  if (!PixelFormat_default.isColorFormat(pixelFormat)) {
    throw new DeveloperError_default("options.pixelFormat must be a color format.");
  }
  this._fragmentShader = fragmentShader;
  this._uniforms = options.uniforms;
  this._textureScale = textureScale;
  this._forcePowerOfTwo = defaultValue_default(options.forcePowerOfTwo, false);
  this._sampleMode = defaultValue_default(
    options.sampleMode,
    PostProcessStageSampleMode_default.NEAREST
  );
  this._pixelFormat = pixelFormat;
  this._pixelDatatype = defaultValue_default(
    options.pixelDatatype,
    PixelDatatype_default.UNSIGNED_BYTE
  );
  this._clearColor = defaultValue_default(options.clearColor, Color_default.BLACK);
  this._uniformMap = void 0;
  this._command = void 0;
  this._colorTexture = void 0;
  this._depthTexture = void 0;
  this._idTexture = void 0;
  this._actualUniforms = {};
  this._dirtyUniforms = [];
  this._texturesToRelease = [];
  this._texturesToCreate = [];
  this._texturePromise = void 0;
  const passState = new PassState_default();
  passState.scissorTest = {
    enabled: true,
    rectangle: defined_default(options.scissorRectangle) ? BoundingRectangle_default.clone(options.scissorRectangle) : new BoundingRectangle_default()
  };
  this._passState = passState;
  this._ready = false;
  let name = options.name;
  if (!defined_default(name)) {
    name = createGuid_default();
  }
  this._name = name;
  this._logDepthChanged = void 0;
  this._useLogDepth = void 0;
  this._selectedIdTexture = void 0;
  this._selected = void 0;
  this._selectedShadow = void 0;
  this._parentSelected = void 0;
  this._parentSelectedShadow = void 0;
  this._combinedSelected = void 0;
  this._combinedSelectedShadow = void 0;
  this._selectedLength = 0;
  this._parentSelectedLength = 0;
  this._selectedDirty = true;
  this._textureCache = void 0;
  this._index = void 0;
  this.enabled = true;
  this._enabled = true;
}
Object.defineProperties(PostProcessStage.prototype, {
  ready: {
    get: function() {
      return this._ready;
    }
  },
  name: {
    get: function() {
      return this._name;
    }
  },
  fragmentShader: {
    get: function() {
      return this._fragmentShader;
    }
  },
  uniforms: {
    get: function() {
      return this._uniforms;
    }
  },
  textureScale: {
    get: function() {
      return this._textureScale;
    }
  },
  forcePowerOfTwo: {
    get: function() {
      return this._forcePowerOfTwo;
    }
  },
  sampleMode: {
    get: function() {
      return this._sampleMode;
    }
  },
  pixelFormat: {
    get: function() {
      return this._pixelFormat;
    }
  },
  pixelDatatype: {
    get: function() {
      return this._pixelDatatype;
    }
  },
  clearColor: {
    get: function() {
      return this._clearColor;
    }
  },
  scissorRectangle: {
    get: function() {
      return this._passState.scissorTest.rectangle;
    }
  },
  outputTexture: {
    get: function() {
      if (defined_default(this._textureCache)) {
        const framebuffer = this._textureCache.getFramebuffer(this._name);
        if (defined_default(framebuffer)) {
          return framebuffer.getColorTexture(0);
        }
      }
      return void 0;
    }
  },
  selected: {
    get: function() {
      return this._selected;
    },
    set: function(value) {
      this._selected = value;
    }
  },
  parentSelected: {
    get: function() {
      return this._parentSelected;
    },
    set: function(value) {
      this._parentSelected = value;
    }
  }
});
var depthTextureRegex = /uniform\s+sampler2D\s+depthTexture/g;
PostProcessStage.prototype._isSupported = function(context) {
  return !depthTextureRegex.test(this._fragmentShader) || context.depthTexture;
};
function getUniformValueGetterAndSetter(stage, uniforms, name) {
  const currentValue = uniforms[name];
  if (typeof currentValue === "string" || currentValue instanceof HTMLCanvasElement || currentValue instanceof HTMLImageElement || currentValue instanceof HTMLVideoElement || currentValue instanceof ImageData) {
    stage._dirtyUniforms.push(name);
  }
  return {
    get: function() {
      return uniforms[name];
    },
    set: function(value) {
      const currentValue2 = uniforms[name];
      uniforms[name] = value;
      const actualUniforms = stage._actualUniforms;
      const actualValue = actualUniforms[name];
      if (defined_default(actualValue) && actualValue !== currentValue2 && actualValue instanceof Texture_default && !defined_default(stage._textureCache.getStageByName(name))) {
        stage._texturesToRelease.push(actualValue);
        delete actualUniforms[name];
        delete actualUniforms[`${name}Dimensions`];
      }
      if (currentValue2 instanceof Texture_default) {
        stage._texturesToRelease.push(currentValue2);
      }
      if (typeof value === "string" || value instanceof HTMLCanvasElement || value instanceof HTMLImageElement || value instanceof HTMLVideoElement || value instanceof ImageData) {
        stage._dirtyUniforms.push(name);
      } else {
        actualUniforms[name] = value;
      }
    }
  };
}
function getUniformMapFunction(stage, name) {
  return function() {
    const value = stage._actualUniforms[name];
    if (typeof value === "function") {
      return value();
    }
    return value;
  };
}
function getUniformMapDimensionsFunction(uniformMap2, name) {
  return function() {
    const texture = uniformMap2[name]();
    if (defined_default(texture)) {
      return texture.dimensions;
    }
    return void 0;
  };
}
function createUniformMap7(stage) {
  if (defined_default(stage._uniformMap)) {
    return;
  }
  const uniformMap2 = {};
  const newUniforms = {};
  const uniforms = stage._uniforms;
  const actualUniforms = stage._actualUniforms;
  for (const name in uniforms) {
    if (uniforms.hasOwnProperty(name)) {
      if (typeof uniforms[name] !== "function") {
        uniformMap2[name] = getUniformMapFunction(stage, name);
        newUniforms[name] = getUniformValueGetterAndSetter(
          stage,
          uniforms,
          name
        );
      } else {
        uniformMap2[name] = uniforms[name];
        newUniforms[name] = uniforms[name];
      }
      actualUniforms[name] = uniforms[name];
      const value = uniformMap2[name]();
      if (typeof value === "string" || value instanceof Texture_default || value instanceof HTMLImageElement || value instanceof HTMLCanvasElement || value instanceof HTMLVideoElement) {
        uniformMap2[`${name}Dimensions`] = getUniformMapDimensionsFunction(
          uniformMap2,
          name
        );
      }
    }
  }
  stage._uniforms = {};
  Object.defineProperties(stage._uniforms, newUniforms);
  stage._uniformMap = combine_default(uniformMap2, {
    colorTexture: function() {
      return stage._colorTexture;
    },
    colorTextureDimensions: function() {
      return stage._colorTexture.dimensions;
    },
    depthTexture: function() {
      return stage._depthTexture;
    },
    depthTextureDimensions: function() {
      return stage._depthTexture.dimensions;
    },
    czm_idTexture: function() {
      return stage._idTexture;
    },
    czm_selectedIdTexture: function() {
      return stage._selectedIdTexture;
    },
    czm_selectedIdTextureStep: function() {
      return 1 / stage._selectedIdTexture.width;
    }
  });
}
function createDrawCommand(stage, context) {
  if (defined_default(stage._command) && !stage._logDepthChanged && !stage._selectedDirty) {
    return;
  }
  let fs = stage._fragmentShader;
  if (defined_default(stage._selectedIdTexture)) {
    const width = stage._selectedIdTexture.width;
    fs = fs.replace(/varying\s+vec2\s+v_textureCoordinates;/g, "");
    fs = `${"#define CZM_SELECTED_FEATURE \nuniform sampler2D czm_idTexture; \nuniform sampler2D czm_selectedIdTexture; \nuniform float czm_selectedIdTextureStep; \nvarying vec2 v_textureCoordinates; \nbool czm_selected(vec2 offset) \n{ \n    bool selected = false;\n    vec4 id = texture2D(czm_idTexture, v_textureCoordinates + offset); \n    for (int i = 0; i < "}${width}; ++i) 
    { 
        vec4 selectedId = texture2D(czm_selectedIdTexture, vec2((float(i) + 0.5) * czm_selectedIdTextureStep, 0.5)); 
        if (all(equal(id, selectedId))) 
        { 
            return true; 
        } 
    } 
    return false; 
} 

bool czm_selected() 
{ 
    return czm_selected(vec2(0.0)); 
} 

${fs}`;
  }
  const fragmentShader = new ShaderSource_default({
    defines: [stage._useLogDepth ? "LOG_DEPTH" : ""],
    sources: [fs]
  });
  stage._command = context.createViewportQuadCommand(fragmentShader, {
    uniformMap: stage._uniformMap,
    owner: stage
  });
}
function createSampler(stage) {
  const mode2 = stage._sampleMode;
  let minFilter;
  let magFilter;
  if (mode2 === PostProcessStageSampleMode_default.LINEAR) {
    minFilter = TextureMinificationFilter_default.LINEAR;
    magFilter = TextureMagnificationFilter_default.LINEAR;
  } else {
    minFilter = TextureMinificationFilter_default.NEAREST;
    magFilter = TextureMagnificationFilter_default.NEAREST;
  }
  const sampler = stage._sampler;
  if (!defined_default(sampler) || sampler.minificationFilter !== minFilter || sampler.magnificationFilter !== magFilter) {
    stage._sampler = new Sampler_default({
      wrapS: TextureWrap_default.CLAMP_TO_EDGE,
      wrapT: TextureWrap_default.CLAMP_TO_EDGE,
      minificationFilter: minFilter,
      magnificationFilter: magFilter
    });
  }
}
function createLoadImageFunction(stage, name) {
  return function(image) {
    stage._texturesToCreate.push({
      name,
      source: image
    });
  };
}
function createStageOutputTextureFunction(stage, name) {
  return function() {
    return stage._textureCache.getOutputTexture(name);
  };
}
function updateUniformTextures(stage, context) {
  let i2;
  let texture;
  let name;
  const texturesToRelease = stage._texturesToRelease;
  let length3 = texturesToRelease.length;
  for (i2 = 0; i2 < length3; ++i2) {
    texture = texturesToRelease[i2];
    texture = texture && texture.destroy();
  }
  texturesToRelease.length = 0;
  const texturesToCreate = stage._texturesToCreate;
  length3 = texturesToCreate.length;
  for (i2 = 0; i2 < length3; ++i2) {
    const textureToCreate = texturesToCreate[i2];
    name = textureToCreate.name;
    const source = textureToCreate.source;
    stage._actualUniforms[name] = new Texture_default({
      context,
      source
    });
  }
  texturesToCreate.length = 0;
  const dirtyUniforms = stage._dirtyUniforms;
  if (dirtyUniforms.length === 0 && !defined_default(stage._texturePromise)) {
    stage._ready = true;
    return;
  }
  if (dirtyUniforms.length === 0 || defined_default(stage._texturePromise)) {
    return;
  }
  length3 = dirtyUniforms.length;
  const uniforms = stage._uniforms;
  const promises = [];
  for (i2 = 0; i2 < length3; ++i2) {
    name = dirtyUniforms[i2];
    const stageNameUrlOrImage = uniforms[name];
    const stageWithName = stage._textureCache.getStageByName(
      stageNameUrlOrImage
    );
    if (defined_default(stageWithName)) {
      stage._actualUniforms[name] = createStageOutputTextureFunction(
        stage,
        stageNameUrlOrImage
      );
    } else if (typeof stageNameUrlOrImage === "string") {
      const resource = new Resource_default({
        url: stageNameUrlOrImage
      });
      promises.push(
        resource.fetchImage().then(createLoadImageFunction(stage, name))
      );
    } else {
      stage._texturesToCreate.push({
        name,
        source: stageNameUrlOrImage
      });
    }
  }
  dirtyUniforms.length = 0;
  if (promises.length > 0) {
    stage._ready = false;
    stage._texturePromise = Promise.all(promises).then(function() {
      stage._ready = true;
      stage._texturePromise = void 0;
    });
  } else {
    stage._ready = true;
  }
}
function releaseResources(stage) {
  if (defined_default(stage._command)) {
    stage._command.shaderProgram = stage._command.shaderProgram && stage._command.shaderProgram.destroy();
    stage._command = void 0;
  }
  stage._selectedIdTexture = stage._selectedIdTexture && stage._selectedIdTexture.destroy();
  const textureCache = stage._textureCache;
  if (!defined_default(textureCache)) {
    return;
  }
  const uniforms = stage._uniforms;
  const actualUniforms = stage._actualUniforms;
  for (const name in actualUniforms) {
    if (actualUniforms.hasOwnProperty(name)) {
      if (actualUniforms[name] instanceof Texture_default) {
        if (!defined_default(textureCache.getStageByName(uniforms[name]))) {
          actualUniforms[name].destroy();
        }
        stage._dirtyUniforms.push(name);
      }
    }
  }
}
function isSelectedTextureDirty(stage) {
  let length3 = defined_default(stage._selected) ? stage._selected.length : 0;
  const parentLength = defined_default(stage._parentSelected) ? stage._parentSelected : 0;
  let dirty = stage._selected !== stage._selectedShadow || length3 !== stage._selectedLength;
  dirty = dirty || stage._parentSelected !== stage._parentSelectedShadow || parentLength !== stage._parentSelectedLength;
  if (defined_default(stage._selected) && defined_default(stage._parentSelected)) {
    stage._combinedSelected = stage._selected.concat(stage._parentSelected);
  } else if (defined_default(stage._parentSelected)) {
    stage._combinedSelected = stage._parentSelected;
  } else {
    stage._combinedSelected = stage._selected;
  }
  if (!dirty && defined_default(stage._combinedSelected)) {
    if (!defined_default(stage._combinedSelectedShadow)) {
      return true;
    }
    length3 = stage._combinedSelected.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      if (stage._combinedSelected[i2] !== stage._combinedSelectedShadow[i2]) {
        return true;
      }
    }
  }
  return dirty;
}
function createSelectedTexture(stage, context) {
  if (!stage._selectedDirty) {
    return;
  }
  stage._selectedIdTexture = stage._selectedIdTexture && stage._selectedIdTexture.destroy();
  stage._selectedIdTexture = void 0;
  const features = stage._combinedSelected;
  if (!defined_default(features)) {
    return;
  }
  let i2;
  let feature2;
  let textureLength = 0;
  const length3 = features.length;
  for (i2 = 0; i2 < length3; ++i2) {
    feature2 = features[i2];
    if (defined_default(feature2.pickIds)) {
      textureLength += feature2.pickIds.length;
    } else if (defined_default(feature2.pickId)) {
      ++textureLength;
    }
  }
  if (length3 === 0 || textureLength === 0) {
    const empty = new Uint8Array(4);
    empty[0] = 255;
    empty[1] = 255;
    empty[2] = 255;
    empty[3] = 255;
    stage._selectedIdTexture = new Texture_default({
      context,
      pixelFormat: PixelFormat_default.RGBA,
      pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
      source: {
        arrayBufferView: empty,
        width: 1,
        height: 1
      },
      sampler: Sampler_default.NEAREST
    });
    return;
  }
  let pickColor;
  let offset2 = 0;
  const ids = new Uint8Array(textureLength * 4);
  for (i2 = 0; i2 < length3; ++i2) {
    feature2 = features[i2];
    if (defined_default(feature2.pickIds)) {
      const pickIds = feature2.pickIds;
      const pickIdsLength = pickIds.length;
      for (let j = 0; j < pickIdsLength; ++j) {
        pickColor = pickIds[j].color;
        ids[offset2] = Color_default.floatToByte(pickColor.red);
        ids[offset2 + 1] = Color_default.floatToByte(pickColor.green);
        ids[offset2 + 2] = Color_default.floatToByte(pickColor.blue);
        ids[offset2 + 3] = Color_default.floatToByte(pickColor.alpha);
        offset2 += 4;
      }
    } else if (defined_default(feature2.pickId)) {
      pickColor = feature2.pickId.color;
      ids[offset2] = Color_default.floatToByte(pickColor.red);
      ids[offset2 + 1] = Color_default.floatToByte(pickColor.green);
      ids[offset2 + 2] = Color_default.floatToByte(pickColor.blue);
      ids[offset2 + 3] = Color_default.floatToByte(pickColor.alpha);
      offset2 += 4;
    }
  }
  stage._selectedIdTexture = new Texture_default({
    context,
    pixelFormat: PixelFormat_default.RGBA,
    pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
    source: {
      arrayBufferView: ids,
      width: textureLength,
      height: 1
    },
    sampler: Sampler_default.NEAREST
  });
}
PostProcessStage.prototype.update = function(context, useLogDepth) {
  if (this.enabled !== this._enabled && !this.enabled) {
    releaseResources(this);
  }
  this._enabled = this.enabled;
  if (!this._enabled) {
    return;
  }
  this._logDepthChanged = useLogDepth !== this._useLogDepth;
  this._useLogDepth = useLogDepth;
  this._selectedDirty = isSelectedTextureDirty(this);
  this._selectedShadow = this._selected;
  this._parentSelectedShadow = this._parentSelected;
  this._combinedSelectedShadow = this._combinedSelected;
  this._selectedLength = defined_default(this._selected) ? this._selected.length : 0;
  this._parentSelectedLength = defined_default(this._parentSelected) ? this._parentSelected.length : 0;
  createSelectedTexture(this, context);
  createUniformMap7(this);
  updateUniformTextures(this, context);
  createDrawCommand(this, context);
  createSampler(this);
  this._selectedDirty = false;
  if (!this._ready) {
    return;
  }
  const framebuffer = this._textureCache.getFramebuffer(this._name);
  this._command.framebuffer = framebuffer;
  if (!defined_default(framebuffer)) {
    return;
  }
  const colorTexture = framebuffer.getColorTexture(0);
  let renderState;
  if (colorTexture.width !== context.drawingBufferWidth || colorTexture.height !== context.drawingBufferHeight) {
    renderState = this._renderState;
    if (!defined_default(renderState) || colorTexture.width !== renderState.viewport.width || colorTexture.height !== renderState.viewport.height) {
      this._renderState = RenderState_default.fromCache({
        viewport: new BoundingRectangle_default(
          0,
          0,
          colorTexture.width,
          colorTexture.height
        )
      });
    }
  }
  this._command.renderState = renderState;
};
PostProcessStage.prototype.execute = function(context, colorTexture, depthTexture, idTexture) {
  if (!defined_default(this._command) || !defined_default(this._command.framebuffer) || !this._ready || !this._enabled) {
    return;
  }
  this._colorTexture = colorTexture;
  this._depthTexture = depthTexture;
  this._idTexture = idTexture;
  if (!Sampler_default.equals(this._colorTexture.sampler, this._sampler)) {
    this._colorTexture.sampler = this._sampler;
  }
  const passState = this.scissorRectangle.width > 0 && this.scissorRectangle.height > 0 ? this._passState : void 0;
  if (defined_default(passState)) {
    passState.context = context;
  }
  this._command.execute(context, passState);
};
PostProcessStage.prototype.isDestroyed = function() {
  return false;
};
PostProcessStage.prototype.destroy = function() {
  releaseResources(this);
  return destroyObject_default(this);
};
var PostProcessStage_default = PostProcessStage;

// node_modules/cesium/Source/Shaders/PostProcessStages/AcesTonemappingStage.js
var AcesTonemappingStage_default = "uniform sampler2D colorTexture;\n\nvarying vec2 v_textureCoordinates;\n\n#ifdef AUTO_EXPOSURE\nuniform sampler2D autoExposure;\n#endif\n\nvoid main()\n{\n    vec4 fragmentColor = texture2D(colorTexture, v_textureCoordinates);\n    vec3 color = fragmentColor.rgb;\n\n#ifdef AUTO_EXPOSURE\n    color /= texture2D(autoExposure, vec2(0.5)).r;\n#endif\n    color = czm_acesTonemapping(color);\n    color = czm_inverseGamma(color);\n\n    gl_FragColor = vec4(color, fragmentColor.a);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.js
var AmbientOcclusionGenerate_default = "uniform sampler2D randomTexture;\nuniform sampler2D depthTexture;\nuniform float intensity;\nuniform float bias;\nuniform float lengthCap;\nuniform float stepSize;\nuniform float frustumLength;\n\nvarying vec2 v_textureCoordinates;\n\nvec4 clipToEye(vec2 uv, float depth)\n{\n    vec2 xy = vec2((uv.x * 2.0 - 1.0), ((1.0 - uv.y) * 2.0 - 1.0));\n    vec4 posEC = czm_inverseProjection * vec4(xy, depth, 1.0);\n    posEC = posEC / posEC.w;\n    return posEC;\n}\n\n//Reconstruct Normal Without Edge Removation\nvec3 getNormalXEdge(vec3 posInCamera, float depthU, float depthD, float depthL, float depthR, vec2 pixelSize)\n{\n    vec4 posInCameraUp = clipToEye(v_textureCoordinates - vec2(0.0, pixelSize.y), depthU);\n    vec4 posInCameraDown = clipToEye(v_textureCoordinates + vec2(0.0, pixelSize.y), depthD);\n    vec4 posInCameraLeft = clipToEye(v_textureCoordinates - vec2(pixelSize.x, 0.0), depthL);\n    vec4 posInCameraRight = clipToEye(v_textureCoordinates + vec2(pixelSize.x, 0.0), depthR);\n\n    vec3 up = posInCamera.xyz - posInCameraUp.xyz;\n    vec3 down = posInCameraDown.xyz - posInCamera.xyz;\n    vec3 left = posInCamera.xyz - posInCameraLeft.xyz;\n    vec3 right = posInCameraRight.xyz - posInCamera.xyz;\n\n    vec3 DX = length(left) < length(right) ? left : right;\n    vec3 DY = length(up) < length(down) ? up : down;\n\n    return normalize(cross(DY, DX));\n}\n\nvoid main(void)\n{\n    float depth = czm_readDepth(depthTexture, v_textureCoordinates);\n    vec4 posInCamera = clipToEye(v_textureCoordinates, depth);\n\n    if (posInCamera.z > frustumLength)\n    {\n        gl_FragColor = vec4(1.0);\n        return;\n    }\n\n    vec2 pixelSize = czm_pixelRatio / czm_viewport.zw;\n    float depthU = czm_readDepth(depthTexture, v_textureCoordinates - vec2(0.0, pixelSize.y));\n    float depthD = czm_readDepth(depthTexture, v_textureCoordinates + vec2(0.0, pixelSize.y));\n    float depthL = czm_readDepth(depthTexture, v_textureCoordinates - vec2(pixelSize.x, 0.0));\n    float depthR = czm_readDepth(depthTexture, v_textureCoordinates + vec2(pixelSize.x, 0.0));\n    vec3 normalInCamera = getNormalXEdge(posInCamera.xyz, depthU, depthD, depthL, depthR, pixelSize);\n\n    float ao = 0.0;\n    vec2 sampleDirection = vec2(1.0, 0.0);\n    float gapAngle = 90.0 * czm_radiansPerDegree;\n\n    // RandomNoise\n    float randomVal = texture2D(randomTexture, v_textureCoordinates).x;\n\n    //Loop for each direction\n    for (int i = 0; i < 4; i++)\n    {\n        float newGapAngle = gapAngle * (float(i) + randomVal);\n        float cosVal = cos(newGapAngle);\n        float sinVal = sin(newGapAngle);\n\n        //Rotate Sampling Direction\n        vec2 rotatedSampleDirection = vec2(cosVal * sampleDirection.x - sinVal * sampleDirection.y, sinVal * sampleDirection.x + cosVal * sampleDirection.y);\n        float localAO = 0.0;\n        float localStepSize = stepSize;\n\n        //Loop for each step\n        for (int j = 0; j < 6; j++)\n        {\n            vec2 newCoords = v_textureCoordinates + rotatedSampleDirection * localStepSize * pixelSize;\n\n            //Exception Handling\n            if(newCoords.x > 1.0 || newCoords.y > 1.0 || newCoords.x < 0.0 || newCoords.y < 0.0)\n            {\n                break;\n            }\n\n            float stepDepthInfo = czm_readDepth(depthTexture, newCoords);\n            vec4 stepPosInCamera = clipToEye(newCoords, stepDepthInfo);\n            vec3 diffVec = stepPosInCamera.xyz - posInCamera.xyz;\n            float len = length(diffVec);\n\n            if (len > lengthCap)\n            {\n                break;\n            }\n\n            float dotVal = clamp(dot(normalInCamera, normalize(diffVec)), 0.0, 1.0 );\n            float weight = len / lengthCap;\n            weight = 1.0 - weight * weight;\n\n            if (dotVal < bias)\n            {\n                dotVal = 0.0;\n            }\n\n            localAO = max(localAO, dotVal * weight);\n            localStepSize += stepSize;\n        }\n        ao += localAO;\n    }\n\n    ao /= 4.0;\n    ao = 1.0 - clamp(ao, 0.0, 1.0);\n    ao = pow(ao, intensity);\n    gl_FragColor = vec4(vec3(ao), 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/AmbientOcclusionModulate.js
var AmbientOcclusionModulate_default = "uniform sampler2D colorTexture;\nuniform sampler2D ambientOcclusionTexture;\nuniform bool ambientOcclusionOnly;\nvarying vec2 v_textureCoordinates;\n\nvoid main(void)\n{\n    vec3 color = texture2D(colorTexture, v_textureCoordinates).rgb;\n    vec3 ao = texture2D(ambientOcclusionTexture, v_textureCoordinates).rgb;\n    gl_FragColor.rgb = ambientOcclusionOnly ? ao : ao * color;\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/BlackAndWhite.js
var BlackAndWhite_default = "uniform sampler2D colorTexture;\nuniform float gradations;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main(void)\n{\n    vec3 rgb = texture2D(colorTexture, v_textureCoordinates).rgb;\n#ifdef CZM_SELECTED_FEATURE\n    if (czm_selected()) {\n        gl_FragColor = vec4(rgb, 1.0);\n        return;\n    }\n#endif\n    float luminance = czm_luminance(rgb);\n    float darkness = luminance * gradations;\n    darkness = (darkness - fract(darkness)) / gradations;\n    gl_FragColor = vec4(vec3(darkness), 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/BloomComposite.js
var BloomComposite_default = "uniform sampler2D colorTexture;\nuniform sampler2D bloomTexture;\nuniform bool glowOnly;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main(void)\n{\n    vec4 color = texture2D(colorTexture, v_textureCoordinates);\n\n#ifdef CZM_SELECTED_FEATURE\n    if (czm_selected()) {\n        gl_FragColor = color;\n        return;\n    }\n#endif\n\n    vec4 bloom = texture2D(bloomTexture, v_textureCoordinates);\n    gl_FragColor = glowOnly ? bloom : bloom + color;\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/Brightness.js
var Brightness_default = "uniform sampler2D colorTexture;\nuniform float brightness;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main(void)\n{\n    vec3 rgb = texture2D(colorTexture, v_textureCoordinates).rgb;\n    vec3 target = vec3(0.0);\n    gl_FragColor = vec4(mix(target, rgb, brightness), 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/ContrastBias.js
var ContrastBias_default = "uniform sampler2D colorTexture;\nuniform float contrast;\nuniform float brightness;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main(void)\n{\n    vec3 sceneColor = texture2D(colorTexture, v_textureCoordinates).xyz;\n    sceneColor = czm_RGBToHSB(sceneColor);\n    sceneColor.z += brightness;\n    sceneColor = czm_HSBToRGB(sceneColor);\n\n    float factor = (259.0 * (contrast + 255.0)) / (255.0 * (259.0 - contrast));\n    sceneColor = factor * (sceneColor - vec3(0.5)) + vec3(0.5);\n    gl_FragColor = vec4(sceneColor, 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/DepthOfField.js
var DepthOfField_default = "uniform sampler2D colorTexture;\nuniform sampler2D blurTexture;\nuniform sampler2D depthTexture;\nuniform float focalDistance;\n\nvarying vec2 v_textureCoordinates;\n\nvec4 toEye(vec2 uv, float depth)\n{\n   vec2 xy = vec2((uv.x * 2.0 - 1.0), ((1.0 - uv.y) * 2.0 - 1.0));\n   vec4 posInCamera = czm_inverseProjection * vec4(xy, depth, 1.0);\n   posInCamera = posInCamera / posInCamera.w;\n   return posInCamera;\n}\n\nfloat computeDepthBlur(float depth)\n{\n    float f;\n    if (depth < focalDistance)\n    {\n        f = (focalDistance - depth) / (focalDistance - czm_currentFrustum.x);\n    }\n    else\n    {\n        f = (depth - focalDistance) / (czm_currentFrustum.y - focalDistance);\n        f = pow(f, 0.1);\n    }\n    f *= f;\n    f = clamp(f, 0.0, 1.0);\n    return pow(f, 0.5);\n}\n\nvoid main(void)\n{\n    float depth = czm_readDepth(depthTexture, v_textureCoordinates);\n    vec4 posInCamera = toEye(v_textureCoordinates, depth);\n    float d = computeDepthBlur(-posInCamera.z);\n    gl_FragColor = mix(texture2D(colorTexture, v_textureCoordinates), texture2D(blurTexture, v_textureCoordinates), d);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/DepthView.js
var DepthView_default = "uniform sampler2D depthTexture;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main(void)\n{\n    float depth = czm_readDepth(depthTexture, v_textureCoordinates);\n    gl_FragColor = vec4(vec3(depth), 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/EdgeDetection.js
var EdgeDetection_default = "uniform sampler2D depthTexture;\nuniform float length;\nuniform vec4 color;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main(void)\n{\n    float directions[3];\n    directions[0] = -1.0;\n    directions[1] = 0.0;\n    directions[2] = 1.0;\n\n    float scalars[3];\n    scalars[0] = 3.0;\n    scalars[1] = 10.0;\n    scalars[2] = 3.0;\n\n    float padx = czm_pixelRatio / czm_viewport.z;\n    float pady = czm_pixelRatio / czm_viewport.w;\n\n#ifdef CZM_SELECTED_FEATURE\n    bool selected = false;\n    for (int i = 0; i < 3; ++i)\n    {\n        float dir = directions[i];\n        selected = selected || czm_selected(vec2(-padx, dir * pady));\n        selected = selected || czm_selected(vec2(padx, dir * pady));\n        selected = selected || czm_selected(vec2(dir * padx, -pady));\n        selected = selected || czm_selected(vec2(dir * padx, pady));\n        if (selected)\n        {\n            break;\n        }\n    }\n    if (!selected)\n    {\n        gl_FragColor = vec4(color.rgb, 0.0);\n        return;\n    }\n#endif\n\n    float horizEdge = 0.0;\n    float vertEdge = 0.0;\n\n    for (int i = 0; i < 3; ++i)\n    {\n        float dir = directions[i];\n        float scale = scalars[i];\n\n        horizEdge -= texture2D(depthTexture, v_textureCoordinates + vec2(-padx, dir * pady)).x * scale;\n        horizEdge += texture2D(depthTexture, v_textureCoordinates + vec2(padx, dir * pady)).x * scale;\n\n        vertEdge -= texture2D(depthTexture, v_textureCoordinates + vec2(dir * padx, -pady)).x * scale;\n        vertEdge += texture2D(depthTexture, v_textureCoordinates + vec2(dir * padx, pady)).x * scale;\n    }\n\n    float len = sqrt(horizEdge * horizEdge + vertEdge * vertEdge);\n    gl_FragColor = vec4(color.rgb, len > length ? color.a : 0.0);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/FilmicTonemapping.js
var FilmicTonemapping_default = "uniform sampler2D colorTexture;\n\nvarying vec2 v_textureCoordinates;\n\n#ifdef AUTO_EXPOSURE\nuniform sampler2D autoExposure;\n#endif\n\n// See slides 142 and 143:\n//     http://www.gdcvault.com/play/1012459/Uncharted_2__HDR_Lighting\n\nvoid main()\n{\n    vec4 fragmentColor = texture2D(colorTexture, v_textureCoordinates);\n    vec3 color = fragmentColor.rgb;\n\n#ifdef AUTO_EXPOSURE\n    float exposure = texture2D(autoExposure, vec2(0.5)).r;\n    color /= exposure;\n#endif\n\n	const float A = 0.22; // shoulder strength\n	const float B = 0.30; // linear strength\n	const float C = 0.10; // linear angle\n	const float D = 0.20; // toe strength\n	const float E = 0.01; // toe numerator\n	const float F = 0.30; // toe denominator\n\n	const float white = 11.2; // linear white point value\n\n	vec3 c = ((color * (A * color + C * B) + D * E) / (color * ( A * color + B) + D * F)) - E / F;\n	float w = ((white * (A * white + C * B) + D * E) / (white * ( A * white + B) + D * F)) - E / F;\n\n	c = czm_inverseGamma(c / w);\n	gl_FragColor = vec4(c, fragmentColor.a);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/FXAA.js
var FXAA_default = "varying vec2 v_textureCoordinates;\n\nuniform sampler2D colorTexture;\n\nconst float fxaaQualitySubpix = 0.5;\nconst float fxaaQualityEdgeThreshold = 0.125;\nconst float fxaaQualityEdgeThresholdMin = 0.0833;\n\nvoid main()\n{\n    vec2 fxaaQualityRcpFrame = vec2(1.0) / czm_viewport.zw;\n    vec4 color = FxaaPixelShader(\n        v_textureCoordinates,\n        colorTexture,\n        fxaaQualityRcpFrame,\n        fxaaQualitySubpix,\n        fxaaQualityEdgeThreshold,\n        fxaaQualityEdgeThresholdMin);\n    float alpha = texture2D(colorTexture, v_textureCoordinates).a;\n    gl_FragColor = vec4(color.rgb, alpha);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/GaussianBlur1D.js
var GaussianBlur1D_default = "#define SAMPLES 8\n\nuniform float delta;\nuniform float sigma;\nuniform float direction; // 0.0 for x direction, 1.0 for y direction\n\nuniform sampler2D colorTexture;\n\n#ifdef USE_STEP_SIZE\nuniform float stepSize;\n#else\nuniform vec2 step;\n#endif\n\nvarying vec2 v_textureCoordinates;\n\n//  Incremental Computation of the Gaussian:\n//  https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch40.html\n\nvoid main()\n{\n    vec2 st = v_textureCoordinates;\n    vec2 dir = vec2(1.0 - direction, direction);\n\n#ifdef USE_STEP_SIZE\n    vec2 step = vec2(stepSize * (czm_pixelRatio / czm_viewport.zw));\n#else\n    vec2 step = step;\n#endif\n\n    vec3 g;\n    g.x = 1.0 / (sqrt(czm_twoPi) * sigma);\n    g.y = exp((-0.5 * delta * delta) / (sigma * sigma));\n    g.z = g.y * g.y;\n\n    vec4 result = texture2D(colorTexture, st) * g.x;\n    for (int i = 1; i < SAMPLES; ++i)\n    {\n        g.xy *= g.yz;\n\n        vec2 offset = float(i) * dir * step;\n        result += texture2D(colorTexture, st - offset) * g.x;\n        result += texture2D(colorTexture, st + offset) * g.x;\n    }\n\n    gl_FragColor = result;\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/LensFlare.js
var LensFlare_default = "uniform sampler2D colorTexture;\nuniform sampler2D dirtTexture;\nuniform sampler2D starTexture;\nuniform vec2 dirtTextureDimensions;\nuniform float distortion;\nuniform float ghostDispersal;\nuniform float haloWidth;\nuniform float dirtAmount;\nuniform float earthRadius;\nuniform float intensity;\n\nvarying vec2 v_textureCoordinates;\n\n// whether it is in space or not\n// 6500000.0 is empirical value\n#define DISTANCE_TO_SPACE 6500000.0\n\n// return ndc from world coordinate biased earthRadius\nvec4 getNDCFromWC(vec3 WC, float earthRadius)\n{\n    vec4 positionEC = czm_view * vec4(WC, 1.0);\n    positionEC = vec4(positionEC.x + earthRadius, positionEC.y, positionEC.z, 1.0);\n    vec4 positionWC = czm_eyeToWindowCoordinates(positionEC);\n    return czm_viewportOrthographic * vec4(positionWC.xy, -positionWC.z, 1.0);\n}\n\n// Check if current pixel is included Earth\n// if then mask it gradually\nfloat isInEarth(vec2 texcoord, vec2 sceneSize)\n{\n    vec2 NDC = texcoord * 2.0 - 1.0;\n    vec4 earthPosSC = getNDCFromWC(vec3(0.0), 0.0);\n    vec4 earthPosSCEdge = getNDCFromWC(vec3(0.0), earthRadius * 1.5);\n    NDC.xy -= earthPosSC.xy;\n\n    float X = abs(NDC.x) * sceneSize.x;\n    float Y = abs(NDC.y) * sceneSize.y;\n\n    return clamp(0.0, 1.0, max(sqrt(X * X + Y * Y) / max(abs(earthPosSCEdge.x * sceneSize.x), 1.0) - 0.8 , 0.0));\n}\n\n// For Chromatic effect\nvec4 textureDistorted(sampler2D tex, vec2 texcoord, vec2 direction, vec3 distortion, bool isSpace)\n{\n    vec2 sceneSize = czm_viewport.zw;\n    vec3 color;\n    if(isSpace)\n    {\n        color.r = isInEarth(texcoord + direction * distortion.r, sceneSize) * texture2D(tex, texcoord + direction * distortion.r).r;\n        color.g = isInEarth(texcoord + direction * distortion.g, sceneSize) * texture2D(tex, texcoord + direction * distortion.g).g;\n        color.b = isInEarth(texcoord + direction * distortion.b, sceneSize) * texture2D(tex, texcoord + direction * distortion.b).b;\n    }\n    else\n    {\n        color.r = texture2D(tex, texcoord + direction * distortion.r).r;\n        color.g = texture2D(tex, texcoord + direction * distortion.g).g;\n        color.b = texture2D(tex, texcoord + direction * distortion.b).b;\n    }\n    return vec4(clamp(color, 0.0, 1.0), 0.0);\n}\n\nvoid main(void)\n{\n    vec4 originalColor = texture2D(colorTexture, v_textureCoordinates);\n    vec3 rgb = originalColor.rgb;\n    bool isSpace = length(czm_viewerPositionWC.xyz) > DISTANCE_TO_SPACE;\n\n    // Sun position\n    vec4 sunPos = czm_morphTime == 1.0 ? vec4(czm_sunPositionWC, 1.0) : vec4(czm_sunPositionColumbusView.zxy, 1.0);\n    vec4 sunPositionEC = czm_view * sunPos;\n    vec4 sunPositionWC = czm_eyeToWindowCoordinates(sunPositionEC);\n    sunPos = czm_viewportOrthographic * vec4(sunPositionWC.xy, -sunPositionWC.z, 1.0);\n\n    // If sun is not in the screen space, use original color.\n    if(!isSpace || !((sunPos.x >= -1.1 && sunPos.x <= 1.1) && (sunPos.y >= -1.1 && sunPos.y <= 1.1)))\n    {\n        // Lens flare is disabled when not in space until #5932 is fixed.\n        //    https://github.com/CesiumGS/cesium/issues/5932\n        gl_FragColor = originalColor;\n        return;\n    }\n\n    vec2 texcoord = vec2(1.0) - v_textureCoordinates;\n    vec2 pixelSize = czm_pixelRatio / czm_viewport.zw;\n    vec2 invPixelSize = 1.0 / pixelSize;\n    vec3 distortionVec = pixelSize.x * vec3(-distortion, 0.0, distortion);\n\n    // ghost vector to image centre:\n    vec2 ghostVec = (vec2(0.5) - texcoord) * ghostDispersal;\n    vec3 direction = normalize(vec3(ghostVec, 0.0));\n\n    // sample ghosts:\n    vec4 result = vec4(0.0);\n    vec4 ghost = vec4(0.0);\n    for (int i = 0; i < 4; ++i)\n    {\n        vec2 offset = fract(texcoord + ghostVec * float(i));\n        // Only bright spots from the centre of the source image\n        ghost += textureDistorted(colorTexture, offset, direction.xy, distortionVec, isSpace);\n    }\n    result += ghost;\n\n    // sample halo\n    vec2 haloVec = normalize(ghostVec) * haloWidth;\n    float weightForHalo = length(vec2(0.5) - fract(texcoord + haloVec)) / length(vec2(0.5));\n    weightForHalo = pow(1.0 - weightForHalo, 5.0);\n\n    result += textureDistorted(colorTexture, texcoord + haloVec, direction.xy, distortionVec, isSpace) * weightForHalo * 1.5;\n\n    // dirt on lens\n    vec2 dirtTexCoords = (v_textureCoordinates * invPixelSize) / dirtTextureDimensions;\n    if (dirtTexCoords.x > 1.0)\n    {\n        dirtTexCoords.x = mod(floor(dirtTexCoords.x), 2.0) == 1.0 ? 1.0 - fract(dirtTexCoords.x) :  fract(dirtTexCoords.x);\n    }\n    if (dirtTexCoords.y > 1.0)\n    {\n        dirtTexCoords.y = mod(floor(dirtTexCoords.y), 2.0) == 1.0 ? 1.0 - fract(dirtTexCoords.y) :  fract(dirtTexCoords.y);\n    }\n    result += dirtAmount * texture2D(dirtTexture, dirtTexCoords);\n\n    // Rotating starburst texture's coordinate\n    // dot(czm_view[0].xyz, vec3(0.0, 0.0, 1.0)) + dot(czm_view[1].xyz, vec3(0.0, 1.0, 0.0))\n    float camrot = czm_view[0].z + czm_view[1].y;\n    float cosValue = cos(camrot);\n    float sinValue = sin(camrot);\n    mat3 rotation = mat3(\n        cosValue, -sinValue, 0.0,\n        sinValue, cosValue, 0.0,\n        0.0, 0.0, 1.0\n    );\n\n    vec3 st1 = vec3(v_textureCoordinates * 2.0 - vec2(1.0), 1.0);\n    vec3 st2 = vec3((rotation * st1).xy, 1.0);\n    vec3 st3 = st2 * 0.5 + vec3(0.5);\n    vec2 lensStarTexcoord = st3.xy;\n    float weightForLensFlare = length(vec3(sunPos.xy, 0.0));\n    float oneMinusWeightForLensFlare = max(1.0 - weightForLensFlare, 0.0);\n\n    if (!isSpace)\n    {\n        result *= oneMinusWeightForLensFlare * intensity * 0.2;\n    }\n    else\n    {\n        result *= oneMinusWeightForLensFlare * intensity;\n        result *= texture2D(starTexture, lensStarTexcoord) * pow(weightForLensFlare, 1.0) * max((1.0 - length(vec3(st1.xy, 0.0))), 0.0) * 2.0;\n    }\n\n    result += texture2D(colorTexture, v_textureCoordinates);\n\n    gl_FragColor = result;\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/ModifiedReinhardTonemapping.js
var ModifiedReinhardTonemapping_default = "uniform sampler2D colorTexture;\nuniform vec3 white;\n\nvarying vec2 v_textureCoordinates;\n\n#ifdef AUTO_EXPOSURE\nuniform sampler2D autoExposure;\n#endif\n\n// See equation 4:\n//    http://www.cs.utah.edu/~reinhard/cdrom/tonemap.pdf\n\nvoid main()\n{\n    vec4 fragmentColor = texture2D(colorTexture, v_textureCoordinates);\n    vec3 color = fragmentColor.rgb;\n#ifdef AUTO_EXPOSURE\n    float exposure = texture2D(autoExposure, vec2(0.5)).r;\n    color /= exposure;\n#endif\n    color = (color * (1.0 + color / white)) / (1.0 + color);\n    color = czm_inverseGamma(color);\n    gl_FragColor = vec4(color, fragmentColor.a);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/NightVision.js
var NightVision_default = "uniform sampler2D colorTexture;\n\nvarying vec2 v_textureCoordinates;\n\nfloat rand(vec2 co)\n{\n    return fract(sin(dot(co.xy ,vec2(12.9898, 78.233))) * 43758.5453);\n}\n\nvoid main(void)\n{\n    float noiseValue = rand(v_textureCoordinates + sin(czm_frameNumber)) * 0.1;\n    vec3 rgb = texture2D(colorTexture, v_textureCoordinates).rgb;\n    vec3 green = vec3(0.0, 1.0, 0.0);\n    gl_FragColor = vec4((noiseValue + rgb) * green, 1.0);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/ReinhardTonemapping.js
var ReinhardTonemapping_default = "uniform sampler2D colorTexture;\n\nvarying vec2 v_textureCoordinates;\n\n#ifdef AUTO_EXPOSURE\nuniform sampler2D autoExposure;\n#endif\n\n// See equation 3:\n//    http://www.cs.utah.edu/~reinhard/cdrom/tonemap.pdf\n\nvoid main()\n{\n    vec4 fragmentColor = texture2D(colorTexture, v_textureCoordinates);\n    vec3 color = fragmentColor.rgb;\n#ifdef AUTO_EXPOSURE\n    float exposure = texture2D(autoExposure, vec2(0.5)).r;\n    color /= exposure;\n#endif\n    color = color / (1.0 + color);\n    color = czm_inverseGamma(color);\n    gl_FragColor = vec4(color, fragmentColor.a);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/Silhouette.js
var Silhouette_default = "uniform sampler2D colorTexture;\nuniform sampler2D silhouetteTexture;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main(void)\n{\n    vec4 silhouetteColor = texture2D(silhouetteTexture, v_textureCoordinates);\n    vec4 color = texture2D(colorTexture, v_textureCoordinates);\n    gl_FragColor = mix(color, silhouetteColor, silhouetteColor.a);\n}\n";

// node_modules/cesium/Source/Shaders/FXAA3_11.js
var FXAA3_11_default = "/**\n * @license\n * Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n *  * Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *  * Redistributions in binary form must reproduce the above copyright\n *    notice, this list of conditions and the following disclaimer in the\n *    documentation and/or other materials provided with the distribution.\n *  * Neither the name of NVIDIA CORPORATION nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY\n * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n// NVIDIA GameWorks Graphics Samples GitHub link: https://github.com/NVIDIAGameWorks/GraphicsSamples\n// Original FXAA 3.11 shader link: https://github.com/NVIDIAGameWorks/GraphicsSamples/blob/master/samples/es3-kepler/FXAA/FXAA3_11.h\n\n// Steps used to integrate into Cesium:\n// * The following defines are set:\n//       #define FXAA_PC 1\n//       #define FXAA_WEBGL_1 1\n//       #define FXAA_GREEN_AS_LUMA 1\n//       #define FXAA_EARLY_EXIT 1\n//       #define FXAA_GLSL_120 1\n// * All other preprocessor directives besides the FXAA_QUALITY__P* directives were removed.\n// * Double underscores are invalid for preprocessor directives so replace them with a single underscore. Replace\n//   /FXAA_QUALITY__P(.*)/g with /FXAA_QUALITY__P$1/.\n// * There are no implicit conversions from ivec* to vec* so replace:\n//       #define FxaaInt2 ivec2\n//           with\n//       #define FxaaInt2 vec2\n// * The texture2DLod function is only available in vertex shaders so replace:\n//       #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)\n//       #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)\n//           with\n//       #define FxaaTexTop(t, p) texture2D(t, p)\n//       #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r))\n// * FXAA_QUALITY_PRESET is prepended in the javascript code. We may want to expose that setting in the future.\n// * The following parameters to FxaaPixelShader are unused and can be removed:\n//       fxaaConsolePosPos\n//       fxaaConsoleRcpFrameOpt\n//       fxaaConsoleRcpFrameOpt2\n//       fxaaConsole360RcpFrameOpt2\n//       fxaaConsoleEdgeSharpness\n//       fxaaConsoleEdgeThreshold\n//       fxaaConsoleEdgeThresholdMi\n//       fxaaConsole360ConstDir\n\n//\n// Choose the quality preset.\n// This needs to be compiled into the shader as it effects code.\n// Best option to include multiple presets is to\n// in each shader define the preset, then include this file.\n//\n// OPTIONS\n// -----------------------------------------------------------------------\n// 10 to 15 - default medium dither (10=fastest, 15=highest quality)\n// 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)\n// 39       - no dither, very expensive\n//\n// NOTES\n// -----------------------------------------------------------------------\n// 12 = slightly faster then FXAA 3.9 and higher edge quality (default)\n// 13 = about same speed as FXAA 3.9 and better than 12\n// 23 = closest to FXAA 3.9 visually and performance wise\n//  _ = the lowest digit is directly related to performance\n// _  = the highest digit is directly related to style\n//\n//#define FXAA_QUALITY_PRESET 12\n\n\n#if (FXAA_QUALITY_PRESET == 10)\n    #define FXAA_QUALITY_PS 3\n    #define FXAA_QUALITY_P0 1.5\n    #define FXAA_QUALITY_P1 3.0\n    #define FXAA_QUALITY_P2 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 11)\n    #define FXAA_QUALITY_PS 4\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 3.0\n    #define FXAA_QUALITY_P3 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 12)\n    #define FXAA_QUALITY_PS 5\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 4.0\n    #define FXAA_QUALITY_P4 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 13)\n    #define FXAA_QUALITY_PS 6\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 4.0\n    #define FXAA_QUALITY_P5 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 14)\n    #define FXAA_QUALITY_PS 7\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 4.0\n    #define FXAA_QUALITY_P6 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 15)\n    #define FXAA_QUALITY_PS 8\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 4.0\n    #define FXAA_QUALITY_P7 12.0\n#endif\n#if (FXAA_QUALITY_PRESET == 20)\n    #define FXAA_QUALITY_PS 3\n    #define FXAA_QUALITY_P0 1.5\n    #define FXAA_QUALITY_P1 2.0\n    #define FXAA_QUALITY_P2 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 21)\n    #define FXAA_QUALITY_PS 4\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 22)\n    #define FXAA_QUALITY_PS 5\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 23)\n    #define FXAA_QUALITY_PS 6\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 24)\n    #define FXAA_QUALITY_PS 7\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 3.0\n    #define FXAA_QUALITY_P6 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 25)\n    #define FXAA_QUALITY_PS 8\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 4.0\n    #define FXAA_QUALITY_P7 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 26)\n    #define FXAA_QUALITY_PS 9\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 4.0\n    #define FXAA_QUALITY_P8 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 27)\n    #define FXAA_QUALITY_PS 10\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 4.0\n    #define FXAA_QUALITY_P9 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 28)\n    #define FXAA_QUALITY_PS 11\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 4.0\n    #define FXAA_QUALITY_P10 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 29)\n    #define FXAA_QUALITY_PS 12\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.5\n    #define FXAA_QUALITY_P2 2.0\n    #define FXAA_QUALITY_P3 2.0\n    #define FXAA_QUALITY_P4 2.0\n    #define FXAA_QUALITY_P5 2.0\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 2.0\n    #define FXAA_QUALITY_P10 4.0\n    #define FXAA_QUALITY_P11 8.0\n#endif\n#if (FXAA_QUALITY_PRESET == 39)\n    #define FXAA_QUALITY_PS 12\n    #define FXAA_QUALITY_P0 1.0\n    #define FXAA_QUALITY_P1 1.0\n    #define FXAA_QUALITY_P2 1.0\n    #define FXAA_QUALITY_P3 1.0\n    #define FXAA_QUALITY_P4 1.0\n    #define FXAA_QUALITY_P5 1.5\n    #define FXAA_QUALITY_P6 2.0\n    #define FXAA_QUALITY_P7 2.0\n    #define FXAA_QUALITY_P8 2.0\n    #define FXAA_QUALITY_P9 2.0\n    #define FXAA_QUALITY_P10 4.0\n    #define FXAA_QUALITY_P11 8.0\n#endif\n\n#define FxaaBool bool\n#define FxaaFloat float\n#define FxaaFloat2 vec2\n#define FxaaFloat3 vec3\n#define FxaaFloat4 vec4\n#define FxaaHalf float\n#define FxaaHalf2 vec2\n#define FxaaHalf3 vec3\n#define FxaaHalf4 vec4\n#define FxaaInt2 vec2\n#define FxaaTex sampler2D\n\n#define FxaaSat(x) clamp(x, 0.0, 1.0)\n#define FxaaTexTop(t, p) texture2D(t, p)\n#define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r))\n\nFxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }\n\nFxaaFloat4 FxaaPixelShader(\n    //\n    // Use noperspective interpolation here (turn off perspective interpolation).\n    // {xy} = center of pixel\n    FxaaFloat2 pos,\n    //\n    // Input color texture.\n    // {rgb_} = color in linear or perceptual color space\n    // if (FXAA_GREEN_AS_LUMA == 0)\n    //     {___a} = luma in perceptual color space (not linear)\n    FxaaTex tex,\n    //\n    // Only used on FXAA Quality.\n    // This must be from a constant/uniform.\n    // {x_} = 1.0/screenWidthInPixels\n    // {_y} = 1.0/screenHeightInPixels\n    FxaaFloat2 fxaaQualityRcpFrame,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_SUBPIX define.\n    // It is here now to allow easier tuning.\n    // Choose the amount of sub-pixel aliasing removal.\n    // This can effect sharpness.\n    //   1.00 - upper limit (softer)\n    //   0.75 - default amount of filtering\n    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)\n    //   0.25 - almost off\n    //   0.00 - completely off\n    FxaaFloat fxaaQualitySubpix,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.\n    // It is here now to allow easier tuning.\n    // The minimum amount of local contrast required to apply algorithm.\n    //   0.333 - too little (faster)\n    //   0.250 - low quality\n    //   0.166 - default\n    //   0.125 - high quality\n    //   0.063 - overkill (slower)\n    FxaaFloat fxaaQualityEdgeThreshold,\n    //\n    // Only used on FXAA Quality.\n    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.\n    // It is here now to allow easier tuning.\n    // Trims the algorithm from processing darks.\n    //   0.0833 - upper limit (default, the start of visible unfiltered edges)\n    //   0.0625 - high quality (faster)\n    //   0.0312 - visible limit (slower)\n    // Special notes when using FXAA_GREEN_AS_LUMA,\n    //   Likely want to set this to zero.\n    //   As colors that are mostly not-green\n    //   will appear very dark in the green channel!\n    //   Tune by looking at mostly non-green content,\n    //   then start at zero and increase until aliasing is a problem.\n    FxaaFloat fxaaQualityEdgeThresholdMin\n) {\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posM;\n    posM.x = pos.x;\n    posM.y = pos.y;\n    FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);\n    #define lumaM rgbyM.y\n    FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));\n/*--------------------------------------------------------------------------*/\n    FxaaFloat maxSM = max(lumaS, lumaM);\n    FxaaFloat minSM = min(lumaS, lumaM);\n    FxaaFloat maxESM = max(lumaE, maxSM);\n    FxaaFloat minESM = min(lumaE, minSM);\n    FxaaFloat maxWN = max(lumaN, lumaW);\n    FxaaFloat minWN = min(lumaN, lumaW);\n    FxaaFloat rangeMax = max(maxWN, maxESM);\n    FxaaFloat rangeMin = min(minWN, minESM);\n    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;\n    FxaaFloat range = rangeMax - rangeMin;\n    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);\n    FxaaBool earlyExit = range < rangeMaxClamped;\n/*--------------------------------------------------------------------------*/\n    if(earlyExit)\n        return rgbyM;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));\n    FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNS = lumaN + lumaS;\n    FxaaFloat lumaWE = lumaW + lumaE;\n    FxaaFloat subpixRcpRange = 1.0/range;\n    FxaaFloat subpixNSWE = lumaNS + lumaWE;\n    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;\n    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNESE = lumaNE + lumaSE;\n    FxaaFloat lumaNWNE = lumaNW + lumaNE;\n    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;\n    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat lumaNWSW = lumaNW + lumaSW;\n    FxaaFloat lumaSWSE = lumaSW + lumaSE;\n    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);\n    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);\n    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;\n    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;\n    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;\n    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;\n    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;\n    FxaaBool horzSpan = edgeHorz >= edgeVert;\n    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;\n/*--------------------------------------------------------------------------*/\n    if(!horzSpan) lumaN = lumaW;\n    if(!horzSpan) lumaS = lumaE;\n    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;\n    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat gradientN = lumaN - lumaM;\n    FxaaFloat gradientS = lumaS - lumaM;\n    FxaaFloat lumaNN = lumaN + lumaM;\n    FxaaFloat lumaSS = lumaS + lumaM;\n    FxaaBool pairN = abs(gradientN) >= abs(gradientS);\n    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));\n    if(pairN) lengthSign = -lengthSign;\n    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posB;\n    posB.x = posM.x;\n    posB.y = posM.y;\n    FxaaFloat2 offNP;\n    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;\n    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;\n    if(!horzSpan) posB.x += lengthSign * 0.5;\n    if( horzSpan) posB.y += lengthSign * 0.5;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat2 posN;\n    posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;\n    posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;\n    FxaaFloat2 posP;\n    posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;\n    posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;\n    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;\n    FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));\n    FxaaFloat subpixE = subpixC * subpixC;\n    FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));\n/*--------------------------------------------------------------------------*/\n    if(!pairN) lumaNN = lumaSS;\n    FxaaFloat gradientScaled = gradient * 1.0/4.0;\n    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;\n    FxaaFloat subpixF = subpixD * subpixE;\n    FxaaBool lumaMLTZero = lumaMM < 0.0;\n/*--------------------------------------------------------------------------*/\n    lumaEndN -= lumaNN * 0.5;\n    lumaEndP -= lumaNN * 0.5;\n    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;\n    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;\n    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;\n    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;\n    FxaaBool doneNP = (!doneN) || (!doneP);\n    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;\n    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;\n/*--------------------------------------------------------------------------*/\n    if(doneNP) {\n        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n        doneN = abs(lumaEndN) >= gradientScaled;\n        doneP = abs(lumaEndP) >= gradientScaled;\n        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;\n        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;\n        doneNP = (!doneN) || (!doneP);\n        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;\n        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;\n/*--------------------------------------------------------------------------*/\n        #if (FXAA_QUALITY_PS > 3)\n        if(doneNP) {\n            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n            doneN = abs(lumaEndN) >= gradientScaled;\n            doneP = abs(lumaEndP) >= gradientScaled;\n            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;\n            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;\n            doneNP = (!doneN) || (!doneP);\n            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;\n            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;\n/*--------------------------------------------------------------------------*/\n            #if (FXAA_QUALITY_PS > 4)\n            if(doneNP) {\n                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                doneN = abs(lumaEndN) >= gradientScaled;\n                doneP = abs(lumaEndP) >= gradientScaled;\n                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;\n                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;\n                doneNP = (!doneN) || (!doneP);\n                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;\n                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;\n/*--------------------------------------------------------------------------*/\n                #if (FXAA_QUALITY_PS > 5)\n                if(doneNP) {\n                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                    doneN = abs(lumaEndN) >= gradientScaled;\n                    doneP = abs(lumaEndP) >= gradientScaled;\n                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;\n                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;\n                    doneNP = (!doneN) || (!doneP);\n                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;\n                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;\n/*--------------------------------------------------------------------------*/\n                    #if (FXAA_QUALITY_PS > 6)\n                    if(doneNP) {\n                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                        doneN = abs(lumaEndN) >= gradientScaled;\n                        doneP = abs(lumaEndP) >= gradientScaled;\n                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;\n                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;\n                        doneNP = (!doneN) || (!doneP);\n                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;\n                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;\n/*--------------------------------------------------------------------------*/\n                        #if (FXAA_QUALITY_PS > 7)\n                        if(doneNP) {\n                            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n                            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                            doneN = abs(lumaEndN) >= gradientScaled;\n                            doneP = abs(lumaEndP) >= gradientScaled;\n                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;\n                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;\n                            doneNP = (!doneN) || (!doneP);\n                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;\n                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;\n/*--------------------------------------------------------------------------*/\n    #if (FXAA_QUALITY_PS > 8)\n    if(doneNP) {\n        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n        doneN = abs(lumaEndN) >= gradientScaled;\n        doneP = abs(lumaEndP) >= gradientScaled;\n        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;\n        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;\n        doneNP = (!doneN) || (!doneP);\n        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;\n        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;\n/*--------------------------------------------------------------------------*/\n        #if (FXAA_QUALITY_PS > 9)\n        if(doneNP) {\n            if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n            if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n            doneN = abs(lumaEndN) >= gradientScaled;\n            doneP = abs(lumaEndP) >= gradientScaled;\n            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;\n            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;\n            doneNP = (!doneN) || (!doneP);\n            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;\n            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;\n/*--------------------------------------------------------------------------*/\n            #if (FXAA_QUALITY_PS > 10)\n            if(doneNP) {\n                if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n                if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                doneN = abs(lumaEndN) >= gradientScaled;\n                doneP = abs(lumaEndP) >= gradientScaled;\n                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;\n                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;\n                doneNP = (!doneN) || (!doneP);\n                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;\n                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;\n/*--------------------------------------------------------------------------*/\n                #if (FXAA_QUALITY_PS > 11)\n                if(doneNP) {\n                    if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n                    if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                    doneN = abs(lumaEndN) >= gradientScaled;\n                    doneP = abs(lumaEndP) >= gradientScaled;\n                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;\n                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;\n                    doneNP = (!doneN) || (!doneP);\n                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;\n                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;\n/*--------------------------------------------------------------------------*/\n                    #if (FXAA_QUALITY_PS > 12)\n                    if(doneNP) {\n                        if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n                        if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n                        doneN = abs(lumaEndN) >= gradientScaled;\n                        doneP = abs(lumaEndP) >= gradientScaled;\n                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;\n                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;\n                        doneNP = (!doneN) || (!doneP);\n                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;\n                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;\n/*--------------------------------------------------------------------------*/\n                    }\n                    #endif\n/*--------------------------------------------------------------------------*/\n                }\n                #endif\n/*--------------------------------------------------------------------------*/\n            }\n            #endif\n/*--------------------------------------------------------------------------*/\n        }\n        #endif\n/*--------------------------------------------------------------------------*/\n    }\n    #endif\n/*--------------------------------------------------------------------------*/\n                        }\n                        #endif\n/*--------------------------------------------------------------------------*/\n                    }\n                    #endif\n/*--------------------------------------------------------------------------*/\n                }\n                #endif\n/*--------------------------------------------------------------------------*/\n            }\n            #endif\n/*--------------------------------------------------------------------------*/\n        }\n        #endif\n/*--------------------------------------------------------------------------*/\n    }\n/*--------------------------------------------------------------------------*/\n    FxaaFloat dstN = posM.x - posN.x;\n    FxaaFloat dstP = posP.x - posM.x;\n    if(!horzSpan) dstN = posM.y - posN.y;\n    if(!horzSpan) dstP = posP.y - posM.y;\n/*--------------------------------------------------------------------------*/\n    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;\n    FxaaFloat spanLength = (dstP + dstN);\n    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;\n    FxaaFloat spanLengthRcp = 1.0/spanLength;\n/*--------------------------------------------------------------------------*/\n    FxaaBool directionN = dstN < dstP;\n    FxaaFloat dst = min(dstN, dstP);\n    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;\n    FxaaFloat subpixG = subpixF * subpixF;\n    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;\n    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;\n/*--------------------------------------------------------------------------*/\n    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;\n    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);\n    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;\n    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;\n    return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);\n}\n";

// node_modules/cesium/Source/Scene/PostProcessStageComposite.js
function PostProcessStageComposite(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.defined("options.stages", options.stages);
  Check_default.typeOf.number.greaterThan(
    "options.stages.length",
    options.stages.length,
    0
  );
  this._stages = options.stages;
  this._inputPreviousStageTexture = defaultValue_default(
    options.inputPreviousStageTexture,
    true
  );
  let name = options.name;
  if (!defined_default(name)) {
    name = createGuid_default();
  }
  this._name = name;
  this._uniforms = options.uniforms;
  this._textureCache = void 0;
  this._index = void 0;
  this._selected = void 0;
  this._selectedShadow = void 0;
  this._parentSelected = void 0;
  this._parentSelectedShadow = void 0;
  this._combinedSelected = void 0;
  this._combinedSelectedShadow = void 0;
  this._selectedLength = 0;
  this._parentSelectedLength = 0;
  this._selectedDirty = true;
}
Object.defineProperties(PostProcessStageComposite.prototype, {
  ready: {
    get: function() {
      const stages = this._stages;
      const length3 = stages.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        if (!stages[i2].ready) {
          return false;
        }
      }
      return true;
    }
  },
  name: {
    get: function() {
      return this._name;
    }
  },
  enabled: {
    get: function() {
      return this._stages[0].enabled;
    },
    set: function(value) {
      const stages = this._stages;
      const length3 = stages.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        stages[i2].enabled = value;
      }
    }
  },
  uniforms: {
    get: function() {
      return this._uniforms;
    }
  },
  inputPreviousStageTexture: {
    get: function() {
      return this._inputPreviousStageTexture;
    }
  },
  length: {
    get: function() {
      return this._stages.length;
    }
  },
  selected: {
    get: function() {
      return this._selected;
    },
    set: function(value) {
      this._selected = value;
    }
  },
  parentSelected: {
    get: function() {
      return this._parentSelected;
    },
    set: function(value) {
      this._parentSelected = value;
    }
  }
});
PostProcessStageComposite.prototype._isSupported = function(context) {
  const stages = this._stages;
  const length3 = stages.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    if (!stages[i2]._isSupported(context)) {
      return false;
    }
  }
  return true;
};
PostProcessStageComposite.prototype.get = function(index2) {
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThan("index", index2, this.length);
  return this._stages[index2];
};
function isSelectedTextureDirty2(stage) {
  let length3 = defined_default(stage._selected) ? stage._selected.length : 0;
  const parentLength = defined_default(stage._parentSelected) ? stage._parentSelected : 0;
  let dirty = stage._selected !== stage._selectedShadow || length3 !== stage._selectedLength;
  dirty = dirty || stage._parentSelected !== stage._parentSelectedShadow || parentLength !== stage._parentSelectedLength;
  if (defined_default(stage._selected) && defined_default(stage._parentSelected)) {
    stage._combinedSelected = stage._selected.concat(stage._parentSelected);
  } else if (defined_default(stage._parentSelected)) {
    stage._combinedSelected = stage._parentSelected;
  } else {
    stage._combinedSelected = stage._selected;
  }
  if (!dirty && defined_default(stage._combinedSelected)) {
    if (!defined_default(stage._combinedSelectedShadow)) {
      return true;
    }
    length3 = stage._combinedSelected.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      if (stage._combinedSelected[i2] !== stage._combinedSelectedShadow[i2]) {
        return true;
      }
    }
  }
  return dirty;
}
PostProcessStageComposite.prototype.update = function(context, useLogDepth) {
  this._selectedDirty = isSelectedTextureDirty2(this);
  this._selectedShadow = this._selected;
  this._parentSelectedShadow = this._parentSelected;
  this._combinedSelectedShadow = this._combinedSelected;
  this._selectedLength = defined_default(this._selected) ? this._selected.length : 0;
  this._parentSelectedLength = defined_default(this._parentSelected) ? this._parentSelected.length : 0;
  const stages = this._stages;
  const length3 = stages.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const stage = stages[i2];
    if (this._selectedDirty) {
      stage.parentSelected = this._combinedSelected;
    }
    stage.update(context, useLogDepth);
  }
};
PostProcessStageComposite.prototype.isDestroyed = function() {
  return false;
};
PostProcessStageComposite.prototype.destroy = function() {
  const stages = this._stages;
  const length3 = stages.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    stages[i2].destroy();
  }
  return destroyObject_default(this);
};
var PostProcessStageComposite_default = PostProcessStageComposite;

// node_modules/cesium/Source/Scene/PostProcessStageLibrary.js
var PostProcessStageLibrary = {};
function createBlur(name) {
  const delta = 1;
  const sigma = 2;
  const stepSize = 1;
  const blurShader = `#define USE_STEP_SIZE
${GaussianBlur1D_default}`;
  const blurX = new PostProcessStage_default({
    name: `${name}_x_direction`,
    fragmentShader: blurShader,
    uniforms: {
      delta,
      sigma,
      stepSize,
      direction: 0
    },
    sampleMode: PostProcessStageSampleMode_default.LINEAR
  });
  const blurY = new PostProcessStage_default({
    name: `${name}_y_direction`,
    fragmentShader: blurShader,
    uniforms: {
      delta,
      sigma,
      stepSize,
      direction: 1
    },
    sampleMode: PostProcessStageSampleMode_default.LINEAR
  });
  const uniforms = {};
  Object.defineProperties(uniforms, {
    delta: {
      get: function() {
        return blurX.uniforms.delta;
      },
      set: function(value) {
        const blurXUniforms = blurX.uniforms;
        const blurYUniforms = blurY.uniforms;
        blurXUniforms.delta = blurYUniforms.delta = value;
      }
    },
    sigma: {
      get: function() {
        return blurX.uniforms.sigma;
      },
      set: function(value) {
        const blurXUniforms = blurX.uniforms;
        const blurYUniforms = blurY.uniforms;
        blurXUniforms.sigma = blurYUniforms.sigma = value;
      }
    },
    stepSize: {
      get: function() {
        return blurX.uniforms.stepSize;
      },
      set: function(value) {
        const blurXUniforms = blurX.uniforms;
        const blurYUniforms = blurY.uniforms;
        blurXUniforms.stepSize = blurYUniforms.stepSize = value;
      }
    }
  });
  return new PostProcessStageComposite_default({
    name,
    stages: [blurX, blurY],
    uniforms
  });
}
PostProcessStageLibrary.createBlurStage = function() {
  return createBlur("czm_blur");
};
PostProcessStageLibrary.createDepthOfFieldStage = function() {
  const blur = createBlur("czm_depth_of_field_blur");
  const dof = new PostProcessStage_default({
    name: "czm_depth_of_field_composite",
    fragmentShader: DepthOfField_default,
    uniforms: {
      focalDistance: 5,
      blurTexture: blur.name
    }
  });
  const uniforms = {};
  Object.defineProperties(uniforms, {
    focalDistance: {
      get: function() {
        return dof.uniforms.focalDistance;
      },
      set: function(value) {
        dof.uniforms.focalDistance = value;
      }
    },
    delta: {
      get: function() {
        return blur.uniforms.delta;
      },
      set: function(value) {
        blur.uniforms.delta = value;
      }
    },
    sigma: {
      get: function() {
        return blur.uniforms.sigma;
      },
      set: function(value) {
        blur.uniforms.sigma = value;
      }
    },
    stepSize: {
      get: function() {
        return blur.uniforms.stepSize;
      },
      set: function(value) {
        blur.uniforms.stepSize = value;
      }
    }
  });
  return new PostProcessStageComposite_default({
    name: "czm_depth_of_field",
    stages: [blur, dof],
    inputPreviousStageTexture: false,
    uniforms
  });
};
PostProcessStageLibrary.isDepthOfFieldSupported = function(scene) {
  return scene.context.depthTexture;
};
PostProcessStageLibrary.createEdgeDetectionStage = function() {
  const name = createGuid_default();
  return new PostProcessStage_default({
    name: `czm_edge_detection_${name}`,
    fragmentShader: EdgeDetection_default,
    uniforms: {
      length: 0.25,
      color: Color_default.clone(Color_default.BLACK)
    }
  });
};
PostProcessStageLibrary.isEdgeDetectionSupported = function(scene) {
  return scene.context.depthTexture;
};
function getSilhouetteEdgeDetection(edgeDetectionStages) {
  if (!defined_default(edgeDetectionStages)) {
    return PostProcessStageLibrary.createEdgeDetectionStage();
  }
  const edgeDetection = new PostProcessStageComposite_default({
    name: "czm_edge_detection_multiple",
    stages: edgeDetectionStages,
    inputPreviousStageTexture: false
  });
  const compositeUniforms = {};
  let fsDecl = "";
  let fsLoop = "";
  for (let i2 = 0; i2 < edgeDetectionStages.length; ++i2) {
    fsDecl += `uniform sampler2D edgeTexture${i2}; 
`;
    fsLoop += `        vec4 edge${i2} = texture2D(edgeTexture${i2}, v_textureCoordinates); 
        if (edge${i2}.a > 0.0) 
        { 
            color = edge${i2}; 
            break; 
        } 
`;
    compositeUniforms[`edgeTexture${i2}`] = edgeDetectionStages[i2].name;
  }
  const fs = `${fsDecl}varying vec2 v_textureCoordinates; 
void main() { 
    vec4 color = vec4(0.0); 
    for (int i = 0; i < ${edgeDetectionStages.length}; i++) 
    { 
${fsLoop}    } 
    gl_FragColor = color; 
} 
`;
  const edgeComposite = new PostProcessStage_default({
    name: "czm_edge_detection_combine",
    fragmentShader: fs,
    uniforms: compositeUniforms
  });
  return new PostProcessStageComposite_default({
    name: "czm_edge_detection_composite",
    stages: [edgeDetection, edgeComposite]
  });
}
PostProcessStageLibrary.createSilhouetteStage = function(edgeDetectionStages) {
  const edgeDetection = getSilhouetteEdgeDetection(edgeDetectionStages);
  const silhouetteProcess = new PostProcessStage_default({
    name: "czm_silhouette_color_edges",
    fragmentShader: Silhouette_default,
    uniforms: {
      silhouetteTexture: edgeDetection.name
    }
  });
  return new PostProcessStageComposite_default({
    name: "czm_silhouette",
    stages: [edgeDetection, silhouetteProcess],
    inputPreviousStageTexture: false,
    uniforms: edgeDetection.uniforms
  });
};
PostProcessStageLibrary.isSilhouetteSupported = function(scene) {
  return scene.context.depthTexture;
};
PostProcessStageLibrary.createBloomStage = function() {
  const contrastBias = new PostProcessStage_default({
    name: "czm_bloom_contrast_bias",
    fragmentShader: ContrastBias_default,
    uniforms: {
      contrast: 128,
      brightness: -0.3
    }
  });
  const blur = createBlur("czm_bloom_blur");
  const generateComposite = new PostProcessStageComposite_default({
    name: "czm_bloom_contrast_bias_blur",
    stages: [contrastBias, blur]
  });
  const bloomComposite = new PostProcessStage_default({
    name: "czm_bloom_generate_composite",
    fragmentShader: BloomComposite_default,
    uniforms: {
      glowOnly: false,
      bloomTexture: generateComposite.name
    }
  });
  const uniforms = {};
  Object.defineProperties(uniforms, {
    glowOnly: {
      get: function() {
        return bloomComposite.uniforms.glowOnly;
      },
      set: function(value) {
        bloomComposite.uniforms.glowOnly = value;
      }
    },
    contrast: {
      get: function() {
        return contrastBias.uniforms.contrast;
      },
      set: function(value) {
        contrastBias.uniforms.contrast = value;
      }
    },
    brightness: {
      get: function() {
        return contrastBias.uniforms.brightness;
      },
      set: function(value) {
        contrastBias.uniforms.brightness = value;
      }
    },
    delta: {
      get: function() {
        return blur.uniforms.delta;
      },
      set: function(value) {
        blur.uniforms.delta = value;
      }
    },
    sigma: {
      get: function() {
        return blur.uniforms.sigma;
      },
      set: function(value) {
        blur.uniforms.sigma = value;
      }
    },
    stepSize: {
      get: function() {
        return blur.uniforms.stepSize;
      },
      set: function(value) {
        blur.uniforms.stepSize = value;
      }
    }
  });
  return new PostProcessStageComposite_default({
    name: "czm_bloom",
    stages: [generateComposite, bloomComposite],
    inputPreviousStageTexture: false,
    uniforms
  });
};
PostProcessStageLibrary.createAmbientOcclusionStage = function() {
  const generate = new PostProcessStage_default({
    name: "czm_ambient_occlusion_generate",
    fragmentShader: AmbientOcclusionGenerate_default,
    uniforms: {
      intensity: 3,
      bias: 0.1,
      lengthCap: 0.26,
      stepSize: 1.95,
      frustumLength: 1e3,
      randomTexture: void 0
    }
  });
  const blur = createBlur("czm_ambient_occlusion_blur");
  blur.uniforms.stepSize = 0.86;
  const generateAndBlur = new PostProcessStageComposite_default({
    name: "czm_ambient_occlusion_generate_blur",
    stages: [generate, blur]
  });
  const ambientOcclusionModulate = new PostProcessStage_default({
    name: "czm_ambient_occlusion_composite",
    fragmentShader: AmbientOcclusionModulate_default,
    uniforms: {
      ambientOcclusionOnly: false,
      ambientOcclusionTexture: generateAndBlur.name
    }
  });
  const uniforms = {};
  Object.defineProperties(uniforms, {
    intensity: {
      get: function() {
        return generate.uniforms.intensity;
      },
      set: function(value) {
        generate.uniforms.intensity = value;
      }
    },
    bias: {
      get: function() {
        return generate.uniforms.bias;
      },
      set: function(value) {
        generate.uniforms.bias = value;
      }
    },
    lengthCap: {
      get: function() {
        return generate.uniforms.lengthCap;
      },
      set: function(value) {
        generate.uniforms.lengthCap = value;
      }
    },
    stepSize: {
      get: function() {
        return generate.uniforms.stepSize;
      },
      set: function(value) {
        generate.uniforms.stepSize = value;
      }
    },
    frustumLength: {
      get: function() {
        return generate.uniforms.frustumLength;
      },
      set: function(value) {
        generate.uniforms.frustumLength = value;
      }
    },
    randomTexture: {
      get: function() {
        return generate.uniforms.randomTexture;
      },
      set: function(value) {
        generate.uniforms.randomTexture = value;
      }
    },
    delta: {
      get: function() {
        return blur.uniforms.delta;
      },
      set: function(value) {
        blur.uniforms.delta = value;
      }
    },
    sigma: {
      get: function() {
        return blur.uniforms.sigma;
      },
      set: function(value) {
        blur.uniforms.sigma = value;
      }
    },
    blurStepSize: {
      get: function() {
        return blur.uniforms.stepSize;
      },
      set: function(value) {
        blur.uniforms.stepSize = value;
      }
    },
    ambientOcclusionOnly: {
      get: function() {
        return ambientOcclusionModulate.uniforms.ambientOcclusionOnly;
      },
      set: function(value) {
        ambientOcclusionModulate.uniforms.ambientOcclusionOnly = value;
      }
    }
  });
  return new PostProcessStageComposite_default({
    name: "czm_ambient_occlusion",
    stages: [generateAndBlur, ambientOcclusionModulate],
    inputPreviousStageTexture: false,
    uniforms
  });
};
PostProcessStageLibrary.isAmbientOcclusionSupported = function(scene) {
  return scene.context.depthTexture;
};
var fxaaFS = `#define FXAA_QUALITY_PRESET 39 
${FXAA3_11_default}
${FXAA_default}`;
PostProcessStageLibrary.createFXAAStage = function() {
  return new PostProcessStage_default({
    name: "czm_FXAA",
    fragmentShader: fxaaFS,
    sampleMode: PostProcessStageSampleMode_default.LINEAR
  });
};
PostProcessStageLibrary.createAcesTonemappingStage = function(useAutoExposure) {
  let fs = useAutoExposure ? "#define AUTO_EXPOSURE\n" : "";
  fs += AcesTonemappingStage_default;
  return new PostProcessStage_default({
    name: "czm_aces",
    fragmentShader: fs,
    uniforms: {
      autoExposure: void 0
    }
  });
};
PostProcessStageLibrary.createFilmicTonemappingStage = function(useAutoExposure) {
  let fs = useAutoExposure ? "#define AUTO_EXPOSURE\n" : "";
  fs += FilmicTonemapping_default;
  return new PostProcessStage_default({
    name: "czm_filmic",
    fragmentShader: fs,
    uniforms: {
      autoExposure: void 0
    }
  });
};
PostProcessStageLibrary.createReinhardTonemappingStage = function(useAutoExposure) {
  let fs = useAutoExposure ? "#define AUTO_EXPOSURE\n" : "";
  fs += ReinhardTonemapping_default;
  return new PostProcessStage_default({
    name: "czm_reinhard",
    fragmentShader: fs,
    uniforms: {
      autoExposure: void 0
    }
  });
};
PostProcessStageLibrary.createModifiedReinhardTonemappingStage = function(useAutoExposure) {
  let fs = useAutoExposure ? "#define AUTO_EXPOSURE\n" : "";
  fs += ModifiedReinhardTonemapping_default;
  return new PostProcessStage_default({
    name: "czm_modified_reinhard",
    fragmentShader: fs,
    uniforms: {
      white: Color_default.WHITE,
      autoExposure: void 0
    }
  });
};
PostProcessStageLibrary.createAutoExposureStage = function() {
  return new AutoExposure_default();
};
PostProcessStageLibrary.createBlackAndWhiteStage = function() {
  return new PostProcessStage_default({
    name: "czm_black_and_white",
    fragmentShader: BlackAndWhite_default,
    uniforms: {
      gradations: 5
    }
  });
};
PostProcessStageLibrary.createBrightnessStage = function() {
  return new PostProcessStage_default({
    name: "czm_brightness",
    fragmentShader: Brightness_default,
    uniforms: {
      brightness: 0.5
    }
  });
};
PostProcessStageLibrary.createNightVisionStage = function() {
  return new PostProcessStage_default({
    name: "czm_night_vision",
    fragmentShader: NightVision_default
  });
};
PostProcessStageLibrary.createDepthViewStage = function() {
  return new PostProcessStage_default({
    name: "czm_depth_view",
    fragmentShader: DepthView_default
  });
};
PostProcessStageLibrary.createLensFlareStage = function() {
  return new PostProcessStage_default({
    name: "czm_lens_flare",
    fragmentShader: LensFlare_default,
    uniforms: {
      dirtTexture: buildModuleUrl_default("Assets/Textures/LensFlare/DirtMask.jpg"),
      starTexture: buildModuleUrl_default("Assets/Textures/LensFlare/StarBurst.jpg"),
      intensity: 2,
      distortion: 10,
      ghostDispersal: 0.4,
      haloWidth: 0.4,
      dirtAmount: 0.4,
      earthRadius: Ellipsoid_default.WGS84.maximumRadius
    }
  });
};
var PostProcessStageLibrary_default = PostProcessStageLibrary;

// node_modules/cesium/Source/Scene/PostProcessStageTextureCache.js
function PostProcessStageTextureCache(postProcessStageCollection) {
  this._collection = postProcessStageCollection;
  this._framebuffers = [];
  this._stageNameToFramebuffer = {};
  this._width = void 0;
  this._height = void 0;
  this._updateDependencies = false;
}
function getLastStageName(stage) {
  while (defined_default(stage.length)) {
    stage = stage.get(stage.length - 1);
  }
  return stage.name;
}
function getStageDependencies(collection, context, dependencies, stage, previousName) {
  if (!stage.enabled || !stage._isSupported(context)) {
    return previousName;
  }
  const stageDependencies = dependencies[stage.name] = {};
  if (defined_default(previousName)) {
    const previous = collection.getStageByName(previousName);
    stageDependencies[getLastStageName(previous)] = true;
  }
  const uniforms = stage.uniforms;
  if (defined_default(uniforms)) {
    const uniformNames = Object.getOwnPropertyNames(uniforms);
    const uniformNamesLength = uniformNames.length;
    for (let i2 = 0; i2 < uniformNamesLength; ++i2) {
      const value = uniforms[uniformNames[i2]];
      if (typeof value === "string") {
        const dependent = collection.getStageByName(value);
        if (defined_default(dependent)) {
          stageDependencies[getLastStageName(dependent)] = true;
        }
      }
    }
  }
  return stage.name;
}
function getCompositeDependencies(collection, context, dependencies, composite, previousName) {
  if (defined_default(composite.enabled) && !composite.enabled || defined_default(composite._isSupported) && !composite._isSupported(context)) {
    return previousName;
  }
  const originalDependency = previousName;
  const inSeries = !defined_default(composite.inputPreviousStageTexture) || composite.inputPreviousStageTexture;
  let currentName = previousName;
  const length3 = composite.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const stage = composite.get(i2);
    if (defined_default(stage.length)) {
      currentName = getCompositeDependencies(
        collection,
        context,
        dependencies,
        stage,
        previousName
      );
    } else {
      currentName = getStageDependencies(
        collection,
        context,
        dependencies,
        stage,
        previousName
      );
    }
    if (inSeries) {
      previousName = currentName;
    }
  }
  let j;
  let name;
  if (!inSeries) {
    for (j = 1; j < length3; ++j) {
      name = getLastStageName(composite.get(j));
      const currentDependencies = dependencies[name];
      for (let k = 0; k < j; ++k) {
        currentDependencies[getLastStageName(composite.get(k))] = true;
      }
    }
  } else {
    for (j = 1; j < length3; ++j) {
      name = getLastStageName(composite.get(j));
      if (!defined_default(dependencies[name])) {
        dependencies[name] = {};
      }
      dependencies[name][originalDependency] = true;
    }
  }
  return currentName;
}
function getDependencies(collection, context) {
  const dependencies = {};
  if (defined_default(collection.ambientOcclusion)) {
    const ao = collection.ambientOcclusion;
    const bloom = collection.bloom;
    const tonemapping = collection._tonemapping;
    const fxaa = collection.fxaa;
    let previousName = getCompositeDependencies(
      collection,
      context,
      dependencies,
      ao,
      void 0
    );
    previousName = getCompositeDependencies(
      collection,
      context,
      dependencies,
      bloom,
      previousName
    );
    previousName = getStageDependencies(
      collection,
      context,
      dependencies,
      tonemapping,
      previousName
    );
    previousName = getCompositeDependencies(
      collection,
      context,
      dependencies,
      collection,
      previousName
    );
    getStageDependencies(collection, context, dependencies, fxaa, previousName);
  } else {
    getCompositeDependencies(
      collection,
      context,
      dependencies,
      collection,
      void 0
    );
  }
  return dependencies;
}
function getFramebuffer(cache, stageName, dependencies) {
  const collection = cache._collection;
  const stage = collection.getStageByName(stageName);
  const textureScale = stage._textureScale;
  const forcePowerOfTwo = stage._forcePowerOfTwo;
  const pixelFormat = stage._pixelFormat;
  const pixelDatatype = stage._pixelDatatype;
  const clearColor = stage._clearColor;
  let i2;
  let framebuffer;
  const framebuffers = cache._framebuffers;
  const length3 = framebuffers.length;
  for (i2 = 0; i2 < length3; ++i2) {
    framebuffer = framebuffers[i2];
    if (textureScale !== framebuffer.textureScale || forcePowerOfTwo !== framebuffer.forcePowerOfTwo || pixelFormat !== framebuffer.pixelFormat || pixelDatatype !== framebuffer.pixelDatatype || !Color_default.equals(clearColor, framebuffer.clearColor)) {
      continue;
    }
    const stageNames = framebuffer.stages;
    const stagesLength = stageNames.length;
    let foundConflict = false;
    for (let j = 0; j < stagesLength; ++j) {
      if (dependencies[stageNames[j]]) {
        foundConflict = true;
        break;
      }
    }
    if (!foundConflict) {
      break;
    }
  }
  if (defined_default(framebuffer) && i2 < length3) {
    framebuffer.stages.push(stageName);
    return framebuffer;
  }
  framebuffer = {
    textureScale,
    forcePowerOfTwo,
    pixelFormat,
    pixelDatatype,
    clearColor,
    stages: [stageName],
    buffer: new FramebufferManager_default({
      pixelFormat,
      pixelDatatype
    }),
    clear: void 0
  };
  framebuffers.push(framebuffer);
  return framebuffer;
}
function createFramebuffers2(cache, context) {
  const dependencies = getDependencies(cache._collection, context);
  for (const stageName in dependencies) {
    if (dependencies.hasOwnProperty(stageName)) {
      cache._stageNameToFramebuffer[stageName] = getFramebuffer(
        cache,
        stageName,
        dependencies[stageName]
      );
    }
  }
}
function releaseResources2(cache) {
  const framebuffers = cache._framebuffers;
  const length3 = framebuffers.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const framebuffer = framebuffers[i2];
    framebuffer.buffer.destroy();
  }
}
function updateFramebuffers4(cache, context) {
  const width = cache._width;
  const height = cache._height;
  const framebuffers = cache._framebuffers;
  const length3 = framebuffers.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const framebuffer = framebuffers[i2];
    const scale = framebuffer.textureScale;
    let textureWidth = Math.ceil(width * scale);
    let textureHeight = Math.ceil(height * scale);
    let size = Math.min(textureWidth, textureHeight);
    if (framebuffer.forcePowerOfTwo) {
      if (!Math_default.isPowerOfTwo(size)) {
        size = Math_default.nextPowerOfTwo(size);
      }
      textureWidth = size;
      textureHeight = size;
    }
    framebuffer.buffer.update(context, textureWidth, textureHeight);
    framebuffer.clear = new ClearCommand_default({
      color: framebuffer.clearColor,
      framebuffer: framebuffer.buffer.framebuffer
    });
  }
}
PostProcessStageTextureCache.prototype.updateDependencies = function() {
  this._updateDependencies = true;
};
PostProcessStageTextureCache.prototype.update = function(context) {
  const collection = this._collection;
  const updateDependencies = this._updateDependencies;
  const aoEnabled = defined_default(collection.ambientOcclusion) && collection.ambientOcclusion.enabled && collection.ambientOcclusion._isSupported(context);
  const bloomEnabled = defined_default(collection.bloom) && collection.bloom.enabled && collection.bloom._isSupported(context);
  const tonemappingEnabled = defined_default(collection._tonemapping) && collection._tonemapping.enabled && collection._tonemapping._isSupported(context);
  const fxaaEnabled = defined_default(collection.fxaa) && collection.fxaa.enabled && collection.fxaa._isSupported(context);
  const needsCheckDimensionsUpdate = !defined_default(collection._activeStages) || collection._activeStages.length > 0 || aoEnabled || bloomEnabled || tonemappingEnabled || fxaaEnabled;
  if (updateDependencies || !needsCheckDimensionsUpdate && this._framebuffers.length > 0) {
    releaseResources2(this);
    this._framebuffers.length = 0;
    this._stageNameToFramebuffer = {};
    this._width = void 0;
    this._height = void 0;
  }
  if (!updateDependencies && !needsCheckDimensionsUpdate) {
    return;
  }
  if (this._framebuffers.length === 0) {
    createFramebuffers2(this, context);
  }
  const width = context.drawingBufferWidth;
  const height = context.drawingBufferHeight;
  const dimensionsChanged = this._width !== width || this._height !== height;
  if (!updateDependencies && !dimensionsChanged) {
    return;
  }
  this._width = width;
  this._height = height;
  this._updateDependencies = false;
  releaseResources2(this);
  updateFramebuffers4(this, context);
};
PostProcessStageTextureCache.prototype.clear = function(context) {
  const framebuffers = this._framebuffers;
  for (let i2 = 0; i2 < framebuffers.length; ++i2) {
    framebuffers[i2].clear.execute(context);
  }
};
PostProcessStageTextureCache.prototype.getStageByName = function(name) {
  return this._collection.getStageByName(name);
};
PostProcessStageTextureCache.prototype.getOutputTexture = function(name) {
  return this._collection.getOutputTexture(name);
};
PostProcessStageTextureCache.prototype.getFramebuffer = function(name) {
  const framebuffer = this._stageNameToFramebuffer[name];
  if (!defined_default(framebuffer)) {
    return void 0;
  }
  return framebuffer.buffer.framebuffer;
};
PostProcessStageTextureCache.prototype.isDestroyed = function() {
  return false;
};
PostProcessStageTextureCache.prototype.destroy = function() {
  releaseResources2(this);
  return destroyObject_default(this);
};
var PostProcessStageTextureCache_default = PostProcessStageTextureCache;

// node_modules/cesium/Source/Scene/Tonemapper.js
var Tonemapper = {
  REINHARD: 0,
  MODIFIED_REINHARD: 1,
  FILMIC: 2,
  ACES: 3,
  validate: function(tonemapper) {
    return tonemapper === Tonemapper.REINHARD || tonemapper === Tonemapper.MODIFIED_REINHARD || tonemapper === Tonemapper.FILMIC || tonemapper === Tonemapper.ACES;
  }
};
var Tonemapper_default = Object.freeze(Tonemapper);

// node_modules/cesium/Source/Scene/PostProcessStageCollection.js
var stackScratch = [];
function PostProcessStageCollection() {
  const fxaa = PostProcessStageLibrary_default.createFXAAStage();
  const ao = PostProcessStageLibrary_default.createAmbientOcclusionStage();
  const bloom = PostProcessStageLibrary_default.createBloomStage();
  this._autoExposureEnabled = false;
  this._autoExposure = PostProcessStageLibrary_default.createAutoExposureStage();
  this._tonemapping = void 0;
  this._tonemapper = void 0;
  this.tonemapper = Tonemapper_default.ACES;
  const tonemapping = this._tonemapping;
  fxaa.enabled = false;
  ao.enabled = false;
  bloom.enabled = false;
  tonemapping.enabled = false;
  const textureCache = new PostProcessStageTextureCache_default(this);
  const stageNames = {};
  const stack = stackScratch;
  stack.push(fxaa, ao, bloom, tonemapping);
  while (stack.length > 0) {
    const stage = stack.pop();
    stageNames[stage.name] = stage;
    stage._textureCache = textureCache;
    const length3 = stage.length;
    if (defined_default(length3)) {
      for (let i2 = 0; i2 < length3; ++i2) {
        stack.push(stage.get(i2));
      }
    }
  }
  this._stages = [];
  this._activeStages = [];
  this._previousActiveStages = [];
  this._randomTexture = void 0;
  const that = this;
  ao.uniforms.randomTexture = function() {
    return that._randomTexture;
  };
  this._ao = ao;
  this._bloom = bloom;
  this._fxaa = fxaa;
  this._aoEnabled = void 0;
  this._bloomEnabled = void 0;
  this._tonemappingEnabled = void 0;
  this._fxaaEnabled = void 0;
  this._activeStagesChanged = false;
  this._stagesRemoved = false;
  this._textureCacheDirty = false;
  this._stageNames = stageNames;
  this._textureCache = textureCache;
}
Object.defineProperties(PostProcessStageCollection.prototype, {
  ready: {
    get: function() {
      let readyAndEnabled = false;
      const stages = this._stages;
      const length3 = stages.length;
      for (let i2 = length3 - 1; i2 >= 0; --i2) {
        const stage = stages[i2];
        readyAndEnabled = readyAndEnabled || stage.ready && stage.enabled;
      }
      const fxaa = this._fxaa;
      const ao = this._ao;
      const bloom = this._bloom;
      const tonemapping = this._tonemapping;
      readyAndEnabled = readyAndEnabled || fxaa.ready && fxaa.enabled;
      readyAndEnabled = readyAndEnabled || ao.ready && ao.enabled;
      readyAndEnabled = readyAndEnabled || bloom.ready && bloom.enabled;
      readyAndEnabled = readyAndEnabled || tonemapping.ready && tonemapping.enabled;
      return readyAndEnabled;
    }
  },
  fxaa: {
    get: function() {
      return this._fxaa;
    }
  },
  ambientOcclusion: {
    get: function() {
      return this._ao;
    }
  },
  bloom: {
    get: function() {
      return this._bloom;
    }
  },
  length: {
    get: function() {
      removeStages(this);
      return this._stages.length;
    }
  },
  outputTexture: {
    get: function() {
      const fxaa = this._fxaa;
      if (fxaa.enabled && fxaa.ready) {
        return this.getOutputTexture(fxaa.name);
      }
      const stages = this._stages;
      const length3 = stages.length;
      for (let i2 = length3 - 1; i2 >= 0; --i2) {
        const stage = stages[i2];
        if (defined_default(stage) && stage.ready && stage.enabled) {
          return this.getOutputTexture(stage.name);
        }
      }
      const tonemapping = this._tonemapping;
      if (tonemapping.enabled && tonemapping.ready) {
        return this.getOutputTexture(tonemapping.name);
      }
      const bloom = this._bloom;
      if (bloom.enabled && bloom.ready) {
        return this.getOutputTexture(bloom.name);
      }
      const ao = this._ao;
      if (ao.enabled && ao.ready) {
        return this.getOutputTexture(ao.name);
      }
      return void 0;
    }
  },
  hasSelected: {
    get: function() {
      const stages = arraySlice_default(this._stages);
      while (stages.length > 0) {
        const stage = stages.pop();
        if (!defined_default(stage)) {
          continue;
        }
        if (defined_default(stage.selected)) {
          return true;
        }
        const length3 = stage.length;
        if (defined_default(length3)) {
          for (let i2 = 0; i2 < length3; ++i2) {
            stages.push(stage.get(i2));
          }
        }
      }
      return false;
    }
  },
  tonemapper: {
    get: function() {
      return this._tonemapper;
    },
    set: function(value) {
      if (this._tonemapper === value) {
        return;
      }
      if (!Tonemapper_default.validate(value)) {
        throw new DeveloperError_default("tonemapper was set to an invalid value.");
      }
      if (defined_default(this._tonemapping)) {
        delete this._stageNames[this._tonemapping.name];
        this._tonemapping.destroy();
      }
      const useAutoExposure = this._autoExposureEnabled;
      let tonemapper;
      switch (value) {
        case Tonemapper_default.REINHARD:
          tonemapper = PostProcessStageLibrary_default.createReinhardTonemappingStage(
            useAutoExposure
          );
          break;
        case Tonemapper_default.MODIFIED_REINHARD:
          tonemapper = PostProcessStageLibrary_default.createModifiedReinhardTonemappingStage(
            useAutoExposure
          );
          break;
        case Tonemapper_default.FILMIC:
          tonemapper = PostProcessStageLibrary_default.createFilmicTonemappingStage(
            useAutoExposure
          );
          break;
        default:
          tonemapper = PostProcessStageLibrary_default.createAcesTonemappingStage(
            useAutoExposure
          );
          break;
      }
      if (useAutoExposure) {
        const autoexposure = this._autoExposure;
        tonemapper.uniforms.autoExposure = function() {
          return autoexposure.outputTexture;
        };
      }
      this._tonemapper = value;
      this._tonemapping = tonemapper;
      if (defined_default(this._stageNames)) {
        this._stageNames[tonemapper.name] = tonemapper;
        tonemapper._textureCache = this._textureCache;
      }
      this._textureCacheDirty = true;
    }
  }
});
function removeStages(collection) {
  if (!collection._stagesRemoved) {
    return;
  }
  collection._stagesRemoved = false;
  const newStages = [];
  const stages = collection._stages;
  const length3 = stages.length;
  for (let i2 = 0, j = 0; i2 < length3; ++i2) {
    const stage = stages[i2];
    if (stage) {
      stage._index = j++;
      newStages.push(stage);
    }
  }
  collection._stages = newStages;
}
PostProcessStageCollection.prototype.add = function(stage) {
  Check_default.typeOf.object("stage", stage);
  const stageNames = this._stageNames;
  const stack = stackScratch;
  stack.push(stage);
  while (stack.length > 0) {
    const currentStage = stack.pop();
    if (defined_default(stageNames[currentStage.name])) {
      throw new DeveloperError_default(
        `${currentStage.name} has already been added to the collection or does not have a unique name.`
      );
    }
    stageNames[currentStage.name] = currentStage;
    currentStage._textureCache = this._textureCache;
    const length3 = currentStage.length;
    if (defined_default(length3)) {
      for (let i2 = 0; i2 < length3; ++i2) {
        stack.push(currentStage.get(i2));
      }
    }
  }
  const stages = this._stages;
  stage._index = stages.length;
  stages.push(stage);
  this._textureCacheDirty = true;
  return stage;
};
PostProcessStageCollection.prototype.remove = function(stage) {
  if (!this.contains(stage)) {
    return false;
  }
  const stageNames = this._stageNames;
  const stack = stackScratch;
  stack.push(stage);
  while (stack.length > 0) {
    const currentStage = stack.pop();
    delete stageNames[currentStage.name];
    const length3 = currentStage.length;
    if (defined_default(length3)) {
      for (let i2 = 0; i2 < length3; ++i2) {
        stack.push(currentStage.get(i2));
      }
    }
  }
  this._stages[stage._index] = void 0;
  this._stagesRemoved = true;
  this._textureCacheDirty = true;
  stage._index = void 0;
  stage._textureCache = void 0;
  stage.destroy();
  return true;
};
PostProcessStageCollection.prototype.contains = function(stage) {
  return defined_default(stage) && defined_default(stage._index) && stage._textureCache === this._textureCache;
};
PostProcessStageCollection.prototype.get = function(index2) {
  removeStages(this);
  const stages = this._stages;
  const length3 = stages.length;
  Check_default.typeOf.number.greaterThanOrEquals("stages length", length3, 0);
  Check_default.typeOf.number.greaterThanOrEquals("index", index2, 0);
  Check_default.typeOf.number.lessThan("index", index2, length3);
  return stages[index2];
};
PostProcessStageCollection.prototype.removeAll = function() {
  const stages = this._stages;
  const length3 = stages.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    this.remove(stages[i2]);
  }
  stages.length = 0;
};
PostProcessStageCollection.prototype.getStageByName = function(name) {
  return this._stageNames[name];
};
PostProcessStageCollection.prototype.update = function(context, useLogDepth, useHdr) {
  removeStages(this);
  const previousActiveStages = this._activeStages;
  const activeStages = this._activeStages = this._previousActiveStages;
  this._previousActiveStages = previousActiveStages;
  const stages = this._stages;
  let length3 = activeStages.length = stages.length;
  let i2;
  let stage;
  let count = 0;
  for (i2 = 0; i2 < length3; ++i2) {
    stage = stages[i2];
    if (stage.ready && stage.enabled && stage._isSupported(context)) {
      activeStages[count++] = stage;
    }
  }
  activeStages.length = count;
  let activeStagesChanged = count !== previousActiveStages.length;
  if (!activeStagesChanged) {
    for (i2 = 0; i2 < count; ++i2) {
      if (activeStages[i2] !== previousActiveStages[i2]) {
        activeStagesChanged = true;
        break;
      }
    }
  }
  const ao = this._ao;
  const bloom = this._bloom;
  const autoexposure = this._autoExposure;
  const tonemapping = this._tonemapping;
  const fxaa = this._fxaa;
  tonemapping.enabled = useHdr;
  const aoEnabled = ao.enabled && ao._isSupported(context);
  const bloomEnabled = bloom.enabled && bloom._isSupported(context);
  const tonemappingEnabled = tonemapping.enabled && tonemapping._isSupported(context);
  const fxaaEnabled = fxaa.enabled && fxaa._isSupported(context);
  if (activeStagesChanged || this._textureCacheDirty || aoEnabled !== this._aoEnabled || bloomEnabled !== this._bloomEnabled || tonemappingEnabled !== this._tonemappingEnabled || fxaaEnabled !== this._fxaaEnabled) {
    this._textureCache.updateDependencies();
    this._aoEnabled = aoEnabled;
    this._bloomEnabled = bloomEnabled;
    this._tonemappingEnabled = tonemappingEnabled;
    this._fxaaEnabled = fxaaEnabled;
    this._textureCacheDirty = false;
  }
  if (defined_default(this._randomTexture) && !aoEnabled) {
    this._randomTexture.destroy();
    this._randomTexture = void 0;
  }
  if (!defined_default(this._randomTexture) && aoEnabled) {
    length3 = 256 * 256 * 3;
    const random2 = new Uint8Array(length3);
    for (i2 = 0; i2 < length3; i2 += 3) {
      random2[i2] = Math.floor(Math.random() * 255);
    }
    this._randomTexture = new Texture_default({
      context,
      pixelFormat: PixelFormat_default.RGB,
      pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
      source: {
        arrayBufferView: random2,
        width: 256,
        height: 256
      },
      sampler: new Sampler_default({
        wrapS: TextureWrap_default.REPEAT,
        wrapT: TextureWrap_default.REPEAT,
        minificationFilter: TextureMinificationFilter_default.NEAREST,
        magnificationFilter: TextureMagnificationFilter_default.NEAREST
      })
    });
  }
  this._textureCache.update(context);
  fxaa.update(context, useLogDepth);
  ao.update(context, useLogDepth);
  bloom.update(context, useLogDepth);
  tonemapping.update(context, useLogDepth);
  if (this._autoExposureEnabled) {
    autoexposure.update(context, useLogDepth);
  }
  length3 = stages.length;
  for (i2 = 0; i2 < length3; ++i2) {
    stages[i2].update(context, useLogDepth);
  }
  count = 0;
  for (i2 = 0; i2 < length3; ++i2) {
    stage = stages[i2];
    if (stage.ready && stage.enabled && stage._isSupported(context)) {
      count++;
    }
  }
  activeStagesChanged = count !== activeStages.length;
  if (activeStagesChanged) {
    this.update(context, useLogDepth, useHdr);
  }
};
PostProcessStageCollection.prototype.clear = function(context) {
  this._textureCache.clear(context);
  if (this._autoExposureEnabled) {
    this._autoExposure.clear(context);
  }
};
function getOutputTexture(stage) {
  while (defined_default(stage.length)) {
    stage = stage.get(stage.length - 1);
  }
  return stage.outputTexture;
}
PostProcessStageCollection.prototype.getOutputTexture = function(stageName) {
  const stage = this.getStageByName(stageName);
  if (!defined_default(stage)) {
    return void 0;
  }
  return getOutputTexture(stage);
};
function execute(stage, context, colorTexture, depthTexture, idTexture) {
  if (defined_default(stage.execute)) {
    stage.execute(context, colorTexture, depthTexture, idTexture);
    return;
  }
  const length3 = stage.length;
  let i2;
  if (stage.inputPreviousStageTexture) {
    execute(stage.get(0), context, colorTexture, depthTexture, idTexture);
    for (i2 = 1; i2 < length3; ++i2) {
      execute(
        stage.get(i2),
        context,
        getOutputTexture(stage.get(i2 - 1)),
        depthTexture,
        idTexture
      );
    }
  } else {
    for (i2 = 0; i2 < length3; ++i2) {
      execute(stage.get(i2), context, colorTexture, depthTexture, idTexture);
    }
  }
}
PostProcessStageCollection.prototype.execute = function(context, colorTexture, depthTexture, idTexture) {
  const activeStages = this._activeStages;
  const length3 = activeStages.length;
  const fxaa = this._fxaa;
  const ao = this._ao;
  const bloom = this._bloom;
  const autoexposure = this._autoExposure;
  const tonemapping = this._tonemapping;
  const aoEnabled = ao.enabled && ao._isSupported(context);
  const bloomEnabled = bloom.enabled && bloom._isSupported(context);
  const autoExposureEnabled = this._autoExposureEnabled;
  const tonemappingEnabled = tonemapping.enabled && tonemapping._isSupported(context);
  const fxaaEnabled = fxaa.enabled && fxaa._isSupported(context);
  if (!fxaaEnabled && !aoEnabled && !bloomEnabled && !tonemappingEnabled && length3 === 0) {
    return;
  }
  let initialTexture = colorTexture;
  if (aoEnabled && ao.ready) {
    execute(ao, context, initialTexture, depthTexture, idTexture);
    initialTexture = getOutputTexture(ao);
  }
  if (bloomEnabled && bloom.ready) {
    execute(bloom, context, initialTexture, depthTexture, idTexture);
    initialTexture = getOutputTexture(bloom);
  }
  if (autoExposureEnabled && autoexposure.ready) {
    execute(autoexposure, context, initialTexture, depthTexture, idTexture);
  }
  if (tonemappingEnabled && tonemapping.ready) {
    execute(tonemapping, context, initialTexture, depthTexture, idTexture);
    initialTexture = getOutputTexture(tonemapping);
  }
  let lastTexture = initialTexture;
  if (length3 > 0) {
    execute(activeStages[0], context, initialTexture, depthTexture, idTexture);
    for (let i2 = 1; i2 < length3; ++i2) {
      execute(
        activeStages[i2],
        context,
        getOutputTexture(activeStages[i2 - 1]),
        depthTexture,
        idTexture
      );
    }
    lastTexture = getOutputTexture(activeStages[length3 - 1]);
  }
  if (fxaaEnabled && fxaa.ready) {
    execute(fxaa, context, lastTexture, depthTexture, idTexture);
  }
};
PostProcessStageCollection.prototype.copy = function(context, framebuffer) {
  if (!defined_default(this._copyColorCommand)) {
    const that = this;
    this._copyColorCommand = context.createViewportQuadCommand(PassThrough_default, {
      uniformMap: {
        colorTexture: function() {
          return that.outputTexture;
        }
      },
      owner: this
    });
  }
  this._copyColorCommand.framebuffer = framebuffer;
  this._copyColorCommand.execute(context);
};
PostProcessStageCollection.prototype.isDestroyed = function() {
  return false;
};
PostProcessStageCollection.prototype.destroy = function() {
  this._fxaa.destroy();
  this._ao.destroy();
  this._bloom.destroy();
  this._autoExposure.destroy();
  this._tonemapping.destroy();
  this.removeAll();
  this._textureCache = this._textureCache && this._textureCache.destroy();
  return destroyObject_default(this);
};
var PostProcessStageCollection_default = PostProcessStageCollection;

// node_modules/cesium/Source/Scene/QuadtreeTileProvider.js
function QuadtreeTileProvider() {
  DeveloperError_default.throwInstantiationError();
}
QuadtreeTileProvider.computeDefaultLevelZeroMaximumGeometricError = function(tilingScheme2) {
  return tilingScheme2.ellipsoid.maximumRadius * 2 * Math.PI * 0.25 / (65 * tilingScheme2.getNumberOfXTilesAtLevel(0));
};
Object.defineProperties(QuadtreeTileProvider.prototype, {
  quadtree: {
    get: DeveloperError_default.throwInstantiationError,
    set: DeveloperError_default.throwInstantiationError
  },
  ready: {
    get: DeveloperError_default.throwInstantiationError
  },
  tilingScheme: {
    get: DeveloperError_default.throwInstantiationError
  },
  errorEvent: {
    get: DeveloperError_default.throwInstantiationError
  }
});
QuadtreeTileProvider.prototype.update = DeveloperError_default.throwInstantiationError;
QuadtreeTileProvider.prototype.beginUpdate = DeveloperError_default.throwInstantiationError;
QuadtreeTileProvider.prototype.endUpdate = DeveloperError_default.throwInstantiationError;
QuadtreeTileProvider.prototype.getLevelMaximumGeometricError = DeveloperError_default.throwInstantiationError;
QuadtreeTileProvider.prototype.loadTile = DeveloperError_default.throwInstantiationError;
QuadtreeTileProvider.prototype.computeTileVisibility = DeveloperError_default.throwInstantiationError;
QuadtreeTileProvider.prototype.showTileThisFrame = DeveloperError_default.throwInstantiationError;
QuadtreeTileProvider.prototype.computeDistanceToTile = DeveloperError_default.throwInstantiationError;
QuadtreeTileProvider.prototype.isDestroyed = DeveloperError_default.throwInstantiationError;
QuadtreeTileProvider.prototype.destroy = DeveloperError_default.throwInstantiationError;
var QuadtreeTileProvider_default = QuadtreeTileProvider;

// node_modules/cesium/Source/Scene/SceneTransitioner.js
function SceneTransitioner(scene) {
  Check_default.typeOf.object("scene", scene);
  this._scene = scene;
  this._currentTweens = [];
  this._morphHandler = void 0;
  this._morphCancelled = false;
  this._completeMorph = void 0;
  this._morphToOrthographic = false;
}
SceneTransitioner.prototype.completeMorph = function() {
  if (defined_default(this._completeMorph)) {
    this._completeMorph();
  }
};
SceneTransitioner.prototype.morphTo2D = function(duration, ellipsoid) {
  if (defined_default(this._completeMorph)) {
    this._completeMorph();
  }
  const scene = this._scene;
  this._previousMode = scene.mode;
  this._morphToOrthographic = scene.camera.frustum instanceof OrthographicFrustum_default;
  if (this._previousMode === SceneMode_default.SCENE2D || this._previousMode === SceneMode_default.MORPHING) {
    return;
  }
  this._scene.morphStart.raiseEvent(
    this,
    this._previousMode,
    SceneMode_default.SCENE2D,
    true
  );
  scene._mode = SceneMode_default.MORPHING;
  scene.camera._setTransform(Matrix4_default.IDENTITY);
  if (this._previousMode === SceneMode_default.COLUMBUS_VIEW) {
    morphFromColumbusViewTo2D(this, duration);
  } else {
    morphFrom3DTo2D(this, duration, ellipsoid);
  }
  if (duration === 0 && defined_default(this._completeMorph)) {
    this._completeMorph();
  }
};
var scratchToCVPosition = new Cartesian3_default();
var scratchToCVDirection = new Cartesian3_default();
var scratchToCVUp = new Cartesian3_default();
var scratchToCVPosition2D = new Cartesian3_default();
var scratchToCVDirection2D = new Cartesian3_default();
var scratchToCVUp2D = new Cartesian3_default();
var scratchToCVSurfacePosition = new Cartesian3_default();
var scratchToCVCartographic = new Cartographic_default();
var scratchToCVToENU = new Matrix4_default();
var scratchToCVFrustumPerspective = new PerspectiveFrustum_default();
var scratchToCVFrustumOrthographic = new OrthographicFrustum_default();
var scratchToCVCamera = {
  position: void 0,
  direction: void 0,
  up: void 0,
  position2D: void 0,
  direction2D: void 0,
  up2D: void 0,
  frustum: void 0
};
SceneTransitioner.prototype.morphToColumbusView = function(duration, ellipsoid) {
  if (defined_default(this._completeMorph)) {
    this._completeMorph();
  }
  const scene = this._scene;
  this._previousMode = scene.mode;
  if (this._previousMode === SceneMode_default.COLUMBUS_VIEW || this._previousMode === SceneMode_default.MORPHING) {
    return;
  }
  this._scene.morphStart.raiseEvent(
    this,
    this._previousMode,
    SceneMode_default.COLUMBUS_VIEW,
    true
  );
  scene.camera._setTransform(Matrix4_default.IDENTITY);
  let position = scratchToCVPosition;
  const direction2 = scratchToCVDirection;
  const up = scratchToCVUp;
  if (duration > 0) {
    position.x = 0;
    position.y = -1;
    position.z = 1;
    position = Cartesian3_default.multiplyByScalar(
      Cartesian3_default.normalize(position, position),
      5 * ellipsoid.maximumRadius,
      position
    );
    Cartesian3_default.negate(Cartesian3_default.normalize(position, direction2), direction2);
    Cartesian3_default.cross(Cartesian3_default.UNIT_X, direction2, up);
  } else {
    const camera = scene.camera;
    if (this._previousMode === SceneMode_default.SCENE2D) {
      Cartesian3_default.clone(camera.position, position);
      position.z = camera.frustum.right - camera.frustum.left;
      Cartesian3_default.negate(Cartesian3_default.UNIT_Z, direction2);
      Cartesian3_default.clone(Cartesian3_default.UNIT_Y, up);
    } else {
      Cartesian3_default.clone(camera.positionWC, position);
      Cartesian3_default.clone(camera.directionWC, direction2);
      Cartesian3_default.clone(camera.upWC, up);
      const surfacePoint = ellipsoid.scaleToGeodeticSurface(
        position,
        scratchToCVSurfacePosition
      );
      const toENU = Transforms_default.eastNorthUpToFixedFrame(
        surfacePoint,
        ellipsoid,
        scratchToCVToENU
      );
      Matrix4_default.inverseTransformation(toENU, toENU);
      scene.mapProjection.project(
        ellipsoid.cartesianToCartographic(position, scratchToCVCartographic),
        position
      );
      Matrix4_default.multiplyByPointAsVector(toENU, direction2, direction2);
      Matrix4_default.multiplyByPointAsVector(toENU, up, up);
    }
  }
  let frustum;
  if (this._morphToOrthographic) {
    frustum = scratchToCVFrustumOrthographic;
    frustum.width = scene.camera.frustum.right - scene.camera.frustum.left;
    frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
  } else {
    frustum = scratchToCVFrustumPerspective;
    frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
    frustum.fov = Math_default.toRadians(60);
  }
  const cameraCV = scratchToCVCamera;
  cameraCV.position = position;
  cameraCV.direction = direction2;
  cameraCV.up = up;
  cameraCV.frustum = frustum;
  const complete = completeColumbusViewCallback(cameraCV);
  createMorphHandler(this, complete);
  if (this._previousMode === SceneMode_default.SCENE2D) {
    morphFrom2DToColumbusView(this, duration, cameraCV, complete);
  } else {
    cameraCV.position2D = Matrix4_default.multiplyByPoint(
      Camera_default.TRANSFORM_2D,
      position,
      scratchToCVPosition2D
    );
    cameraCV.direction2D = Matrix4_default.multiplyByPointAsVector(
      Camera_default.TRANSFORM_2D,
      direction2,
      scratchToCVDirection2D
    );
    cameraCV.up2D = Matrix4_default.multiplyByPointAsVector(
      Camera_default.TRANSFORM_2D,
      up,
      scratchToCVUp2D
    );
    scene._mode = SceneMode_default.MORPHING;
    morphFrom3DToColumbusView(this, duration, cameraCV, complete);
  }
  if (duration === 0 && defined_default(this._completeMorph)) {
    this._completeMorph();
  }
};
var scratchCVTo3DCamera = {
  position: new Cartesian3_default(),
  direction: new Cartesian3_default(),
  up: new Cartesian3_default(),
  frustum: void 0
};
var scratch2DTo3DFrustumPersp = new PerspectiveFrustum_default();
SceneTransitioner.prototype.morphTo3D = function(duration, ellipsoid) {
  if (defined_default(this._completeMorph)) {
    this._completeMorph();
  }
  const scene = this._scene;
  this._previousMode = scene.mode;
  if (this._previousMode === SceneMode_default.SCENE3D || this._previousMode === SceneMode_default.MORPHING) {
    return;
  }
  this._scene.morphStart.raiseEvent(
    this,
    this._previousMode,
    SceneMode_default.SCENE3D,
    true
  );
  scene._mode = SceneMode_default.MORPHING;
  scene.camera._setTransform(Matrix4_default.IDENTITY);
  if (this._previousMode === SceneMode_default.SCENE2D) {
    morphFrom2DTo3D(this, duration, ellipsoid);
  } else {
    let camera3D;
    if (duration > 0) {
      camera3D = scratchCVTo3DCamera;
      Cartesian3_default.fromDegrees(
        0,
        0,
        5 * ellipsoid.maximumRadius,
        ellipsoid,
        camera3D.position
      );
      Cartesian3_default.negate(camera3D.position, camera3D.direction);
      Cartesian3_default.normalize(camera3D.direction, camera3D.direction);
      Cartesian3_default.clone(Cartesian3_default.UNIT_Z, camera3D.up);
    } else {
      camera3D = getColumbusViewTo3DCamera(this, ellipsoid);
    }
    let frustum;
    const camera = scene.camera;
    if (camera.frustum instanceof OrthographicFrustum_default) {
      frustum = camera.frustum.clone();
    } else {
      frustum = scratch2DTo3DFrustumPersp;
      frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
      frustum.fov = Math_default.toRadians(60);
    }
    camera3D.frustum = frustum;
    const complete = complete3DCallback(camera3D);
    createMorphHandler(this, complete);
    morphFromColumbusViewTo3D(this, duration, camera3D, complete);
  }
  if (duration === 0 && defined_default(this._completeMorph)) {
    this._completeMorph();
  }
};
SceneTransitioner.prototype.isDestroyed = function() {
  return false;
};
SceneTransitioner.prototype.destroy = function() {
  destroyMorphHandler(this);
  return destroyObject_default(this);
};
function createMorphHandler(transitioner, completeMorphFunction) {
  if (transitioner._scene.completeMorphOnUserInput) {
    transitioner._morphHandler = new ScreenSpaceEventHandler_default(
      transitioner._scene.canvas
    );
    const completeMorph = function() {
      transitioner._morphCancelled = true;
      transitioner._scene.camera.cancelFlight();
      completeMorphFunction(transitioner);
    };
    transitioner._completeMorph = completeMorph;
    transitioner._morphHandler.setInputAction(
      completeMorph,
      ScreenSpaceEventType_default.LEFT_DOWN
    );
    transitioner._morphHandler.setInputAction(
      completeMorph,
      ScreenSpaceEventType_default.MIDDLE_DOWN
    );
    transitioner._morphHandler.setInputAction(
      completeMorph,
      ScreenSpaceEventType_default.RIGHT_DOWN
    );
    transitioner._morphHandler.setInputAction(
      completeMorph,
      ScreenSpaceEventType_default.WHEEL
    );
  }
}
function destroyMorphHandler(transitioner) {
  const tweens = transitioner._currentTweens;
  for (let i2 = 0; i2 < tweens.length; ++i2) {
    tweens[i2].cancelTween();
  }
  transitioner._currentTweens.length = 0;
  transitioner._morphHandler = transitioner._morphHandler && transitioner._morphHandler.destroy();
}
var scratchCVTo3DCartographic = new Cartographic_default();
var scratchCVTo3DSurfacePoint = new Cartesian3_default();
var scratchCVTo3DFromENU = new Matrix4_default();
function getColumbusViewTo3DCamera(transitioner, ellipsoid) {
  const scene = transitioner._scene;
  const camera = scene.camera;
  const camera3D = scratchCVTo3DCamera;
  const position = camera3D.position;
  const direction2 = camera3D.direction;
  const up = camera3D.up;
  const positionCarto = scene.mapProjection.unproject(
    camera.position,
    scratchCVTo3DCartographic
  );
  ellipsoid.cartographicToCartesian(positionCarto, position);
  const surfacePoint = ellipsoid.scaleToGeodeticSurface(
    position,
    scratchCVTo3DSurfacePoint
  );
  const fromENU = Transforms_default.eastNorthUpToFixedFrame(
    surfacePoint,
    ellipsoid,
    scratchCVTo3DFromENU
  );
  Matrix4_default.multiplyByPointAsVector(fromENU, camera.direction, direction2);
  Matrix4_default.multiplyByPointAsVector(fromENU, camera.up, up);
  return camera3D;
}
var scratchCVTo3DStartPos = new Cartesian3_default();
var scratchCVTo3DStartDir = new Cartesian3_default();
var scratchCVTo3DStartUp = new Cartesian3_default();
var scratchCVTo3DEndPos = new Cartesian3_default();
var scratchCVTo3DEndDir = new Cartesian3_default();
var scratchCVTo3DEndUp = new Cartesian3_default();
function morphFromColumbusViewTo3D(transitioner, duration, endCamera, complete) {
  duration *= 0.5;
  const scene = transitioner._scene;
  const camera = scene.camera;
  const startPos = Cartesian3_default.clone(camera.position, scratchCVTo3DStartPos);
  const startDir = Cartesian3_default.clone(camera.direction, scratchCVTo3DStartDir);
  const startUp = Cartesian3_default.clone(camera.up, scratchCVTo3DStartUp);
  const endPos = Matrix4_default.multiplyByPoint(
    Camera_default.TRANSFORM_2D_INVERSE,
    endCamera.position,
    scratchCVTo3DEndPos
  );
  const endDir = Matrix4_default.multiplyByPointAsVector(
    Camera_default.TRANSFORM_2D_INVERSE,
    endCamera.direction,
    scratchCVTo3DEndDir
  );
  const endUp = Matrix4_default.multiplyByPointAsVector(
    Camera_default.TRANSFORM_2D_INVERSE,
    endCamera.up,
    scratchCVTo3DEndUp
  );
  function update7(value) {
    columbusViewMorph(startPos, endPos, value.time, camera.position);
    columbusViewMorph(startDir, endDir, value.time, camera.direction);
    columbusViewMorph(startUp, endUp, value.time, camera.up);
    Cartesian3_default.cross(camera.direction, camera.up, camera.right);
    Cartesian3_default.normalize(camera.right, camera.right);
  }
  const tween = scene.tweens.add({
    duration,
    easingFunction: EasingFunction_default.QUARTIC_OUT,
    startObject: {
      time: 0
    },
    stopObject: {
      time: 1
    },
    update: update7,
    complete: function() {
      addMorphTimeAnimations(transitioner, scene, 0, 1, duration, complete);
    }
  });
  transitioner._currentTweens.push(tween);
}
var scratch2DTo3DFrustumOrtho = new OrthographicFrustum_default();
var scratch3DToCVStartPos = new Cartesian3_default();
var scratch3DToCVStartDir = new Cartesian3_default();
var scratch3DToCVStartUp = new Cartesian3_default();
var scratch3DToCVEndPos = new Cartesian3_default();
var scratch3DToCVEndDir = new Cartesian3_default();
var scratch3DToCVEndUp = new Cartesian3_default();
function morphFrom2DTo3D(transitioner, duration, ellipsoid) {
  duration /= 3;
  const scene = transitioner._scene;
  const camera = scene.camera;
  let camera3D;
  if (duration > 0) {
    camera3D = scratchCVTo3DCamera;
    Cartesian3_default.fromDegrees(
      0,
      0,
      5 * ellipsoid.maximumRadius,
      ellipsoid,
      camera3D.position
    );
    Cartesian3_default.negate(camera3D.position, camera3D.direction);
    Cartesian3_default.normalize(camera3D.direction, camera3D.direction);
    Cartesian3_default.clone(Cartesian3_default.UNIT_Z, camera3D.up);
  } else {
    camera.position.z = camera.frustum.right - camera.frustum.left;
    camera3D = getColumbusViewTo3DCamera(transitioner, ellipsoid);
  }
  let frustum;
  if (transitioner._morphToOrthographic) {
    frustum = scratch2DTo3DFrustumOrtho;
    frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
    frustum.width = camera.frustum.right - camera.frustum.left;
  } else {
    frustum = scratch2DTo3DFrustumPersp;
    frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
    frustum.fov = Math_default.toRadians(60);
  }
  camera3D.frustum = frustum;
  const complete = complete3DCallback(camera3D);
  createMorphHandler(transitioner, complete);
  let morph;
  if (transitioner._morphToOrthographic) {
    morph = function() {
      morphFromColumbusViewTo3D(transitioner, duration, camera3D, complete);
    };
  } else {
    morph = function() {
      morphOrthographicToPerspective(
        transitioner,
        duration,
        camera3D,
        function() {
          morphFromColumbusViewTo3D(transitioner, duration, camera3D, complete);
        }
      );
    };
  }
  if (duration > 0) {
    scene._mode = SceneMode_default.SCENE2D;
    camera.flyTo({
      duration,
      destination: Cartesian3_default.fromDegrees(
        0,
        0,
        5 * ellipsoid.maximumRadius,
        ellipsoid,
        scratch3DToCVEndPos
      ),
      complete: function() {
        scene._mode = SceneMode_default.MORPHING;
        morph();
      }
    });
  } else {
    morph();
  }
}
function columbusViewMorph(startPosition, endPosition, time, result) {
  return Cartesian3_default.lerp(startPosition, endPosition, time, result);
}
function morphPerspectiveToOrthographic(transitioner, duration, endCamera, updateHeight, complete) {
  const scene = transitioner._scene;
  const camera = scene.camera;
  if (camera.frustum instanceof OrthographicFrustum_default) {
    return;
  }
  const startFOV = camera.frustum.fov;
  const endFOV = Math_default.RADIANS_PER_DEGREE * 0.5;
  const d = endCamera.position.z * Math.tan(startFOV * 0.5);
  camera.frustum.far = d / Math.tan(endFOV * 0.5) + 1e7;
  function update7(value) {
    camera.frustum.fov = Math_default.lerp(startFOV, endFOV, value.time);
    const height = d / Math.tan(camera.frustum.fov * 0.5);
    updateHeight(camera, height);
  }
  const tween = scene.tweens.add({
    duration,
    easingFunction: EasingFunction_default.QUARTIC_OUT,
    startObject: {
      time: 0
    },
    stopObject: {
      time: 1
    },
    update: update7,
    complete: function() {
      camera.frustum = endCamera.frustum.clone();
      complete(transitioner);
    }
  });
  transitioner._currentTweens.push(tween);
}
var scratchCVTo2DStartPos = new Cartesian3_default();
var scratchCVTo2DStartDir = new Cartesian3_default();
var scratchCVTo2DStartUp = new Cartesian3_default();
var scratchCVTo2DEndPos = new Cartesian3_default();
var scratchCVTo2DEndDir = new Cartesian3_default();
var scratchCVTo2DEndUp = new Cartesian3_default();
var scratchCVTo2DFrustum = new OrthographicOffCenterFrustum_default();
var scratchCVTo2DRay = new Ray_default();
var scratchCVTo2DPickPos = new Cartesian3_default();
var scratchCVTo2DCamera = {
  position: void 0,
  direction: void 0,
  up: void 0,
  frustum: void 0
};
function morphFromColumbusViewTo2D(transitioner, duration) {
  duration *= 0.5;
  const scene = transitioner._scene;
  const camera = scene.camera;
  const startPos = Cartesian3_default.clone(camera.position, scratchCVTo2DStartPos);
  const startDir = Cartesian3_default.clone(camera.direction, scratchCVTo2DStartDir);
  const startUp = Cartesian3_default.clone(camera.up, scratchCVTo2DStartUp);
  const endDir = Cartesian3_default.negate(Cartesian3_default.UNIT_Z, scratchCVTo2DEndDir);
  const endUp = Cartesian3_default.clone(Cartesian3_default.UNIT_Y, scratchCVTo2DEndUp);
  const endPos = scratchCVTo2DEndPos;
  if (duration > 0) {
    Cartesian3_default.clone(Cartesian3_default.ZERO, scratchCVTo2DEndPos);
    endPos.z = 5 * scene.mapProjection.ellipsoid.maximumRadius;
  } else {
    Cartesian3_default.clone(startPos, scratchCVTo2DEndPos);
    const ray = scratchCVTo2DRay;
    Matrix4_default.multiplyByPoint(Camera_default.TRANSFORM_2D, startPos, ray.origin);
    Matrix4_default.multiplyByPointAsVector(
      Camera_default.TRANSFORM_2D,
      startDir,
      ray.direction
    );
    const globe = scene.globe;
    if (defined_default(globe)) {
      const pickPos = globe.pickWorldCoordinates(
        ray,
        scene,
        true,
        scratchCVTo2DPickPos
      );
      if (defined_default(pickPos)) {
        Matrix4_default.multiplyByPoint(Camera_default.TRANSFORM_2D_INVERSE, pickPos, endPos);
        endPos.z += Cartesian3_default.distance(startPos, endPos);
      }
    }
  }
  const frustum = scratchCVTo2DFrustum;
  frustum.right = endPos.z * 0.5;
  frustum.left = -frustum.right;
  frustum.top = frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
  frustum.bottom = -frustum.top;
  const camera2D = scratchCVTo2DCamera;
  camera2D.position = endPos;
  camera2D.direction = endDir;
  camera2D.up = endUp;
  camera2D.frustum = frustum;
  const complete = complete2DCallback(camera2D);
  createMorphHandler(transitioner, complete);
  function updateCV2(value) {
    columbusViewMorph(startPos, endPos, value.time, camera.position);
    columbusViewMorph(startDir, endDir, value.time, camera.direction);
    columbusViewMorph(startUp, endUp, value.time, camera.up);
    Cartesian3_default.cross(camera.direction, camera.up, camera.right);
    Cartesian3_default.normalize(camera.right, camera.right);
    camera._adjustOrthographicFrustum(true);
  }
  function updateHeight(camera2, height) {
    camera2.position.z = height;
  }
  const tween = scene.tweens.add({
    duration,
    easingFunction: EasingFunction_default.QUARTIC_OUT,
    startObject: {
      time: 0
    },
    stopObject: {
      time: 1
    },
    update: updateCV2,
    complete: function() {
      morphPerspectiveToOrthographic(
        transitioner,
        duration,
        camera2D,
        updateHeight,
        complete
      );
    }
  });
  transitioner._currentTweens.push(tween);
}
var scratch3DTo2DCartographic = new Cartographic_default();
var scratch3DTo2DCamera = {
  position: new Cartesian3_default(),
  direction: new Cartesian3_default(),
  up: new Cartesian3_default(),
  position2D: new Cartesian3_default(),
  direction2D: new Cartesian3_default(),
  up2D: new Cartesian3_default(),
  frustum: new OrthographicOffCenterFrustum_default()
};
var scratch3DTo2DEndCamera = {
  position: new Cartesian3_default(),
  direction: new Cartesian3_default(),
  up: new Cartesian3_default(),
  frustum: void 0
};
var scratch3DTo2DPickPosition = new Cartesian3_default();
var scratch3DTo2DRay = new Ray_default();
var scratch3DTo2DToENU = new Matrix4_default();
var scratch3DTo2DSurfacePoint = new Cartesian3_default();
function morphFrom3DTo2D(transitioner, duration, ellipsoid) {
  duration *= 0.5;
  const scene = transitioner._scene;
  const camera = scene.camera;
  const camera2D = scratch3DTo2DCamera;
  if (duration > 0) {
    Cartesian3_default.clone(Cartesian3_default.ZERO, camera2D.position);
    camera2D.position.z = 5 * ellipsoid.maximumRadius;
    Cartesian3_default.negate(Cartesian3_default.UNIT_Z, camera2D.direction);
    Cartesian3_default.clone(Cartesian3_default.UNIT_Y, camera2D.up);
  } else {
    ellipsoid.cartesianToCartographic(
      camera.positionWC,
      scratch3DTo2DCartographic
    );
    scene.mapProjection.project(scratch3DTo2DCartographic, camera2D.position);
    Cartesian3_default.negate(Cartesian3_default.UNIT_Z, camera2D.direction);
    Cartesian3_default.clone(Cartesian3_default.UNIT_Y, camera2D.up);
    const ray = scratch3DTo2DRay;
    Cartesian3_default.clone(camera2D.position2D, ray.origin);
    const rayDirection = Cartesian3_default.clone(camera.directionWC, ray.direction);
    const surfacePoint = ellipsoid.scaleToGeodeticSurface(
      camera.positionWC,
      scratch3DTo2DSurfacePoint
    );
    const toENU = Transforms_default.eastNorthUpToFixedFrame(
      surfacePoint,
      ellipsoid,
      scratch3DTo2DToENU
    );
    Matrix4_default.inverseTransformation(toENU, toENU);
    Matrix4_default.multiplyByPointAsVector(toENU, rayDirection, rayDirection);
    Matrix4_default.multiplyByPointAsVector(
      Camera_default.TRANSFORM_2D,
      rayDirection,
      rayDirection
    );
    const globe = scene.globe;
    if (defined_default(globe)) {
      const pickedPos = globe.pickWorldCoordinates(
        ray,
        scene,
        true,
        scratch3DTo2DPickPosition
      );
      if (defined_default(pickedPos)) {
        const height = Cartesian3_default.distance(camera2D.position2D, pickedPos);
        pickedPos.x += height;
        Cartesian3_default.clone(pickedPos, camera2D.position2D);
      }
    }
  }
  function updateHeight(camera2, height) {
    camera2.position.x = height;
  }
  Matrix4_default.multiplyByPoint(
    Camera_default.TRANSFORM_2D,
    camera2D.position,
    camera2D.position2D
  );
  Matrix4_default.multiplyByPointAsVector(
    Camera_default.TRANSFORM_2D,
    camera2D.direction,
    camera2D.direction2D
  );
  Matrix4_default.multiplyByPointAsVector(
    Camera_default.TRANSFORM_2D,
    camera2D.up,
    camera2D.up2D
  );
  const frustum = camera2D.frustum;
  frustum.right = camera2D.position.z * 0.5;
  frustum.left = -frustum.right;
  frustum.top = frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
  frustum.bottom = -frustum.top;
  const endCamera = scratch3DTo2DEndCamera;
  Matrix4_default.multiplyByPoint(
    Camera_default.TRANSFORM_2D_INVERSE,
    camera2D.position2D,
    endCamera.position
  );
  Cartesian3_default.clone(camera2D.direction, endCamera.direction);
  Cartesian3_default.clone(camera2D.up, endCamera.up);
  endCamera.frustum = frustum;
  const complete = complete2DCallback(endCamera);
  createMorphHandler(transitioner, complete);
  function completeCallback() {
    morphPerspectiveToOrthographic(
      transitioner,
      duration,
      camera2D,
      updateHeight,
      complete
    );
  }
  morphFrom3DToColumbusView(transitioner, duration, camera2D, completeCallback);
}
function morphOrthographicToPerspective(transitioner, duration, cameraCV, complete) {
  const scene = transitioner._scene;
  const camera = scene.camera;
  const height = camera.frustum.right - camera.frustum.left;
  camera.frustum = cameraCV.frustum.clone();
  const endFOV = camera.frustum.fov;
  const startFOV = Math_default.RADIANS_PER_DEGREE * 0.5;
  const d = height * Math.tan(endFOV * 0.5);
  camera.frustum.far = d / Math.tan(startFOV * 0.5) + 1e7;
  camera.frustum.fov = startFOV;
  function update7(value) {
    camera.frustum.fov = Math_default.lerp(startFOV, endFOV, value.time);
    camera.position.z = d / Math.tan(camera.frustum.fov * 0.5);
  }
  const tween = scene.tweens.add({
    duration,
    easingFunction: EasingFunction_default.QUARTIC_OUT,
    startObject: {
      time: 0
    },
    stopObject: {
      time: 1
    },
    update: update7,
    complete: function() {
      complete(transitioner);
    }
  });
  transitioner._currentTweens.push(tween);
}
function morphFrom2DToColumbusView(transitioner, duration, cameraCV, complete) {
  duration *= 0.5;
  const scene = transitioner._scene;
  const camera = scene.camera;
  const endPos = Cartesian3_default.clone(cameraCV.position, scratch3DToCVEndPos);
  const endDir = Cartesian3_default.clone(cameraCV.direction, scratch3DToCVEndDir);
  const endUp = Cartesian3_default.clone(cameraCV.up, scratch3DToCVEndUp);
  scene._mode = SceneMode_default.MORPHING;
  function morph() {
    camera.frustum = cameraCV.frustum.clone();
    const startPos = Cartesian3_default.clone(camera.position, scratch3DToCVStartPos);
    const startDir = Cartesian3_default.clone(camera.direction, scratch3DToCVStartDir);
    const startUp = Cartesian3_default.clone(camera.up, scratch3DToCVStartUp);
    startPos.z = endPos.z;
    function update7(value) {
      columbusViewMorph(startPos, endPos, value.time, camera.position);
      columbusViewMorph(startDir, endDir, value.time, camera.direction);
      columbusViewMorph(startUp, endUp, value.time, camera.up);
      Cartesian3_default.cross(camera.direction, camera.up, camera.right);
      Cartesian3_default.normalize(camera.right, camera.right);
    }
    const tween = scene.tweens.add({
      duration,
      easingFunction: EasingFunction_default.QUARTIC_OUT,
      startObject: {
        time: 0
      },
      stopObject: {
        time: 1
      },
      update: update7,
      complete: function() {
        complete(transitioner);
      }
    });
    transitioner._currentTweens.push(tween);
  }
  if (transitioner._morphToOrthographic) {
    morph();
  } else {
    morphOrthographicToPerspective(transitioner, 0, cameraCV, morph);
  }
}
function morphFrom3DToColumbusView(transitioner, duration, endCamera, complete) {
  const scene = transitioner._scene;
  const camera = scene.camera;
  const startPos = Cartesian3_default.clone(camera.position, scratch3DToCVStartPos);
  const startDir = Cartesian3_default.clone(camera.direction, scratch3DToCVStartDir);
  const startUp = Cartesian3_default.clone(camera.up, scratch3DToCVStartUp);
  const endPos = Cartesian3_default.clone(endCamera.position2D, scratch3DToCVEndPos);
  const endDir = Cartesian3_default.clone(endCamera.direction2D, scratch3DToCVEndDir);
  const endUp = Cartesian3_default.clone(endCamera.up2D, scratch3DToCVEndUp);
  function update7(value) {
    columbusViewMorph(startPos, endPos, value.time, camera.position);
    columbusViewMorph(startDir, endDir, value.time, camera.direction);
    columbusViewMorph(startUp, endUp, value.time, camera.up);
    Cartesian3_default.cross(camera.direction, camera.up, camera.right);
    Cartesian3_default.normalize(camera.right, camera.right);
    camera._adjustOrthographicFrustum(true);
  }
  const tween = scene.tweens.add({
    duration,
    easingFunction: EasingFunction_default.QUARTIC_OUT,
    startObject: {
      time: 0
    },
    stopObject: {
      time: 1
    },
    update: update7,
    complete: function() {
      addMorphTimeAnimations(transitioner, scene, 1, 0, duration, complete);
    }
  });
  transitioner._currentTweens.push(tween);
}
function addMorphTimeAnimations(transitioner, scene, start, stop2, duration, complete) {
  const options = {
    object: scene,
    property: "morphTime",
    startValue: start,
    stopValue: stop2,
    duration,
    easingFunction: EasingFunction_default.QUARTIC_OUT
  };
  if (defined_default(complete)) {
    options.complete = function() {
      complete(transitioner);
    };
  }
  const tween = scene.tweens.addProperty(options);
  transitioner._currentTweens.push(tween);
}
function complete3DCallback(camera3D) {
  return function(transitioner) {
    const scene = transitioner._scene;
    scene._mode = SceneMode_default.SCENE3D;
    scene.morphTime = SceneMode_default.getMorphTime(SceneMode_default.SCENE3D);
    destroyMorphHandler(transitioner);
    const camera = scene.camera;
    if (transitioner._previousMode !== SceneMode_default.MORPHING || transitioner._morphCancelled) {
      transitioner._morphCancelled = false;
      Cartesian3_default.clone(camera3D.position, camera.position);
      Cartesian3_default.clone(camera3D.direction, camera.direction);
      Cartesian3_default.clone(camera3D.up, camera.up);
      Cartesian3_default.cross(camera.direction, camera.up, camera.right);
      Cartesian3_default.normalize(camera.right, camera.right);
      camera.frustum = camera3D.frustum.clone();
    }
    const frustum = camera.frustum;
    if (scene.frameState.useLogDepth) {
      frustum.near = 0.1;
      frustum.far = 1e10;
    }
    const wasMorphing = defined_default(transitioner._completeMorph);
    transitioner._completeMorph = void 0;
    scene.camera.update(scene.mode);
    transitioner._scene.morphComplete.raiseEvent(
      transitioner,
      transitioner._previousMode,
      SceneMode_default.SCENE3D,
      wasMorphing
    );
  };
}
function complete2DCallback(camera2D) {
  return function(transitioner) {
    const scene = transitioner._scene;
    scene._mode = SceneMode_default.SCENE2D;
    scene.morphTime = SceneMode_default.getMorphTime(SceneMode_default.SCENE2D);
    destroyMorphHandler(transitioner);
    const camera = scene.camera;
    Cartesian3_default.clone(camera2D.position, camera.position);
    camera.position.z = scene.mapProjection.ellipsoid.maximumRadius * 2;
    Cartesian3_default.clone(camera2D.direction, camera.direction);
    Cartesian3_default.clone(camera2D.up, camera.up);
    Cartesian3_default.cross(camera.direction, camera.up, camera.right);
    Cartesian3_default.normalize(camera.right, camera.right);
    camera.frustum = camera2D.frustum.clone();
    const wasMorphing = defined_default(transitioner._completeMorph);
    transitioner._completeMorph = void 0;
    scene.camera.update(scene.mode);
    transitioner._scene.morphComplete.raiseEvent(
      transitioner,
      transitioner._previousMode,
      SceneMode_default.SCENE2D,
      wasMorphing
    );
  };
}
function completeColumbusViewCallback(cameraCV) {
  return function(transitioner) {
    const scene = transitioner._scene;
    scene._mode = SceneMode_default.COLUMBUS_VIEW;
    scene.morphTime = SceneMode_default.getMorphTime(SceneMode_default.COLUMBUS_VIEW);
    destroyMorphHandler(transitioner);
    const camera = scene.camera;
    if (transitioner._previousModeMode !== SceneMode_default.MORPHING || transitioner._morphCancelled) {
      transitioner._morphCancelled = false;
      Cartesian3_default.clone(cameraCV.position, camera.position);
      Cartesian3_default.clone(cameraCV.direction, camera.direction);
      Cartesian3_default.clone(cameraCV.up, camera.up);
      Cartesian3_default.cross(camera.direction, camera.up, camera.right);
      Cartesian3_default.normalize(camera.right, camera.right);
    }
    const frustum = camera.frustum;
    if (scene.frameState.useLogDepth) {
      frustum.near = 0.1;
      frustum.far = 1e10;
    }
    const wasMorphing = defined_default(transitioner._completeMorph);
    transitioner._completeMorph = void 0;
    scene.camera.update(scene.mode);
    transitioner._scene.morphComplete.raiseEvent(
      transitioner,
      transitioner._previousMode,
      SceneMode_default.COLUMBUS_VIEW,
      wasMorphing
    );
  };
}
var SceneTransitioner_default = SceneTransitioner;

// node_modules/cesium/Source/Scene/TweenCollection.js
function Tween2(tweens, tweenjs, startObject, stopObject, duration, delay, easingFunction, update7, complete, cancel) {
  this._tweens = tweens;
  this._tweenjs = tweenjs;
  this._startObject = clone_default(startObject);
  this._stopObject = clone_default(stopObject);
  this._duration = duration;
  this._delay = delay;
  this._easingFunction = easingFunction;
  this._update = update7;
  this._complete = complete;
  this.cancel = cancel;
  this.needsStart = true;
}
Object.defineProperties(Tween2.prototype, {
  startObject: {
    get: function() {
      return this._startObject;
    }
  },
  stopObject: {
    get: function() {
      return this._stopObject;
    }
  },
  duration: {
    get: function() {
      return this._duration;
    }
  },
  delay: {
    get: function() {
      return this._delay;
    }
  },
  easingFunction: {
    get: function() {
      return this._easingFunction;
    }
  },
  update: {
    get: function() {
      return this._update;
    }
  },
  complete: {
    get: function() {
      return this._complete;
    }
  },
  tweenjs: {
    get: function() {
      return this._tweenjs;
    }
  }
});
Tween2.prototype.cancelTween = function() {
  this._tweens.remove(this);
};
function TweenCollection() {
  this._tweens = [];
}
Object.defineProperties(TweenCollection.prototype, {
  length: {
    get: function() {
      return this._tweens.length;
    }
  }
});
TweenCollection.prototype.add = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  if (!defined_default(options.startObject) || !defined_default(options.stopObject)) {
    throw new DeveloperError_default(
      "options.startObject and options.stopObject are required."
    );
  }
  if (!defined_default(options.duration) || options.duration < 0) {
    throw new DeveloperError_default(
      "options.duration is required and must be positive."
    );
  }
  if (options.duration === 0) {
    if (defined_default(options.complete)) {
      options.complete();
    }
    return new Tween2(this);
  }
  const duration = options.duration / TimeConstants_default.SECONDS_PER_MILLISECOND;
  const delayInSeconds = defaultValue_default(options.delay, 0);
  const delay = delayInSeconds / TimeConstants_default.SECONDS_PER_MILLISECOND;
  const easingFunction = defaultValue_default(
    options.easingFunction,
    EasingFunction_default.LINEAR_NONE
  );
  const value = options.startObject;
  const tweenjs = new Tween.Tween(value);
  tweenjs.to(clone_default(options.stopObject), duration);
  tweenjs.delay(delay);
  tweenjs.easing(easingFunction);
  if (defined_default(options.update)) {
    tweenjs.onUpdate(function() {
      options.update(value);
    });
  }
  tweenjs.onComplete(defaultValue_default(options.complete, null));
  tweenjs.repeat(defaultValue_default(options._repeat, 0));
  const tween = new Tween2(
    this,
    tweenjs,
    options.startObject,
    options.stopObject,
    options.duration,
    delayInSeconds,
    easingFunction,
    options.update,
    options.complete,
    options.cancel
  );
  this._tweens.push(tween);
  return tween;
};
TweenCollection.prototype.addProperty = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const object2 = options.object;
  const property = options.property;
  const startValue = options.startValue;
  const stopValue = options.stopValue;
  if (!defined_default(object2) || !defined_default(options.property)) {
    throw new DeveloperError_default(
      "options.object and options.property are required."
    );
  }
  if (!defined_default(object2[property])) {
    throw new DeveloperError_default(
      "options.object must have the specified property."
    );
  }
  if (!defined_default(startValue) || !defined_default(stopValue)) {
    throw new DeveloperError_default(
      "options.startValue and options.stopValue are required."
    );
  }
  function update7(value) {
    object2[property] = value.value;
  }
  return this.add({
    startObject: {
      value: startValue
    },
    stopObject: {
      value: stopValue
    },
    duration: defaultValue_default(options.duration, 3),
    delay: options.delay,
    easingFunction: options.easingFunction,
    update: update7,
    complete: options.complete,
    cancel: options.cancel,
    _repeat: options._repeat
  });
};
TweenCollection.prototype.addAlpha = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const material = options.material;
  if (!defined_default(material)) {
    throw new DeveloperError_default("options.material is required.");
  }
  const properties = [];
  for (const property in material.uniforms) {
    if (material.uniforms.hasOwnProperty(property) && defined_default(material.uniforms[property]) && defined_default(material.uniforms[property].alpha)) {
      properties.push(property);
    }
  }
  if (properties.length === 0) {
    throw new DeveloperError_default(
      "material has no properties with alpha components."
    );
  }
  function update7(value) {
    const length3 = properties.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      material.uniforms[properties[i2]].alpha = value.alpha;
    }
  }
  return this.add({
    startObject: {
      alpha: defaultValue_default(options.startValue, 0)
    },
    stopObject: {
      alpha: defaultValue_default(options.stopValue, 1)
    },
    duration: defaultValue_default(options.duration, 3),
    delay: options.delay,
    easingFunction: options.easingFunction,
    update: update7,
    complete: options.complete,
    cancel: options.cancel
  });
};
TweenCollection.prototype.addOffsetIncrement = function(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const material = options.material;
  if (!defined_default(material)) {
    throw new DeveloperError_default("material is required.");
  }
  if (!defined_default(material.uniforms.offset)) {
    throw new DeveloperError_default("material.uniforms must have an offset property.");
  }
  const uniforms = material.uniforms;
  return this.addProperty({
    object: uniforms,
    property: "offset",
    startValue: uniforms.offset,
    stopValue: uniforms.offset + 1,
    duration: options.duration,
    delay: options.delay,
    easingFunction: options.easingFunction,
    update: options.update,
    cancel: options.cancel,
    _repeat: Infinity
  });
};
TweenCollection.prototype.remove = function(tween) {
  if (!defined_default(tween)) {
    return false;
  }
  const index2 = this._tweens.indexOf(tween);
  if (index2 !== -1) {
    tween.tweenjs.stop();
    if (defined_default(tween.cancel)) {
      tween.cancel();
    }
    this._tweens.splice(index2, 1);
    return true;
  }
  return false;
};
TweenCollection.prototype.removeAll = function() {
  const tweens = this._tweens;
  for (let i2 = 0; i2 < tweens.length; ++i2) {
    const tween = tweens[i2];
    tween.tweenjs.stop();
    if (defined_default(tween.cancel)) {
      tween.cancel();
    }
  }
  tweens.length = 0;
};
TweenCollection.prototype.contains = function(tween) {
  return defined_default(tween) && this._tweens.indexOf(tween) !== -1;
};
TweenCollection.prototype.get = function(index2) {
  if (!defined_default(index2)) {
    throw new DeveloperError_default("index is required.");
  }
  return this._tweens[index2];
};
TweenCollection.prototype.update = function(time) {
  const tweens = this._tweens;
  let i2 = 0;
  time = defined_default(time) ? time / TimeConstants_default.SECONDS_PER_MILLISECOND : getTimestamp_default();
  while (i2 < tweens.length) {
    const tween = tweens[i2];
    const tweenjs = tween.tweenjs;
    if (tween.needsStart) {
      tween.needsStart = false;
      tweenjs.start(time);
    } else if (tweenjs.update(time)) {
      i2++;
    } else {
      tweenjs.stop();
      tweens.splice(i2, 1);
    }
  }
};
var TweenCollection_default = TweenCollection;

// node_modules/cesium/Source/Scene/ScreenSpaceCameraController.js
function ScreenSpaceCameraController(scene) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  this.enableInputs = true;
  this.enableTranslate = true;
  this.enableZoom = true;
  this.enableRotate = true;
  this.enableTilt = true;
  this.enableLook = true;
  this.inertiaSpin = 0.9;
  this.inertiaTranslate = 0.9;
  this.inertiaZoom = 0.8;
  this.maximumMovementRatio = 0.1;
  this.bounceAnimationTime = 3;
  this.minimumZoomDistance = 1;
  this.maximumZoomDistance = Number.POSITIVE_INFINITY;
  this.translateEventTypes = CameraEventType_default.LEFT_DRAG;
  this.zoomEventTypes = [
    CameraEventType_default.RIGHT_DRAG,
    CameraEventType_default.WHEEL,
    CameraEventType_default.PINCH
  ];
  this.rotateEventTypes = CameraEventType_default.LEFT_DRAG;
  this.tiltEventTypes = [
    CameraEventType_default.MIDDLE_DRAG,
    CameraEventType_default.PINCH,
    {
      eventType: CameraEventType_default.LEFT_DRAG,
      modifier: KeyboardEventModifier_default.CTRL
    },
    {
      eventType: CameraEventType_default.RIGHT_DRAG,
      modifier: KeyboardEventModifier_default.CTRL
    }
  ];
  this.lookEventTypes = {
    eventType: CameraEventType_default.LEFT_DRAG,
    modifier: KeyboardEventModifier_default.SHIFT
  };
  this.minimumPickingTerrainHeight = 15e4;
  this._minimumPickingTerrainHeight = this.minimumPickingTerrainHeight;
  this.minimumCollisionTerrainHeight = 15e3;
  this._minimumCollisionTerrainHeight = this.minimumCollisionTerrainHeight;
  this.minimumTrackBallHeight = 75e5;
  this._minimumTrackBallHeight = this.minimumTrackBallHeight;
  this.enableCollisionDetection = true;
  this._scene = scene;
  this._globe = void 0;
  this._ellipsoid = void 0;
  this._aggregator = new CameraEventAggregator_default(scene.canvas);
  this._lastInertiaSpinMovement = void 0;
  this._lastInertiaZoomMovement = void 0;
  this._lastInertiaTranslateMovement = void 0;
  this._lastInertiaTiltMovement = void 0;
  this._inertiaDisablers = {
    _lastInertiaZoomMovement: [
      "_lastInertiaSpinMovement",
      "_lastInertiaTranslateMovement",
      "_lastInertiaTiltMovement"
    ],
    _lastInertiaTiltMovement: [
      "_lastInertiaSpinMovement",
      "_lastInertiaTranslateMovement"
    ]
  };
  this._tweens = new TweenCollection_default();
  this._tween = void 0;
  this._horizontalRotationAxis = void 0;
  this._tiltCenterMousePosition = new Cartesian2_default(-1, -1);
  this._tiltCenter = new Cartesian3_default();
  this._rotateMousePosition = new Cartesian2_default(-1, -1);
  this._rotateStartPosition = new Cartesian3_default();
  this._strafeStartPosition = new Cartesian3_default();
  this._strafeMousePosition = new Cartesian2_default();
  this._strafeEndMousePosition = new Cartesian2_default();
  this._zoomMouseStart = new Cartesian2_default(-1, -1);
  this._zoomWorldPosition = new Cartesian3_default();
  this._useZoomWorldPosition = false;
  this._tiltCVOffMap = false;
  this._looking = false;
  this._rotating = false;
  this._strafing = false;
  this._zoomingOnVector = false;
  this._zoomingUnderground = false;
  this._rotatingZoom = false;
  this._adjustedHeightForTerrain = false;
  this._cameraUnderground = false;
  const projection = scene.mapProjection;
  this._maxCoord = projection.project(
    new Cartographic_default(Math.PI, Math_default.PI_OVER_TWO)
  );
  this._zoomFactor = 5;
  this._rotateFactor = void 0;
  this._rotateRateRangeAdjustment = void 0;
  this._maximumRotateRate = 1.77;
  this._minimumRotateRate = 1 / 5e3;
  this._minimumZoomRate = 20;
  this._maximumZoomRate = 5906376272e3;
  this._minimumUndergroundPickDistance = 2e3;
  this._maximumUndergroundPickDistance = 1e4;
}
function decay(time, coefficient) {
  if (time < 0) {
    return 0;
  }
  const tau = (1 - coefficient) * 25;
  return Math.exp(-tau * time);
}
function sameMousePosition(movement) {
  return Cartesian2_default.equalsEpsilon(
    movement.startPosition,
    movement.endPosition,
    Math_default.EPSILON14
  );
}
var inertiaMaxClickTimeThreshold = 0.4;
function maintainInertia(aggregator, type, modifier, decayCoef, action, object2, lastMovementName) {
  let movementState = object2[lastMovementName];
  if (!defined_default(movementState)) {
    movementState = object2[lastMovementName] = {
      startPosition: new Cartesian2_default(),
      endPosition: new Cartesian2_default(),
      motion: new Cartesian2_default(),
      inertiaEnabled: true
    };
  }
  const ts = aggregator.getButtonPressTime(type, modifier);
  const tr = aggregator.getButtonReleaseTime(type, modifier);
  const threshold = ts && tr && (tr.getTime() - ts.getTime()) / 1e3;
  const now = new Date();
  const fromNow = tr && (now.getTime() - tr.getTime()) / 1e3;
  if (ts && tr && threshold < inertiaMaxClickTimeThreshold) {
    const d = decay(fromNow, decayCoef);
    const lastMovement = aggregator.getLastMovement(type, modifier);
    if (!defined_default(lastMovement) || sameMousePosition(lastMovement) || !movementState.inertiaEnabled) {
      return;
    }
    movementState.motion.x = (lastMovement.endPosition.x - lastMovement.startPosition.x) * 0.5;
    movementState.motion.y = (lastMovement.endPosition.y - lastMovement.startPosition.y) * 0.5;
    movementState.startPosition = Cartesian2_default.clone(
      lastMovement.startPosition,
      movementState.startPosition
    );
    movementState.endPosition = Cartesian2_default.multiplyByScalar(
      movementState.motion,
      d,
      movementState.endPosition
    );
    movementState.endPosition = Cartesian2_default.add(
      movementState.startPosition,
      movementState.endPosition,
      movementState.endPosition
    );
    if (isNaN(movementState.endPosition.x) || isNaN(movementState.endPosition.y) || Cartesian2_default.distance(
      movementState.startPosition,
      movementState.endPosition
    ) < 0.5) {
      return;
    }
    if (!aggregator.isButtonDown(type, modifier)) {
      const startPosition = aggregator.getStartMousePosition(type, modifier);
      action(object2, startPosition, movementState);
    }
  }
}
function activateInertia(controller, inertiaStateName) {
  if (defined_default(inertiaStateName)) {
    let movementState = controller[inertiaStateName];
    if (defined_default(movementState)) {
      movementState.inertiaEnabled = true;
    }
    const inertiasToDisable = controller._inertiaDisablers[inertiaStateName];
    if (defined_default(inertiasToDisable)) {
      const length3 = inertiasToDisable.length;
      for (let i2 = 0; i2 < length3; ++i2) {
        movementState = controller[inertiasToDisable[i2]];
        if (defined_default(movementState)) {
          movementState.inertiaEnabled = false;
        }
      }
    }
  }
}
var scratchEventTypeArray = [];
function reactToInput(controller, enabled, eventTypes, action, inertiaConstant, inertiaStateName) {
  if (!defined_default(eventTypes)) {
    return;
  }
  const aggregator = controller._aggregator;
  if (!Array.isArray(eventTypes)) {
    scratchEventTypeArray[0] = eventTypes;
    eventTypes = scratchEventTypeArray;
  }
  const length3 = eventTypes.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const eventType = eventTypes[i2];
    const type = defined_default(eventType.eventType) ? eventType.eventType : eventType;
    const modifier = eventType.modifier;
    const movement = aggregator.isMoving(type, modifier) && aggregator.getMovement(type, modifier);
    const startPosition = aggregator.getStartMousePosition(type, modifier);
    if (controller.enableInputs && enabled) {
      if (movement) {
        action(controller, startPosition, movement);
        activateInertia(controller, inertiaStateName);
      } else if (inertiaConstant < 1) {
        maintainInertia(
          aggregator,
          type,
          modifier,
          inertiaConstant,
          action,
          controller,
          inertiaStateName
        );
      }
    }
  }
}
var scratchZoomPickRay = new Ray_default();
var scratchPickCartesian = new Cartesian3_default();
var scratchZoomOffset = new Cartesian2_default();
var scratchZoomDirection = new Cartesian3_default();
var scratchCenterPixel = new Cartesian2_default();
var scratchCenterPosition = new Cartesian3_default();
var scratchPositionNormal3 = new Cartesian3_default();
var scratchPickNormal = new Cartesian3_default();
var scratchZoomAxis = new Cartesian3_default();
var scratchCameraPositionNormal = new Cartesian3_default();
var scratchTargetNormal = new Cartesian3_default();
var scratchCameraPosition2 = new Cartesian3_default();
var scratchCameraUpNormal = new Cartesian3_default();
var scratchCameraRightNormal = new Cartesian3_default();
var scratchForwardNormal = new Cartesian3_default();
var scratchPositionToTarget = new Cartesian3_default();
var scratchPositionToTargetNormal = new Cartesian3_default();
var scratchPan = new Cartesian3_default();
var scratchCenterMovement = new Cartesian3_default();
var scratchCenter9 = new Cartesian3_default();
var scratchCartesian31 = new Cartesian3_default();
var scratchCartesianTwo = new Cartesian3_default();
var scratchCartesianThree = new Cartesian3_default();
var scratchZoomViewOptions = {
  orientation: new HeadingPitchRoll_default()
};
function handleZoom(object2, startPosition, movement, zoomFactor, distanceMeasure, unitPositionDotDirection) {
  let percentage = 1;
  if (defined_default(unitPositionDotDirection)) {
    percentage = Math_default.clamp(
      Math.abs(unitPositionDotDirection),
      0.25,
      1
    );
  }
  const diff = movement.endPosition.y - movement.startPosition.y;
  const approachingSurface = diff > 0;
  const minHeight = approachingSurface ? object2.minimumZoomDistance * percentage : 0;
  const maxHeight = object2.maximumZoomDistance;
  const minDistance = distanceMeasure - minHeight;
  let zoomRate = zoomFactor * minDistance;
  zoomRate = Math_default.clamp(
    zoomRate,
    object2._minimumZoomRate,
    object2._maximumZoomRate
  );
  let rangeWindowRatio = diff / object2._scene.canvas.clientHeight;
  rangeWindowRatio = Math.min(rangeWindowRatio, object2.maximumMovementRatio);
  let distance2 = zoomRate * rangeWindowRatio;
  if (object2.enableCollisionDetection || object2.minimumZoomDistance === 0 || !defined_default(object2._globe)) {
    if (distance2 > 0 && Math.abs(distanceMeasure - minHeight) < 1) {
      return;
    }
    if (distance2 < 0 && Math.abs(distanceMeasure - maxHeight) < 1) {
      return;
    }
    if (distanceMeasure - distance2 < minHeight) {
      distance2 = distanceMeasure - minHeight - 1;
    } else if (distanceMeasure - distance2 > maxHeight) {
      distance2 = distanceMeasure - maxHeight;
    }
  }
  const scene = object2._scene;
  const camera = scene.camera;
  const mode2 = scene.mode;
  const orientation = scratchZoomViewOptions.orientation;
  orientation.heading = camera.heading;
  orientation.pitch = camera.pitch;
  orientation.roll = camera.roll;
  if (camera.frustum instanceof OrthographicFrustum_default) {
    if (Math.abs(distance2) > 0) {
      camera.zoomIn(distance2);
      camera._adjustOrthographicFrustum();
    }
    return;
  }
  const sameStartPosition = Cartesian2_default.equals(
    startPosition,
    object2._zoomMouseStart
  );
  let zoomingOnVector = object2._zoomingOnVector;
  let rotatingZoom = object2._rotatingZoom;
  let pickedPosition;
  if (!sameStartPosition) {
    object2._zoomMouseStart = Cartesian2_default.clone(
      startPosition,
      object2._zoomMouseStart
    );
    if (defined_default(object2._globe)) {
      if (mode2 === SceneMode_default.SCENE2D) {
        pickedPosition = camera.getPickRay(startPosition, scratchZoomPickRay).origin;
        pickedPosition = Cartesian3_default.fromElements(
          pickedPosition.y,
          pickedPosition.z,
          pickedPosition.x
        );
      } else {
        pickedPosition = pickGlobe(object2, startPosition, scratchPickCartesian);
      }
    }
    if (defined_default(pickedPosition)) {
      object2._useZoomWorldPosition = true;
      object2._zoomWorldPosition = Cartesian3_default.clone(
        pickedPosition,
        object2._zoomWorldPosition
      );
    } else {
      object2._useZoomWorldPosition = false;
    }
    zoomingOnVector = object2._zoomingOnVector = false;
    rotatingZoom = object2._rotatingZoom = false;
    object2._zoomingUnderground = object2._cameraUnderground;
  }
  if (!object2._useZoomWorldPosition) {
    camera.zoomIn(distance2);
    return;
  }
  let zoomOnVector = mode2 === SceneMode_default.COLUMBUS_VIEW;
  if (camera.positionCartographic.height < 2e6) {
    rotatingZoom = true;
  }
  if (!sameStartPosition || rotatingZoom) {
    if (mode2 === SceneMode_default.SCENE2D) {
      const worldPosition = object2._zoomWorldPosition;
      const endPosition = camera.position;
      if (!Cartesian3_default.equals(worldPosition, endPosition) && camera.positionCartographic.height < object2._maxCoord.x * 2) {
        const savedX = camera.position.x;
        const direction2 = Cartesian3_default.subtract(
          worldPosition,
          endPosition,
          scratchZoomDirection
        );
        Cartesian3_default.normalize(direction2, direction2);
        const d = Cartesian3_default.distance(worldPosition, endPosition) * distance2 / (camera.getMagnitude() * 0.5);
        camera.move(direction2, d * 0.5);
        if (camera.position.x < 0 && savedX > 0 || camera.position.x > 0 && savedX < 0) {
          pickedPosition = camera.getPickRay(startPosition, scratchZoomPickRay).origin;
          pickedPosition = Cartesian3_default.fromElements(
            pickedPosition.y,
            pickedPosition.z,
            pickedPosition.x
          );
          object2._zoomWorldPosition = Cartesian3_default.clone(
            pickedPosition,
            object2._zoomWorldPosition
          );
        }
      }
    } else if (mode2 === SceneMode_default.SCENE3D) {
      const cameraPositionNormal = Cartesian3_default.normalize(
        camera.position,
        scratchCameraPositionNormal
      );
      if (object2._cameraUnderground || object2._zoomingUnderground || camera.positionCartographic.height < 3e3 && Math.abs(Cartesian3_default.dot(camera.direction, cameraPositionNormal)) < 0.6) {
        zoomOnVector = true;
      } else {
        const canvas = scene.canvas;
        const centerPixel = scratchCenterPixel;
        centerPixel.x = canvas.clientWidth / 2;
        centerPixel.y = canvas.clientHeight / 2;
        const centerPosition = pickGlobe(
          object2,
          centerPixel,
          scratchCenterPosition
        );
        if (!defined_default(centerPosition)) {
          zoomOnVector = true;
        } else if (camera.positionCartographic.height < 1e6) {
          if (Cartesian3_default.dot(camera.direction, cameraPositionNormal) >= -0.5) {
            zoomOnVector = true;
          } else {
            const cameraPosition = scratchCameraPosition2;
            Cartesian3_default.clone(camera.position, cameraPosition);
            const target = object2._zoomWorldPosition;
            let targetNormal = scratchTargetNormal;
            targetNormal = Cartesian3_default.normalize(target, targetNormal);
            if (Cartesian3_default.dot(targetNormal, cameraPositionNormal) < 0) {
              return;
            }
            const center = scratchCenter9;
            const forward = scratchForwardNormal;
            Cartesian3_default.clone(camera.direction, forward);
            Cartesian3_default.add(
              cameraPosition,
              Cartesian3_default.multiplyByScalar(forward, 1e3, scratchCartesian31),
              center
            );
            const positionToTarget = scratchPositionToTarget;
            const positionToTargetNormal = scratchPositionToTargetNormal;
            Cartesian3_default.subtract(target, cameraPosition, positionToTarget);
            Cartesian3_default.normalize(positionToTarget, positionToTargetNormal);
            const alphaDot = Cartesian3_default.dot(
              cameraPositionNormal,
              positionToTargetNormal
            );
            if (alphaDot >= 0) {
              object2._zoomMouseStart.x = -1;
              return;
            }
            const alpha = Math.acos(-alphaDot);
            const cameraDistance = Cartesian3_default.magnitude(cameraPosition);
            const targetDistance = Cartesian3_default.magnitude(target);
            const remainingDistance = cameraDistance - distance2;
            const positionToTargetDistance = Cartesian3_default.magnitude(
              positionToTarget
            );
            const gamma = Math.asin(
              Math_default.clamp(
                positionToTargetDistance / targetDistance * Math.sin(alpha),
                -1,
                1
              )
            );
            const delta = Math.asin(
              Math_default.clamp(
                remainingDistance / targetDistance * Math.sin(alpha),
                -1,
                1
              )
            );
            const beta = gamma - delta + alpha;
            const up = scratchCameraUpNormal;
            Cartesian3_default.normalize(cameraPosition, up);
            let right = scratchCameraRightNormal;
            right = Cartesian3_default.cross(positionToTargetNormal, up, right);
            right = Cartesian3_default.normalize(right, right);
            Cartesian3_default.normalize(
              Cartesian3_default.cross(up, right, scratchCartesian31),
              forward
            );
            Cartesian3_default.multiplyByScalar(
              Cartesian3_default.normalize(center, scratchCartesian31),
              Cartesian3_default.magnitude(center) - distance2,
              center
            );
            Cartesian3_default.normalize(cameraPosition, cameraPosition);
            Cartesian3_default.multiplyByScalar(
              cameraPosition,
              remainingDistance,
              cameraPosition
            );
            const pMid = scratchPan;
            Cartesian3_default.multiplyByScalar(
              Cartesian3_default.add(
                Cartesian3_default.multiplyByScalar(
                  up,
                  Math.cos(beta) - 1,
                  scratchCartesianTwo
                ),
                Cartesian3_default.multiplyByScalar(
                  forward,
                  Math.sin(beta),
                  scratchCartesianThree
                ),
                scratchCartesian31
              ),
              remainingDistance,
              pMid
            );
            Cartesian3_default.add(cameraPosition, pMid, cameraPosition);
            Cartesian3_default.normalize(center, up);
            Cartesian3_default.normalize(
              Cartesian3_default.cross(up, right, scratchCartesian31),
              forward
            );
            const cMid = scratchCenterMovement;
            Cartesian3_default.multiplyByScalar(
              Cartesian3_default.add(
                Cartesian3_default.multiplyByScalar(
                  up,
                  Math.cos(beta) - 1,
                  scratchCartesianTwo
                ),
                Cartesian3_default.multiplyByScalar(
                  forward,
                  Math.sin(beta),
                  scratchCartesianThree
                ),
                scratchCartesian31
              ),
              Cartesian3_default.magnitude(center),
              cMid
            );
            Cartesian3_default.add(center, cMid, center);
            Cartesian3_default.clone(cameraPosition, camera.position);
            Cartesian3_default.normalize(
              Cartesian3_default.subtract(center, cameraPosition, scratchCartesian31),
              camera.direction
            );
            Cartesian3_default.clone(camera.direction, camera.direction);
            Cartesian3_default.cross(camera.direction, camera.up, camera.right);
            Cartesian3_default.cross(camera.right, camera.direction, camera.up);
            camera.setView(scratchZoomViewOptions);
            return;
          }
        } else {
          const positionNormal = Cartesian3_default.normalize(
            centerPosition,
            scratchPositionNormal3
          );
          const pickedNormal = Cartesian3_default.normalize(
            object2._zoomWorldPosition,
            scratchPickNormal
          );
          const dotProduct = Cartesian3_default.dot(pickedNormal, positionNormal);
          if (dotProduct > 0 && dotProduct < 1) {
            const angle = Math_default.acosClamped(dotProduct);
            const axis = Cartesian3_default.cross(
              pickedNormal,
              positionNormal,
              scratchZoomAxis
            );
            const denom = Math.abs(angle) > Math_default.toRadians(20) ? camera.positionCartographic.height * 0.75 : camera.positionCartographic.height - distance2;
            const scalar = distance2 / denom;
            camera.rotate(axis, angle * scalar);
          }
        }
      }
    }
    object2._rotatingZoom = !zoomOnVector;
  }
  if (!sameStartPosition && zoomOnVector || zoomingOnVector) {
    let ray;
    const zoomMouseStart = SceneTransforms_default.wgs84ToWindowCoordinates(
      scene,
      object2._zoomWorldPosition,
      scratchZoomOffset
    );
    if (mode2 !== SceneMode_default.COLUMBUS_VIEW && Cartesian2_default.equals(startPosition, object2._zoomMouseStart) && defined_default(zoomMouseStart)) {
      ray = camera.getPickRay(zoomMouseStart, scratchZoomPickRay);
    } else {
      ray = camera.getPickRay(startPosition, scratchZoomPickRay);
    }
    const rayDirection = ray.direction;
    if (mode2 === SceneMode_default.COLUMBUS_VIEW || mode2 === SceneMode_default.SCENE2D) {
      Cartesian3_default.fromElements(
        rayDirection.y,
        rayDirection.z,
        rayDirection.x,
        rayDirection
      );
    }
    camera.move(rayDirection, distance2);
    object2._zoomingOnVector = true;
  } else {
    camera.zoomIn(distance2);
  }
  if (!object2._cameraUnderground) {
    camera.setView(scratchZoomViewOptions);
  }
}
var translate2DStart = new Ray_default();
var translate2DEnd = new Ray_default();
var scratchTranslateP0 = new Cartesian3_default();
function translate2D(controller, startPosition, movement) {
  const scene = controller._scene;
  const camera = scene.camera;
  let start = camera.getPickRay(movement.startPosition, translate2DStart).origin;
  let end = camera.getPickRay(movement.endPosition, translate2DEnd).origin;
  start = Cartesian3_default.fromElements(start.y, start.z, start.x, start);
  end = Cartesian3_default.fromElements(end.y, end.z, end.x, end);
  const direction2 = Cartesian3_default.subtract(start, end, scratchTranslateP0);
  const distance2 = Cartesian3_default.magnitude(direction2);
  if (distance2 > 0) {
    Cartesian3_default.normalize(direction2, direction2);
    camera.move(direction2, distance2);
  }
}
function zoom2D2(controller, startPosition, movement) {
  if (defined_default(movement.distance)) {
    movement = movement.distance;
  }
  const scene = controller._scene;
  const camera = scene.camera;
  handleZoom(
    controller,
    startPosition,
    movement,
    controller._zoomFactor,
    camera.getMagnitude()
  );
}
var twist2DStart = new Cartesian2_default();
var twist2DEnd = new Cartesian2_default();
function twist2D(controller, startPosition, movement) {
  if (defined_default(movement.angleAndHeight)) {
    singleAxisTwist2D(controller, startPosition, movement.angleAndHeight);
    return;
  }
  const scene = controller._scene;
  const camera = scene.camera;
  const canvas = scene.canvas;
  const width = canvas.clientWidth;
  const height = canvas.clientHeight;
  let start = twist2DStart;
  start.x = 2 / width * movement.startPosition.x - 1;
  start.y = 2 / height * (height - movement.startPosition.y) - 1;
  start = Cartesian2_default.normalize(start, start);
  let end = twist2DEnd;
  end.x = 2 / width * movement.endPosition.x - 1;
  end.y = 2 / height * (height - movement.endPosition.y) - 1;
  end = Cartesian2_default.normalize(end, end);
  let startTheta = Math_default.acosClamped(start.x);
  if (start.y < 0) {
    startTheta = Math_default.TWO_PI - startTheta;
  }
  let endTheta = Math_default.acosClamped(end.x);
  if (end.y < 0) {
    endTheta = Math_default.TWO_PI - endTheta;
  }
  const theta = endTheta - startTheta;
  camera.twistRight(theta);
}
function singleAxisTwist2D(controller, startPosition, movement) {
  let rotateRate = controller._rotateFactor * controller._rotateRateRangeAdjustment;
  if (rotateRate > controller._maximumRotateRate) {
    rotateRate = controller._maximumRotateRate;
  }
  if (rotateRate < controller._minimumRotateRate) {
    rotateRate = controller._minimumRotateRate;
  }
  const scene = controller._scene;
  const camera = scene.camera;
  const canvas = scene.canvas;
  let phiWindowRatio = (movement.endPosition.x - movement.startPosition.x) / canvas.clientWidth;
  phiWindowRatio = Math.min(phiWindowRatio, controller.maximumMovementRatio);
  const deltaPhi = rotateRate * phiWindowRatio * Math.PI * 4;
  camera.twistRight(deltaPhi);
}
function update2D(controller) {
  const rotatable2D = controller._scene.mapMode2D === MapMode2D_default.ROTATE;
  if (!Matrix4_default.equals(Matrix4_default.IDENTITY, controller._scene.camera.transform)) {
    reactToInput(
      controller,
      controller.enableZoom,
      controller.zoomEventTypes,
      zoom2D2,
      controller.inertiaZoom,
      "_lastInertiaZoomMovement"
    );
    if (rotatable2D) {
      reactToInput(
        controller,
        controller.enableRotate,
        controller.translateEventTypes,
        twist2D,
        controller.inertiaSpin,
        "_lastInertiaSpinMovement"
      );
    }
  } else {
    reactToInput(
      controller,
      controller.enableTranslate,
      controller.translateEventTypes,
      translate2D,
      controller.inertiaTranslate,
      "_lastInertiaTranslateMovement"
    );
    reactToInput(
      controller,
      controller.enableZoom,
      controller.zoomEventTypes,
      zoom2D2,
      controller.inertiaZoom,
      "_lastInertiaZoomMovement"
    );
    if (rotatable2D) {
      reactToInput(
        controller,
        controller.enableRotate,
        controller.tiltEventTypes,
        twist2D,
        controller.inertiaSpin,
        "_lastInertiaTiltMovement"
      );
    }
  }
}
var pickGlobeScratchRay = new Ray_default();
var scratchDepthIntersection2 = new Cartesian3_default();
var scratchRayIntersection2 = new Cartesian3_default();
function pickGlobe(controller, mousePosition, result) {
  const scene = controller._scene;
  const globe = controller._globe;
  const camera = scene.camera;
  if (!defined_default(globe)) {
    return void 0;
  }
  const cullBackFaces = !controller._cameraUnderground;
  let depthIntersection;
  if (scene.pickPositionSupported) {
    depthIntersection = scene.pickPositionWorldCoordinates(
      mousePosition,
      scratchDepthIntersection2
    );
  }
  const ray = camera.getPickRay(mousePosition, pickGlobeScratchRay);
  const rayIntersection = globe.pickWorldCoordinates(
    ray,
    scene,
    cullBackFaces,
    scratchRayIntersection2
  );
  const pickDistance = defined_default(depthIntersection) ? Cartesian3_default.distance(depthIntersection, camera.positionWC) : Number.POSITIVE_INFINITY;
  const rayDistance = defined_default(rayIntersection) ? Cartesian3_default.distance(rayIntersection, camera.positionWC) : Number.POSITIVE_INFINITY;
  if (pickDistance < rayDistance) {
    return Cartesian3_default.clone(depthIntersection, result);
  }
  return Cartesian3_default.clone(rayIntersection, result);
}
var scratchDistanceCartographic = new Cartographic_default();
function getDistanceFromSurface(controller) {
  const ellipsoid = controller._ellipsoid;
  const scene = controller._scene;
  const camera = scene.camera;
  const mode2 = scene.mode;
  let height = 0;
  if (mode2 === SceneMode_default.SCENE3D) {
    const cartographic2 = ellipsoid.cartesianToCartographic(
      camera.position,
      scratchDistanceCartographic
    );
    if (defined_default(cartographic2)) {
      height = cartographic2.height;
    }
  } else {
    height = camera.position.z;
  }
  const globeHeight = defaultValue_default(controller._scene.globeHeight, 0);
  const distanceFromSurface = Math.abs(globeHeight - height);
  return distanceFromSurface;
}
var scratchSurfaceNormal2 = new Cartesian3_default();
function getZoomDistanceUnderground(controller, ray) {
  const origin = ray.origin;
  const direction2 = ray.direction;
  const distanceFromSurface = getDistanceFromSurface(controller);
  const surfaceNormal = Cartesian3_default.normalize(origin, scratchSurfaceNormal2);
  let strength = Math.abs(Cartesian3_default.dot(surfaceNormal, direction2));
  strength = Math.max(strength, 0.5) * 2;
  return distanceFromSurface * strength;
}
function getTiltCenterUnderground(controller, ray, pickedPosition, result) {
  let distance2 = Cartesian3_default.distance(ray.origin, pickedPosition);
  const distanceFromSurface = getDistanceFromSurface(controller);
  const maximumDistance = Math_default.clamp(
    distanceFromSurface * 5,
    controller._minimumUndergroundPickDistance,
    controller._maximumUndergroundPickDistance
  );
  if (distance2 > maximumDistance) {
    distance2 = Math.min(distance2, distanceFromSurface / 5);
    distance2 = Math.max(distance2, 100);
  }
  return Ray_default.getPoint(ray, distance2, result);
}
function getStrafeStartPositionUnderground(controller, ray, pickedPosition, result) {
  let distance2;
  if (!defined_default(pickedPosition)) {
    distance2 = getDistanceFromSurface(controller);
  } else {
    distance2 = Cartesian3_default.distance(ray.origin, pickedPosition);
    if (distance2 > controller._maximumUndergroundPickDistance) {
      distance2 = getDistanceFromSurface(controller);
    }
  }
  return Ray_default.getPoint(ray, distance2, result);
}
var scratchInertialDelta = new Cartesian2_default();
function continueStrafing(controller, movement) {
  const originalEndPosition = movement.endPosition;
  const inertialDelta = Cartesian2_default.subtract(
    movement.endPosition,
    movement.startPosition,
    scratchInertialDelta
  );
  const endPosition = controller._strafeEndMousePosition;
  Cartesian2_default.add(endPosition, inertialDelta, endPosition);
  movement.endPosition = endPosition;
  strafe(controller, movement, controller._strafeStartPosition);
  movement.endPosition = originalEndPosition;
}
var translateCVStartRay = new Ray_default();
var translateCVEndRay = new Ray_default();
var translateCVStartPos = new Cartesian3_default();
var translateCVEndPos = new Cartesian3_default();
var translateCVDifference = new Cartesian3_default();
var translateCVOrigin = new Cartesian3_default();
var translateCVPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
var translateCVStartMouse = new Cartesian2_default();
var translateCVEndMouse = new Cartesian2_default();
function translateCV(controller, startPosition, movement) {
  if (!Cartesian3_default.equals(startPosition, controller._translateMousePosition)) {
    controller._looking = false;
  }
  if (!Cartesian3_default.equals(startPosition, controller._strafeMousePosition)) {
    controller._strafing = false;
  }
  if (controller._looking) {
    look3D(controller, startPosition, movement);
    return;
  }
  if (controller._strafing) {
    continueStrafing(controller, movement);
    return;
  }
  const scene = controller._scene;
  const camera = scene.camera;
  const cameraUnderground = controller._cameraUnderground;
  const startMouse = Cartesian2_default.clone(
    movement.startPosition,
    translateCVStartMouse
  );
  const endMouse = Cartesian2_default.clone(movement.endPosition, translateCVEndMouse);
  let startRay = camera.getPickRay(startMouse, translateCVStartRay);
  const origin = Cartesian3_default.clone(Cartesian3_default.ZERO, translateCVOrigin);
  const normal2 = Cartesian3_default.UNIT_X;
  let globePos;
  if (camera.position.z < controller._minimumPickingTerrainHeight) {
    globePos = pickGlobe(controller, startMouse, translateCVStartPos);
    if (defined_default(globePos)) {
      origin.x = globePos.x;
    }
  }
  if (cameraUnderground || origin.x > camera.position.z && defined_default(globePos)) {
    let pickPosition = globePos;
    if (cameraUnderground) {
      pickPosition = getStrafeStartPositionUnderground(
        controller,
        startRay,
        globePos,
        translateCVStartPos
      );
    }
    Cartesian2_default.clone(startPosition, controller._strafeMousePosition);
    Cartesian2_default.clone(startPosition, controller._strafeEndMousePosition);
    Cartesian3_default.clone(pickPosition, controller._strafeStartPosition);
    controller._strafing = true;
    strafe(controller, movement, controller._strafeStartPosition);
    return;
  }
  const plane = Plane_default.fromPointNormal(origin, normal2, translateCVPlane);
  startRay = camera.getPickRay(startMouse, translateCVStartRay);
  const startPlanePos = IntersectionTests_default.rayPlane(
    startRay,
    plane,
    translateCVStartPos
  );
  const endRay = camera.getPickRay(endMouse, translateCVEndRay);
  const endPlanePos = IntersectionTests_default.rayPlane(
    endRay,
    plane,
    translateCVEndPos
  );
  if (!defined_default(startPlanePos) || !defined_default(endPlanePos)) {
    controller._looking = true;
    look3D(controller, startPosition, movement);
    Cartesian2_default.clone(startPosition, controller._translateMousePosition);
    return;
  }
  const diff = Cartesian3_default.subtract(
    startPlanePos,
    endPlanePos,
    translateCVDifference
  );
  const temp = diff.x;
  diff.x = diff.y;
  diff.y = diff.z;
  diff.z = temp;
  const mag = Cartesian3_default.magnitude(diff);
  if (mag > Math_default.EPSILON6) {
    Cartesian3_default.normalize(diff, diff);
    camera.move(diff, mag);
  }
}
var rotateCVWindowPos = new Cartesian2_default();
var rotateCVWindowRay = new Ray_default();
var rotateCVCenter = new Cartesian3_default();
var rotateCVVerticalCenter = new Cartesian3_default();
var rotateCVTransform = new Matrix4_default();
var rotateCVVerticalTransform = new Matrix4_default();
var rotateCVOrigin = new Cartesian3_default();
var rotateCVPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
var rotateCVCartesian3 = new Cartesian3_default();
var rotateCVCart = new Cartographic_default();
var rotateCVOldTransform = new Matrix4_default();
var rotateCVQuaternion = new Quaternion_default();
var rotateCVMatrix = new Matrix3_default();
var tilt3DCartesian3 = new Cartesian3_default();
function rotateCV(controller, startPosition, movement) {
  if (defined_default(movement.angleAndHeight)) {
    movement = movement.angleAndHeight;
  }
  if (!Cartesian2_default.equals(startPosition, controller._tiltCenterMousePosition)) {
    controller._tiltCVOffMap = false;
    controller._looking = false;
  }
  if (controller._looking) {
    look3D(controller, startPosition, movement);
    return;
  }
  const scene = controller._scene;
  const camera = scene.camera;
  if (controller._tiltCVOffMap || !controller.onMap() || Math.abs(camera.position.z) > controller._minimumPickingTerrainHeight) {
    controller._tiltCVOffMap = true;
    rotateCVOnPlane(controller, startPosition, movement);
  } else {
    rotateCVOnTerrain(controller, startPosition, movement);
  }
}
function rotateCVOnPlane(controller, startPosition, movement) {
  const scene = controller._scene;
  const camera = scene.camera;
  const canvas = scene.canvas;
  const windowPosition = rotateCVWindowPos;
  windowPosition.x = canvas.clientWidth / 2;
  windowPosition.y = canvas.clientHeight / 2;
  const ray = camera.getPickRay(windowPosition, rotateCVWindowRay);
  const normal2 = Cartesian3_default.UNIT_X;
  const position = ray.origin;
  const direction2 = ray.direction;
  let scalar;
  const normalDotDirection = Cartesian3_default.dot(normal2, direction2);
  if (Math.abs(normalDotDirection) > Math_default.EPSILON6) {
    scalar = -Cartesian3_default.dot(normal2, position) / normalDotDirection;
  }
  if (!defined_default(scalar) || scalar <= 0) {
    controller._looking = true;
    look3D(controller, startPosition, movement);
    Cartesian2_default.clone(startPosition, controller._tiltCenterMousePosition);
    return;
  }
  const center = Cartesian3_default.multiplyByScalar(direction2, scalar, rotateCVCenter);
  Cartesian3_default.add(position, center, center);
  const projection = scene.mapProjection;
  const ellipsoid = projection.ellipsoid;
  Cartesian3_default.fromElements(center.y, center.z, center.x, center);
  const cart = projection.unproject(center, rotateCVCart);
  ellipsoid.cartographicToCartesian(cart, center);
  const transform4 = Transforms_default.eastNorthUpToFixedFrame(
    center,
    ellipsoid,
    rotateCVTransform
  );
  const oldGlobe = controller._globe;
  const oldEllipsoid = controller._ellipsoid;
  controller._globe = void 0;
  controller._ellipsoid = Ellipsoid_default.UNIT_SPHERE;
  controller._rotateFactor = 1;
  controller._rotateRateRangeAdjustment = 1;
  const oldTransform = Matrix4_default.clone(camera.transform, rotateCVOldTransform);
  camera._setTransform(transform4);
  rotate3D(controller, startPosition, movement, Cartesian3_default.UNIT_Z);
  camera._setTransform(oldTransform);
  controller._globe = oldGlobe;
  controller._ellipsoid = oldEllipsoid;
  const radius = oldEllipsoid.maximumRadius;
  controller._rotateFactor = 1 / radius;
  controller._rotateRateRangeAdjustment = radius;
}
function rotateCVOnTerrain(controller, startPosition, movement) {
  const scene = controller._scene;
  const camera = scene.camera;
  const cameraUnderground = controller._cameraUnderground;
  let center;
  let ray;
  const normal2 = Cartesian3_default.UNIT_X;
  if (Cartesian2_default.equals(startPosition, controller._tiltCenterMousePosition)) {
    center = Cartesian3_default.clone(controller._tiltCenter, rotateCVCenter);
  } else {
    if (camera.position.z < controller._minimumPickingTerrainHeight) {
      center = pickGlobe(controller, startPosition, rotateCVCenter);
    }
    if (!defined_default(center)) {
      ray = camera.getPickRay(startPosition, rotateCVWindowRay);
      const position = ray.origin;
      const direction2 = ray.direction;
      let scalar;
      const normalDotDirection = Cartesian3_default.dot(normal2, direction2);
      if (Math.abs(normalDotDirection) > Math_default.EPSILON6) {
        scalar = -Cartesian3_default.dot(normal2, position) / normalDotDirection;
      }
      if (!defined_default(scalar) || scalar <= 0) {
        controller._looking = true;
        look3D(controller, startPosition, movement);
        Cartesian2_default.clone(startPosition, controller._tiltCenterMousePosition);
        return;
      }
      center = Cartesian3_default.multiplyByScalar(direction2, scalar, rotateCVCenter);
      Cartesian3_default.add(position, center, center);
    }
    if (cameraUnderground) {
      if (!defined_default(ray)) {
        ray = camera.getPickRay(startPosition, rotateCVWindowRay);
      }
      getTiltCenterUnderground(controller, ray, center, center);
    }
    Cartesian2_default.clone(startPosition, controller._tiltCenterMousePosition);
    Cartesian3_default.clone(center, controller._tiltCenter);
  }
  const canvas = scene.canvas;
  const windowPosition = rotateCVWindowPos;
  windowPosition.x = canvas.clientWidth / 2;
  windowPosition.y = controller._tiltCenterMousePosition.y;
  ray = camera.getPickRay(windowPosition, rotateCVWindowRay);
  const origin = Cartesian3_default.clone(Cartesian3_default.ZERO, rotateCVOrigin);
  origin.x = center.x;
  const plane = Plane_default.fromPointNormal(origin, normal2, rotateCVPlane);
  const verticalCenter = IntersectionTests_default.rayPlane(
    ray,
    plane,
    rotateCVVerticalCenter
  );
  const projection = camera._projection;
  const ellipsoid = projection.ellipsoid;
  Cartesian3_default.fromElements(center.y, center.z, center.x, center);
  let cart = projection.unproject(center, rotateCVCart);
  ellipsoid.cartographicToCartesian(cart, center);
  const transform4 = Transforms_default.eastNorthUpToFixedFrame(
    center,
    ellipsoid,
    rotateCVTransform
  );
  let verticalTransform;
  if (defined_default(verticalCenter)) {
    Cartesian3_default.fromElements(
      verticalCenter.y,
      verticalCenter.z,
      verticalCenter.x,
      verticalCenter
    );
    cart = projection.unproject(verticalCenter, rotateCVCart);
    ellipsoid.cartographicToCartesian(cart, verticalCenter);
    verticalTransform = Transforms_default.eastNorthUpToFixedFrame(
      verticalCenter,
      ellipsoid,
      rotateCVVerticalTransform
    );
  } else {
    verticalTransform = transform4;
  }
  const oldGlobe = controller._globe;
  const oldEllipsoid = controller._ellipsoid;
  controller._globe = void 0;
  controller._ellipsoid = Ellipsoid_default.UNIT_SPHERE;
  controller._rotateFactor = 1;
  controller._rotateRateRangeAdjustment = 1;
  let constrainedAxis = Cartesian3_default.UNIT_Z;
  const oldTransform = Matrix4_default.clone(camera.transform, rotateCVOldTransform);
  camera._setTransform(transform4);
  const tangent = Cartesian3_default.cross(
    Cartesian3_default.UNIT_Z,
    Cartesian3_default.normalize(camera.position, rotateCVCartesian3),
    rotateCVCartesian3
  );
  const dot2 = Cartesian3_default.dot(camera.right, tangent);
  rotate3D(controller, startPosition, movement, constrainedAxis, false, true);
  camera._setTransform(verticalTransform);
  if (dot2 < 0) {
    const movementDelta = movement.startPosition.y - movement.endPosition.y;
    if (cameraUnderground && movementDelta < 0 || !cameraUnderground && movementDelta > 0) {
      constrainedAxis = void 0;
    }
    const oldConstrainedAxis = camera.constrainedAxis;
    camera.constrainedAxis = void 0;
    rotate3D(controller, startPosition, movement, constrainedAxis, true, false);
    camera.constrainedAxis = oldConstrainedAxis;
  } else {
    rotate3D(controller, startPosition, movement, constrainedAxis, true, false);
  }
  if (defined_default(camera.constrainedAxis)) {
    const right = Cartesian3_default.cross(
      camera.direction,
      camera.constrainedAxis,
      tilt3DCartesian3
    );
    if (!Cartesian3_default.equalsEpsilon(right, Cartesian3_default.ZERO, Math_default.EPSILON6)) {
      if (Cartesian3_default.dot(right, camera.right) < 0) {
        Cartesian3_default.negate(right, right);
      }
      Cartesian3_default.cross(right, camera.direction, camera.up);
      Cartesian3_default.cross(camera.direction, camera.up, camera.right);
      Cartesian3_default.normalize(camera.up, camera.up);
      Cartesian3_default.normalize(camera.right, camera.right);
    }
  }
  camera._setTransform(oldTransform);
  controller._globe = oldGlobe;
  controller._ellipsoid = oldEllipsoid;
  const radius = oldEllipsoid.maximumRadius;
  controller._rotateFactor = 1 / radius;
  controller._rotateRateRangeAdjustment = radius;
  const originalPosition = Cartesian3_default.clone(
    camera.positionWC,
    rotateCVCartesian3
  );
  if (controller.enableCollisionDetection) {
    adjustHeightForTerrain(controller);
  }
  if (!Cartesian3_default.equals(camera.positionWC, originalPosition)) {
    camera._setTransform(verticalTransform);
    camera.worldToCameraCoordinatesPoint(originalPosition, originalPosition);
    const magSqrd = Cartesian3_default.magnitudeSquared(originalPosition);
    if (Cartesian3_default.magnitudeSquared(camera.position) > magSqrd) {
      Cartesian3_default.normalize(camera.position, camera.position);
      Cartesian3_default.multiplyByScalar(
        camera.position,
        Math.sqrt(magSqrd),
        camera.position
      );
    }
    const angle = Cartesian3_default.angleBetween(originalPosition, camera.position);
    const axis = Cartesian3_default.cross(
      originalPosition,
      camera.position,
      originalPosition
    );
    Cartesian3_default.normalize(axis, axis);
    const quaternion = Quaternion_default.fromAxisAngle(
      axis,
      angle,
      rotateCVQuaternion
    );
    const rotation = Matrix3_default.fromQuaternion(quaternion, rotateCVMatrix);
    Matrix3_default.multiplyByVector(rotation, camera.direction, camera.direction);
    Matrix3_default.multiplyByVector(rotation, camera.up, camera.up);
    Cartesian3_default.cross(camera.direction, camera.up, camera.right);
    Cartesian3_default.cross(camera.right, camera.direction, camera.up);
    camera._setTransform(oldTransform);
  }
}
var zoomCVWindowPos = new Cartesian2_default();
var zoomCVWindowRay = new Ray_default();
var zoomCVIntersection = new Cartesian3_default();
function zoomCV(controller, startPosition, movement) {
  if (defined_default(movement.distance)) {
    movement = movement.distance;
  }
  const scene = controller._scene;
  const camera = scene.camera;
  const canvas = scene.canvas;
  const cameraUnderground = controller._cameraUnderground;
  let windowPosition;
  if (cameraUnderground) {
    windowPosition = startPosition;
  } else {
    windowPosition = zoomCVWindowPos;
    windowPosition.x = canvas.clientWidth / 2;
    windowPosition.y = canvas.clientHeight / 2;
  }
  const ray = camera.getPickRay(windowPosition, zoomCVWindowRay);
  const position = ray.origin;
  const direction2 = ray.direction;
  const height = camera.position.z;
  let intersection;
  if (height < controller._minimumPickingTerrainHeight) {
    intersection = pickGlobe(controller, windowPosition, zoomCVIntersection);
  }
  let distance2;
  if (defined_default(intersection)) {
    distance2 = Cartesian3_default.distance(position, intersection);
  }
  if (cameraUnderground) {
    const distanceUnderground = getZoomDistanceUnderground(
      controller,
      ray,
      height
    );
    if (defined_default(distance2)) {
      distance2 = Math.min(distance2, distanceUnderground);
    } else {
      distance2 = distanceUnderground;
    }
  }
  if (!defined_default(distance2)) {
    const normal2 = Cartesian3_default.UNIT_X;
    distance2 = -Cartesian3_default.dot(normal2, position) / Cartesian3_default.dot(normal2, direction2);
  }
  handleZoom(
    controller,
    startPosition,
    movement,
    controller._zoomFactor,
    distance2
  );
}
function updateCV(controller) {
  const scene = controller._scene;
  const camera = scene.camera;
  if (!Matrix4_default.equals(Matrix4_default.IDENTITY, camera.transform)) {
    reactToInput(
      controller,
      controller.enableRotate,
      controller.rotateEventTypes,
      rotate3D,
      controller.inertiaSpin,
      "_lastInertiaSpinMovement"
    );
    reactToInput(
      controller,
      controller.enableZoom,
      controller.zoomEventTypes,
      zoom3D2,
      controller.inertiaZoom,
      "_lastInertiaZoomMovement"
    );
  } else {
    const tweens = controller._tweens;
    if (controller._aggregator.anyButtonDown) {
      tweens.removeAll();
    }
    reactToInput(
      controller,
      controller.enableTilt,
      controller.tiltEventTypes,
      rotateCV,
      controller.inertiaSpin,
      "_lastInertiaTiltMovement"
    );
    reactToInput(
      controller,
      controller.enableTranslate,
      controller.translateEventTypes,
      translateCV,
      controller.inertiaTranslate,
      "_lastInertiaTranslateMovement"
    );
    reactToInput(
      controller,
      controller.enableZoom,
      controller.zoomEventTypes,
      zoomCV,
      controller.inertiaZoom,
      "_lastInertiaZoomMovement"
    );
    reactToInput(
      controller,
      controller.enableLook,
      controller.lookEventTypes,
      look3D
    );
    if (!controller._aggregator.anyButtonDown && !tweens.contains(controller._tween)) {
      const tween = camera.createCorrectPositionTween(
        controller.bounceAnimationTime
      );
      if (defined_default(tween)) {
        controller._tween = tweens.add(tween);
      }
    }
    tweens.update();
  }
}
var scratchStrafeRay = new Ray_default();
var scratchStrafePlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
var scratchStrafeIntersection = new Cartesian3_default();
var scratchStrafeDirection = new Cartesian3_default();
var scratchMousePos = new Cartesian3_default();
function strafe(controller, movement, strafeStartPosition) {
  const scene = controller._scene;
  const camera = scene.camera;
  const ray = camera.getPickRay(movement.endPosition, scratchStrafeRay);
  let direction2 = Cartesian3_default.clone(camera.direction, scratchStrafeDirection);
  if (scene.mode === SceneMode_default.COLUMBUS_VIEW) {
    Cartesian3_default.fromElements(direction2.z, direction2.x, direction2.y, direction2);
  }
  const plane = Plane_default.fromPointNormal(
    strafeStartPosition,
    direction2,
    scratchStrafePlane
  );
  const intersection = IntersectionTests_default.rayPlane(
    ray,
    plane,
    scratchStrafeIntersection
  );
  if (!defined_default(intersection)) {
    return;
  }
  direction2 = Cartesian3_default.subtract(strafeStartPosition, intersection, direction2);
  if (scene.mode === SceneMode_default.COLUMBUS_VIEW) {
    Cartesian3_default.fromElements(direction2.y, direction2.z, direction2.x, direction2);
  }
  Cartesian3_default.add(camera.position, direction2, camera.position);
}
var spin3DPick = new Cartesian3_default();
var scratchCartographic20 = new Cartographic_default();
var scratchRadii3 = new Cartesian3_default();
var scratchEllipsoid15 = new Ellipsoid_default();
var scratchLookUp = new Cartesian3_default();
var scratchNormal8 = new Cartesian3_default();
function spin3D(controller, startPosition, movement) {
  const scene = controller._scene;
  const camera = scene.camera;
  const cameraUnderground = controller._cameraUnderground;
  let ellipsoid = controller._ellipsoid;
  if (!Matrix4_default.equals(camera.transform, Matrix4_default.IDENTITY)) {
    rotate3D(controller, startPosition, movement);
    return;
  }
  let magnitude;
  let radii;
  const up = ellipsoid.geodeticSurfaceNormal(camera.position, scratchLookUp);
  if (Cartesian2_default.equals(startPosition, controller._rotateMousePosition)) {
    if (controller._looking) {
      look3D(controller, startPosition, movement, up);
    } else if (controller._rotating) {
      rotate3D(controller, startPosition, movement);
    } else if (controller._strafing) {
      continueStrafing(controller, movement);
    } else {
      if (Cartesian3_default.magnitude(camera.position) < Cartesian3_default.magnitude(controller._rotateStartPosition)) {
        return;
      }
      magnitude = Cartesian3_default.magnitude(controller._rotateStartPosition);
      radii = scratchRadii3;
      radii.x = radii.y = radii.z = magnitude;
      ellipsoid = Ellipsoid_default.fromCartesian3(radii, scratchEllipsoid15);
      pan3D(controller, startPosition, movement, ellipsoid);
    }
    return;
  }
  controller._looking = false;
  controller._rotating = false;
  controller._strafing = false;
  const height = ellipsoid.cartesianToCartographic(
    camera.positionWC,
    scratchCartographic20
  ).height;
  const globe = controller._globe;
  if (defined_default(globe) && height < controller._minimumPickingTerrainHeight) {
    const mousePos = pickGlobe(
      controller,
      movement.startPosition,
      scratchMousePos
    );
    if (defined_default(mousePos)) {
      let strafing = false;
      const ray = camera.getPickRay(
        movement.startPosition,
        pickGlobeScratchRay
      );
      if (cameraUnderground) {
        strafing = true;
        getStrafeStartPositionUnderground(controller, ray, mousePos, mousePos);
      } else {
        const normal2 = ellipsoid.geodeticSurfaceNormal(mousePos, scratchNormal8);
        const tangentPick = Math.abs(Cartesian3_default.dot(ray.direction, normal2)) < 0.05;
        if (tangentPick) {
          strafing = true;
        } else {
          strafing = Cartesian3_default.magnitude(camera.position) < Cartesian3_default.magnitude(mousePos);
        }
      }
      if (strafing) {
        Cartesian2_default.clone(startPosition, controller._strafeEndMousePosition);
        Cartesian3_default.clone(mousePos, controller._strafeStartPosition);
        controller._strafing = true;
        strafe(controller, movement, controller._strafeStartPosition);
      } else {
        magnitude = Cartesian3_default.magnitude(mousePos);
        radii = scratchRadii3;
        radii.x = radii.y = radii.z = magnitude;
        ellipsoid = Ellipsoid_default.fromCartesian3(radii, scratchEllipsoid15);
        pan3D(controller, startPosition, movement, ellipsoid);
        Cartesian3_default.clone(mousePos, controller._rotateStartPosition);
      }
    } else {
      controller._looking = true;
      look3D(controller, startPosition, movement, up);
    }
  } else if (defined_default(
    camera.pickEllipsoid(
      movement.startPosition,
      controller._ellipsoid,
      spin3DPick
    )
  )) {
    pan3D(controller, startPosition, movement, controller._ellipsoid);
    Cartesian3_default.clone(spin3DPick, controller._rotateStartPosition);
  } else if (height > controller._minimumTrackBallHeight) {
    controller._rotating = true;
    rotate3D(controller, startPosition, movement);
  } else {
    controller._looking = true;
    look3D(controller, startPosition, movement, up);
  }
  Cartesian2_default.clone(startPosition, controller._rotateMousePosition);
}
function rotate3D(controller, startPosition, movement, constrainedAxis, rotateOnlyVertical, rotateOnlyHorizontal) {
  rotateOnlyVertical = defaultValue_default(rotateOnlyVertical, false);
  rotateOnlyHorizontal = defaultValue_default(rotateOnlyHorizontal, false);
  const scene = controller._scene;
  const camera = scene.camera;
  const canvas = scene.canvas;
  const oldAxis = camera.constrainedAxis;
  if (defined_default(constrainedAxis)) {
    camera.constrainedAxis = constrainedAxis;
  }
  const rho = Cartesian3_default.magnitude(camera.position);
  let rotateRate = controller._rotateFactor * (rho - controller._rotateRateRangeAdjustment);
  if (rotateRate > controller._maximumRotateRate) {
    rotateRate = controller._maximumRotateRate;
  }
  if (rotateRate < controller._minimumRotateRate) {
    rotateRate = controller._minimumRotateRate;
  }
  let phiWindowRatio = (movement.startPosition.x - movement.endPosition.x) / canvas.clientWidth;
  let thetaWindowRatio = (movement.startPosition.y - movement.endPosition.y) / canvas.clientHeight;
  phiWindowRatio = Math.min(phiWindowRatio, controller.maximumMovementRatio);
  thetaWindowRatio = Math.min(
    thetaWindowRatio,
    controller.maximumMovementRatio
  );
  const deltaPhi = rotateRate * phiWindowRatio * Math.PI * 2;
  const deltaTheta = rotateRate * thetaWindowRatio * Math.PI;
  if (!rotateOnlyVertical) {
    camera.rotateRight(deltaPhi);
  }
  if (!rotateOnlyHorizontal) {
    camera.rotateUp(deltaTheta);
  }
  camera.constrainedAxis = oldAxis;
}
var pan3DP0 = Cartesian4_default.clone(Cartesian4_default.UNIT_W);
var pan3DP1 = Cartesian4_default.clone(Cartesian4_default.UNIT_W);
var pan3DTemp0 = new Cartesian3_default();
var pan3DTemp1 = new Cartesian3_default();
var pan3DTemp2 = new Cartesian3_default();
var pan3DTemp3 = new Cartesian3_default();
var pan3DStartMousePosition = new Cartesian2_default();
var pan3DEndMousePosition = new Cartesian2_default();
function pan3D(controller, startPosition, movement, ellipsoid) {
  const scene = controller._scene;
  const camera = scene.camera;
  const startMousePosition = Cartesian2_default.clone(
    movement.startPosition,
    pan3DStartMousePosition
  );
  const endMousePosition = Cartesian2_default.clone(
    movement.endPosition,
    pan3DEndMousePosition
  );
  let p0 = camera.pickEllipsoid(startMousePosition, ellipsoid, pan3DP0);
  let p1 = camera.pickEllipsoid(endMousePosition, ellipsoid, pan3DP1);
  if (!defined_default(p0) || !defined_default(p1)) {
    controller._rotating = true;
    rotate3D(controller, startPosition, movement);
    return;
  }
  p0 = camera.worldToCameraCoordinates(p0, p0);
  p1 = camera.worldToCameraCoordinates(p1, p1);
  if (!defined_default(camera.constrainedAxis)) {
    Cartesian3_default.normalize(p0, p0);
    Cartesian3_default.normalize(p1, p1);
    const dot2 = Cartesian3_default.dot(p0, p1);
    const axis = Cartesian3_default.cross(p0, p1, pan3DTemp0);
    if (dot2 < 1 && !Cartesian3_default.equalsEpsilon(axis, Cartesian3_default.ZERO, Math_default.EPSILON14)) {
      const angle = Math.acos(dot2);
      camera.rotate(axis, angle);
    }
  } else {
    const basis0 = camera.constrainedAxis;
    const basis1 = Cartesian3_default.mostOrthogonalAxis(basis0, pan3DTemp0);
    Cartesian3_default.cross(basis1, basis0, basis1);
    Cartesian3_default.normalize(basis1, basis1);
    const basis2 = Cartesian3_default.cross(basis0, basis1, pan3DTemp1);
    const startRho = Cartesian3_default.magnitude(p0);
    const startDot = Cartesian3_default.dot(basis0, p0);
    const startTheta = Math.acos(startDot / startRho);
    const startRej = Cartesian3_default.multiplyByScalar(basis0, startDot, pan3DTemp2);
    Cartesian3_default.subtract(p0, startRej, startRej);
    Cartesian3_default.normalize(startRej, startRej);
    const endRho = Cartesian3_default.magnitude(p1);
    const endDot = Cartesian3_default.dot(basis0, p1);
    const endTheta = Math.acos(endDot / endRho);
    const endRej = Cartesian3_default.multiplyByScalar(basis0, endDot, pan3DTemp3);
    Cartesian3_default.subtract(p1, endRej, endRej);
    Cartesian3_default.normalize(endRej, endRej);
    let startPhi = Math.acos(Cartesian3_default.dot(startRej, basis1));
    if (Cartesian3_default.dot(startRej, basis2) < 0) {
      startPhi = Math_default.TWO_PI - startPhi;
    }
    let endPhi = Math.acos(Cartesian3_default.dot(endRej, basis1));
    if (Cartesian3_default.dot(endRej, basis2) < 0) {
      endPhi = Math_default.TWO_PI - endPhi;
    }
    const deltaPhi = startPhi - endPhi;
    let east;
    if (Cartesian3_default.equalsEpsilon(basis0, camera.position, Math_default.EPSILON2)) {
      east = camera.right;
    } else {
      east = Cartesian3_default.cross(basis0, camera.position, pan3DTemp0);
    }
    const planeNormal = Cartesian3_default.cross(basis0, east, pan3DTemp0);
    const side0 = Cartesian3_default.dot(
      planeNormal,
      Cartesian3_default.subtract(p0, basis0, pan3DTemp1)
    );
    const side1 = Cartesian3_default.dot(
      planeNormal,
      Cartesian3_default.subtract(p1, basis0, pan3DTemp1)
    );
    let deltaTheta;
    if (side0 > 0 && side1 > 0) {
      deltaTheta = endTheta - startTheta;
    } else if (side0 > 0 && side1 <= 0) {
      if (Cartesian3_default.dot(camera.position, basis0) > 0) {
        deltaTheta = -startTheta - endTheta;
      } else {
        deltaTheta = startTheta + endTheta;
      }
    } else {
      deltaTheta = startTheta - endTheta;
    }
    camera.rotateRight(deltaPhi);
    camera.rotateUp(deltaTheta);
  }
}
var zoom3DUnitPosition = new Cartesian3_default();
var zoom3DCartographic = new Cartographic_default();
function zoom3D2(controller, startPosition, movement) {
  if (defined_default(movement.distance)) {
    movement = movement.distance;
  }
  const ellipsoid = controller._ellipsoid;
  const scene = controller._scene;
  const camera = scene.camera;
  const canvas = scene.canvas;
  const cameraUnderground = controller._cameraUnderground;
  let windowPosition;
  if (cameraUnderground) {
    windowPosition = startPosition;
  } else {
    windowPosition = zoomCVWindowPos;
    windowPosition.x = canvas.clientWidth / 2;
    windowPosition.y = canvas.clientHeight / 2;
  }
  const ray = camera.getPickRay(windowPosition, zoomCVWindowRay);
  let intersection;
  const height = ellipsoid.cartesianToCartographic(
    camera.position,
    zoom3DCartographic
  ).height;
  if (height < controller._minimumPickingTerrainHeight) {
    intersection = pickGlobe(controller, windowPosition, zoomCVIntersection);
  }
  let distance2;
  if (defined_default(intersection)) {
    distance2 = Cartesian3_default.distance(ray.origin, intersection);
  }
  if (cameraUnderground) {
    const distanceUnderground = getZoomDistanceUnderground(
      controller,
      ray,
      height
    );
    if (defined_default(distance2)) {
      distance2 = Math.min(distance2, distanceUnderground);
    } else {
      distance2 = distanceUnderground;
    }
  }
  if (!defined_default(distance2)) {
    distance2 = height;
  }
  const unitPosition = Cartesian3_default.normalize(
    camera.position,
    zoom3DUnitPosition
  );
  handleZoom(
    controller,
    startPosition,
    movement,
    controller._zoomFactor,
    distance2,
    Cartesian3_default.dot(unitPosition, camera.direction)
  );
}
var tilt3DWindowPos = new Cartesian2_default();
var tilt3DRay = new Ray_default();
var tilt3DCenter = new Cartesian3_default();
var tilt3DVerticalCenter = new Cartesian3_default();
var tilt3DTransform = new Matrix4_default();
var tilt3DVerticalTransform = new Matrix4_default();
var tilt3DOldTransform = new Matrix4_default();
var tilt3DQuaternion = new Quaternion_default();
var tilt3DMatrix = new Matrix3_default();
var tilt3DCart = new Cartographic_default();
var tilt3DLookUp = new Cartesian3_default();
function tilt3D(controller, startPosition, movement) {
  const scene = controller._scene;
  const camera = scene.camera;
  if (!Matrix4_default.equals(camera.transform, Matrix4_default.IDENTITY)) {
    return;
  }
  if (defined_default(movement.angleAndHeight)) {
    movement = movement.angleAndHeight;
  }
  if (!Cartesian2_default.equals(startPosition, controller._tiltCenterMousePosition)) {
    controller._tiltOnEllipsoid = false;
    controller._looking = false;
  }
  if (controller._looking) {
    const up = controller._ellipsoid.geodeticSurfaceNormal(
      camera.position,
      tilt3DLookUp
    );
    look3D(controller, startPosition, movement, up);
    return;
  }
  const ellipsoid = controller._ellipsoid;
  const cartographic2 = ellipsoid.cartesianToCartographic(
    camera.position,
    tilt3DCart
  );
  if (controller._tiltOnEllipsoid || cartographic2.height > controller._minimumCollisionTerrainHeight) {
    controller._tiltOnEllipsoid = true;
    tilt3DOnEllipsoid(controller, startPosition, movement);
  } else {
    tilt3DOnTerrain(controller, startPosition, movement);
  }
}
var tilt3DOnEllipsoidCartographic = new Cartographic_default();
function tilt3DOnEllipsoid(controller, startPosition, movement) {
  const ellipsoid = controller._ellipsoid;
  const scene = controller._scene;
  const camera = scene.camera;
  const minHeight = controller.minimumZoomDistance * 0.25;
  const height = ellipsoid.cartesianToCartographic(
    camera.positionWC,
    tilt3DOnEllipsoidCartographic
  ).height;
  if (height - minHeight - 1 < Math_default.EPSILON3 && movement.endPosition.y - movement.startPosition.y < 0) {
    return;
  }
  const canvas = scene.canvas;
  const windowPosition = tilt3DWindowPos;
  windowPosition.x = canvas.clientWidth / 2;
  windowPosition.y = canvas.clientHeight / 2;
  const ray = camera.getPickRay(windowPosition, tilt3DRay);
  let center;
  const intersection = IntersectionTests_default.rayEllipsoid(ray, ellipsoid);
  if (defined_default(intersection)) {
    center = Ray_default.getPoint(ray, intersection.start, tilt3DCenter);
  } else if (height > controller._minimumTrackBallHeight) {
    const grazingAltitudeLocation = IntersectionTests_default.grazingAltitudeLocation(
      ray,
      ellipsoid
    );
    if (!defined_default(grazingAltitudeLocation)) {
      return;
    }
    const grazingAltitudeCart = ellipsoid.cartesianToCartographic(
      grazingAltitudeLocation,
      tilt3DCart
    );
    grazingAltitudeCart.height = 0;
    center = ellipsoid.cartographicToCartesian(
      grazingAltitudeCart,
      tilt3DCenter
    );
  } else {
    controller._looking = true;
    const up = controller._ellipsoid.geodeticSurfaceNormal(
      camera.position,
      tilt3DLookUp
    );
    look3D(controller, startPosition, movement, up);
    Cartesian2_default.clone(startPosition, controller._tiltCenterMousePosition);
    return;
  }
  const transform4 = Transforms_default.eastNorthUpToFixedFrame(
    center,
    ellipsoid,
    tilt3DTransform
  );
  const oldGlobe = controller._globe;
  const oldEllipsoid = controller._ellipsoid;
  controller._globe = void 0;
  controller._ellipsoid = Ellipsoid_default.UNIT_SPHERE;
  controller._rotateFactor = 1;
  controller._rotateRateRangeAdjustment = 1;
  const oldTransform = Matrix4_default.clone(camera.transform, tilt3DOldTransform);
  camera._setTransform(transform4);
  rotate3D(controller, startPosition, movement, Cartesian3_default.UNIT_Z);
  camera._setTransform(oldTransform);
  controller._globe = oldGlobe;
  controller._ellipsoid = oldEllipsoid;
  const radius = oldEllipsoid.maximumRadius;
  controller._rotateFactor = 1 / radius;
  controller._rotateRateRangeAdjustment = radius;
}
function tilt3DOnTerrain(controller, startPosition, movement) {
  const ellipsoid = controller._ellipsoid;
  const scene = controller._scene;
  const camera = scene.camera;
  const cameraUnderground = controller._cameraUnderground;
  let center;
  let ray;
  let intersection;
  if (Cartesian2_default.equals(startPosition, controller._tiltCenterMousePosition)) {
    center = Cartesian3_default.clone(controller._tiltCenter, tilt3DCenter);
  } else {
    center = pickGlobe(controller, startPosition, tilt3DCenter);
    if (!defined_default(center)) {
      ray = camera.getPickRay(startPosition, tilt3DRay);
      intersection = IntersectionTests_default.rayEllipsoid(ray, ellipsoid);
      if (!defined_default(intersection)) {
        const cartographic2 = ellipsoid.cartesianToCartographic(
          camera.position,
          tilt3DCart
        );
        if (cartographic2.height <= controller._minimumTrackBallHeight) {
          controller._looking = true;
          const up = controller._ellipsoid.geodeticSurfaceNormal(
            camera.position,
            tilt3DLookUp
          );
          look3D(controller, startPosition, movement, up);
          Cartesian2_default.clone(startPosition, controller._tiltCenterMousePosition);
        }
        return;
      }
      center = Ray_default.getPoint(ray, intersection.start, tilt3DCenter);
    }
    if (cameraUnderground) {
      if (!defined_default(ray)) {
        ray = camera.getPickRay(startPosition, tilt3DRay);
      }
      getTiltCenterUnderground(controller, ray, center, center);
    }
    Cartesian2_default.clone(startPosition, controller._tiltCenterMousePosition);
    Cartesian3_default.clone(center, controller._tiltCenter);
  }
  const canvas = scene.canvas;
  const windowPosition = tilt3DWindowPos;
  windowPosition.x = canvas.clientWidth / 2;
  windowPosition.y = controller._tiltCenterMousePosition.y;
  ray = camera.getPickRay(windowPosition, tilt3DRay);
  const mag = Cartesian3_default.magnitude(center);
  const radii = Cartesian3_default.fromElements(mag, mag, mag, scratchRadii3);
  const newEllipsoid = Ellipsoid_default.fromCartesian3(radii, scratchEllipsoid15);
  intersection = IntersectionTests_default.rayEllipsoid(ray, newEllipsoid);
  if (!defined_default(intersection)) {
    return;
  }
  const t = Cartesian3_default.magnitude(ray.origin) > mag ? intersection.start : intersection.stop;
  const verticalCenter = Ray_default.getPoint(ray, t, tilt3DVerticalCenter);
  const transform4 = Transforms_default.eastNorthUpToFixedFrame(
    center,
    ellipsoid,
    tilt3DTransform
  );
  const verticalTransform = Transforms_default.eastNorthUpToFixedFrame(
    verticalCenter,
    newEllipsoid,
    tilt3DVerticalTransform
  );
  const oldGlobe = controller._globe;
  const oldEllipsoid = controller._ellipsoid;
  controller._globe = void 0;
  controller._ellipsoid = Ellipsoid_default.UNIT_SPHERE;
  controller._rotateFactor = 1;
  controller._rotateRateRangeAdjustment = 1;
  let constrainedAxis = Cartesian3_default.UNIT_Z;
  const oldTransform = Matrix4_default.clone(camera.transform, tilt3DOldTransform);
  camera._setTransform(verticalTransform);
  const tangent = Cartesian3_default.cross(
    verticalCenter,
    camera.positionWC,
    tilt3DCartesian3
  );
  const dot2 = Cartesian3_default.dot(camera.rightWC, tangent);
  if (dot2 < 0) {
    const movementDelta = movement.startPosition.y - movement.endPosition.y;
    if (cameraUnderground && movementDelta < 0 || !cameraUnderground && movementDelta > 0) {
      constrainedAxis = void 0;
    }
    const oldConstrainedAxis = camera.constrainedAxis;
    camera.constrainedAxis = void 0;
    rotate3D(controller, startPosition, movement, constrainedAxis, true, false);
    camera.constrainedAxis = oldConstrainedAxis;
  } else {
    rotate3D(controller, startPosition, movement, constrainedAxis, true, false);
  }
  camera._setTransform(transform4);
  rotate3D(controller, startPosition, movement, constrainedAxis, false, true);
  if (defined_default(camera.constrainedAxis)) {
    const right = Cartesian3_default.cross(
      camera.direction,
      camera.constrainedAxis,
      tilt3DCartesian3
    );
    if (!Cartesian3_default.equalsEpsilon(right, Cartesian3_default.ZERO, Math_default.EPSILON6)) {
      if (Cartesian3_default.dot(right, camera.right) < 0) {
        Cartesian3_default.negate(right, right);
      }
      Cartesian3_default.cross(right, camera.direction, camera.up);
      Cartesian3_default.cross(camera.direction, camera.up, camera.right);
      Cartesian3_default.normalize(camera.up, camera.up);
      Cartesian3_default.normalize(camera.right, camera.right);
    }
  }
  camera._setTransform(oldTransform);
  controller._globe = oldGlobe;
  controller._ellipsoid = oldEllipsoid;
  const radius = oldEllipsoid.maximumRadius;
  controller._rotateFactor = 1 / radius;
  controller._rotateRateRangeAdjustment = radius;
  const originalPosition = Cartesian3_default.clone(
    camera.positionWC,
    tilt3DCartesian3
  );
  if (controller.enableCollisionDetection) {
    adjustHeightForTerrain(controller);
  }
  if (!Cartesian3_default.equals(camera.positionWC, originalPosition)) {
    camera._setTransform(verticalTransform);
    camera.worldToCameraCoordinatesPoint(originalPosition, originalPosition);
    const magSqrd = Cartesian3_default.magnitudeSquared(originalPosition);
    if (Cartesian3_default.magnitudeSquared(camera.position) > magSqrd) {
      Cartesian3_default.normalize(camera.position, camera.position);
      Cartesian3_default.multiplyByScalar(
        camera.position,
        Math.sqrt(magSqrd),
        camera.position
      );
    }
    const angle = Cartesian3_default.angleBetween(originalPosition, camera.position);
    const axis = Cartesian3_default.cross(
      originalPosition,
      camera.position,
      originalPosition
    );
    Cartesian3_default.normalize(axis, axis);
    const quaternion = Quaternion_default.fromAxisAngle(axis, angle, tilt3DQuaternion);
    const rotation = Matrix3_default.fromQuaternion(quaternion, tilt3DMatrix);
    Matrix3_default.multiplyByVector(rotation, camera.direction, camera.direction);
    Matrix3_default.multiplyByVector(rotation, camera.up, camera.up);
    Cartesian3_default.cross(camera.direction, camera.up, camera.right);
    Cartesian3_default.cross(camera.right, camera.direction, camera.up);
    camera._setTransform(oldTransform);
  }
}
var look3DStartPos = new Cartesian2_default();
var look3DEndPos = new Cartesian2_default();
var look3DStartRay = new Ray_default();
var look3DEndRay = new Ray_default();
var look3DNegativeRot = new Cartesian3_default();
var look3DTan = new Cartesian3_default();
function look3D(controller, startPosition, movement, rotationAxis) {
  const scene = controller._scene;
  const camera = scene.camera;
  const startPos = look3DStartPos;
  startPos.x = movement.startPosition.x;
  startPos.y = 0;
  const endPos = look3DEndPos;
  endPos.x = movement.endPosition.x;
  endPos.y = 0;
  let startRay = camera.getPickRay(startPos, look3DStartRay);
  let endRay = camera.getPickRay(endPos, look3DEndRay);
  let angle = 0;
  let start;
  let end;
  if (camera.frustum instanceof OrthographicFrustum_default) {
    start = startRay.origin;
    end = endRay.origin;
    Cartesian3_default.add(camera.direction, start, start);
    Cartesian3_default.add(camera.direction, end, end);
    Cartesian3_default.subtract(start, camera.position, start);
    Cartesian3_default.subtract(end, camera.position, end);
    Cartesian3_default.normalize(start, start);
    Cartesian3_default.normalize(end, end);
  } else {
    start = startRay.direction;
    end = endRay.direction;
  }
  let dot2 = Cartesian3_default.dot(start, end);
  if (dot2 < 1) {
    angle = Math.acos(dot2);
  }
  angle = movement.startPosition.x > movement.endPosition.x ? -angle : angle;
  const horizontalRotationAxis = controller._horizontalRotationAxis;
  if (defined_default(rotationAxis)) {
    camera.look(rotationAxis, -angle);
  } else if (defined_default(horizontalRotationAxis)) {
    camera.look(horizontalRotationAxis, -angle);
  } else {
    camera.lookLeft(angle);
  }
  startPos.x = 0;
  startPos.y = movement.startPosition.y;
  endPos.x = 0;
  endPos.y = movement.endPosition.y;
  startRay = camera.getPickRay(startPos, look3DStartRay);
  endRay = camera.getPickRay(endPos, look3DEndRay);
  angle = 0;
  if (camera.frustum instanceof OrthographicFrustum_default) {
    start = startRay.origin;
    end = endRay.origin;
    Cartesian3_default.add(camera.direction, start, start);
    Cartesian3_default.add(camera.direction, end, end);
    Cartesian3_default.subtract(start, camera.position, start);
    Cartesian3_default.subtract(end, camera.position, end);
    Cartesian3_default.normalize(start, start);
    Cartesian3_default.normalize(end, end);
  } else {
    start = startRay.direction;
    end = endRay.direction;
  }
  dot2 = Cartesian3_default.dot(start, end);
  if (dot2 < 1) {
    angle = Math.acos(dot2);
  }
  angle = movement.startPosition.y > movement.endPosition.y ? -angle : angle;
  rotationAxis = defaultValue_default(rotationAxis, horizontalRotationAxis);
  if (defined_default(rotationAxis)) {
    const direction2 = camera.direction;
    const negativeRotationAxis = Cartesian3_default.negate(
      rotationAxis,
      look3DNegativeRot
    );
    const northParallel = Cartesian3_default.equalsEpsilon(
      direction2,
      rotationAxis,
      Math_default.EPSILON2
    );
    const southParallel = Cartesian3_default.equalsEpsilon(
      direction2,
      negativeRotationAxis,
      Math_default.EPSILON2
    );
    if (!northParallel && !southParallel) {
      dot2 = Cartesian3_default.dot(direction2, rotationAxis);
      let angleToAxis = Math_default.acosClamped(dot2);
      if (angle > 0 && angle > angleToAxis) {
        angle = angleToAxis - Math_default.EPSILON4;
      }
      dot2 = Cartesian3_default.dot(direction2, negativeRotationAxis);
      angleToAxis = Math_default.acosClamped(dot2);
      if (angle < 0 && -angle > angleToAxis) {
        angle = -angleToAxis + Math_default.EPSILON4;
      }
      const tangent = Cartesian3_default.cross(rotationAxis, direction2, look3DTan);
      camera.look(tangent, angle);
    } else if (northParallel && angle < 0 || southParallel && angle > 0) {
      camera.look(camera.right, -angle);
    }
  } else {
    camera.lookUp(angle);
  }
}
function update3D(controller) {
  reactToInput(
    controller,
    controller.enableRotate,
    controller.rotateEventTypes,
    spin3D,
    controller.inertiaSpin,
    "_lastInertiaSpinMovement"
  );
  reactToInput(
    controller,
    controller.enableZoom,
    controller.zoomEventTypes,
    zoom3D2,
    controller.inertiaZoom,
    "_lastInertiaZoomMovement"
  );
  reactToInput(
    controller,
    controller.enableTilt,
    controller.tiltEventTypes,
    tilt3D,
    controller.inertiaSpin,
    "_lastInertiaTiltMovement"
  );
  reactToInput(
    controller,
    controller.enableLook,
    controller.lookEventTypes,
    look3D
  );
}
var scratchAdjustHeightTransform = new Matrix4_default();
var scratchAdjustHeightCartographic = new Cartographic_default();
function adjustHeightForTerrain(controller) {
  controller._adjustedHeightForTerrain = true;
  const scene = controller._scene;
  const mode2 = scene.mode;
  const globe = scene.globe;
  if (!defined_default(globe) || mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.MORPHING) {
    return;
  }
  const camera = scene.camera;
  const ellipsoid = globe.ellipsoid;
  const projection = scene.mapProjection;
  let transform4;
  let mag;
  if (!Matrix4_default.equals(camera.transform, Matrix4_default.IDENTITY)) {
    transform4 = Matrix4_default.clone(camera.transform, scratchAdjustHeightTransform);
    mag = Cartesian3_default.magnitude(camera.position);
    camera._setTransform(Matrix4_default.IDENTITY);
  }
  const cartographic2 = scratchAdjustHeightCartographic;
  if (mode2 === SceneMode_default.SCENE3D) {
    ellipsoid.cartesianToCartographic(camera.position, cartographic2);
  } else {
    projection.unproject(camera.position, cartographic2);
  }
  let heightUpdated = false;
  if (cartographic2.height < controller._minimumCollisionTerrainHeight) {
    const globeHeight = controller._scene.globeHeight;
    if (defined_default(globeHeight)) {
      const height = globeHeight + controller.minimumZoomDistance;
      if (cartographic2.height < height) {
        cartographic2.height = height;
        if (mode2 === SceneMode_default.SCENE3D) {
          ellipsoid.cartographicToCartesian(cartographic2, camera.position);
        } else {
          projection.project(cartographic2, camera.position);
        }
        heightUpdated = true;
      }
    }
  }
  if (defined_default(transform4)) {
    camera._setTransform(transform4);
    if (heightUpdated) {
      Cartesian3_default.normalize(camera.position, camera.position);
      Cartesian3_default.negate(camera.position, camera.direction);
      Cartesian3_default.multiplyByScalar(
        camera.position,
        Math.max(mag, controller.minimumZoomDistance),
        camera.position
      );
      Cartesian3_default.normalize(camera.direction, camera.direction);
      Cartesian3_default.cross(camera.direction, camera.up, camera.right);
      Cartesian3_default.cross(camera.right, camera.direction, camera.up);
    }
  }
}
ScreenSpaceCameraController.prototype.onMap = function() {
  const scene = this._scene;
  const mode2 = scene.mode;
  const camera = scene.camera;
  if (mode2 === SceneMode_default.COLUMBUS_VIEW) {
    return Math.abs(camera.position.x) - this._maxCoord.x < 0 && Math.abs(camera.position.y) - this._maxCoord.y < 0;
  }
  return true;
};
var scratchPreviousPosition = new Cartesian3_default();
var scratchPreviousDirection = new Cartesian3_default();
ScreenSpaceCameraController.prototype.update = function() {
  const scene = this._scene;
  const camera = scene.camera;
  const globe = scene.globe;
  const mode2 = scene.mode;
  if (!Matrix4_default.equals(camera.transform, Matrix4_default.IDENTITY)) {
    this._globe = void 0;
    this._ellipsoid = Ellipsoid_default.UNIT_SPHERE;
  } else {
    this._globe = globe;
    this._ellipsoid = defined_default(this._globe) ? this._globe.ellipsoid : scene.mapProjection.ellipsoid;
  }
  const exaggeration = defined_default(this._globe) ? this._globe.terrainExaggeration : 1;
  const exaggerationRelativeHeight = defined_default(this._globe) ? this._globe.terrainExaggerationRelativeHeight : 0;
  this._minimumCollisionTerrainHeight = TerrainExaggeration_default.getHeight(
    this.minimumCollisionTerrainHeight,
    exaggeration,
    exaggerationRelativeHeight
  );
  this._minimumPickingTerrainHeight = TerrainExaggeration_default.getHeight(
    this.minimumPickingTerrainHeight,
    exaggeration,
    exaggerationRelativeHeight
  );
  this._minimumTrackBallHeight = TerrainExaggeration_default.getHeight(
    this.minimumTrackBallHeight,
    exaggeration,
    exaggerationRelativeHeight
  );
  this._cameraUnderground = scene.cameraUnderground && defined_default(this._globe);
  const radius = this._ellipsoid.maximumRadius;
  this._rotateFactor = 1 / radius;
  this._rotateRateRangeAdjustment = radius;
  this._adjustedHeightForTerrain = false;
  const previousPosition = Cartesian3_default.clone(
    camera.positionWC,
    scratchPreviousPosition
  );
  const previousDirection = Cartesian3_default.clone(
    camera.directionWC,
    scratchPreviousDirection
  );
  if (mode2 === SceneMode_default.SCENE2D) {
    update2D(this);
  } else if (mode2 === SceneMode_default.COLUMBUS_VIEW) {
    this._horizontalRotationAxis = Cartesian3_default.UNIT_Z;
    updateCV(this);
  } else if (mode2 === SceneMode_default.SCENE3D) {
    this._horizontalRotationAxis = void 0;
    update3D(this);
  }
  if (this.enableCollisionDetection && !this._adjustedHeightForTerrain) {
    const cameraChanged = !Cartesian3_default.equals(previousPosition, camera.positionWC) || !Cartesian3_default.equals(previousDirection, camera.directionWC);
    if (cameraChanged) {
      adjustHeightForTerrain(this);
    }
  }
  this._aggregator.reset();
};
ScreenSpaceCameraController.prototype.isDestroyed = function() {
  return false;
};
ScreenSpaceCameraController.prototype.destroy = function() {
  this._tweens.removeAll();
  this._aggregator = this._aggregator && this._aggregator.destroy();
  return destroyObject_default(this);
};
var ScreenSpaceCameraController_default = ScreenSpaceCameraController;

// node_modules/cesium/Source/Shaders/PostProcessStages/AdditiveBlend.js
var AdditiveBlend_default = "uniform sampler2D colorTexture;\nuniform sampler2D colorTexture2;\n\nuniform vec2 center;\nuniform float radius;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    vec4 color0 = texture2D(colorTexture, v_textureCoordinates);\n    vec4 color1 = texture2D(colorTexture2, v_textureCoordinates);\n\n    float x = length(gl_FragCoord.xy - center) / radius;\n    float t = smoothstep(0.5, 0.8, x);\n    gl_FragColor = mix(color0 + color1, color1, t);\n}\n";

// node_modules/cesium/Source/Shaders/PostProcessStages/BrightPass.js
var BrightPass_default = 'uniform sampler2D colorTexture;\n\nuniform float avgLuminance;\nuniform float threshold;\nuniform float offset;\n\nvarying vec2 v_textureCoordinates;\n\nfloat key(float avg)\n{\n    float guess = 1.5 - (1.5 / (avg * 0.1 + 1.0));\n    return max(0.0, guess) + 0.1;\n}\n\n// See section 9. "The bright-pass filter" of Realtime HDR Rendering\n// http://www.cg.tuwien.ac.at/research/publications/2007/Luksch_2007_RHR/Luksch_2007_RHR-RealtimeHDR%20.pdf\n\nvoid main()\n{\n    vec4 color = texture2D(colorTexture, v_textureCoordinates);\n    vec3 xyz = czm_RGBToXYZ(color.rgb);\n    float luminance = xyz.r;\n\n    float scaledLum = key(avgLuminance) * luminance / avgLuminance;\n    float brightLum = max(scaledLum - threshold, 0.0);\n    float brightness = brightLum / (offset + brightLum);\n\n    xyz.r = brightness;\n    gl_FragColor = vec4(czm_XYZToRGB(xyz), 1.0);\n}\n';

// node_modules/cesium/Source/Scene/SunPostProcess.js
function SunPostProcess() {
  this._sceneFramebuffer = new SceneFramebuffer_default();
  const scale = 0.125;
  const stages = new Array(6);
  stages[0] = new PostProcessStage_default({
    fragmentShader: PassThrough_default,
    textureScale: scale,
    forcePowerOfTwo: true,
    sampleMode: PostProcessStageSampleMode_default.LINEAR
  });
  const brightPass = stages[1] = new PostProcessStage_default({
    fragmentShader: BrightPass_default,
    uniforms: {
      avgLuminance: 0.5,
      threshold: 0.25,
      offset: 0.1
    },
    textureScale: scale,
    forcePowerOfTwo: true
  });
  const that = this;
  this._delta = 1;
  this._sigma = 2;
  this._blurStep = new Cartesian2_default();
  stages[2] = new PostProcessStage_default({
    fragmentShader: GaussianBlur1D_default,
    uniforms: {
      step: function() {
        that._blurStep.x = that._blurStep.y = 1 / brightPass.outputTexture.width;
        return that._blurStep;
      },
      delta: function() {
        return that._delta;
      },
      sigma: function() {
        return that._sigma;
      },
      direction: 0
    },
    textureScale: scale,
    forcePowerOfTwo: true
  });
  stages[3] = new PostProcessStage_default({
    fragmentShader: GaussianBlur1D_default,
    uniforms: {
      step: function() {
        that._blurStep.x = that._blurStep.y = 1 / brightPass.outputTexture.width;
        return that._blurStep;
      },
      delta: function() {
        return that._delta;
      },
      sigma: function() {
        return that._sigma;
      },
      direction: 1
    },
    textureScale: scale,
    forcePowerOfTwo: true
  });
  stages[4] = new PostProcessStage_default({
    fragmentShader: PassThrough_default,
    sampleMode: PostProcessStageSampleMode_default.LINEAR
  });
  this._uCenter = new Cartesian2_default();
  this._uRadius = void 0;
  stages[5] = new PostProcessStage_default({
    fragmentShader: AdditiveBlend_default,
    uniforms: {
      center: function() {
        return that._uCenter;
      },
      radius: function() {
        return that._uRadius;
      },
      colorTexture2: function() {
        return that._sceneFramebuffer.framebuffer.getColorTexture(0);
      }
    }
  });
  this._stages = new PostProcessStageComposite_default({
    stages
  });
  const textureCache = new PostProcessStageTextureCache_default(this);
  const length3 = stages.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    stages[i2]._textureCache = textureCache;
  }
  this._textureCache = textureCache;
  this.length = stages.length;
}
SunPostProcess.prototype.get = function(index2) {
  return this._stages.get(index2);
};
SunPostProcess.prototype.getStageByName = function(name) {
  const length3 = this._stages.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const stage = this._stages.get(i2);
    if (stage.name === name) {
      return stage;
    }
  }
  return void 0;
};
var sunPositionECScratch = new Cartesian4_default();
var sunPositionWCScratch = new Cartesian2_default();
var sizeScratch = new Cartesian2_default();
var postProcessMatrix4Scratch = new Matrix4_default();
function updateSunPosition(postProcess, context, viewport) {
  const us = context.uniformState;
  const sunPosition = us.sunPositionWC;
  const viewMatrix = us.view;
  const viewProjectionMatrix = us.viewProjection;
  const projectionMatrix = us.projection;
  let viewportTransformation = Matrix4_default.computeViewportTransformation(
    viewport,
    0,
    1,
    postProcessMatrix4Scratch
  );
  const sunPositionEC = Matrix4_default.multiplyByPoint(
    viewMatrix,
    sunPosition,
    sunPositionECScratch
  );
  let sunPositionWC = Transforms_default.pointToGLWindowCoordinates(
    viewProjectionMatrix,
    viewportTransformation,
    sunPosition,
    sunPositionWCScratch
  );
  sunPositionEC.x += Math_default.SOLAR_RADIUS;
  const limbWC = Transforms_default.pointToGLWindowCoordinates(
    projectionMatrix,
    viewportTransformation,
    sunPositionEC,
    sunPositionEC
  );
  const sunSize = Cartesian2_default.magnitude(Cartesian2_default.subtract(limbWC, sunPositionWC, limbWC)) * 30 * 2;
  const size = sizeScratch;
  size.x = sunSize;
  size.y = sunSize;
  postProcess._uCenter = Cartesian2_default.clone(sunPositionWC, postProcess._uCenter);
  postProcess._uRadius = Math.max(size.x, size.y) * 0.15;
  const width = context.drawingBufferWidth;
  const height = context.drawingBufferHeight;
  const stages = postProcess._stages;
  const firstStage = stages.get(0);
  const downSampleWidth = firstStage.outputTexture.width;
  const downSampleHeight = firstStage.outputTexture.height;
  const downSampleViewport = new BoundingRectangle_default();
  downSampleViewport.width = downSampleWidth;
  downSampleViewport.height = downSampleHeight;
  viewportTransformation = Matrix4_default.computeViewportTransformation(
    downSampleViewport,
    0,
    1,
    postProcessMatrix4Scratch
  );
  sunPositionWC = Transforms_default.pointToGLWindowCoordinates(
    viewProjectionMatrix,
    viewportTransformation,
    sunPosition,
    sunPositionWCScratch
  );
  size.x *= downSampleWidth / width;
  size.y *= downSampleHeight / height;
  const scissorRectangle = firstStage.scissorRectangle;
  scissorRectangle.x = Math.max(sunPositionWC.x - size.x * 0.5, 0);
  scissorRectangle.y = Math.max(sunPositionWC.y - size.y * 0.5, 0);
  scissorRectangle.width = Math.min(size.x, width);
  scissorRectangle.height = Math.min(size.y, height);
  for (let i2 = 1; i2 < 4; ++i2) {
    BoundingRectangle_default.clone(scissorRectangle, stages.get(i2).scissorRectangle);
  }
}
SunPostProcess.prototype.clear = function(context, passState, clearColor) {
  this._sceneFramebuffer.clear(context, passState, clearColor);
  this._textureCache.clear(context);
};
SunPostProcess.prototype.update = function(passState) {
  const context = passState.context;
  const viewport = passState.viewport;
  const sceneFramebuffer = this._sceneFramebuffer;
  sceneFramebuffer.update(context, viewport);
  const framebuffer = sceneFramebuffer.framebuffer;
  this._textureCache.update(context);
  this._stages.update(context, false);
  updateSunPosition(this, context, viewport);
  return framebuffer;
};
SunPostProcess.prototype.execute = function(context) {
  const colorTexture = this._sceneFramebuffer.framebuffer.getColorTexture(0);
  const stages = this._stages;
  const length3 = stages.length;
  stages.get(0).execute(context, colorTexture);
  for (let i2 = 1; i2 < length3; ++i2) {
    stages.get(i2).execute(context, stages.get(i2 - 1).outputTexture);
  }
};
SunPostProcess.prototype.copy = function(context, framebuffer) {
  if (!defined_default(this._copyColorCommand)) {
    const that = this;
    this._copyColorCommand = context.createViewportQuadCommand(PassThrough_default, {
      uniformMap: {
        colorTexture: function() {
          return that._stages.get(that._stages.length - 1).outputTexture;
        }
      },
      owner: this
    });
  }
  this._copyColorCommand.framebuffer = framebuffer;
  this._copyColorCommand.execute(context);
};
SunPostProcess.prototype.isDestroyed = function() {
  return false;
};
SunPostProcess.prototype.destroy = function() {
  this._textureCache.destroy();
  this._stages.destroy();
  return destroyObject_default(this);
};
var SunPostProcess_default = SunPostProcess;

// node_modules/cesium/Source/Scene/Scene.js
var requestRenderAfterFrame = function(scene) {
  return function() {
    scene.frameState.afterRender.push(function() {
      scene.requestRender();
    });
  };
};
function Scene4(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const canvas = options.canvas;
  let creditContainer = options.creditContainer;
  let creditViewport = options.creditViewport;
  let contextOptions = clone_default(options.contextOptions);
  if (!defined_default(contextOptions)) {
    contextOptions = {};
  }
  if (!defined_default(contextOptions.webgl)) {
    contextOptions.webgl = {};
  }
  contextOptions.webgl.powerPreference = defaultValue_default(
    contextOptions.webgl.powerPreference,
    "high-performance"
  );
  if (!defined_default(canvas)) {
    throw new DeveloperError_default("options and options.canvas are required.");
  }
  const hasCreditContainer = defined_default(creditContainer);
  const context = new Context_default(canvas, contextOptions);
  if (!hasCreditContainer) {
    creditContainer = document.createElement("div");
    creditContainer.style.position = "absolute";
    creditContainer.style.bottom = "0";
    creditContainer.style["text-shadow"] = "0 0 2px #000000";
    creditContainer.style.color = "#ffffff";
    creditContainer.style["font-size"] = "10px";
    creditContainer.style["padding-right"] = "5px";
    canvas.parentNode.appendChild(creditContainer);
  }
  if (!defined_default(creditViewport)) {
    creditViewport = canvas.parentNode;
  }
  this._id = createGuid_default();
  this._jobScheduler = new JobScheduler_default();
  this._frameState = new FrameState_default(
    context,
    new CreditDisplay_default(creditContainer, " \u2022 ", creditViewport),
    this._jobScheduler
  );
  this._frameState.scene3DOnly = defaultValue_default(options.scene3DOnly, false);
  this._removeCreditContainer = !hasCreditContainer;
  this._creditContainer = creditContainer;
  this._canvas = canvas;
  this._context = context;
  this._computeEngine = new ComputeEngine_default(context);
  this._globe = void 0;
  this._globeTranslucencyState = new GlobeTranslucencyState_default();
  this._primitives = new PrimitiveCollection_default();
  this._groundPrimitives = new PrimitiveCollection_default();
  this._globeHeight = void 0;
  this._cameraUnderground = false;
  this._logDepthBuffer = context.fragmentDepth;
  this._logDepthBufferDirty = true;
  this._tweens = new TweenCollection_default();
  this._shaderFrameCount = 0;
  this._sunPostProcess = void 0;
  this._computeCommandList = [];
  this._overlayCommandList = [];
  const defaultOIT = !FeatureDetection_default.isIPadOrIOS();
  this._useOIT = defaultValue_default(options.orderIndependentTranslucency, defaultOIT);
  this._executeOITFunction = void 0;
  this._depthPlane = new DepthPlane_default(options.depthPlaneEllipsoidOffset);
  this._clearColorCommand = new ClearCommand_default({
    color: new Color_default(),
    stencil: 0,
    owner: this
  });
  this._depthClearCommand = new ClearCommand_default({
    depth: 1,
    owner: this
  });
  this._stencilClearCommand = new ClearCommand_default({
    stencil: 0
  });
  this._classificationStencilClearCommand = new ClearCommand_default({
    stencil: 0,
    renderState: RenderState_default.fromCache({
      stencilMask: StencilConstants_default.CLASSIFICATION_MASK
    })
  });
  this._depthOnlyRenderStateCache = {};
  this._transitioner = new SceneTransitioner_default(this);
  this._preUpdate = new Event_default();
  this._postUpdate = new Event_default();
  this._renderError = new Event_default();
  this._preRender = new Event_default();
  this._postRender = new Event_default();
  this._minimumDisableDepthTestDistance = 0;
  this._debugInspector = new DebugInspector_default();
  this._msaaSamples = defaultValue_default(options.msaaSamples, 1);
  this.rethrowRenderErrors = false;
  this.completeMorphOnUserInput = true;
  this.morphStart = new Event_default();
  this.morphComplete = new Event_default();
  this.skyBox = void 0;
  this.skyAtmosphere = void 0;
  this.sun = void 0;
  this.sunBloom = true;
  this._sunBloom = void 0;
  this.moon = void 0;
  this.backgroundColor = Color_default.clone(Color_default.BLACK);
  this._mode = SceneMode_default.SCENE3D;
  this._mapProjection = defined_default(options.mapProjection) ? options.mapProjection : new GeographicProjection_default();
  this.morphTime = 1;
  this.farToNearRatio = 1e3;
  this.logarithmicDepthFarToNearRatio = 1e9;
  this.nearToFarDistance2D = 175e4;
  this.debugCommandFilter = void 0;
  this.debugShowCommands = false;
  this.debugShowFrustums = false;
  this.debugShowFramesPerSecond = false;
  this.debugShowDepthFrustum = 1;
  this.debugShowFrustumPlanes = false;
  this._debugShowFrustumPlanes = false;
  this._debugFrustumPlanes = void 0;
  this.useDepthPicking = true;
  this.pickTranslucentDepth = false;
  this.cameraEventWaitTime = 500;
  this.fog = new Fog_default();
  this._shadowMapCamera = new Camera_default(this);
  this.shadowMap = new ShadowMap_default({
    context,
    lightCamera: this._shadowMapCamera,
    enabled: defaultValue_default(options.shadows, false)
  });
  this.invertClassification = false;
  this.invertClassificationColor = Color_default.clone(Color_default.WHITE);
  this._actualInvertClassificationColor = Color_default.clone(
    this._invertClassificationColor
  );
  this._invertClassification = new InvertClassification_default();
  this.focalLength = void 0;
  this.eyeSeparation = void 0;
  this.postProcessStages = new PostProcessStageCollection_default();
  this._brdfLutGenerator = new BrdfLutGenerator_default();
  this._performanceDisplay = void 0;
  this._debugVolume = void 0;
  this._screenSpaceCameraController = new ScreenSpaceCameraController_default(this);
  this._cameraUnderground = false;
  this._mapMode2D = defaultValue_default(options.mapMode2D, MapMode2D_default.INFINITE_SCROLL);
  this._environmentState = {
    skyBoxCommand: void 0,
    skyAtmosphereCommand: void 0,
    sunDrawCommand: void 0,
    sunComputeCommand: void 0,
    moonCommand: void 0,
    isSunVisible: false,
    isMoonVisible: false,
    isReadyForAtmosphere: false,
    isSkyAtmosphereVisible: false,
    clearGlobeDepth: false,
    useDepthPlane: false,
    renderTranslucentDepthForPick: false,
    originalFramebuffer: void 0,
    useGlobeDepthFramebuffer: false,
    useOIT: false,
    useInvertClassification: false,
    usePostProcess: false,
    usePostProcessSelected: false,
    useWebVR: false
  };
  this._useWebVR = false;
  this._cameraVR = void 0;
  this._aspectRatioVR = void 0;
  this.requestRenderMode = defaultValue_default(options.requestRenderMode, false);
  this._renderRequested = true;
  this.maximumRenderTimeChange = defaultValue_default(
    options.maximumRenderTimeChange,
    0
  );
  this._lastRenderTime = void 0;
  this._frameRateMonitor = void 0;
  this._removeRequestListenerCallback = RequestScheduler_default.requestCompletedEvent.addEventListener(
    requestRenderAfterFrame(this)
  );
  this._removeTaskProcessorListenerCallback = TaskProcessor_default.taskCompletedEvent.addEventListener(
    requestRenderAfterFrame(this)
  );
  this._removeGlobeCallbacks = [];
  const viewport = new BoundingRectangle_default(
    0,
    0,
    context.drawingBufferWidth,
    context.drawingBufferHeight
  );
  const camera = new Camera_default(this);
  if (this._logDepthBuffer) {
    camera.frustum.near = 0.1;
    camera.frustum.far = 1e10;
  }
  this.preloadFlightCamera = new Camera_default(this);
  this.preloadFlightCullingVolume = void 0;
  this._picking = new Picking_default(this);
  this._defaultView = new View_default(this, camera, viewport);
  this._view = this._defaultView;
  this._hdr = void 0;
  this._hdrDirty = void 0;
  this.highDynamicRange = false;
  this.gamma = 2.2;
  this.sphericalHarmonicCoefficients = void 0;
  this.specularEnvironmentMaps = void 0;
  this._specularEnvironmentMapAtlas = void 0;
  this.light = new SunLight_default();
  updateFrameNumber(this, 0, JulianDate_default.now());
  this.updateFrameState();
  this.initializeFrame();
}
function updateGlobeListeners(scene, globe) {
  for (let i2 = 0; i2 < scene._removeGlobeCallbacks.length; ++i2) {
    scene._removeGlobeCallbacks[i2]();
  }
  scene._removeGlobeCallbacks.length = 0;
  const removeGlobeCallbacks = [];
  if (defined_default(globe)) {
    removeGlobeCallbacks.push(
      globe.imageryLayersUpdatedEvent.addEventListener(
        requestRenderAfterFrame(scene)
      )
    );
    removeGlobeCallbacks.push(
      globe.terrainProviderChanged.addEventListener(
        requestRenderAfterFrame(scene)
      )
    );
  }
  scene._removeGlobeCallbacks = removeGlobeCallbacks;
}
Object.defineProperties(Scene4.prototype, {
  canvas: {
    get: function() {
      return this._canvas;
    }
  },
  drawingBufferHeight: {
    get: function() {
      return this._context.drawingBufferHeight;
    }
  },
  drawingBufferWidth: {
    get: function() {
      return this._context.drawingBufferWidth;
    }
  },
  maximumAliasedLineWidth: {
    get: function() {
      return ContextLimits_default.maximumAliasedLineWidth;
    }
  },
  maximumCubeMapSize: {
    get: function() {
      return ContextLimits_default.maximumCubeMapSize;
    }
  },
  pickPositionSupported: {
    get: function() {
      return this._context.depthTexture;
    }
  },
  sampleHeightSupported: {
    get: function() {
      return this._context.depthTexture;
    }
  },
  clampToHeightSupported: {
    get: function() {
      return this._context.depthTexture;
    }
  },
  invertClassificationSupported: {
    get: function() {
      return this._context.depthTexture;
    }
  },
  specularEnvironmentMapsSupported: {
    get: function() {
      return OctahedralProjectedCubeMap_default.isSupported(this._context);
    }
  },
  globe: {
    get: function() {
      return this._globe;
    },
    set: function(globe) {
      this._globe = this._globe && this._globe.destroy();
      this._globe = globe;
      updateGlobeListeners(this, globe);
    }
  },
  primitives: {
    get: function() {
      return this._primitives;
    }
  },
  groundPrimitives: {
    get: function() {
      return this._groundPrimitives;
    }
  },
  camera: {
    get: function() {
      return this._view.camera;
    },
    set: function(camera) {
      this._view.camera = camera;
    }
  },
  view: {
    get: function() {
      return this._view;
    },
    set: function(view) {
      this._view = view;
    }
  },
  defaultView: {
    get: function() {
      return this._defaultView;
    }
  },
  picking: {
    get: function() {
      return this._picking;
    }
  },
  screenSpaceCameraController: {
    get: function() {
      return this._screenSpaceCameraController;
    }
  },
  mapProjection: {
    get: function() {
      return this._mapProjection;
    }
  },
  jobScheduler: {
    get: function() {
      return this._jobScheduler;
    }
  },
  frameState: {
    get: function() {
      return this._frameState;
    }
  },
  environmentState: {
    get: function() {
      return this._environmentState;
    }
  },
  tweens: {
    get: function() {
      return this._tweens;
    }
  },
  imageryLayers: {
    get: function() {
      if (!defined_default(this.globe)) {
        return void 0;
      }
      return this.globe.imageryLayers;
    }
  },
  terrainProvider: {
    get: function() {
      if (!defined_default(this.globe)) {
        return void 0;
      }
      return this.globe.terrainProvider;
    },
    set: function(terrainProvider) {
      if (defined_default(this.globe)) {
        this.globe.terrainProvider = terrainProvider;
      }
    }
  },
  terrainProviderChanged: {
    get: function() {
      if (!defined_default(this.globe)) {
        return void 0;
      }
      return this.globe.terrainProviderChanged;
    }
  },
  preUpdate: {
    get: function() {
      return this._preUpdate;
    }
  },
  postUpdate: {
    get: function() {
      return this._postUpdate;
    }
  },
  renderError: {
    get: function() {
      return this._renderError;
    }
  },
  preRender: {
    get: function() {
      return this._preRender;
    }
  },
  postRender: {
    get: function() {
      return this._postRender;
    }
  },
  lastRenderTime: {
    get: function() {
      return this._lastRenderTime;
    }
  },
  context: {
    get: function() {
      return this._context;
    }
  },
  debugFrustumStatistics: {
    get: function() {
      return this._view.debugFrustumStatistics;
    }
  },
  scene3DOnly: {
    get: function() {
      return this._frameState.scene3DOnly;
    }
  },
  orderIndependentTranslucency: {
    get: function() {
      return this._useOIT;
    }
  },
  id: {
    get: function() {
      return this._id;
    }
  },
  mode: {
    get: function() {
      return this._mode;
    },
    set: function(value) {
      if (this.scene3DOnly && value !== SceneMode_default.SCENE3D) {
        throw new DeveloperError_default(
          "Only SceneMode.SCENE3D is valid when scene3DOnly is true."
        );
      }
      if (value === SceneMode_default.SCENE2D) {
        this.morphTo2D(0);
      } else if (value === SceneMode_default.SCENE3D) {
        this.morphTo3D(0);
      } else if (value === SceneMode_default.COLUMBUS_VIEW) {
        this.morphToColumbusView(0);
      } else {
        throw new DeveloperError_default(
          "value must be a valid SceneMode enumeration."
        );
      }
      this._mode = value;
    }
  },
  frustumCommandsList: {
    get: function() {
      return this._view.frustumCommandsList;
    }
  },
  numberOfFrustums: {
    get: function() {
      return this._view.frustumCommandsList.length;
    }
  },
  useWebVR: {
    get: function() {
      return this._useWebVR;
    },
    set: function(value) {
      if (this.camera.frustum instanceof OrthographicFrustum_default) {
        throw new DeveloperError_default(
          "VR is unsupported with an orthographic projection."
        );
      }
      this._useWebVR = value;
      if (this._useWebVR) {
        this._frameState.creditDisplay.container.style.visibility = "hidden";
        this._cameraVR = new Camera_default(this);
        if (!defined_default(this._deviceOrientationCameraController)) {
          this._deviceOrientationCameraController = new DeviceOrientationCameraController_default(
            this
          );
        }
        this._aspectRatioVR = this.camera.frustum.aspectRatio;
      } else {
        this._frameState.creditDisplay.container.style.visibility = "visible";
        this._cameraVR = void 0;
        this._deviceOrientationCameraController = this._deviceOrientationCameraController && !this._deviceOrientationCameraController.isDestroyed() && this._deviceOrientationCameraController.destroy();
        this.camera.frustum.aspectRatio = this._aspectRatioVR;
        this.camera.frustum.xOffset = 0;
      }
    }
  },
  mapMode2D: {
    get: function() {
      return this._mapMode2D;
    }
  },
  splitPosition: {
    get: function() {
      return this._frameState.splitPosition;
    },
    set: function(value) {
      this._frameState.splitPosition = value;
    }
  },
  imagerySplitPosition: {
    get: function() {
      deprecationWarning_default(
        "Scene.imagerySplitPosition",
        "Scene.imagerySplitPosition has been deprecated in Cesium 1.92. It will be removed in Cesium 1.94. Use splitPosition instead."
      );
      return this._frameState.splitPosition;
    },
    set: function(value) {
      deprecationWarning_default(
        "Scene.imagerySplitPosition",
        "Scene.imagerySplitPosition has been deprecated in Cesium 1.92. It will be removed in Cesium 1.94. Use splitPosition instead."
      );
      this._frameState.splitPosition = value;
    }
  },
  minimumDisableDepthTestDistance: {
    get: function() {
      return this._minimumDisableDepthTestDistance;
    },
    set: function(value) {
      if (!defined_default(value) || value < 0) {
        throw new DeveloperError_default(
          "minimumDisableDepthTestDistance must be greater than or equal to 0.0."
        );
      }
      this._minimumDisableDepthTestDistance = value;
    }
  },
  logarithmicDepthBuffer: {
    get: function() {
      return this._logDepthBuffer;
    },
    set: function(value) {
      value = this._context.fragmentDepth && value;
      if (this._logDepthBuffer !== value) {
        this._logDepthBuffer = value;
        this._logDepthBufferDirty = true;
      }
    }
  },
  gamma: {
    get: function() {
      return this._context.uniformState.gamma;
    },
    set: function(value) {
      this._context.uniformState.gamma = value;
    }
  },
  highDynamicRange: {
    get: function() {
      return this._hdr;
    },
    set: function(value) {
      const context = this._context;
      const hdr = value && context.depthTexture && (context.colorBufferFloat || context.colorBufferHalfFloat);
      this._hdrDirty = hdr !== this._hdr;
      this._hdr = hdr;
    }
  },
  highDynamicRangeSupported: {
    get: function() {
      const context = this._context;
      return context.depthTexture && (context.colorBufferFloat || context.colorBufferHalfFloat);
    }
  },
  cameraUnderground: {
    get: function() {
      return this._cameraUnderground;
    }
  },
  msaaSamples: {
    get: function() {
      return this._msaaSamples;
    },
    set: function(value) {
      value = Math.min(value, ContextLimits_default.maximumSamples);
      this._msaaSamples = value;
    }
  },
  msaaSupported: {
    get: function() {
      return this._context.msaa;
    }
  },
  pixelRatio: {
    get: function() {
      return this._frameState.pixelRatio;
    },
    set: function(value) {
      this._frameState.pixelRatio = value;
    }
  },
  opaqueFrustumNearOffset: {
    get: function() {
      return 0.9999;
    }
  },
  globeHeight: {
    get: function() {
      return this._globeHeight;
    }
  }
});
Scene4.prototype.getCompressedTextureFormatSupported = function(format) {
  const context = this.context;
  return (format === "WEBGL_compressed_texture_s3tc" || format === "s3tc") && context.s3tc || (format === "WEBGL_compressed_texture_pvrtc" || format === "pvrtc") && context.pvrtc || (format === "WEBGL_compressed_texture_etc" || format === "etc") && context.etc || (format === "WEBGL_compressed_texture_etc1" || format === "etc1") && context.etc1 || (format === "WEBGL_compressed_texture_astc" || format === "astc") && context.astc || (format === "EXT_texture_compression_bptc" || format === "bc7") && context.bc7;
};
function updateDerivedCommands2(scene, command, shadowsDirty) {
  const frameState = scene._frameState;
  const context = scene._context;
  const oit = scene._view.oit;
  const lightShadowMaps = frameState.shadowState.lightShadowMaps;
  const lightShadowsEnabled = frameState.shadowState.lightShadowsEnabled;
  let derivedCommands = command.derivedCommands;
  if (defined_default(command.pickId)) {
    derivedCommands.picking = DerivedCommand_default.createPickDerivedCommand(
      scene,
      command,
      context,
      derivedCommands.picking
    );
  }
  if (!command.pickOnly) {
    derivedCommands.depth = DerivedCommand_default.createDepthOnlyDerivedCommand(
      scene,
      command,
      context,
      derivedCommands.depth
    );
  }
  derivedCommands.originalCommand = command;
  if (scene._hdr) {
    derivedCommands.hdr = DerivedCommand_default.createHdrCommand(
      command,
      context,
      derivedCommands.hdr
    );
    command = derivedCommands.hdr.command;
    derivedCommands = command.derivedCommands;
  }
  if (lightShadowsEnabled && command.receiveShadows) {
    derivedCommands.shadows = ShadowMap_default.createReceiveDerivedCommand(
      lightShadowMaps,
      command,
      shadowsDirty,
      context,
      derivedCommands.shadows
    );
  }
  if (command.pass === Pass_default.TRANSLUCENT && defined_default(oit) && oit.isSupported()) {
    if (lightShadowsEnabled && command.receiveShadows) {
      derivedCommands.oit = defined_default(derivedCommands.oit) ? derivedCommands.oit : {};
      derivedCommands.oit.shadows = oit.createDerivedCommands(
        derivedCommands.shadows.receiveCommand,
        context,
        derivedCommands.oit.shadows
      );
    } else {
      derivedCommands.oit = oit.createDerivedCommands(
        command,
        context,
        derivedCommands.oit
      );
    }
  }
}
Scene4.prototype.updateDerivedCommands = function(command) {
  if (!defined_default(command.derivedCommands)) {
    return;
  }
  const frameState = this._frameState;
  const context = this._context;
  let shadowsDirty = false;
  const lastDirtyTime = frameState.shadowState.lastDirtyTime;
  if (command.lastDirtyTime !== lastDirtyTime) {
    command.lastDirtyTime = lastDirtyTime;
    command.dirty = true;
    shadowsDirty = true;
  }
  const useLogDepth = frameState.useLogDepth;
  const useHdr = this._hdr;
  const derivedCommands = command.derivedCommands;
  const hasLogDepthDerivedCommands = defined_default(derivedCommands.logDepth);
  const hasHdrCommands = defined_default(derivedCommands.hdr);
  const hasDerivedCommands = defined_default(derivedCommands.originalCommand);
  const needsLogDepthDerivedCommands = useLogDepth && !hasLogDepthDerivedCommands;
  const needsHdrCommands = useHdr && !hasHdrCommands;
  const needsDerivedCommands = (!useLogDepth || !useHdr) && !hasDerivedCommands;
  command.dirty = command.dirty || needsLogDepthDerivedCommands || needsHdrCommands || needsDerivedCommands;
  if (command.dirty) {
    command.dirty = false;
    const shadowMaps = frameState.shadowState.shadowMaps;
    const shadowsEnabled = frameState.shadowState.shadowsEnabled;
    if (shadowsEnabled && command.castShadows) {
      derivedCommands.shadows = ShadowMap_default.createCastDerivedCommand(
        shadowMaps,
        command,
        shadowsDirty,
        context,
        derivedCommands.shadows
      );
    }
    if (hasLogDepthDerivedCommands || needsLogDepthDerivedCommands) {
      derivedCommands.logDepth = DerivedCommand_default.createLogDepthCommand(
        command,
        context,
        derivedCommands.logDepth
      );
      updateDerivedCommands2(
        this,
        derivedCommands.logDepth.command,
        shadowsDirty
      );
    }
    if (hasDerivedCommands || needsDerivedCommands) {
      updateDerivedCommands2(this, command, shadowsDirty);
    }
  }
};
var renderTilesetPassState = new Cesium3DTilePassState_default({
  pass: Cesium3DTilePass_default.RENDER
});
var preloadTilesetPassState = new Cesium3DTilePassState_default({
  pass: Cesium3DTilePass_default.PRELOAD
});
var preloadFlightTilesetPassState = new Cesium3DTilePassState_default({
  pass: Cesium3DTilePass_default.PRELOAD_FLIGHT
});
var requestRenderModeDeferCheckPassState = new Cesium3DTilePassState_default({
  pass: Cesium3DTilePass_default.REQUEST_RENDER_MODE_DEFER_CHECK
});
var scratchOccluderBoundingSphere = new BoundingSphere_default();
var scratchOccluder;
function getOccluder(scene) {
  const globe = scene.globe;
  if (scene._mode === SceneMode_default.SCENE3D && defined_default(globe) && globe.show && !scene._cameraUnderground && !scene._globeTranslucencyState.translucent) {
    const ellipsoid = globe.ellipsoid;
    const minimumTerrainHeight = scene.frameState.minimumTerrainHeight;
    scratchOccluderBoundingSphere.radius = ellipsoid.minimumRadius + minimumTerrainHeight;
    scratchOccluder = Occluder_default.fromBoundingSphere(
      scratchOccluderBoundingSphere,
      scene.camera.positionWC,
      scratchOccluder
    );
    return scratchOccluder;
  }
  return void 0;
}
Scene4.prototype.clearPasses = function(passes) {
  passes.render = false;
  passes.pick = false;
  passes.depth = false;
  passes.postProcess = false;
  passes.offscreen = false;
};
function updateFrameNumber(scene, frameNumber, time) {
  const frameState = scene._frameState;
  frameState.frameNumber = frameNumber;
  frameState.time = JulianDate_default.clone(time, frameState.time);
}
Scene4.prototype.updateFrameState = function() {
  const camera = this.camera;
  const frameState = this._frameState;
  frameState.commandList.length = 0;
  frameState.shadowMaps.length = 0;
  frameState.brdfLutGenerator = this._brdfLutGenerator;
  frameState.environmentMap = this.skyBox && this.skyBox._cubeMap;
  frameState.mode = this._mode;
  frameState.morphTime = this.morphTime;
  frameState.mapProjection = this.mapProjection;
  frameState.camera = camera;
  frameState.cullingVolume = camera.frustum.computeCullingVolume(
    camera.positionWC,
    camera.directionWC,
    camera.upWC
  );
  frameState.occluder = getOccluder(this);
  frameState.minimumTerrainHeight = 0;
  frameState.minimumDisableDepthTestDistance = this._minimumDisableDepthTestDistance;
  frameState.invertClassification = this.invertClassification;
  frameState.useLogDepth = this._logDepthBuffer && !(this.camera.frustum instanceof OrthographicFrustum_default || this.camera.frustum instanceof OrthographicOffCenterFrustum_default);
  frameState.light = this.light;
  frameState.cameraUnderground = this._cameraUnderground;
  frameState.globeTranslucencyState = this._globeTranslucencyState;
  if (defined_default(this.globe)) {
    frameState.terrainExaggeration = this.globe.terrainExaggeration;
    frameState.terrainExaggerationRelativeHeight = this.globe.terrainExaggerationRelativeHeight;
  }
  if (defined_default(this._specularEnvironmentMapAtlas) && this._specularEnvironmentMapAtlas.ready) {
    frameState.specularEnvironmentMaps = this._specularEnvironmentMapAtlas.texture;
    frameState.specularEnvironmentMapsMaximumLOD = this._specularEnvironmentMapAtlas.maximumMipmapLevel;
  } else {
    frameState.specularEnvironmentMaps = void 0;
    frameState.specularEnvironmentMapsMaximumLOD = void 0;
  }
  frameState.sphericalHarmonicCoefficients = this.sphericalHarmonicCoefficients;
  this._actualInvertClassificationColor = Color_default.clone(
    this.invertClassificationColor,
    this._actualInvertClassificationColor
  );
  if (!InvertClassification_default.isTranslucencySupported(this._context)) {
    this._actualInvertClassificationColor.alpha = 1;
  }
  frameState.invertClassificationColor = this._actualInvertClassificationColor;
  if (defined_default(this.globe)) {
    frameState.maximumScreenSpaceError = this.globe.maximumScreenSpaceError;
  } else {
    frameState.maximumScreenSpaceError = 2;
  }
  this.clearPasses(frameState.passes);
  frameState.tilesetPassState = void 0;
};
Scene4.prototype.isVisible = function(command, cullingVolume, occluder) {
  return defined_default(command) && (!defined_default(command.boundingVolume) || !command.cull || cullingVolume.computeVisibility(command.boundingVolume) !== Intersect_default.OUTSIDE && (!defined_default(occluder) || !command.occlude || !command.boundingVolume.isOccluded(occluder)));
};
var transformFrom2D = new Matrix4_default(
  0,
  0,
  1,
  0,
  1,
  0,
  0,
  0,
  0,
  1,
  0,
  0,
  0,
  0,
  0,
  1
);
transformFrom2D = Matrix4_default.inverseTransformation(
  transformFrom2D,
  transformFrom2D
);
function debugShowBoundingVolume(command, scene, passState, debugFramebuffer) {
  const frameState = scene._frameState;
  const context = frameState.context;
  const boundingVolume = command.boundingVolume;
  if (defined_default(scene._debugVolume)) {
    scene._debugVolume.destroy();
  }
  let geometry;
  let center = Cartesian3_default.clone(boundingVolume.center);
  if (frameState.mode !== SceneMode_default.SCENE3D) {
    center = Matrix4_default.multiplyByPoint(transformFrom2D, center, center);
    const projection = frameState.mapProjection;
    const centerCartographic = projection.unproject(center);
    center = projection.ellipsoid.cartographicToCartesian(centerCartographic);
  }
  if (defined_default(boundingVolume.radius)) {
    const radius = boundingVolume.radius;
    geometry = GeometryPipeline_default.toWireframe(
      EllipsoidGeometry_default.createGeometry(
        new EllipsoidGeometry_default({
          radii: new Cartesian3_default(radius, radius, radius),
          vertexFormat: PerInstanceColorAppearance_default.FLAT_VERTEX_FORMAT
        })
      )
    );
    scene._debugVolume = new Primitive_default({
      geometryInstances: new GeometryInstance_default({
        geometry,
        modelMatrix: Matrix4_default.fromTranslation(center),
        attributes: {
          color: new ColorGeometryInstanceAttribute_default(1, 0, 0, 1)
        }
      }),
      appearance: new PerInstanceColorAppearance_default({
        flat: true,
        translucent: false
      }),
      asynchronous: false
    });
  } else {
    const halfAxes = boundingVolume.halfAxes;
    geometry = GeometryPipeline_default.toWireframe(
      BoxGeometry_default.createGeometry(
        BoxGeometry_default.fromDimensions({
          dimensions: new Cartesian3_default(2, 2, 2),
          vertexFormat: PerInstanceColorAppearance_default.FLAT_VERTEX_FORMAT
        })
      )
    );
    scene._debugVolume = new Primitive_default({
      geometryInstances: new GeometryInstance_default({
        geometry,
        modelMatrix: Matrix4_default.fromRotationTranslation(
          halfAxes,
          center,
          new Matrix4_default()
        ),
        attributes: {
          color: new ColorGeometryInstanceAttribute_default(1, 0, 0, 1)
        }
      }),
      appearance: new PerInstanceColorAppearance_default({
        flat: true,
        translucent: false
      }),
      asynchronous: false
    });
  }
  const savedCommandList = frameState.commandList;
  const commandList = frameState.commandList = [];
  scene._debugVolume.update(frameState);
  command = commandList[0];
  if (frameState.useLogDepth) {
    const logDepth = DerivedCommand_default.createLogDepthCommand(command, context);
    command = logDepth.command;
  }
  let framebuffer;
  if (defined_default(debugFramebuffer)) {
    framebuffer = passState.framebuffer;
    passState.framebuffer = debugFramebuffer;
  }
  command.execute(context, passState);
  if (defined_default(framebuffer)) {
    passState.framebuffer = framebuffer;
  }
  frameState.commandList = savedCommandList;
}
function executeCommand(command, scene, context, passState, debugFramebuffer) {
  const frameState = scene._frameState;
  if (defined_default(scene.debugCommandFilter) && !scene.debugCommandFilter(command)) {
    return;
  }
  if (command instanceof ClearCommand_default) {
    command.execute(context, passState);
    return;
  }
  if (command.debugShowBoundingVolume && defined_default(command.boundingVolume)) {
    debugShowBoundingVolume(command, scene, passState, debugFramebuffer);
  }
  if (frameState.useLogDepth && defined_default(command.derivedCommands.logDepth)) {
    command = command.derivedCommands.logDepth.command;
  }
  const passes = frameState.passes;
  if (!passes.pick && !passes.depth && scene._hdr && defined_default(command.derivedCommands) && defined_default(command.derivedCommands.hdr)) {
    command = command.derivedCommands.hdr.command;
  }
  if (passes.pick || passes.depth) {
    if (passes.pick && !passes.depth && defined_default(command.derivedCommands.picking)) {
      command = command.derivedCommands.picking.pickCommand;
      command.execute(context, passState);
      return;
    } else if (defined_default(command.derivedCommands.depth)) {
      command = command.derivedCommands.depth.depthOnlyCommand;
      command.execute(context, passState);
      return;
    }
  }
  if (scene.debugShowCommands || scene.debugShowFrustums) {
    scene._debugInspector.executeDebugShowFrustumsCommand(
      scene,
      command,
      passState
    );
    return;
  }
  if (frameState.shadowState.lightShadowsEnabled && command.receiveShadows && defined_default(command.derivedCommands.shadows)) {
    command.derivedCommands.shadows.receiveCommand.execute(context, passState);
  } else {
    command.execute(context, passState);
  }
}
function executeIdCommand(command, scene, context, passState) {
  const frameState = scene._frameState;
  let derivedCommands = command.derivedCommands;
  if (!defined_default(derivedCommands)) {
    return;
  }
  if (frameState.useLogDepth && defined_default(derivedCommands.logDepth)) {
    command = derivedCommands.logDepth.command;
  }
  derivedCommands = command.derivedCommands;
  if (defined_default(derivedCommands.picking)) {
    command = derivedCommands.picking.pickCommand;
    command.execute(context, passState);
  } else if (defined_default(derivedCommands.depth)) {
    command = derivedCommands.depth.depthOnlyCommand;
    command.execute(context, passState);
  }
}
function backToFront(a4, b, position) {
  return b.boundingVolume.distanceSquaredTo(position) - a4.boundingVolume.distanceSquaredTo(position);
}
function frontToBack(a4, b, position) {
  return a4.boundingVolume.distanceSquaredTo(position) - b.boundingVolume.distanceSquaredTo(position) + Math_default.EPSILON12;
}
function executeTranslucentCommandsBackToFront(scene, executeFunction, passState, commands, invertClassification) {
  const context = scene.context;
  mergeSort_default(commands, backToFront, scene.camera.positionWC);
  if (defined_default(invertClassification)) {
    executeFunction(
      invertClassification.unclassifiedCommand,
      scene,
      context,
      passState
    );
  }
  const length3 = commands.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    executeFunction(commands[i2], scene, context, passState);
  }
}
function executeTranslucentCommandsFrontToBack(scene, executeFunction, passState, commands, invertClassification) {
  const context = scene.context;
  mergeSort_default(commands, frontToBack, scene.camera.positionWC);
  if (defined_default(invertClassification)) {
    executeFunction(
      invertClassification.unclassifiedCommand,
      scene,
      context,
      passState
    );
  }
  const length3 = commands.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    executeFunction(commands[i2], scene, context, passState);
  }
}
var scratchPerspectiveFrustum2 = new PerspectiveFrustum_default();
var scratchPerspectiveOffCenterFrustum2 = new PerspectiveOffCenterFrustum_default();
var scratchOrthographicFrustum2 = new OrthographicFrustum_default();
var scratchOrthographicOffCenterFrustum2 = new OrthographicOffCenterFrustum_default();
function executeCommands2(scene, passState) {
  const camera = scene.camera;
  const context = scene.context;
  const frameState = scene.frameState;
  const us = context.uniformState;
  us.updateCamera(camera);
  let frustum;
  if (defined_default(camera.frustum.fov)) {
    frustum = camera.frustum.clone(scratchPerspectiveFrustum2);
  } else if (defined_default(camera.frustum.infiniteProjectionMatrix)) {
    frustum = camera.frustum.clone(scratchPerspectiveOffCenterFrustum2);
  } else if (defined_default(camera.frustum.width)) {
    frustum = camera.frustum.clone(scratchOrthographicFrustum2);
  } else {
    frustum = camera.frustum.clone(scratchOrthographicOffCenterFrustum2);
  }
  frustum.near = camera.frustum.near;
  frustum.far = camera.frustum.far;
  us.updateFrustum(frustum);
  us.updatePass(Pass_default.ENVIRONMENT);
  const passes = frameState.passes;
  const picking = passes.pick;
  const environmentState = scene._environmentState;
  const view = scene._view;
  const renderTranslucentDepthForPick2 = environmentState.renderTranslucentDepthForPick;
  const useWebVR = environmentState.useWebVR;
  if (!picking) {
    const skyBoxCommand = environmentState.skyBoxCommand;
    if (defined_default(skyBoxCommand)) {
      executeCommand(skyBoxCommand, scene, context, passState);
    }
    if (environmentState.isSkyAtmosphereVisible) {
      executeCommand(
        environmentState.skyAtmosphereCommand,
        scene,
        context,
        passState
      );
    }
    if (environmentState.isSunVisible) {
      environmentState.sunDrawCommand.execute(context, passState);
      if (scene.sunBloom && !useWebVR) {
        let framebuffer;
        if (environmentState.useGlobeDepthFramebuffer) {
          framebuffer = view.globeDepth.framebuffer;
        } else if (environmentState.usePostProcess) {
          framebuffer = view.sceneFramebuffer.framebuffer;
        } else {
          framebuffer = environmentState.originalFramebuffer;
        }
        scene._sunPostProcess.execute(context);
        scene._sunPostProcess.copy(context, framebuffer);
        passState.framebuffer = framebuffer;
      }
    }
    if (environmentState.isMoonVisible) {
      environmentState.moonCommand.execute(context, passState);
    }
  }
  let executeTranslucentCommands;
  if (environmentState.useOIT) {
    if (!defined_default(scene._executeOITFunction)) {
      scene._executeOITFunction = function(scene2, executeFunction, passState2, commands, invertClassification) {
        view.globeDepth.prepareColorTextures(context);
        view.oit.executeCommands(
          scene2,
          executeFunction,
          passState2,
          commands,
          invertClassification
        );
      };
    }
    executeTranslucentCommands = scene._executeOITFunction;
  } else if (passes.render) {
    executeTranslucentCommands = executeTranslucentCommandsBackToFront;
  } else {
    executeTranslucentCommands = executeTranslucentCommandsFrontToBack;
  }
  const frustumCommandsList = view.frustumCommandsList;
  const numFrustums = frustumCommandsList.length;
  const clearGlobeDepth = environmentState.clearGlobeDepth;
  const useDepthPlane2 = environmentState.useDepthPlane;
  const globeTranslucencyState = scene._globeTranslucencyState;
  const globeTranslucent = globeTranslucencyState.translucent;
  const globeTranslucencyFramebuffer = scene._view.globeTranslucencyFramebuffer;
  const clearDepth = scene._depthClearCommand;
  const clearStencil = scene._stencilClearCommand;
  const clearClassificationStencil = scene._classificationStencilClearCommand;
  const depthPlane = scene._depthPlane;
  const usePostProcessSelected = environmentState.usePostProcessSelected;
  const height2D = camera.position.z;
  let j;
  for (let i2 = 0; i2 < numFrustums; ++i2) {
    const index2 = numFrustums - i2 - 1;
    const frustumCommands = frustumCommandsList[index2];
    if (scene.mode === SceneMode_default.SCENE2D) {
      camera.position.z = height2D - frustumCommands.near + 1;
      frustum.far = Math.max(1, frustumCommands.far - frustumCommands.near);
      frustum.near = 1;
      us.update(frameState);
      us.updateFrustum(frustum);
    } else {
      frustum.near = index2 !== 0 ? frustumCommands.near * scene.opaqueFrustumNearOffset : frustumCommands.near;
      frustum.far = frustumCommands.far;
      us.updateFrustum(frustum);
    }
    clearDepth.execute(context, passState);
    if (context.stencilBuffer) {
      clearStencil.execute(context, passState);
    }
    us.updatePass(Pass_default.GLOBE);
    let commands = frustumCommands.commands[Pass_default.GLOBE];
    let length3 = frustumCommands.indices[Pass_default.GLOBE];
    if (globeTranslucent) {
      globeTranslucencyState.executeGlobeCommands(
        frustumCommands,
        executeCommand,
        globeTranslucencyFramebuffer,
        scene,
        passState
      );
    } else {
      for (j = 0; j < length3; ++j) {
        executeCommand(commands[j], scene, context, passState);
      }
    }
    const globeDepth = view.globeDepth;
    if (defined_default(globeDepth) && environmentState.useGlobeDepthFramebuffer) {
      globeDepth.executeCopyDepth(context, passState);
    }
    if (!environmentState.renderTranslucentDepthForPick) {
      us.updatePass(Pass_default.TERRAIN_CLASSIFICATION);
      commands = frustumCommands.commands[Pass_default.TERRAIN_CLASSIFICATION];
      length3 = frustumCommands.indices[Pass_default.TERRAIN_CLASSIFICATION];
      if (globeTranslucent) {
        globeTranslucencyState.executeGlobeClassificationCommands(
          frustumCommands,
          executeCommand,
          globeTranslucencyFramebuffer,
          scene,
          passState
        );
      } else {
        for (j = 0; j < length3; ++j) {
          executeCommand(commands[j], scene, context, passState);
        }
      }
    }
    if (clearGlobeDepth) {
      clearDepth.execute(context, passState);
      if (useDepthPlane2) {
        depthPlane.execute(context, passState);
      }
    }
    if (!environmentState.useInvertClassification || picking || environmentState.renderTranslucentDepthForPick) {
      us.updatePass(Pass_default.CESIUM_3D_TILE);
      commands = frustumCommands.commands[Pass_default.CESIUM_3D_TILE];
      length3 = frustumCommands.indices[Pass_default.CESIUM_3D_TILE];
      for (j = 0; j < length3; ++j) {
        executeCommand(commands[j], scene, context, passState);
      }
      if (length3 > 0) {
        if (defined_default(globeDepth) && environmentState.useGlobeDepthFramebuffer) {
          globeDepth.prepareColorTextures(context, clearGlobeDepth);
          globeDepth.executeUpdateDepth(
            context,
            passState,
            clearGlobeDepth,
            globeDepth.depthStencilTexture
          );
        }
        if (!environmentState.renderTranslucentDepthForPick) {
          us.updatePass(Pass_default.CESIUM_3D_TILE_CLASSIFICATION);
          commands = frustumCommands.commands[Pass_default.CESIUM_3D_TILE_CLASSIFICATION];
          length3 = frustumCommands.indices[Pass_default.CESIUM_3D_TILE_CLASSIFICATION];
          for (j = 0; j < length3; ++j) {
            executeCommand(commands[j], scene, context, passState);
          }
        }
      }
    } else {
      scene._invertClassification.clear(context, passState);
      const opaqueClassificationFramebuffer = passState.framebuffer;
      passState.framebuffer = scene._invertClassification._fbo.framebuffer;
      us.updatePass(Pass_default.CESIUM_3D_TILE);
      commands = frustumCommands.commands[Pass_default.CESIUM_3D_TILE];
      length3 = frustumCommands.indices[Pass_default.CESIUM_3D_TILE];
      for (j = 0; j < length3; ++j) {
        executeCommand(commands[j], scene, context, passState);
      }
      if (defined_default(globeDepth) && environmentState.useGlobeDepthFramebuffer) {
        scene._invertClassification.prepareTextures(context);
        globeDepth.executeUpdateDepth(
          context,
          passState,
          clearGlobeDepth,
          scene._invertClassification._fbo.getDepthStencilTexture()
        );
      }
      us.updatePass(Pass_default.CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW);
      commands = frustumCommands.commands[Pass_default.CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW];
      length3 = frustumCommands.indices[Pass_default.CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW];
      for (j = 0; j < length3; ++j) {
        executeCommand(commands[j], scene, context, passState);
      }
      passState.framebuffer = opaqueClassificationFramebuffer;
      scene._invertClassification.executeClassified(context, passState);
      if (frameState.invertClassificationColor.alpha === 1) {
        scene._invertClassification.executeUnclassified(context, passState);
      }
      if (length3 > 0 && context.stencilBuffer) {
        clearClassificationStencil.execute(context, passState);
      }
      us.updatePass(Pass_default.CESIUM_3D_TILE_CLASSIFICATION);
      commands = frustumCommands.commands[Pass_default.CESIUM_3D_TILE_CLASSIFICATION];
      length3 = frustumCommands.indices[Pass_default.CESIUM_3D_TILE_CLASSIFICATION];
      for (j = 0; j < length3; ++j) {
        executeCommand(commands[j], scene, context, passState);
      }
    }
    if (length3 > 0 && context.stencilBuffer) {
      clearStencil.execute(context, passState);
    }
    us.updatePass(Pass_default.OPAQUE);
    commands = frustumCommands.commands[Pass_default.OPAQUE];
    length3 = frustumCommands.indices[Pass_default.OPAQUE];
    for (j = 0; j < length3; ++j) {
      executeCommand(commands[j], scene, context, passState);
    }
    if (index2 !== 0 && scene.mode !== SceneMode_default.SCENE2D) {
      frustum.near = frustumCommands.near;
      us.updateFrustum(frustum);
    }
    let invertClassification;
    if (!picking && environmentState.useInvertClassification && frameState.invertClassificationColor.alpha < 1) {
      invertClassification = scene._invertClassification;
    }
    us.updatePass(Pass_default.TRANSLUCENT);
    commands = frustumCommands.commands[Pass_default.TRANSLUCENT];
    commands.length = frustumCommands.indices[Pass_default.TRANSLUCENT];
    executeTranslucentCommands(
      scene,
      executeCommand,
      passState,
      commands,
      invertClassification
    );
    const has3DTilesClassificationCommands = frustumCommands.indices[Pass_default.CESIUM_3D_TILE_CLASSIFICATION] > 0;
    if (has3DTilesClassificationCommands && view.translucentTileClassification.isSupported()) {
      view.translucentTileClassification.executeTranslucentCommands(
        scene,
        executeCommand,
        passState,
        commands,
        globeDepth.depthStencilTexture
      );
      view.translucentTileClassification.executeClassificationCommands(
        scene,
        executeCommand,
        passState,
        frustumCommands
      );
    }
    if (context.depthTexture && scene.useDepthPicking && (environmentState.useGlobeDepthFramebuffer || renderTranslucentDepthForPick2)) {
      const depthStencilTexture = globeDepth.depthStencilTexture;
      const pickDepth = scene._picking.getPickDepth(scene, index2);
      pickDepth.update(context, depthStencilTexture);
      pickDepth.executeCopyDepth(context, passState);
    }
    if (picking || !usePostProcessSelected) {
      continue;
    }
    const originalFramebuffer = passState.framebuffer;
    passState.framebuffer = view.sceneFramebuffer.getIdFramebuffer();
    frustum.near = index2 !== 0 ? frustumCommands.near * scene.opaqueFrustumNearOffset : frustumCommands.near;
    frustum.far = frustumCommands.far;
    us.updateFrustum(frustum);
    us.updatePass(Pass_default.GLOBE);
    commands = frustumCommands.commands[Pass_default.GLOBE];
    length3 = frustumCommands.indices[Pass_default.GLOBE];
    if (globeTranslucent) {
      globeTranslucencyState.executeGlobeCommands(
        frustumCommands,
        executeIdCommand,
        globeTranslucencyFramebuffer,
        scene,
        passState
      );
    } else {
      for (j = 0; j < length3; ++j) {
        executeIdCommand(commands[j], scene, context, passState);
      }
    }
    if (clearGlobeDepth) {
      clearDepth.framebuffer = passState.framebuffer;
      clearDepth.execute(context, passState);
      clearDepth.framebuffer = void 0;
    }
    if (clearGlobeDepth && useDepthPlane2) {
      depthPlane.execute(context, passState);
    }
    us.updatePass(Pass_default.CESIUM_3D_TILE);
    commands = frustumCommands.commands[Pass_default.CESIUM_3D_TILE];
    length3 = frustumCommands.indices[Pass_default.CESIUM_3D_TILE];
    for (j = 0; j < length3; ++j) {
      executeIdCommand(commands[j], scene, context, passState);
    }
    us.updatePass(Pass_default.OPAQUE);
    commands = frustumCommands.commands[Pass_default.OPAQUE];
    length3 = frustumCommands.indices[Pass_default.OPAQUE];
    for (j = 0; j < length3; ++j) {
      executeIdCommand(commands[j], scene, context, passState);
    }
    us.updatePass(Pass_default.TRANSLUCENT);
    commands = frustumCommands.commands[Pass_default.TRANSLUCENT];
    length3 = frustumCommands.indices[Pass_default.TRANSLUCENT];
    for (j = 0; j < length3; ++j) {
      executeIdCommand(commands[j], scene, context, passState);
    }
    passState.framebuffer = originalFramebuffer;
  }
}
function executeComputeCommands(scene) {
  const us = scene.context.uniformState;
  us.updatePass(Pass_default.COMPUTE);
  const sunComputeCommand = scene._environmentState.sunComputeCommand;
  if (defined_default(sunComputeCommand)) {
    sunComputeCommand.execute(scene._computeEngine);
  }
  const commandList = scene._computeCommandList;
  const length3 = commandList.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    commandList[i2].execute(scene._computeEngine);
  }
}
function executeOverlayCommands(scene, passState) {
  const us = scene.context.uniformState;
  us.updatePass(Pass_default.OVERLAY);
  const context = scene.context;
  const commandList = scene._overlayCommandList;
  const length3 = commandList.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    commandList[i2].execute(context, passState);
  }
}
function insertShadowCastCommands(scene, commandList, shadowMap) {
  const shadowVolume = shadowMap.shadowMapCullingVolume;
  const isPointLight = shadowMap.isPointLight;
  const passes = shadowMap.passes;
  const numberOfPasses = passes.length;
  const length3 = commandList.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const command = commandList[i2];
    scene.updateDerivedCommands(command);
    if (command.castShadows && (command.pass === Pass_default.GLOBE || command.pass === Pass_default.CESIUM_3D_TILE || command.pass === Pass_default.OPAQUE || command.pass === Pass_default.TRANSLUCENT)) {
      if (scene.isVisible(command, shadowVolume)) {
        if (isPointLight) {
          for (let k = 0; k < numberOfPasses; ++k) {
            passes[k].commandList.push(command);
          }
        } else if (numberOfPasses === 1) {
          passes[0].commandList.push(command);
        } else {
          let wasVisible = false;
          for (let j = numberOfPasses - 1; j >= 0; --j) {
            const cascadeVolume = passes[j].cullingVolume;
            if (scene.isVisible(command, cascadeVolume)) {
              passes[j].commandList.push(command);
              wasVisible = true;
            } else if (wasVisible) {
              break;
            }
          }
        }
      }
    }
  }
}
function executeShadowMapCastCommands(scene) {
  const frameState = scene.frameState;
  const shadowMaps = frameState.shadowState.shadowMaps;
  const shadowMapLength = shadowMaps.length;
  if (!frameState.shadowState.shadowsEnabled) {
    return;
  }
  const context = scene.context;
  const uniformState = context.uniformState;
  for (let i2 = 0; i2 < shadowMapLength; ++i2) {
    const shadowMap = shadowMaps[i2];
    if (shadowMap.outOfView) {
      continue;
    }
    const passes = shadowMap.passes;
    const numberOfPasses = passes.length;
    for (let j = 0; j < numberOfPasses; ++j) {
      passes[j].commandList.length = 0;
    }
    const sceneCommands = scene.frameState.commandList;
    insertShadowCastCommands(scene, sceneCommands, shadowMap);
    for (let j = 0; j < numberOfPasses; ++j) {
      const pass = shadowMap.passes[j];
      uniformState.updateCamera(pass.camera);
      shadowMap.updatePass(context, j);
      const numberOfCommands = pass.commandList.length;
      for (let k = 0; k < numberOfCommands; ++k) {
        const command = pass.commandList[k];
        uniformState.updatePass(command.pass);
        executeCommand(
          command.derivedCommands.shadows.castCommands[i2],
          scene,
          context,
          pass.passState
        );
      }
    }
  }
}
var scratchEyeTranslation = new Cartesian3_default();
Scene4.prototype.updateAndExecuteCommands = function(passState, backgroundColor) {
  const frameState = this._frameState;
  const mode2 = frameState.mode;
  const useWebVR = this._environmentState.useWebVR;
  if (useWebVR) {
    executeWebVRCommands(this, passState, backgroundColor);
  } else if (mode2 !== SceneMode_default.SCENE2D || this._mapMode2D === MapMode2D_default.ROTATE) {
    executeCommandsInViewport(true, this, passState, backgroundColor);
  } else {
    updateAndClearFramebuffers(this, passState, backgroundColor);
    execute2DViewportCommands(this, passState);
  }
};
function executeWebVRCommands(scene, passState, backgroundColor) {
  const view = scene._view;
  const camera = view.camera;
  const environmentState = scene._environmentState;
  const renderTranslucentDepthForPick2 = environmentState.renderTranslucentDepthForPick;
  updateAndClearFramebuffers(scene, passState, backgroundColor);
  updateAndRenderPrimitives(scene);
  view.createPotentiallyVisibleSet(scene);
  executeComputeCommands(scene);
  if (!renderTranslucentDepthForPick2) {
    executeShadowMapCastCommands(scene);
  }
  const viewport = passState.viewport;
  viewport.x = 0;
  viewport.y = 0;
  viewport.width = viewport.width * 0.5;
  const savedCamera = Camera_default.clone(camera, scene._cameraVR);
  savedCamera.frustum = camera.frustum;
  const near = camera.frustum.near;
  const fo = near * defaultValue_default(scene.focalLength, 5);
  const eyeSeparation = defaultValue_default(scene.eyeSeparation, fo / 30);
  const eyeTranslation = Cartesian3_default.multiplyByScalar(
    savedCamera.right,
    eyeSeparation * 0.5,
    scratchEyeTranslation
  );
  camera.frustum.aspectRatio = viewport.width / viewport.height;
  const offset2 = 0.5 * eyeSeparation * near / fo;
  Cartesian3_default.add(savedCamera.position, eyeTranslation, camera.position);
  camera.frustum.xOffset = offset2;
  executeCommands2(scene, passState);
  viewport.x = viewport.width;
  Cartesian3_default.subtract(savedCamera.position, eyeTranslation, camera.position);
  camera.frustum.xOffset = -offset2;
  executeCommands2(scene, passState);
  Camera_default.clone(savedCamera, camera);
}
var scratch2DViewportCartographic = new Cartographic_default(
  Math.PI,
  Math_default.PI_OVER_TWO
);
var scratch2DViewportMaxCoord = new Cartesian3_default();
var scratch2DViewportSavedPosition = new Cartesian3_default();
var scratch2DViewportTransform = new Matrix4_default();
var scratch2DViewportCameraTransform = new Matrix4_default();
var scratch2DViewportEyePoint = new Cartesian3_default();
var scratch2DViewportWindowCoords = new Cartesian3_default();
var scratch2DViewport = new BoundingRectangle_default();
function execute2DViewportCommands(scene, passState) {
  const context = scene.context;
  const frameState = scene.frameState;
  const camera = scene.camera;
  const originalViewport = passState.viewport;
  const viewport = BoundingRectangle_default.clone(originalViewport, scratch2DViewport);
  passState.viewport = viewport;
  const maxCartographic = scratch2DViewportCartographic;
  const maxCoord = scratch2DViewportMaxCoord;
  const projection = scene.mapProjection;
  projection.project(maxCartographic, maxCoord);
  const position = Cartesian3_default.clone(
    camera.position,
    scratch2DViewportSavedPosition
  );
  const transform4 = Matrix4_default.clone(
    camera.transform,
    scratch2DViewportCameraTransform
  );
  const frustum = camera.frustum.clone();
  camera._setTransform(Matrix4_default.IDENTITY);
  const viewportTransformation = Matrix4_default.computeViewportTransformation(
    viewport,
    0,
    1,
    scratch2DViewportTransform
  );
  const projectionMatrix = camera.frustum.projectionMatrix;
  const x = camera.positionWC.y;
  const eyePoint = Cartesian3_default.fromElements(
    Math_default.sign(x) * maxCoord.x - x,
    0,
    -camera.positionWC.x,
    scratch2DViewportEyePoint
  );
  const windowCoordinates = Transforms_default.pointToGLWindowCoordinates(
    projectionMatrix,
    viewportTransformation,
    eyePoint,
    scratch2DViewportWindowCoords
  );
  windowCoordinates.x = Math.floor(windowCoordinates.x);
  const viewportX = viewport.x;
  const viewportWidth = viewport.width;
  if (x === 0 || windowCoordinates.x <= viewportX || windowCoordinates.x >= viewportX + viewportWidth) {
    executeCommandsInViewport(true, scene, passState);
  } else if (Math.abs(viewportX + viewportWidth * 0.5 - windowCoordinates.x) < 1) {
    viewport.width = windowCoordinates.x - viewport.x;
    camera.position.x *= Math_default.sign(camera.position.x);
    camera.frustum.right = 0;
    frameState.cullingVolume = camera.frustum.computeCullingVolume(
      camera.positionWC,
      camera.directionWC,
      camera.upWC
    );
    context.uniformState.update(frameState);
    executeCommandsInViewport(true, scene, passState);
    viewport.x = windowCoordinates.x;
    camera.position.x = -camera.position.x;
    camera.frustum.right = -camera.frustum.left;
    camera.frustum.left = 0;
    frameState.cullingVolume = camera.frustum.computeCullingVolume(
      camera.positionWC,
      camera.directionWC,
      camera.upWC
    );
    context.uniformState.update(frameState);
    executeCommandsInViewport(false, scene, passState);
  } else if (windowCoordinates.x > viewportX + viewportWidth * 0.5) {
    viewport.width = windowCoordinates.x - viewportX;
    const right = camera.frustum.right;
    camera.frustum.right = maxCoord.x - x;
    frameState.cullingVolume = camera.frustum.computeCullingVolume(
      camera.positionWC,
      camera.directionWC,
      camera.upWC
    );
    context.uniformState.update(frameState);
    executeCommandsInViewport(true, scene, passState);
    viewport.x = windowCoordinates.x;
    viewport.width = viewportX + viewportWidth - windowCoordinates.x;
    camera.position.x = -camera.position.x;
    camera.frustum.left = -camera.frustum.right;
    camera.frustum.right = right - camera.frustum.right * 2;
    frameState.cullingVolume = camera.frustum.computeCullingVolume(
      camera.positionWC,
      camera.directionWC,
      camera.upWC
    );
    context.uniformState.update(frameState);
    executeCommandsInViewport(false, scene, passState);
  } else {
    viewport.x = windowCoordinates.x;
    viewport.width = viewportX + viewportWidth - windowCoordinates.x;
    const left = camera.frustum.left;
    camera.frustum.left = -maxCoord.x - x;
    frameState.cullingVolume = camera.frustum.computeCullingVolume(
      camera.positionWC,
      camera.directionWC,
      camera.upWC
    );
    context.uniformState.update(frameState);
    executeCommandsInViewport(true, scene, passState);
    viewport.x = viewportX;
    viewport.width = windowCoordinates.x - viewportX;
    camera.position.x = -camera.position.x;
    camera.frustum.right = -camera.frustum.left;
    camera.frustum.left = left - camera.frustum.left * 2;
    frameState.cullingVolume = camera.frustum.computeCullingVolume(
      camera.positionWC,
      camera.directionWC,
      camera.upWC
    );
    context.uniformState.update(frameState);
    executeCommandsInViewport(false, scene, passState);
  }
  camera._setTransform(transform4);
  Cartesian3_default.clone(position, camera.position);
  camera.frustum = frustum.clone();
  passState.viewport = originalViewport;
}
function executeCommandsInViewport(firstViewport, scene, passState, backgroundColor) {
  const environmentState = scene._environmentState;
  const view = scene._view;
  const renderTranslucentDepthForPick2 = environmentState.renderTranslucentDepthForPick;
  if (!firstViewport) {
    scene.frameState.commandList.length = 0;
  }
  updateAndRenderPrimitives(scene);
  view.createPotentiallyVisibleSet(scene);
  if (firstViewport) {
    if (defined_default(backgroundColor)) {
      updateAndClearFramebuffers(scene, passState, backgroundColor);
    }
    executeComputeCommands(scene);
    if (!renderTranslucentDepthForPick2) {
      executeShadowMapCastCommands(scene);
    }
  }
  executeCommands2(scene, passState);
}
var scratchCullingVolume2 = new CullingVolume_default();
Scene4.prototype.updateEnvironment = function() {
  const frameState = this._frameState;
  const view = this._view;
  const environmentState = this._environmentState;
  const renderPass = frameState.passes.render;
  const offscreenPass = frameState.passes.offscreen;
  const skyAtmosphere = this.skyAtmosphere;
  const globe = this.globe;
  const globeTranslucencyState = this._globeTranslucencyState;
  if (!renderPass || this._mode !== SceneMode_default.SCENE2D && view.camera.frustum instanceof OrthographicFrustum_default || !globeTranslucencyState.environmentVisible) {
    environmentState.skyAtmosphereCommand = void 0;
    environmentState.skyBoxCommand = void 0;
    environmentState.sunDrawCommand = void 0;
    environmentState.sunComputeCommand = void 0;
    environmentState.moonCommand = void 0;
  } else {
    if (defined_default(skyAtmosphere)) {
      if (defined_default(globe)) {
        skyAtmosphere.setDynamicAtmosphereColor(
          globe.enableLighting && globe.dynamicAtmosphereLighting,
          globe.dynamicAtmosphereLightingFromSun
        );
        environmentState.isReadyForAtmosphere = environmentState.isReadyForAtmosphere || globe._surface._tilesToRender.length > 0;
      }
      environmentState.skyAtmosphereCommand = skyAtmosphere.update(
        frameState,
        globe
      );
      if (defined_default(environmentState.skyAtmosphereCommand)) {
        this.updateDerivedCommands(environmentState.skyAtmosphereCommand);
      }
    } else {
      environmentState.skyAtmosphereCommand = void 0;
    }
    environmentState.skyBoxCommand = defined_default(this.skyBox) ? this.skyBox.update(frameState, this._hdr) : void 0;
    const sunCommands = defined_default(this.sun) ? this.sun.update(frameState, view.passState, this._hdr) : void 0;
    environmentState.sunDrawCommand = defined_default(sunCommands) ? sunCommands.drawCommand : void 0;
    environmentState.sunComputeCommand = defined_default(sunCommands) ? sunCommands.computeCommand : void 0;
    environmentState.moonCommand = defined_default(this.moon) ? this.moon.update(frameState) : void 0;
  }
  const clearGlobeDepth = environmentState.clearGlobeDepth = defined_default(globe) && globe.show && (!globe.depthTestAgainstTerrain || this.mode === SceneMode_default.SCENE2D);
  const useDepthPlane2 = environmentState.useDepthPlane = clearGlobeDepth && this.mode === SceneMode_default.SCENE3D && globeTranslucencyState.useDepthPlane;
  if (useDepthPlane2) {
    this._depthPlane.update(frameState);
  }
  environmentState.renderTranslucentDepthForPick = false;
  environmentState.useWebVR = this._useWebVR && this.mode !== SceneMode_default.SCENE2D && !offscreenPass;
  const occluder = frameState.mode === SceneMode_default.SCENE3D && !globeTranslucencyState.sunVisibleThroughGlobe ? frameState.occluder : void 0;
  let cullingVolume = frameState.cullingVolume;
  const planes = scratchCullingVolume2.planes;
  for (let k = 0; k < 5; ++k) {
    planes[k] = cullingVolume.planes[k];
  }
  cullingVolume = scratchCullingVolume2;
  environmentState.isSkyAtmosphereVisible = defined_default(environmentState.skyAtmosphereCommand) && environmentState.isReadyForAtmosphere;
  environmentState.isSunVisible = this.isVisible(
    environmentState.sunDrawCommand,
    cullingVolume,
    occluder
  );
  environmentState.isMoonVisible = this.isVisible(
    environmentState.moonCommand,
    cullingVolume,
    occluder
  );
  const envMaps = this.specularEnvironmentMaps;
  let envMapAtlas = this._specularEnvironmentMapAtlas;
  if (defined_default(envMaps) && (!defined_default(envMapAtlas) || envMapAtlas.url !== envMaps)) {
    envMapAtlas = envMapAtlas && envMapAtlas.destroy();
    this._specularEnvironmentMapAtlas = new OctahedralProjectedCubeMap_default(envMaps);
  } else if (!defined_default(envMaps) && defined_default(envMapAtlas)) {
    envMapAtlas.destroy();
    this._specularEnvironmentMapAtlas = void 0;
  }
  if (defined_default(this._specularEnvironmentMapAtlas)) {
    this._specularEnvironmentMapAtlas.update(frameState);
  }
};
function updateDebugFrustumPlanes(scene) {
  const frameState = scene._frameState;
  if (scene.debugShowFrustumPlanes !== scene._debugShowFrustumPlanes) {
    if (scene.debugShowFrustumPlanes) {
      scene._debugFrustumPlanes = new DebugCameraPrimitive_default({
        camera: scene.camera,
        updateOnChange: false,
        frustumSplits: frameState.frustumSplits
      });
    } else {
      scene._debugFrustumPlanes = scene._debugFrustumPlanes && scene._debugFrustumPlanes.destroy();
    }
    scene._debugShowFrustumPlanes = scene.debugShowFrustumPlanes;
  }
  if (defined_default(scene._debugFrustumPlanes)) {
    scene._debugFrustumPlanes.update(frameState);
  }
}
function updateShadowMaps(scene) {
  const frameState = scene._frameState;
  const shadowMaps = frameState.shadowMaps;
  const length3 = shadowMaps.length;
  const shadowsEnabled = length3 > 0 && !frameState.passes.pick && scene.mode === SceneMode_default.SCENE3D;
  if (shadowsEnabled !== frameState.shadowState.shadowsEnabled) {
    ++frameState.shadowState.lastDirtyTime;
    frameState.shadowState.shadowsEnabled = shadowsEnabled;
  }
  frameState.shadowState.lightShadowsEnabled = false;
  if (!shadowsEnabled) {
    return;
  }
  for (let j = 0; j < length3; ++j) {
    if (shadowMaps[j] !== frameState.shadowState.shadowMaps[j]) {
      ++frameState.shadowState.lastDirtyTime;
      break;
    }
  }
  frameState.shadowState.shadowMaps.length = 0;
  frameState.shadowState.lightShadowMaps.length = 0;
  for (let i2 = 0; i2 < length3; ++i2) {
    const shadowMap = shadowMaps[i2];
    shadowMap.update(frameState);
    frameState.shadowState.shadowMaps.push(shadowMap);
    if (shadowMap.fromLightSource) {
      frameState.shadowState.lightShadowMaps.push(shadowMap);
      frameState.shadowState.lightShadowsEnabled = true;
    }
    if (shadowMap.dirty) {
      ++frameState.shadowState.lastDirtyTime;
      shadowMap.dirty = false;
    }
  }
}
function updateAndRenderPrimitives(scene) {
  const frameState = scene._frameState;
  scene._groundPrimitives.update(frameState);
  scene._primitives.update(frameState);
  updateDebugFrustumPlanes(scene);
  updateShadowMaps(scene);
  if (scene._globe) {
    scene._globe.render(frameState);
  }
}
function updateAndClearFramebuffers(scene, passState, clearColor) {
  const context = scene._context;
  const frameState = scene._frameState;
  const environmentState = scene._environmentState;
  const view = scene._view;
  const passes = scene._frameState.passes;
  const picking = passes.pick;
  if (defined_default(view.globeDepth)) {
    view.globeDepth.picking = picking;
  }
  const useWebVR = environmentState.useWebVR;
  environmentState.originalFramebuffer = passState.framebuffer;
  if (defined_default(scene.sun) && scene.sunBloom !== scene._sunBloom) {
    if (scene.sunBloom && !useWebVR) {
      scene._sunPostProcess = new SunPostProcess_default();
    } else if (defined_default(scene._sunPostProcess)) {
      scene._sunPostProcess = scene._sunPostProcess.destroy();
    }
    scene._sunBloom = scene.sunBloom;
  } else if (!defined_default(scene.sun) && defined_default(scene._sunPostProcess)) {
    scene._sunPostProcess = scene._sunPostProcess.destroy();
    scene._sunBloom = false;
  }
  const clear2 = scene._clearColorCommand;
  Color_default.clone(clearColor, clear2.color);
  clear2.execute(context, passState);
  const useGlobeDepthFramebuffer = environmentState.useGlobeDepthFramebuffer = defined_default(
    view.globeDepth
  );
  if (useGlobeDepthFramebuffer) {
    view.globeDepth.update(
      context,
      passState,
      view.viewport,
      scene.msaaSamples,
      scene._hdr,
      environmentState.clearGlobeDepth
    );
    view.globeDepth.clear(context, passState, clearColor);
  }
  const oit = view.oit;
  const useOIT = environmentState.useOIT = !picking && defined_default(oit) && oit.isSupported();
  if (useOIT) {
    oit.update(
      context,
      passState,
      view.globeDepth.colorFramebufferManager,
      scene._hdr,
      scene.msaaSamples
    );
    oit.clear(context, passState, clearColor);
    environmentState.useOIT = oit.isSupported();
  }
  const postProcess = scene.postProcessStages;
  let usePostProcess = environmentState.usePostProcess = !picking && (scene._hdr || postProcess.length > 0 || postProcess.ambientOcclusion.enabled || postProcess.fxaa.enabled || postProcess.bloom.enabled);
  environmentState.usePostProcessSelected = false;
  if (usePostProcess) {
    view.sceneFramebuffer.update(
      context,
      view.viewport,
      scene._hdr,
      scene.msaaSamples
    );
    view.sceneFramebuffer.clear(context, passState, clearColor);
    postProcess.update(context, frameState.useLogDepth, scene._hdr);
    postProcess.clear(context);
    usePostProcess = environmentState.usePostProcess = postProcess.ready;
    environmentState.usePostProcessSelected = usePostProcess && postProcess.hasSelected;
  }
  if (environmentState.isSunVisible && scene.sunBloom && !useWebVR) {
    passState.framebuffer = scene._sunPostProcess.update(passState);
    scene._sunPostProcess.clear(context, passState, clearColor);
  } else if (useGlobeDepthFramebuffer) {
    passState.framebuffer = view.globeDepth.framebuffer;
  } else if (usePostProcess) {
    passState.framebuffer = view.sceneFramebuffer.framebuffer;
  }
  if (defined_default(passState.framebuffer)) {
    clear2.execute(context, passState);
  }
  const useInvertClassification = environmentState.useInvertClassification = !picking && defined_default(passState.framebuffer) && scene.invertClassification;
  if (useInvertClassification) {
    let depthFramebuffer;
    if (scene.frameState.invertClassificationColor.alpha === 1) {
      if (environmentState.useGlobeDepthFramebuffer) {
        depthFramebuffer = view.globeDepth.framebuffer;
      }
    }
    if (defined_default(depthFramebuffer) || context.depthTexture) {
      scene._invertClassification.previousFramebuffer = depthFramebuffer;
      scene._invertClassification.update(
        context,
        scene.msaaSamples,
        view.globeDepth.colorFramebufferManager
      );
      scene._invertClassification.clear(context, passState);
      if (scene.frameState.invertClassificationColor.alpha < 1 && useOIT) {
        const command = scene._invertClassification.unclassifiedCommand;
        const derivedCommands = command.derivedCommands;
        derivedCommands.oit = oit.createDerivedCommands(
          command,
          context,
          derivedCommands.oit
        );
      }
    } else {
      environmentState.useInvertClassification = false;
    }
  }
  if (scene._globeTranslucencyState.translucent) {
    view.globeTranslucencyFramebuffer.updateAndClear(
      scene._hdr,
      view.viewport,
      context,
      passState
    );
  }
}
Scene4.prototype.resolveFramebuffers = function(passState) {
  const context = this._context;
  const environmentState = this._environmentState;
  const view = this._view;
  const globeDepth = view.globeDepth;
  if (defined_default(globeDepth)) {
    globeDepth.prepareColorTextures(context);
  }
  const useOIT = environmentState.useOIT;
  const useGlobeDepthFramebuffer = environmentState.useGlobeDepthFramebuffer;
  const usePostProcess = environmentState.usePostProcess;
  const defaultFramebuffer = environmentState.originalFramebuffer;
  const globeFramebuffer = useGlobeDepthFramebuffer ? globeDepth.colorFramebufferManager : void 0;
  const sceneFramebuffer = view.sceneFramebuffer._colorFramebuffer;
  const idFramebuffer = view.sceneFramebuffer.idFramebuffer;
  if (useOIT) {
    passState.framebuffer = usePostProcess ? sceneFramebuffer.framebuffer : defaultFramebuffer;
    view.oit.execute(context, passState);
  }
  const translucentTileClassification = view.translucentTileClassification;
  if (translucentTileClassification.hasTranslucentDepth && translucentTileClassification.isSupported()) {
    translucentTileClassification.execute(this, passState);
  }
  if (usePostProcess) {
    view.sceneFramebuffer.prepareColorTextures(context);
    let inputFramebuffer = sceneFramebuffer;
    if (useGlobeDepthFramebuffer && !useOIT) {
      inputFramebuffer = globeFramebuffer;
    }
    const postProcess = this.postProcessStages;
    const colorTexture = inputFramebuffer.getColorTexture(0);
    const idTexture = idFramebuffer.getColorTexture(0);
    const depthTexture = defaultValue_default(
      globeFramebuffer,
      sceneFramebuffer
    ).getDepthStencilTexture();
    postProcess.execute(context, colorTexture, depthTexture, idTexture);
    postProcess.copy(context, defaultFramebuffer);
  }
  if (!useOIT && !usePostProcess && useGlobeDepthFramebuffer) {
    passState.framebuffer = defaultFramebuffer;
    globeDepth.executeCopyColor(context, passState);
  }
};
function callAfterRenderFunctions(scene) {
  const functions = scene._frameState.afterRender;
  for (let i2 = 0, length3 = functions.length; i2 < length3; ++i2) {
    functions[i2]();
    scene.requestRender();
  }
  functions.length = 0;
}
function getGlobeHeight(scene) {
  const globe = scene._globe;
  const camera = scene.camera;
  const cartographic2 = camera.positionCartographic;
  if (defined_default(globe) && globe.show && defined_default(cartographic2)) {
    return globe.getHeight(cartographic2);
  }
  return void 0;
}
function isCameraUnderground(scene) {
  const camera = scene.camera;
  const mode2 = scene._mode;
  const globe = scene.globe;
  const cameraController = scene._screenSpaceCameraController;
  const cartographic2 = camera.positionCartographic;
  if (!defined_default(cartographic2)) {
    return false;
  }
  if (!cameraController.onMap() && cartographic2.height < 0) {
    return true;
  }
  if (!defined_default(globe) || !globe.show || mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.MORPHING) {
    return false;
  }
  const globeHeight = scene._globeHeight;
  return defined_default(globeHeight) && cartographic2.height < globeHeight;
}
Scene4.prototype.initializeFrame = function() {
  if (this._shaderFrameCount++ === 120) {
    this._shaderFrameCount = 0;
    this._context.shaderCache.destroyReleasedShaderPrograms();
    this._context.textureCache.destroyReleasedTextures();
  }
  this._tweens.update();
  this._globeHeight = getGlobeHeight(this);
  this._cameraUnderground = isCameraUnderground(this);
  this._globeTranslucencyState.update(this);
  this._screenSpaceCameraController.update();
  if (defined_default(this._deviceOrientationCameraController)) {
    this._deviceOrientationCameraController.update();
  }
  this.camera.update(this._mode);
  this.camera._updateCameraChanged();
};
function updateDebugShowFramesPerSecond(scene, renderedThisFrame) {
  if (scene.debugShowFramesPerSecond) {
    if (!defined_default(scene._performanceDisplay)) {
      const performanceContainer = document.createElement("div");
      performanceContainer.className = "cesium-performanceDisplay-defaultContainer";
      const container = scene._canvas.parentNode;
      container.appendChild(performanceContainer);
      const performanceDisplay = new PerformanceDisplay_default({
        container: performanceContainer
      });
      scene._performanceDisplay = performanceDisplay;
      scene._performanceContainer = performanceContainer;
    }
    scene._performanceDisplay.throttled = scene.requestRenderMode;
    scene._performanceDisplay.update(renderedThisFrame);
  } else if (defined_default(scene._performanceDisplay)) {
    scene._performanceDisplay = scene._performanceDisplay && scene._performanceDisplay.destroy();
    scene._performanceContainer.parentNode.removeChild(
      scene._performanceContainer
    );
  }
}
function prePassesUpdate(scene) {
  scene._jobScheduler.resetBudgets();
  const frameState = scene._frameState;
  const primitives = scene.primitives;
  primitives.prePassesUpdate(frameState);
  if (defined_default(scene.globe)) {
    scene.globe.update(frameState);
  }
  scene._picking.update();
  frameState.creditDisplay.update();
}
function postPassesUpdate(scene) {
  const frameState = scene._frameState;
  const primitives = scene.primitives;
  primitives.postPassesUpdate(frameState);
  RequestScheduler_default.update();
}
var scratchBackgroundColor = new Color_default();
function render(scene) {
  const frameState = scene._frameState;
  const context = scene.context;
  const us = context.uniformState;
  const view = scene._defaultView;
  scene._view = view;
  scene.updateFrameState();
  frameState.passes.render = true;
  frameState.passes.postProcess = scene.postProcessStages.hasSelected;
  frameState.tilesetPassState = renderTilesetPassState;
  let backgroundColor = defaultValue_default(scene.backgroundColor, Color_default.BLACK);
  if (scene._hdr) {
    backgroundColor = Color_default.clone(backgroundColor, scratchBackgroundColor);
    backgroundColor.red = Math.pow(backgroundColor.red, scene.gamma);
    backgroundColor.green = Math.pow(backgroundColor.green, scene.gamma);
    backgroundColor.blue = Math.pow(backgroundColor.blue, scene.gamma);
  }
  frameState.backgroundColor = backgroundColor;
  scene.fog.update(frameState);
  us.update(frameState);
  const shadowMap = scene.shadowMap;
  if (defined_default(shadowMap) && shadowMap.enabled) {
    if (!defined_default(scene.light) || scene.light instanceof SunLight_default) {
      Cartesian3_default.negate(us.sunDirectionWC, scene._shadowMapCamera.direction);
    } else {
      Cartesian3_default.clone(scene.light.direction, scene._shadowMapCamera.direction);
    }
    frameState.shadowMaps.push(shadowMap);
  }
  scene._computeCommandList.length = 0;
  scene._overlayCommandList.length = 0;
  const viewport = view.viewport;
  viewport.x = 0;
  viewport.y = 0;
  viewport.width = context.drawingBufferWidth;
  viewport.height = context.drawingBufferHeight;
  const passState = view.passState;
  passState.framebuffer = void 0;
  passState.blendingEnabled = void 0;
  passState.scissorTest = void 0;
  passState.viewport = BoundingRectangle_default.clone(viewport, passState.viewport);
  if (defined_default(scene.globe)) {
    scene.globe.beginFrame(frameState);
  }
  scene.updateEnvironment();
  scene.updateAndExecuteCommands(passState, backgroundColor);
  scene.resolveFramebuffers(passState);
  passState.framebuffer = void 0;
  executeOverlayCommands(scene, passState);
  if (defined_default(scene.globe)) {
    scene.globe.endFrame(frameState);
    if (!scene.globe.tilesLoaded) {
      scene._renderRequested = true;
    }
  }
  context.endFrame();
}
function tryAndCatchError(scene, functionToExecute) {
  try {
    functionToExecute(scene);
  } catch (error) {
    scene._renderError.raiseEvent(scene, error);
    if (scene.rethrowRenderErrors) {
      throw error;
    }
  }
}
function updateMostDetailedRayPicks(scene) {
  return scene._picking.updateMostDetailedRayPicks(scene);
}
Scene4.prototype.render = function(time) {
  this._preUpdate.raiseEvent(this, time);
  const frameState = this._frameState;
  frameState.newFrame = false;
  if (!defined_default(time)) {
    time = JulianDate_default.now();
  }
  const cameraChanged = this._view.checkForCameraUpdates(this);
  let shouldRender = !this.requestRenderMode || this._renderRequested || cameraChanged || this._logDepthBufferDirty || this._hdrDirty || this.mode === SceneMode_default.MORPHING;
  if (!shouldRender && defined_default(this.maximumRenderTimeChange) && defined_default(this._lastRenderTime)) {
    const difference = Math.abs(
      JulianDate_default.secondsDifference(this._lastRenderTime, time)
    );
    shouldRender = shouldRender || difference > this.maximumRenderTimeChange;
  }
  if (shouldRender) {
    this._lastRenderTime = JulianDate_default.clone(time, this._lastRenderTime);
    this._renderRequested = false;
    this._logDepthBufferDirty = false;
    this._hdrDirty = false;
    const frameNumber = Math_default.incrementWrap(
      frameState.frameNumber,
      15e6,
      1
    );
    updateFrameNumber(this, frameNumber, time);
    frameState.newFrame = true;
  }
  tryAndCatchError(this, prePassesUpdate);
  if (this.primitives.show) {
    tryAndCatchError(this, updateMostDetailedRayPicks);
    tryAndCatchError(this, updatePreloadPass);
    tryAndCatchError(this, updatePreloadFlightPass);
    if (!shouldRender) {
      tryAndCatchError(this, updateRequestRenderModeDeferCheckPass);
    }
  }
  this._postUpdate.raiseEvent(this, time);
  if (shouldRender) {
    this._preRender.raiseEvent(this, time);
    frameState.creditDisplay.beginFrame();
    tryAndCatchError(this, render);
  }
  updateDebugShowFramesPerSecond(this, shouldRender);
  tryAndCatchError(this, postPassesUpdate);
  callAfterRenderFunctions(this);
  if (shouldRender) {
    this._postRender.raiseEvent(this, time);
    frameState.creditDisplay.endFrame();
  }
};
Scene4.prototype.forceRender = function(time) {
  this._renderRequested = true;
  this.render(time);
};
Scene4.prototype.requestRender = function() {
  this._renderRequested = true;
};
Scene4.prototype.clampLineWidth = function(width) {
  return Math.max(
    ContextLimits_default.minimumAliasedLineWidth,
    Math.min(width, ContextLimits_default.maximumAliasedLineWidth)
  );
};
Scene4.prototype.pick = function(windowPosition, width, height) {
  return this._picking.pick(this, windowPosition, width, height);
};
Scene4.prototype.pickPositionWorldCoordinates = function(windowPosition, result) {
  return this._picking.pickPositionWorldCoordinates(
    this,
    windowPosition,
    result
  );
};
Scene4.prototype.pickPosition = function(windowPosition, result) {
  return this._picking.pickPosition(this, windowPosition, result);
};
Scene4.prototype.drillPick = function(windowPosition, limit, width, height) {
  return this._picking.drillPick(this, windowPosition, limit, width, height);
};
function updatePreloadPass(scene) {
  const frameState = scene._frameState;
  preloadTilesetPassState.camera = frameState.camera;
  preloadTilesetPassState.cullingVolume = frameState.cullingVolume;
  const primitives = scene.primitives;
  primitives.updateForPass(frameState, preloadTilesetPassState);
}
function updatePreloadFlightPass(scene) {
  const frameState = scene._frameState;
  const camera = frameState.camera;
  if (!camera.canPreloadFlight()) {
    return;
  }
  preloadFlightTilesetPassState.camera = scene.preloadFlightCamera;
  preloadFlightTilesetPassState.cullingVolume = scene.preloadFlightCullingVolume;
  const primitives = scene.primitives;
  primitives.updateForPass(frameState, preloadFlightTilesetPassState);
}
function updateRequestRenderModeDeferCheckPass(scene) {
  scene.primitives.updateForPass(
    scene._frameState,
    requestRenderModeDeferCheckPassState
  );
}
Scene4.prototype.pickFromRay = function(ray, objectsToExclude, width) {
  return this._picking.pickFromRay(this, ray, objectsToExclude, width);
};
Scene4.prototype.drillPickFromRay = function(ray, limit, objectsToExclude, width) {
  return this._picking.drillPickFromRay(
    this,
    ray,
    limit,
    objectsToExclude,
    width
  );
};
Scene4.prototype.pickFromRayMostDetailed = function(ray, objectsToExclude, width) {
  return this._picking.pickFromRayMostDetailed(
    this,
    ray,
    objectsToExclude,
    width
  );
};
Scene4.prototype.drillPickFromRayMostDetailed = function(ray, limit, objectsToExclude, width) {
  return this._picking.drillPickFromRayMostDetailed(
    this,
    ray,
    limit,
    objectsToExclude,
    width
  );
};
Scene4.prototype.sampleHeight = function(position, objectsToExclude, width) {
  return this._picking.sampleHeight(this, position, objectsToExclude, width);
};
Scene4.prototype.clampToHeight = function(cartesian11, objectsToExclude, width, result) {
  return this._picking.clampToHeight(
    this,
    cartesian11,
    objectsToExclude,
    width,
    result
  );
};
Scene4.prototype.sampleHeightMostDetailed = function(positions, objectsToExclude, width) {
  return this._picking.sampleHeightMostDetailed(
    this,
    positions,
    objectsToExclude,
    width
  );
};
Scene4.prototype.clampToHeightMostDetailed = function(cartesians, objectsToExclude, width) {
  return this._picking.clampToHeightMostDetailed(
    this,
    cartesians,
    objectsToExclude,
    width
  );
};
Scene4.prototype.cartesianToCanvasCoordinates = function(position, result) {
  return SceneTransforms_default.wgs84ToWindowCoordinates(this, position, result);
};
Scene4.prototype.completeMorph = function() {
  this._transitioner.completeMorph();
};
Scene4.prototype.morphTo2D = function(duration) {
  let ellipsoid;
  const globe = this.globe;
  if (defined_default(globe)) {
    ellipsoid = globe.ellipsoid;
  } else {
    ellipsoid = this.mapProjection.ellipsoid;
  }
  duration = defaultValue_default(duration, 2);
  this._transitioner.morphTo2D(duration, ellipsoid);
};
Scene4.prototype.morphToColumbusView = function(duration) {
  let ellipsoid;
  const globe = this.globe;
  if (defined_default(globe)) {
    ellipsoid = globe.ellipsoid;
  } else {
    ellipsoid = this.mapProjection.ellipsoid;
  }
  duration = defaultValue_default(duration, 2);
  this._transitioner.morphToColumbusView(duration, ellipsoid);
};
Scene4.prototype.morphTo3D = function(duration) {
  let ellipsoid;
  const globe = this.globe;
  if (defined_default(globe)) {
    ellipsoid = globe.ellipsoid;
  } else {
    ellipsoid = this.mapProjection.ellipsoid;
  }
  duration = defaultValue_default(duration, 2);
  this._transitioner.morphTo3D(duration, ellipsoid);
};
Scene4.prototype.isDestroyed = function() {
  return false;
};
Scene4.prototype.destroy = function() {
  this._tweens.removeAll();
  this._computeEngine = this._computeEngine && this._computeEngine.destroy();
  this._screenSpaceCameraController = this._screenSpaceCameraController && this._screenSpaceCameraController.destroy();
  this._deviceOrientationCameraController = this._deviceOrientationCameraController && !this._deviceOrientationCameraController.isDestroyed() && this._deviceOrientationCameraController.destroy();
  this._primitives = this._primitives && this._primitives.destroy();
  this._groundPrimitives = this._groundPrimitives && this._groundPrimitives.destroy();
  this._globe = this._globe && this._globe.destroy();
  this.skyBox = this.skyBox && this.skyBox.destroy();
  this.skyAtmosphere = this.skyAtmosphere && this.skyAtmosphere.destroy();
  this._debugSphere = this._debugSphere && this._debugSphere.destroy();
  this.sun = this.sun && this.sun.destroy();
  this._sunPostProcess = this._sunPostProcess && this._sunPostProcess.destroy();
  this._depthPlane = this._depthPlane && this._depthPlane.destroy();
  this._transitioner = this._transitioner && this._transitioner.destroy();
  this._debugFrustumPlanes = this._debugFrustumPlanes && this._debugFrustumPlanes.destroy();
  this._brdfLutGenerator = this._brdfLutGenerator && this._brdfLutGenerator.destroy();
  this._picking = this._picking && this._picking.destroy();
  this._defaultView = this._defaultView && this._defaultView.destroy();
  this._view = void 0;
  if (this._removeCreditContainer) {
    this._canvas.parentNode.removeChild(this._creditContainer);
  }
  this.postProcessStages = this.postProcessStages && this.postProcessStages.destroy();
  this._context = this._context && this._context.destroy();
  this._frameState.creditDisplay = this._frameState.creditDisplay && this._frameState.creditDisplay.destroy();
  if (defined_default(this._performanceDisplay)) {
    this._performanceDisplay = this._performanceDisplay && this._performanceDisplay.destroy();
    this._performanceContainer.parentNode.removeChild(
      this._performanceContainer
    );
  }
  this._removeRequestListenerCallback();
  this._removeTaskProcessorListenerCallback();
  for (let i2 = 0; i2 < this._removeGlobeCallbacks.length; ++i2) {
    this._removeGlobeCallbacks[i2]();
  }
  this._removeGlobeCallbacks.length = 0;
  return destroyObject_default(this);
};
var Scene_default = Scene4;

// node_modules/cesium/Source/Shaders/SkyAtmosphereCommon.js
var SkyAtmosphereCommon_default = "float interpolateByDistance(vec4 nearFarScalar, float distance)\n{\n    float startDistance = nearFarScalar.x;\n    float startValue = nearFarScalar.y;\n    float endDistance = nearFarScalar.z;\n    float endValue = nearFarScalar.w;\n    float t = clamp((distance - startDistance) / (endDistance - startDistance), 0.0, 1.0);\n    return mix(startValue, endValue, t);\n}\n\nvec3 getLightDirection(vec3 positionWC)\n{\n    float lightEnum = u_radiiAndDynamicAtmosphereColor.z;\n    vec3 lightDirection =\n        positionWC * float(lightEnum == 0.0) +\n        czm_lightDirectionWC * float(lightEnum == 1.0) +\n        czm_sunDirectionWC * float(lightEnum == 2.0);\n    return normalize(lightDirection);\n}\n\nvoid computeAtmosphereScattering(vec3 positionWC, vec3 lightDirection, out vec3 rayleighColor, out vec3 mieColor, out float opacity, out float underTranslucentGlobe)\n{\n    float ellipsoidRadiiDifference = czm_ellipsoidRadii.x - czm_ellipsoidRadii.z;\n\n    // Adjustment to the atmosphere radius applied based on the camera height.\n    float distanceAdjustMin = czm_ellipsoidRadii.x / 4.0;\n    float distanceAdjustMax = czm_ellipsoidRadii.x;\n    float distanceAdjustModifier = ellipsoidRadiiDifference / 2.0;\n    float distanceAdjust = distanceAdjustModifier * clamp((czm_eyeHeight - distanceAdjustMin) / (distanceAdjustMax - distanceAdjustMin), 0.0, 1.0);\n\n    // Since atmosphere scattering assumes the atmosphere is a spherical shell, we compute an inner radius of the atmosphere best fit \n    // for the position on the ellipsoid.\n    float radiusAdjust = (ellipsoidRadiiDifference / 4.0) + distanceAdjust;\n    float atmosphereInnerRadius = (length(czm_viewerPositionWC) - czm_eyeHeight) - radiusAdjust;\n\n    // Setup the primary ray: from the camera position to the vertex position.\n    vec3 cameraToPositionWC = positionWC - czm_viewerPositionWC;\n    vec3 cameraToPositionWCDirection = normalize(cameraToPositionWC);\n    czm_ray primaryRay = czm_ray(czm_viewerPositionWC, cameraToPositionWCDirection);\n\n    underTranslucentGlobe = 0.0;\n\n    // Brighten the sky atmosphere under the Earth's atmosphere when translucency is enabled.\n    #if defined(GLOBE_TRANSLUCENT)\n\n        // Check for intersection with the inner radius of the atmopshere.\n        czm_raySegment primaryRayEarthIntersect = czm_raySphereIntersectionInterval(primaryRay, vec3(0.0), atmosphereInnerRadius + radiusAdjust);\n        if (primaryRayEarthIntersect.start > 0.0 && primaryRayEarthIntersect.stop > 0.0) {\n            \n            // Compute position on globe.\n            vec3 direction = normalize(positionWC);\n            czm_ray ellipsoidRay = czm_ray(positionWC, -direction);\n            czm_raySegment ellipsoidIntersection = czm_rayEllipsoidIntersectionInterval(ellipsoidRay, vec3(0.0), czm_ellipsoidInverseRadii);\n            vec3 onEarth = positionWC - (direction * ellipsoidIntersection.start);\n\n            // Control the color using the camera angle.\n            float angle = dot(normalize(czm_viewerPositionWC), normalize(onEarth));\n\n            // Control the opacity using the distance from Earth.\n            opacity = interpolateByDistance(vec4(0.0, 1.0, czm_ellipsoidRadii.x, 0.0), length(czm_viewerPositionWC - onEarth));\n            vec3 horizonColor = vec3(0.1, 0.2, 0.3);\n            vec3 nearColor = vec3(0.0);\n\n            rayleighColor = mix(nearColor, horizonColor, exp(-angle) * opacity);\n            \n            // Set the traslucent flag to avoid alpha adjustment in computeFinalColor funciton.\n            underTranslucentGlobe = 1.0;\n            return;\n        }\n    #endif\n\n    computeScattering(\n        primaryRay,\n        length(cameraToPositionWC),\n        lightDirection,\n        atmosphereInnerRadius,\n        rayleighColor,\n        mieColor,\n        opacity\n    );\n\n    // Alter the opacity based on how close the viewer is to the ground.\n    // (0.0 = At edge of atmosphere, 1.0 = On ground)\n    float cameraHeight = czm_eyeHeight + atmosphereInnerRadius;\n    float atmosphereOuterRadius = atmosphereInnerRadius + ATMOSPHERE_THICKNESS;\n    opacity = clamp((atmosphereOuterRadius - cameraHeight) / (atmosphereOuterRadius - atmosphereInnerRadius), 0.0, 1.0);\n\n    // Alter alpha based on time of day (0.0 = night , 1.0 = day)\n    float nightAlpha = (u_radiiAndDynamicAtmosphereColor.z != 0.0) ? clamp(dot(normalize(positionWC), lightDirection), 0.0, 1.0) : 1.0;\n    opacity *= pow(nightAlpha, 0.5);\n}\n";

// node_modules/cesium/Source/Shaders/SkyAtmosphereFS.js
var SkyAtmosphereFS_default = "varying vec3 v_outerPositionWC;\n\nuniform vec3 u_hsbShift;\n\n#ifndef PER_FRAGMENT_ATMOSPHERE\nvarying vec3 v_mieColor;\nvarying vec3 v_rayleighColor;\nvarying float v_opacity;\nvarying float v_translucent;\n#endif\n\nvoid main (void)\n{\n    vec3 lightDirection = getLightDirection(v_outerPositionWC);\n   \n    vec3 mieColor;\n    vec3 rayleighColor;\n    float opacity;\n    float translucent;\n\n    #ifdef PER_FRAGMENT_ATMOSPHERE\n        computeAtmosphereScattering(\n            v_outerPositionWC,\n            lightDirection,\n            rayleighColor,\n            mieColor,\n            opacity,\n            translucent\n        );\n    #else\n        mieColor = v_mieColor;\n        rayleighColor = v_rayleighColor;\n        opacity = v_opacity;\n        translucent = v_translucent;\n    #endif\n\n    vec4 color = computeAtmosphereColor(v_outerPositionWC, lightDirection, rayleighColor, mieColor, opacity);\n\n    #ifndef HDR\n        color.rgb = czm_acesTonemapping(color.rgb);\n        color.rgb = czm_inverseGamma(color.rgb);\n    #endif\n\n    #ifdef COLOR_CORRECT\n        // Convert rgb color to hsb\n        vec3 hsb = czm_RGBToHSB(color.rgb);\n        // Perform hsb shift\n        hsb.x += u_hsbShift.x; // hue\n        hsb.y = clamp(hsb.y + u_hsbShift.y, 0.0, 1.0); // saturation\n        hsb.z = hsb.z > czm_epsilon7 ? hsb.z + u_hsbShift.z : 0.0; // brightness\n        // Convert shifted hsb back to rgb\n        color.rgb = czm_HSBToRGB(hsb);\n    #endif\n\n    // For the parts of the sky atmosphere that are not behind a translucent globe,\n    // we mix in the default opacity so that the sky atmosphere still appears at distance.\n    // This is needed because the opacity in the sky atmosphere is initially adjusted based\n    // on the camera height.\n    if (translucent == 0.0) {\n        color.a = mix(color.b, 1.0, color.a) * smoothstep(0.0, 1.0, czm_morphTime);\n    }\n\n    gl_FragColor = color;\n}\n";

// node_modules/cesium/Source/Shaders/SkyAtmosphereVS.js
var SkyAtmosphereVS_default = "attribute vec4 position;\n\nvarying vec3 v_outerPositionWC;\n\n#ifndef PER_FRAGMENT_ATMOSPHERE\nvarying vec3 v_mieColor;\nvarying vec3 v_rayleighColor;\nvarying float v_opacity;\nvarying float v_translucent;\n#endif\n\nvoid main(void)\n{\n    vec4 positionWC = czm_model * position;\n    vec3 lightDirection = getLightDirection(positionWC.xyz);\n\n    #ifndef PER_FRAGMENT_ATMOSPHERE\n        computeAtmosphereScattering(\n            positionWC.xyz,\n            lightDirection,\n            v_rayleighColor,\n            v_mieColor,\n            v_opacity,\n            v_translucent\n        );\n    #endif\n    \n    v_outerPositionWC = positionWC.xyz;\n    gl_Position = czm_modelViewProjection * position;\n}\n";

// node_modules/cesium/Source/Scene/SkyAtmosphere.js
function SkyAtmosphere(ellipsoid) {
  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.WGS84);
  this.show = true;
  this.perFragmentAtmosphere = false;
  this._ellipsoid = ellipsoid;
  const outerEllipsoidScale = 1.025;
  const scaleVector = Cartesian3_default.multiplyByScalar(
    ellipsoid.radii,
    outerEllipsoidScale,
    new Cartesian3_default()
  );
  this._scaleMatrix = Matrix4_default.fromScale(scaleVector);
  this._modelMatrix = new Matrix4_default();
  this._command = new DrawCommand_default({
    owner: this,
    modelMatrix: this._modelMatrix
  });
  this._spSkyFromSpace = void 0;
  this._spSkyFromAtmosphere = void 0;
  this._flags = void 0;
  this.atmosphereLightIntensity = 50;
  this.atmosphereRayleighCoefficient = new Cartesian3_default(55e-7, 13e-6, 284e-7);
  this.atmosphereMieCoefficient = new Cartesian3_default(21e-6, 21e-6, 21e-6);
  this.atmosphereRayleighScaleHeight = 1e4;
  this.atmosphereMieScaleHeight = 3200;
  this.atmosphereMieAnisotropy = 0.9;
  this.hueShift = 0;
  this.saturationShift = 0;
  this.brightnessShift = 0;
  this._hueSaturationBrightness = new Cartesian3_default();
  const radiiAndDynamicAtmosphereColor = new Cartesian3_default();
  radiiAndDynamicAtmosphereColor.x = ellipsoid.maximumRadius * outerEllipsoidScale;
  radiiAndDynamicAtmosphereColor.y = ellipsoid.maximumRadius;
  radiiAndDynamicAtmosphereColor.z = 0;
  this._radiiAndDynamicAtmosphereColor = radiiAndDynamicAtmosphereColor;
  const that = this;
  this._command.uniformMap = {
    u_radiiAndDynamicAtmosphereColor: function() {
      return that._radiiAndDynamicAtmosphereColor;
    },
    u_hsbShift: function() {
      that._hueSaturationBrightness.x = that.hueShift;
      that._hueSaturationBrightness.y = that.saturationShift;
      that._hueSaturationBrightness.z = that.brightnessShift;
      return that._hueSaturationBrightness;
    },
    u_atmosphereLightIntensity: function() {
      return that.atmosphereLightIntensity;
    },
    u_atmosphereRayleighCoefficient: function() {
      return that.atmosphereRayleighCoefficient;
    },
    u_atmosphereMieCoefficient: function() {
      return that.atmosphereMieCoefficient;
    },
    u_atmosphereRayleighScaleHeight: function() {
      return that.atmosphereRayleighScaleHeight;
    },
    u_atmosphereMieScaleHeight: function() {
      return that.atmosphereMieScaleHeight;
    },
    u_atmosphereMieAnisotropy: function() {
      return that.atmosphereMieAnisotropy;
    }
  };
}
Object.defineProperties(SkyAtmosphere.prototype, {
  ellipsoid: {
    get: function() {
      return this._ellipsoid;
    }
  }
});
SkyAtmosphere.prototype.setDynamicAtmosphereColor = function(enableLighting, useSunDirection) {
  const lightEnum = enableLighting ? useSunDirection ? 2 : 1 : 0;
  this._radiiAndDynamicAtmosphereColor.z = lightEnum;
};
var scratchModelMatrix = new Matrix4_default();
SkyAtmosphere.prototype.update = function(frameState, globe) {
  if (!this.show) {
    return void 0;
  }
  const mode2 = frameState.mode;
  if (mode2 !== SceneMode_default.SCENE3D && mode2 !== SceneMode_default.MORPHING) {
    return void 0;
  }
  if (!frameState.passes.render) {
    return void 0;
  }
  const rotationMatrix = Matrix4_default.fromRotationTranslation(
    frameState.context.uniformState.inverseViewRotation,
    Cartesian3_default.ZERO,
    scratchModelMatrix
  );
  const rotationOffsetMatrix = Matrix4_default.multiplyTransformation(
    rotationMatrix,
    Axis_default.Y_UP_TO_Z_UP,
    scratchModelMatrix
  );
  const modelMatrix = Matrix4_default.multiply(
    this._scaleMatrix,
    rotationOffsetMatrix,
    scratchModelMatrix
  );
  Matrix4_default.clone(modelMatrix, this._modelMatrix);
  const context = frameState.context;
  const colorCorrect = hasColorCorrection(this);
  const translucent = frameState.globeTranslucencyState.translucent;
  const perFragmentAtmosphere = this.perFragmentAtmosphere || translucent || !defined_default(globe) || !globe.show;
  const command = this._command;
  if (!defined_default(command.vertexArray)) {
    const geometry = EllipsoidGeometry_default.createGeometry(
      new EllipsoidGeometry_default({
        radii: new Cartesian3_default(1, 1, 1),
        slicePartitions: 256,
        stackPartitions: 256,
        vertexFormat: VertexFormat_default.POSITION_ONLY
      })
    );
    command.vertexArray = VertexArray_default.fromGeometry({
      context,
      geometry,
      attributeLocations: GeometryPipeline_default.createAttributeLocations(geometry),
      bufferUsage: BufferUsage_default.STATIC_DRAW
    });
    command.renderState = RenderState_default.fromCache({
      cull: {
        enabled: true,
        face: CullFace_default.FRONT
      },
      blending: BlendingState_default.ALPHA_BLEND,
      depthMask: false
    });
  }
  const flags = colorCorrect | perFragmentAtmosphere << 2 | translucent << 3;
  if (flags !== this._flags) {
    this._flags = flags;
    const defines = [];
    if (colorCorrect) {
      defines.push("COLOR_CORRECT");
    }
    if (perFragmentAtmosphere) {
      defines.push("PER_FRAGMENT_ATMOSPHERE");
    }
    if (translucent) {
      defines.push("GLOBE_TRANSLUCENT");
    }
    const vs = new ShaderSource_default({
      defines,
      sources: [AtmosphereCommon_default, SkyAtmosphereCommon_default, SkyAtmosphereVS_default]
    });
    const fs = new ShaderSource_default({
      defines,
      sources: [AtmosphereCommon_default, SkyAtmosphereCommon_default, SkyAtmosphereFS_default]
    });
    this._spSkyAtmosphere = ShaderProgram_default.fromCache({
      context,
      vertexShaderSource: vs,
      fragmentShaderSource: fs
    });
    command.shaderProgram = this._spSkyAtmosphere;
  }
  return command;
};
function hasColorCorrection(skyAtmosphere) {
  return !(Math_default.equalsEpsilon(
    skyAtmosphere.hueShift,
    0,
    Math_default.EPSILON7
  ) && Math_default.equalsEpsilon(
    skyAtmosphere.saturationShift,
    0,
    Math_default.EPSILON7
  ) && Math_default.equalsEpsilon(
    skyAtmosphere.brightnessShift,
    0,
    Math_default.EPSILON7
  ));
}
SkyAtmosphere.prototype.isDestroyed = function() {
  return false;
};
SkyAtmosphere.prototype.destroy = function() {
  const command = this._command;
  command.vertexArray = command.vertexArray && command.vertexArray.destroy();
  this._spSkyAtmosphere = this._spSkyAtmosphere && this._spSkyAtmosphere.destroy();
  return destroyObject_default(this);
};
var SkyAtmosphere_default = SkyAtmosphere;

// node_modules/cesium/Source/Shaders/SkyBoxFS.js
var SkyBoxFS_default = "uniform samplerCube u_cubeMap;\n\nvarying vec3 v_texCoord;\n\nvoid main()\n{\n    vec4 color = textureCube(u_cubeMap, normalize(v_texCoord));\n    gl_FragColor = vec4(czm_gammaCorrect(color).rgb, czm_morphTime);\n}\n";

// node_modules/cesium/Source/Shaders/SkyBoxVS.js
var SkyBoxVS_default = "attribute vec3 position;\n\nvarying vec3 v_texCoord;\n\nvoid main()\n{\n    vec3 p = czm_viewRotation * (czm_temeToPseudoFixed * (czm_entireFrustum.y * position));\n    gl_Position = czm_projection * vec4(p, 1.0);\n    v_texCoord = position.xyz;\n}\n";

// node_modules/cesium/Source/Scene/SkyBox.js
function SkyBox(options) {
  this.sources = options.sources;
  this._sources = void 0;
  this.show = defaultValue_default(options.show, true);
  this._command = new DrawCommand_default({
    modelMatrix: Matrix4_default.clone(Matrix4_default.IDENTITY),
    owner: this
  });
  this._cubeMap = void 0;
  this._attributeLocations = void 0;
  this._useHdr = void 0;
}
SkyBox.prototype.update = function(frameState, useHdr) {
  const that = this;
  if (!this.show) {
    return void 0;
  }
  if (frameState.mode !== SceneMode_default.SCENE3D && frameState.mode !== SceneMode_default.MORPHING) {
    return void 0;
  }
  if (!frameState.passes.render) {
    return void 0;
  }
  const context = frameState.context;
  if (this._sources !== this.sources) {
    this._sources = this.sources;
    const sources = this.sources;
    if (!defined_default(sources.positiveX) || !defined_default(sources.negativeX) || !defined_default(sources.positiveY) || !defined_default(sources.negativeY) || !defined_default(sources.positiveZ) || !defined_default(sources.negativeZ)) {
      throw new DeveloperError_default(
        "this.sources is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties."
      );
    }
    if (typeof sources.positiveX !== typeof sources.negativeX || typeof sources.positiveX !== typeof sources.positiveY || typeof sources.positiveX !== typeof sources.negativeY || typeof sources.positiveX !== typeof sources.positiveZ || typeof sources.positiveX !== typeof sources.negativeZ) {
      throw new DeveloperError_default(
        "this.sources properties must all be the same type."
      );
    }
    if (typeof sources.positiveX === "string") {
      loadCubeMap_default(context, this._sources).then(function(cubeMap) {
        that._cubeMap = that._cubeMap && that._cubeMap.destroy();
        that._cubeMap = cubeMap;
      });
    } else {
      this._cubeMap = this._cubeMap && this._cubeMap.destroy();
      this._cubeMap = new CubeMap_default({
        context,
        source: sources
      });
    }
  }
  const command = this._command;
  if (!defined_default(command.vertexArray)) {
    command.uniformMap = {
      u_cubeMap: function() {
        return that._cubeMap;
      }
    };
    const geometry = BoxGeometry_default.createGeometry(
      BoxGeometry_default.fromDimensions({
        dimensions: new Cartesian3_default(2, 2, 2),
        vertexFormat: VertexFormat_default.POSITION_ONLY
      })
    );
    const attributeLocations8 = this._attributeLocations = GeometryPipeline_default.createAttributeLocations(
      geometry
    );
    command.vertexArray = VertexArray_default.fromGeometry({
      context,
      geometry,
      attributeLocations: attributeLocations8,
      bufferUsage: BufferUsage_default.STATIC_DRAW
    });
    command.renderState = RenderState_default.fromCache({
      blending: BlendingState_default.ALPHA_BLEND
    });
  }
  if (!defined_default(command.shaderProgram) || this._useHdr !== useHdr) {
    const fs = new ShaderSource_default({
      defines: [useHdr ? "HDR" : ""],
      sources: [SkyBoxFS_default]
    });
    command.shaderProgram = ShaderProgram_default.fromCache({
      context,
      vertexShaderSource: SkyBoxVS_default,
      fragmentShaderSource: fs,
      attributeLocations: this._attributeLocations
    });
    this._useHdr = useHdr;
  }
  if (!defined_default(this._cubeMap)) {
    return void 0;
  }
  return command;
};
SkyBox.prototype.isDestroyed = function() {
  return false;
};
SkyBox.prototype.destroy = function() {
  const command = this._command;
  command.vertexArray = command.vertexArray && command.vertexArray.destroy();
  command.shaderProgram = command.shaderProgram && command.shaderProgram.destroy();
  this._cubeMap = this._cubeMap && this._cubeMap.destroy();
  return destroyObject_default(this);
};
var SkyBox_default = SkyBox;

// node_modules/cesium/Source/Scene/SphereEmitter.js
function SphereEmitter(radius) {
  radius = defaultValue_default(radius, 1);
  Check_default.typeOf.number.greaterThan("radius", radius, 0);
  this._radius = defaultValue_default(radius, 1);
}
Object.defineProperties(SphereEmitter.prototype, {
  radius: {
    get: function() {
      return this._radius;
    },
    set: function(value) {
      Check_default.typeOf.number.greaterThan("value", value, 0);
      this._radius = value;
    }
  }
});
SphereEmitter.prototype.emit = function(particle) {
  const theta = Math_default.randomBetween(0, Math_default.TWO_PI);
  const phi = Math_default.randomBetween(0, Math_default.PI);
  const rad = Math_default.randomBetween(0, this._radius);
  const x = rad * Math.cos(theta) * Math.sin(phi);
  const y = rad * Math.sin(theta) * Math.sin(phi);
  const z = rad * Math.cos(phi);
  particle.position = Cartesian3_default.fromElements(x, y, z, particle.position);
  particle.velocity = Cartesian3_default.normalize(
    particle.position,
    particle.velocity
  );
};
var SphereEmitter_default = SphereEmitter;

// node_modules/cesium/Source/Scene/StyleExpression.js
function StyleExpression() {
}
StyleExpression.prototype.evaluate = function(feature2, result) {
  DeveloperError_default.throwInstantiationError();
};
StyleExpression.prototype.evaluateColor = function(feature2, result) {
  DeveloperError_default.throwInstantiationError();
};
StyleExpression.prototype.getShaderFunction = function(functionSignature, variableSubstitutionMap, shaderState, returnType) {
  DeveloperError_default.throwInstantiationError();
};
StyleExpression.prototype.getVariables = function() {
  DeveloperError_default.throwInstantiationError();
};
var StyleExpression_default = StyleExpression;

// node_modules/cesium/Source/Shaders/SunFS.js
var SunFS_default = "uniform sampler2D u_texture;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    vec4 color = texture2D(u_texture, v_textureCoordinates);\n    gl_FragColor = czm_gammaCorrect(color);\n}\n";

// node_modules/cesium/Source/Shaders/SunTextureFS.js
var SunTextureFS_default = "uniform float u_radiusTS;\n\nvarying vec2 v_textureCoordinates;\n\nvec2 rotate(vec2 p, vec2 direction)\n{\n    return vec2(p.x * direction.x - p.y * direction.y, p.x * direction.y + p.y * direction.x);\n}\n\nvec4 addBurst(vec2 position, vec2 direction, float lengthScalar)\n{\n    vec2 rotatedPosition = rotate(position, direction) * vec2(25.0, 0.75);\n    float radius = length(rotatedPosition) * lengthScalar;\n    float burst = 1.0 - smoothstep(0.0, 0.55, radius);\n    return vec4(burst);\n}\n\nvoid main()\n{\n    float lengthScalar = 2.0 / sqrt(2.0);\n    vec2 position = v_textureCoordinates - vec2(0.5);\n    float radius = length(position) * lengthScalar;\n    float surface = step(radius, u_radiusTS);\n    vec4 color = vec4(vec2(1.0), surface + 0.2, surface);\n\n    float glow = 1.0 - smoothstep(0.0, 0.55, radius);\n    color.ba += mix(vec2(0.0), vec2(1.0), glow) * 0.75;\n\n    vec4 burst = vec4(0.0);\n\n    // The following loop has been manually unrolled for speed, to\n    // avoid sin() and cos().\n    //\n    //for (float i = 0.4; i < 3.2; i += 1.047) {\n    //    vec2 direction = vec2(sin(i), cos(i));\n    //    burst += 0.4 * addBurst(position, direction, lengthScalar);\n    //\n    //    direction = vec2(sin(i - 0.08), cos(i - 0.08));\n    //    burst += 0.3 * addBurst(position, direction, lengthScalar);\n    //}\n\n    burst += 0.4 * addBurst(position, vec2(0.38942,  0.92106), lengthScalar);  // angle == 0.4\n    burst += 0.4 * addBurst(position, vec2(0.99235,  0.12348), lengthScalar);  // angle == 0.4 + 1.047\n    burst += 0.4 * addBurst(position, vec2(0.60327, -0.79754), lengthScalar);  // angle == 0.4 + 1.047 * 2.0\n\n    burst += 0.3 * addBurst(position, vec2(0.31457,  0.94924), lengthScalar);  // angle == 0.4 - 0.08\n    burst += 0.3 * addBurst(position, vec2(0.97931,  0.20239), lengthScalar);  // angle == 0.4 + 1.047 - 0.08\n    burst += 0.3 * addBurst(position, vec2(0.66507, -0.74678), lengthScalar);  // angle == 0.4 + 1.047 * 2.0 - 0.08\n\n    // End of manual loop unrolling.\n\n    color += clamp(burst, vec4(0.0), vec4(1.0)) * 0.15;\n\n    gl_FragColor = clamp(color, vec4(0.0), vec4(1.0));\n}\n";

// node_modules/cesium/Source/Shaders/SunVS.js
var SunVS_default = "attribute vec2 direction;\n\nuniform float u_size;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main() \n{\n    vec4 position;\n    if (czm_morphTime == 1.0)\n    {\n        position = vec4(czm_sunPositionWC, 1.0);\n    }\n    else\n    {\n        position = vec4(czm_sunPositionColumbusView.zxy, 1.0);\n    }\n    \n    vec4 positionEC = czm_view * position;\n    vec4 positionWC = czm_eyeToWindowCoordinates(positionEC);\n    \n    vec2 halfSize = vec2(u_size * 0.5);\n    halfSize *= ((direction * 2.0) - 1.0);\n    \n    gl_Position = czm_viewportOrthographic * vec4(positionWC.xy + halfSize, -positionWC.z, 1.0);\n    \n    v_textureCoordinates = direction;\n}\n";

// node_modules/cesium/Source/Scene/Sun.js
function Sun() {
  this.show = true;
  this._drawCommand = new DrawCommand_default({
    primitiveType: PrimitiveType_default.TRIANGLES,
    boundingVolume: new BoundingSphere_default(),
    owner: this
  });
  this._commands = {
    drawCommand: this._drawCommand,
    computeCommand: void 0
  };
  this._boundingVolume = new BoundingSphere_default();
  this._boundingVolume2D = new BoundingSphere_default();
  this._texture = void 0;
  this._drawingBufferWidth = void 0;
  this._drawingBufferHeight = void 0;
  this._radiusTS = void 0;
  this._size = void 0;
  this.glowFactor = 1;
  this._glowFactorDirty = false;
  this._useHdr = void 0;
  const that = this;
  this._uniformMap = {
    u_texture: function() {
      return that._texture;
    },
    u_size: function() {
      return that._size;
    }
  };
}
Object.defineProperties(Sun.prototype, {
  glowFactor: {
    get: function() {
      return this._glowFactor;
    },
    set: function(glowFactor) {
      glowFactor = Math.max(glowFactor, 0);
      this._glowFactor = glowFactor;
      this._glowFactorDirty = true;
    }
  }
});
var scratchPositionWC = new Cartesian2_default();
var scratchLimbWC = new Cartesian2_default();
var scratchPositionEC = new Cartesian4_default();
var scratchCartesian47 = new Cartesian4_default();
Sun.prototype.update = function(frameState, passState, useHdr) {
  if (!this.show) {
    return void 0;
  }
  const mode2 = frameState.mode;
  if (mode2 === SceneMode_default.SCENE2D || mode2 === SceneMode_default.MORPHING) {
    return void 0;
  }
  if (!frameState.passes.render) {
    return void 0;
  }
  const context = frameState.context;
  const drawingBufferWidth = passState.viewport.width;
  const drawingBufferHeight = passState.viewport.height;
  if (!defined_default(this._texture) || drawingBufferWidth !== this._drawingBufferWidth || drawingBufferHeight !== this._drawingBufferHeight || this._glowFactorDirty || useHdr !== this._useHdr) {
    this._texture = this._texture && this._texture.destroy();
    this._drawingBufferWidth = drawingBufferWidth;
    this._drawingBufferHeight = drawingBufferHeight;
    this._glowFactorDirty = false;
    this._useHdr = useHdr;
    let size = Math.max(drawingBufferWidth, drawingBufferHeight);
    size = Math.pow(2, Math.ceil(Math.log(size) / Math.log(2)) - 2);
    size = Math.max(1, size);
    const pixelDatatype = useHdr ? context.halfFloatingPointTexture ? PixelDatatype_default.HALF_FLOAT : PixelDatatype_default.FLOAT : PixelDatatype_default.UNSIGNED_BYTE;
    this._texture = new Texture_default({
      context,
      width: size,
      height: size,
      pixelFormat: PixelFormat_default.RGBA,
      pixelDatatype
    });
    this._glowLengthTS = this._glowFactor * 5;
    this._radiusTS = 1 / (1 + 2 * this._glowLengthTS) * 0.5;
    const that = this;
    const uniformMap2 = {
      u_radiusTS: function() {
        return that._radiusTS;
      }
    };
    this._commands.computeCommand = new ComputeCommand_default({
      fragmentShaderSource: SunTextureFS_default,
      outputTexture: this._texture,
      uniformMap: uniformMap2,
      persists: false,
      owner: this,
      postExecute: function() {
        that._commands.computeCommand = void 0;
      }
    });
  }
  const drawCommand = this._drawCommand;
  if (!defined_default(drawCommand.vertexArray)) {
    const attributeLocations8 = {
      direction: 0
    };
    const directions2 = new Uint8Array(4 * 2);
    directions2[0] = 0;
    directions2[1] = 0;
    directions2[2] = 255;
    directions2[3] = 0;
    directions2[4] = 255;
    directions2[5] = 255;
    directions2[6] = 0;
    directions2[7] = 255;
    const vertexBuffer = Buffer_default.createVertexBuffer({
      context,
      typedArray: directions2,
      usage: BufferUsage_default.STATIC_DRAW
    });
    const attributes = [
      {
        index: attributeLocations8.direction,
        vertexBuffer,
        componentsPerAttribute: 2,
        normalize: true,
        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE
      }
    ];
    const indexBuffer = Buffer_default.createIndexBuffer({
      context,
      typedArray: new Uint16Array([0, 1, 2, 0, 2, 3]),
      usage: BufferUsage_default.STATIC_DRAW,
      indexDatatype: IndexDatatype_default.UNSIGNED_SHORT
    });
    drawCommand.vertexArray = new VertexArray_default({
      context,
      attributes,
      indexBuffer
    });
    drawCommand.shaderProgram = ShaderProgram_default.fromCache({
      context,
      vertexShaderSource: SunVS_default,
      fragmentShaderSource: SunFS_default,
      attributeLocations: attributeLocations8
    });
    drawCommand.renderState = RenderState_default.fromCache({
      blending: BlendingState_default.ALPHA_BLEND
    });
    drawCommand.uniformMap = this._uniformMap;
  }
  const sunPosition = context.uniformState.sunPositionWC;
  const sunPositionCV = context.uniformState.sunPositionColumbusView;
  const boundingVolume = this._boundingVolume;
  const boundingVolume2D = this._boundingVolume2D;
  Cartesian3_default.clone(sunPosition, boundingVolume.center);
  boundingVolume2D.center.x = sunPositionCV.z;
  boundingVolume2D.center.y = sunPositionCV.x;
  boundingVolume2D.center.z = sunPositionCV.y;
  boundingVolume.radius = Math_default.SOLAR_RADIUS + Math_default.SOLAR_RADIUS * this._glowLengthTS;
  boundingVolume2D.radius = boundingVolume.radius;
  if (mode2 === SceneMode_default.SCENE3D) {
    BoundingSphere_default.clone(boundingVolume, drawCommand.boundingVolume);
  } else if (mode2 === SceneMode_default.COLUMBUS_VIEW) {
    BoundingSphere_default.clone(boundingVolume2D, drawCommand.boundingVolume);
  }
  const position = SceneTransforms_default.computeActualWgs84Position(
    frameState,
    sunPosition,
    scratchCartesian47
  );
  const dist = Cartesian3_default.magnitude(
    Cartesian3_default.subtract(position, frameState.camera.position, scratchCartesian47)
  );
  const projMatrix = context.uniformState.projection;
  const positionEC = scratchPositionEC;
  positionEC.x = 0;
  positionEC.y = 0;
  positionEC.z = -dist;
  positionEC.w = 1;
  const positionCC2 = Matrix4_default.multiplyByVector(
    projMatrix,
    positionEC,
    scratchCartesian47
  );
  const positionWC2 = SceneTransforms_default.clipToGLWindowCoordinates(
    passState.viewport,
    positionCC2,
    scratchPositionWC
  );
  positionEC.x = Math_default.SOLAR_RADIUS;
  const limbCC = Matrix4_default.multiplyByVector(
    projMatrix,
    positionEC,
    scratchCartesian47
  );
  const limbWC = SceneTransforms_default.clipToGLWindowCoordinates(
    passState.viewport,
    limbCC,
    scratchLimbWC
  );
  this._size = Cartesian2_default.magnitude(
    Cartesian2_default.subtract(limbWC, positionWC2, scratchCartesian47)
  );
  this._size = 2 * this._size * (1 + 2 * this._glowLengthTS);
  this._size = Math.ceil(this._size);
  return this._commands;
};
Sun.prototype.isDestroyed = function() {
  return false;
};
Sun.prototype.destroy = function() {
  const command = this._drawCommand;
  command.vertexArray = command.vertexArray && command.vertexArray.destroy();
  command.shaderProgram = command.shaderProgram && command.shaderProgram.destroy();
  this._texture = this._texture && this._texture.destroy();
  return destroyObject_default(this);
};
var Sun_default = Sun;

// node_modules/cesium/Source/Scene/TileBoundingVolume.js
function TileBoundingVolume() {
}
TileBoundingVolume.prototype.boundingVolume = void 0;
TileBoundingVolume.prototype.boundingSphere = void 0;
TileBoundingVolume.prototype.distanceToCamera = function(frameState) {
  DeveloperError_default.throwInstantiationError();
};
TileBoundingVolume.prototype.intersectPlane = function(plane) {
  DeveloperError_default.throwInstantiationError();
};
TileBoundingVolume.prototype.createDebugVolume = function(color) {
  DeveloperError_default.throwInstantiationError();
};
var TileBoundingVolume_default = TileBoundingVolume;

// node_modules/cesium/Source/Scene/TileCoordinatesImageryProvider.js
function TileCoordinatesImageryProvider(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this._tilingScheme = defined_default(options.tilingScheme) ? options.tilingScheme : new GeographicTilingScheme_default({ ellipsoid: options.ellipsoid });
  this._color = defaultValue_default(options.color, Color_default.YELLOW);
  this._errorEvent = new Event_default();
  this._tileWidth = defaultValue_default(options.tileWidth, 256);
  this._tileHeight = defaultValue_default(options.tileHeight, 256);
  this._readyPromise = Promise.resolve(true);
  this.defaultAlpha = void 0;
  this.defaultNightAlpha = void 0;
  this.defaultDayAlpha = void 0;
  this.defaultBrightness = void 0;
  this.defaultContrast = void 0;
  this.defaultHue = void 0;
  this.defaultSaturation = void 0;
  this.defaultGamma = void 0;
  this.defaultMinificationFilter = void 0;
  this.defaultMagnificationFilter = void 0;
}
Object.defineProperties(TileCoordinatesImageryProvider.prototype, {
  proxy: {
    get: function() {
      return void 0;
    }
  },
  tileWidth: {
    get: function() {
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      return this._tileHeight;
    }
  },
  maximumLevel: {
    get: function() {
      return void 0;
    }
  },
  minimumLevel: {
    get: function() {
      return void 0;
    }
  },
  tilingScheme: {
    get: function() {
      return this._tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      return this._tilingScheme.rectangle;
    }
  },
  tileDiscardPolicy: {
    get: function() {
      return void 0;
    }
  },
  errorEvent: {
    get: function() {
      return this._errorEvent;
    }
  },
  ready: {
    get: function() {
      return true;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise;
    }
  },
  credit: {
    get: function() {
      return void 0;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return true;
    }
  }
});
TileCoordinatesImageryProvider.prototype.getTileCredits = function(x, y, level) {
  return void 0;
};
TileCoordinatesImageryProvider.prototype.requestImage = function(x, y, level, request) {
  const canvas = document.createElement("canvas");
  canvas.width = 256;
  canvas.height = 256;
  const context = canvas.getContext("2d");
  const cssColor = this._color.toCssColorString();
  context.strokeStyle = cssColor;
  context.lineWidth = 2;
  context.strokeRect(1, 1, 255, 255);
  context.font = "bold 25px Arial";
  context.textAlign = "center";
  context.fillStyle = cssColor;
  context.fillText(`L: ${level}`, 124, 86);
  context.fillText(`X: ${x}`, 124, 136);
  context.fillText(`Y: ${y}`, 124, 186);
  return Promise.resolve(canvas);
};
TileCoordinatesImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  return void 0;
};
var TileCoordinatesImageryProvider_default = TileCoordinatesImageryProvider;

// node_modules/cesium/Source/Scene/TileDiscardPolicy.js
function TileDiscardPolicy(options) {
  DeveloperError_default.throwInstantiationError();
}
TileDiscardPolicy.prototype.isReady = DeveloperError_default.throwInstantiationError;
TileDiscardPolicy.prototype.shouldDiscardImage = DeveloperError_default.throwInstantiationError;
var TileDiscardPolicy_default = TileDiscardPolicy;

// node_modules/cesium/Source/Scene/TileState.js
var TileState = {
  START: 0,
  LOADING: 1,
  READY: 2,
  UPSAMPLED_ONLY: 3
};
var TileState_default = Object.freeze(TileState);

// node_modules/cesium/Source/Scene/TimeDynamicPointCloud.js
function TimeDynamicPointCloud(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  Check_default.typeOf.object("options.clock", options.clock);
  Check_default.typeOf.object("options.intervals", options.intervals);
  this.show = defaultValue_default(options.show, true);
  this.modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  this.shadows = defaultValue_default(options.shadows, ShadowMode_default.ENABLED);
  this.maximumMemoryUsage = defaultValue_default(options.maximumMemoryUsage, 256);
  this.shading = new PointCloudShading_default(options.shading);
  this.style = options.style;
  this.frameFailed = new Event_default();
  this.frameChanged = new Event_default();
  this._clock = options.clock;
  this._intervals = options.intervals;
  this._clippingPlanes = void 0;
  this.clippingPlanes = options.clippingPlanes;
  this._pointCloudEyeDomeLighting = new PointCloudEyeDomeLighting_default2();
  this._loadTimestamp = void 0;
  this._clippingPlanesState = 0;
  this._styleDirty = false;
  this._pickId = void 0;
  this._totalMemoryUsageInBytes = 0;
  this._frames = [];
  this._previousInterval = void 0;
  this._nextInterval = void 0;
  this._lastRenderedFrame = void 0;
  this._clockMultiplier = 0;
  this._readyPromise = defer_default();
  this._runningSum = 0;
  this._runningLength = 0;
  this._runningIndex = 0;
  this._runningSamples = arrayFill_default(new Array(5), 0);
  this._runningAverage = 0;
}
Object.defineProperties(TimeDynamicPointCloud.prototype, {
  clippingPlanes: {
    get: function() {
      return this._clippingPlanes;
    },
    set: function(value) {
      ClippingPlaneCollection_default.setOwner(value, this, "_clippingPlanes");
    }
  },
  totalMemoryUsageInBytes: {
    get: function() {
      return this._totalMemoryUsageInBytes;
    }
  },
  boundingSphere: {
    get: function() {
      if (defined_default(this._lastRenderedFrame)) {
        return this._lastRenderedFrame.pointCloud.boundingSphere;
      }
      return void 0;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  }
});
function getFragmentShaderLoaded2(fs) {
  return `uniform vec4 czm_pickColor;
${fs}`;
}
function getUniformMapLoaded2(stream) {
  return function(uniformMap2) {
    return combine_default(uniformMap2, {
      czm_pickColor: function() {
        return stream._pickId.color;
      }
    });
  };
}
function getPickIdLoaded2() {
  return "czm_pickColor";
}
TimeDynamicPointCloud.prototype.makeStyleDirty = function() {
  this._styleDirty = true;
};
TimeDynamicPointCloud.prototype._getAverageLoadTime = function() {
  if (this._runningLength === 0) {
    return 0.05;
  }
  return this._runningAverage;
};
var scratchDate2 = new JulianDate_default();
function getClockMultiplier(that) {
  const clock = that._clock;
  const isAnimating = clock.canAnimate && clock.shouldAnimate;
  const multiplier = clock.multiplier;
  return isAnimating ? multiplier : 0;
}
function getIntervalIndex(that, interval) {
  return that._intervals.indexOf(interval.start);
}
function getNextInterval(that, currentInterval) {
  const intervals = that._intervals;
  const clock = that._clock;
  const multiplier = getClockMultiplier(that);
  if (multiplier === 0) {
    return void 0;
  }
  const averageLoadTime = that._getAverageLoadTime();
  const time = JulianDate_default.addSeconds(
    clock.currentTime,
    averageLoadTime * multiplier,
    scratchDate2
  );
  let index2 = intervals.indexOf(time);
  const currentIndex = getIntervalIndex(that, currentInterval);
  if (index2 === currentIndex) {
    if (multiplier >= 0) {
      ++index2;
    } else {
      --index2;
    }
  }
  return intervals.get(index2);
}
function getCurrentInterval(that) {
  const intervals = that._intervals;
  const clock = that._clock;
  const time = clock.currentTime;
  const index2 = intervals.indexOf(time);
  return intervals.get(index2);
}
function reachedInterval(that, currentInterval, nextInterval) {
  const multiplier = getClockMultiplier(that);
  const currentIndex = getIntervalIndex(that, currentInterval);
  const nextIndex = getIntervalIndex(that, nextInterval);
  if (multiplier >= 0) {
    return currentIndex >= nextIndex;
  }
  return currentIndex <= nextIndex;
}
function handleFrameFailure(that, uri) {
  return function(error) {
    const message = defined_default(error.message) ? error.message : error.toString();
    if (that.frameFailed.numberOfListeners > 0) {
      that.frameFailed.raiseEvent({
        uri,
        message
      });
    } else {
      console.log(`A frame failed to load: ${uri}`);
      console.log(`Error: ${message}`);
    }
  };
}
function requestFrame(that, interval, frameState) {
  const index2 = getIntervalIndex(that, interval);
  const frames = that._frames;
  let frame = frames[index2];
  if (!defined_default(frame)) {
    const transformArray = interval.data.transform;
    const transform4 = defined_default(transformArray) ? Matrix4_default.fromArray(transformArray) : void 0;
    const uri = interval.data.uri;
    frame = {
      pointCloud: void 0,
      transform: transform4,
      timestamp: getTimestamp_default(),
      sequential: true,
      ready: false,
      touchedFrameNumber: frameState.frameNumber
    };
    frames[index2] = frame;
    Resource_default.fetchArrayBuffer({
      url: uri
    }).then(function(arrayBuffer) {
      frame.pointCloud = new PointCloud_default({
        arrayBuffer,
        cull: true,
        fragmentShaderLoaded: getFragmentShaderLoaded2,
        uniformMapLoaded: getUniformMapLoaded2(that),
        pickIdLoaded: getPickIdLoaded2
      });
      return frame.pointCloud.readyPromise;
    }).catch(handleFrameFailure(that, uri));
  }
  return frame;
}
function updateAverageLoadTime(that, loadTime) {
  that._runningSum += loadTime;
  that._runningSum -= that._runningSamples[that._runningIndex];
  that._runningSamples[that._runningIndex] = loadTime;
  that._runningLength = Math.min(
    that._runningLength + 1,
    that._runningSamples.length
  );
  that._runningIndex = (that._runningIndex + 1) % that._runningSamples.length;
  that._runningAverage = that._runningSum / that._runningLength;
}
function prepareFrame(that, frame, updateState2, frameState) {
  if (frame.touchedFrameNumber < frameState.frameNumber - 1) {
    frame.sequential = false;
  }
  const pointCloud = frame.pointCloud;
  if (defined_default(pointCloud) && !frame.ready) {
    const commandList = frameState.commandList;
    const lengthBeforeUpdate = commandList.length;
    renderFrame(that, frame, updateState2, frameState);
    if (pointCloud.ready) {
      frame.ready = true;
      that._totalMemoryUsageInBytes += pointCloud.geometryByteLength;
      commandList.length = lengthBeforeUpdate;
      if (frame.sequential) {
        const loadTime = (getTimestamp_default() - frame.timestamp) / 1e3;
        updateAverageLoadTime(that, loadTime);
      }
    }
  }
  frame.touchedFrameNumber = frameState.frameNumber;
}
var scratchModelMatrix2 = new Matrix4_default();
function getGeometricError4(that, pointCloud) {
  const shading = that.shading;
  if (defined_default(shading) && defined_default(shading.baseResolution)) {
    return shading.baseResolution;
  } else if (defined_default(pointCloud.boundingSphere)) {
    return Math_default.cbrt(
      pointCloud.boundingSphere.volume() / pointCloud.pointsLength
    );
  }
  return 0;
}
function getMaximumAttenuation(that) {
  const shading = that.shading;
  if (defined_default(shading) && defined_default(shading.maximumAttenuation)) {
    return shading.maximumAttenuation;
  }
  return 10;
}
var defaultShading2 = new PointCloudShading_default();
function renderFrame(that, frame, updateState2, frameState) {
  const shading = defaultValue_default(that.shading, defaultShading2);
  const pointCloud = frame.pointCloud;
  const transform4 = defaultValue_default(frame.transform, Matrix4_default.IDENTITY);
  pointCloud.modelMatrix = Matrix4_default.multiplyTransformation(
    that.modelMatrix,
    transform4,
    scratchModelMatrix2
  );
  pointCloud.style = that.style;
  pointCloud.time = updateState2.timeSinceLoad;
  pointCloud.shadows = that.shadows;
  pointCloud.clippingPlanes = that._clippingPlanes;
  pointCloud.isClipped = updateState2.isClipped;
  pointCloud.attenuation = shading.attenuation;
  pointCloud.backFaceCulling = shading.backFaceCulling;
  pointCloud.normalShading = shading.normalShading;
  pointCloud.geometricError = getGeometricError4(that, pointCloud);
  pointCloud.geometricErrorScale = shading.geometricErrorScale;
  pointCloud.maximumAttenuation = getMaximumAttenuation(that);
  pointCloud.update(frameState);
  frame.touchedFrameNumber = frameState.frameNumber;
}
function loadFrame(that, interval, updateState2, frameState) {
  const frame = requestFrame(that, interval, frameState);
  prepareFrame(that, frame, updateState2, frameState);
}
function getUnloadCondition(frameState) {
  return function(frame) {
    return frame.touchedFrameNumber < frameState.frameNumber;
  };
}
function unloadFrames(that, unloadCondition) {
  const frames = that._frames;
  const length3 = frames.length;
  for (let i2 = 0; i2 < length3; ++i2) {
    const frame = frames[i2];
    if (defined_default(frame)) {
      if (!defined_default(unloadCondition) || unloadCondition(frame)) {
        const pointCloud = frame.pointCloud;
        if (frame.ready) {
          that._totalMemoryUsageInBytes -= pointCloud.geometryByteLength;
        }
        if (defined_default(pointCloud)) {
          pointCloud.destroy();
        }
        if (frame === that._lastRenderedFrame) {
          that._lastRenderedFrame = void 0;
        }
        frames[i2] = void 0;
      }
    }
  }
}
function getFrame(that, interval) {
  const index2 = getIntervalIndex(that, interval);
  const frame = that._frames[index2];
  if (defined_default(frame) && frame.ready) {
    return frame;
  }
}
function updateInterval(that, interval, frame, updateState2, frameState) {
  if (defined_default(frame)) {
    if (frame.ready) {
      return true;
    }
    loadFrame(that, interval, updateState2, frameState);
    return frame.ready;
  }
  return false;
}
function getNearestReadyInterval(that, previousInterval, currentInterval, updateState2, frameState) {
  let i2;
  let interval;
  let frame;
  const intervals = that._intervals;
  const frames = that._frames;
  const currentIndex = getIntervalIndex(that, currentInterval);
  const previousIndex = getIntervalIndex(that, previousInterval);
  if (currentIndex >= previousIndex) {
    for (i2 = currentIndex; i2 >= previousIndex; --i2) {
      interval = intervals.get(i2);
      frame = frames[i2];
      if (updateInterval(that, interval, frame, updateState2, frameState)) {
        return interval;
      }
    }
  } else {
    for (i2 = currentIndex; i2 <= previousIndex; ++i2) {
      interval = intervals.get(i2);
      frame = frames[i2];
      if (updateInterval(that, interval, frame, updateState2, frameState)) {
        return interval;
      }
    }
  }
  return previousInterval;
}
function setFramesDirty(that, clippingPlanesDirty, styleDirty) {
  const frames = that._frames;
  const framesLength = frames.length;
  for (let i2 = 0; i2 < framesLength; ++i2) {
    const frame = frames[i2];
    if (defined_default(frame) && defined_default(frame.pointCloud)) {
      frame.pointCloud.clippingPlanesDirty = clippingPlanesDirty;
      frame.pointCloud.styleDirty = styleDirty;
    }
  }
}
var updateState = {
  timeSinceLoad: 0,
  isClipped: false,
  clippingPlanesDirty: false
};
TimeDynamicPointCloud.prototype.update = function(frameState) {
  if (frameState.mode === SceneMode_default.MORPHING) {
    return;
  }
  if (!this.show) {
    return;
  }
  if (!defined_default(this._pickId)) {
    this._pickId = frameState.context.createPickId({
      primitive: this
    });
  }
  if (!defined_default(this._loadTimestamp)) {
    this._loadTimestamp = JulianDate_default.clone(frameState.time);
  }
  const timeSinceLoad = Math.max(
    JulianDate_default.secondsDifference(frameState.time, this._loadTimestamp) * 1e3,
    0
  );
  const clippingPlanes = this._clippingPlanes;
  let clippingPlanesState = 0;
  let clippingPlanesDirty = false;
  const isClipped = defined_default(clippingPlanes) && clippingPlanes.enabled;
  if (isClipped) {
    clippingPlanes.update(frameState);
    clippingPlanesState = clippingPlanes.clippingPlanesState;
  }
  if (this._clippingPlanesState !== clippingPlanesState) {
    this._clippingPlanesState = clippingPlanesState;
    clippingPlanesDirty = true;
  }
  const styleDirty = this._styleDirty;
  this._styleDirty = false;
  if (clippingPlanesDirty || styleDirty) {
    setFramesDirty(this, clippingPlanesDirty, styleDirty);
  }
  updateState.timeSinceLoad = timeSinceLoad;
  updateState.isClipped = isClipped;
  const shading = this.shading;
  const eyeDomeLighting = this._pointCloudEyeDomeLighting;
  const commandList = frameState.commandList;
  const lengthBeforeUpdate = commandList.length;
  let previousInterval = this._previousInterval;
  let nextInterval = this._nextInterval;
  const currentInterval = getCurrentInterval(this);
  if (!defined_default(currentInterval)) {
    return;
  }
  let clockMultiplierChanged = false;
  const clockMultiplier = getClockMultiplier(this);
  const clockPaused = clockMultiplier === 0;
  if (clockMultiplier !== this._clockMultiplier) {
    clockMultiplierChanged = true;
    this._clockMultiplier = clockMultiplier;
  }
  if (!defined_default(previousInterval) || clockPaused) {
    previousInterval = currentInterval;
  }
  if (!defined_default(nextInterval) || clockMultiplierChanged || reachedInterval(this, currentInterval, nextInterval)) {
    nextInterval = getNextInterval(this, currentInterval);
  }
  previousInterval = getNearestReadyInterval(
    this,
    previousInterval,
    currentInterval,
    updateState,
    frameState
  );
  let frame = getFrame(this, previousInterval);
  if (!defined_default(frame)) {
    loadFrame(this, previousInterval, updateState, frameState);
    frame = this._lastRenderedFrame;
  }
  if (defined_default(frame)) {
    renderFrame(this, frame, updateState, frameState);
  }
  if (defined_default(nextInterval)) {
    loadFrame(this, nextInterval, updateState, frameState);
  }
  const that = this;
  if (defined_default(frame) && !defined_default(this._lastRenderedFrame)) {
    frameState.afterRender.push(function() {
      that._readyPromise.resolve(that);
    });
  }
  if (defined_default(frame) && frame !== this._lastRenderedFrame) {
    if (that.frameChanged.numberOfListeners > 0) {
      frameState.afterRender.push(function() {
        that.frameChanged.raiseEvent(that);
      });
    }
  }
  this._previousInterval = previousInterval;
  this._nextInterval = nextInterval;
  this._lastRenderedFrame = frame;
  const totalMemoryUsageInBytes = this._totalMemoryUsageInBytes;
  const maximumMemoryUsageInBytes = this.maximumMemoryUsage * 1024 * 1024;
  if (totalMemoryUsageInBytes > maximumMemoryUsageInBytes) {
    unloadFrames(this, getUnloadCondition(frameState));
  }
  const lengthAfterUpdate = commandList.length;
  const addedCommandsLength = lengthAfterUpdate - lengthBeforeUpdate;
  if (defined_default(shading) && shading.attenuation && shading.eyeDomeLighting && addedCommandsLength > 0) {
    eyeDomeLighting.update(
      frameState,
      lengthBeforeUpdate,
      shading,
      this.boundingSphere
    );
  }
};
TimeDynamicPointCloud.prototype.isDestroyed = function() {
  return false;
};
TimeDynamicPointCloud.prototype.destroy = function() {
  unloadFrames(this);
  this._clippingPlanes = this._clippingPlanes && this._clippingPlanes.destroy();
  this._pickId = this._pickId && this._pickId.destroy();
  return destroyObject_default(this);
};
var TimeDynamicPointCloud_default = TimeDynamicPointCloud;

// node_modules/cesium/Source/Shaders/ViewportQuadFS.js
var ViewportQuadFS_default = "\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    czm_materialInput materialInput;\n    \n    materialInput.s = v_textureCoordinates.s;\n    materialInput.st = v_textureCoordinates;\n    materialInput.str = vec3(v_textureCoordinates, 0.0);\n    materialInput.normalEC = vec3(0.0, 0.0, -1.0);\n    \n    czm_material material = czm_getMaterial(materialInput);\n\n    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n}\n";

// node_modules/cesium/Source/Scene/ViewportQuad.js
function ViewportQuad(rectangle, material) {
  this.show = true;
  if (!defined_default(rectangle)) {
    rectangle = new BoundingRectangle_default();
  }
  this.rectangle = BoundingRectangle_default.clone(rectangle);
  if (!defined_default(material)) {
    material = Material_default.fromType(Material_default.ColorType, {
      color: new Color_default(1, 1, 1, 1)
    });
  }
  this.material = material;
  this._material = void 0;
  this._overlayCommand = void 0;
  this._rs = void 0;
}
ViewportQuad.prototype.update = function(frameState) {
  if (!this.show) {
    return;
  }
  if (!defined_default(this.material)) {
    throw new DeveloperError_default("this.material must be defined.");
  }
  if (!defined_default(this.rectangle)) {
    throw new DeveloperError_default("this.rectangle must be defined.");
  }
  const rs = this._rs;
  if (!defined_default(rs) || !BoundingRectangle_default.equals(rs.viewport, this.rectangle)) {
    this._rs = RenderState_default.fromCache({
      blending: BlendingState_default.ALPHA_BLEND,
      viewport: this.rectangle
    });
  }
  const pass = frameState.passes;
  if (pass.render) {
    const context = frameState.context;
    if (this._material !== this.material || !defined_default(this._overlayCommand)) {
      this._material = this.material;
      if (defined_default(this._overlayCommand)) {
        this._overlayCommand.shaderProgram.destroy();
      }
      const fs = new ShaderSource_default({
        sources: [this._material.shaderSource, ViewportQuadFS_default]
      });
      this._overlayCommand = context.createViewportQuadCommand(fs, {
        renderState: this._rs,
        uniformMap: this._material._uniforms,
        owner: this
      });
      this._overlayCommand.pass = Pass_default.OVERLAY;
    }
    this._material.update(context);
    this._overlayCommand.renderState = this._rs;
    this._overlayCommand.uniformMap = this._material._uniforms;
    frameState.commandList.push(this._overlayCommand);
  }
};
ViewportQuad.prototype.isDestroyed = function() {
  return false;
};
ViewportQuad.prototype.destroy = function() {
  if (defined_default(this._overlayCommand)) {
    this._overlayCommand.shaderProgram = this._overlayCommand.shaderProgram && this._overlayCommand.shaderProgram.destroy();
  }
  return destroyObject_default(this);
};
var ViewportQuad_default = ViewportQuad;

// node_modules/cesium/Source/Scene/computeFlyToLocationForRectangle.js
function computeFlyToLocationForRectangle(rectangle, scene) {
  const terrainProvider = scene.terrainProvider;
  const mapProjection = scene.mapProjection;
  const ellipsoid = mapProjection.ellipsoid;
  let positionWithoutTerrain;
  const tmp2 = scene.camera.getRectangleCameraCoordinates(rectangle);
  if (scene.mode === SceneMode_default.SCENE3D) {
    positionWithoutTerrain = ellipsoid.cartesianToCartographic(tmp2);
  } else {
    positionWithoutTerrain = mapProjection.unproject(tmp2);
  }
  if (!defined_default(terrainProvider)) {
    return Promise.resolve(positionWithoutTerrain);
  }
  return terrainProvider.readyPromise.then(function() {
    const availability = terrainProvider.availability;
    if (!defined_default(availability) || scene.mode === SceneMode_default.SCENE2D) {
      return positionWithoutTerrain;
    }
    const cartographics = [
      Rectangle_default.center(rectangle),
      Rectangle_default.southeast(rectangle),
      Rectangle_default.southwest(rectangle),
      Rectangle_default.northeast(rectangle),
      Rectangle_default.northwest(rectangle)
    ];
    return computeFlyToLocationForRectangle._sampleTerrainMostDetailed(terrainProvider, cartographics).then(function(positionsOnTerrain) {
      const maxHeight = positionsOnTerrain.reduce(
        function(currentMax, item) {
          return Math.max(item.height, currentMax);
        },
        -Number.MAX_VALUE
      );
      const finalPosition = positionWithoutTerrain;
      finalPosition.height += maxHeight;
      return finalPosition;
    });
  });
}
computeFlyToLocationForRectangle._sampleTerrainMostDetailed = sampleTerrainMostDetailed_default;
var computeFlyToLocationForRectangle_default = computeFlyToLocationForRectangle;

// node_modules/cesium/Source/Scene/createElevationBandMaterial.js
var scratchColor25 = new Color_default();
var scratchColorAbove = new Color_default();
var scratchColorBelow = new Color_default();
var scratchColorBlend = new Color_default();
var scratchPackedFloat = new Cartesian4_default();
var scratchColorBytes2 = new Uint8Array(4);
function lerpEntryColor(height, entryBefore, entryAfter, result) {
  const lerpFactor = entryBefore.height === entryAfter.height ? 0 : (height - entryBefore.height) / (entryAfter.height - entryBefore.height);
  return Color_default.lerp(entryBefore.color, entryAfter.color, lerpFactor, result);
}
function createNewEntry(height, color) {
  return {
    height,
    color: Color_default.clone(color)
  };
}
function removeDuplicates2(entries) {
  entries = entries.filter(function(entry, index2, array) {
    const hasPrev = index2 > 0;
    const hasNext = index2 < array.length - 1;
    const sameHeightAsPrev = hasPrev ? entry.height === array[index2 - 1].height : true;
    const sameHeightAsNext = hasNext ? entry.height === array[index2 + 1].height : true;
    const keep = !sameHeightAsPrev || !sameHeightAsNext;
    return keep;
  });
  entries = entries.filter(function(entry, index2, array) {
    const hasPrev = index2 > 0;
    const hasNext = index2 < array.length - 1;
    const sameColorAsPrev = hasPrev ? Color_default.equals(entry.color, array[index2 - 1].color) : false;
    const sameColorAsNext = hasNext ? Color_default.equals(entry.color, array[index2 + 1].color) : false;
    const keep = !sameColorAsPrev || !sameColorAsNext;
    return keep;
  });
  entries = entries.filter(function(entry, index2, array) {
    const hasPrev = index2 > 0;
    const sameColorAsPrev = hasPrev ? Color_default.equals(entry.color, array[index2 - 1].color) : false;
    const sameHeightAsPrev = hasPrev ? entry.height === array[index2 - 1].height : true;
    const keep = !sameColorAsPrev || !sameHeightAsPrev;
    return keep;
  });
  return entries;
}
function preprocess(layers) {
  let i2, j;
  const layeredEntries = [];
  const layersLength = layers.length;
  for (i2 = 0; i2 < layersLength; i2++) {
    const layer = layers[i2];
    const entriesOrig = layer.entries;
    const entriesLength = entriesOrig.length;
    if (!Array.isArray(entriesOrig) || entriesLength === 0) {
      throw new DeveloperError_default("entries must be an array with size > 0.");
    }
    let entries = [];
    for (j = 0; j < entriesLength; j++) {
      const entryOrig = entriesOrig[j];
      if (!defined_default(entryOrig.height)) {
        throw new DeveloperError_default("entry requires a height.");
      }
      if (!defined_default(entryOrig.color)) {
        throw new DeveloperError_default("entry requires a color.");
      }
      const height = Math_default.clamp(
        entryOrig.height,
        createElevationBandMaterial._minimumHeight,
        createElevationBandMaterial._maximumHeight
      );
      const color = Color_default.clone(entryOrig.color, scratchColor25);
      color.red *= color.alpha;
      color.green *= color.alpha;
      color.blue *= color.alpha;
      entries.push(createNewEntry(height, color));
    }
    let sortedAscending = true;
    let sortedDescending = true;
    for (j = 0; j < entriesLength - 1; j++) {
      const currEntry = entries[j + 0];
      const nextEntry = entries[j + 1];
      sortedAscending = sortedAscending && currEntry.height <= nextEntry.height;
      sortedDescending = sortedDescending && currEntry.height >= nextEntry.height;
    }
    if (sortedDescending) {
      entries = entries.reverse();
    } else if (!sortedAscending) {
      mergeSort_default(entries, function(a4, b) {
        return Math_default.sign(a4.height - b.height);
      });
    }
    let extendDownwards = defaultValue_default(layer.extendDownwards, false);
    let extendUpwards = defaultValue_default(layer.extendUpwards, false);
    if (entries.length === 1 && !extendDownwards && !extendUpwards) {
      extendDownwards = true;
      extendUpwards = true;
    }
    if (extendDownwards) {
      entries.splice(
        0,
        0,
        createNewEntry(
          createElevationBandMaterial._minimumHeight,
          entries[0].color
        )
      );
    }
    if (extendUpwards) {
      entries.splice(
        entries.length,
        0,
        createNewEntry(
          createElevationBandMaterial._maximumHeight,
          entries[entries.length - 1].color
        )
      );
    }
    entries = removeDuplicates2(entries);
    layeredEntries.push(entries);
  }
  return layeredEntries;
}
function createLayeredEntries(layers) {
  const layeredEntries = preprocess(layers);
  let entriesAccumNext = [];
  let entriesAccumCurr = [];
  let i2;
  function addEntry(height, color) {
    entriesAccumNext.push(createNewEntry(height, color));
  }
  function addBlendEntry(height, a4, b) {
    let result = Color_default.multiplyByScalar(b, 1 - a4.alpha, scratchColorBlend);
    result = Color_default.add(result, a4, result);
    addEntry(height, result);
  }
  const layerLength = layeredEntries.length;
  for (i2 = 0; i2 < layerLength; i2++) {
    const entries = layeredEntries[i2];
    let idx = 0;
    let accumIdx = 0;
    entriesAccumCurr = entriesAccumNext;
    entriesAccumNext = [];
    const entriesLength = entries.length;
    const entriesAccumLength = entriesAccumCurr.length;
    while (idx < entriesLength || accumIdx < entriesAccumLength) {
      const entry = idx < entriesLength ? entries[idx] : void 0;
      const prevEntry = idx > 0 ? entries[idx - 1] : void 0;
      const nextEntry = idx < entriesLength - 1 ? entries[idx + 1] : void 0;
      const entryAccum = accumIdx < entriesAccumLength ? entriesAccumCurr[accumIdx] : void 0;
      const prevEntryAccum = accumIdx > 0 ? entriesAccumCurr[accumIdx - 1] : void 0;
      const nextEntryAccum = accumIdx < entriesAccumLength - 1 ? entriesAccumCurr[accumIdx + 1] : void 0;
      if (defined_default(entry) && defined_default(entryAccum) && entry.height === entryAccum.height) {
        const isSplitAccum = defined_default(nextEntryAccum) && entryAccum.height === nextEntryAccum.height;
        const isStartAccum = !defined_default(prevEntryAccum);
        const isEndAccum = !defined_default(nextEntryAccum);
        const isSplit = defined_default(nextEntry) && entry.height === nextEntry.height;
        const isStart = !defined_default(prevEntry);
        const isEnd = !defined_default(nextEntry);
        if (isSplitAccum) {
          if (isSplit) {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
            addBlendEntry(entry.height, nextEntry.color, nextEntryAccum.color);
          } else if (isStart) {
            addEntry(entry.height, entryAccum.color);
            addBlendEntry(entry.height, entry.color, nextEntryAccum.color);
          } else if (isEnd) {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
            addEntry(entry.height, nextEntryAccum.color);
          } else {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
            addBlendEntry(entry.height, entry.color, nextEntryAccum.color);
          }
        } else if (isStartAccum) {
          if (isSplit) {
            addEntry(entry.height, entry.color);
            addBlendEntry(entry.height, nextEntry.color, entryAccum.color);
          } else if (isEnd) {
            addEntry(entry.height, entry.color);
            addEntry(entry.height, entryAccum.color);
          } else if (isStart) {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
          } else {
            addEntry(entry.height, entry.color);
            addBlendEntry(entry.height, entry.color, entryAccum.color);
          }
        } else if (isEndAccum) {
          if (isSplit) {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
            addEntry(entry.height, nextEntry.color);
          } else if (isStart) {
            addEntry(entry.height, entryAccum.color);
            addEntry(entry.height, entry.color);
          } else if (isEnd) {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
          } else {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
            addEntry(entry.height, entry.color);
          }
        } else {
          if (isSplit) {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
            addBlendEntry(entry.height, nextEntry.color, entryAccum.color);
          } else if (isStart) {
            addEntry(entry.height, entryAccum.color);
            addBlendEntry(entry.height, entry.color, entryAccum.color);
          } else if (isEnd) {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
            addEntry(entry.height, entryAccum.color);
          } else {
            addBlendEntry(entry.height, entry.color, entryAccum.color);
          }
        }
        idx += isSplit ? 2 : 1;
        accumIdx += isSplitAccum ? 2 : 1;
      } else if (defined_default(entry) && defined_default(entryAccum) && defined_default(prevEntryAccum) && entry.height < entryAccum.height) {
        const colorBelow = lerpEntryColor(
          entry.height,
          prevEntryAccum,
          entryAccum,
          scratchColorBelow
        );
        if (!defined_default(prevEntry)) {
          addEntry(entry.height, colorBelow);
          addBlendEntry(entry.height, entry.color, colorBelow);
        } else if (!defined_default(nextEntry)) {
          addBlendEntry(entry.height, entry.color, colorBelow);
          addEntry(entry.height, colorBelow);
        } else {
          addBlendEntry(entry.height, entry.color, colorBelow);
        }
        idx++;
      } else if (defined_default(entryAccum) && defined_default(entry) && defined_default(prevEntry) && entryAccum.height < entry.height) {
        const colorAbove = lerpEntryColor(
          entryAccum.height,
          prevEntry,
          entry,
          scratchColorAbove
        );
        if (!defined_default(prevEntryAccum)) {
          addEntry(entryAccum.height, colorAbove);
          addBlendEntry(entryAccum.height, colorAbove, entryAccum.color);
        } else if (!defined_default(nextEntryAccum)) {
          addBlendEntry(entryAccum.height, colorAbove, entryAccum.color);
          addEntry(entryAccum.height, colorAbove);
        } else {
          addBlendEntry(entryAccum.height, colorAbove, entryAccum.color);
        }
        accumIdx++;
      } else if (defined_default(entry) && (!defined_default(entryAccum) || entry.height < entryAccum.height)) {
        if (defined_default(entryAccum) && !defined_default(prevEntryAccum) && !defined_default(nextEntry)) {
          addEntry(entry.height, entry.color);
          addEntry(entry.height, createElevationBandMaterial._emptyColor);
          addEntry(entryAccum.height, createElevationBandMaterial._emptyColor);
        } else if (!defined_default(entryAccum) && defined_default(prevEntryAccum) && !defined_default(prevEntry)) {
          addEntry(
            prevEntryAccum.height,
            createElevationBandMaterial._emptyColor
          );
          addEntry(entry.height, createElevationBandMaterial._emptyColor);
          addEntry(entry.height, entry.color);
        } else {
          addEntry(entry.height, entry.color);
        }
        idx++;
      } else if (defined_default(entryAccum) && (!defined_default(entry) || entryAccum.height < entry.height)) {
        addEntry(entryAccum.height, entryAccum.color);
        accumIdx++;
      }
    }
  }
  const allEntries = removeDuplicates2(entriesAccumNext);
  return allEntries;
}
function createElevationBandMaterial(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const scene = options.scene;
  const layers = options.layers;
  Check_default.typeOf.object("options.scene", scene);
  Check_default.defined("options.layers", layers);
  Check_default.typeOf.number.greaterThan("options.layers.length", layers.length, 0);
  const entries = createLayeredEntries(layers);
  const entriesLength = entries.length;
  let i2;
  let heightTexBuffer;
  let heightTexDatatype;
  let heightTexFormat;
  const isPackedHeight = !createElevationBandMaterial._useFloatTexture(
    scene.context
  );
  if (isPackedHeight) {
    heightTexDatatype = PixelDatatype_default.UNSIGNED_BYTE;
    heightTexFormat = PixelFormat_default.RGBA;
    heightTexBuffer = new Uint8Array(entriesLength * 4);
    for (i2 = 0; i2 < entriesLength; i2++) {
      Cartesian4_default.packFloat(entries[i2].height, scratchPackedFloat);
      Cartesian4_default.pack(scratchPackedFloat, heightTexBuffer, i2 * 4);
    }
  } else {
    heightTexDatatype = PixelDatatype_default.FLOAT;
    heightTexFormat = PixelFormat_default.LUMINANCE;
    heightTexBuffer = new Float32Array(entriesLength);
    for (i2 = 0; i2 < entriesLength; i2++) {
      heightTexBuffer[i2] = entries[i2].height;
    }
  }
  const heightsTex = Texture_default.create({
    context: scene.context,
    pixelFormat: heightTexFormat,
    pixelDatatype: heightTexDatatype,
    source: {
      arrayBufferView: heightTexBuffer,
      width: entriesLength,
      height: 1
    },
    sampler: new Sampler_default({
      wrapS: TextureWrap_default.CLAMP_TO_EDGE,
      wrapT: TextureWrap_default.CLAMP_TO_EDGE,
      minificationFilter: TextureMinificationFilter_default.NEAREST,
      magnificationFilter: TextureMagnificationFilter_default.NEAREST
    })
  });
  const colorsArray = new Uint8Array(entriesLength * 4);
  for (i2 = 0; i2 < entriesLength; i2++) {
    const color = entries[i2].color;
    color.toBytes(scratchColorBytes2);
    colorsArray[i2 * 4 + 0] = scratchColorBytes2[0];
    colorsArray[i2 * 4 + 1] = scratchColorBytes2[1];
    colorsArray[i2 * 4 + 2] = scratchColorBytes2[2];
    colorsArray[i2 * 4 + 3] = scratchColorBytes2[3];
  }
  const colorsTex = Texture_default.create({
    context: scene.context,
    pixelFormat: PixelFormat_default.RGBA,
    pixelDatatype: PixelDatatype_default.UNSIGNED_BYTE,
    source: {
      arrayBufferView: colorsArray,
      width: entriesLength,
      height: 1
    },
    sampler: new Sampler_default({
      wrapS: TextureWrap_default.CLAMP_TO_EDGE,
      wrapT: TextureWrap_default.CLAMP_TO_EDGE,
      minificationFilter: TextureMinificationFilter_default.LINEAR,
      magnificationFilter: TextureMagnificationFilter_default.LINEAR
    })
  });
  const material = Material_default.fromType("ElevationBand", {
    heights: heightsTex,
    colors: colorsTex
  });
  return material;
}
createElevationBandMaterial._useFloatTexture = function(context) {
  return context.floatingPointTexture;
};
createElevationBandMaterial._maximumHeight = 5906376425472;
createElevationBandMaterial._minimumHeight = -5906376425472;
createElevationBandMaterial._emptyColor = new Color_default(0, 0, 0, 0);
var createElevationBandMaterial_default = createElevationBandMaterial;

// node_modules/cesium/Source/Scene/createOsmBuildings.js
function createOsmBuildings(options) {
  options = combine_default(options, {
    url: IonResource_default.fromAssetId(96188)
  });
  const tileset = new Cesium3DTileset_default(options);
  let style = options.style;
  if (!defined_default(style)) {
    const color = defaultValue_default(
      options.defaultColor,
      Color_default.WHITE
    ).toCssColorString();
    style = new Cesium3DTileStyle_default({
      color: `Boolean(\${feature['cesium#color']}) ? color(\${feature['cesium#color']}) : ${color}`
    });
  }
  tileset.style = style;
  return tileset;
}
var createOsmBuildings_default = createOsmBuildings;

// node_modules/cesium/Source/Scene/createTangentSpaceDebugPrimitive.js
function createTangentSpaceDebugPrimitive(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const instances = [];
  let geometry = options.geometry;
  if (!defined_default(geometry)) {
    throw new DeveloperError_default("options.geometry is required.");
  }
  if (!defined_default(geometry.attributes) || !defined_default(geometry.primitiveType)) {
    geometry = geometry.constructor.createGeometry(geometry);
  }
  const attributes = geometry.attributes;
  const modelMatrix = Matrix4_default.clone(
    defaultValue_default(options.modelMatrix, Matrix4_default.IDENTITY)
  );
  const length3 = defaultValue_default(options.length, 1e4);
  if (defined_default(attributes.normal)) {
    instances.push(
      new GeometryInstance_default({
        geometry: GeometryPipeline_default.createLineSegmentsForVectors(
          geometry,
          "normal",
          length3
        ),
        attributes: {
          color: new ColorGeometryInstanceAttribute_default(1, 0, 0, 1)
        },
        modelMatrix
      })
    );
  }
  if (defined_default(attributes.tangent)) {
    instances.push(
      new GeometryInstance_default({
        geometry: GeometryPipeline_default.createLineSegmentsForVectors(
          geometry,
          "tangent",
          length3
        ),
        attributes: {
          color: new ColorGeometryInstanceAttribute_default(0, 1, 0, 1)
        },
        modelMatrix
      })
    );
  }
  if (defined_default(attributes.bitangent)) {
    instances.push(
      new GeometryInstance_default({
        geometry: GeometryPipeline_default.createLineSegmentsForVectors(
          geometry,
          "bitangent",
          length3
        ),
        attributes: {
          color: new ColorGeometryInstanceAttribute_default(0, 0, 1, 1)
        },
        modelMatrix
      })
    );
  }
  if (instances.length > 0) {
    return new Primitive_default({
      asynchronous: false,
      geometryInstances: instances,
      appearance: new PerInstanceColorAppearance_default({
        flat: true,
        translucent: false
      })
    });
  }
  return void 0;
}
var createTangentSpaceDebugPrimitive_default = createTangentSpaceDebugPrimitive;

// node_modules/cesium/Source/Scene/createWorldImagery.js
function createWorldImagery(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const style = defaultValue_default(options.style, IonWorldImageryStyle_default.AERIAL);
  return new IonImageryProvider_default({
    assetId: style
  });
}
var createWorldImagery_default = createWorldImagery;

// node_modules/cesium/Source/ThirdParty/knockout-3.5.1.js
var oldValue;
if (typeof ko !== "undefined") {
  oldValue = ko;
}
(function() {
  (function() {
    (function(n2) {
      var A = this || (0, eval)("this"), w = A.document, R = A.navigator, v7 = A.jQuery, H = A.JSON;
      v7 || "undefined" === typeof jQuery || (v7 = jQuery);
      (function(n3) {
        n3(A.ko = {});
      })(function(S, T) {
        function K(a5, c14) {
          return null === a5 || typeof a5 in W ? a5 === c14 : false;
        }
        function X(b, c14) {
          var d;
          return function() {
            d || (d = a4.a.setTimeout(function() {
              d = n2;
              b();
            }, c14));
          };
        }
        function Y(b, c14) {
          var d;
          return function() {
            clearTimeout(d);
            d = a4.a.setTimeout(b, c14);
          };
        }
        function Z(a5, c14) {
          c14 && "change" !== c14 ? "beforeChange" === c14 ? this.pc(a5) : this.gb(a5, c14) : this.qc(a5);
        }
        function aa(a5, c14) {
          null !== c14 && c14.s && c14.s();
        }
        function ba(a5, c14) {
          var d = this.qd, e2 = d[r2];
          e2.ra || (this.Qb && this.mb[c14] ? (d.uc(c14, a5, this.mb[c14]), this.mb[c14] = null, --this.Qb) : e2.I[c14] || d.uc(c14, a5, e2.J ? { da: a5 } : d.$c(a5)), a5.Ja && a5.gd());
        }
        var a4 = "undefined" !== typeof S ? S : {};
        a4.b = function(b, c14) {
          for (var d = b.split("."), e2 = a4, f2 = 0; f2 < d.length - 1; f2++)
            e2 = e2[d[f2]];
          e2[d[d.length - 1]] = c14;
        };
        a4.L = function(a5, c14, d) {
          a5[c14] = d;
        };
        a4.version = "3.5.1";
        a4.b(
          "version",
          a4.version
        );
        a4.options = { deferUpdates: false, useOnlyNativeEvents: false, foreachHidesDestroyed: false };
        a4.a = function() {
          function b(a5, b2) {
            for (var c15 in a5)
              f2.call(a5, c15) && b2(c15, a5[c15]);
          }
          function c14(a5, b2) {
            if (b2)
              for (var c15 in b2)
                f2.call(b2, c15) && (a5[c15] = b2[c15]);
            return a5;
          }
          function d(a5, b2) {
            a5.__proto__ = b2;
            return a5;
          }
          function e2(b2, c15, d2, e3) {
            var l3 = b2[c15].match(q) || [];
            a4.a.D(d2.match(q), function(b3) {
              a4.a.Na(l3, b3, e3);
            });
            b2[c15] = l3.join(" ");
          }
          var f2 = Object.prototype.hasOwnProperty, g = { __proto__: [] } instanceof Array, h = "function" === typeof Symbol, m = {}, k = {};
          m[R && /Firefox\/2/i.test(R.userAgent) ? "KeyboardEvent" : "UIEvents"] = ["keyup", "keydown", "keypress"];
          m.MouseEvents = "click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave".split(" ");
          b(m, function(a5, b2) {
            if (b2.length)
              for (var c15 = 0, d2 = b2.length; c15 < d2; c15++)
                k[b2[c15]] = a5;
          });
          var l2 = { propertychange: true }, p2 = w && function() {
            for (var a5 = 3, b2 = w.createElement("div"), c15 = b2.getElementsByTagName("i"); b2.innerHTML = "<!--[if gt IE " + ++a5 + "]><i></i><![endif]-->", c15[0]; )
              ;
            return 4 < a5 ? a5 : n2;
          }(), q = /\S+/g, t;
          return {
            Jc: ["authenticity_token", /^__RequestVerificationToken(_.*)?$/],
            D: function(a5, b2, c15) {
              for (var d2 = 0, e3 = a5.length; d2 < e3; d2++)
                b2.call(c15, a5[d2], d2, a5);
            },
            A: "function" == typeof Array.prototype.indexOf ? function(a5, b2) {
              return Array.prototype.indexOf.call(a5, b2);
            } : function(a5, b2) {
              for (var c15 = 0, d2 = a5.length; c15 < d2; c15++)
                if (a5[c15] === b2)
                  return c15;
              return -1;
            },
            Lb: function(a5, b2, c15) {
              for (var d2 = 0, e3 = a5.length; d2 < e3; d2++)
                if (b2.call(c15, a5[d2], d2, a5))
                  return a5[d2];
              return n2;
            },
            Pa: function(b2, c15) {
              var d2 = a4.a.A(b2, c15);
              0 < d2 ? b2.splice(d2, 1) : 0 === d2 && b2.shift();
            },
            wc: function(b2) {
              var c15 = [];
              b2 && a4.a.D(b2, function(b3) {
                0 > a4.a.A(c15, b3) && c15.push(b3);
              });
              return c15;
            },
            Mb: function(a5, b2, c15) {
              var d2 = [];
              if (a5)
                for (var e3 = 0, l3 = a5.length; e3 < l3; e3++)
                  d2.push(b2.call(c15, a5[e3], e3));
              return d2;
            },
            jb: function(a5, b2, c15) {
              var d2 = [];
              if (a5)
                for (var e3 = 0, l3 = a5.length; e3 < l3; e3++)
                  b2.call(c15, a5[e3], e3) && d2.push(a5[e3]);
              return d2;
            },
            Nb: function(a5, b2) {
              if (b2 instanceof Array)
                a5.push.apply(a5, b2);
              else
                for (var c15 = 0, d2 = b2.length; c15 < d2; c15++)
                  a5.push(b2[c15]);
              return a5;
            },
            Na: function(b2, c15, d2) {
              var e3 = a4.a.A(a4.a.bc(b2), c15);
              0 > e3 ? d2 && b2.push(c15) : d2 || b2.splice(e3, 1);
            },
            Ba: g,
            extend: c14,
            setPrototypeOf: d,
            Ab: g ? d : c14,
            P: b,
            Ga: function(a5, b2, c15) {
              if (!a5)
                return a5;
              var d2 = {}, e3;
              for (e3 in a5)
                f2.call(a5, e3) && (d2[e3] = b2.call(c15, a5[e3], e3, a5));
              return d2;
            },
            Tb: function(b2) {
              for (; b2.firstChild; )
                a4.removeNode(b2.firstChild);
            },
            Yb: function(b2) {
              b2 = a4.a.la(b2);
              for (var c15 = (b2[0] && b2[0].ownerDocument || w).createElement("div"), d2 = 0, e3 = b2.length; d2 < e3; d2++)
                c15.appendChild(a4.oa(b2[d2]));
              return c15;
            },
            Ca: function(b2, c15) {
              for (var d2 = 0, e3 = b2.length, l3 = []; d2 < e3; d2++) {
                var k2 = b2[d2].cloneNode(true);
                l3.push(c15 ? a4.oa(k2) : k2);
              }
              return l3;
            },
            va: function(b2, c15) {
              a4.a.Tb(b2);
              if (c15)
                for (var d2 = 0, e3 = c15.length; d2 < e3; d2++)
                  b2.appendChild(c15[d2]);
            },
            Xc: function(b2, c15) {
              var d2 = b2.nodeType ? [b2] : b2;
              if (0 < d2.length) {
                for (var e3 = d2[0], l3 = e3.parentNode, k2 = 0, f3 = c15.length; k2 < f3; k2++)
                  l3.insertBefore(c15[k2], e3);
                k2 = 0;
                for (f3 = d2.length; k2 < f3; k2++)
                  a4.removeNode(d2[k2]);
              }
            },
            Ua: function(a5, b2) {
              if (a5.length) {
                for (b2 = 8 === b2.nodeType && b2.parentNode || b2; a5.length && a5[0].parentNode !== b2; )
                  a5.splice(0, 1);
                for (; 1 < a5.length && a5[a5.length - 1].parentNode !== b2; )
                  a5.length--;
                if (1 < a5.length) {
                  var c15 = a5[0], d2 = a5[a5.length - 1];
                  for (a5.length = 0; c15 !== d2; )
                    a5.push(c15), c15 = c15.nextSibling;
                  a5.push(d2);
                }
              }
              return a5;
            },
            Zc: function(a5, b2) {
              7 > p2 ? a5.setAttribute("selected", b2) : a5.selected = b2;
            },
            Db: function(a5) {
              return null === a5 || a5 === n2 ? "" : a5.trim ? a5.trim() : a5.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g, "");
            },
            Ud: function(a5, b2) {
              a5 = a5 || "";
              return b2.length > a5.length ? false : a5.substring(0, b2.length) === b2;
            },
            vd: function(a5, b2) {
              if (a5 === b2)
                return true;
              if (11 === a5.nodeType)
                return false;
              if (b2.contains)
                return b2.contains(1 !== a5.nodeType ? a5.parentNode : a5);
              if (b2.compareDocumentPosition)
                return 16 == (b2.compareDocumentPosition(a5) & 16);
              for (; a5 && a5 != b2; )
                a5 = a5.parentNode;
              return !!a5;
            },
            Sb: function(b2) {
              return a4.a.vd(b2, b2.ownerDocument.documentElement);
            },
            kd: function(b2) {
              return !!a4.a.Lb(b2, a4.a.Sb);
            },
            R: function(a5) {
              return a5 && a5.tagName && a5.tagName.toLowerCase();
            },
            Ac: function(b2) {
              return a4.onError ? function() {
                try {
                  return b2.apply(this, arguments);
                } catch (c15) {
                  throw a4.onError && a4.onError(c15), c15;
                }
              } : b2;
            },
            setTimeout: function(b2, c15) {
              return setTimeout(a4.a.Ac(b2), c15);
            },
            Gc: function(b2) {
              setTimeout(function() {
                a4.onError && a4.onError(b2);
                throw b2;
              }, 0);
            },
            B: function(b2, c15, d2) {
              var e3 = a4.a.Ac(d2);
              d2 = l2[c15];
              if (a4.options.useOnlyNativeEvents || d2 || !v7)
                if (d2 || "function" != typeof b2.addEventListener)
                  if ("undefined" != typeof b2.attachEvent) {
                    var k2 = function(a5) {
                      e3.call(b2, a5);
                    }, f3 = "on" + c15;
                    b2.attachEvent(
                      f3,
                      k2
                    );
                    a4.a.K.za(b2, function() {
                      b2.detachEvent(f3, k2);
                    });
                  } else
                    throw Error("Browser doesn't support addEventListener or attachEvent");
                else
                  b2.addEventListener(c15, e3, false);
              else
                t || (t = "function" == typeof v7(b2).on ? "on" : "bind"), v7(b2)[t](c15, e3);
            },
            Fb: function(b2, c15) {
              if (!b2 || !b2.nodeType)
                throw Error("element must be a DOM node when calling triggerEvent");
              var d2;
              "input" === a4.a.R(b2) && b2.type && "click" == c15.toLowerCase() ? (d2 = b2.type, d2 = "checkbox" == d2 || "radio" == d2) : d2 = false;
              if (a4.options.useOnlyNativeEvents || !v7 || d2)
                if ("function" == typeof w.createEvent)
                  if ("function" == typeof b2.dispatchEvent)
                    d2 = w.createEvent(k[c15] || "HTMLEvents"), d2.initEvent(c15, true, true, A, 0, 0, 0, 0, 0, false, false, false, false, 0, b2), b2.dispatchEvent(d2);
                  else
                    throw Error("The supplied element doesn't support dispatchEvent");
                else if (d2 && b2.click)
                  b2.click();
                else if ("undefined" != typeof b2.fireEvent)
                  b2.fireEvent("on" + c15);
                else
                  throw Error("Browser doesn't support triggering events");
              else
                v7(b2).trigger(c15);
            },
            f: function(b2) {
              return a4.O(b2) ? b2() : b2;
            },
            bc: function(b2) {
              return a4.O(b2) ? b2.v() : b2;
            },
            Eb: function(b2, c15, d2) {
              var l3;
              c15 && ("object" === typeof b2.classList ? (l3 = b2.classList[d2 ? "add" : "remove"], a4.a.D(c15.match(q), function(a5) {
                l3.call(b2.classList, a5);
              })) : "string" === typeof b2.className.baseVal ? e2(b2.className, "baseVal", c15, d2) : e2(b2, "className", c15, d2));
            },
            Bb: function(b2, c15) {
              var d2 = a4.a.f(c15);
              if (null === d2 || d2 === n2)
                d2 = "";
              var e3 = a4.h.firstChild(b2);
              !e3 || 3 != e3.nodeType || a4.h.nextSibling(e3) ? a4.h.va(b2, [b2.ownerDocument.createTextNode(d2)]) : e3.data = d2;
              a4.a.Ad(b2);
            },
            Yc: function(a5, b2) {
              a5.name = b2;
              if (7 >= p2)
                try {
                  var c15 = a5.name.replace(/[&<>'"]/g, function(a6) {
                    return "&#" + a6.charCodeAt(0) + ";";
                  });
                  a5.mergeAttributes(w.createElement("<input name='" + c15 + "'/>"), false);
                } catch (d2) {
                }
            },
            Ad: function(a5) {
              9 <= p2 && (a5 = 1 == a5.nodeType ? a5 : a5.parentNode, a5.style && (a5.style.zoom = a5.style.zoom));
            },
            wd: function(a5) {
              if (p2) {
                var b2 = a5.style.width;
                a5.style.width = 0;
                a5.style.width = b2;
              }
            },
            Pd: function(b2, c15) {
              b2 = a4.a.f(b2);
              c15 = a4.a.f(c15);
              for (var d2 = [], e3 = b2; e3 <= c15; e3++)
                d2.push(e3);
              return d2;
            },
            la: function(a5) {
              for (var b2 = [], c15 = 0, d2 = a5.length; c15 < d2; c15++)
                b2.push(a5[c15]);
              return b2;
            },
            Da: function(a5) {
              return h ? Symbol(a5) : a5;
            },
            Zd: 6 === p2,
            $d: 7 === p2,
            W: p2,
            Lc: function(b2, c15) {
              for (var d2 = a4.a.la(b2.getElementsByTagName("input")).concat(a4.a.la(b2.getElementsByTagName("textarea"))), e3 = "string" == typeof c15 ? function(a5) {
                return a5.name === c15;
              } : function(a5) {
                return c15.test(a5.name);
              }, l3 = [], k2 = d2.length - 1; 0 <= k2; k2--)
                e3(d2[k2]) && l3.push(d2[k2]);
              return l3;
            },
            Nd: function(b2) {
              return "string" == typeof b2 && (b2 = a4.a.Db(b2)) ? H && H.parse ? H.parse(b2) : new Function("return " + b2)() : null;
            },
            hc: function(b2, c15, d2) {
              if (!H || !H.stringify)
                throw Error("Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js");
              return H.stringify(a4.a.f(b2), c15, d2);
            },
            Od: function(c15, d2, e3) {
              e3 = e3 || {};
              var l3 = e3.params || {}, k2 = e3.includeFields || this.Jc, f3 = c15;
              if ("object" == typeof c15 && "form" === a4.a.R(c15))
                for (var f3 = c15.action, h2 = k2.length - 1; 0 <= h2; h2--)
                  for (var g2 = a4.a.Lc(c15, k2[h2]), m2 = g2.length - 1; 0 <= m2; m2--)
                    l3[g2[m2].name] = g2[m2].value;
              d2 = a4.a.f(d2);
              var p3 = w.createElement("form");
              p3.style.display = "none";
              p3.action = f3;
              p3.method = "post";
              for (var q3 in d2)
                c15 = w.createElement("input"), c15.type = "hidden", c15.name = q3, c15.value = a4.a.hc(a4.a.f(d2[q3])), p3.appendChild(c15);
              b(l3, function(a5, b2) {
                var c16 = w.createElement("input");
                c16.type = "hidden";
                c16.name = a5;
                c16.value = b2;
                p3.appendChild(c16);
              });
              w.body.appendChild(p3);
              e3.submitter ? e3.submitter(p3) : p3.submit();
              setTimeout(function() {
                p3.parentNode.removeChild(p3);
              }, 0);
            }
          };
        }();
        a4.b("utils", a4.a);
        a4.b("utils.arrayForEach", a4.a.D);
        a4.b("utils.arrayFirst", a4.a.Lb);
        a4.b("utils.arrayFilter", a4.a.jb);
        a4.b("utils.arrayGetDistinctValues", a4.a.wc);
        a4.b("utils.arrayIndexOf", a4.a.A);
        a4.b("utils.arrayMap", a4.a.Mb);
        a4.b("utils.arrayPushAll", a4.a.Nb);
        a4.b("utils.arrayRemoveItem", a4.a.Pa);
        a4.b("utils.cloneNodes", a4.a.Ca);
        a4.b(
          "utils.createSymbolOrString",
          a4.a.Da
        );
        a4.b("utils.extend", a4.a.extend);
        a4.b("utils.fieldsIncludedWithJsonPost", a4.a.Jc);
        a4.b("utils.getFormFields", a4.a.Lc);
        a4.b("utils.objectMap", a4.a.Ga);
        a4.b("utils.peekObservable", a4.a.bc);
        a4.b("utils.postJson", a4.a.Od);
        a4.b("utils.parseJson", a4.a.Nd);
        a4.b("utils.registerEventHandler", a4.a.B);
        a4.b("utils.stringifyJson", a4.a.hc);
        a4.b("utils.range", a4.a.Pd);
        a4.b("utils.toggleDomNodeCssClass", a4.a.Eb);
        a4.b("utils.triggerEvent", a4.a.Fb);
        a4.b("utils.unwrapObservable", a4.a.f);
        a4.b("utils.objectForEach", a4.a.P);
        a4.b(
          "utils.addOrRemoveItem",
          a4.a.Na
        );
        a4.b("utils.setTextContent", a4.a.Bb);
        a4.b("unwrap", a4.a.f);
        Function.prototype.bind || (Function.prototype.bind = function(a5) {
          var c14 = this;
          if (1 === arguments.length)
            return function() {
              return c14.apply(a5, arguments);
            };
          var d = Array.prototype.slice.call(arguments, 1);
          return function() {
            var e2 = d.slice(0);
            e2.push.apply(e2, arguments);
            return c14.apply(a5, e2);
          };
        });
        a4.a.g = new function() {
          var b = 0, c14 = "__ko__" + new Date().getTime(), d = {}, e2, f2;
          a4.a.W ? (e2 = function(a5, e3) {
            var f3 = a5[c14];
            if (!f3 || "null" === f3 || !d[f3]) {
              if (!e3)
                return n2;
              f3 = a5[c14] = "ko" + b++;
              d[f3] = {};
            }
            return d[f3];
          }, f2 = function(a5) {
            var b2 = a5[c14];
            return b2 ? (delete d[b2], a5[c14] = null, true) : false;
          }) : (e2 = function(a5, b2) {
            var d2 = a5[c14];
            !d2 && b2 && (d2 = a5[c14] = {});
            return d2;
          }, f2 = function(a5) {
            return a5[c14] ? (delete a5[c14], true) : false;
          });
          return { get: function(a5, b2) {
            var c15 = e2(a5, false);
            return c15 && c15[b2];
          }, set: function(a5, b2, c15) {
            (a5 = e2(a5, c15 !== n2)) && (a5[b2] = c15);
          }, Ub: function(a5, b2, c15) {
            a5 = e2(a5, true);
            return a5[b2] || (a5[b2] = c15);
          }, clear: f2, Z: function() {
            return b++ + c14;
          } };
        }();
        a4.b("utils.domData", a4.a.g);
        a4.b("utils.domData.clear", a4.a.g.clear);
        a4.a.K = new function() {
          function b(b2, c15) {
            var d2 = a4.a.g.get(b2, e2);
            d2 === n2 && c15 && (d2 = [], a4.a.g.set(b2, e2, d2));
            return d2;
          }
          function c14(c15) {
            var e3 = b(c15, false);
            if (e3)
              for (var e3 = e3.slice(0), k = 0; k < e3.length; k++)
                e3[k](c15);
            a4.a.g.clear(c15);
            a4.a.K.cleanExternalData(c15);
            g[c15.nodeType] && d(c15.childNodes, true);
          }
          function d(b2, d2) {
            for (var e3 = [], l2, f3 = 0; f3 < b2.length; f3++)
              if (!d2 || 8 === b2[f3].nodeType) {
                if (c14(e3[e3.length] = l2 = b2[f3]), b2[f3] !== l2)
                  for (; f3-- && -1 == a4.a.A(e3, b2[f3]); )
                    ;
              }
          }
          var e2 = a4.a.g.Z(), f2 = { 1: true, 8: true, 9: true }, g = { 1: true, 9: true };
          return { za: function(a5, c15) {
            if ("function" != typeof c15)
              throw Error("Callback must be a function");
            b(a5, true).push(c15);
          }, yb: function(c15, d2) {
            var f3 = b(c15, false);
            f3 && (a4.a.Pa(f3, d2), 0 == f3.length && a4.a.g.set(c15, e2, n2));
          }, oa: function(b2) {
            a4.u.G(function() {
              f2[b2.nodeType] && (c14(b2), g[b2.nodeType] && d(b2.getElementsByTagName("*")));
            });
            return b2;
          }, removeNode: function(b2) {
            a4.oa(b2);
            b2.parentNode && b2.parentNode.removeChild(b2);
          }, cleanExternalData: function(a5) {
            v7 && "function" == typeof v7.cleanData && v7.cleanData([a5]);
          } };
        }();
        a4.oa = a4.a.K.oa;
        a4.removeNode = a4.a.K.removeNode;
        a4.b("cleanNode", a4.oa);
        a4.b("removeNode", a4.removeNode);
        a4.b("utils.domNodeDisposal", a4.a.K);
        a4.b(
          "utils.domNodeDisposal.addDisposeCallback",
          a4.a.K.za
        );
        a4.b("utils.domNodeDisposal.removeDisposeCallback", a4.a.K.yb);
        (function() {
          var b = [0, "", ""], c14 = [1, "<table>", "</table>"], d = [3, "<table><tbody><tr>", "</tr></tbody></table>"], e2 = [1, "<select multiple='multiple'>", "</select>"], f2 = { thead: c14, tbody: c14, tfoot: c14, tr: [2, "<table><tbody>", "</tbody></table>"], td: d, th: d, option: e2, optgroup: e2 }, g = 8 >= a4.a.W;
          a4.a.ua = function(c15, d2) {
            var e3;
            if (v7)
              if (v7.parseHTML)
                e3 = v7.parseHTML(c15, d2) || [];
              else {
                if ((e3 = v7.clean([c15], d2)) && e3[0]) {
                  for (var l2 = e3[0]; l2.parentNode && 11 !== l2.parentNode.nodeType; )
                    l2 = l2.parentNode;
                  l2.parentNode && l2.parentNode.removeChild(l2);
                }
              }
            else {
              (e3 = d2) || (e3 = w);
              var l2 = e3.parentWindow || e3.defaultView || A, p2 = a4.a.Db(c15).toLowerCase(), q = e3.createElement("div"), t;
              t = (p2 = p2.match(/^(?:\x3c!--.*?--\x3e\s*?)*?<([a-z]+)[\s>]/)) && f2[p2[1]] || b;
              p2 = t[0];
              t = "ignored<div>" + t[1] + c15 + t[2] + "</div>";
              "function" == typeof l2.innerShiv ? q.appendChild(l2.innerShiv(t)) : (g && e3.body.appendChild(q), q.innerHTML = t, g && q.parentNode.removeChild(q));
              for (; p2--; )
                q = q.lastChild;
              e3 = a4.a.la(q.lastChild.childNodes);
            }
            return e3;
          };
          a4.a.Md = function(b2, c15) {
            var d2 = a4.a.ua(
              b2,
              c15
            );
            return d2.length && d2[0].parentElement || a4.a.Yb(d2);
          };
          a4.a.fc = function(b2, c15) {
            a4.a.Tb(b2);
            c15 = a4.a.f(c15);
            if (null !== c15 && c15 !== n2)
              if ("string" != typeof c15 && (c15 = c15.toString()), v7)
                v7(b2).html(c15);
              else
                for (var d2 = a4.a.ua(c15, b2.ownerDocument), e3 = 0; e3 < d2.length; e3++)
                  b2.appendChild(d2[e3]);
          };
        })();
        a4.b("utils.parseHtmlFragment", a4.a.ua);
        a4.b("utils.setHtml", a4.a.fc);
        a4.aa = function() {
          function b(c15, e2) {
            if (c15) {
              if (8 == c15.nodeType) {
                var f2 = a4.aa.Uc(c15.nodeValue);
                null != f2 && e2.push({ ud: c15, Kd: f2 });
              } else if (1 == c15.nodeType)
                for (var f2 = 0, g = c15.childNodes, h = g.length; f2 < h; f2++)
                  b(
                    g[f2],
                    e2
                  );
            }
          }
          var c14 = {};
          return { Xb: function(a5) {
            if ("function" != typeof a5)
              throw Error("You can only pass a function to ko.memoization.memoize()");
            var b2 = (4294967296 * (1 + Math.random()) | 0).toString(16).substring(1) + (4294967296 * (1 + Math.random()) | 0).toString(16).substring(1);
            c14[b2] = a5;
            return "<!--[ko_memo:" + b2 + "]-->";
          }, bd: function(a5, b2) {
            var f2 = c14[a5];
            if (f2 === n2)
              throw Error("Couldn't find any memo with ID " + a5 + ". Perhaps it's already been unmemoized.");
            try {
              return f2.apply(null, b2 || []), true;
            } finally {
              delete c14[a5];
            }
          }, cd: function(c15, e2) {
            var f2 = [];
            b(c15, f2);
            for (var g = 0, h = f2.length; g < h; g++) {
              var m = f2[g].ud, k = [m];
              e2 && a4.a.Nb(k, e2);
              a4.aa.bd(f2[g].Kd, k);
              m.nodeValue = "";
              m.parentNode && m.parentNode.removeChild(m);
            }
          }, Uc: function(a5) {
            return (a5 = a5.match(/^\[ko_memo\:(.*?)\]$/)) ? a5[1] : null;
          } };
        }();
        a4.b("memoization", a4.aa);
        a4.b("memoization.memoize", a4.aa.Xb);
        a4.b("memoization.unmemoize", a4.aa.bd);
        a4.b("memoization.parseMemoText", a4.aa.Uc);
        a4.b("memoization.unmemoizeDomNodeAndDescendants", a4.aa.cd);
        a4.na = function() {
          function b() {
            if (f2) {
              for (var b2 = f2, c15 = 0, d2; h < f2; )
                if (d2 = e2[h++]) {
                  if (h > b2) {
                    if (5e3 <= ++c15) {
                      h = f2;
                      a4.a.Gc(Error("'Too much recursion' after processing " + c15 + " task groups."));
                      break;
                    }
                    b2 = f2;
                  }
                  try {
                    d2();
                  } catch (p2) {
                    a4.a.Gc(p2);
                  }
                }
            }
          }
          function c14() {
            b();
            h = f2 = e2.length = 0;
          }
          var d, e2 = [], f2 = 0, g = 1, h = 0;
          A.MutationObserver ? d = function(a5) {
            var b2 = w.createElement("div");
            new MutationObserver(a5).observe(b2, { attributes: true });
            return function() {
              b2.classList.toggle("foo");
            };
          }(c14) : d = w && "onreadystatechange" in w.createElement("script") ? function(a5) {
            var b2 = w.createElement("script");
            b2.onreadystatechange = function() {
              b2.onreadystatechange = null;
              w.documentElement.removeChild(b2);
              b2 = null;
              a5();
            };
            w.documentElement.appendChild(b2);
          } : function(a5) {
            setTimeout(a5, 0);
          };
          return { scheduler: d, zb: function(b2) {
            f2 || a4.na.scheduler(c14);
            e2[f2++] = b2;
            return g++;
          }, cancel: function(a5) {
            a5 = a5 - (g - f2);
            a5 >= h && a5 < f2 && (e2[a5] = null);
          }, resetForTesting: function() {
            var a5 = f2 - h;
            h = f2 = e2.length = 0;
            return a5;
          }, Sd: b };
        }();
        a4.b("tasks", a4.na);
        a4.b("tasks.schedule", a4.na.zb);
        a4.b("tasks.runEarly", a4.na.Sd);
        a4.Ta = { throttle: function(b, c14) {
          b.throttleEvaluation = c14;
          var d = null;
          return a4.$({ read: b, write: function(e2) {
            clearTimeout(d);
            d = a4.a.setTimeout(
              function() {
                b(e2);
              },
              c14
            );
          } });
        }, rateLimit: function(a5, c14) {
          var d, e2, f2;
          "number" == typeof c14 ? d = c14 : (d = c14.timeout, e2 = c14.method);
          a5.Hb = false;
          f2 = "function" == typeof e2 ? e2 : "notifyWhenChangesStop" == e2 ? Y : X;
          a5.ub(function(a6) {
            return f2(a6, d, c14);
          });
        }, deferred: function(b, c14) {
          if (true !== c14)
            throw Error("The 'deferred' extender only accepts the value 'true', because it is not supported to turn deferral off once enabled.");
          b.Hb || (b.Hb = true, b.ub(function(c15) {
            var e2, f2 = false;
            return function() {
              if (!f2) {
                a4.na.cancel(e2);
                e2 = a4.na.zb(c15);
                try {
                  f2 = true, b.notifySubscribers(n2, "dirty");
                } finally {
                  f2 = false;
                }
              }
            };
          }));
        }, notify: function(a5, c14) {
          a5.equalityComparer = "always" == c14 ? null : K;
        } };
        var W = { undefined: 1, "boolean": 1, number: 1, string: 1 };
        a4.b("extenders", a4.Ta);
        a4.ic = function(b, c14, d) {
          this.da = b;
          this.lc = c14;
          this.mc = d;
          this.Ib = false;
          this.fb = this.Jb = null;
          a4.L(this, "dispose", this.s);
          a4.L(this, "disposeWhenNodeIsRemoved", this.l);
        };
        a4.ic.prototype.s = function() {
          this.Ib || (this.fb && a4.a.K.yb(this.Jb, this.fb), this.Ib = true, this.mc(), this.da = this.lc = this.mc = this.Jb = this.fb = null);
        };
        a4.ic.prototype.l = function(b) {
          this.Jb = b;
          a4.a.K.za(b, this.fb = this.s.bind(this));
        };
        a4.T = function() {
          a4.a.Ab(this, D);
          D.qb(this);
        };
        var D = {
          qb: function(a5) {
            a5.U = { change: [] };
            a5.sc = 1;
          },
          subscribe: function(b, c14, d) {
            var e2 = this;
            d = d || "change";
            var f2 = new a4.ic(e2, c14 ? b.bind(c14) : b, function() {
              a4.a.Pa(e2.U[d], f2);
              e2.hb && e2.hb(d);
            });
            e2.Qa && e2.Qa(d);
            e2.U[d] || (e2.U[d] = []);
            e2.U[d].push(f2);
            return f2;
          },
          notifySubscribers: function(b, c14) {
            c14 = c14 || "change";
            "change" === c14 && this.Gb();
            if (this.Wa(c14)) {
              var d = "change" === c14 && this.ed || this.U[c14].slice(0);
              try {
                a4.u.xc();
                for (var e2 = 0, f2; f2 = d[e2]; ++e2)
                  f2.Ib || f2.lc(b);
              } finally {
                a4.u.end();
              }
            }
          },
          ob: function() {
            return this.sc;
          },
          Dd: function(a5) {
            return this.ob() !== a5;
          },
          Gb: function() {
            ++this.sc;
          },
          ub: function(b) {
            var c14 = this, d = a4.O(c14), e2, f2, g, h, m;
            c14.gb || (c14.gb = c14.notifySubscribers, c14.notifySubscribers = Z);
            var k = b(function() {
              c14.Ja = false;
              d && h === c14 && (h = c14.nc ? c14.nc() : c14());
              var a5 = f2 || m && c14.sb(g, h);
              m = f2 = e2 = false;
              a5 && c14.gb(g = h);
            });
            c14.qc = function(a5, b2) {
              b2 && c14.Ja || (m = !b2);
              c14.ed = c14.U.change.slice(0);
              c14.Ja = e2 = true;
              h = a5;
              k();
            };
            c14.pc = function(a5) {
              e2 || (g = a5, c14.gb(a5, "beforeChange"));
            };
            c14.rc = function() {
              m = true;
            };
            c14.gd = function() {
              c14.sb(g, c14.v(true)) && (f2 = true);
            };
          },
          Wa: function(a5) {
            return this.U[a5] && this.U[a5].length;
          },
          Bd: function(b) {
            if (b)
              return this.U[b] && this.U[b].length || 0;
            var c14 = 0;
            a4.a.P(this.U, function(a5, b2) {
              "dirty" !== a5 && (c14 += b2.length);
            });
            return c14;
          },
          sb: function(a5, c14) {
            return !this.equalityComparer || !this.equalityComparer(a5, c14);
          },
          toString: function() {
            return "[object Object]";
          },
          extend: function(b) {
            var c14 = this;
            b && a4.a.P(b, function(b2, e2) {
              var f2 = a4.Ta[b2];
              "function" == typeof f2 && (c14 = f2(c14, e2) || c14);
            });
            return c14;
          }
        };
        a4.L(D, "init", D.qb);
        a4.L(D, "subscribe", D.subscribe);
        a4.L(D, "extend", D.extend);
        a4.L(D, "getSubscriptionsCount", D.Bd);
        a4.a.Ba && a4.a.setPrototypeOf(
          D,
          Function.prototype
        );
        a4.T.fn = D;
        a4.Qc = function(a5) {
          return null != a5 && "function" == typeof a5.subscribe && "function" == typeof a5.notifySubscribers;
        };
        a4.b("subscribable", a4.T);
        a4.b("isSubscribable", a4.Qc);
        a4.S = a4.u = function() {
          function b(a5) {
            d.push(e2);
            e2 = a5;
          }
          function c14() {
            e2 = d.pop();
          }
          var d = [], e2, f2 = 0;
          return {
            xc: b,
            end: c14,
            cc: function(b2) {
              if (e2) {
                if (!a4.Qc(b2))
                  throw Error("Only subscribable things can act as dependencies");
                e2.od.call(e2.pd, b2, b2.fd || (b2.fd = ++f2));
              }
            },
            G: function(a5, d2, e3) {
              try {
                return b(), a5.apply(d2, e3 || []);
              } finally {
                c14();
              }
            },
            qa: function() {
              if (e2)
                return e2.o.qa();
            },
            Va: function() {
              if (e2)
                return e2.o.Va();
            },
            Ya: function() {
              if (e2)
                return e2.Ya;
            },
            o: function() {
              if (e2)
                return e2.o;
            }
          };
        }();
        a4.b("computedContext", a4.S);
        a4.b("computedContext.getDependenciesCount", a4.S.qa);
        a4.b("computedContext.getDependencies", a4.S.Va);
        a4.b("computedContext.isInitial", a4.S.Ya);
        a4.b("computedContext.registerDependency", a4.S.cc);
        a4.b("ignoreDependencies", a4.Yd = a4.u.G);
        var I = a4.a.Da("_latestValue");
        a4.ta = function(b) {
          function c14() {
            if (0 < arguments.length)
              return c14.sb(c14[I], arguments[0]) && (c14.ya(), c14[I] = arguments[0], c14.xa()), this;
            a4.u.cc(c14);
            return c14[I];
          }
          c14[I] = b;
          a4.a.Ba || a4.a.extend(c14, a4.T.fn);
          a4.T.fn.qb(c14);
          a4.a.Ab(c14, F);
          a4.options.deferUpdates && a4.Ta.deferred(c14, true);
          return c14;
        };
        var F = { equalityComparer: K, v: function() {
          return this[I];
        }, xa: function() {
          this.notifySubscribers(this[I], "spectate");
          this.notifySubscribers(this[I]);
        }, ya: function() {
          this.notifySubscribers(this[I], "beforeChange");
        } };
        a4.a.Ba && a4.a.setPrototypeOf(F, a4.T.fn);
        var G = a4.ta.Ma = "__ko_proto__";
        F[G] = a4.ta;
        a4.O = function(b) {
          if ((b = "function" == typeof b && b[G]) && b !== F[G] && b !== a4.o.fn[G])
            throw Error("Invalid object that looks like an observable; possibly from another Knockout instance");
          return !!b;
        };
        a4.Za = function(b) {
          return "function" == typeof b && (b[G] === F[G] || b[G] === a4.o.fn[G] && b.Nc);
        };
        a4.b("observable", a4.ta);
        a4.b("isObservable", a4.O);
        a4.b("isWriteableObservable", a4.Za);
        a4.b("isWritableObservable", a4.Za);
        a4.b("observable.fn", F);
        a4.L(F, "peek", F.v);
        a4.L(F, "valueHasMutated", F.xa);
        a4.L(F, "valueWillMutate", F.ya);
        a4.Ha = function(b) {
          b = b || [];
          if ("object" != typeof b || !("length" in b))
            throw Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");
          b = a4.ta(b);
          a4.a.Ab(
            b,
            a4.Ha.fn
          );
          return b.extend({ trackArrayChanges: true });
        };
        a4.Ha.fn = { remove: function(b) {
          for (var c14 = this.v(), d = [], e2 = "function" != typeof b || a4.O(b) ? function(a5) {
            return a5 === b;
          } : b, f2 = 0; f2 < c14.length; f2++) {
            var g = c14[f2];
            if (e2(g)) {
              0 === d.length && this.ya();
              if (c14[f2] !== g)
                throw Error("Array modified during remove; cannot remove item");
              d.push(g);
              c14.splice(f2, 1);
              f2--;
            }
          }
          d.length && this.xa();
          return d;
        }, removeAll: function(b) {
          if (b === n2) {
            var c14 = this.v(), d = c14.slice(0);
            this.ya();
            c14.splice(0, c14.length);
            this.xa();
            return d;
          }
          return b ? this.remove(function(c15) {
            return 0 <= a4.a.A(b, c15);
          }) : [];
        }, destroy: function(b) {
          var c14 = this.v(), d = "function" != typeof b || a4.O(b) ? function(a5) {
            return a5 === b;
          } : b;
          this.ya();
          for (var e2 = c14.length - 1; 0 <= e2; e2--) {
            var f2 = c14[e2];
            d(f2) && (f2._destroy = true);
          }
          this.xa();
        }, destroyAll: function(b) {
          return b === n2 ? this.destroy(function() {
            return true;
          }) : b ? this.destroy(function(c14) {
            return 0 <= a4.a.A(b, c14);
          }) : [];
        }, indexOf: function(b) {
          var c14 = this();
          return a4.a.A(c14, b);
        }, replace: function(a5, c14) {
          var d = this.indexOf(a5);
          0 <= d && (this.ya(), this.v()[d] = c14, this.xa());
        }, sorted: function(a5) {
          var c14 = this().slice(0);
          return a5 ? c14.sort(a5) : c14.sort();
        }, reversed: function() {
          return this().slice(0).reverse();
        } };
        a4.a.Ba && a4.a.setPrototypeOf(a4.Ha.fn, a4.ta.fn);
        a4.a.D("pop push reverse shift sort splice unshift".split(" "), function(b) {
          a4.Ha.fn[b] = function() {
            var a5 = this.v();
            this.ya();
            this.zc(a5, b, arguments);
            var d = a5[b].apply(a5, arguments);
            this.xa();
            return d === a5 ? this : d;
          };
        });
        a4.a.D(["slice"], function(b) {
          a4.Ha.fn[b] = function() {
            var a5 = this();
            return a5[b].apply(a5, arguments);
          };
        });
        a4.Pc = function(b) {
          return a4.O(b) && "function" == typeof b.remove && "function" == typeof b.push;
        };
        a4.b("observableArray", a4.Ha);
        a4.b("isObservableArray", a4.Pc);
        a4.Ta.trackArrayChanges = function(b, c14) {
          function d() {
            function c15() {
              if (m) {
                var d2 = [].concat(b.v() || []), e3;
                if (b.Wa("arrayChange")) {
                  if (!f2 || 1 < m)
                    f2 = a4.a.Pb(k, d2, b.Ob);
                  e3 = f2;
                }
                k = d2;
                f2 = null;
                m = 0;
                e3 && e3.length && b.notifySubscribers(e3, "arrayChange");
              }
            }
            e2 ? c15() : (e2 = true, h = b.subscribe(function() {
              ++m;
            }, null, "spectate"), k = [].concat(b.v() || []), f2 = null, g = b.subscribe(c15));
          }
          b.Ob = {};
          c14 && "object" == typeof c14 && a4.a.extend(b.Ob, c14);
          b.Ob.sparse = true;
          if (!b.zc) {
            var e2 = false, f2 = null, g, h, m = 0, k, l2 = b.Qa, p2 = b.hb;
            b.Qa = function(a5) {
              l2 && l2.call(b, a5);
              "arrayChange" === a5 && d();
            };
            b.hb = function(a5) {
              p2 && p2.call(b, a5);
              "arrayChange" !== a5 || b.Wa("arrayChange") || (g && g.s(), h && h.s(), h = g = null, e2 = false, k = n2);
            };
            b.zc = function(b2, c15, d2) {
              function l3(a5, b3, c16) {
                return k2[k2.length] = { status: a5, value: b3, index: c16 };
              }
              if (e2 && !m) {
                var k2 = [], p3 = b2.length, g2 = d2.length, h2 = 0;
                switch (c15) {
                  case "push":
                    h2 = p3;
                  case "unshift":
                    for (c15 = 0; c15 < g2; c15++)
                      l3("added", d2[c15], h2 + c15);
                    break;
                  case "pop":
                    h2 = p3 - 1;
                  case "shift":
                    p3 && l3("deleted", b2[h2], h2);
                    break;
                  case "splice":
                    c15 = Math.min(Math.max(0, 0 > d2[0] ? p3 + d2[0] : d2[0]), p3);
                    for (var p3 = 1 === g2 ? p3 : Math.min(c15 + (d2[1] || 0), p3), g2 = c15 + g2 - 2, h2 = Math.max(p3, g2), U2 = [], L = [], n3 = 2; c15 < h2; ++c15, ++n3)
                      c15 < p3 && L.push(l3("deleted", b2[c15], c15)), c15 < g2 && U2.push(l3("added", d2[n3], c15));
                    a4.a.Kc(L, U2);
                    break;
                  default:
                    return;
                }
                f2 = k2;
              }
            };
          }
        };
        var r2 = a4.a.Da("_state");
        a4.o = a4.$ = function(b, c14, d) {
          function e2() {
            if (0 < arguments.length) {
              if ("function" === typeof f2)
                f2.apply(g.nb, arguments);
              else
                throw Error("Cannot write a value to a ko.computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.");
              return this;
            }
            g.ra || a4.u.cc(e2);
            (g.ka || g.J && e2.Xa()) && e2.ha();
            return g.X;
          }
          "object" === typeof b ? d = b : (d = d || {}, b && (d.read = b));
          if ("function" != typeof d.read)
            throw Error("Pass a function that returns the value of the ko.computed");
          var f2 = d.write, g = { X: n2, sa: true, ka: true, rb: false, jc: false, ra: false, wb: false, J: false, Wc: d.read, nb: c14 || d.owner, l: d.disposeWhenNodeIsRemoved || d.l || null, Sa: d.disposeWhen || d.Sa, Rb: null, I: {}, V: 0, Ic: null };
          e2[r2] = g;
          e2.Nc = "function" === typeof f2;
          a4.a.Ba || a4.a.extend(e2, a4.T.fn);
          a4.T.fn.qb(e2);
          a4.a.Ab(e2, C);
          d.pure ? (g.wb = true, g.J = true, a4.a.extend(e2, da)) : d.deferEvaluation && a4.a.extend(e2, ea);
          a4.options.deferUpdates && a4.Ta.deferred(e2, true);
          g.l && (g.jc = true, g.l.nodeType || (g.l = null));
          g.J || d.deferEvaluation || e2.ha();
          g.l && e2.ja() && a4.a.K.za(g.l, g.Rb = function() {
            e2.s();
          });
          return e2;
        };
        var C = {
          equalityComparer: K,
          qa: function() {
            return this[r2].V;
          },
          Va: function() {
            var b = [];
            a4.a.P(this[r2].I, function(a5, d) {
              b[d.Ka] = d.da;
            });
            return b;
          },
          Vb: function(b) {
            if (!this[r2].V)
              return false;
            var c14 = this.Va();
            return -1 !== a4.a.A(c14, b) ? true : !!a4.a.Lb(c14, function(a5) {
              return a5.Vb && a5.Vb(b);
            });
          },
          uc: function(a5, c14, d) {
            if (this[r2].wb && c14 === this)
              throw Error("A 'pure' computed must not be called recursively");
            this[r2].I[a5] = d;
            d.Ka = this[r2].V++;
            d.La = c14.ob();
          },
          Xa: function() {
            var a5, c14, d = this[r2].I;
            for (a5 in d)
              if (Object.prototype.hasOwnProperty.call(d, a5) && (c14 = d[a5], this.Ia && c14.da.Ja || c14.da.Dd(c14.La)))
                return true;
          },
          Jd: function() {
            this.Ia && !this[r2].rb && this.Ia(false);
          },
          ja: function() {
            var a5 = this[r2];
            return a5.ka || 0 < a5.V;
          },
          Rd: function() {
            this.Ja ? this[r2].ka && (this[r2].sa = true) : this.Hc();
          },
          $c: function(a5) {
            if (a5.Hb) {
              var c14 = a5.subscribe(this.Jd, this, "dirty"), d = a5.subscribe(
                this.Rd,
                this
              );
              return { da: a5, s: function() {
                c14.s();
                d.s();
              } };
            }
            return a5.subscribe(this.Hc, this);
          },
          Hc: function() {
            var b = this, c14 = b.throttleEvaluation;
            c14 && 0 <= c14 ? (clearTimeout(this[r2].Ic), this[r2].Ic = a4.a.setTimeout(function() {
              b.ha(true);
            }, c14)) : b.Ia ? b.Ia(true) : b.ha(true);
          },
          ha: function(b) {
            var c14 = this[r2], d = c14.Sa, e2 = false;
            if (!c14.rb && !c14.ra) {
              if (c14.l && !a4.a.Sb(c14.l) || d && d()) {
                if (!c14.jc) {
                  this.s();
                  return;
                }
              } else
                c14.jc = false;
              c14.rb = true;
              try {
                e2 = this.zd(b);
              } finally {
                c14.rb = false;
              }
              return e2;
            }
          },
          zd: function(b) {
            var c14 = this[r2], d = false, e2 = c14.wb ? n2 : !c14.V, d = { qd: this, mb: c14.I, Qb: c14.V };
            a4.u.xc({
              pd: d,
              od: ba,
              o: this,
              Ya: e2
            });
            c14.I = {};
            c14.V = 0;
            var f2 = this.yd(c14, d);
            c14.V ? d = this.sb(c14.X, f2) : (this.s(), d = true);
            d && (c14.J ? this.Gb() : this.notifySubscribers(c14.X, "beforeChange"), c14.X = f2, this.notifySubscribers(c14.X, "spectate"), !c14.J && b && this.notifySubscribers(c14.X), this.rc && this.rc());
            e2 && this.notifySubscribers(c14.X, "awake");
            return d;
          },
          yd: function(b, c14) {
            try {
              var d = b.Wc;
              return b.nb ? d.call(b.nb) : d();
            } finally {
              a4.u.end(), c14.Qb && !b.J && a4.a.P(c14.mb, aa), b.sa = b.ka = false;
            }
          },
          v: function(a5) {
            var c14 = this[r2];
            (c14.ka && (a5 || !c14.V) || c14.J && this.Xa()) && this.ha();
            return c14.X;
          },
          ub: function(b) {
            a4.T.fn.ub.call(this, b);
            this.nc = function() {
              this[r2].J || (this[r2].sa ? this.ha() : this[r2].ka = false);
              return this[r2].X;
            };
            this.Ia = function(a5) {
              this.pc(this[r2].X);
              this[r2].ka = true;
              a5 && (this[r2].sa = true);
              this.qc(this, !a5);
            };
          },
          s: function() {
            var b = this[r2];
            !b.J && b.I && a4.a.P(b.I, function(a5, b2) {
              b2.s && b2.s();
            });
            b.l && b.Rb && a4.a.K.yb(b.l, b.Rb);
            b.I = n2;
            b.V = 0;
            b.ra = true;
            b.sa = false;
            b.ka = false;
            b.J = false;
            b.l = n2;
            b.Sa = n2;
            b.Wc = n2;
            this.Nc || (b.nb = n2);
          }
        }, da = { Qa: function(b) {
          var c14 = this, d = c14[r2];
          if (!d.ra && d.J && "change" == b) {
            d.J = false;
            if (d.sa || c14.Xa())
              d.I = null, d.V = 0, c14.ha() && c14.Gb();
            else {
              var e2 = [];
              a4.a.P(d.I, function(a5, b2) {
                e2[b2.Ka] = a5;
              });
              a4.a.D(e2, function(a5, b2) {
                var e3 = d.I[a5], m = c14.$c(e3.da);
                m.Ka = b2;
                m.La = e3.La;
                d.I[a5] = m;
              });
              c14.Xa() && c14.ha() && c14.Gb();
            }
            d.ra || c14.notifySubscribers(d.X, "awake");
          }
        }, hb: function(b) {
          var c14 = this[r2];
          c14.ra || "change" != b || this.Wa("change") || (a4.a.P(c14.I, function(a5, b2) {
            b2.s && (c14.I[a5] = { da: b2.da, Ka: b2.Ka, La: b2.La }, b2.s());
          }), c14.J = true, this.notifySubscribers(n2, "asleep"));
        }, ob: function() {
          var b = this[r2];
          b.J && (b.sa || this.Xa()) && this.ha();
          return a4.T.fn.ob.call(this);
        } }, ea = { Qa: function(a5) {
          "change" != a5 && "beforeChange" != a5 || this.v();
        } };
        a4.a.Ba && a4.a.setPrototypeOf(C, a4.T.fn);
        var N = a4.ta.Ma;
        C[N] = a4.o;
        a4.Oc = function(a5) {
          return "function" == typeof a5 && a5[N] === C[N];
        };
        a4.Fd = function(b) {
          return a4.Oc(b) && b[r2] && b[r2].wb;
        };
        a4.b("computed", a4.o);
        a4.b("dependentObservable", a4.o);
        a4.b("isComputed", a4.Oc);
        a4.b("isPureComputed", a4.Fd);
        a4.b("computed.fn", C);
        a4.L(C, "peek", C.v);
        a4.L(C, "dispose", C.s);
        a4.L(C, "isActive", C.ja);
        a4.L(C, "getDependenciesCount", C.qa);
        a4.L(C, "getDependencies", C.Va);
        a4.xb = function(b, c14) {
          if ("function" === typeof b)
            return a4.o(
              b,
              c14,
              { pure: true }
            );
          b = a4.a.extend({}, b);
          b.pure = true;
          return a4.o(b, c14);
        };
        a4.b("pureComputed", a4.xb);
        (function() {
          function b(a5, f2, g) {
            g = g || new d();
            a5 = f2(a5);
            if ("object" != typeof a5 || null === a5 || a5 === n2 || a5 instanceof RegExp || a5 instanceof Date || a5 instanceof String || a5 instanceof Number || a5 instanceof Boolean)
              return a5;
            var h = a5 instanceof Array ? [] : {};
            g.save(a5, h);
            c14(a5, function(c15) {
              var d2 = f2(a5[c15]);
              switch (typeof d2) {
                case "boolean":
                case "number":
                case "string":
                case "function":
                  h[c15] = d2;
                  break;
                case "object":
                case "undefined":
                  var l2 = g.get(d2);
                  h[c15] = l2 !== n2 ? l2 : b(d2, f2, g);
              }
            });
            return h;
          }
          function c14(a5, b2) {
            if (a5 instanceof Array) {
              for (var c15 = 0; c15 < a5.length; c15++)
                b2(c15);
              "function" == typeof a5.toJSON && b2("toJSON");
            } else
              for (c15 in a5)
                b2(c15);
          }
          function d() {
            this.keys = [];
            this.values = [];
          }
          a4.ad = function(c15) {
            if (0 == arguments.length)
              throw Error("When calling ko.toJS, pass the object you want to convert.");
            return b(c15, function(b2) {
              for (var c16 = 0; a4.O(b2) && 10 > c16; c16++)
                b2 = b2();
              return b2;
            });
          };
          a4.toJSON = function(b2, c15, d2) {
            b2 = a4.ad(b2);
            return a4.a.hc(b2, c15, d2);
          };
          d.prototype = { constructor: d, save: function(b2, c15) {
            var d2 = a4.a.A(
              this.keys,
              b2
            );
            0 <= d2 ? this.values[d2] = c15 : (this.keys.push(b2), this.values.push(c15));
          }, get: function(b2) {
            b2 = a4.a.A(this.keys, b2);
            return 0 <= b2 ? this.values[b2] : n2;
          } };
        })();
        a4.b("toJS", a4.ad);
        a4.b("toJSON", a4.toJSON);
        a4.Wd = function(b, c14, d) {
          function e2(c15) {
            var e3 = a4.xb(b, d).extend({ ma: "always" }), h = e3.subscribe(function(a5) {
              a5 && (h.s(), c15(a5));
            });
            e3.notifySubscribers(e3.v());
            return h;
          }
          return "function" !== typeof Promise || c14 ? e2(c14.bind(d)) : new Promise(e2);
        };
        a4.b("when", a4.Wd);
        (function() {
          a4.w = { M: function(b) {
            switch (a4.a.R(b)) {
              case "option":
                return true === b.__ko__hasDomDataOptionValue__ ? a4.a.g.get(b, a4.c.options.$b) : 7 >= a4.a.W ? b.getAttributeNode("value") && b.getAttributeNode("value").specified ? b.value : b.text : b.value;
              case "select":
                return 0 <= b.selectedIndex ? a4.w.M(b.options[b.selectedIndex]) : n2;
              default:
                return b.value;
            }
          }, cb: function(b, c14, d) {
            switch (a4.a.R(b)) {
              case "option":
                "string" === typeof c14 ? (a4.a.g.set(b, a4.c.options.$b, n2), "__ko__hasDomDataOptionValue__" in b && delete b.__ko__hasDomDataOptionValue__, b.value = c14) : (a4.a.g.set(b, a4.c.options.$b, c14), b.__ko__hasDomDataOptionValue__ = true, b.value = "number" === typeof c14 ? c14 : "");
                break;
              case "select":
                if ("" === c14 || null === c14)
                  c14 = n2;
                for (var e2 = -1, f2 = 0, g = b.options.length, h; f2 < g; ++f2)
                  if (h = a4.w.M(b.options[f2]), h == c14 || "" === h && c14 === n2) {
                    e2 = f2;
                    break;
                  }
                if (d || 0 <= e2 || c14 === n2 && 1 < b.size)
                  b.selectedIndex = e2, 6 === a4.a.W && a4.a.setTimeout(function() {
                    b.selectedIndex = e2;
                  }, 0);
                break;
              default:
                if (null === c14 || c14 === n2)
                  c14 = "";
                b.value = c14;
            }
          } };
        })();
        a4.b("selectExtensions", a4.w);
        a4.b("selectExtensions.readValue", a4.w.M);
        a4.b("selectExtensions.writeValue", a4.w.cb);
        a4.m = function() {
          function b(b2) {
            b2 = a4.a.Db(b2);
            123 === b2.charCodeAt(0) && (b2 = b2.slice(
              1,
              -1
            ));
            b2 += "\n,";
            var c15 = [], d2 = b2.match(e2), p2, q = [], h2 = 0;
            if (1 < d2.length) {
              for (var x = 0, B; B = d2[x]; ++x) {
                var u3 = B.charCodeAt(0);
                if (44 === u3) {
                  if (0 >= h2) {
                    c15.push(p2 && q.length ? { key: p2, value: q.join("") } : { unknown: p2 || q.join("") });
                    p2 = h2 = 0;
                    q = [];
                    continue;
                  }
                } else if (58 === u3) {
                  if (!h2 && !p2 && 1 === q.length) {
                    p2 = q.pop();
                    continue;
                  }
                } else if (47 === u3 && 1 < B.length && (47 === B.charCodeAt(1) || 42 === B.charCodeAt(1)))
                  continue;
                else
                  47 === u3 && x && 1 < B.length ? (u3 = d2[x - 1].match(f2)) && !g[u3[0]] && (b2 = b2.substr(b2.indexOf(B) + 1), d2 = b2.match(e2), x = -1, B = "/") : 40 === u3 || 123 === u3 || 91 === u3 ? ++h2 : 41 === u3 || 125 === u3 || 93 === u3 ? --h2 : p2 || q.length || 34 !== u3 && 39 !== u3 || (B = B.slice(1, -1));
                q.push(B);
              }
              if (0 < h2)
                throw Error("Unbalanced parentheses, braces, or brackets");
            }
            return c15;
          }
          var c14 = ["true", "false", "null", "undefined"], d = /^(?:[$_a-z][$\w]*|(.+)(\.\s*[$_a-z][$\w]*|\[.+\]))$/i, e2 = RegExp("\"(?:\\\\.|[^\"])*\"|'(?:\\\\.|[^'])*'|`(?:\\\\.|[^`])*`|/\\*(?:[^*]|\\*+[^*/])*\\*+/|//.*\n|/(?:\\\\.|[^/])+/w*|[^\\s:,/][^,\"'`{}()/:[\\]]*[^\\s,\"'`{}()/:[\\]]|[^\\s]", "g"), f2 = /[\])"'A-Za-z0-9_$]+$/, g = { "in": 1, "return": 1, "typeof": 1 }, h = {};
          return { Ra: [], wa: h, ac: b, vb: function(e3, f3) {
            function l2(b2, e4) {
              var f4;
              if (!x) {
                var k = a4.getBindingHandler(b2);
                if (k && k.preprocess && !(e4 = k.preprocess(e4, b2, l2)))
                  return;
                if (k = h[b2])
                  f4 = e4, 0 <= a4.a.A(c14, f4) ? f4 = false : (k = f4.match(d), f4 = null === k ? false : k[1] ? "Object(" + k[1] + ")" + k[2] : f4), k = f4;
                k && q.push("'" + ("string" == typeof h[b2] ? h[b2] : b2) + "':function(_z){" + f4 + "=_z}");
              }
              g2 && (e4 = "function(){return " + e4 + " }");
              p2.push("'" + b2 + "':" + e4);
            }
            f3 = f3 || {};
            var p2 = [], q = [], g2 = f3.valueAccessors, x = f3.bindingParams, B = "string" === typeof e3 ? b(e3) : e3;
            a4.a.D(B, function(a5) {
              l2(
                a5.key || a5.unknown,
                a5.value
              );
            });
            q.length && l2("_ko_property_writers", "{" + q.join(",") + " }");
            return p2.join(",");
          }, Id: function(a5, b2) {
            for (var c15 = 0; c15 < a5.length; c15++)
              if (a5[c15].key == b2)
                return true;
            return false;
          }, eb: function(b2, c15, d2, e3, f3) {
            if (b2 && a4.O(b2))
              !a4.Za(b2) || f3 && b2.v() === e3 || b2(e3);
            else if ((b2 = c15.get("_ko_property_writers")) && b2[d2])
              b2[d2](e3);
          } };
        }();
        a4.b("expressionRewriting", a4.m);
        a4.b("expressionRewriting.bindingRewriteValidators", a4.m.Ra);
        a4.b("expressionRewriting.parseObjectLiteral", a4.m.ac);
        a4.b("expressionRewriting.preProcessBindings", a4.m.vb);
        a4.b(
          "expressionRewriting._twoWayBindings",
          a4.m.wa
        );
        a4.b("jsonExpressionRewriting", a4.m);
        a4.b("jsonExpressionRewriting.insertPropertyAccessorsIntoJson", a4.m.vb);
        (function() {
          function b(a5) {
            return 8 == a5.nodeType && g.test(f2 ? a5.text : a5.nodeValue);
          }
          function c14(a5) {
            return 8 == a5.nodeType && h.test(f2 ? a5.text : a5.nodeValue);
          }
          function d(d2, e3) {
            for (var f3 = d2, h2 = 1, g2 = []; f3 = f3.nextSibling; ) {
              if (c14(f3) && (a4.a.g.set(f3, k, true), h2--, 0 === h2))
                return g2;
              g2.push(f3);
              b(f3) && h2++;
            }
            if (!e3)
              throw Error("Cannot find closing comment tag to match: " + d2.nodeValue);
            return null;
          }
          function e2(a5, b2) {
            var c15 = d(a5, b2);
            return c15 ? 0 < c15.length ? c15[c15.length - 1].nextSibling : a5.nextSibling : null;
          }
          var f2 = w && "<!--test-->" === w.createComment("test").text, g = f2 ? /^\x3c!--\s*ko(?:\s+([\s\S]+))?\s*--\x3e$/ : /^\s*ko(?:\s+([\s\S]+))?\s*$/, h = f2 ? /^\x3c!--\s*\/ko\s*--\x3e$/ : /^\s*\/ko\s*$/, m = { ul: true, ol: true }, k = "__ko_matchedEndComment__";
          a4.h = { ea: {}, childNodes: function(a5) {
            return b(a5) ? d(a5) : a5.childNodes;
          }, Ea: function(c15) {
            if (b(c15)) {
              c15 = a4.h.childNodes(c15);
              for (var d2 = 0, e3 = c15.length; d2 < e3; d2++)
                a4.removeNode(c15[d2]);
            } else
              a4.a.Tb(c15);
          }, va: function(c15, d2) {
            if (b(c15)) {
              a4.h.Ea(c15);
              for (var e3 = c15.nextSibling, f3 = 0, k2 = d2.length; f3 < k2; f3++)
                e3.parentNode.insertBefore(d2[f3], e3);
            } else
              a4.a.va(c15, d2);
          }, Vc: function(a5, c15) {
            var d2;
            b(a5) ? (d2 = a5.nextSibling, a5 = a5.parentNode) : d2 = a5.firstChild;
            d2 ? c15 !== d2 && a5.insertBefore(c15, d2) : a5.appendChild(c15);
          }, Wb: function(c15, d2, e3) {
            e3 ? (e3 = e3.nextSibling, b(c15) && (c15 = c15.parentNode), e3 ? d2 !== e3 && c15.insertBefore(d2, e3) : c15.appendChild(d2)) : a4.h.Vc(c15, d2);
          }, firstChild: function(a5) {
            if (b(a5))
              return !a5.nextSibling || c14(a5.nextSibling) ? null : a5.nextSibling;
            if (a5.firstChild && c14(a5.firstChild))
              throw Error("Found invalid end comment, as the first child of " + a5);
            return a5.firstChild;
          }, nextSibling: function(d2) {
            b(d2) && (d2 = e2(d2));
            if (d2.nextSibling && c14(d2.nextSibling)) {
              var f3 = d2.nextSibling;
              if (c14(f3) && !a4.a.g.get(f3, k))
                throw Error("Found end comment without a matching opening comment, as child of " + d2);
              return null;
            }
            return d2.nextSibling;
          }, Cd: b, Vd: function(a5) {
            return (a5 = (f2 ? a5.text : a5.nodeValue).match(g)) ? a5[1] : null;
          }, Sc: function(d2) {
            if (m[a4.a.R(d2)]) {
              var f3 = d2.firstChild;
              if (f3) {
                do
                  if (1 === f3.nodeType) {
                    var k2;
                    k2 = f3.firstChild;
                    var h2 = null;
                    if (k2) {
                      do
                        if (h2)
                          h2.push(k2);
                        else if (b(k2)) {
                          var g2 = e2(k2, true);
                          g2 ? k2 = g2 : h2 = [k2];
                        } else
                          c14(k2) && (h2 = [k2]);
                      while (k2 = k2.nextSibling);
                    }
                    if (k2 = h2)
                      for (h2 = f3.nextSibling, g2 = 0; g2 < k2.length; g2++)
                        h2 ? d2.insertBefore(k2[g2], h2) : d2.appendChild(k2[g2]);
                  }
                while (f3 = f3.nextSibling);
              }
            }
          } };
        })();
        a4.b("virtualElements", a4.h);
        a4.b("virtualElements.allowedBindings", a4.h.ea);
        a4.b("virtualElements.emptyNode", a4.h.Ea);
        a4.b("virtualElements.insertAfter", a4.h.Wb);
        a4.b("virtualElements.prepend", a4.h.Vc);
        a4.b("virtualElements.setDomNodeChildren", a4.h.va);
        (function() {
          a4.ga = function() {
            this.nd = {};
          };
          a4.a.extend(a4.ga.prototype, {
            nodeHasBindings: function(b) {
              switch (b.nodeType) {
                case 1:
                  return null != b.getAttribute("data-bind") || a4.j.getComponentNameForNode(b);
                case 8:
                  return a4.h.Cd(b);
                default:
                  return false;
              }
            },
            getBindings: function(b, c14) {
              var d = this.getBindingsString(b, c14), d = d ? this.parseBindingsString(d, c14, b) : null;
              return a4.j.tc(d, b, c14, false);
            },
            getBindingAccessors: function(b, c14) {
              var d = this.getBindingsString(b, c14), d = d ? this.parseBindingsString(d, c14, b, { valueAccessors: true }) : null;
              return a4.j.tc(d, b, c14, true);
            },
            getBindingsString: function(b) {
              switch (b.nodeType) {
                case 1:
                  return b.getAttribute("data-bind");
                case 8:
                  return a4.h.Vd(b);
                default:
                  return null;
              }
            },
            parseBindingsString: function(b, c14, d, e2) {
              try {
                var f2 = this.nd, g = b + (e2 && e2.valueAccessors || ""), h;
                if (!(h = f2[g])) {
                  var m, k = "with($context){with($data||{}){return{" + a4.m.vb(b, e2) + "}}}";
                  m = new Function("$context", "$element", k);
                  h = f2[g] = m;
                }
                return h(c14, d);
              } catch (l2) {
                throw l2.message = "Unable to parse bindings.\nBindings value: " + b + "\nMessage: " + l2.message, l2;
              }
            }
          });
          a4.ga.instance = new a4.ga();
        })();
        a4.b("bindingProvider", a4.ga);
        (function() {
          function b(b2) {
            var c15 = (b2 = a4.a.g.get(b2, z)) && b2.N;
            c15 && (b2.N = null, c15.Tc());
          }
          function c14(c15, d2, e3) {
            this.node = c15;
            this.yc = d2;
            this.kb = [];
            this.H = false;
            d2.N || a4.a.K.za(c15, b);
            e3 && e3.N && (e3.N.kb.push(c15), this.Kb = e3);
          }
          function d(a5) {
            return function() {
              return a5;
            };
          }
          function e2(a5) {
            return a5();
          }
          function f2(b2) {
            return a4.a.Ga(a4.u.G(b2), function(a5, c15) {
              return function() {
                return b2()[c15];
              };
            });
          }
          function g(b2, c15, e3) {
            return "function" === typeof b2 ? f2(b2.bind(null, c15, e3)) : a4.a.Ga(b2, d);
          }
          function h(a5, b2) {
            return f2(this.getBindings.bind(this, a5, b2));
          }
          function m(b2, c15) {
            var d2 = a4.h.firstChild(c15);
            if (d2) {
              var e3, f3 = a4.ga.instance, l3 = f3.preprocessNode;
              if (l3) {
                for (; e3 = d2; )
                  d2 = a4.h.nextSibling(e3), l3.call(f3, e3);
                d2 = a4.h.firstChild(c15);
              }
              for (; e3 = d2; )
                d2 = a4.h.nextSibling(e3), k(b2, e3);
            }
            a4.i.ma(c15, a4.i.H);
          }
          function k(b2, c15) {
            var d2 = b2, e3 = 1 === c15.nodeType;
            e3 && a4.h.Sc(c15);
            if (e3 || a4.ga.instance.nodeHasBindings(c15))
              d2 = p2(c15, null, b2).bindingContextForDescendants;
            d2 && !u3[a4.a.R(c15)] && m(d2, c15);
          }
          function l2(b2) {
            var c15 = [], d2 = {}, e3 = [];
            a4.a.P(b2, function ca(f3) {
              if (!d2[f3]) {
                var k2 = a4.getBindingHandler(f3);
                k2 && (k2.after && (e3.push(f3), a4.a.D(k2.after, function(c16) {
                  if (b2[c16]) {
                    if (-1 !== a4.a.A(e3, c16))
                      throw Error("Cannot combine the following bindings, because they have a cyclic dependency: " + e3.join(", "));
                    ca(c16);
                  }
                }), e3.length--), c15.push({ key: f3, Mc: k2 }));
                d2[f3] = true;
              }
            });
            return c15;
          }
          function p2(b2, c15, d2) {
            var f3 = a4.a.g.Ub(b2, z, {}), k2 = f3.hd;
            if (!c15) {
              if (k2)
                throw Error("You cannot apply bindings multiple times to the same element.");
              f3.hd = true;
            }
            k2 || (f3.context = d2);
            f3.Zb || (f3.Zb = {});
            var g2;
            if (c15 && "function" !== typeof c15)
              g2 = c15;
            else {
              var p3 = a4.ga.instance, q3 = p3.getBindingAccessors || h, m2 = a4.$(function() {
                if (g2 = c15 ? c15(d2, b2) : q3.call(p3, b2, d2)) {
                  if (d2[t])
                    d2[t]();
                  if (d2[B])
                    d2[B]();
                }
                return g2;
              }, null, { l: b2 });
              g2 && m2.ja() || (m2 = null);
            }
            var x2 = d2, u4;
            if (g2) {
              var J2 = function() {
                return a4.a.Ga(m2 ? m2() : g2, e2);
              }, r3 = m2 ? function(a5) {
                return function() {
                  return e2(m2()[a5]);
                };
              } : function(a5) {
                return g2[a5];
              };
              J2.get = function(a5) {
                return g2[a5] && e2(r3(a5));
              };
              J2.has = function(a5) {
                return a5 in g2;
              };
              a4.i.H in g2 && a4.i.subscribe(b2, a4.i.H, function() {
                var c16 = (0, g2[a4.i.H])();
                if (c16) {
                  var d3 = a4.h.childNodes(b2);
                  d3.length && c16(d3, a4.Ec(d3[0]));
                }
              });
              a4.i.pa in g2 && (x2 = a4.i.Cb(b2, d2), a4.i.subscribe(b2, a4.i.pa, function() {
                var c16 = (0, g2[a4.i.pa])();
                c16 && a4.h.firstChild(b2) && c16(b2);
              }));
              f3 = l2(g2);
              a4.a.D(f3, function(c16) {
                var d3 = c16.Mc.init, e3 = c16.Mc.update, f4 = c16.key;
                if (8 === b2.nodeType && !a4.h.ea[f4])
                  throw Error("The binding '" + f4 + "' cannot be used with virtual elements");
                try {
                  "function" == typeof d3 && a4.u.G(function() {
                    var a5 = d3(b2, r3(f4), J2, x2.$data, x2);
                    if (a5 && a5.controlsDescendantBindings) {
                      if (u4 !== n2)
                        throw Error("Multiple bindings (" + u4 + " and " + f4 + ") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.");
                      u4 = f4;
                    }
                  }), "function" == typeof e3 && a4.$(function() {
                    e3(b2, r3(f4), J2, x2.$data, x2);
                  }, null, { l: b2 });
                } catch (k3) {
                  throw k3.message = 'Unable to process binding "' + f4 + ": " + g2[f4] + '"\nMessage: ' + k3.message, k3;
                }
              });
            }
            f3 = u4 === n2;
            return { shouldBindDescendants: f3, bindingContextForDescendants: f3 && x2 };
          }
          function q(b2, c15) {
            return b2 && b2 instanceof a4.fa ? b2 : new a4.fa(b2, n2, n2, c15);
          }
          var t = a4.a.Da("_subscribable"), x = a4.a.Da("_ancestorBindingInfo"), B = a4.a.Da("_dataDependency");
          a4.c = {};
          var u3 = { script: true, textarea: true, template: true };
          a4.getBindingHandler = function(b2) {
            return a4.c[b2];
          };
          var J = {};
          a4.fa = function(b2, c15, d2, e3, f3) {
            function k2() {
              var b3 = p3 ? h2() : h2, f4 = a4.a.f(b3);
              c15 ? (a4.a.extend(l3, c15), x in c15 && (l3[x] = c15[x])) : (l3.$parents = [], l3.$root = f4, l3.ko = a4);
              l3[t] = q3;
              g2 ? f4 = l3.$data : (l3.$rawData = b3, l3.$data = f4);
              d2 && (l3[d2] = f4);
              e3 && e3(l3, c15, f4);
              if (c15 && c15[t] && !a4.S.o().Vb(c15[t]))
                c15[t]();
              m2 && (l3[B] = m2);
              return l3.$data;
            }
            var l3 = this, g2 = b2 === J, h2 = g2 ? n2 : b2, p3 = "function" == typeof h2 && !a4.O(h2), q3, m2 = f3 && f3.dataDependency;
            f3 && f3.exportDependencies ? k2() : (q3 = a4.xb(k2), q3.v(), q3.ja() ? q3.equalityComparer = null : l3[t] = n2);
          };
          a4.fa.prototype.createChildContext = function(b2, c15, d2, e3) {
            !e3 && c15 && "object" == typeof c15 && (e3 = c15, c15 = e3.as, d2 = e3.extend);
            if (c15 && e3 && e3.noChildContext) {
              var f3 = "function" == typeof b2 && !a4.O(b2);
              return new a4.fa(J, this, null, function(a5) {
                d2 && d2(a5);
                a5[c15] = f3 ? b2() : b2;
              }, e3);
            }
            return new a4.fa(
              b2,
              this,
              c15,
              function(a5, b3) {
                a5.$parentContext = b3;
                a5.$parent = b3.$data;
                a5.$parents = (b3.$parents || []).slice(0);
                a5.$parents.unshift(a5.$parent);
                d2 && d2(a5);
              },
              e3
            );
          };
          a4.fa.prototype.extend = function(b2, c15) {
            return new a4.fa(J, this, null, function(c16) {
              a4.a.extend(c16, "function" == typeof b2 ? b2(c16) : b2);
            }, c15);
          };
          var z = a4.a.g.Z();
          c14.prototype.Tc = function() {
            this.Kb && this.Kb.N && this.Kb.N.sd(this.node);
          };
          c14.prototype.sd = function(b2) {
            a4.a.Pa(this.kb, b2);
            !this.kb.length && this.H && this.Cc();
          };
          c14.prototype.Cc = function() {
            this.H = true;
            this.yc.N && !this.kb.length && (this.yc.N = null, a4.a.K.yb(this.node, b), a4.i.ma(this.node, a4.i.pa), this.Tc());
          };
          a4.i = { H: "childrenComplete", pa: "descendantsComplete", subscribe: function(b2, c15, d2, e3, f3) {
            var k2 = a4.a.g.Ub(b2, z, {});
            k2.Fa || (k2.Fa = new a4.T());
            f3 && f3.notifyImmediately && k2.Zb[c15] && a4.u.G(d2, e3, [b2]);
            return k2.Fa.subscribe(d2, e3, c15);
          }, ma: function(b2, c15) {
            var d2 = a4.a.g.get(b2, z);
            if (d2 && (d2.Zb[c15] = true, d2.Fa && d2.Fa.notifySubscribers(b2, c15), c15 == a4.i.H)) {
              if (d2.N)
                d2.N.Cc();
              else if (d2.N === n2 && d2.Fa && d2.Fa.Wa(a4.i.pa))
                throw Error("descendantsComplete event not supported for bindings on this node");
            }
          }, Cb: function(b2, d2) {
            var e3 = a4.a.g.Ub(b2, z, {});
            e3.N || (e3.N = new c14(b2, e3, d2[x]));
            return d2[x] == e3 ? d2 : d2.extend(function(a5) {
              a5[x] = e3;
            });
          } };
          a4.Td = function(b2) {
            return (b2 = a4.a.g.get(b2, z)) && b2.context;
          };
          a4.ib = function(b2, c15, d2) {
            1 === b2.nodeType && a4.h.Sc(b2);
            return p2(b2, c15, q(d2));
          };
          a4.ld = function(b2, c15, d2) {
            d2 = q(d2);
            return a4.ib(b2, g(c15, d2, b2), d2);
          };
          a4.Oa = function(a5, b2) {
            1 !== b2.nodeType && 8 !== b2.nodeType || m(q(a5), b2);
          };
          a4.vc = function(a5, b2, c15) {
            !v7 && A.jQuery && (v7 = A.jQuery);
            if (2 > arguments.length) {
              if (b2 = w.body, !b2)
                throw Error("ko.applyBindings: could not find document.body; has the document been loaded?");
            } else if (!b2 || 1 !== b2.nodeType && 8 !== b2.nodeType)
              throw Error("ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node");
            k(q(a5, c15), b2);
          };
          a4.Dc = function(b2) {
            return !b2 || 1 !== b2.nodeType && 8 !== b2.nodeType ? n2 : a4.Td(b2);
          };
          a4.Ec = function(b2) {
            return (b2 = a4.Dc(b2)) ? b2.$data : n2;
          };
          a4.b("bindingHandlers", a4.c);
          a4.b("bindingEvent", a4.i);
          a4.b("bindingEvent.subscribe", a4.i.subscribe);
          a4.b("bindingEvent.startPossiblyAsyncContentBinding", a4.i.Cb);
          a4.b("applyBindings", a4.vc);
          a4.b("applyBindingsToDescendants", a4.Oa);
          a4.b("applyBindingAccessorsToNode", a4.ib);
          a4.b("applyBindingsToNode", a4.ld);
          a4.b("contextFor", a4.Dc);
          a4.b("dataFor", a4.Ec);
        })();
        (function(b) {
          function c14(c15, e3) {
            var k = Object.prototype.hasOwnProperty.call(f2, c15) ? f2[c15] : b, l2;
            k ? k.subscribe(e3) : (k = f2[c15] = new a4.T(), k.subscribe(e3), d(c15, function(b2, d2) {
              var e4 = !(!d2 || !d2.synchronous);
              g[c15] = { definition: b2, Gd: e4 };
              delete f2[c15];
              l2 || e4 ? k.notifySubscribers(b2) : a4.na.zb(function() {
                k.notifySubscribers(b2);
              });
            }), l2 = true);
          }
          function d(a5, b2) {
            e2("getConfig", [a5], function(c15) {
              c15 ? e2("loadComponent", [a5, c15], function(a6) {
                b2(
                  a6,
                  c15
                );
              }) : b2(null, null);
            });
          }
          function e2(c15, d2, f3, l2) {
            l2 || (l2 = a4.j.loaders.slice(0));
            var g2 = l2.shift();
            if (g2) {
              var q = g2[c15];
              if (q) {
                var t = false;
                if (q.apply(g2, d2.concat(function(a5) {
                  t ? f3(null) : null !== a5 ? f3(a5) : e2(c15, d2, f3, l2);
                })) !== b && (t = true, !g2.suppressLoaderExceptions))
                  throw Error("Component loaders must supply values by invoking the callback, not by returning values synchronously.");
              } else
                e2(c15, d2, f3, l2);
            } else
              f3(null);
          }
          var f2 = {}, g = {};
          a4.j = { get: function(d2, e3) {
            var f3 = Object.prototype.hasOwnProperty.call(g, d2) ? g[d2] : b;
            f3 ? f3.Gd ? a4.u.G(function() {
              e3(f3.definition);
            }) : a4.na.zb(function() {
              e3(f3.definition);
            }) : c14(d2, e3);
          }, Bc: function(a5) {
            delete g[a5];
          }, oc: e2 };
          a4.j.loaders = [];
          a4.b("components", a4.j);
          a4.b("components.get", a4.j.get);
          a4.b("components.clearCachedDefinition", a4.j.Bc);
        })();
        (function() {
          function b(b2, c15, d2, e3) {
            function g2() {
              0 === --B && e3(h2);
            }
            var h2 = {}, B = 2, u3 = d2.template;
            d2 = d2.viewModel;
            u3 ? f2(c15, u3, function(c16) {
              a4.j.oc("loadTemplate", [b2, c16], function(a5) {
                h2.template = a5;
                g2();
              });
            }) : g2();
            d2 ? f2(c15, d2, function(c16) {
              a4.j.oc("loadViewModel", [b2, c16], function(a5) {
                h2[m] = a5;
                g2();
              });
            }) : g2();
          }
          function c14(a5, b2, d2) {
            if ("function" === typeof b2)
              d2(function(a6) {
                return new b2(a6);
              });
            else if ("function" === typeof b2[m])
              d2(b2[m]);
            else if ("instance" in b2) {
              var e3 = b2.instance;
              d2(function() {
                return e3;
              });
            } else
              "viewModel" in b2 ? c14(a5, b2.viewModel, d2) : a5("Unknown viewModel value: " + b2);
          }
          function d(b2) {
            switch (a4.a.R(b2)) {
              case "script":
                return a4.a.ua(b2.text);
              case "textarea":
                return a4.a.ua(b2.value);
              case "template":
                if (e2(b2.content))
                  return a4.a.Ca(b2.content.childNodes);
            }
            return a4.a.Ca(b2.childNodes);
          }
          function e2(a5) {
            return A.DocumentFragment ? a5 instanceof DocumentFragment : a5 && 11 === a5.nodeType;
          }
          function f2(a5, b2, c15) {
            "string" === typeof b2.require ? T || A.require ? (T || A.require)([b2.require], function(a6) {
              a6 && "object" === typeof a6 && a6.Xd && a6["default"] && (a6 = a6["default"]);
              c15(a6);
            }) : a5("Uses require, but no AMD loader is present") : c15(b2);
          }
          function g(a5) {
            return function(b2) {
              throw Error("Component '" + a5 + "': " + b2);
            };
          }
          var h = {};
          a4.j.register = function(b2, c15) {
            if (!c15)
              throw Error("Invalid configuration for " + b2);
            if (a4.j.tb(b2))
              throw Error("Component " + b2 + " is already registered");
            h[b2] = c15;
          };
          a4.j.tb = function(a5) {
            return Object.prototype.hasOwnProperty.call(h, a5);
          };
          a4.j.unregister = function(b2) {
            delete h[b2];
            a4.j.Bc(b2);
          };
          a4.j.Fc = { getConfig: function(b2, c15) {
            c15(a4.j.tb(b2) ? h[b2] : null);
          }, loadComponent: function(a5, c15, d2) {
            var e3 = g(a5);
            f2(e3, c15, function(c16) {
              b(a5, e3, c16, d2);
            });
          }, loadTemplate: function(b2, c15, f3) {
            b2 = g(b2);
            if ("string" === typeof c15)
              f3(a4.a.ua(c15));
            else if (c15 instanceof Array)
              f3(c15);
            else if (e2(c15))
              f3(a4.a.la(c15.childNodes));
            else if (c15.element)
              if (c15 = c15.element, A.HTMLElement ? c15 instanceof HTMLElement : c15 && c15.tagName && 1 === c15.nodeType)
                f3(d(c15));
              else if ("string" === typeof c15) {
                var h2 = w.getElementById(c15);
                h2 ? f3(d(h2)) : b2("Cannot find element with ID " + c15);
              } else
                b2("Unknown element type: " + c15);
            else
              b2("Unknown template value: " + c15);
          }, loadViewModel: function(a5, b2, d2) {
            c14(g(a5), b2, d2);
          } };
          var m = "createViewModel";
          a4.b("components.register", a4.j.register);
          a4.b("components.isRegistered", a4.j.tb);
          a4.b("components.unregister", a4.j.unregister);
          a4.b("components.defaultLoader", a4.j.Fc);
          a4.j.loaders.push(a4.j.Fc);
          a4.j.dd = h;
        })();
        (function() {
          function b(b2, e2) {
            var f2 = b2.getAttribute("params");
            if (f2) {
              var f2 = c14.parseBindingsString(f2, e2, b2, { valueAccessors: true, bindingParams: true }), f2 = a4.a.Ga(f2, function(c15) {
                return a4.o(c15, null, { l: b2 });
              }), g = a4.a.Ga(
                f2,
                function(c15) {
                  var e3 = c15.v();
                  return c15.ja() ? a4.o({ read: function() {
                    return a4.a.f(c15());
                  }, write: a4.Za(e3) && function(a5) {
                    c15()(a5);
                  }, l: b2 }) : e3;
                }
              );
              Object.prototype.hasOwnProperty.call(g, "$raw") || (g.$raw = f2);
              return g;
            }
            return { $raw: {} };
          }
          a4.j.getComponentNameForNode = function(b2) {
            var c15 = a4.a.R(b2);
            if (a4.j.tb(c15) && (-1 != c15.indexOf("-") || "[object HTMLUnknownElement]" == "" + b2 || 8 >= a4.a.W && b2.tagName === c15))
              return c15;
          };
          a4.j.tc = function(c15, e2, f2, g) {
            if (1 === e2.nodeType) {
              var h = a4.j.getComponentNameForNode(e2);
              if (h) {
                c15 = c15 || {};
                if (c15.component)
                  throw Error('Cannot use the "component" binding on a custom element matching a component');
                var m = { name: h, params: b(e2, f2) };
                c15.component = g ? function() {
                  return m;
                } : m;
              }
            }
            return c15;
          };
          var c14 = new a4.ga();
          9 > a4.a.W && (a4.j.register = function(a5) {
            return function(b2) {
              return a5.apply(this, arguments);
            };
          }(a4.j.register), w.createDocumentFragment = function(b2) {
            return function() {
              var c15 = b2(), f2 = a4.j.dd, g;
              for (g in f2)
                ;
              return c15;
            };
          }(w.createDocumentFragment));
        })();
        (function() {
          function b(b2, c15, d2) {
            c15 = c15.template;
            if (!c15)
              throw Error("Component '" + b2 + "' has no template");
            b2 = a4.a.Ca(c15);
            a4.h.va(d2, b2);
          }
          function c14(a5, b2, c15) {
            var d2 = a5.createViewModel;
            return d2 ? d2.call(
              a5,
              b2,
              c15
            ) : b2;
          }
          var d = 0;
          a4.c.component = { init: function(e2, f2, g, h, m) {
            function k() {
              var a5 = l2 && l2.dispose;
              "function" === typeof a5 && a5.call(l2);
              q && q.s();
              p2 = l2 = q = null;
            }
            var l2, p2, q, t = a4.a.la(a4.h.childNodes(e2));
            a4.h.Ea(e2);
            a4.a.K.za(e2, k);
            a4.o(function() {
              var g2 = a4.a.f(f2()), h2, u3;
              "string" === typeof g2 ? h2 = g2 : (h2 = a4.a.f(g2.name), u3 = a4.a.f(g2.params));
              if (!h2)
                throw Error("No component name specified");
              var n3 = a4.i.Cb(e2, m), z = p2 = ++d;
              a4.j.get(h2, function(d2) {
                if (p2 === z) {
                  k();
                  if (!d2)
                    throw Error("Unknown component '" + h2 + "'");
                  b(h2, d2, e2);
                  var f3 = c14(d2, u3, { element: e2, templateNodes: t });
                  d2 = n3.createChildContext(f3, { extend: function(a5) {
                    a5.$component = f3;
                    a5.$componentTemplateNodes = t;
                  } });
                  f3 && f3.koDescendantsComplete && (q = a4.i.subscribe(e2, a4.i.pa, f3.koDescendantsComplete, f3));
                  l2 = f3;
                  a4.Oa(d2, e2);
                }
              });
            }, null, { l: e2 });
            return { controlsDescendantBindings: true };
          } };
          a4.h.ea.component = true;
        })();
        var V = { "class": "className", "for": "htmlFor" };
        a4.c.attr = { update: function(b, c14) {
          var d = a4.a.f(c14()) || {};
          a4.a.P(d, function(c15, d2) {
            d2 = a4.a.f(d2);
            var g = c15.indexOf(":"), g = "lookupNamespaceURI" in b && 0 < g && b.lookupNamespaceURI(c15.substr(0, g)), h = false === d2 || null === d2 || d2 === n2;
            h ? g ? b.removeAttributeNS(g, c15) : b.removeAttribute(c15) : d2 = d2.toString();
            8 >= a4.a.W && c15 in V ? (c15 = V[c15], h ? b.removeAttribute(c15) : b[c15] = d2) : h || (g ? b.setAttributeNS(g, c15, d2) : b.setAttribute(c15, d2));
            "name" === c15 && a4.a.Yc(b, h ? "" : d2);
          });
        } };
        (function() {
          a4.c.checked = { after: ["value", "attr"], init: function(b, c14, d) {
            function e2() {
              var e3 = b.checked, f3 = g();
              if (!a4.S.Ya() && (e3 || !m && !a4.S.qa())) {
                var k2 = a4.u.G(c14);
                if (l2) {
                  var q3 = p2 ? k2.v() : k2, z = t;
                  t = f3;
                  z !== f3 ? e3 && (a4.a.Na(q3, f3, true), a4.a.Na(q3, z, false)) : a4.a.Na(q3, f3, e3);
                  p2 && a4.Za(k2) && k2(q3);
                } else
                  h && (f3 === n2 ? f3 = e3 : e3 || (f3 = n2)), a4.m.eb(
                    k2,
                    d,
                    "checked",
                    f3,
                    true
                  );
              }
            }
            function f2() {
              var d2 = a4.a.f(c14()), e3 = g();
              l2 ? (b.checked = 0 <= a4.a.A(d2, e3), t = e3) : b.checked = h && e3 === n2 ? !!d2 : g() === d2;
            }
            var g = a4.xb(function() {
              if (d.has("checkedValue"))
                return a4.a.f(d.get("checkedValue"));
              if (q)
                return d.has("value") ? a4.a.f(d.get("value")) : b.value;
            }), h = "checkbox" == b.type, m = "radio" == b.type;
            if (h || m) {
              var k = c14(), l2 = h && a4.a.f(k) instanceof Array, p2 = !(l2 && k.push && k.splice), q = m || l2, t = l2 ? g() : n2;
              m && !b.name && a4.c.uniqueName.init(b, function() {
                return true;
              });
              a4.o(e2, null, { l: b });
              a4.a.B(b, "click", e2);
              a4.o(f2, null, { l: b });
              k = n2;
            }
          } };
          a4.m.wa.checked = true;
          a4.c.checkedValue = { update: function(b, c14) {
            b.value = a4.a.f(c14());
          } };
        })();
        a4.c["class"] = { update: function(b, c14) {
          var d = a4.a.Db(a4.a.f(c14()));
          a4.a.Eb(b, b.__ko__cssValue, false);
          b.__ko__cssValue = d;
          a4.a.Eb(b, d, true);
        } };
        a4.c.css = { update: function(b, c14) {
          var d = a4.a.f(c14());
          null !== d && "object" == typeof d ? a4.a.P(d, function(c15, d2) {
            d2 = a4.a.f(d2);
            a4.a.Eb(b, c15, d2);
          }) : a4.c["class"].update(b, c14);
        } };
        a4.c.enable = { update: function(b, c14) {
          var d = a4.a.f(c14());
          d && b.disabled ? b.removeAttribute("disabled") : d || b.disabled || (b.disabled = true);
        } };
        a4.c.disable = { update: function(b, c14) {
          a4.c.enable.update(b, function() {
            return !a4.a.f(c14());
          });
        } };
        a4.c.event = { init: function(b, c14, d, e2, f2) {
          var g = c14() || {};
          a4.a.P(g, function(g2) {
            "string" == typeof g2 && a4.a.B(b, g2, function(b2) {
              var k, l2 = c14()[g2];
              if (l2) {
                try {
                  var p2 = a4.a.la(arguments);
                  e2 = f2.$data;
                  p2.unshift(e2);
                  k = l2.apply(e2, p2);
                } finally {
                  true !== k && (b2.preventDefault ? b2.preventDefault() : b2.returnValue = false);
                }
                false === d.get(g2 + "Bubble") && (b2.cancelBubble = true, b2.stopPropagation && b2.stopPropagation());
              }
            });
          });
        } };
        a4.c.foreach = { Rc: function(b) {
          return function() {
            var c14 = b(), d = a4.a.bc(c14);
            if (!d || "number" == typeof d.length)
              return { foreach: c14, templateEngine: a4.ba.Ma };
            a4.a.f(c14);
            return { foreach: d.data, as: d.as, noChildContext: d.noChildContext, includeDestroyed: d.includeDestroyed, afterAdd: d.afterAdd, beforeRemove: d.beforeRemove, afterRender: d.afterRender, beforeMove: d.beforeMove, afterMove: d.afterMove, templateEngine: a4.ba.Ma };
          };
        }, init: function(b, c14) {
          return a4.c.template.init(b, a4.c.foreach.Rc(c14));
        }, update: function(b, c14, d, e2, f2) {
          return a4.c.template.update(b, a4.c.foreach.Rc(c14), d, e2, f2);
        } };
        a4.m.Ra.foreach = false;
        a4.h.ea.foreach = true;
        a4.c.hasfocus = { init: function(b, c14, d) {
          function e2(e3) {
            b.__ko_hasfocusUpdating = true;
            var f3 = b.ownerDocument;
            if ("activeElement" in f3) {
              var g2;
              try {
                g2 = f3.activeElement;
              } catch (l2) {
                g2 = f3.body;
              }
              e3 = g2 === b;
            }
            f3 = c14();
            a4.m.eb(f3, d, "hasfocus", e3, true);
            b.__ko_hasfocusLastValue = e3;
            b.__ko_hasfocusUpdating = false;
          }
          var f2 = e2.bind(null, true), g = e2.bind(null, false);
          a4.a.B(b, "focus", f2);
          a4.a.B(b, "focusin", f2);
          a4.a.B(b, "blur", g);
          a4.a.B(b, "focusout", g);
          b.__ko_hasfocusLastValue = false;
        }, update: function(b, c14) {
          var d = !!a4.a.f(c14());
          b.__ko_hasfocusUpdating || b.__ko_hasfocusLastValue === d || (d ? b.focus() : b.blur(), !d && b.__ko_hasfocusLastValue && b.ownerDocument.body.focus(), a4.u.G(a4.a.Fb, null, [b, d ? "focusin" : "focusout"]));
        } };
        a4.m.wa.hasfocus = true;
        a4.c.hasFocus = a4.c.hasfocus;
        a4.m.wa.hasFocus = "hasfocus";
        a4.c.html = { init: function() {
          return { controlsDescendantBindings: true };
        }, update: function(b, c14) {
          a4.a.fc(b, c14());
        } };
        (function() {
          function b(b2, d, e2) {
            a4.c[b2] = { init: function(b3, c14, h, m, k) {
              var l2, p2, q = {}, t, x, n3;
              if (d) {
                m = h.get("as");
                var u3 = h.get("noChildContext");
                n3 = !(m && u3);
                q = { as: m, noChildContext: u3, exportDependencies: n3 };
              }
              x = (t = "render" == h.get("completeOn")) || h.has(a4.i.pa);
              a4.o(function() {
                var h2 = a4.a.f(c14()), m2 = !e2 !== !h2, u4 = !p2, r3;
                if (n3 || m2 !== l2) {
                  x && (k = a4.i.Cb(b3, k));
                  if (m2) {
                    if (!d || n3)
                      q.dataDependency = a4.S.o();
                    r3 = d ? k.createChildContext("function" == typeof h2 ? h2 : c14, q) : a4.S.qa() ? k.extend(null, q) : k;
                  }
                  u4 && a4.S.qa() && (p2 = a4.a.Ca(a4.h.childNodes(b3), true));
                  m2 ? (u4 || a4.h.va(b3, a4.a.Ca(p2)), a4.Oa(r3, b3)) : (a4.h.Ea(b3), t || a4.i.ma(b3, a4.i.H));
                  l2 = m2;
                }
              }, null, { l: b3 });
              return { controlsDescendantBindings: true };
            } };
            a4.m.Ra[b2] = false;
            a4.h.ea[b2] = true;
          }
          b("if");
          b("ifnot", false, true);
          b("with", true);
        })();
        a4.c.let = { init: function(b, c14, d, e2, f2) {
          c14 = f2.extend(c14);
          a4.Oa(c14, b);
          return { controlsDescendantBindings: true };
        } };
        a4.h.ea.let = true;
        var Q = {};
        a4.c.options = { init: function(b) {
          if ("select" !== a4.a.R(b))
            throw Error("options binding applies only to SELECT elements");
          for (; 0 < b.length; )
            b.remove(0);
          return { controlsDescendantBindings: true };
        }, update: function(b, c14, d) {
          function e2() {
            return a4.a.jb(b.options, function(a5) {
              return a5.selected;
            });
          }
          function f2(a5, b2, c15) {
            var d2 = typeof b2;
            return "function" == d2 ? b2(a5) : "string" == d2 ? a5[b2] : c15;
          }
          function g(c15, d2) {
            if (x && l2)
              a4.i.ma(b, a4.i.H);
            else if (t.length) {
              var e3 = 0 <= a4.a.A(t, a4.w.M(d2[0]));
              a4.a.Zc(d2[0], e3);
              x && !e3 && a4.u.G(a4.a.Fb, null, [b, "change"]);
            }
          }
          var h = b.multiple, m = 0 != b.length && h ? b.scrollTop : null, k = a4.a.f(c14()), l2 = d.get("valueAllowUnset") && d.has("value"), p2 = d.get("optionsIncludeDestroyed");
          c14 = {};
          var q, t = [];
          l2 || (h ? t = a4.a.Mb(e2(), a4.w.M) : 0 <= b.selectedIndex && t.push(a4.w.M(b.options[b.selectedIndex])));
          k && ("undefined" == typeof k.length && (k = [k]), q = a4.a.jb(k, function(b2) {
            return p2 || b2 === n2 || null === b2 || !a4.a.f(b2._destroy);
          }), d.has("optionsCaption") && (k = a4.a.f(d.get("optionsCaption")), null !== k && k !== n2 && q.unshift(Q)));
          var x = false;
          c14.beforeRemove = function(a5) {
            b.removeChild(a5);
          };
          k = g;
          d.has("optionsAfterRender") && "function" == typeof d.get("optionsAfterRender") && (k = function(b2, c15) {
            g(0, c15);
            a4.u.G(d.get("optionsAfterRender"), null, [c15[0], b2 !== Q ? b2 : n2]);
          });
          a4.a.ec(b, q, function(c15, e3, g2) {
            g2.length && (t = !l2 && g2[0].selected ? [a4.w.M(g2[0])] : [], x = true);
            e3 = b.ownerDocument.createElement("option");
            c15 === Q ? (a4.a.Bb(e3, d.get("optionsCaption")), a4.w.cb(e3, n2)) : (g2 = f2(c15, d.get("optionsValue"), c15), a4.w.cb(e3, a4.a.f(g2)), c15 = f2(c15, d.get("optionsText"), g2), a4.a.Bb(e3, c15));
            return [e3];
          }, c14, k);
          if (!l2) {
            var B;
            h ? B = t.length && e2().length < t.length : B = t.length && 0 <= b.selectedIndex ? a4.w.M(b.options[b.selectedIndex]) !== t[0] : t.length || 0 <= b.selectedIndex;
            B && a4.u.G(a4.a.Fb, null, [b, "change"]);
          }
          (l2 || a4.S.Ya()) && a4.i.ma(b, a4.i.H);
          a4.a.wd(b);
          m && 20 < Math.abs(m - b.scrollTop) && (b.scrollTop = m);
        } };
        a4.c.options.$b = a4.a.g.Z();
        a4.c.selectedOptions = { init: function(b, c14, d) {
          function e2() {
            var e3 = c14(), f3 = [];
            a4.a.D(b.getElementsByTagName("option"), function(b2) {
              b2.selected && f3.push(a4.w.M(b2));
            });
            a4.m.eb(
              e3,
              d,
              "selectedOptions",
              f3
            );
          }
          function f2() {
            var d2 = a4.a.f(c14()), e3 = b.scrollTop;
            d2 && "number" == typeof d2.length && a4.a.D(b.getElementsByTagName("option"), function(b2) {
              var c15 = 0 <= a4.a.A(d2, a4.w.M(b2));
              b2.selected != c15 && a4.a.Zc(b2, c15);
            });
            b.scrollTop = e3;
          }
          if ("select" != a4.a.R(b))
            throw Error("selectedOptions binding applies only to SELECT elements");
          var g;
          a4.i.subscribe(b, a4.i.H, function() {
            g ? e2() : (a4.a.B(b, "change", e2), g = a4.o(f2, null, { l: b }));
          }, null, { notifyImmediately: true });
        }, update: function() {
        } };
        a4.m.wa.selectedOptions = true;
        a4.c.style = { update: function(b, c14) {
          var d = a4.a.f(c14() || {});
          a4.a.P(d, function(c15, d2) {
            d2 = a4.a.f(d2);
            if (null === d2 || d2 === n2 || false === d2)
              d2 = "";
            if (v7)
              v7(b).css(c15, d2);
            else if (/^--/.test(c15))
              b.style.setProperty(c15, d2);
            else {
              c15 = c15.replace(/-(\w)/g, function(a5, b2) {
                return b2.toUpperCase();
              });
              var g = b.style[c15];
              b.style[c15] = d2;
              d2 === g || b.style[c15] != g || isNaN(d2) || (b.style[c15] = d2 + "px");
            }
          });
        } };
        a4.c.submit = { init: function(b, c14, d, e2, f2) {
          if ("function" != typeof c14())
            throw Error("The value for a submit binding must be a function");
          a4.a.B(b, "submit", function(a5) {
            var d2, e3 = c14();
            try {
              d2 = e3.call(f2.$data, b);
            } finally {
              true !== d2 && (a5.preventDefault ? a5.preventDefault() : a5.returnValue = false);
            }
          });
        } };
        a4.c.text = { init: function() {
          return { controlsDescendantBindings: true };
        }, update: function(b, c14) {
          a4.a.Bb(b, c14());
        } };
        a4.h.ea.text = true;
        (function() {
          if (A && A.navigator) {
            var b = function(a5) {
              if (a5)
                return parseFloat(a5[1]);
            }, c14 = A.navigator.userAgent, d, e2, f2, g, h;
            (d = A.opera && A.opera.version && parseInt(A.opera.version())) || (h = b(c14.match(/Edge\/([^ ]+)$/))) || b(c14.match(/Chrome\/([^ ]+)/)) || (e2 = b(c14.match(/Version\/([^ ]+) Safari/))) || (f2 = b(c14.match(/Firefox\/([^ ]+)/))) || (g = a4.a.W || b(c14.match(/MSIE ([^ ]+)/))) || (g = b(c14.match(/rv:([^ )]+)/)));
          }
          if (8 <= g && 10 > g)
            var m = a4.a.g.Z(), k = a4.a.g.Z(), l2 = function(b2) {
              var c15 = this.activeElement;
              (c15 = c15 && a4.a.g.get(c15, k)) && c15(b2);
            }, p2 = function(b2, c15) {
              var d2 = b2.ownerDocument;
              a4.a.g.get(d2, m) || (a4.a.g.set(d2, m, true), a4.a.B(d2, "selectionchange", l2));
              a4.a.g.set(b2, k, c15);
            };
          a4.c.textInput = { init: function(b2, c15, k2) {
            function l3(c16, d2) {
              a4.a.B(b2, c16, d2);
            }
            function m2() {
              var d2 = a4.a.f(c15());
              if (null === d2 || d2 === n2)
                d2 = "";
              L !== n2 && d2 === L ? a4.a.setTimeout(m2, 4) : b2.value !== d2 && (y = true, b2.value = d2, y = false, v8 = b2.value);
            }
            function r3() {
              w2 || (L = b2.value, w2 = a4.a.setTimeout(
                z,
                4
              ));
            }
            function z() {
              clearTimeout(w2);
              L = w2 = n2;
              var d2 = b2.value;
              v8 !== d2 && (v8 = d2, a4.m.eb(c15(), k2, "textInput", d2));
            }
            var v8 = b2.value, w2, L, A2 = 9 == a4.a.W ? r3 : z, y = false;
            g && l3("keypress", z);
            11 > g && l3("propertychange", function(a5) {
              y || "value" !== a5.propertyName || A2(a5);
            });
            8 == g && (l3("keyup", z), l3("keydown", z));
            p2 && (p2(b2, A2), l3("dragend", r3));
            (!g || 9 <= g) && l3("input", A2);
            5 > e2 && "textarea" === a4.a.R(b2) ? (l3("keydown", r3), l3("paste", r3), l3("cut", r3)) : 11 > d ? l3("keydown", r3) : 4 > f2 ? (l3("DOMAutoComplete", z), l3("dragdrop", z), l3("drop", z)) : h && "number" === b2.type && l3("keydown", r3);
            l3(
              "change",
              z
            );
            l3("blur", z);
            a4.o(m2, null, { l: b2 });
          } };
          a4.m.wa.textInput = true;
          a4.c.textinput = { preprocess: function(a5, b2, c15) {
            c15("textInput", a5);
          } };
        })();
        a4.c.uniqueName = { init: function(b, c14) {
          if (c14()) {
            var d = "ko_unique_" + ++a4.c.uniqueName.rd;
            a4.a.Yc(b, d);
          }
        } };
        a4.c.uniqueName.rd = 0;
        a4.c.using = { init: function(b, c14, d, e2, f2) {
          var g;
          d.has("as") && (g = { as: d.get("as"), noChildContext: d.get("noChildContext") });
          c14 = f2.createChildContext(c14, g);
          a4.Oa(c14, b);
          return { controlsDescendantBindings: true };
        } };
        a4.h.ea.using = true;
        a4.c.value = { init: function(b, c14, d) {
          var e2 = a4.a.R(b), f2 = "input" == e2;
          if (!f2 || "checkbox" != b.type && "radio" != b.type) {
            var g = [], h = d.get("valueUpdate"), m = false, k = null;
            h && ("string" == typeof h ? g = [h] : g = a4.a.wc(h), a4.a.Pa(g, "change"));
            var l2 = function() {
              k = null;
              m = false;
              var e3 = c14(), f3 = a4.w.M(b);
              a4.m.eb(e3, d, "value", f3);
            };
            !a4.a.W || !f2 || "text" != b.type || "off" == b.autocomplete || b.form && "off" == b.form.autocomplete || -1 != a4.a.A(g, "propertychange") || (a4.a.B(b, "propertychange", function() {
              m = true;
            }), a4.a.B(b, "focus", function() {
              m = false;
            }), a4.a.B(b, "blur", function() {
              m && l2();
            }));
            a4.a.D(g, function(c15) {
              var d2 = l2;
              a4.a.Ud(c15, "after") && (d2 = function() {
                k = a4.w.M(b);
                a4.a.setTimeout(l2, 0);
              }, c15 = c15.substring(5));
              a4.a.B(b, c15, d2);
            });
            var p2;
            p2 = f2 && "file" == b.type ? function() {
              var d2 = a4.a.f(c14());
              null === d2 || d2 === n2 || "" === d2 ? b.value = "" : a4.u.G(l2);
            } : function() {
              var f3 = a4.a.f(c14()), g2 = a4.w.M(b);
              if (null !== k && f3 === k)
                a4.a.setTimeout(p2, 0);
              else if (f3 !== g2 || g2 === n2)
                "select" === e2 ? (g2 = d.get("valueAllowUnset"), a4.w.cb(b, f3, g2), g2 || f3 === a4.w.M(b) || a4.u.G(l2)) : a4.w.cb(b, f3);
            };
            if ("select" === e2) {
              var q;
              a4.i.subscribe(
                b,
                a4.i.H,
                function() {
                  q ? d.get("valueAllowUnset") ? p2() : l2() : (a4.a.B(b, "change", l2), q = a4.o(p2, null, { l: b }));
                },
                null,
                { notifyImmediately: true }
              );
            } else
              a4.a.B(b, "change", l2), a4.o(p2, null, { l: b });
          } else
            a4.ib(b, { checkedValue: c14 });
        }, update: function() {
        } };
        a4.m.wa.value = true;
        a4.c.visible = { update: function(b, c14) {
          var d = a4.a.f(c14()), e2 = "none" != b.style.display;
          d && !e2 ? b.style.display = "" : !d && e2 && (b.style.display = "none");
        } };
        a4.c.hidden = { update: function(b, c14) {
          a4.c.visible.update(b, function() {
            return !a4.a.f(c14());
          });
        } };
        (function(b) {
          a4.c[b] = { init: function(c14, d, e2, f2, g) {
            return a4.c.event.init.call(this, c14, function() {
              var a5 = {};
              a5[b] = d();
              return a5;
            }, e2, f2, g);
          } };
        })("click");
        a4.ca = function() {
        };
        a4.ca.prototype.renderTemplateSource = function() {
          throw Error("Override renderTemplateSource");
        };
        a4.ca.prototype.createJavaScriptEvaluatorBlock = function() {
          throw Error("Override createJavaScriptEvaluatorBlock");
        };
        a4.ca.prototype.makeTemplateSource = function(b, c14) {
          if ("string" == typeof b) {
            c14 = c14 || w;
            var d = c14.getElementById(b);
            if (!d)
              throw Error("Cannot find template with ID " + b);
            return new a4.C.F(d);
          }
          if (1 == b.nodeType || 8 == b.nodeType)
            return new a4.C.ia(b);
          throw Error("Unknown template type: " + b);
        };
        a4.ca.prototype.renderTemplate = function(a5, c14, d, e2) {
          a5 = this.makeTemplateSource(a5, e2);
          return this.renderTemplateSource(a5, c14, d, e2);
        };
        a4.ca.prototype.isTemplateRewritten = function(a5, c14) {
          return false === this.allowTemplateRewriting ? true : this.makeTemplateSource(a5, c14).data("isRewritten");
        };
        a4.ca.prototype.rewriteTemplate = function(a5, c14, d) {
          a5 = this.makeTemplateSource(a5, d);
          c14 = c14(a5.text());
          a5.text(c14);
          a5.data("isRewritten", true);
        };
        a4.b("templateEngine", a4.ca);
        a4.kc = function() {
          function b(b2, c15, d2, h) {
            b2 = a4.m.ac(b2);
            for (var m = a4.m.Ra, k = 0; k < b2.length; k++) {
              var l2 = b2[k].key;
              if (Object.prototype.hasOwnProperty.call(
                m,
                l2
              )) {
                var p2 = m[l2];
                if ("function" === typeof p2) {
                  if (l2 = p2(b2[k].value))
                    throw Error(l2);
                } else if (!p2)
                  throw Error("This template engine does not support the '" + l2 + "' binding within its templates");
              }
            }
            d2 = "ko.__tr_ambtns(function($context,$element){return(function(){return{ " + a4.m.vb(b2, { valueAccessors: true }) + " } })()},'" + d2.toLowerCase() + "')";
            return h.createJavaScriptEvaluatorBlock(d2) + c15;
          }
          var c14 = /(<([a-z]+\d*)(?:\s+(?!data-bind\s*=\s*)[a-z0-9\-]+(?:=(?:\"[^\"]*\"|\'[^\']*\'|[^>]*))?)*\s+)data-bind\s*=\s*(["'])([\s\S]*?)\3/gi, d = /\x3c!--\s*ko\b\s*([\s\S]*?)\s*--\x3e/g;
          return { xd: function(b2, c15, d2) {
            c15.isTemplateRewritten(b2, d2) || c15.rewriteTemplate(b2, function(b3) {
              return a4.kc.Ld(b3, c15);
            }, d2);
          }, Ld: function(a5, f2) {
            return a5.replace(c14, function(a6, c15, d2, e2, l2) {
              return b(l2, c15, d2, f2);
            }).replace(d, function(a6, c15) {
              return b(c15, "<!-- ko -->", "#comment", f2);
            });
          }, md: function(b2, c15) {
            return a4.aa.Xb(function(d2, h) {
              var m = d2.nextSibling;
              m && m.nodeName.toLowerCase() === c15 && a4.ib(m, b2, h);
            });
          } };
        }();
        a4.b("__tr_ambtns", a4.kc.md);
        (function() {
          a4.C = {};
          a4.C.F = function(b2) {
            if (this.F = b2) {
              var c15 = a4.a.R(b2);
              this.ab = "script" === c15 ? 1 : "textarea" === c15 ? 2 : "template" == c15 && b2.content && 11 === b2.content.nodeType ? 3 : 4;
            }
          };
          a4.C.F.prototype.text = function() {
            var b2 = 1 === this.ab ? "text" : 2 === this.ab ? "value" : "innerHTML";
            if (0 == arguments.length)
              return this.F[b2];
            var c15 = arguments[0];
            "innerHTML" === b2 ? a4.a.fc(this.F, c15) : this.F[b2] = c15;
          };
          var b = a4.a.g.Z() + "_";
          a4.C.F.prototype.data = function(c15) {
            if (1 === arguments.length)
              return a4.a.g.get(this.F, b + c15);
            a4.a.g.set(this.F, b + c15, arguments[1]);
          };
          var c14 = a4.a.g.Z();
          a4.C.F.prototype.nodes = function() {
            var b2 = this.F;
            if (0 == arguments.length) {
              var e2 = a4.a.g.get(b2, c14) || {}, f2 = e2.lb || (3 === this.ab ? b2.content : 4 === this.ab ? b2 : n2);
              if (!f2 || e2.jd) {
                var g = this.text();
                g && g !== e2.bb && (f2 = a4.a.Md(g, b2.ownerDocument), a4.a.g.set(b2, c14, { lb: f2, bb: g, jd: true }));
              }
              return f2;
            }
            e2 = arguments[0];
            this.ab !== n2 && this.text("");
            a4.a.g.set(b2, c14, { lb: e2 });
          };
          a4.C.ia = function(a5) {
            this.F = a5;
          };
          a4.C.ia.prototype = new a4.C.F();
          a4.C.ia.prototype.constructor = a4.C.ia;
          a4.C.ia.prototype.text = function() {
            if (0 == arguments.length) {
              var b2 = a4.a.g.get(this.F, c14) || {};
              b2.bb === n2 && b2.lb && (b2.bb = b2.lb.innerHTML);
              return b2.bb;
            }
            a4.a.g.set(
              this.F,
              c14,
              { bb: arguments[0] }
            );
          };
          a4.b("templateSources", a4.C);
          a4.b("templateSources.domElement", a4.C.F);
          a4.b("templateSources.anonymousTemplate", a4.C.ia);
        })();
        (function() {
          function b(b2, c15, d2) {
            var e3;
            for (c15 = a4.h.nextSibling(c15); b2 && (e3 = b2) !== c15; )
              b2 = a4.h.nextSibling(e3), d2(e3, b2);
          }
          function c14(c15, d2) {
            if (c15.length) {
              var e3 = c15[0], f3 = c15[c15.length - 1], g2 = e3.parentNode, h2 = a4.ga.instance, m2 = h2.preprocessNode;
              if (m2) {
                b(e3, f3, function(a5, b2) {
                  var c16 = a5.previousSibling, d3 = m2.call(h2, a5);
                  d3 && (a5 === e3 && (e3 = d3[0] || b2), a5 === f3 && (f3 = d3[d3.length - 1] || c16));
                });
                c15.length = 0;
                if (!e3)
                  return;
                e3 === f3 ? c15.push(e3) : (c15.push(e3, f3), a4.a.Ua(c15, g2));
              }
              b(e3, f3, function(b2) {
                1 !== b2.nodeType && 8 !== b2.nodeType || a4.vc(d2, b2);
              });
              b(e3, f3, function(b2) {
                1 !== b2.nodeType && 8 !== b2.nodeType || a4.aa.cd(b2, [d2]);
              });
              a4.a.Ua(c15, g2);
            }
          }
          function d(a5) {
            return a5.nodeType ? a5 : 0 < a5.length ? a5[0] : null;
          }
          function e2(b2, e3, f3, h2, m2) {
            m2 = m2 || {};
            var n3 = (b2 && d(b2) || f3 || {}).ownerDocument, B = m2.templateEngine || g;
            a4.kc.xd(f3, B, n3);
            f3 = B.renderTemplate(f3, h2, m2, n3);
            if ("number" != typeof f3.length || 0 < f3.length && "number" != typeof f3[0].nodeType)
              throw Error("Template engine must return an array of DOM nodes");
            n3 = false;
            switch (e3) {
              case "replaceChildren":
                a4.h.va(
                  b2,
                  f3
                );
                n3 = true;
                break;
              case "replaceNode":
                a4.a.Xc(b2, f3);
                n3 = true;
                break;
              case "ignoreTargetNode":
                break;
              default:
                throw Error("Unknown renderMode: " + e3);
            }
            n3 && (c14(f3, h2), m2.afterRender && a4.u.G(m2.afterRender, null, [f3, h2[m2.as || "$data"]]), "replaceChildren" == e3 && a4.i.ma(b2, a4.i.H));
            return f3;
          }
          function f2(b2, c15, d2) {
            return a4.O(b2) ? b2() : "function" === typeof b2 ? b2(c15, d2) : b2;
          }
          var g;
          a4.gc = function(b2) {
            if (b2 != n2 && !(b2 instanceof a4.ca))
              throw Error("templateEngine must inherit from ko.templateEngine");
            g = b2;
          };
          a4.dc = function(b2, c15, h2, m2, t) {
            h2 = h2 || {};
            if ((h2.templateEngine || g) == n2)
              throw Error("Set a template engine before calling renderTemplate");
            t = t || "replaceChildren";
            if (m2) {
              var x = d(m2);
              return a4.$(function() {
                var g2 = c15 && c15 instanceof a4.fa ? c15 : new a4.fa(c15, null, null, null, { exportDependencies: true }), n3 = f2(b2, g2.$data, g2), g2 = e2(m2, t, n3, g2, h2);
                "replaceNode" == t && (m2 = g2, x = d(m2));
              }, null, { Sa: function() {
                return !x || !a4.a.Sb(x);
              }, l: x && "replaceNode" == t ? x.parentNode : x });
            }
            return a4.aa.Xb(function(d2) {
              a4.dc(b2, c15, h2, d2, "replaceNode");
            });
          };
          a4.Qd = function(b2, d2, g2, h2, m2) {
            function x(b3, c15) {
              a4.u.G(a4.a.ec, null, [h2, b3, u3, g2, r3, c15]);
              a4.i.ma(h2, a4.i.H);
            }
            function r3(a5, b3) {
              c14(b3, v8);
              g2.afterRender && g2.afterRender(b3, a5);
              v8 = null;
            }
            function u3(a5, c15) {
              v8 = m2.createChildContext(a5, { as: z, noChildContext: g2.noChildContext, extend: function(a6) {
                a6.$index = c15;
                z && (a6[z + "Index"] = c15);
              } });
              var d3 = f2(b2, a5, v8);
              return e2(h2, "ignoreTargetNode", d3, v8, g2);
            }
            var v8, z = g2.as, w2 = false === g2.includeDestroyed || a4.options.foreachHidesDestroyed && !g2.includeDestroyed;
            if (w2 || g2.beforeRemove || !a4.Pc(d2))
              return a4.$(function() {
                var b3 = a4.a.f(d2) || [];
                "undefined" == typeof b3.length && (b3 = [b3]);
                w2 && (b3 = a4.a.jb(b3, function(b4) {
                  return b4 === n2 || null === b4 || !a4.a.f(b4._destroy);
                }));
                x(b3);
              }, null, { l: h2 });
            x(d2.v());
            var A2 = d2.subscribe(function(a5) {
              x(d2(), a5);
            }, null, "arrayChange");
            A2.l(h2);
            return A2;
          };
          var h = a4.a.g.Z(), m = a4.a.g.Z();
          a4.c.template = { init: function(b2, c15) {
            var d2 = a4.a.f(c15());
            if ("string" == typeof d2 || "name" in d2)
              a4.h.Ea(b2);
            else if ("nodes" in d2) {
              d2 = d2.nodes || [];
              if (a4.O(d2))
                throw Error('The "nodes" option must be a plain, non-observable array.');
              var e3 = d2[0] && d2[0].parentNode;
              e3 && a4.a.g.get(e3, m) || (e3 = a4.a.Yb(d2), a4.a.g.set(e3, m, true));
              new a4.C.ia(b2).nodes(e3);
            } else if (d2 = a4.h.childNodes(b2), 0 < d2.length)
              e3 = a4.a.Yb(d2), new a4.C.ia(b2).nodes(e3);
            else
              throw Error("Anonymous template defined, but no template content was provided");
            return { controlsDescendantBindings: true };
          }, update: function(b2, c15, d2, e3, f3) {
            var g2 = c15();
            c15 = a4.a.f(g2);
            d2 = true;
            e3 = null;
            "string" == typeof c15 ? c15 = {} : (g2 = "name" in c15 ? c15.name : b2, "if" in c15 && (d2 = a4.a.f(c15["if"])), d2 && "ifnot" in c15 && (d2 = !a4.a.f(c15.ifnot)), d2 && !g2 && (d2 = false));
            "foreach" in c15 ? e3 = a4.Qd(g2, d2 && c15.foreach || [], c15, b2, f3) : d2 ? (d2 = f3, "data" in c15 && (d2 = f3.createChildContext(c15.data, { as: c15.as, noChildContext: c15.noChildContext, exportDependencies: true })), e3 = a4.dc(g2, d2, c15, b2)) : a4.h.Ea(b2);
            f3 = e3;
            (c15 = a4.a.g.get(b2, h)) && "function" == typeof c15.s && c15.s();
            a4.a.g.set(b2, h, !f3 || f3.ja && !f3.ja() ? n2 : f3);
          } };
          a4.m.Ra.template = function(b2) {
            b2 = a4.m.ac(b2);
            return 1 == b2.length && b2[0].unknown || a4.m.Id(b2, "name") ? null : "This template engine does not support anonymous templates nested within its templates";
          };
          a4.h.ea.template = true;
        })();
        a4.b("setTemplateEngine", a4.gc);
        a4.b("renderTemplate", a4.dc);
        a4.a.Kc = function(a5, c14, d) {
          if (a5.length && c14.length) {
            var e2, f2, g, h, m;
            for (e2 = f2 = 0; (!d || e2 < d) && (h = a5[f2]); ++f2) {
              for (g = 0; m = c14[g]; ++g)
                if (h.value === m.value) {
                  h.moved = m.index;
                  m.moved = h.index;
                  c14.splice(g, 1);
                  e2 = g = 0;
                  break;
                }
              e2 += g;
            }
          }
        };
        a4.a.Pb = function() {
          function b(b2, d, e2, f2, g) {
            var h = Math.min, m = Math.max, k = [], l2, p2 = b2.length, q, n3 = d.length, r3 = n3 - p2 || 1, v8 = p2 + n3 + 1, u3, w2, z;
            for (l2 = 0; l2 <= p2; l2++)
              for (w2 = u3, k.push(u3 = []), z = h(n3, l2 + r3), q = m(0, l2 - 1); q <= z; q++)
                u3[q] = q ? l2 ? b2[l2 - 1] === d[q - 1] ? w2[q - 1] : h(w2[q] || v8, u3[q - 1] || v8) + 1 : q + 1 : l2 + 1;
            h = [];
            m = [];
            r3 = [];
            l2 = p2;
            for (q = n3; l2 || q; )
              n3 = k[l2][q] - 1, q && n3 === k[l2][q - 1] ? m.push(h[h.length] = { status: e2, value: d[--q], index: q }) : l2 && n3 === k[l2 - 1][q] ? r3.push(h[h.length] = { status: f2, value: b2[--l2], index: l2 }) : (--q, --l2, g.sparse || h.push({ status: "retained", value: d[q] }));
            a4.a.Kc(r3, m, !g.dontLimitMoves && 10 * p2);
            return h.reverse();
          }
          return function(a5, d, e2) {
            e2 = "boolean" === typeof e2 ? { dontLimitMoves: e2 } : e2 || {};
            a5 = a5 || [];
            d = d || [];
            return a5.length < d.length ? b(a5, d, "added", "deleted", e2) : b(d, a5, "deleted", "added", e2);
          };
        }();
        a4.b("utils.compareArrays", a4.a.Pb);
        (function() {
          function b(b2, c15, d2, h, m) {
            var k = [], l2 = a4.$(function() {
              var l3 = c15(d2, m, a4.a.Ua(k, b2)) || [];
              0 < k.length && (a4.a.Xc(k, l3), h && a4.u.G(h, null, [d2, l3, m]));
              k.length = 0;
              a4.a.Nb(k, l3);
            }, null, { l: b2, Sa: function() {
              return !a4.a.kd(k);
            } });
            return { Y: k, $: l2.ja() ? l2 : n2 };
          }
          var c14 = a4.a.g.Z(), d = a4.a.g.Z();
          a4.a.ec = function(e2, f2, g, h, m, k) {
            function l2(b2) {
              y = { Aa: b2, pb: a4.ta(w2++) };
              v8.push(y);
              r3 || F2.push(y);
            }
            function p2(b2) {
              y = t[b2];
              w2 !== y.pb.v() && D2.push(y);
              y.pb(w2++);
              a4.a.Ua(y.Y, e2);
              v8.push(y);
            }
            function q(b2, c15) {
              if (b2)
                for (var d2 = 0, e3 = c15.length; d2 < e3; d2++)
                  a4.a.D(c15[d2].Y, function(a5) {
                    b2(a5, d2, c15[d2].Aa);
                  });
            }
            f2 = f2 || [];
            "undefined" == typeof f2.length && (f2 = [f2]);
            h = h || {};
            var t = a4.a.g.get(e2, c14), r3 = !t, v8 = [], u3 = 0, w2 = 0, z = [], A2 = [], C2 = [], D2 = [], F2 = [], y, I2 = 0;
            if (r3)
              a4.a.D(f2, l2);
            else {
              if (!k || t && t._countWaitingForRemove) {
                var E = a4.a.Mb(t, function(a5) {
                  return a5.Aa;
                });
                k = a4.a.Pb(E, f2, { dontLimitMoves: h.dontLimitMoves, sparse: true });
              }
              for (var E = 0, G2, H2, K2; G2 = k[E]; E++)
                switch (H2 = G2.moved, K2 = G2.index, G2.status) {
                  case "deleted":
                    for (; u3 < K2; )
                      p2(u3++);
                    H2 === n2 && (y = t[u3], y.$ && (y.$.s(), y.$ = n2), a4.a.Ua(y.Y, e2).length && (h.beforeRemove && (v8.push(y), I2++, y.Aa === d ? y = null : C2.push(y)), y && z.push.apply(z, y.Y)));
                    u3++;
                    break;
                  case "added":
                    for (; w2 < K2; )
                      p2(u3++);
                    H2 !== n2 ? (A2.push(v8.length), p2(H2)) : l2(G2.value);
                }
              for (; w2 < f2.length; )
                p2(u3++);
              v8._countWaitingForRemove = I2;
            }
            a4.a.g.set(e2, c14, v8);
            q(h.beforeMove, D2);
            a4.a.D(
              z,
              h.beforeRemove ? a4.oa : a4.removeNode
            );
            var M, O, P;
            try {
              P = e2.ownerDocument.activeElement;
            } catch (N2) {
            }
            if (A2.length)
              for (; (E = A2.shift()) != n2; ) {
                y = v8[E];
                for (M = n2; E; )
                  if ((O = v8[--E].Y) && O.length) {
                    M = O[O.length - 1];
                    break;
                  }
                for (f2 = 0; u3 = y.Y[f2]; M = u3, f2++)
                  a4.h.Wb(e2, u3, M);
              }
            for (E = 0; y = v8[E]; E++) {
              y.Y || a4.a.extend(y, b(e2, g, y.Aa, m, y.pb));
              for (f2 = 0; u3 = y.Y[f2]; M = u3, f2++)
                a4.h.Wb(e2, u3, M);
              !y.Ed && m && (m(y.Aa, y.Y, y.pb), y.Ed = true, M = y.Y[y.Y.length - 1]);
            }
            P && e2.ownerDocument.activeElement != P && P.focus();
            q(h.beforeRemove, C2);
            for (E = 0; E < C2.length; ++E)
              C2[E].Aa = d;
            q(h.afterMove, D2);
            q(h.afterAdd, F2);
          };
        })();
        a4.b("utils.setDomNodeChildrenFromArrayMapping", a4.a.ec);
        a4.ba = function() {
          this.allowTemplateRewriting = false;
        };
        a4.ba.prototype = new a4.ca();
        a4.ba.prototype.constructor = a4.ba;
        a4.ba.prototype.renderTemplateSource = function(b, c14, d, e2) {
          if (c14 = (9 > a4.a.W ? 0 : b.nodes) ? b.nodes() : null)
            return a4.a.la(c14.cloneNode(true).childNodes);
          b = b.text();
          return a4.a.ua(b, e2);
        };
        a4.ba.Ma = new a4.ba();
        a4.gc(a4.ba.Ma);
        a4.b("nativeTemplateEngine", a4.ba);
        (function() {
          a4.$a = function() {
            var a5 = this.Hd = function() {
              if (!v7 || !v7.tmpl)
                return 0;
              try {
                if (0 <= v7.tmpl.tag.tmpl.open.toString().indexOf("__"))
                  return 2;
              } catch (a6) {
              }
              return 1;
            }();
            this.renderTemplateSource = function(b2, e2, f2, g) {
              g = g || w;
              f2 = f2 || {};
              if (2 > a5)
                throw Error("Your version of jQuery.tmpl is too old. Please upgrade to jQuery.tmpl 1.0.0pre or later.");
              var h = b2.data("precompiled");
              h || (h = b2.text() || "", h = v7.template(null, "{{ko_with $item.koBindingContext}}" + h + "{{/ko_with}}"), b2.data("precompiled", h));
              b2 = [e2.$data];
              e2 = v7.extend({ koBindingContext: e2 }, f2.templateOptions);
              e2 = v7.tmpl(h, b2, e2);
              e2.appendTo(g.createElement("div"));
              v7.fragments = {};
              return e2;
            };
            this.createJavaScriptEvaluatorBlock = function(a6) {
              return "{{ko_code ((function() { return " + a6 + " })()) }}";
            };
            this.addTemplate = function(a6, b2) {
              w.write("<script type='text/html' id='" + a6 + "'>" + b2 + "<\/script>");
            };
            0 < a5 && (v7.tmpl.tag.ko_code = { open: "__.push($1 || '');" }, v7.tmpl.tag.ko_with = { open: "with($1) {", close: "} " });
          };
          a4.$a.prototype = new a4.ca();
          a4.$a.prototype.constructor = a4.$a;
          var b = new a4.$a();
          0 < b.Hd && a4.gc(b);
          a4.b("jqueryTmplTemplateEngine", a4.$a);
        })();
      });
    })();
  })();
})();
var knockout = ko;
if (typeof window !== "undefined") {
  ko = window.ko;
  if (typeof oldValue !== "undefined") {
    window.ko = oldValue;
  } else {
    delete window.ko;
  }
} else {
  ko = global.ko;
  if (typeof oldValue !== "undefined") {
    global.ko = oldValue;
  } else {
    delete global.ko;
  }
}
var knockout_3_5_1_default = knockout;

// node_modules/cesium/Source/ThirdParty/knockout-es5.js
var OBSERVABLES_PROPERTY = "__knockoutObservables";
var SUBSCRIBABLE_PROPERTY = "__knockoutSubscribable";
function track(obj, propertyNames) {
  if (!obj) {
    throw new Error("When calling ko.track, you must pass an object as the first parameter.");
  }
  var ko2 = this, allObservablesForObject = getAllObservablesForObject(obj, true);
  propertyNames = propertyNames || Object.getOwnPropertyNames(obj);
  propertyNames.forEach(function(propertyName) {
    if (propertyName === OBSERVABLES_PROPERTY || propertyName === SUBSCRIBABLE_PROPERTY) {
      return;
    }
    if (propertyName in allObservablesForObject) {
      return;
    }
    var origValue = obj[propertyName], isArray = origValue instanceof Array, observable = ko2.isObservable(origValue) ? origValue : isArray ? ko2.observableArray(origValue) : ko2.observable(origValue);
    Object.defineProperty(obj, propertyName, {
      configurable: true,
      enumerable: true,
      get: observable,
      set: ko2.isWriteableObservable(observable) ? observable : void 0
    });
    allObservablesForObject[propertyName] = observable;
    if (isArray) {
      notifyWhenPresentOrFutureArrayValuesMutate(ko2, observable);
    }
  });
  return obj;
}
function getAllObservablesForObject(obj, createIfNotDefined) {
  var result = obj[OBSERVABLES_PROPERTY];
  if (!result && createIfNotDefined) {
    result = {};
    Object.defineProperty(obj, OBSERVABLES_PROPERTY, {
      value: result
    });
  }
  return result;
}
function defineComputedProperty(obj, propertyName, evaluatorOrOptions) {
  var ko2 = this, computedOptions = { owner: obj, deferEvaluation: true };
  if (typeof evaluatorOrOptions === "function") {
    computedOptions.read = evaluatorOrOptions;
  } else {
    if ("value" in evaluatorOrOptions) {
      throw new Error('For ko.defineProperty, you must not specify a "value" for the property. You must provide a "get" function.');
    }
    if (typeof evaluatorOrOptions.get !== "function") {
      throw new Error('For ko.defineProperty, the third parameter must be either an evaluator function, or an options object containing a function called "get".');
    }
    computedOptions.read = evaluatorOrOptions.get;
    computedOptions.write = evaluatorOrOptions.set;
  }
  obj[propertyName] = ko2.computed(computedOptions);
  track.call(ko2, obj, [propertyName]);
  return obj;
}
function notifyWhenPresentOrFutureArrayValuesMutate(ko2, observable) {
  var watchingArraySubscription = null;
  ko2.computed(function() {
    if (watchingArraySubscription) {
      watchingArraySubscription.dispose();
      watchingArraySubscription = null;
    }
    var newArrayInstance = observable();
    if (newArrayInstance instanceof Array) {
      watchingArraySubscription = startWatchingArrayInstance(ko2, observable, newArrayInstance);
    }
  });
}
function startWatchingArrayInstance(ko2, observable, arrayInstance) {
  var subscribable = getSubscribableForArray(ko2, arrayInstance);
  return subscribable.subscribe(observable);
}
function getSubscribableForArray(ko2, arrayInstance) {
  var subscribable = arrayInstance[SUBSCRIBABLE_PROPERTY];
  if (!subscribable) {
    subscribable = new ko2.subscribable();
    Object.defineProperty(arrayInstance, SUBSCRIBABLE_PROPERTY, {
      value: subscribable
    });
    var notificationPauseSignal = {};
    wrapStandardArrayMutators(arrayInstance, subscribable, notificationPauseSignal);
    addKnockoutArrayMutators(ko2, arrayInstance, subscribable, notificationPauseSignal);
  }
  return subscribable;
}
function wrapStandardArrayMutators(arrayInstance, subscribable, notificationPauseSignal) {
  ["pop", "push", "reverse", "shift", "sort", "splice", "unshift"].forEach(function(fnName) {
    var origMutator = arrayInstance[fnName];
    arrayInstance[fnName] = function() {
      var result = origMutator.apply(this, arguments);
      if (notificationPauseSignal.pause !== true) {
        subscribable.notifySubscribers(this);
      }
      return result;
    };
  });
}
function addKnockoutArrayMutators(ko2, arrayInstance, subscribable, notificationPauseSignal) {
  ["remove", "removeAll", "destroy", "destroyAll", "replace"].forEach(function(fnName) {
    Object.defineProperty(arrayInstance, fnName, {
      enumerable: false,
      value: function() {
        var result;
        notificationPauseSignal.pause = true;
        try {
          result = ko2.observableArray.fn[fnName].apply(ko2.observableArray(arrayInstance), arguments);
        } finally {
          notificationPauseSignal.pause = false;
        }
        subscribable.notifySubscribers(arrayInstance);
        return result;
      }
    });
  });
}
function getObservable(obj, propertyName) {
  if (!obj) {
    return null;
  }
  var allObservablesForObject = getAllObservablesForObject(obj, false);
  return allObservablesForObject && allObservablesForObject[propertyName] || null;
}
function valueHasMutated(obj, propertyName) {
  var observable = getObservable(obj, propertyName);
  if (observable) {
    observable.valueHasMutated();
  }
}
function attachToKo(ko2) {
  ko2.track = track;
  ko2.getObservable = getObservable;
  ko2.valueHasMutated = valueHasMutated;
  ko2.defineProperty = defineComputedProperty;
}
var knockout_es5_default = {
  attachToKo
};

// node_modules/cesium/Source/Widgets/SvgPathBindingHandler.js
var svgNS = "http://www.w3.org/2000/svg";
var svgClassName = "cesium-svgPath-svg";
var SvgPathBindingHandler = {
  register: function(knockout2) {
    knockout2.bindingHandlers.cesiumSvgPath = {
      init: function(element, valueAccessor) {
        const svg2 = document.createElementNS(svgNS, "svg:svg");
        svg2.setAttribute("class", svgClassName);
        const pathElement = document.createElementNS(svgNS, "path");
        svg2.appendChild(pathElement);
        knockout2.virtualElements.setDomNodeChildren(element, [svg2]);
        knockout2.computed({
          read: function() {
            const value = knockout2.unwrap(valueAccessor());
            pathElement.setAttribute("d", knockout2.unwrap(value.path));
            const pathWidth = knockout2.unwrap(value.width);
            const pathHeight = knockout2.unwrap(value.height);
            svg2.setAttribute("width", pathWidth);
            svg2.setAttribute("height", pathHeight);
            svg2.setAttribute("viewBox", `0 0 ${pathWidth} ${pathHeight}`);
            if (value.css) {
              svg2.setAttribute(
                "class",
                `${svgClassName} ${knockout2.unwrap(value.css)}`
              );
            }
          },
          disposeWhenNodeIsRemoved: element
        });
        return {
          controlsDescendantBindings: true
        };
      }
    };
    knockout2.virtualElements.allowedBindings.cesiumSvgPath = true;
  }
};
var SvgPathBindingHandler_default = SvgPathBindingHandler;

// node_modules/cesium/Source/ThirdParty/knockout.js
knockout_es5_default.attachToKo(knockout_3_5_1_default);
SvgPathBindingHandler_default.register(knockout_3_5_1_default);
var knockout_default = knockout_3_5_1_default;

// node_modules/cesium/Source/ThirdParty/ktx-parse.js
var e = [171, 75, 84, 88, 32, 50, 48, 187, 13, 10, 26, 10];
var n;
var i;
var s;
var a3;
var r;
var o;
var l;
var f;
!function(t) {
  t[t.NONE = 0] = "NONE", t[t.BASISLZ = 1] = "BASISLZ", t[t.ZSTD = 2] = "ZSTD", t[t.ZLIB = 3] = "ZLIB";
}(n || (n = {})), function(t) {
  t[t.BASICFORMAT = 0] = "BASICFORMAT";
}(i || (i = {})), function(t) {
  t[t.UNSPECIFIED = 0] = "UNSPECIFIED", t[t.ETC1S = 163] = "ETC1S", t[t.UASTC = 166] = "UASTC";
}(s || (s = {})), function(t) {
  t[t.UNSPECIFIED = 0] = "UNSPECIFIED", t[t.SRGB = 1] = "SRGB";
}(a3 || (a3 = {})), function(t) {
  t[t.UNSPECIFIED = 0] = "UNSPECIFIED", t[t.LINEAR = 1] = "LINEAR", t[t.SRGB = 2] = "SRGB", t[t.ITU = 3] = "ITU", t[t.NTSC = 4] = "NTSC", t[t.SLOG = 5] = "SLOG", t[t.SLOG2 = 6] = "SLOG2";
}(r || (r = {})), function(t) {
  t[t.ALPHA_STRAIGHT = 0] = "ALPHA_STRAIGHT", t[t.ALPHA_PREMULTIPLIED = 1] = "ALPHA_PREMULTIPLIED";
}(o || (o = {})), function(t) {
  t[t.RGB = 0] = "RGB", t[t.RRR = 3] = "RRR", t[t.GGG = 4] = "GGG", t[t.AAA = 15] = "AAA";
}(l || (l = {})), function(t) {
  t[t.RGB = 0] = "RGB", t[t.RGBA = 3] = "RGBA", t[t.RRR = 4] = "RRR", t[t.RRRG = 5] = "RRRG";
}(f || (f = {}));
var U = class {
  constructor() {
    this.vkFormat = 0, this.typeSize = 1, this.pixelWidth = 0, this.pixelHeight = 0, this.pixelDepth = 0, this.layerCount = 0, this.faceCount = 1, this.supercompressionScheme = n.NONE, this.levels = [], this.dataFormatDescriptor = [{ vendorId: 0, descriptorType: i.BASICFORMAT, versionNumber: 2, descriptorBlockSize: 40, colorModel: s.UNSPECIFIED, colorPrimaries: a3.SRGB, transferFunction: a3.SRGB, flags: o.ALPHA_STRAIGHT, texelBlockDimension: { x: 4, y: 4, z: 1, w: 1 }, bytesPlane: [], samples: [] }], this.keyValue = {}, this.globalData = null;
  }
};
var c = class {
  constructor(t, e2, n2, i2) {
    this._dataView = new DataView(t.buffer, t.byteOffset + e2, n2), this._littleEndian = i2, this._offset = 0;
  }
  _nextUint8() {
    const t = this._dataView.getUint8(this._offset);
    return this._offset += 1, t;
  }
  _nextUint16() {
    const t = this._dataView.getUint16(this._offset, this._littleEndian);
    return this._offset += 2, t;
  }
  _nextUint32() {
    const t = this._dataView.getUint32(this._offset, this._littleEndian);
    return this._offset += 4, t;
  }
  _nextUint64() {
    const t = this._dataView.getUint32(this._offset, this._littleEndian) + 2 ** 32 * this._dataView.getUint32(this._offset + 4, this._littleEndian);
    return this._offset += 8, t;
  }
  _skip(t) {
    return this._offset += t, this;
  }
  _scan(t, e2 = 0) {
    const n2 = this._offset;
    let i2 = 0;
    for (; this._dataView.getUint8(this._offset) !== e2 && i2 < t; )
      i2++, this._offset++;
    return i2 < t && this._offset++, new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + n2, i2);
  }
};
function _(t) {
  return "undefined" != typeof TextDecoder ? new TextDecoder().decode(t) : Buffer.from(t).toString("utf8");
}
function p(t) {
  const n2 = new Uint8Array(t.buffer, t.byteOffset, e.length);
  if (n2[0] !== e[0] || n2[1] !== e[1] || n2[2] !== e[2] || n2[3] !== e[3] || n2[4] !== e[4] || n2[5] !== e[5] || n2[6] !== e[6] || n2[7] !== e[7] || n2[8] !== e[8] || n2[9] !== e[9] || n2[10] !== e[10] || n2[11] !== e[11])
    throw new Error("Missing KTX 2.0 identifier.");
  const i2 = new U(), s2 = 17 * Uint32Array.BYTES_PER_ELEMENT, a4 = new c(t, e.length, s2, true);
  i2.vkFormat = a4._nextUint32(), i2.typeSize = a4._nextUint32(), i2.pixelWidth = a4._nextUint32(), i2.pixelHeight = a4._nextUint32(), i2.pixelDepth = a4._nextUint32(), i2.layerCount = a4._nextUint32(), i2.faceCount = a4._nextUint32();
  const r2 = a4._nextUint32();
  i2.supercompressionScheme = a4._nextUint32();
  const o2 = a4._nextUint32(), l2 = a4._nextUint32(), f2 = a4._nextUint32(), h = a4._nextUint32(), g = a4._nextUint64(), p2 = a4._nextUint64(), x = new c(t, e.length + s2, 3 * r2 * 8, true);
  for (let e2 = 0; e2 < r2; e2++)
    i2.levels.push({ levelData: new Uint8Array(t.buffer, t.byteOffset + x._nextUint64(), x._nextUint64()), uncompressedByteLength: x._nextUint64() });
  const u3 = new c(t, o2, l2, true), y = { vendorId: u3._skip(4)._nextUint16(), descriptorType: u3._nextUint16(), versionNumber: u3._nextUint16(), descriptorBlockSize: u3._nextUint16(), colorModel: u3._nextUint8(), colorPrimaries: u3._nextUint8(), transferFunction: u3._nextUint8(), flags: u3._nextUint8(), texelBlockDimension: { x: u3._nextUint8() + 1, y: u3._nextUint8() + 1, z: u3._nextUint8() + 1, w: u3._nextUint8() + 1 }, bytesPlane: [u3._nextUint8(), u3._nextUint8(), u3._nextUint8(), u3._nextUint8(), u3._nextUint8(), u3._nextUint8(), u3._nextUint8(), u3._nextUint8()], samples: [] }, D = (y.descriptorBlockSize / 4 - 6) / 4;
  for (let t2 = 0; t2 < D; t2++)
    y.samples[t2] = { bitOffset: u3._nextUint16(), bitLength: u3._nextUint8(), channelID: u3._nextUint8(), samplePosition: [u3._nextUint8(), u3._nextUint8(), u3._nextUint8(), u3._nextUint8()], sampleLower: u3._nextUint32(), sampleUpper: u3._nextUint32() };
  i2.dataFormatDescriptor.length = 0, i2.dataFormatDescriptor.push(y);
  const b = new c(t, f2, h, true);
  for (; b._offset < h; ) {
    const t2 = b._nextUint32(), e2 = b._scan(t2), n3 = _(e2), s3 = b._scan(t2 - e2.byteLength);
    i2.keyValue[n3] = n3.match(/^ktx/i) ? _(s3) : s3, b._offset % 4 && b._skip(4 - b._offset % 4);
  }
  if (p2 <= 0)
    return i2;
  const d = new c(t, g, p2, true), B = d._nextUint16(), w = d._nextUint16(), A = d._nextUint32(), S = d._nextUint32(), m = d._nextUint32(), L = d._nextUint32(), I = [];
  for (let t2 = 0; t2 < r2; t2++)
    I.push({ imageFlags: d._nextUint32(), rgbSliceByteOffset: d._nextUint32(), rgbSliceByteLength: d._nextUint32(), alphaSliceByteOffset: d._nextUint32(), alphaSliceByteLength: d._nextUint32() });
  const R = g + d._offset, E = R + A, T = E + S, O = T + m, P = new Uint8Array(t.buffer, t.byteOffset + R, A), C = new Uint8Array(t.buffer, t.byteOffset + E, S), F = new Uint8Array(t.buffer, t.byteOffset + T, m), G = new Uint8Array(t.buffer, t.byteOffset + O, L);
  return i2.globalData = { endpointCount: B, selectorCount: w, imageDescs: I, endpointsData: P, selectorsData: C, tablesData: F, extendedData: G }, i2;
}

// node_modules/cesium/Source/ThirdParty/lerc.js
var LercDecode = createCommonjsModule(function(module2) {
  (function() {
    var LercDecode2 = function() {
      var CntZImage = {};
      CntZImage.defaultNoDataValue = -34027999387901484e22;
      CntZImage.decode = function(input, options) {
        options = options || {};
        var skipMask = options.encodedMaskData || options.encodedMaskData === null;
        var parsedData = parse2(input, options.inputOffset || 0, skipMask);
        var noDataValue = options.noDataValue !== null ? options.noDataValue : CntZImage.defaultNoDataValue;
        var uncompressedData = uncompressPixelValues(
          parsedData,
          options.pixelType || Float32Array,
          options.encodedMaskData,
          noDataValue,
          options.returnMask
        );
        var result = {
          width: parsedData.width,
          height: parsedData.height,
          pixelData: uncompressedData.resultPixels,
          minValue: uncompressedData.minValue,
          maxValue: parsedData.pixels.maxValue,
          noDataValue
        };
        if (uncompressedData.resultMask) {
          result.maskData = uncompressedData.resultMask;
        }
        if (options.returnEncodedMask && parsedData.mask) {
          result.encodedMaskData = parsedData.mask.bitset ? parsedData.mask.bitset : null;
        }
        if (options.returnFileInfo) {
          result.fileInfo = formatFileInfo(parsedData);
          if (options.computeUsedBitDepths) {
            result.fileInfo.bitDepths = computeUsedBitDepths(parsedData);
          }
        }
        return result;
      };
      var uncompressPixelValues = function(data, TypedArrayClass, maskBitset, noDataValue, storeDecodedMask) {
        var blockIdx = 0;
        var numX = data.pixels.numBlocksX;
        var numY = data.pixels.numBlocksY;
        var blockWidth = Math.floor(data.width / numX);
        var blockHeight = Math.floor(data.height / numY);
        var scale = 2 * data.maxZError;
        var minValue = Number.MAX_VALUE, currentValue;
        maskBitset = maskBitset || (data.mask ? data.mask.bitset : null);
        var resultPixels, resultMask;
        resultPixels = new TypedArrayClass(data.width * data.height);
        if (storeDecodedMask && maskBitset) {
          resultMask = new Uint8Array(data.width * data.height);
        }
        var blockDataBuffer = new Float32Array(blockWidth * blockHeight);
        var xx, yy;
        for (var y = 0; y <= numY; y++) {
          var thisBlockHeight = y !== numY ? blockHeight : data.height % numY;
          if (thisBlockHeight === 0) {
            continue;
          }
          for (var x = 0; x <= numX; x++) {
            var thisBlockWidth = x !== numX ? blockWidth : data.width % numX;
            if (thisBlockWidth === 0) {
              continue;
            }
            var outPtr = y * data.width * blockHeight + x * blockWidth;
            var outStride = data.width - thisBlockWidth;
            var block = data.pixels.blocks[blockIdx];
            var blockData, blockPtr, constValue;
            if (block.encoding < 2) {
              if (block.encoding === 0) {
                blockData = block.rawData;
              } else {
                unstuff(block.stuffedData, block.bitsPerPixel, block.numValidPixels, block.offset, scale, blockDataBuffer, data.pixels.maxValue);
                blockData = blockDataBuffer;
              }
              blockPtr = 0;
            } else if (block.encoding === 2) {
              constValue = 0;
            } else {
              constValue = block.offset;
            }
            var maskByte;
            if (maskBitset) {
              for (yy = 0; yy < thisBlockHeight; yy++) {
                if (outPtr & 7) {
                  maskByte = maskBitset[outPtr >> 3];
                  maskByte <<= outPtr & 7;
                }
                for (xx = 0; xx < thisBlockWidth; xx++) {
                  if (!(outPtr & 7)) {
                    maskByte = maskBitset[outPtr >> 3];
                  }
                  if (maskByte & 128) {
                    if (resultMask) {
                      resultMask[outPtr] = 1;
                    }
                    currentValue = block.encoding < 2 ? blockData[blockPtr++] : constValue;
                    minValue = minValue > currentValue ? currentValue : minValue;
                    resultPixels[outPtr++] = currentValue;
                  } else {
                    if (resultMask) {
                      resultMask[outPtr] = 0;
                    }
                    resultPixels[outPtr++] = noDataValue;
                  }
                  maskByte <<= 1;
                }
                outPtr += outStride;
              }
            } else {
              if (block.encoding < 2) {
                for (yy = 0; yy < thisBlockHeight; yy++) {
                  for (xx = 0; xx < thisBlockWidth; xx++) {
                    currentValue = blockData[blockPtr++];
                    minValue = minValue > currentValue ? currentValue : minValue;
                    resultPixels[outPtr++] = currentValue;
                  }
                  outPtr += outStride;
                }
              } else {
                minValue = minValue > constValue ? constValue : minValue;
                for (yy = 0; yy < thisBlockHeight; yy++) {
                  for (xx = 0; xx < thisBlockWidth; xx++) {
                    resultPixels[outPtr++] = constValue;
                  }
                  outPtr += outStride;
                }
              }
            }
            if (block.encoding === 1 && blockPtr !== block.numValidPixels) {
              throw "Block and Mask do not match";
            }
            blockIdx++;
          }
        }
        return {
          resultPixels,
          resultMask,
          minValue
        };
      };
      var formatFileInfo = function(data) {
        return {
          "fileIdentifierString": data.fileIdentifierString,
          "fileVersion": data.fileVersion,
          "imageType": data.imageType,
          "height": data.height,
          "width": data.width,
          "maxZError": data.maxZError,
          "eofOffset": data.eofOffset,
          "mask": data.mask ? {
            "numBlocksX": data.mask.numBlocksX,
            "numBlocksY": data.mask.numBlocksY,
            "numBytes": data.mask.numBytes,
            "maxValue": data.mask.maxValue
          } : null,
          "pixels": {
            "numBlocksX": data.pixels.numBlocksX,
            "numBlocksY": data.pixels.numBlocksY,
            "numBytes": data.pixels.numBytes,
            "maxValue": data.pixels.maxValue,
            "noDataValue": data.noDataValue
          }
        };
      };
      var computeUsedBitDepths = function(data) {
        var numBlocks = data.pixels.numBlocksX * data.pixels.numBlocksY;
        var bitDepths = {};
        for (var i2 = 0; i2 < numBlocks; i2++) {
          var block = data.pixels.blocks[i2];
          if (block.encoding === 0) {
            bitDepths.float32 = true;
          } else if (block.encoding === 1) {
            bitDepths[block.bitsPerPixel] = true;
          } else {
            bitDepths[0] = true;
          }
        }
        return Object.keys(bitDepths);
      };
      var parse2 = function(input, fp, skipMask) {
        var data = {};
        var fileIdView = new Uint8Array(input, fp, 10);
        data.fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
        if (data.fileIdentifierString.trim() !== "CntZImage") {
          throw "Unexpected file identifier string: " + data.fileIdentifierString;
        }
        fp += 10;
        var view = new DataView(input, fp, 24);
        data.fileVersion = view.getInt32(0, true);
        data.imageType = view.getInt32(4, true);
        data.height = view.getUint32(8, true);
        data.width = view.getUint32(12, true);
        data.maxZError = view.getFloat64(16, true);
        fp += 24;
        if (!skipMask) {
          view = new DataView(input, fp, 16);
          data.mask = {};
          data.mask.numBlocksY = view.getUint32(0, true);
          data.mask.numBlocksX = view.getUint32(4, true);
          data.mask.numBytes = view.getUint32(8, true);
          data.mask.maxValue = view.getFloat32(12, true);
          fp += 16;
          if (data.mask.numBytes > 0) {
            var bitset = new Uint8Array(Math.ceil(data.width * data.height / 8));
            view = new DataView(input, fp, data.mask.numBytes);
            var cnt = view.getInt16(0, true);
            var ip = 2, op = 0;
            do {
              if (cnt > 0) {
                while (cnt--) {
                  bitset[op++] = view.getUint8(ip++);
                }
              } else {
                var val = view.getUint8(ip++);
                cnt = -cnt;
                while (cnt--) {
                  bitset[op++] = val;
                }
              }
              cnt = view.getInt16(ip, true);
              ip += 2;
            } while (ip < data.mask.numBytes);
            if (cnt !== -32768 || op < bitset.length) {
              throw "Unexpected end of mask RLE encoding";
            }
            data.mask.bitset = bitset;
            fp += data.mask.numBytes;
          } else if ((data.mask.numBytes | data.mask.numBlocksY | data.mask.maxValue) === 0) {
            data.mask.bitset = new Uint8Array(Math.ceil(data.width * data.height / 8));
          }
        }
        view = new DataView(input, fp, 16);
        data.pixels = {};
        data.pixels.numBlocksY = view.getUint32(0, true);
        data.pixels.numBlocksX = view.getUint32(4, true);
        data.pixels.numBytes = view.getUint32(8, true);
        data.pixels.maxValue = view.getFloat32(12, true);
        fp += 16;
        var numBlocksX = data.pixels.numBlocksX;
        var numBlocksY = data.pixels.numBlocksY;
        var actualNumBlocksX = numBlocksX + (data.width % numBlocksX > 0 ? 1 : 0);
        var actualNumBlocksY = numBlocksY + (data.height % numBlocksY > 0 ? 1 : 0);
        data.pixels.blocks = new Array(actualNumBlocksX * actualNumBlocksY);
        var blockI = 0;
        for (var blockY = 0; blockY < actualNumBlocksY; blockY++) {
          for (var blockX = 0; blockX < actualNumBlocksX; blockX++) {
            var size = 0;
            var bytesLeft = input.byteLength - fp;
            view = new DataView(input, fp, Math.min(10, bytesLeft));
            var block = {};
            data.pixels.blocks[blockI++] = block;
            var headerByte = view.getUint8(0);
            size++;
            block.encoding = headerByte & 63;
            if (block.encoding > 3) {
              throw "Invalid block encoding (" + block.encoding + ")";
            }
            if (block.encoding === 2) {
              fp++;
              continue;
            }
            if (headerByte !== 0 && headerByte !== 2) {
              headerByte >>= 6;
              block.offsetType = headerByte;
              if (headerByte === 2) {
                block.offset = view.getInt8(1);
                size++;
              } else if (headerByte === 1) {
                block.offset = view.getInt16(1, true);
                size += 2;
              } else if (headerByte === 0) {
                block.offset = view.getFloat32(1, true);
                size += 4;
              } else {
                throw "Invalid block offset type";
              }
              if (block.encoding === 1) {
                headerByte = view.getUint8(size);
                size++;
                block.bitsPerPixel = headerByte & 63;
                headerByte >>= 6;
                block.numValidPixelsType = headerByte;
                if (headerByte === 2) {
                  block.numValidPixels = view.getUint8(size);
                  size++;
                } else if (headerByte === 1) {
                  block.numValidPixels = view.getUint16(size, true);
                  size += 2;
                } else if (headerByte === 0) {
                  block.numValidPixels = view.getUint32(size, true);
                  size += 4;
                } else {
                  throw "Invalid valid pixel count type";
                }
              }
            }
            fp += size;
            if (block.encoding === 3) {
              continue;
            }
            var arrayBuf, store8;
            if (block.encoding === 0) {
              var numPixels = (data.pixels.numBytes - 1) / 4;
              if (numPixels !== Math.floor(numPixels)) {
                throw "uncompressed block has invalid length";
              }
              arrayBuf = new ArrayBuffer(numPixels * 4);
              store8 = new Uint8Array(arrayBuf);
              store8.set(new Uint8Array(input, fp, numPixels * 4));
              var rawData = new Float32Array(arrayBuf);
              block.rawData = rawData;
              fp += numPixels * 4;
            } else if (block.encoding === 1) {
              var dataBytes = Math.ceil(block.numValidPixels * block.bitsPerPixel / 8);
              var dataWords = Math.ceil(dataBytes / 4);
              arrayBuf = new ArrayBuffer(dataWords * 4);
              store8 = new Uint8Array(arrayBuf);
              store8.set(new Uint8Array(input, fp, dataBytes));
              block.stuffedData = new Uint32Array(arrayBuf);
              fp += dataBytes;
            }
          }
        }
        data.eofOffset = fp;
        return data;
      };
      var unstuff = function(src2, bitsPerPixel, numPixels, offset2, scale, dest, maxValue) {
        var bitMask = (1 << bitsPerPixel) - 1;
        var i2 = 0, o2;
        var bitsLeft = 0;
        var n2, buffer;
        var nmax = Math.ceil((maxValue - offset2) / scale);
        var numInvalidTailBytes = src2.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
        src2[src2.length - 1] <<= 8 * numInvalidTailBytes;
        for (o2 = 0; o2 < numPixels; o2++) {
          if (bitsLeft === 0) {
            buffer = src2[i2++];
            bitsLeft = 32;
          }
          if (bitsLeft >= bitsPerPixel) {
            n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask;
            bitsLeft -= bitsPerPixel;
          } else {
            var missingBits = bitsPerPixel - bitsLeft;
            n2 = (buffer & bitMask) << missingBits & bitMask;
            buffer = src2[i2++];
            bitsLeft = 32 - missingBits;
            n2 += buffer >>> bitsLeft;
          }
          dest[o2] = n2 < nmax ? offset2 + n2 * scale : maxValue;
        }
        return dest;
      };
      return CntZImage;
    }();
    var Lerc2Decode = function() {
      var BitStuffer = {
        unstuff: function(src2, dest, bitsPerPixel, numPixels, lutArr, offset2, scale, maxValue) {
          var bitMask = (1 << bitsPerPixel) - 1;
          var i2 = 0, o2;
          var bitsLeft = 0;
          var n2, buffer, missingBits, nmax;
          var numInvalidTailBytes = src2.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
          src2[src2.length - 1] <<= 8 * numInvalidTailBytes;
          if (lutArr) {
            for (o2 = 0; o2 < numPixels; o2++) {
              if (bitsLeft === 0) {
                buffer = src2[i2++];
                bitsLeft = 32;
              }
              if (bitsLeft >= bitsPerPixel) {
                n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask;
                bitsLeft -= bitsPerPixel;
              } else {
                missingBits = bitsPerPixel - bitsLeft;
                n2 = (buffer & bitMask) << missingBits & bitMask;
                buffer = src2[i2++];
                bitsLeft = 32 - missingBits;
                n2 += buffer >>> bitsLeft;
              }
              dest[o2] = lutArr[n2];
            }
          } else {
            nmax = Math.ceil((maxValue - offset2) / scale);
            for (o2 = 0; o2 < numPixels; o2++) {
              if (bitsLeft === 0) {
                buffer = src2[i2++];
                bitsLeft = 32;
              }
              if (bitsLeft >= bitsPerPixel) {
                n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask;
                bitsLeft -= bitsPerPixel;
              } else {
                missingBits = bitsPerPixel - bitsLeft;
                n2 = (buffer & bitMask) << missingBits & bitMask;
                buffer = src2[i2++];
                bitsLeft = 32 - missingBits;
                n2 += buffer >>> bitsLeft;
              }
              dest[o2] = n2 < nmax ? offset2 + n2 * scale : maxValue;
            }
          }
        },
        unstuffLUT: function(src2, bitsPerPixel, numPixels, offset2, scale, maxValue) {
          var bitMask = (1 << bitsPerPixel) - 1;
          var i2 = 0, o2 = 0, missingBits = 0, bitsLeft = 0, n2 = 0;
          var buffer;
          var dest = [];
          var numInvalidTailBytes = src2.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
          src2[src2.length - 1] <<= 8 * numInvalidTailBytes;
          var nmax = Math.ceil((maxValue - offset2) / scale);
          for (o2 = 0; o2 < numPixels; o2++) {
            if (bitsLeft === 0) {
              buffer = src2[i2++];
              bitsLeft = 32;
            }
            if (bitsLeft >= bitsPerPixel) {
              n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask;
              bitsLeft -= bitsPerPixel;
            } else {
              missingBits = bitsPerPixel - bitsLeft;
              n2 = (buffer & bitMask) << missingBits & bitMask;
              buffer = src2[i2++];
              bitsLeft = 32 - missingBits;
              n2 += buffer >>> bitsLeft;
            }
            dest[o2] = n2 < nmax ? offset2 + n2 * scale : maxValue;
          }
          dest.unshift(offset2);
          return dest;
        },
        unstuff2: function(src2, dest, bitsPerPixel, numPixels, lutArr, offset2, scale, maxValue) {
          var bitMask = (1 << bitsPerPixel) - 1;
          var i2 = 0, o2;
          var bitsLeft = 0, bitPos = 0;
          var n2, buffer, missingBits;
          if (lutArr) {
            for (o2 = 0; o2 < numPixels; o2++) {
              if (bitsLeft === 0) {
                buffer = src2[i2++];
                bitsLeft = 32;
                bitPos = 0;
              }
              if (bitsLeft >= bitsPerPixel) {
                n2 = buffer >>> bitPos & bitMask;
                bitsLeft -= bitsPerPixel;
                bitPos += bitsPerPixel;
              } else {
                missingBits = bitsPerPixel - bitsLeft;
                n2 = buffer >>> bitPos & bitMask;
                buffer = src2[i2++];
                bitsLeft = 32 - missingBits;
                n2 |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
                bitPos = missingBits;
              }
              dest[o2] = lutArr[n2];
            }
          } else {
            var nmax = Math.ceil((maxValue - offset2) / scale);
            for (o2 = 0; o2 < numPixels; o2++) {
              if (bitsLeft === 0) {
                buffer = src2[i2++];
                bitsLeft = 32;
                bitPos = 0;
              }
              if (bitsLeft >= bitsPerPixel) {
                n2 = buffer >>> bitPos & bitMask;
                bitsLeft -= bitsPerPixel;
                bitPos += bitsPerPixel;
              } else {
                missingBits = bitsPerPixel - bitsLeft;
                n2 = buffer >>> bitPos & bitMask;
                buffer = src2[i2++];
                bitsLeft = 32 - missingBits;
                n2 |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
                bitPos = missingBits;
              }
              dest[o2] = n2 < nmax ? offset2 + n2 * scale : maxValue;
            }
          }
          return dest;
        },
        unstuffLUT2: function(src2, bitsPerPixel, numPixels, offset2, scale, maxValue) {
          var bitMask = (1 << bitsPerPixel) - 1;
          var i2 = 0, o2 = 0, missingBits = 0, bitsLeft = 0, n2 = 0, bitPos = 0;
          var buffer;
          var dest = [];
          var nmax = Math.ceil((maxValue - offset2) / scale);
          for (o2 = 0; o2 < numPixels; o2++) {
            if (bitsLeft === 0) {
              buffer = src2[i2++];
              bitsLeft = 32;
              bitPos = 0;
            }
            if (bitsLeft >= bitsPerPixel) {
              n2 = buffer >>> bitPos & bitMask;
              bitsLeft -= bitsPerPixel;
              bitPos += bitsPerPixel;
            } else {
              missingBits = bitsPerPixel - bitsLeft;
              n2 = buffer >>> bitPos & bitMask;
              buffer = src2[i2++];
              bitsLeft = 32 - missingBits;
              n2 |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
              bitPos = missingBits;
            }
            dest[o2] = n2 < nmax ? offset2 + n2 * scale : maxValue;
          }
          dest.unshift(offset2);
          return dest;
        },
        originalUnstuff: function(src2, dest, bitsPerPixel, numPixels) {
          var bitMask = (1 << bitsPerPixel) - 1;
          var i2 = 0, o2;
          var bitsLeft = 0;
          var n2, buffer, missingBits;
          var numInvalidTailBytes = src2.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
          src2[src2.length - 1] <<= 8 * numInvalidTailBytes;
          for (o2 = 0; o2 < numPixels; o2++) {
            if (bitsLeft === 0) {
              buffer = src2[i2++];
              bitsLeft = 32;
            }
            if (bitsLeft >= bitsPerPixel) {
              n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask;
              bitsLeft -= bitsPerPixel;
            } else {
              missingBits = bitsPerPixel - bitsLeft;
              n2 = (buffer & bitMask) << missingBits & bitMask;
              buffer = src2[i2++];
              bitsLeft = 32 - missingBits;
              n2 += buffer >>> bitsLeft;
            }
            dest[o2] = n2;
          }
          return dest;
        },
        originalUnstuff2: function(src2, dest, bitsPerPixel, numPixels) {
          var bitMask = (1 << bitsPerPixel) - 1;
          var i2 = 0, o2;
          var bitsLeft = 0, bitPos = 0;
          var n2, buffer, missingBits;
          for (o2 = 0; o2 < numPixels; o2++) {
            if (bitsLeft === 0) {
              buffer = src2[i2++];
              bitsLeft = 32;
              bitPos = 0;
            }
            if (bitsLeft >= bitsPerPixel) {
              n2 = buffer >>> bitPos & bitMask;
              bitsLeft -= bitsPerPixel;
              bitPos += bitsPerPixel;
            } else {
              missingBits = bitsPerPixel - bitsLeft;
              n2 = buffer >>> bitPos & bitMask;
              buffer = src2[i2++];
              bitsLeft = 32 - missingBits;
              n2 |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
              bitPos = missingBits;
            }
            dest[o2] = n2;
          }
          return dest;
        }
      };
      var Lerc2Helpers = {
        HUFFMAN_LUT_BITS_MAX: 12,
        computeChecksumFletcher32: function(input) {
          var sum1 = 65535, sum2 = 65535;
          var len = input.length;
          var words = Math.floor(len / 2);
          var i2 = 0;
          while (words) {
            var tlen = words >= 359 ? 359 : words;
            words -= tlen;
            do {
              sum1 += input[i2++] << 8;
              sum2 += sum1 += input[i2++];
            } while (--tlen);
            sum1 = (sum1 & 65535) + (sum1 >>> 16);
            sum2 = (sum2 & 65535) + (sum2 >>> 16);
          }
          if (len & 1) {
            sum2 += sum1 += input[i2] << 8;
          }
          sum1 = (sum1 & 65535) + (sum1 >>> 16);
          sum2 = (sum2 & 65535) + (sum2 >>> 16);
          return (sum2 << 16 | sum1) >>> 0;
        },
        readHeaderInfo: function(input, data) {
          var ptr = data.ptr;
          var fileIdView = new Uint8Array(input, ptr, 6);
          var headerInfo = {};
          headerInfo.fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
          if (headerInfo.fileIdentifierString.lastIndexOf("Lerc2", 0) !== 0) {
            throw "Unexpected file identifier string (expect Lerc2 ): " + headerInfo.fileIdentifierString;
          }
          ptr += 6;
          var view = new DataView(input, ptr, 8);
          var fileVersion = view.getInt32(0, true);
          headerInfo.fileVersion = fileVersion;
          ptr += 4;
          if (fileVersion >= 3) {
            headerInfo.checksum = view.getUint32(4, true);
            ptr += 4;
          }
          view = new DataView(input, ptr, 12);
          headerInfo.height = view.getUint32(0, true);
          headerInfo.width = view.getUint32(4, true);
          ptr += 8;
          if (fileVersion >= 4) {
            headerInfo.numDims = view.getUint32(8, true);
            ptr += 4;
          } else {
            headerInfo.numDims = 1;
          }
          view = new DataView(input, ptr, 40);
          headerInfo.numValidPixel = view.getUint32(0, true);
          headerInfo.microBlockSize = view.getInt32(4, true);
          headerInfo.blobSize = view.getInt32(8, true);
          headerInfo.imageType = view.getInt32(12, true);
          headerInfo.maxZError = view.getFloat64(16, true);
          headerInfo.zMin = view.getFloat64(24, true);
          headerInfo.zMax = view.getFloat64(32, true);
          ptr += 40;
          data.headerInfo = headerInfo;
          data.ptr = ptr;
          var checksum, keyLength;
          if (fileVersion >= 3) {
            keyLength = fileVersion >= 4 ? 52 : 48;
            checksum = this.computeChecksumFletcher32(new Uint8Array(input, ptr - keyLength, headerInfo.blobSize - 14));
            if (checksum !== headerInfo.checksum) {
              throw "Checksum failed.";
            }
          }
          return true;
        },
        checkMinMaxRanges: function(input, data) {
          var headerInfo = data.headerInfo;
          var OutPixelTypeArray = this.getDataTypeArray(headerInfo.imageType);
          var rangeBytes = headerInfo.numDims * this.getDataTypeSize(headerInfo.imageType);
          var minValues = this.readSubArray(input, data.ptr, OutPixelTypeArray, rangeBytes);
          var maxValues = this.readSubArray(input, data.ptr + rangeBytes, OutPixelTypeArray, rangeBytes);
          data.ptr += 2 * rangeBytes;
          var i2, equal = true;
          for (i2 = 0; i2 < headerInfo.numDims; i2++) {
            if (minValues[i2] !== maxValues[i2]) {
              equal = false;
              break;
            }
          }
          headerInfo.minValues = minValues;
          headerInfo.maxValues = maxValues;
          return equal;
        },
        readSubArray: function(input, ptr, OutPixelTypeArray, numBytes) {
          var rawData;
          if (OutPixelTypeArray === Uint8Array) {
            rawData = new Uint8Array(input, ptr, numBytes);
          } else {
            var arrayBuf = new ArrayBuffer(numBytes);
            var store8 = new Uint8Array(arrayBuf);
            store8.set(new Uint8Array(input, ptr, numBytes));
            rawData = new OutPixelTypeArray(arrayBuf);
          }
          return rawData;
        },
        readMask: function(input, data) {
          var ptr = data.ptr;
          var headerInfo = data.headerInfo;
          var numPixels = headerInfo.width * headerInfo.height;
          var numValidPixel = headerInfo.numValidPixel;
          var view = new DataView(input, ptr, 4);
          var mask = {};
          mask.numBytes = view.getUint32(0, true);
          ptr += 4;
          if ((0 === numValidPixel || numPixels === numValidPixel) && 0 !== mask.numBytes) {
            throw "invalid mask";
          }
          var bitset, resultMask;
          if (numValidPixel === 0) {
            bitset = new Uint8Array(Math.ceil(numPixels / 8));
            mask.bitset = bitset;
            resultMask = new Uint8Array(numPixels);
            data.pixels.resultMask = resultMask;
            ptr += mask.numBytes;
          } else if (mask.numBytes > 0) {
            bitset = new Uint8Array(Math.ceil(numPixels / 8));
            view = new DataView(input, ptr, mask.numBytes);
            var cnt = view.getInt16(0, true);
            var ip = 2, op = 0, val = 0;
            do {
              if (cnt > 0) {
                while (cnt--) {
                  bitset[op++] = view.getUint8(ip++);
                }
              } else {
                val = view.getUint8(ip++);
                cnt = -cnt;
                while (cnt--) {
                  bitset[op++] = val;
                }
              }
              cnt = view.getInt16(ip, true);
              ip += 2;
            } while (ip < mask.numBytes);
            if (cnt !== -32768 || op < bitset.length) {
              throw "Unexpected end of mask RLE encoding";
            }
            resultMask = new Uint8Array(numPixels);
            var mb = 0, k = 0;
            for (k = 0; k < numPixels; k++) {
              if (k & 7) {
                mb = bitset[k >> 3];
                mb <<= k & 7;
              } else {
                mb = bitset[k >> 3];
              }
              if (mb & 128) {
                resultMask[k] = 1;
              }
            }
            data.pixels.resultMask = resultMask;
            mask.bitset = bitset;
            ptr += mask.numBytes;
          }
          data.ptr = ptr;
          data.mask = mask;
          return true;
        },
        readDataOneSweep: function(input, data, OutPixelTypeArray) {
          var ptr = data.ptr;
          var headerInfo = data.headerInfo;
          var numDims = headerInfo.numDims;
          var numPixels = headerInfo.width * headerInfo.height;
          var imageType = headerInfo.imageType;
          var numBytes = headerInfo.numValidPixel * Lerc2Helpers.getDataTypeSize(imageType) * numDims;
          var rawData;
          var mask = data.pixels.resultMask;
          if (OutPixelTypeArray === Uint8Array) {
            rawData = new Uint8Array(input, ptr, numBytes);
          } else {
            var arrayBuf = new ArrayBuffer(numBytes);
            var store8 = new Uint8Array(arrayBuf);
            store8.set(new Uint8Array(input, ptr, numBytes));
            rawData = new OutPixelTypeArray(arrayBuf);
          }
          if (rawData.length === numPixels * numDims) {
            data.pixels.resultPixels = rawData;
          } else {
            data.pixels.resultPixels = new OutPixelTypeArray(numPixels * numDims);
            var z = 0, k = 0, i2 = 0, nStart = 0;
            if (numDims > 1) {
              for (i2 = 0; i2 < numDims; i2++) {
                nStart = i2 * numPixels;
                for (k = 0; k < numPixels; k++) {
                  if (mask[k]) {
                    data.pixels.resultPixels[nStart + k] = rawData[z++];
                  }
                }
              }
            } else {
              for (k = 0; k < numPixels; k++) {
                if (mask[k]) {
                  data.pixels.resultPixels[k] = rawData[z++];
                }
              }
            }
          }
          ptr += numBytes;
          data.ptr = ptr;
          return true;
        },
        readHuffmanTree: function(input, data) {
          var BITS_MAX = this.HUFFMAN_LUT_BITS_MAX;
          var view = new DataView(input, data.ptr, 16);
          data.ptr += 16;
          var version = view.getInt32(0, true);
          if (version < 2) {
            throw "unsupported Huffman version";
          }
          var size = view.getInt32(4, true);
          var i0 = view.getInt32(8, true);
          var i1 = view.getInt32(12, true);
          if (i0 >= i1) {
            return false;
          }
          var blockDataBuffer = new Uint32Array(i1 - i0);
          Lerc2Helpers.decodeBits(input, data, blockDataBuffer);
          var codeTable = [];
          var i2, j, k, len;
          for (i2 = i0; i2 < i1; i2++) {
            j = i2 - (i2 < size ? 0 : size);
            codeTable[j] = { first: blockDataBuffer[i2 - i0], second: null };
          }
          var dataBytes = input.byteLength - data.ptr;
          var dataWords = Math.ceil(dataBytes / 4);
          var arrayBuf = new ArrayBuffer(dataWords * 4);
          var store8 = new Uint8Array(arrayBuf);
          store8.set(new Uint8Array(input, data.ptr, dataBytes));
          var stuffedData = new Uint32Array(arrayBuf);
          var bitPos = 0, word, srcPtr = 0;
          word = stuffedData[0];
          for (i2 = i0; i2 < i1; i2++) {
            j = i2 - (i2 < size ? 0 : size);
            len = codeTable[j].first;
            if (len > 0) {
              codeTable[j].second = word << bitPos >>> 32 - len;
              if (32 - bitPos >= len) {
                bitPos += len;
                if (bitPos === 32) {
                  bitPos = 0;
                  srcPtr++;
                  word = stuffedData[srcPtr];
                }
              } else {
                bitPos += len - 32;
                srcPtr++;
                word = stuffedData[srcPtr];
                codeTable[j].second |= word >>> 32 - bitPos;
              }
            }
          }
          var numBitsLUT = 0, numBitsLUTQick = 0;
          var tree = new TreeNode();
          for (i2 = 0; i2 < codeTable.length; i2++) {
            if (codeTable[i2] !== void 0) {
              numBitsLUT = Math.max(numBitsLUT, codeTable[i2].first);
            }
          }
          if (numBitsLUT >= BITS_MAX) {
            numBitsLUTQick = BITS_MAX;
          } else {
            numBitsLUTQick = numBitsLUT;
          }
          if (numBitsLUT >= 30) {
            console.log("WARning, large NUM LUT BITS IS " + numBitsLUT);
          }
          var decodeLut = [], entry, code, numEntries, jj, currentBit, node;
          for (i2 = i0; i2 < i1; i2++) {
            j = i2 - (i2 < size ? 0 : size);
            len = codeTable[j].first;
            if (len > 0) {
              entry = [len, j];
              if (len <= numBitsLUTQick) {
                code = codeTable[j].second << numBitsLUTQick - len;
                numEntries = 1 << numBitsLUTQick - len;
                for (k = 0; k < numEntries; k++) {
                  decodeLut[code | k] = entry;
                }
              } else {
                code = codeTable[j].second;
                node = tree;
                for (jj = len - 1; jj >= 0; jj--) {
                  currentBit = code >>> jj & 1;
                  if (currentBit) {
                    if (!node.right) {
                      node.right = new TreeNode();
                    }
                    node = node.right;
                  } else {
                    if (!node.left) {
                      node.left = new TreeNode();
                    }
                    node = node.left;
                  }
                  if (jj === 0 && !node.val) {
                    node.val = entry[1];
                  }
                }
              }
            }
          }
          return {
            decodeLut,
            numBitsLUTQick,
            numBitsLUT,
            tree,
            stuffedData,
            srcPtr,
            bitPos
          };
        },
        readHuffman: function(input, data, OutPixelTypeArray) {
          var headerInfo = data.headerInfo;
          var numDims = headerInfo.numDims;
          var height = data.headerInfo.height;
          var width = data.headerInfo.width;
          var numPixels = width * height;
          var huffmanInfo = this.readHuffmanTree(input, data);
          var decodeLut = huffmanInfo.decodeLut;
          var tree = huffmanInfo.tree;
          var stuffedData = huffmanInfo.stuffedData;
          var srcPtr = huffmanInfo.srcPtr;
          var bitPos = huffmanInfo.bitPos;
          var numBitsLUTQick = huffmanInfo.numBitsLUTQick;
          var numBitsLUT = huffmanInfo.numBitsLUT;
          var offset2 = data.headerInfo.imageType === 0 ? 128 : 0;
          var node, val, delta, mask = data.pixels.resultMask, valTmp, valTmpQuick, currentBit;
          var i2, j, k, ii;
          var prevVal = 0;
          if (bitPos > 0) {
            srcPtr++;
            bitPos = 0;
          }
          var word = stuffedData[srcPtr];
          var deltaEncode = data.encodeMode === 1;
          var resultPixelsAllDim = new OutPixelTypeArray(numPixels * numDims);
          var resultPixels = resultPixelsAllDim;
          var iDim;
          for (iDim = 0; iDim < headerInfo.numDims; iDim++) {
            if (numDims > 1) {
              resultPixels = new OutPixelTypeArray(resultPixelsAllDim.buffer, numPixels * iDim, numPixels);
              prevVal = 0;
            }
            if (data.headerInfo.numValidPixel === width * height) {
              for (k = 0, i2 = 0; i2 < height; i2++) {
                for (j = 0; j < width; j++, k++) {
                  val = 0;
                  valTmp = word << bitPos >>> 32 - numBitsLUTQick;
                  valTmpQuick = valTmp;
                  if (32 - bitPos < numBitsLUTQick) {
                    valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
                    valTmpQuick = valTmp;
                  }
                  if (decodeLut[valTmpQuick]) {
                    val = decodeLut[valTmpQuick][1];
                    bitPos += decodeLut[valTmpQuick][0];
                  } else {
                    valTmp = word << bitPos >>> 32 - numBitsLUT;
                    valTmpQuick = valTmp;
                    if (32 - bitPos < numBitsLUT) {
                      valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
                      valTmpQuick = valTmp;
                    }
                    node = tree;
                    for (ii = 0; ii < numBitsLUT; ii++) {
                      currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
                      node = currentBit ? node.right : node.left;
                      if (!(node.left || node.right)) {
                        val = node.val;
                        bitPos = bitPos + ii + 1;
                        break;
                      }
                    }
                  }
                  if (bitPos >= 32) {
                    bitPos -= 32;
                    srcPtr++;
                    word = stuffedData[srcPtr];
                  }
                  delta = val - offset2;
                  if (deltaEncode) {
                    if (j > 0) {
                      delta += prevVal;
                    } else if (i2 > 0) {
                      delta += resultPixels[k - width];
                    } else {
                      delta += prevVal;
                    }
                    delta &= 255;
                    resultPixels[k] = delta;
                    prevVal = delta;
                  } else {
                    resultPixels[k] = delta;
                  }
                }
              }
            } else {
              for (k = 0, i2 = 0; i2 < height; i2++) {
                for (j = 0; j < width; j++, k++) {
                  if (mask[k]) {
                    val = 0;
                    valTmp = word << bitPos >>> 32 - numBitsLUTQick;
                    valTmpQuick = valTmp;
                    if (32 - bitPos < numBitsLUTQick) {
                      valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
                      valTmpQuick = valTmp;
                    }
                    if (decodeLut[valTmpQuick]) {
                      val = decodeLut[valTmpQuick][1];
                      bitPos += decodeLut[valTmpQuick][0];
                    } else {
                      valTmp = word << bitPos >>> 32 - numBitsLUT;
                      valTmpQuick = valTmp;
                      if (32 - bitPos < numBitsLUT) {
                        valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
                        valTmpQuick = valTmp;
                      }
                      node = tree;
                      for (ii = 0; ii < numBitsLUT; ii++) {
                        currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
                        node = currentBit ? node.right : node.left;
                        if (!(node.left || node.right)) {
                          val = node.val;
                          bitPos = bitPos + ii + 1;
                          break;
                        }
                      }
                    }
                    if (bitPos >= 32) {
                      bitPos -= 32;
                      srcPtr++;
                      word = stuffedData[srcPtr];
                    }
                    delta = val - offset2;
                    if (deltaEncode) {
                      if (j > 0 && mask[k - 1]) {
                        delta += prevVal;
                      } else if (i2 > 0 && mask[k - width]) {
                        delta += resultPixels[k - width];
                      } else {
                        delta += prevVal;
                      }
                      delta &= 255;
                      resultPixels[k] = delta;
                      prevVal = delta;
                    } else {
                      resultPixels[k] = delta;
                    }
                  }
                }
              }
            }
            data.ptr = data.ptr + (srcPtr + 1) * 4 + (bitPos > 0 ? 4 : 0);
          }
          data.pixels.resultPixels = resultPixelsAllDim;
        },
        decodeBits: function(input, data, blockDataBuffer, offset2, iDim) {
          {
            var headerInfo = data.headerInfo;
            var fileVersion = headerInfo.fileVersion;
            var blockPtr = 0;
            var view = new DataView(input, data.ptr, 5);
            var headerByte = view.getUint8(0);
            blockPtr++;
            var bits67 = headerByte >> 6;
            var n2 = bits67 === 0 ? 4 : 3 - bits67;
            var doLut = (headerByte & 32) > 0 ? true : false;
            var numBits = headerByte & 31;
            var numElements = 0;
            if (n2 === 1) {
              numElements = view.getUint8(blockPtr);
              blockPtr++;
            } else if (n2 === 2) {
              numElements = view.getUint16(blockPtr, true);
              blockPtr += 2;
            } else if (n2 === 4) {
              numElements = view.getUint32(blockPtr, true);
              blockPtr += 4;
            } else {
              throw "Invalid valid pixel count type";
            }
            var scale = 2 * headerInfo.maxZError;
            var stuffedData, arrayBuf, store8, dataBytes, dataWords;
            var lutArr, lutData, lutBytes, bitsPerPixel;
            var zMax = headerInfo.numDims > 1 ? headerInfo.maxValues[iDim] : headerInfo.zMax;
            if (doLut) {
              data.counter.lut++;
              lutBytes = view.getUint8(blockPtr);
              blockPtr++;
              dataBytes = Math.ceil((lutBytes - 1) * numBits / 8);
              dataWords = Math.ceil(dataBytes / 4);
              arrayBuf = new ArrayBuffer(dataWords * 4);
              store8 = new Uint8Array(arrayBuf);
              data.ptr += blockPtr;
              store8.set(new Uint8Array(input, data.ptr, dataBytes));
              lutData = new Uint32Array(arrayBuf);
              data.ptr += dataBytes;
              bitsPerPixel = 0;
              while (lutBytes - 1 >>> bitsPerPixel) {
                bitsPerPixel++;
              }
              dataBytes = Math.ceil(numElements * bitsPerPixel / 8);
              dataWords = Math.ceil(dataBytes / 4);
              arrayBuf = new ArrayBuffer(dataWords * 4);
              store8 = new Uint8Array(arrayBuf);
              store8.set(new Uint8Array(input, data.ptr, dataBytes));
              stuffedData = new Uint32Array(arrayBuf);
              data.ptr += dataBytes;
              if (fileVersion >= 3) {
                lutArr = BitStuffer.unstuffLUT2(lutData, numBits, lutBytes - 1, offset2, scale, zMax);
              } else {
                lutArr = BitStuffer.unstuffLUT(lutData, numBits, lutBytes - 1, offset2, scale, zMax);
              }
              if (fileVersion >= 3) {
                BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr);
              } else {
                BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr);
              }
            } else {
              data.counter.bitstuffer++;
              bitsPerPixel = numBits;
              data.ptr += blockPtr;
              if (bitsPerPixel > 0) {
                dataBytes = Math.ceil(numElements * bitsPerPixel / 8);
                dataWords = Math.ceil(dataBytes / 4);
                arrayBuf = new ArrayBuffer(dataWords * 4);
                store8 = new Uint8Array(arrayBuf);
                store8.set(new Uint8Array(input, data.ptr, dataBytes));
                stuffedData = new Uint32Array(arrayBuf);
                data.ptr += dataBytes;
                if (fileVersion >= 3) {
                  if (offset2 == null) {
                    BitStuffer.originalUnstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements);
                  } else {
                    BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset2, scale, zMax);
                  }
                } else {
                  if (offset2 == null) {
                    BitStuffer.originalUnstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements);
                  } else {
                    BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset2, scale, zMax);
                  }
                }
              }
            }
          }
        },
        readTiles: function(input, data, OutPixelTypeArray) {
          var headerInfo = data.headerInfo;
          var width = headerInfo.width;
          var height = headerInfo.height;
          var microBlockSize = headerInfo.microBlockSize;
          var imageType = headerInfo.imageType;
          var dataTypeSize = Lerc2Helpers.getDataTypeSize(imageType);
          var numBlocksX = Math.ceil(width / microBlockSize);
          var numBlocksY = Math.ceil(height / microBlockSize);
          data.pixels.numBlocksY = numBlocksY;
          data.pixels.numBlocksX = numBlocksX;
          data.pixels.ptr = 0;
          var row = 0, col = 0, blockY = 0, blockX = 0, thisBlockHeight = 0, thisBlockWidth = 0, bytesLeft = 0, headerByte = 0, bits67 = 0, testCode = 0, outPtr = 0, outStride = 0, numBytes = 0, bytesleft = 0, z = 0, blockPtr = 0;
          var view, block, arrayBuf, store8, rawData;
          var blockEncoding;
          var blockDataBuffer = new OutPixelTypeArray(microBlockSize * microBlockSize);
          var lastBlockHeight = height % microBlockSize || microBlockSize;
          var lastBlockWidth = width % microBlockSize || microBlockSize;
          var offsetType, offset2;
          var numDims = headerInfo.numDims, iDim;
          var mask = data.pixels.resultMask;
          var resultPixels = data.pixels.resultPixels;
          for (blockY = 0; blockY < numBlocksY; blockY++) {
            thisBlockHeight = blockY !== numBlocksY - 1 ? microBlockSize : lastBlockHeight;
            for (blockX = 0; blockX < numBlocksX; blockX++) {
              thisBlockWidth = blockX !== numBlocksX - 1 ? microBlockSize : lastBlockWidth;
              outPtr = blockY * width * microBlockSize + blockX * microBlockSize;
              outStride = width - thisBlockWidth;
              for (iDim = 0; iDim < numDims; iDim++) {
                if (numDims > 1) {
                  resultPixels = new OutPixelTypeArray(data.pixels.resultPixels.buffer, width * height * iDim * dataTypeSize, width * height);
                }
                bytesLeft = input.byteLength - data.ptr;
                view = new DataView(input, data.ptr, Math.min(10, bytesLeft));
                block = {};
                blockPtr = 0;
                headerByte = view.getUint8(0);
                blockPtr++;
                bits67 = headerByte >> 6 & 255;
                testCode = headerByte >> 2 & 15;
                if (testCode !== (blockX * microBlockSize >> 3 & 15)) {
                  throw "integrity issue";
                }
                blockEncoding = headerByte & 3;
                if (blockEncoding > 3) {
                  data.ptr += blockPtr;
                  throw "Invalid block encoding (" + blockEncoding + ")";
                } else if (blockEncoding === 2) {
                  data.counter.constant++;
                  data.ptr += blockPtr;
                  continue;
                } else if (blockEncoding === 0) {
                  data.counter.uncompressed++;
                  data.ptr += blockPtr;
                  numBytes = thisBlockHeight * thisBlockWidth * dataTypeSize;
                  bytesleft = input.byteLength - data.ptr;
                  numBytes = numBytes < bytesleft ? numBytes : bytesleft;
                  arrayBuf = new ArrayBuffer(numBytes % dataTypeSize === 0 ? numBytes : numBytes + dataTypeSize - numBytes % dataTypeSize);
                  store8 = new Uint8Array(arrayBuf);
                  store8.set(new Uint8Array(input, data.ptr, numBytes));
                  rawData = new OutPixelTypeArray(arrayBuf);
                  z = 0;
                  if (mask) {
                    for (row = 0; row < thisBlockHeight; row++) {
                      for (col = 0; col < thisBlockWidth; col++) {
                        if (mask[outPtr]) {
                          resultPixels[outPtr] = rawData[z++];
                        }
                        outPtr++;
                      }
                      outPtr += outStride;
                    }
                  } else {
                    for (row = 0; row < thisBlockHeight; row++) {
                      for (col = 0; col < thisBlockWidth; col++) {
                        resultPixels[outPtr++] = rawData[z++];
                      }
                      outPtr += outStride;
                    }
                  }
                  data.ptr += z * dataTypeSize;
                } else {
                  offsetType = Lerc2Helpers.getDataTypeUsed(imageType, bits67);
                  offset2 = Lerc2Helpers.getOnePixel(block, blockPtr, offsetType, view);
                  blockPtr += Lerc2Helpers.getDataTypeSize(offsetType);
                  if (blockEncoding === 3) {
                    data.ptr += blockPtr;
                    data.counter.constantoffset++;
                    if (mask) {
                      for (row = 0; row < thisBlockHeight; row++) {
                        for (col = 0; col < thisBlockWidth; col++) {
                          if (mask[outPtr]) {
                            resultPixels[outPtr] = offset2;
                          }
                          outPtr++;
                        }
                        outPtr += outStride;
                      }
                    } else {
                      for (row = 0; row < thisBlockHeight; row++) {
                        for (col = 0; col < thisBlockWidth; col++) {
                          resultPixels[outPtr++] = offset2;
                        }
                        outPtr += outStride;
                      }
                    }
                  } else {
                    data.ptr += blockPtr;
                    Lerc2Helpers.decodeBits(input, data, blockDataBuffer, offset2, iDim);
                    blockPtr = 0;
                    if (mask) {
                      for (row = 0; row < thisBlockHeight; row++) {
                        for (col = 0; col < thisBlockWidth; col++) {
                          if (mask[outPtr]) {
                            resultPixels[outPtr] = blockDataBuffer[blockPtr++];
                          }
                          outPtr++;
                        }
                        outPtr += outStride;
                      }
                    } else {
                      for (row = 0; row < thisBlockHeight; row++) {
                        for (col = 0; col < thisBlockWidth; col++) {
                          resultPixels[outPtr++] = blockDataBuffer[blockPtr++];
                        }
                        outPtr += outStride;
                      }
                    }
                  }
                }
              }
            }
          }
        },
        formatFileInfo: function(data) {
          return {
            "fileIdentifierString": data.headerInfo.fileIdentifierString,
            "fileVersion": data.headerInfo.fileVersion,
            "imageType": data.headerInfo.imageType,
            "height": data.headerInfo.height,
            "width": data.headerInfo.width,
            "numValidPixel": data.headerInfo.numValidPixel,
            "microBlockSize": data.headerInfo.microBlockSize,
            "blobSize": data.headerInfo.blobSize,
            "maxZError": data.headerInfo.maxZError,
            "pixelType": Lerc2Helpers.getPixelType(data.headerInfo.imageType),
            "eofOffset": data.eofOffset,
            "mask": data.mask ? {
              "numBytes": data.mask.numBytes
            } : null,
            "pixels": {
              "numBlocksX": data.pixels.numBlocksX,
              "numBlocksY": data.pixels.numBlocksY,
              "maxValue": data.headerInfo.zMax,
              "minValue": data.headerInfo.zMin,
              "noDataValue": data.noDataValue
            }
          };
        },
        constructConstantSurface: function(data) {
          var val = data.headerInfo.zMax;
          var numDims = data.headerInfo.numDims;
          var numPixels = data.headerInfo.height * data.headerInfo.width;
          var numPixelAllDims = numPixels * numDims;
          var i2 = 0, k = 0, nStart = 0;
          var mask = data.pixels.resultMask;
          if (mask) {
            if (numDims > 1) {
              for (i2 = 0; i2 < numDims; i2++) {
                nStart = i2 * numPixels;
                for (k = 0; k < numPixels; k++) {
                  if (mask[k]) {
                    data.pixels.resultPixels[nStart + k] = val;
                  }
                }
              }
            } else {
              for (k = 0; k < numPixels; k++) {
                if (mask[k]) {
                  data.pixels.resultPixels[k] = val;
                }
              }
            }
          } else {
            if (data.pixels.resultPixels.fill) {
              data.pixels.resultPixels.fill(val);
            } else {
              for (k = 0; k < numPixelAllDims; k++) {
                data.pixels.resultPixels[k] = val;
              }
            }
          }
          return;
        },
        getDataTypeArray: function(t) {
          var tp;
          switch (t) {
            case 0:
              tp = Int8Array;
              break;
            case 1:
              tp = Uint8Array;
              break;
            case 2:
              tp = Int16Array;
              break;
            case 3:
              tp = Uint16Array;
              break;
            case 4:
              tp = Int32Array;
              break;
            case 5:
              tp = Uint32Array;
              break;
            case 6:
              tp = Float32Array;
              break;
            case 7:
              tp = Float64Array;
              break;
            default:
              tp = Float32Array;
          }
          return tp;
        },
        getPixelType: function(t) {
          var tp;
          switch (t) {
            case 0:
              tp = "S8";
              break;
            case 1:
              tp = "U8";
              break;
            case 2:
              tp = "S16";
              break;
            case 3:
              tp = "U16";
              break;
            case 4:
              tp = "S32";
              break;
            case 5:
              tp = "U32";
              break;
            case 6:
              tp = "F32";
              break;
            case 7:
              tp = "F64";
              break;
            default:
              tp = "F32";
          }
          return tp;
        },
        isValidPixelValue: function(t, val) {
          if (val == null) {
            return false;
          }
          var isValid;
          switch (t) {
            case 0:
              isValid = val >= -128 && val <= 127;
              break;
            case 1:
              isValid = val >= 0 && val <= 255;
              break;
            case 2:
              isValid = val >= -32768 && val <= 32767;
              break;
            case 3:
              isValid = val >= 0 && val <= 65536;
              break;
            case 4:
              isValid = val >= -2147483648 && val <= 2147483647;
              break;
            case 5:
              isValid = val >= 0 && val <= 4294967296;
              break;
            case 6:
              isValid = val >= -34027999387901484e22 && val <= 34027999387901484e22;
              break;
            case 7:
              isValid = val >= 5e-324 && val <= 17976931348623157e292;
              break;
            default:
              isValid = false;
          }
          return isValid;
        },
        getDataTypeSize: function(t) {
          var s2 = 0;
          switch (t) {
            case 0:
            case 1:
              s2 = 1;
              break;
            case 2:
            case 3:
              s2 = 2;
              break;
            case 4:
            case 5:
            case 6:
              s2 = 4;
              break;
            case 7:
              s2 = 8;
              break;
            default:
              s2 = t;
          }
          return s2;
        },
        getDataTypeUsed: function(dt, tc) {
          var t = dt;
          switch (dt) {
            case 2:
            case 4:
              t = dt - tc;
              break;
            case 3:
            case 5:
              t = dt - 2 * tc;
              break;
            case 6:
              if (0 === tc) {
                t = dt;
              } else if (1 === tc) {
                t = 2;
              } else {
                t = 1;
              }
              break;
            case 7:
              if (0 === tc) {
                t = dt;
              } else {
                t = dt - 2 * tc + 1;
              }
              break;
            default:
              t = dt;
              break;
          }
          return t;
        },
        getOnePixel: function(block, blockPtr, offsetType, view) {
          var temp = 0;
          switch (offsetType) {
            case 0:
              temp = view.getInt8(blockPtr);
              break;
            case 1:
              temp = view.getUint8(blockPtr);
              break;
            case 2:
              temp = view.getInt16(blockPtr, true);
              break;
            case 3:
              temp = view.getUint16(blockPtr, true);
              break;
            case 4:
              temp = view.getInt32(blockPtr, true);
              break;
            case 5:
              temp = view.getUInt32(blockPtr, true);
              break;
            case 6:
              temp = view.getFloat32(blockPtr, true);
              break;
            case 7:
              temp = view.getFloat64(blockPtr, true);
              break;
            default:
              throw "the decoder does not understand this pixel type";
          }
          return temp;
        }
      };
      var TreeNode = function(val, left, right) {
        this.val = val;
        this.left = left;
        this.right = right;
      };
      var Lerc2Decode2 = {
        decode: function(input, options) {
          options = options || {};
          var noDataValue = options.noDataValue;
          var i2 = 0, data = {};
          data.ptr = options.inputOffset || 0;
          data.pixels = {};
          if (!Lerc2Helpers.readHeaderInfo(input, data))
            ;
          var headerInfo = data.headerInfo;
          var fileVersion = headerInfo.fileVersion;
          var OutPixelTypeArray = Lerc2Helpers.getDataTypeArray(headerInfo.imageType);
          Lerc2Helpers.readMask(input, data);
          if (headerInfo.numValidPixel !== headerInfo.width * headerInfo.height && !data.pixels.resultMask) {
            data.pixels.resultMask = options.maskData;
          }
          var numPixels = headerInfo.width * headerInfo.height;
          data.pixels.resultPixels = new OutPixelTypeArray(numPixels * headerInfo.numDims);
          data.counter = {
            onesweep: 0,
            uncompressed: 0,
            lut: 0,
            bitstuffer: 0,
            constant: 0,
            constantoffset: 0
          };
          if (headerInfo.numValidPixel !== 0) {
            if (headerInfo.zMax === headerInfo.zMin) {
              Lerc2Helpers.constructConstantSurface(data);
            } else if (fileVersion >= 4 && Lerc2Helpers.checkMinMaxRanges(input, data)) {
              Lerc2Helpers.constructConstantSurface(data);
            } else {
              var view = new DataView(input, data.ptr, 2);
              var bReadDataOneSweep = view.getUint8(0);
              data.ptr++;
              if (bReadDataOneSweep) {
                Lerc2Helpers.readDataOneSweep(input, data, OutPixelTypeArray);
              } else {
                if (fileVersion > 1 && headerInfo.imageType <= 1 && Math.abs(headerInfo.maxZError - 0.5) < 1e-5) {
                  var flagHuffman = view.getUint8(1);
                  data.ptr++;
                  data.encodeMode = flagHuffman;
                  if (flagHuffman > 2 || fileVersion < 4 && flagHuffman > 1) {
                    throw "Invalid Huffman flag " + flagHuffman;
                  }
                  if (flagHuffman) {
                    Lerc2Helpers.readHuffman(input, data, OutPixelTypeArray);
                  } else {
                    Lerc2Helpers.readTiles(input, data, OutPixelTypeArray);
                  }
                } else {
                  Lerc2Helpers.readTiles(input, data, OutPixelTypeArray);
                }
              }
            }
          }
          data.eofOffset = data.ptr;
          var diff;
          if (options.inputOffset) {
            diff = data.headerInfo.blobSize + options.inputOffset - data.ptr;
            if (Math.abs(diff) >= 1) {
              data.eofOffset = options.inputOffset + data.headerInfo.blobSize;
            }
          } else {
            diff = data.headerInfo.blobSize - data.ptr;
            if (Math.abs(diff) >= 1) {
              data.eofOffset = data.headerInfo.blobSize;
            }
          }
          var result = {
            width: headerInfo.width,
            height: headerInfo.height,
            pixelData: data.pixels.resultPixels,
            minValue: headerInfo.zMin,
            maxValue: headerInfo.zMax,
            validPixelCount: headerInfo.numValidPixel,
            dimCount: headerInfo.numDims,
            dimStats: {
              minValues: headerInfo.minValues,
              maxValues: headerInfo.maxValues
            },
            maskData: data.pixels.resultMask
          };
          if (data.pixels.resultMask && Lerc2Helpers.isValidPixelValue(headerInfo.imageType, noDataValue)) {
            var mask = data.pixels.resultMask;
            for (i2 = 0; i2 < numPixels; i2++) {
              if (!mask[i2]) {
                result.pixelData[i2] = noDataValue;
              }
            }
            result.noDataValue = noDataValue;
          }
          data.noDataValue = noDataValue;
          if (options.returnFileInfo) {
            result.fileInfo = Lerc2Helpers.formatFileInfo(data);
          }
          return result;
        },
        getBandCount: function(input) {
          var count = 0;
          var i2 = 0;
          var temp = {};
          temp.ptr = 0;
          temp.pixels = {};
          while (i2 < input.byteLength - 58) {
            Lerc2Helpers.readHeaderInfo(input, temp);
            i2 += temp.headerInfo.blobSize;
            count++;
            temp.ptr = i2;
          }
          return count;
        }
      };
      return Lerc2Decode2;
    }();
    var isPlatformLittleEndian = function() {
      var a4 = new ArrayBuffer(4);
      var b = new Uint8Array(a4);
      var c14 = new Uint32Array(a4);
      c14[0] = 1;
      return b[0] === 1;
    }();
    var Lerc = {
      decode: function(encodedData, options) {
        if (!isPlatformLittleEndian) {
          throw "Big endian system is not supported.";
        }
        options = options || {};
        var inputOffset = options.inputOffset || 0;
        var fileIdView = new Uint8Array(encodedData, inputOffset, 10);
        var fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
        var lerc, majorVersion;
        if (fileIdentifierString.trim() === "CntZImage") {
          lerc = LercDecode2;
          majorVersion = 1;
        } else if (fileIdentifierString.substring(0, 5) === "Lerc2") {
          lerc = Lerc2Decode;
          majorVersion = 2;
        } else {
          throw "Unexpected file identifier string: " + fileIdentifierString;
        }
        var iPlane = 0, eof = encodedData.byteLength - 10, encodedMaskData, bandMasks = [], bandMask, maskData;
        var decodedPixelBlock = {
          width: 0,
          height: 0,
          pixels: [],
          pixelType: options.pixelType,
          mask: null,
          statistics: []
        };
        while (inputOffset < eof) {
          var result = lerc.decode(encodedData, {
            inputOffset,
            encodedMaskData,
            maskData,
            returnMask: iPlane === 0 ? true : false,
            returnEncodedMask: iPlane === 0 ? true : false,
            returnFileInfo: true,
            pixelType: options.pixelType || null,
            noDataValue: options.noDataValue || null
          });
          inputOffset = result.fileInfo.eofOffset;
          if (iPlane === 0) {
            encodedMaskData = result.encodedMaskData;
            maskData = result.maskData;
            decodedPixelBlock.width = result.width;
            decodedPixelBlock.height = result.height;
            decodedPixelBlock.dimCount = result.dimCount || 1;
            decodedPixelBlock.pixelType = result.pixelType || result.fileInfo.pixelType;
            decodedPixelBlock.mask = result.maskData;
          }
          if (majorVersion > 1 && result.fileInfo.mask && result.fileInfo.mask.numBytes > 0) {
            bandMasks.push(result.maskData);
          }
          iPlane++;
          decodedPixelBlock.pixels.push(result.pixelData);
          decodedPixelBlock.statistics.push({
            minValue: result.minValue,
            maxValue: result.maxValue,
            noDataValue: result.noDataValue,
            dimStats: result.dimStats
          });
        }
        var i2, j, numPixels;
        if (majorVersion > 1 && bandMasks.length > 1) {
          numPixels = decodedPixelBlock.width * decodedPixelBlock.height;
          decodedPixelBlock.bandMasks = bandMasks;
          maskData = new Uint8Array(numPixels);
          maskData.set(bandMasks[0]);
          for (i2 = 1; i2 < bandMasks.length; i2++) {
            bandMask = bandMasks[i2];
            for (j = 0; j < numPixels; j++) {
              maskData[j] = maskData[j] & bandMask[j];
            }
          }
          decodedPixelBlock.maskData = maskData;
        }
        return decodedPixelBlock;
      }
    };
    if (module2.exports) {
      module2.exports = Lerc;
    } else {
      this.Lerc = Lerc;
    }
  })();
});

// node_modules/cesium/Source/ThirdParty/nosleep.js
var media = {
  webm: "data:video/webm;base64,GkXfo0AgQoaBAUL3gQFC8oEEQvOBCEKCQAR3ZWJtQoeBAkKFgQIYU4BnQI0VSalmQCgq17FAAw9CQE2AQAZ3aGFtbXlXQUAGd2hhbW15RIlACECPQAAAAAAAFlSua0AxrkAu14EBY8WBAZyBACK1nEADdW5khkAFVl9WUDglhohAA1ZQOIOBAeBABrCBCLqBCB9DtnVAIueBAKNAHIEAAIAwAQCdASoIAAgAAUAmJaQAA3AA/vz0AAA=",
  mp4: "data:video/mp4;base64,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"
};
var { webm, mp4 } = media;
var oldIOS = typeof navigator !== "undefined" && parseFloat(
  ("" + (/CPU.*OS ([0-9_]{3,4})[0-9_]{0,1}|(CPU like).*AppleWebKit.*Mobile/i.exec(navigator.userAgent) || [0, ""])[1]).replace("undefined", "3_2").replace("_", ".").replace("_", "")
) < 10 && !window.MSStream;
var NoSleep = class {
  constructor() {
    if (oldIOS) {
      this.noSleepTimer = null;
    } else {
      this.noSleepVideo = document.createElement("video");
      this.noSleepVideo.setAttribute("muted", "");
      this.noSleepVideo.setAttribute("title", "No Sleep");
      this.noSleepVideo.setAttribute("playsinline", "");
      this._addSourceToVideo(this.noSleepVideo, "webm", webm);
      this._addSourceToVideo(this.noSleepVideo, "mp4", mp4);
      this.noSleepVideo.addEventListener("loadedmetadata", () => {
        if (this.noSleepVideo.duration <= 1) {
          this.noSleepVideo.setAttribute("loop", "");
        } else {
          this.noSleepVideo.addEventListener("timeupdate", () => {
            if (this.noSleepVideo.currentTime > 0.5) {
              this.noSleepVideo.currentTime = Math.random();
            }
          });
        }
      });
    }
  }
  _addSourceToVideo(element, type, dataURI) {
    var source = document.createElement("source");
    source.src = dataURI;
    source.type = `video/${type}`;
    element.appendChild(source);
  }
  enable() {
    if (oldIOS) {
      this.disable();
      console.warn(`
        NoSleep enabled for older iOS devices. This can interrupt
        active or long-running network requests from completing successfully.
        See https://github.com/richtr/NoSleep.js/issues/15 for more details.
      `);
      this.noSleepTimer = window.setInterval(() => {
        if (!document.hidden) {
          window.location.href = window.location.href.split("#")[0];
          window.setTimeout(window.stop, 0);
        }
      }, 15e3);
    } else {
      this.noSleepVideo.play();
    }
  }
  disable() {
    if (oldIOS) {
      if (this.noSleepTimer) {
        console.warn(`
          NoSleep now disabled for older iOS devices.
        `);
        window.clearInterval(this.noSleepTimer);
        this.noSleepTimer = null;
      }
    } else {
      this.noSleepVideo.pause();
    }
  }
};
var src = NoSleep;

// node_modules/cesium/Source/ThirdParty/pako.js
var common = createCommonjsModule(function(module2, exports2) {
  var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined";
  function _has(obj, key) {
    return Object.prototype.hasOwnProperty.call(obj, key);
  }
  exports2.assign = function(obj) {
    var sources = Array.prototype.slice.call(arguments, 1);
    while (sources.length) {
      var source = sources.shift();
      if (!source) {
        continue;
      }
      if (typeof source !== "object") {
        throw new TypeError(source + "must be non-object");
      }
      for (var p2 in source) {
        if (_has(source, p2)) {
          obj[p2] = source[p2];
        }
      }
    }
    return obj;
  };
  exports2.shrinkBuf = function(buf, size) {
    if (buf.length === size) {
      return buf;
    }
    if (buf.subarray) {
      return buf.subarray(0, size);
    }
    buf.length = size;
    return buf;
  };
  var fnTyped = {
    arraySet: function(dest, src2, src_offs, len, dest_offs) {
      if (src2.subarray && dest.subarray) {
        dest.set(src2.subarray(src_offs, src_offs + len), dest_offs);
        return;
      }
      for (var i2 = 0; i2 < len; i2++) {
        dest[dest_offs + i2] = src2[src_offs + i2];
      }
    },
    flattenChunks: function(chunks) {
      var i2, l2, len, pos, chunk, result;
      len = 0;
      for (i2 = 0, l2 = chunks.length; i2 < l2; i2++) {
        len += chunks[i2].length;
      }
      result = new Uint8Array(len);
      pos = 0;
      for (i2 = 0, l2 = chunks.length; i2 < l2; i2++) {
        chunk = chunks[i2];
        result.set(chunk, pos);
        pos += chunk.length;
      }
      return result;
    }
  };
  var fnUntyped = {
    arraySet: function(dest, src2, src_offs, len, dest_offs) {
      for (var i2 = 0; i2 < len; i2++) {
        dest[dest_offs + i2] = src2[src_offs + i2];
      }
    },
    flattenChunks: function(chunks) {
      return [].concat.apply([], chunks);
    }
  };
  exports2.setTyped = function(on) {
    if (on) {
      exports2.Buf8 = Uint8Array;
      exports2.Buf16 = Uint16Array;
      exports2.Buf32 = Int32Array;
      exports2.assign(exports2, fnTyped);
    } else {
      exports2.Buf8 = Array;
      exports2.Buf16 = Array;
      exports2.Buf32 = Array;
      exports2.assign(exports2, fnUntyped);
    }
  };
  exports2.setTyped(TYPED_OK);
});
function adler32(adler, buf, len, pos) {
  var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n2 = 0;
  while (len !== 0) {
    n2 = len > 2e3 ? 2e3 : len;
    len -= n2;
    do {
      s1 = s1 + buf[pos++] | 0;
      s2 = s2 + s1 | 0;
    } while (--n2);
    s1 %= 65521;
    s2 %= 65521;
  }
  return s1 | s2 << 16 | 0;
}
var adler32_1 = adler32;
function makeTable() {
  var c14, table2 = [];
  for (var n2 = 0; n2 < 256; n2++) {
    c14 = n2;
    for (var k = 0; k < 8; k++) {
      c14 = c14 & 1 ? 3988292384 ^ c14 >>> 1 : c14 >>> 1;
    }
    table2[n2] = c14;
  }
  return table2;
}
var crcTable = makeTable();
function crc32(crc, buf, len, pos) {
  var t = crcTable, end = pos + len;
  crc ^= -1;
  for (var i2 = pos; i2 < end; i2++) {
    crc = crc >>> 8 ^ t[(crc ^ buf[i2]) & 255];
  }
  return crc ^ -1;
}
var crc32_1 = crc32;
var BAD$1 = 30;
var TYPE$1 = 12;
var inffast = function inflate_fast(strm, start) {
  var state;
  var _in;
  var last;
  var _out;
  var beg;
  var end;
  var dmax;
  var wsize;
  var whave;
  var wnext;
  var s_window;
  var hold;
  var bits;
  var lcode;
  var dcode;
  var lmask;
  var dmask;
  var here;
  var op;
  var len;
  var dist;
  var from;
  var from_source;
  var input, output;
  state = strm.state;
  _in = strm.next_in;
  input = strm.input;
  last = _in + (strm.avail_in - 5);
  _out = strm.next_out;
  output = strm.output;
  beg = _out - (start - strm.avail_out);
  end = _out + (strm.avail_out - 257);
  dmax = state.dmax;
  wsize = state.wsize;
  whave = state.whave;
  wnext = state.wnext;
  s_window = state.window;
  hold = state.hold;
  bits = state.bits;
  lcode = state.lencode;
  dcode = state.distcode;
  lmask = (1 << state.lenbits) - 1;
  dmask = (1 << state.distbits) - 1;
  top:
    do {
      if (bits < 15) {
        hold += input[_in++] << bits;
        bits += 8;
        hold += input[_in++] << bits;
        bits += 8;
      }
      here = lcode[hold & lmask];
      dolen:
        for (; ; ) {
          op = here >>> 24;
          hold >>>= op;
          bits -= op;
          op = here >>> 16 & 255;
          if (op === 0) {
            output[_out++] = here & 65535;
          } else if (op & 16) {
            len = here & 65535;
            op &= 15;
            if (op) {
              if (bits < op) {
                hold += input[_in++] << bits;
                bits += 8;
              }
              len += hold & (1 << op) - 1;
              hold >>>= op;
              bits -= op;
            }
            if (bits < 15) {
              hold += input[_in++] << bits;
              bits += 8;
              hold += input[_in++] << bits;
              bits += 8;
            }
            here = dcode[hold & dmask];
            dodist:
              for (; ; ) {
                op = here >>> 24;
                hold >>>= op;
                bits -= op;
                op = here >>> 16 & 255;
                if (op & 16) {
                  dist = here & 65535;
                  op &= 15;
                  if (bits < op) {
                    hold += input[_in++] << bits;
                    bits += 8;
                    if (bits < op) {
                      hold += input[_in++] << bits;
                      bits += 8;
                    }
                  }
                  dist += hold & (1 << op) - 1;
                  if (dist > dmax) {
                    strm.msg = "invalid distance too far back";
                    state.mode = BAD$1;
                    break top;
                  }
                  hold >>>= op;
                  bits -= op;
                  op = _out - beg;
                  if (dist > op) {
                    op = dist - op;
                    if (op > whave) {
                      if (state.sane) {
                        strm.msg = "invalid distance too far back";
                        state.mode = BAD$1;
                        break top;
                      }
                    }
                    from = 0;
                    from_source = s_window;
                    if (wnext === 0) {
                      from += wsize - op;
                      if (op < len) {
                        len -= op;
                        do {
                          output[_out++] = s_window[from++];
                        } while (--op);
                        from = _out - dist;
                        from_source = output;
                      }
                    } else if (wnext < op) {
                      from += wsize + wnext - op;
                      op -= wnext;
                      if (op < len) {
                        len -= op;
                        do {
                          output[_out++] = s_window[from++];
                        } while (--op);
                        from = 0;
                        if (wnext < len) {
                          op = wnext;
                          len -= op;
                          do {
                            output[_out++] = s_window[from++];
                          } while (--op);
                          from = _out - dist;
                          from_source = output;
                        }
                      }
                    } else {
                      from += wnext - op;
                      if (op < len) {
                        len -= op;
                        do {
                          output[_out++] = s_window[from++];
                        } while (--op);
                        from = _out - dist;
                        from_source = output;
                      }
                    }
                    while (len > 2) {
                      output[_out++] = from_source[from++];
                      output[_out++] = from_source[from++];
                      output[_out++] = from_source[from++];
                      len -= 3;
                    }
                    if (len) {
                      output[_out++] = from_source[from++];
                      if (len > 1) {
                        output[_out++] = from_source[from++];
                      }
                    }
                  } else {
                    from = _out - dist;
                    do {
                      output[_out++] = output[from++];
                      output[_out++] = output[from++];
                      output[_out++] = output[from++];
                      len -= 3;
                    } while (len > 2);
                    if (len) {
                      output[_out++] = output[from++];
                      if (len > 1) {
                        output[_out++] = output[from++];
                      }
                    }
                  }
                } else if ((op & 64) === 0) {
                  here = dcode[(here & 65535) + (hold & (1 << op) - 1)];
                  continue dodist;
                } else {
                  strm.msg = "invalid distance code";
                  state.mode = BAD$1;
                  break top;
                }
                break;
              }
          } else if ((op & 64) === 0) {
            here = lcode[(here & 65535) + (hold & (1 << op) - 1)];
            continue dolen;
          } else if (op & 32) {
            state.mode = TYPE$1;
            break top;
          } else {
            strm.msg = "invalid literal/length code";
            state.mode = BAD$1;
            break top;
          }
          break;
        }
    } while (_in < last && _out < end);
  len = bits >> 3;
  _in -= len;
  bits -= len << 3;
  hold &= (1 << bits) - 1;
  strm.next_in = _in;
  strm.next_out = _out;
  strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last);
  strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end);
  state.hold = hold;
  state.bits = bits;
  return;
};
var MAXBITS = 15;
var ENOUGH_LENS$1 = 852;
var ENOUGH_DISTS$1 = 592;
var CODES$1 = 0;
var LENS$1 = 1;
var DISTS$1 = 2;
var lbase = [
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  11,
  13,
  15,
  17,
  19,
  23,
  27,
  31,
  35,
  43,
  51,
  59,
  67,
  83,
  99,
  115,
  131,
  163,
  195,
  227,
  258,
  0,
  0
];
var lext = [
  16,
  16,
  16,
  16,
  16,
  16,
  16,
  16,
  17,
  17,
  17,
  17,
  18,
  18,
  18,
  18,
  19,
  19,
  19,
  19,
  20,
  20,
  20,
  20,
  21,
  21,
  21,
  21,
  16,
  72,
  78
];
var dbase = [
  1,
  2,
  3,
  4,
  5,
  7,
  9,
  13,
  17,
  25,
  33,
  49,
  65,
  97,
  129,
  193,
  257,
  385,
  513,
  769,
  1025,
  1537,
  2049,
  3073,
  4097,
  6145,
  8193,
  12289,
  16385,
  24577,
  0,
  0
];
var dext = [
  16,
  16,
  16,
  16,
  17,
  17,
  18,
  18,
  19,
  19,
  20,
  20,
  21,
  21,
  22,
  22,
  23,
  23,
  24,
  24,
  25,
  25,
  26,
  26,
  27,
  27,
  28,
  28,
  29,
  29,
  64,
  64
];
var inftrees = function inflate_table(type, lens, lens_index, codes, table2, table_index, work, opts) {
  var bits = opts.bits;
  var len = 0;
  var sym = 0;
  var min3 = 0, max3 = 0;
  var root = 0;
  var curr = 0;
  var drop = 0;
  var left = 0;
  var used = 0;
  var huff = 0;
  var incr;
  var fill;
  var low;
  var mask;
  var next;
  var base = null;
  var base_index = 0;
  var end;
  var count = new common.Buf16(MAXBITS + 1);
  var offs = new common.Buf16(MAXBITS + 1);
  var extra = null;
  var extra_index = 0;
  var here_bits, here_op, here_val;
  for (len = 0; len <= MAXBITS; len++) {
    count[len] = 0;
  }
  for (sym = 0; sym < codes; sym++) {
    count[lens[lens_index + sym]]++;
  }
  root = bits;
  for (max3 = MAXBITS; max3 >= 1; max3--) {
    if (count[max3] !== 0) {
      break;
    }
  }
  if (root > max3) {
    root = max3;
  }
  if (max3 === 0) {
    table2[table_index++] = 1 << 24 | 64 << 16 | 0;
    table2[table_index++] = 1 << 24 | 64 << 16 | 0;
    opts.bits = 1;
    return 0;
  }
  for (min3 = 1; min3 < max3; min3++) {
    if (count[min3] !== 0) {
      break;
    }
  }
  if (root < min3) {
    root = min3;
  }
  left = 1;
  for (len = 1; len <= MAXBITS; len++) {
    left <<= 1;
    left -= count[len];
    if (left < 0) {
      return -1;
    }
  }
  if (left > 0 && (type === CODES$1 || max3 !== 1)) {
    return -1;
  }
  offs[1] = 0;
  for (len = 1; len < MAXBITS; len++) {
    offs[len + 1] = offs[len] + count[len];
  }
  for (sym = 0; sym < codes; sym++) {
    if (lens[lens_index + sym] !== 0) {
      work[offs[lens[lens_index + sym]]++] = sym;
    }
  }
  if (type === CODES$1) {
    base = extra = work;
    end = 19;
  } else if (type === LENS$1) {
    base = lbase;
    base_index -= 257;
    extra = lext;
    extra_index -= 257;
    end = 256;
  } else {
    base = dbase;
    extra = dext;
    end = -1;
  }
  huff = 0;
  sym = 0;
  len = min3;
  next = table_index;
  curr = root;
  drop = 0;
  low = -1;
  used = 1 << root;
  mask = used - 1;
  if (type === LENS$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) {
    return 1;
  }
  for (; ; ) {
    here_bits = len - drop;
    if (work[sym] < end) {
      here_op = 0;
      here_val = work[sym];
    } else if (work[sym] > end) {
      here_op = extra[extra_index + work[sym]];
      here_val = base[base_index + work[sym]];
    } else {
      here_op = 32 + 64;
      here_val = 0;
    }
    incr = 1 << len - drop;
    fill = 1 << curr;
    min3 = fill;
    do {
      fill -= incr;
      table2[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
    } while (fill !== 0);
    incr = 1 << len - 1;
    while (huff & incr) {
      incr >>= 1;
    }
    if (incr !== 0) {
      huff &= incr - 1;
      huff += incr;
    } else {
      huff = 0;
    }
    sym++;
    if (--count[len] === 0) {
      if (len === max3) {
        break;
      }
      len = lens[lens_index + work[sym]];
    }
    if (len > root && (huff & mask) !== low) {
      if (drop === 0) {
        drop = root;
      }
      next += min3;
      curr = len - drop;
      left = 1 << curr;
      while (curr + drop < max3) {
        left -= count[curr + drop];
        if (left <= 0) {
          break;
        }
        curr++;
        left <<= 1;
      }
      used += 1 << curr;
      if (type === LENS$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) {
        return 1;
      }
      low = huff & mask;
      table2[low] = root << 24 | curr << 16 | next - table_index | 0;
    }
  }
  if (huff !== 0) {
    table2[next + huff] = len - drop << 24 | 64 << 16 | 0;
  }
  opts.bits = root;
  return 0;
};
var CODES2 = 0;
var LENS2 = 1;
var DISTS = 2;
var Z_FINISH2 = 4;
var Z_BLOCK = 5;
var Z_TREES = 6;
var Z_OK2 = 0;
var Z_STREAM_END2 = 1;
var Z_NEED_DICT2 = 2;
var Z_STREAM_ERROR2 = -2;
var Z_DATA_ERROR2 = -3;
var Z_MEM_ERROR2 = -4;
var Z_BUF_ERROR2 = -5;
var Z_DEFLATED2 = 8;
var HEAD = 1;
var FLAGS = 2;
var TIME = 3;
var OS = 4;
var EXLEN = 5;
var EXTRA = 6;
var NAME = 7;
var COMMENT = 8;
var HCRC = 9;
var DICTID = 10;
var DICT = 11;
var TYPE2 = 12;
var TYPEDO = 13;
var STORED2 = 14;
var COPY_ = 15;
var COPY2 = 16;
var TABLE2 = 17;
var LENLENS = 18;
var CODELENS = 19;
var LEN_ = 20;
var LEN2 = 21;
var LENEXT2 = 22;
var DIST2 = 23;
var DISTEXT2 = 24;
var MATCH = 25;
var LIT2 = 26;
var CHECK = 27;
var LENGTH = 28;
var DONE2 = 29;
var BAD2 = 30;
var MEM = 31;
var SYNC = 32;
var ENOUGH_LENS = 852;
var ENOUGH_DISTS = 592;
var MAX_WBITS = 15;
var DEF_WBITS = MAX_WBITS;
function zswap32(q) {
  return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24);
}
function InflateState() {
  this.mode = 0;
  this.last = false;
  this.wrap = 0;
  this.havedict = false;
  this.flags = 0;
  this.dmax = 0;
  this.check = 0;
  this.total = 0;
  this.head = null;
  this.wbits = 0;
  this.wsize = 0;
  this.whave = 0;
  this.wnext = 0;
  this.window = null;
  this.hold = 0;
  this.bits = 0;
  this.length = 0;
  this.offset = 0;
  this.extra = 0;
  this.lencode = null;
  this.distcode = null;
  this.lenbits = 0;
  this.distbits = 0;
  this.ncode = 0;
  this.nlen = 0;
  this.ndist = 0;
  this.have = 0;
  this.next = null;
  this.lens = new common.Buf16(320);
  this.work = new common.Buf16(288);
  this.lendyn = null;
  this.distdyn = null;
  this.sane = 0;
  this.back = 0;
  this.was = 0;
}
function inflateResetKeep(strm) {
  var state;
  if (!strm || !strm.state) {
    return Z_STREAM_ERROR2;
  }
  state = strm.state;
  strm.total_in = strm.total_out = state.total = 0;
  strm.msg = "";
  if (state.wrap) {
    strm.adler = state.wrap & 1;
  }
  state.mode = HEAD;
  state.last = 0;
  state.havedict = 0;
  state.dmax = 32768;
  state.head = null;
  state.hold = 0;
  state.bits = 0;
  state.lencode = state.lendyn = new common.Buf32(ENOUGH_LENS);
  state.distcode = state.distdyn = new common.Buf32(ENOUGH_DISTS);
  state.sane = 1;
  state.back = -1;
  return Z_OK2;
}
function inflateReset(strm) {
  var state;
  if (!strm || !strm.state) {
    return Z_STREAM_ERROR2;
  }
  state = strm.state;
  state.wsize = 0;
  state.whave = 0;
  state.wnext = 0;
  return inflateResetKeep(strm);
}
function inflateReset2(strm, windowBits) {
  var wrap;
  var state;
  if (!strm || !strm.state) {
    return Z_STREAM_ERROR2;
  }
  state = strm.state;
  if (windowBits < 0) {
    wrap = 0;
    windowBits = -windowBits;
  } else {
    wrap = (windowBits >> 4) + 1;
    if (windowBits < 48) {
      windowBits &= 15;
    }
  }
  if (windowBits && (windowBits < 8 || windowBits > 15)) {
    return Z_STREAM_ERROR2;
  }
  if (state.window !== null && state.wbits !== windowBits) {
    state.window = null;
  }
  state.wrap = wrap;
  state.wbits = windowBits;
  return inflateReset(strm);
}
function inflateInit2(strm, windowBits) {
  var ret;
  var state;
  if (!strm) {
    return Z_STREAM_ERROR2;
  }
  state = new InflateState();
  strm.state = state;
  state.window = null;
  ret = inflateReset2(strm, windowBits);
  if (ret !== Z_OK2) {
    strm.state = null;
  }
  return ret;
}
function inflateInit(strm) {
  return inflateInit2(strm, DEF_WBITS);
}
var virgin = true;
var lenfix;
var distfix;
function fixedtables(state) {
  if (virgin) {
    var sym;
    lenfix = new common.Buf32(512);
    distfix = new common.Buf32(32);
    sym = 0;
    while (sym < 144) {
      state.lens[sym++] = 8;
    }
    while (sym < 256) {
      state.lens[sym++] = 9;
    }
    while (sym < 280) {
      state.lens[sym++] = 7;
    }
    while (sym < 288) {
      state.lens[sym++] = 8;
    }
    inftrees(LENS2, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
    sym = 0;
    while (sym < 32) {
      state.lens[sym++] = 5;
    }
    inftrees(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
    virgin = false;
  }
  state.lencode = lenfix;
  state.lenbits = 9;
  state.distcode = distfix;
  state.distbits = 5;
}
function updatewindow(strm, src2, end, copy) {
  var dist;
  var state = strm.state;
  if (state.window === null) {
    state.wsize = 1 << state.wbits;
    state.wnext = 0;
    state.whave = 0;
    state.window = new common.Buf8(state.wsize);
  }
  if (copy >= state.wsize) {
    common.arraySet(state.window, src2, end - state.wsize, state.wsize, 0);
    state.wnext = 0;
    state.whave = state.wsize;
  } else {
    dist = state.wsize - state.wnext;
    if (dist > copy) {
      dist = copy;
    }
    common.arraySet(state.window, src2, end - copy, dist, state.wnext);
    copy -= dist;
    if (copy) {
      common.arraySet(state.window, src2, end - copy, copy, 0);
      state.wnext = copy;
      state.whave = state.wsize;
    } else {
      state.wnext += dist;
      if (state.wnext === state.wsize) {
        state.wnext = 0;
      }
      if (state.whave < state.wsize) {
        state.whave += dist;
      }
    }
  }
  return 0;
}
function inflate$1(strm, flush) {
  var state;
  var input, output;
  var next;
  var put;
  var have, left;
  var hold;
  var bits;
  var _in, _out;
  var copy;
  var from;
  var from_source;
  var here = 0;
  var here_bits, here_op, here_val;
  var last_bits, last_op, last_val;
  var len;
  var ret;
  var hbuf = new common.Buf8(4);
  var opts;
  var n2;
  var order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
  if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) {
    return Z_STREAM_ERROR2;
  }
  state = strm.state;
  if (state.mode === TYPE2) {
    state.mode = TYPEDO;
  }
  put = strm.next_out;
  output = strm.output;
  left = strm.avail_out;
  next = strm.next_in;
  input = strm.input;
  have = strm.avail_in;
  hold = state.hold;
  bits = state.bits;
  _in = have;
  _out = left;
  ret = Z_OK2;
  inf_leave:
    for (; ; ) {
      switch (state.mode) {
        case HEAD:
          if (state.wrap === 0) {
            state.mode = TYPEDO;
            break;
          }
          while (bits < 16) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if (state.wrap & 2 && hold === 35615) {
            state.check = 0;
            hbuf[0] = hold & 255;
            hbuf[1] = hold >>> 8 & 255;
            state.check = crc32_1(state.check, hbuf, 2, 0);
            hold = 0;
            bits = 0;
            state.mode = FLAGS;
            break;
          }
          state.flags = 0;
          if (state.head) {
            state.head.done = false;
          }
          if (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) {
            strm.msg = "incorrect header check";
            state.mode = BAD2;
            break;
          }
          if ((hold & 15) !== Z_DEFLATED2) {
            strm.msg = "unknown compression method";
            state.mode = BAD2;
            break;
          }
          hold >>>= 4;
          bits -= 4;
          len = (hold & 15) + 8;
          if (state.wbits === 0) {
            state.wbits = len;
          } else if (len > state.wbits) {
            strm.msg = "invalid window size";
            state.mode = BAD2;
            break;
          }
          state.dmax = 1 << len;
          strm.adler = state.check = 1;
          state.mode = hold & 512 ? DICTID : TYPE2;
          hold = 0;
          bits = 0;
          break;
        case FLAGS:
          while (bits < 16) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          state.flags = hold;
          if ((state.flags & 255) !== Z_DEFLATED2) {
            strm.msg = "unknown compression method";
            state.mode = BAD2;
            break;
          }
          if (state.flags & 57344) {
            strm.msg = "unknown header flags set";
            state.mode = BAD2;
            break;
          }
          if (state.head) {
            state.head.text = hold >> 8 & 1;
          }
          if (state.flags & 512) {
            hbuf[0] = hold & 255;
            hbuf[1] = hold >>> 8 & 255;
            state.check = crc32_1(state.check, hbuf, 2, 0);
          }
          hold = 0;
          bits = 0;
          state.mode = TIME;
        case TIME:
          while (bits < 32) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if (state.head) {
            state.head.time = hold;
          }
          if (state.flags & 512) {
            hbuf[0] = hold & 255;
            hbuf[1] = hold >>> 8 & 255;
            hbuf[2] = hold >>> 16 & 255;
            hbuf[3] = hold >>> 24 & 255;
            state.check = crc32_1(state.check, hbuf, 4, 0);
          }
          hold = 0;
          bits = 0;
          state.mode = OS;
        case OS:
          while (bits < 16) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if (state.head) {
            state.head.xflags = hold & 255;
            state.head.os = hold >> 8;
          }
          if (state.flags & 512) {
            hbuf[0] = hold & 255;
            hbuf[1] = hold >>> 8 & 255;
            state.check = crc32_1(state.check, hbuf, 2, 0);
          }
          hold = 0;
          bits = 0;
          state.mode = EXLEN;
        case EXLEN:
          if (state.flags & 1024) {
            while (bits < 16) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            state.length = hold;
            if (state.head) {
              state.head.extra_len = hold;
            }
            if (state.flags & 512) {
              hbuf[0] = hold & 255;
              hbuf[1] = hold >>> 8 & 255;
              state.check = crc32_1(state.check, hbuf, 2, 0);
            }
            hold = 0;
            bits = 0;
          } else if (state.head) {
            state.head.extra = null;
          }
          state.mode = EXTRA;
        case EXTRA:
          if (state.flags & 1024) {
            copy = state.length;
            if (copy > have) {
              copy = have;
            }
            if (copy) {
              if (state.head) {
                len = state.head.extra_len - state.length;
                if (!state.head.extra) {
                  state.head.extra = new Array(state.head.extra_len);
                }
                common.arraySet(
                  state.head.extra,
                  input,
                  next,
                  copy,
                  len
                );
              }
              if (state.flags & 512) {
                state.check = crc32_1(state.check, input, copy, next);
              }
              have -= copy;
              next += copy;
              state.length -= copy;
            }
            if (state.length) {
              break inf_leave;
            }
          }
          state.length = 0;
          state.mode = NAME;
        case NAME:
          if (state.flags & 2048) {
            if (have === 0) {
              break inf_leave;
            }
            copy = 0;
            do {
              len = input[next + copy++];
              if (state.head && len && state.length < 65536) {
                state.head.name += String.fromCharCode(len);
              }
            } while (len && copy < have);
            if (state.flags & 512) {
              state.check = crc32_1(state.check, input, copy, next);
            }
            have -= copy;
            next += copy;
            if (len) {
              break inf_leave;
            }
          } else if (state.head) {
            state.head.name = null;
          }
          state.length = 0;
          state.mode = COMMENT;
        case COMMENT:
          if (state.flags & 4096) {
            if (have === 0) {
              break inf_leave;
            }
            copy = 0;
            do {
              len = input[next + copy++];
              if (state.head && len && state.length < 65536) {
                state.head.comment += String.fromCharCode(len);
              }
            } while (len && copy < have);
            if (state.flags & 512) {
              state.check = crc32_1(state.check, input, copy, next);
            }
            have -= copy;
            next += copy;
            if (len) {
              break inf_leave;
            }
          } else if (state.head) {
            state.head.comment = null;
          }
          state.mode = HCRC;
        case HCRC:
          if (state.flags & 512) {
            while (bits < 16) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            if (hold !== (state.check & 65535)) {
              strm.msg = "header crc mismatch";
              state.mode = BAD2;
              break;
            }
            hold = 0;
            bits = 0;
          }
          if (state.head) {
            state.head.hcrc = state.flags >> 9 & 1;
            state.head.done = true;
          }
          strm.adler = state.check = 0;
          state.mode = TYPE2;
          break;
        case DICTID:
          while (bits < 32) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          strm.adler = state.check = zswap32(hold);
          hold = 0;
          bits = 0;
          state.mode = DICT;
        case DICT:
          if (state.havedict === 0) {
            strm.next_out = put;
            strm.avail_out = left;
            strm.next_in = next;
            strm.avail_in = have;
            state.hold = hold;
            state.bits = bits;
            return Z_NEED_DICT2;
          }
          strm.adler = state.check = 1;
          state.mode = TYPE2;
        case TYPE2:
          if (flush === Z_BLOCK || flush === Z_TREES) {
            break inf_leave;
          }
        case TYPEDO:
          if (state.last) {
            hold >>>= bits & 7;
            bits -= bits & 7;
            state.mode = CHECK;
            break;
          }
          while (bits < 3) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          state.last = hold & 1;
          hold >>>= 1;
          bits -= 1;
          switch (hold & 3) {
            case 0:
              state.mode = STORED2;
              break;
            case 1:
              fixedtables(state);
              state.mode = LEN_;
              if (flush === Z_TREES) {
                hold >>>= 2;
                bits -= 2;
                break inf_leave;
              }
              break;
            case 2:
              state.mode = TABLE2;
              break;
            case 3:
              strm.msg = "invalid block type";
              state.mode = BAD2;
          }
          hold >>>= 2;
          bits -= 2;
          break;
        case STORED2:
          hold >>>= bits & 7;
          bits -= bits & 7;
          while (bits < 32) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if ((hold & 65535) !== (hold >>> 16 ^ 65535)) {
            strm.msg = "invalid stored block lengths";
            state.mode = BAD2;
            break;
          }
          state.length = hold & 65535;
          hold = 0;
          bits = 0;
          state.mode = COPY_;
          if (flush === Z_TREES) {
            break inf_leave;
          }
        case COPY_:
          state.mode = COPY2;
        case COPY2:
          copy = state.length;
          if (copy) {
            if (copy > have) {
              copy = have;
            }
            if (copy > left) {
              copy = left;
            }
            if (copy === 0) {
              break inf_leave;
            }
            common.arraySet(output, input, next, copy, put);
            have -= copy;
            next += copy;
            left -= copy;
            put += copy;
            state.length -= copy;
            break;
          }
          state.mode = TYPE2;
          break;
        case TABLE2:
          while (bits < 14) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          state.nlen = (hold & 31) + 257;
          hold >>>= 5;
          bits -= 5;
          state.ndist = (hold & 31) + 1;
          hold >>>= 5;
          bits -= 5;
          state.ncode = (hold & 15) + 4;
          hold >>>= 4;
          bits -= 4;
          if (state.nlen > 286 || state.ndist > 30) {
            strm.msg = "too many length or distance symbols";
            state.mode = BAD2;
            break;
          }
          state.have = 0;
          state.mode = LENLENS;
        case LENLENS:
          while (state.have < state.ncode) {
            while (bits < 3) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            state.lens[order[state.have++]] = hold & 7;
            hold >>>= 3;
            bits -= 3;
          }
          while (state.have < 19) {
            state.lens[order[state.have++]] = 0;
          }
          state.lencode = state.lendyn;
          state.lenbits = 7;
          opts = { bits: state.lenbits };
          ret = inftrees(CODES2, state.lens, 0, 19, state.lencode, 0, state.work, opts);
          state.lenbits = opts.bits;
          if (ret) {
            strm.msg = "invalid code lengths set";
            state.mode = BAD2;
            break;
          }
          state.have = 0;
          state.mode = CODELENS;
        case CODELENS:
          while (state.have < state.nlen + state.ndist) {
            for (; ; ) {
              here = state.lencode[hold & (1 << state.lenbits) - 1];
              here_bits = here >>> 24;
              here_op = here >>> 16 & 255;
              here_val = here & 65535;
              if (here_bits <= bits) {
                break;
              }
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            if (here_val < 16) {
              hold >>>= here_bits;
              bits -= here_bits;
              state.lens[state.have++] = here_val;
            } else {
              if (here_val === 16) {
                n2 = here_bits + 2;
                while (bits < n2) {
                  if (have === 0) {
                    break inf_leave;
                  }
                  have--;
                  hold += input[next++] << bits;
                  bits += 8;
                }
                hold >>>= here_bits;
                bits -= here_bits;
                if (state.have === 0) {
                  strm.msg = "invalid bit length repeat";
                  state.mode = BAD2;
                  break;
                }
                len = state.lens[state.have - 1];
                copy = 3 + (hold & 3);
                hold >>>= 2;
                bits -= 2;
              } else if (here_val === 17) {
                n2 = here_bits + 3;
                while (bits < n2) {
                  if (have === 0) {
                    break inf_leave;
                  }
                  have--;
                  hold += input[next++] << bits;
                  bits += 8;
                }
                hold >>>= here_bits;
                bits -= here_bits;
                len = 0;
                copy = 3 + (hold & 7);
                hold >>>= 3;
                bits -= 3;
              } else {
                n2 = here_bits + 7;
                while (bits < n2) {
                  if (have === 0) {
                    break inf_leave;
                  }
                  have--;
                  hold += input[next++] << bits;
                  bits += 8;
                }
                hold >>>= here_bits;
                bits -= here_bits;
                len = 0;
                copy = 11 + (hold & 127);
                hold >>>= 7;
                bits -= 7;
              }
              if (state.have + copy > state.nlen + state.ndist) {
                strm.msg = "invalid bit length repeat";
                state.mode = BAD2;
                break;
              }
              while (copy--) {
                state.lens[state.have++] = len;
              }
            }
          }
          if (state.mode === BAD2) {
            break;
          }
          if (state.lens[256] === 0) {
            strm.msg = "invalid code -- missing end-of-block";
            state.mode = BAD2;
            break;
          }
          state.lenbits = 9;
          opts = { bits: state.lenbits };
          ret = inftrees(LENS2, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
          state.lenbits = opts.bits;
          if (ret) {
            strm.msg = "invalid literal/lengths set";
            state.mode = BAD2;
            break;
          }
          state.distbits = 6;
          state.distcode = state.distdyn;
          opts = { bits: state.distbits };
          ret = inftrees(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
          state.distbits = opts.bits;
          if (ret) {
            strm.msg = "invalid distances set";
            state.mode = BAD2;
            break;
          }
          state.mode = LEN_;
          if (flush === Z_TREES) {
            break inf_leave;
          }
        case LEN_:
          state.mode = LEN2;
        case LEN2:
          if (have >= 6 && left >= 258) {
            strm.next_out = put;
            strm.avail_out = left;
            strm.next_in = next;
            strm.avail_in = have;
            state.hold = hold;
            state.bits = bits;
            inffast(strm, _out);
            put = strm.next_out;
            output = strm.output;
            left = strm.avail_out;
            next = strm.next_in;
            input = strm.input;
            have = strm.avail_in;
            hold = state.hold;
            bits = state.bits;
            if (state.mode === TYPE2) {
              state.back = -1;
            }
            break;
          }
          state.back = 0;
          for (; ; ) {
            here = state.lencode[hold & (1 << state.lenbits) - 1];
            here_bits = here >>> 24;
            here_op = here >>> 16 & 255;
            here_val = here & 65535;
            if (here_bits <= bits) {
              break;
            }
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if (here_op && (here_op & 240) === 0) {
            last_bits = here_bits;
            last_op = here_op;
            last_val = here_val;
            for (; ; ) {
              here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
              here_bits = here >>> 24;
              here_op = here >>> 16 & 255;
              here_val = here & 65535;
              if (last_bits + here_bits <= bits) {
                break;
              }
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            hold >>>= last_bits;
            bits -= last_bits;
            state.back += last_bits;
          }
          hold >>>= here_bits;
          bits -= here_bits;
          state.back += here_bits;
          state.length = here_val;
          if (here_op === 0) {
            state.mode = LIT2;
            break;
          }
          if (here_op & 32) {
            state.back = -1;
            state.mode = TYPE2;
            break;
          }
          if (here_op & 64) {
            strm.msg = "invalid literal/length code";
            state.mode = BAD2;
            break;
          }
          state.extra = here_op & 15;
          state.mode = LENEXT2;
        case LENEXT2:
          if (state.extra) {
            n2 = state.extra;
            while (bits < n2) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            state.length += hold & (1 << state.extra) - 1;
            hold >>>= state.extra;
            bits -= state.extra;
            state.back += state.extra;
          }
          state.was = state.length;
          state.mode = DIST2;
        case DIST2:
          for (; ; ) {
            here = state.distcode[hold & (1 << state.distbits) - 1];
            here_bits = here >>> 24;
            here_op = here >>> 16 & 255;
            here_val = here & 65535;
            if (here_bits <= bits) {
              break;
            }
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if ((here_op & 240) === 0) {
            last_bits = here_bits;
            last_op = here_op;
            last_val = here_val;
            for (; ; ) {
              here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
              here_bits = here >>> 24;
              here_op = here >>> 16 & 255;
              here_val = here & 65535;
              if (last_bits + here_bits <= bits) {
                break;
              }
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            hold >>>= last_bits;
            bits -= last_bits;
            state.back += last_bits;
          }
          hold >>>= here_bits;
          bits -= here_bits;
          state.back += here_bits;
          if (here_op & 64) {
            strm.msg = "invalid distance code";
            state.mode = BAD2;
            break;
          }
          state.offset = here_val;
          state.extra = here_op & 15;
          state.mode = DISTEXT2;
        case DISTEXT2:
          if (state.extra) {
            n2 = state.extra;
            while (bits < n2) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            state.offset += hold & (1 << state.extra) - 1;
            hold >>>= state.extra;
            bits -= state.extra;
            state.back += state.extra;
          }
          if (state.offset > state.dmax) {
            strm.msg = "invalid distance too far back";
            state.mode = BAD2;
            break;
          }
          state.mode = MATCH;
        case MATCH:
          if (left === 0) {
            break inf_leave;
          }
          copy = _out - left;
          if (state.offset > copy) {
            copy = state.offset - copy;
            if (copy > state.whave) {
              if (state.sane) {
                strm.msg = "invalid distance too far back";
                state.mode = BAD2;
                break;
              }
            }
            if (copy > state.wnext) {
              copy -= state.wnext;
              from = state.wsize - copy;
            } else {
              from = state.wnext - copy;
            }
            if (copy > state.length) {
              copy = state.length;
            }
            from_source = state.window;
          } else {
            from_source = output;
            from = put - state.offset;
            copy = state.length;
          }
          if (copy > left) {
            copy = left;
          }
          left -= copy;
          state.length -= copy;
          do {
            output[put++] = from_source[from++];
          } while (--copy);
          if (state.length === 0) {
            state.mode = LEN2;
          }
          break;
        case LIT2:
          if (left === 0) {
            break inf_leave;
          }
          output[put++] = state.length;
          left--;
          state.mode = LEN2;
          break;
        case CHECK:
          if (state.wrap) {
            while (bits < 32) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold |= input[next++] << bits;
              bits += 8;
            }
            _out -= left;
            strm.total_out += _out;
            state.total += _out;
            if (_out) {
              strm.adler = state.check = state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out);
            }
            _out = left;
            if ((state.flags ? hold : zswap32(hold)) !== state.check) {
              strm.msg = "incorrect data check";
              state.mode = BAD2;
              break;
            }
            hold = 0;
            bits = 0;
          }
          state.mode = LENGTH;
        case LENGTH:
          if (state.wrap && state.flags) {
            while (bits < 32) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            if (hold !== (state.total & 4294967295)) {
              strm.msg = "incorrect length check";
              state.mode = BAD2;
              break;
            }
            hold = 0;
            bits = 0;
          }
          state.mode = DONE2;
        case DONE2:
          ret = Z_STREAM_END2;
          break inf_leave;
        case BAD2:
          ret = Z_DATA_ERROR2;
          break inf_leave;
        case MEM:
          return Z_MEM_ERROR2;
        case SYNC:
        default:
          return Z_STREAM_ERROR2;
      }
    }
  strm.next_out = put;
  strm.avail_out = left;
  strm.next_in = next;
  strm.avail_in = have;
  state.hold = hold;
  state.bits = bits;
  if (state.wsize || _out !== strm.avail_out && state.mode < BAD2 && (state.mode < CHECK || flush !== Z_FINISH2)) {
    if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out))
      ;
  }
  _in -= strm.avail_in;
  _out -= strm.avail_out;
  strm.total_in += _in;
  strm.total_out += _out;
  state.total += _out;
  if (state.wrap && _out) {
    strm.adler = state.check = state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out);
  }
  strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE2 ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
  if ((_in === 0 && _out === 0 || flush === Z_FINISH2) && ret === Z_OK2) {
    ret = Z_BUF_ERROR2;
  }
  return ret;
}
function inflateEnd(strm) {
  if (!strm || !strm.state) {
    return Z_STREAM_ERROR2;
  }
  var state = strm.state;
  if (state.window) {
    state.window = null;
  }
  strm.state = null;
  return Z_OK2;
}
function inflateGetHeader(strm, head) {
  var state;
  if (!strm || !strm.state) {
    return Z_STREAM_ERROR2;
  }
  state = strm.state;
  if ((state.wrap & 2) === 0) {
    return Z_STREAM_ERROR2;
  }
  state.head = head;
  head.done = false;
  return Z_OK2;
}
function inflateSetDictionary(strm, dictionary) {
  var dictLength = dictionary.length;
  var state;
  var dictid;
  var ret;
  if (!strm || !strm.state) {
    return Z_STREAM_ERROR2;
  }
  state = strm.state;
  if (state.wrap !== 0 && state.mode !== DICT) {
    return Z_STREAM_ERROR2;
  }
  if (state.mode === DICT) {
    dictid = 1;
    dictid = adler32_1(dictid, dictionary, dictLength, 0);
    if (dictid !== state.check) {
      return Z_DATA_ERROR2;
    }
  }
  ret = updatewindow(strm, dictionary, dictLength, dictLength);
  if (ret) {
    state.mode = MEM;
    return Z_MEM_ERROR2;
  }
  state.havedict = 1;
  return Z_OK2;
}
var inflateReset_1 = inflateReset;
var inflateReset2_1 = inflateReset2;
var inflateResetKeep_1 = inflateResetKeep;
var inflateInit_1 = inflateInit;
var inflateInit2_1 = inflateInit2;
var inflate_2$1 = inflate$1;
var inflateEnd_1 = inflateEnd;
var inflateGetHeader_1 = inflateGetHeader;
var inflateSetDictionary_1 = inflateSetDictionary;
var inflateInfo = "pako inflate (from Nodeca project)";
var inflate_1$1 = {
  inflateReset: inflateReset_1,
  inflateReset2: inflateReset2_1,
  inflateResetKeep: inflateResetKeep_1,
  inflateInit: inflateInit_1,
  inflateInit2: inflateInit2_1,
  inflate: inflate_2$1,
  inflateEnd: inflateEnd_1,
  inflateGetHeader: inflateGetHeader_1,
  inflateSetDictionary: inflateSetDictionary_1,
  inflateInfo
};
var STR_APPLY_OK = true;
var STR_APPLY_UIA_OK = true;
try {
  String.fromCharCode.apply(null, [0]);
} catch (__) {
  STR_APPLY_OK = false;
}
try {
  String.fromCharCode.apply(null, new Uint8Array(1));
} catch (__) {
  STR_APPLY_UIA_OK = false;
}
var _utf8len = new common.Buf8(256);
for (q = 0; q < 256; q++) {
  _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;
}
var q;
_utf8len[254] = _utf8len[254] = 1;
var string2buf = function(str) {
  var buf, c14, c22, m_pos, i2, str_len = str.length, buf_len = 0;
  for (m_pos = 0; m_pos < str_len; m_pos++) {
    c14 = str.charCodeAt(m_pos);
    if ((c14 & 64512) === 55296 && m_pos + 1 < str_len) {
      c22 = str.charCodeAt(m_pos + 1);
      if ((c22 & 64512) === 56320) {
        c14 = 65536 + (c14 - 55296 << 10) + (c22 - 56320);
        m_pos++;
      }
    }
    buf_len += c14 < 128 ? 1 : c14 < 2048 ? 2 : c14 < 65536 ? 3 : 4;
  }
  buf = new common.Buf8(buf_len);
  for (i2 = 0, m_pos = 0; i2 < buf_len; m_pos++) {
    c14 = str.charCodeAt(m_pos);
    if ((c14 & 64512) === 55296 && m_pos + 1 < str_len) {
      c22 = str.charCodeAt(m_pos + 1);
      if ((c22 & 64512) === 56320) {
        c14 = 65536 + (c14 - 55296 << 10) + (c22 - 56320);
        m_pos++;
      }
    }
    if (c14 < 128) {
      buf[i2++] = c14;
    } else if (c14 < 2048) {
      buf[i2++] = 192 | c14 >>> 6;
      buf[i2++] = 128 | c14 & 63;
    } else if (c14 < 65536) {
      buf[i2++] = 224 | c14 >>> 12;
      buf[i2++] = 128 | c14 >>> 6 & 63;
      buf[i2++] = 128 | c14 & 63;
    } else {
      buf[i2++] = 240 | c14 >>> 18;
      buf[i2++] = 128 | c14 >>> 12 & 63;
      buf[i2++] = 128 | c14 >>> 6 & 63;
      buf[i2++] = 128 | c14 & 63;
    }
  }
  return buf;
};
function buf2binstring(buf, len) {
  if (len < 65534) {
    if (buf.subarray && STR_APPLY_UIA_OK || !buf.subarray && STR_APPLY_OK) {
      return String.fromCharCode.apply(null, common.shrinkBuf(buf, len));
    }
  }
  var result = "";
  for (var i2 = 0; i2 < len; i2++) {
    result += String.fromCharCode(buf[i2]);
  }
  return result;
}
var buf2binstring_1 = function(buf) {
  return buf2binstring(buf, buf.length);
};
var binstring2buf = function(str) {
  var buf = new common.Buf8(str.length);
  for (var i2 = 0, len = buf.length; i2 < len; i2++) {
    buf[i2] = str.charCodeAt(i2);
  }
  return buf;
};
var buf2string = function(buf, max3) {
  var i2, out, c14, c_len;
  var len = max3 || buf.length;
  var utf16buf = new Array(len * 2);
  for (out = 0, i2 = 0; i2 < len; ) {
    c14 = buf[i2++];
    if (c14 < 128) {
      utf16buf[out++] = c14;
      continue;
    }
    c_len = _utf8len[c14];
    if (c_len > 4) {
      utf16buf[out++] = 65533;
      i2 += c_len - 1;
      continue;
    }
    c14 &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7;
    while (c_len > 1 && i2 < len) {
      c14 = c14 << 6 | buf[i2++] & 63;
      c_len--;
    }
    if (c_len > 1) {
      utf16buf[out++] = 65533;
      continue;
    }
    if (c14 < 65536) {
      utf16buf[out++] = c14;
    } else {
      c14 -= 65536;
      utf16buf[out++] = 55296 | c14 >> 10 & 1023;
      utf16buf[out++] = 56320 | c14 & 1023;
    }
  }
  return buf2binstring(utf16buf, out);
};
var utf8border = function(buf, max3) {
  var pos;
  max3 = max3 || buf.length;
  if (max3 > buf.length) {
    max3 = buf.length;
  }
  pos = max3 - 1;
  while (pos >= 0 && (buf[pos] & 192) === 128) {
    pos--;
  }
  if (pos < 0) {
    return max3;
  }
  if (pos === 0) {
    return max3;
  }
  return pos + _utf8len[buf[pos]] > max3 ? pos : max3;
};
var strings = {
  string2buf,
  buf2binstring: buf2binstring_1,
  binstring2buf,
  buf2string,
  utf8border
};
var constants = {
  Z_NO_FLUSH: 0,
  Z_PARTIAL_FLUSH: 1,
  Z_SYNC_FLUSH: 2,
  Z_FULL_FLUSH: 3,
  Z_FINISH: 4,
  Z_BLOCK: 5,
  Z_TREES: 6,
  Z_OK: 0,
  Z_STREAM_END: 1,
  Z_NEED_DICT: 2,
  Z_ERRNO: -1,
  Z_STREAM_ERROR: -2,
  Z_DATA_ERROR: -3,
  Z_BUF_ERROR: -5,
  Z_NO_COMPRESSION: 0,
  Z_BEST_SPEED: 1,
  Z_BEST_COMPRESSION: 9,
  Z_DEFAULT_COMPRESSION: -1,
  Z_FILTERED: 1,
  Z_HUFFMAN_ONLY: 2,
  Z_RLE: 3,
  Z_FIXED: 4,
  Z_DEFAULT_STRATEGY: 0,
  Z_BINARY: 0,
  Z_TEXT: 1,
  Z_UNKNOWN: 2,
  Z_DEFLATED: 8
};
var messages = {
  2: "need dictionary",
  1: "stream end",
  0: "",
  "-1": "file error",
  "-2": "stream error",
  "-3": "data error",
  "-4": "insufficient memory",
  "-5": "buffer error",
  "-6": "incompatible version"
};
function ZStream2() {
  this.input = null;
  this.next_in = 0;
  this.avail_in = 0;
  this.total_in = 0;
  this.output = null;
  this.next_out = 0;
  this.avail_out = 0;
  this.total_out = 0;
  this.msg = "";
  this.state = null;
  this.data_type = 2;
  this.adler = 0;
}
var zstream = ZStream2;
function GZheader() {
  this.text = 0;
  this.time = 0;
  this.xflags = 0;
  this.os = 0;
  this.extra = null;
  this.extra_len = 0;
  this.name = "";
  this.comment = "";
  this.hcrc = 0;
  this.done = false;
}
var gzheader = GZheader;
var toString = Object.prototype.toString;
function Inflate2(options) {
  if (!(this instanceof Inflate2))
    return new Inflate2(options);
  this.options = common.assign({
    chunkSize: 16384,
    windowBits: 0,
    to: ""
  }, options || {});
  var opt = this.options;
  if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) {
    opt.windowBits = -opt.windowBits;
    if (opt.windowBits === 0) {
      opt.windowBits = -15;
    }
  }
  if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) {
    opt.windowBits += 32;
  }
  if (opt.windowBits > 15 && opt.windowBits < 48) {
    if ((opt.windowBits & 15) === 0) {
      opt.windowBits |= 15;
    }
  }
  this.err = 0;
  this.msg = "";
  this.ended = false;
  this.chunks = [];
  this.strm = new zstream();
  this.strm.avail_out = 0;
  var status = inflate_1$1.inflateInit2(
    this.strm,
    opt.windowBits
  );
  if (status !== constants.Z_OK) {
    throw new Error(messages[status]);
  }
  this.header = new gzheader();
  inflate_1$1.inflateGetHeader(this.strm, this.header);
  if (opt.dictionary) {
    if (typeof opt.dictionary === "string") {
      opt.dictionary = strings.string2buf(opt.dictionary);
    } else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") {
      opt.dictionary = new Uint8Array(opt.dictionary);
    }
    if (opt.raw) {
      status = inflate_1$1.inflateSetDictionary(this.strm, opt.dictionary);
      if (status !== constants.Z_OK) {
        throw new Error(messages[status]);
      }
    }
  }
}
Inflate2.prototype.push = function(data, mode2) {
  var strm = this.strm;
  var chunkSize = this.options.chunkSize;
  var dictionary = this.options.dictionary;
  var status, _mode;
  var next_out_utf8, tail, utf8str;
  var allowBufError = false;
  if (this.ended) {
    return false;
  }
  _mode = mode2 === ~~mode2 ? mode2 : mode2 === true ? constants.Z_FINISH : constants.Z_NO_FLUSH;
  if (typeof data === "string") {
    strm.input = strings.binstring2buf(data);
  } else if (toString.call(data) === "[object ArrayBuffer]") {
    strm.input = new Uint8Array(data);
  } else {
    strm.input = data;
  }
  strm.next_in = 0;
  strm.avail_in = strm.input.length;
  do {
    if (strm.avail_out === 0) {
      strm.output = new common.Buf8(chunkSize);
      strm.next_out = 0;
      strm.avail_out = chunkSize;
    }
    status = inflate_1$1.inflate(strm, constants.Z_NO_FLUSH);
    if (status === constants.Z_NEED_DICT && dictionary) {
      status = inflate_1$1.inflateSetDictionary(this.strm, dictionary);
    }
    if (status === constants.Z_BUF_ERROR && allowBufError === true) {
      status = constants.Z_OK;
      allowBufError = false;
    }
    if (status !== constants.Z_STREAM_END && status !== constants.Z_OK) {
      this.onEnd(status);
      this.ended = true;
      return false;
    }
    if (strm.next_out) {
      if (strm.avail_out === 0 || status === constants.Z_STREAM_END || strm.avail_in === 0 && (_mode === constants.Z_FINISH || _mode === constants.Z_SYNC_FLUSH)) {
        if (this.options.to === "string") {
          next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
          tail = strm.next_out - next_out_utf8;
          utf8str = strings.buf2string(strm.output, next_out_utf8);
          strm.next_out = tail;
          strm.avail_out = chunkSize - tail;
          if (tail) {
            common.arraySet(strm.output, strm.output, next_out_utf8, tail, 0);
          }
          this.onData(utf8str);
        } else {
          this.onData(common.shrinkBuf(strm.output, strm.next_out));
        }
      }
    }
    if (strm.avail_in === 0 && strm.avail_out === 0) {
      allowBufError = true;
    }
  } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== constants.Z_STREAM_END);
  if (status === constants.Z_STREAM_END) {
    _mode = constants.Z_FINISH;
  }
  if (_mode === constants.Z_FINISH) {
    status = inflate_1$1.inflateEnd(this.strm);
    this.onEnd(status);
    this.ended = true;
    return status === constants.Z_OK;
  }
  if (_mode === constants.Z_SYNC_FLUSH) {
    this.onEnd(constants.Z_OK);
    strm.avail_out = 0;
    return true;
  }
  return true;
};
Inflate2.prototype.onData = function(chunk) {
  this.chunks.push(chunk);
};
Inflate2.prototype.onEnd = function(status) {
  if (status === constants.Z_OK) {
    if (this.options.to === "string") {
      this.result = this.chunks.join("");
    } else {
      this.result = common.flattenChunks(this.chunks);
    }
  }
  this.chunks = [];
  this.err = status;
  this.msg = this.strm.msg;
};
function inflate(input, options) {
  var inflator = new Inflate2(options);
  inflator.push(input, true);
  if (inflator.err) {
    throw inflator.msg || messages[inflator.err];
  }
  return inflator.result;
}
function inflateRaw(input, options) {
  options = options || {};
  options.raw = true;
  return inflate(input, options);
}
var Inflate_1 = Inflate2;
var inflate_2 = inflate;
var inflateRaw_1 = inflateRaw;
var ungzip = inflate;
var inflate_1 = {
  Inflate: Inflate_1,
  inflate: inflate_2,
  inflateRaw: inflateRaw_1,
  ungzip
};

// node_modules/cesium/Source/Widgets/ClockViewModel.js
function ClockViewModel(clock) {
  if (!defined_default(clock)) {
    clock = new Clock_default();
  }
  this._clock = clock;
  this._eventHelper = new EventHelper_default();
  this._eventHelper.add(clock.onTick, this.synchronize, this);
  this.systemTime = knockout_default.observable(JulianDate_default.now());
  this.systemTime.equalityComparer = JulianDate_default.equals;
  this.startTime = knockout_default.observable(clock.startTime);
  this.startTime.equalityComparer = JulianDate_default.equals;
  this.startTime.subscribe(function(value) {
    clock.startTime = value;
    this.synchronize();
  }, this);
  this.stopTime = knockout_default.observable(clock.stopTime);
  this.stopTime.equalityComparer = JulianDate_default.equals;
  this.stopTime.subscribe(function(value) {
    clock.stopTime = value;
    this.synchronize();
  }, this);
  this.currentTime = knockout_default.observable(clock.currentTime);
  this.currentTime.equalityComparer = JulianDate_default.equals;
  this.currentTime.subscribe(function(value) {
    clock.currentTime = value;
    this.synchronize();
  }, this);
  this.multiplier = knockout_default.observable(clock.multiplier);
  this.multiplier.subscribe(function(value) {
    clock.multiplier = value;
    this.synchronize();
  }, this);
  this.clockStep = knockout_default.observable(clock.clockStep);
  this.clockStep.subscribe(function(value) {
    clock.clockStep = value;
    this.synchronize();
  }, this);
  this.clockRange = knockout_default.observable(clock.clockRange);
  this.clockRange.subscribe(function(value) {
    clock.clockRange = value;
    this.synchronize();
  }, this);
  this.canAnimate = knockout_default.observable(clock.canAnimate);
  this.canAnimate.subscribe(function(value) {
    clock.canAnimate = value;
    this.synchronize();
  }, this);
  this.shouldAnimate = knockout_default.observable(clock.shouldAnimate);
  this.shouldAnimate.subscribe(function(value) {
    clock.shouldAnimate = value;
    this.synchronize();
  }, this);
  knockout_default.track(this, [
    "systemTime",
    "startTime",
    "stopTime",
    "currentTime",
    "multiplier",
    "clockStep",
    "clockRange",
    "canAnimate",
    "shouldAnimate"
  ]);
}
Object.defineProperties(ClockViewModel.prototype, {
  clock: {
    get: function() {
      return this._clock;
    }
  }
});
ClockViewModel.prototype.synchronize = function() {
  const clock = this._clock;
  this.systemTime = JulianDate_default.now();
  this.startTime = clock.startTime;
  this.stopTime = clock.stopTime;
  this.currentTime = clock.currentTime;
  this.multiplier = clock.multiplier;
  this.clockStep = clock.clockStep;
  this.clockRange = clock.clockRange;
  this.canAnimate = clock.canAnimate;
  this.shouldAnimate = clock.shouldAnimate;
};
ClockViewModel.prototype.isDestroyed = function() {
  return false;
};
ClockViewModel.prototype.destroy = function() {
  this._eventHelper.removeAll();
  destroyObject_default(this);
};
var ClockViewModel_default = ClockViewModel;

// node_modules/cesium/Source/Widgets/Command.js
function Command() {
  this.canExecute = void 0;
  this.beforeExecute = void 0;
  this.afterExecute = void 0;
  DeveloperError_default.throwInstantiationError();
}
var Command_default = Command;

// node_modules/cesium/Source/Widgets/InspectorShared.js
var InspectorShared = {};
InspectorShared.createCheckbox = function(labelText, checkedBinding, enableBinding) {
  Check_default.typeOf.string("labelText", labelText);
  Check_default.typeOf.string("checkedBinding", checkedBinding);
  const checkboxContainer = document.createElement("div");
  const checkboxLabel = document.createElement("label");
  const checkboxInput = document.createElement("input");
  checkboxInput.type = "checkbox";
  let binding = `checked: ${checkedBinding}`;
  if (defined_default(enableBinding)) {
    binding += `, enable: ${enableBinding}`;
  }
  checkboxInput.setAttribute("data-bind", binding);
  checkboxLabel.appendChild(checkboxInput);
  checkboxLabel.appendChild(document.createTextNode(labelText));
  checkboxContainer.appendChild(checkboxLabel);
  return checkboxContainer;
};
InspectorShared.createSection = function(panel, headerText, sectionVisibleBinding, toggleSectionVisibilityBinding) {
  Check_default.defined("panel", panel);
  Check_default.typeOf.string("headerText", headerText);
  Check_default.typeOf.string("sectionVisibleBinding", sectionVisibleBinding);
  Check_default.typeOf.string(
    "toggleSectionVisibilityBinding",
    toggleSectionVisibilityBinding
  );
  const section = document.createElement("div");
  section.className = "cesium-cesiumInspector-section";
  section.setAttribute(
    "data-bind",
    `css: { "cesium-cesiumInspector-section-collapsed": !${sectionVisibleBinding} }`
  );
  panel.appendChild(section);
  const sectionHeader = document.createElement("h3");
  sectionHeader.className = "cesium-cesiumInspector-sectionHeader";
  sectionHeader.appendChild(document.createTextNode(headerText));
  sectionHeader.setAttribute(
    "data-bind",
    `click: ${toggleSectionVisibilityBinding}`
  );
  section.appendChild(sectionHeader);
  const sectionContent = document.createElement("div");
  sectionContent.className = "cesium-cesiumInspector-sectionContent";
  section.appendChild(sectionContent);
  return sectionContent;
};
var InspectorShared_default = InspectorShared;

// node_modules/cesium/Source/Widgets/ToggleButtonViewModel.js
function ToggleButtonViewModel(command, options) {
  if (!defined_default(command)) {
    throw new DeveloperError_default("command is required.");
  }
  this._command = command;
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.toggled = defaultValue_default(options.toggled, false);
  this.tooltip = defaultValue_default(options.tooltip, "");
  knockout_default.track(this, ["toggled", "tooltip"]);
}
Object.defineProperties(ToggleButtonViewModel.prototype, {
  command: {
    get: function() {
      return this._command;
    }
  }
});
var ToggleButtonViewModel_default = ToggleButtonViewModel;

// node_modules/cesium/Source/Widgets/createCommand.js
function createCommand3(func, canExecute) {
  if (!defined_default(func)) {
    throw new DeveloperError_default("func is required.");
  }
  canExecute = defaultValue_default(canExecute, true);
  const beforeExecute = new Event_default();
  const afterExecute = new Event_default();
  function command() {
    if (!command.canExecute) {
      throw new DeveloperError_default("Cannot execute command, canExecute is false.");
    }
    const commandInfo = {
      args: arguments,
      cancel: false
    };
    let result;
    beforeExecute.raiseEvent(commandInfo);
    if (!commandInfo.cancel) {
      result = func.apply(null, arguments);
      afterExecute.raiseEvent(result);
    }
    return result;
  }
  command.canExecute = canExecute;
  knockout_default.track(command, ["canExecute"]);
  Object.defineProperties(command, {
    beforeExecute: {
      value: beforeExecute
    },
    afterExecute: {
      value: afterExecute
    }
  });
  return command;
}
var createCommand_default = createCommand3;

// node_modules/cesium/Source/Widgets/subscribeAndEvaluate.js
function subscribeAndEvaluate(owner, observablePropertyName, callback, target, event) {
  callback.call(target, owner[observablePropertyName]);
  return knockout_default.getObservable(owner, observablePropertyName).subscribe(callback, target, event);
}
var subscribeAndEvaluate_default = subscribeAndEvaluate;

// node_modules/cesium/Source/Scene/ModelExperimental/UniformType.js
var UniformType = {
  FLOAT: "float",
  VEC2: "vec2",
  VEC3: "vec3",
  VEC4: "vec4",
  INT: "int",
  INT_VEC2: "ivec2",
  INT_VEC3: "ivec3",
  INT_VEC4: "ivec4",
  BOOL: "bool",
  BOOL_VEC2: "bvec2",
  BOOL_VEC3: "bvec3",
  BOOL_VEC4: "bvec4",
  MAT2: "mat2",
  MAT3: "mat2",
  MAT4: "mat4",
  SAMPLER_2D: "sampler2D",
  SAMPLER_CUBE: "samplerCube"
};
var UniformType_default = Object.freeze(UniformType);

// node_modules/cesium/Source/Scene/ModelExperimental/TextureManager.js
function TextureManager() {
  this._defaultTexture = void 0;
  this._textures = {};
  this._loadedImages = [];
  this._lastUpdatedFrame = -1;
}
TextureManager.prototype.getTexture = function(textureId) {
  return this._textures[textureId];
};
function fetchTexture2D(textureManager, textureId, textureUniform) {
  textureUniform.resource.fetchImage().then(function(image) {
    textureManager._loadedImages.push({
      id: textureId,
      image,
      textureUniform
    });
  }).catch(function() {
    const texture = textureManager._textures[textureId];
    if (defined_default(texture) && texture !== textureManager._defaultTexture) {
      texture.destroy();
    }
    textureManager._textures[textureId] = textureManager._defaultTexture;
  });
}
TextureManager.prototype.loadTexture2D = function(textureId, textureUniform) {
  if (defined_default(textureUniform.typedArray)) {
    this._loadedImages.push({
      id: textureId,
      textureUniform
    });
  } else {
    fetchTexture2D(this, textureId, textureUniform);
  }
};
function createTexture6(textureManager, loadedImage, context) {
  const id = loadedImage.id;
  const textureUniform = loadedImage.textureUniform;
  const typedArray = textureUniform.typedArray;
  const sampler = textureUniform.sampler;
  let texture;
  if (defined_default(typedArray)) {
    texture = new Texture_default({
      context,
      pixelFormat: textureUniform.pixelFormat,
      pixelDatatype: textureUniform.pixelDatatype,
      source: {
        arrayBufferView: typedArray,
        width: textureUniform.width,
        height: textureUniform.height
      },
      sampler,
      flipY: false
    });
  } else {
    texture = new Texture_default({
      context,
      source: loadedImage.image,
      sampler
    });
  }
  const oldTexture = textureManager._textures[id];
  if (defined_default(oldTexture) && oldTexture !== context.defaultTexture) {
    oldTexture.destroy();
  }
  textureManager._textures[id] = texture;
}
TextureManager.prototype.update = function(frameState) {
  if (frameState.frameNumber === this._lastUpdatedFrame) {
    return;
  }
  this._lastUpdatedFrame = frameState.frameNumber;
  const context = frameState.context;
  this._defaultTexture = context.defaultTexture;
  const loadedImages = this._loadedImages;
  for (let i2 = 0; i2 < loadedImages.length; i2++) {
    const loadedImage = loadedImages[i2];
    createTexture6(this, loadedImage, context);
  }
  loadedImages.length = 0;
};
TextureManager.prototype.isDestroyed = function() {
  return false;
};
TextureManager.prototype.destroy = function() {
  const textures = this._textures;
  for (const texture in textures) {
    if (textures.hasOwnProperty(texture)) {
      const instance = textures[texture];
      if (instance !== this._defaultTexture) {
        instance.destroy();
      }
    }
  }
  return destroyObject_default(this);
};

// node_modules/cesium/Source/Scene/ModelExperimental/CustomShader.js
function CustomShader(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  this.mode = defaultValue_default(options.mode, CustomShaderMode_default.MODIFY_MATERIAL);
  this.lightingModel = options.lightingModel;
  this.uniforms = defaultValue_default(options.uniforms, defaultValue_default.EMPTY_OBJECT);
  this.varyings = defaultValue_default(options.varyings, defaultValue_default.EMPTY_OBJECT);
  this.vertexShaderText = options.vertexShaderText;
  this.fragmentShaderText = options.fragmentShaderText;
  this.isTranslucent = defaultValue_default(options.isTranslucent, false);
  this._textureManager = new TextureManager();
  this._defaultTexture = void 0;
  this.uniformMap = buildUniformMap(this);
  this.usedVariablesVertex = {
    attributeSet: {},
    featureIdSet: {},
    metadataSet: {}
  };
  this.usedVariablesFragment = {
    attributeSet: {},
    featureIdSet: {},
    metadataSet: {},
    materialSet: {}
  };
  findUsedVariables(this);
  validateBuiltinVariables(this);
}
function buildUniformMap(customShader) {
  const uniforms = customShader.uniforms;
  const uniformMap2 = {};
  for (const uniformName in uniforms) {
    if (uniforms.hasOwnProperty(uniformName)) {
      const uniform = uniforms[uniformName];
      const type = uniform.type;
      if (type === UniformType_default.SAMPLER_CUBE) {
        throw new DeveloperError_default(
          "CustomShader does not support samplerCube uniforms"
        );
      }
      if (type === UniformType_default.SAMPLER_2D) {
        customShader._textureManager.loadTexture2D(uniformName, uniform.value);
        uniformMap2[uniformName] = createUniformTexture2DFunction(
          customShader,
          uniformName
        );
      } else {
        uniformMap2[uniformName] = createUniformFunction(
          customShader,
          uniformName
        );
      }
    }
  }
  return uniformMap2;
}
function createUniformTexture2DFunction(customShader, uniformName) {
  return function() {
    return defaultValue_default(
      customShader._textureManager.getTexture(uniformName),
      customShader._defaultTexture
    );
  };
}
function createUniformFunction(customShader, uniformName) {
  return function() {
    return customShader.uniforms[uniformName].value;
  };
}
function getVariables(shaderText, regex, outputSet) {
  let match;
  while ((match = regex.exec(shaderText)) !== null) {
    const variableName = match[1];
    outputSet[variableName] = true;
  }
}
function findUsedVariables(customShader) {
  const attributeRegex = /[vf]sInput\.attributes\.(\w+)/g;
  const featureIdRegex = /[vf]sInput\.featureIds\.(\w+)/g;
  const metadataRegex = /[vf]sInput\.metadata.(\w+)/g;
  let attributeSet;
  const vertexShaderText = customShader.vertexShaderText;
  if (defined_default(vertexShaderText)) {
    attributeSet = customShader.usedVariablesVertex.attributeSet;
    getVariables(vertexShaderText, attributeRegex, attributeSet);
    attributeSet = customShader.usedVariablesVertex.featureIdSet;
    getVariables(vertexShaderText, featureIdRegex, attributeSet);
    attributeSet = customShader.usedVariablesVertex.metadataSet;
    getVariables(vertexShaderText, metadataRegex, attributeSet);
  }
  const fragmentShaderText = customShader.fragmentShaderText;
  if (defined_default(fragmentShaderText)) {
    attributeSet = customShader.usedVariablesFragment.attributeSet;
    getVariables(fragmentShaderText, attributeRegex, attributeSet);
    attributeSet = customShader.usedVariablesFragment.featureIdSet;
    getVariables(fragmentShaderText, featureIdRegex, attributeSet);
    attributeSet = customShader.usedVariablesFragment.metadataSet;
    getVariables(fragmentShaderText, metadataRegex, attributeSet);
    const materialRegex = /material\.(\w+)/g;
    const materialSet = customShader.usedVariablesFragment.materialSet;
    getVariables(fragmentShaderText, materialRegex, materialSet);
  }
}
function expandCoordinateAbbreviations(variableName) {
  const modelCoordinatesRegex = /^.*MC$/;
  const worldCoordinatesRegex = /^.*WC$/;
  const eyeCoordinatesRegex = /^.*EC$/;
  if (modelCoordinatesRegex.test(variableName)) {
    return `${variableName} (model coordinates)`;
  }
  if (worldCoordinatesRegex.test(variableName)) {
    return `${variableName} (Cartesian world coordinates)`;
  }
  if (eyeCoordinatesRegex.test(variableName)) {
    return `${variableName} (eye coordinates)`;
  }
  return variableName;
}
function validateVariableUsage(variableSet, incorrectVariable, correctVariable, vertexOrFragment) {
  if (variableSet.hasOwnProperty(incorrectVariable)) {
    const message = `${expandCoordinateAbbreviations(
      incorrectVariable
    )} is not available in the ${vertexOrFragment} shader. Did you mean ${expandCoordinateAbbreviations(
      correctVariable
    )} instead?`;
    throw new DeveloperError_default(message);
  }
}
function validateBuiltinVariables(customShader) {
  const attributesVS = customShader.usedVariablesVertex.attributeSet;
  validateVariableUsage(attributesVS, "position", "positionMC", "vertex");
  validateVariableUsage(attributesVS, "normal", "normalMC", "vertex");
  validateVariableUsage(attributesVS, "tangent", "tangentMC", "vertex");
  validateVariableUsage(attributesVS, "bitangent", "bitangentMC", "vertex");
  validateVariableUsage(attributesVS, "positionWC", "positionMC", "vertex");
  validateVariableUsage(attributesVS, "positionEC", "positionMC", "vertex");
  validateVariableUsage(attributesVS, "normalEC", "normalMC", "vertex");
  validateVariableUsage(attributesVS, "tangentEC", "tangentMC", "vertex");
  validateVariableUsage(attributesVS, "bitangentEC", "bitangentMC", "vertex");
  const attributesFS = customShader.usedVariablesFragment.attributeSet;
  validateVariableUsage(attributesFS, "position", "positionEC", "fragment");
  validateVariableUsage(attributesFS, "normal", "normalEC", "fragment");
  validateVariableUsage(attributesFS, "tangent", "tangentEC", "fragment");
  validateVariableUsage(attributesFS, "bitangent", "bitangentEC", "fragment");
  validateVariableUsage(attributesFS, "normalMC", "normalEC", "fragment");
  validateVariableUsage(attributesFS, "tangentMC", "tangentEC", "fragment");
  validateVariableUsage(attributesFS, "bitangentMC", "bitangentEC", "fragment");
}
CustomShader.prototype.setUniform = function(uniformName, value) {
  Check_default.typeOf.string("uniformName", uniformName);
  Check_default.defined("value", value);
  if (!defined_default(this.uniforms[uniformName])) {
    throw new DeveloperError_default(
      `Uniform ${uniformName} must be declared in the CustomShader constructor.`
    );
  }
  const uniform = this.uniforms[uniformName];
  if (uniform.type === UniformType_default.SAMPLER_2D) {
    this._textureManager.loadTexture2D(uniformName, value);
  } else if (defined_default(value.clone)) {
    uniform.value = value.clone(uniform.value);
  } else {
    uniform.value = value;
  }
};
CustomShader.prototype.update = function(frameState) {
  this._defaultTexture = frameState.context.defaultTexture;
  this._textureManager.update(frameState);
};
CustomShader.prototype.isDestroyed = function() {
  return false;
};
CustomShader.prototype.destroy = function() {
  this._textureManager = this._textureManager && this._textureManager.destroy();
  destroyObject_default(this);
};

// node_modules/cesium/Source/Scene/ModelExperimental/TextureUniform.js
function TextureUniform(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const hasTypedArray = defined_default(options.typedArray);
  const hasUrl = defined_default(options.url);
  if (hasTypedArray === hasUrl) {
    throw new DeveloperError_default(
      "exactly one of options.typedArray, options.url must be defined"
    );
  }
  if (hasTypedArray && (!defined_default(options.width) || !defined_default(options.height))) {
    throw new DeveloperError_default(
      "options.width and options.height are required when options.typedArray is defined"
    );
  }
  this.typedArray = options.typedArray;
  this.width = options.width;
  this.height = options.height;
  this.pixelFormat = defaultValue_default(options.pixelFormat, PixelFormat_default.RGBA);
  this.pixelDatatype = defaultValue_default(
    options.pixelDatatype,
    PixelDatatype_default.UNSIGNED_BYTE
  );
  let resource = options.url;
  if (typeof resource === "string") {
    resource = Resource_default.createIfNeeded(resource);
  }
  this.resource = resource;
  const repeat = defaultValue_default(options.repeat, true);
  const wrap = repeat ? TextureWrap_default.REPEAT : TextureWrap_default.CLAMP_TO_EDGE;
  this.sampler = new Sampler_default({
    wrapS: wrap,
    wrapT: wrap,
    minificationFilter: options.minificationFilter,
    magnificationFilter: options.magnificationFilter,
    maximumAnisotropy: options.maximumAnisotropy
  });
}

// node_modules/cesium/Source/Scene/ModelExperimental/VaryingType.js
var VaryingType = {
  FLOAT: "float",
  VEC2: "vec2",
  VEC3: "vec3",
  VEC4: "vec4",
  MAT2: "mat2",
  MAT3: "mat2",
  MAT4: "mat4"
};
var VaryingType_default = Object.freeze(VaryingType);

// node_modules/cesium/Source/Shaders/PostProcessStages/DepthViewPacked.js
var DepthViewPacked_default = "uniform sampler2D u_depthTexture;\n\nvarying vec2 v_textureCoordinates;\n\nvoid main()\n{\n    float z_window = czm_unpackDepth(texture2D(u_depthTexture, v_textureCoordinates));\n    z_window = czm_reverseLogDepth(z_window);\n    float n_range = czm_depthRange.near;\n    float f_range = czm_depthRange.far;\n    float z_ndc = (2.0 * z_window - n_range - f_range) / (f_range - n_range);\n    float scale = pow(z_ndc * 0.5 + 0.5, 8.0);\n    gl_FragColor = vec4(mix(vec3(0.0), vec3(1.0), scale), 1.0);\n}\n";

// node_modules/cesium/Source/Widgets/Animation/Animation.js
var svgNS2 = "http://www.w3.org/2000/svg";
var xlinkNS = "http://www.w3.org/1999/xlink";
var widgetForDrag;
var gradientEnabledColor0 = Color_default.fromCssColorString(
  "rgba(247,250,255,0.384)"
);
var gradientEnabledColor1 = Color_default.fromCssColorString(
  "rgba(143,191,255,0.216)"
);
var gradientEnabledColor2 = Color_default.fromCssColorString(
  "rgba(153,197,255,0.098)"
);
var gradientEnabledColor3 = Color_default.fromCssColorString(
  "rgba(255,255,255,0.086)"
);
var gradientDisabledColor0 = Color_default.fromCssColorString(
  "rgba(255,255,255,0.267)"
);
var gradientDisabledColor1 = Color_default.fromCssColorString("rgba(255,255,255,0)");
var gradientKnobColor = Color_default.fromCssColorString("rgba(66,67,68,0.3)");
var gradientPointerColor = Color_default.fromCssColorString("rgba(0,0,0,0.5)");
function getElementColor(element) {
  return Color_default.fromCssColorString(
    window.getComputedStyle(element).getPropertyValue("color")
  );
}
var svgIconsById = {
  animation_pathReset: {
    tagName: "path",
    transform: "translate(16,16) scale(0.85) translate(-16,-16)",
    d: "M24.316,5.318,9.833,13.682,9.833,5.5,5.5,5.5,5.5,25.5,9.833,25.5,9.833,17.318,24.316,25.682z"
  },
  animation_pathPause: {
    tagName: "path",
    transform: "translate(16,16) scale(0.85) translate(-16,-16)",
    d: "M13,5.5,7.5,5.5,7.5,25.5,13,25.5zM24.5,5.5,19,5.5,19,25.5,24.5,25.5z"
  },
  animation_pathPlay: {
    tagName: "path",
    transform: "translate(16,16) scale(0.85) translate(-16,-16)",
    d: "M6.684,25.682L24.316,15.5L6.684,5.318V25.682z"
  },
  animation_pathPlayReverse: {
    tagName: "path",
    transform: "translate(16,16) scale(-0.85,0.85) translate(-16,-16)",
    d: "M6.684,25.682L24.316,15.5L6.684,5.318V25.682z"
  },
  animation_pathLoop: {
    tagName: "path",
    transform: "translate(16,16) scale(0.85) translate(-16,-16)",
    d: "M24.249,15.499c-0.009,4.832-3.918,8.741-8.75,8.75c-2.515,0-4.768-1.064-6.365-2.763l2.068-1.442l-7.901-3.703l0.744,8.694l2.193-1.529c2.244,2.594,5.562,4.242,9.26,4.242c6.767,0,12.249-5.482,12.249-12.249H24.249zM15.499,6.75c2.516,0,4.769,1.065,6.367,2.764l-2.068,1.443l7.901,3.701l-0.746-8.693l-2.192,1.529c-2.245-2.594-5.562-4.245-9.262-4.245C8.734,3.25,3.25,8.734,3.249,15.499H6.75C6.758,10.668,10.668,6.758,15.499,6.75z"
  },
  animation_pathClock: {
    tagName: "path",
    transform: "translate(16,16) scale(0.85) translate(-16,-15.5)",
    d: "M15.5,2.374C8.251,2.375,2.376,8.251,2.374,15.5C2.376,22.748,8.251,28.623,15.5,28.627c7.249-0.004,13.124-5.879,13.125-13.127C28.624,8.251,22.749,2.375,15.5,2.374zM15.5,25.623C9.909,25.615,5.385,21.09,5.375,15.5C5.385,9.909,9.909,5.384,15.5,5.374c5.59,0.01,10.115,4.535,10.124,10.125C25.615,21.09,21.091,25.615,15.5,25.623zM8.625,15.5c-0.001-0.552-0.448-0.999-1.001-1c-0.553,0-1,0.448-1,1c0,0.553,0.449,1,1,1C8.176,16.5,8.624,16.053,8.625,15.5zM8.179,18.572c-0.478,0.277-0.642,0.889-0.365,1.367c0.275,0.479,0.889,0.641,1.365,0.365c0.479-0.275,0.643-0.887,0.367-1.367C9.27,18.461,8.658,18.297,8.179,18.572zM9.18,10.696c-0.479-0.276-1.09-0.112-1.366,0.366s-0.111,1.09,0.365,1.366c0.479,0.276,1.09,0.113,1.367-0.366C9.821,11.584,9.657,10.973,9.18,10.696zM22.822,12.428c0.478-0.275,0.643-0.888,0.366-1.366c-0.275-0.478-0.89-0.642-1.366-0.366c-0.479,0.278-0.642,0.89-0.366,1.367C21.732,12.54,22.344,12.705,22.822,12.428zM12.062,21.455c-0.478-0.275-1.089-0.111-1.366,0.367c-0.275,0.479-0.111,1.09,0.366,1.365c0.478,0.277,1.091,0.111,1.365-0.365C12.704,22.344,12.54,21.732,12.062,21.455zM12.062,9.545c0.479-0.276,0.642-0.888,0.366-1.366c-0.276-0.478-0.888-0.642-1.366-0.366s-0.642,0.888-0.366,1.366C10.973,9.658,11.584,9.822,12.062,9.545zM22.823,18.572c-0.48-0.275-1.092-0.111-1.367,0.365c-0.275,0.479-0.112,1.092,0.367,1.367c0.477,0.275,1.089,0.113,1.365-0.365C23.464,19.461,23.3,18.848,22.823,18.572zM19.938,7.813c-0.477-0.276-1.091-0.111-1.365,0.366c-0.275,0.48-0.111,1.091,0.366,1.367s1.089,0.112,1.366-0.366C20.581,8.702,20.418,8.089,19.938,7.813zM23.378,14.5c-0.554,0.002-1.001,0.45-1.001,1c0.001,0.552,0.448,1,1.001,1c0.551,0,1-0.447,1-1C24.378,14.949,23.929,14.5,23.378,14.5zM15.501,6.624c-0.552,0-1,0.448-1,1l-0.466,7.343l-3.004,1.96c-0.478,0.277-0.642,0.889-0.365,1.365c0.275,0.479,0.889,0.643,1.365,0.367l3.305-1.676C15.39,16.99,15.444,17,15.501,17c0.828,0,1.5-0.671,1.5-1.5l-0.5-7.876C16.501,7.072,16.053,6.624,15.501,6.624zM15.501,22.377c-0.552,0-1,0.447-1,1s0.448,1,1,1s1-0.447,1-1S16.053,22.377,15.501,22.377zM18.939,21.455c-0.479,0.277-0.643,0.889-0.366,1.367c0.275,0.477,0.888,0.643,1.366,0.365c0.478-0.275,0.642-0.889,0.366-1.365C20.028,21.344,19.417,21.18,18.939,21.455z"
  },
  animation_pathWingButton: {
    tagName: "path",
    d: "m 4.5,0.5 c -2.216,0 -4,1.784 -4,4 l 0,24 c 0,2.216 1.784,4 4,4 l 13.71875,0 C 22.478584,27.272785 27.273681,22.511272 32.5,18.25 l 0,-13.75 c 0,-2.216 -1.784,-4 -4,-4 l -24,0 z"
  },
  animation_pathPointer: {
    tagName: "path",
    d: "M-15,-65,-15,-55,15,-55,15,-65,0,-95z"
  },
  animation_pathSwooshFX: {
    tagName: "path",
    d: "m 85,0 c 0,16.617 -4.813944,35.356 -13.131081,48.4508 h 6.099803 c 8.317138,-13.0948 13.13322,-28.5955 13.13322,-45.2124 0,-46.94483 -38.402714,-85.00262 -85.7743869,-85.00262 -1.0218522,0 -2.0373001,0.0241 -3.0506131,0.0589 45.958443,1.59437 82.723058,35.77285 82.723058,81.70532 z"
  }
};
function svgFromObject(obj) {
  const ele = document.createElementNS(svgNS2, obj.tagName);
  for (const field in obj) {
    if (obj.hasOwnProperty(field) && field !== "tagName") {
      if (field === "children") {
        const len = obj.children.length;
        for (let i2 = 0; i2 < len; ++i2) {
          ele.appendChild(svgFromObject(obj.children[i2]));
        }
      } else if (field.indexOf("xlink:") === 0) {
        ele.setAttributeNS(xlinkNS, field.substring(6), obj[field]);
      } else if (field === "textContent") {
        ele.textContent = obj[field];
      } else {
        ele.setAttribute(field, obj[field]);
      }
    }
  }
  return ele;
}
function svgText(x, y, msg) {
  const text2 = document.createElementNS(svgNS2, "text");
  text2.setAttribute("x", x);
  text2.setAttribute("y", y);
  text2.setAttribute("class", "cesium-animation-svgText");
  const tspan = document.createElementNS(svgNS2, "tspan");
  tspan.textContent = msg;
  text2.appendChild(tspan);
  return text2;
}
function setShuttleRingPointer(shuttleRingPointer, knobOuter, angle) {
  shuttleRingPointer.setAttribute(
    "transform",
    `translate(100,100) rotate(${angle})`
  );
  knobOuter.setAttribute("transform", `rotate(${angle})`);
}
var makeColorStringScratch = new Color_default();
function makeColorString(background, gradient) {
  const gradientAlpha = gradient.alpha;
  const backgroundAlpha = 1 - gradientAlpha;
  makeColorStringScratch.red = background.red * backgroundAlpha + gradient.red * gradientAlpha;
  makeColorStringScratch.green = background.green * backgroundAlpha + gradient.green * gradientAlpha;
  makeColorStringScratch.blue = background.blue * backgroundAlpha + gradient.blue * gradientAlpha;
  return makeColorStringScratch.toCssColorString();
}
function rectButton(x, y, path) {
  const iconInfo = svgIconsById[path];
  const button = {
    tagName: "g",
    class: "cesium-animation-rectButton",
    transform: `translate(${x},${y})`,
    children: [
      {
        tagName: "rect",
        class: "cesium-animation-buttonGlow",
        width: 32,
        height: 32,
        rx: 2,
        ry: 2
      },
      {
        tagName: "rect",
        class: "cesium-animation-buttonMain",
        width: 32,
        height: 32,
        rx: 4,
        ry: 4
      },
      {
        class: "cesium-animation-buttonPath",
        id: path,
        tagName: iconInfo.tagName,
        transform: iconInfo.transform,
        d: iconInfo.d
      },
      {
        tagName: "title",
        textContent: ""
      }
    ]
  };
  return svgFromObject(button);
}
function wingButton(x, y, path) {
  const buttonIconInfo = svgIconsById[path];
  const wingIconInfo = svgIconsById["animation_pathWingButton"];
  const button = {
    tagName: "g",
    class: "cesium-animation-rectButton",
    transform: `translate(${x},${y})`,
    children: [
      {
        class: "cesium-animation-buttonGlow",
        id: "animation_pathWingButton",
        tagName: wingIconInfo.tagName,
        d: wingIconInfo.d
      },
      {
        class: "cesium-animation-buttonMain",
        id: "animation_pathWingButton",
        tagName: wingIconInfo.tagName,
        d: wingIconInfo.d
      },
      {
        class: "cesium-animation-buttonPath",
        id: path,
        tagName: buttonIconInfo.tagName,
        transform: buttonIconInfo.transform,
        d: buttonIconInfo.d
      },
      {
        tagName: "title",
        textContent: ""
      }
    ]
  };
  return svgFromObject(button);
}
function setShuttleRingFromMouseOrTouch(widget, e2) {
  const viewModel = widget._viewModel;
  const shuttleRingDragging = viewModel.shuttleRingDragging;
  if (shuttleRingDragging && widgetForDrag !== widget) {
    return;
  }
  if (e2.type === "mousedown" || shuttleRingDragging && e2.type === "mousemove" || e2.type === "touchstart" && e2.touches.length === 1 || shuttleRingDragging && e2.type === "touchmove" && e2.touches.length === 1) {
    const centerX = widget._centerX;
    const centerY = widget._centerY;
    const svg2 = widget._svgNode;
    const rect = svg2.getBoundingClientRect();
    let clientX;
    let clientY;
    if (e2.type === "touchstart" || e2.type === "touchmove") {
      clientX = e2.touches[0].clientX;
      clientY = e2.touches[0].clientY;
    } else {
      clientX = e2.clientX;
      clientY = e2.clientY;
    }
    if (!shuttleRingDragging && (clientX > rect.right || clientX < rect.left || clientY < rect.top || clientY > rect.bottom)) {
      return;
    }
    const pointerRect = widget._shuttleRingPointer.getBoundingClientRect();
    const x = clientX - centerX - rect.left;
    const y = clientY - centerY - rect.top;
    let angle = Math.atan2(y, x) * 180 / Math.PI + 90;
    if (angle > 180) {
      angle -= 360;
    }
    const shuttleRingAngle = viewModel.shuttleRingAngle;
    if (shuttleRingDragging || clientX < pointerRect.right && clientX > pointerRect.left && clientY > pointerRect.top && clientY < pointerRect.bottom) {
      widgetForDrag = widget;
      viewModel.shuttleRingDragging = true;
      viewModel.shuttleRingAngle = angle;
    } else if (angle < shuttleRingAngle) {
      viewModel.slower();
    } else if (angle > shuttleRingAngle) {
      viewModel.faster();
    }
    e2.preventDefault();
  } else {
    if (widget === widgetForDrag) {
      widgetForDrag = void 0;
    }
    viewModel.shuttleRingDragging = false;
  }
}
function SvgButton(svgElement, viewModel) {
  this._viewModel = viewModel;
  this.svgElement = svgElement;
  this._enabled = void 0;
  this._toggled = void 0;
  const that = this;
  this._clickFunction = function() {
    const command = that._viewModel.command;
    if (command.canExecute) {
      command();
    }
  };
  svgElement.addEventListener("click", this._clickFunction, true);
  this._subscriptions = [
    subscribeAndEvaluate_default(viewModel, "toggled", this.setToggled, this),
    subscribeAndEvaluate_default(viewModel, "tooltip", this.setTooltip, this),
    subscribeAndEvaluate_default(
      viewModel.command,
      "canExecute",
      this.setEnabled,
      this
    )
  ];
}
SvgButton.prototype.destroy = function() {
  this.svgElement.removeEventListener("click", this._clickFunction, true);
  const subscriptions = this._subscriptions;
  for (let i2 = 0, len = subscriptions.length; i2 < len; i2++) {
    subscriptions[i2].dispose();
  }
  destroyObject_default(this);
};
SvgButton.prototype.isDestroyed = function() {
  return false;
};
SvgButton.prototype.setEnabled = function(enabled) {
  if (this._enabled !== enabled) {
    this._enabled = enabled;
    if (!enabled) {
      this.svgElement.setAttribute("class", "cesium-animation-buttonDisabled");
      return;
    }
    if (this._toggled) {
      this.svgElement.setAttribute(
        "class",
        "cesium-animation-rectButton cesium-animation-buttonToggled"
      );
      return;
    }
    this.svgElement.setAttribute("class", "cesium-animation-rectButton");
  }
};
SvgButton.prototype.setToggled = function(toggled) {
  if (this._toggled !== toggled) {
    this._toggled = toggled;
    if (this._enabled) {
      if (toggled) {
        this.svgElement.setAttribute(
          "class",
          "cesium-animation-rectButton cesium-animation-buttonToggled"
        );
      } else {
        this.svgElement.setAttribute("class", "cesium-animation-rectButton");
      }
    }
  }
};
SvgButton.prototype.setTooltip = function(tooltip) {
  this.svgElement.getElementsByTagName("title")[0].textContent = tooltip;
};
function Animation3(container, viewModel) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  if (!defined_default(viewModel)) {
    throw new DeveloperError_default("viewModel is required.");
  }
  container = getElement_default(container);
  this._viewModel = viewModel;
  this._container = container;
  this._centerX = 0;
  this._centerY = 0;
  this._defsElement = void 0;
  this._svgNode = void 0;
  this._topG = void 0;
  this._lastHeight = void 0;
  this._lastWidth = void 0;
  const ownerDocument = container.ownerDocument;
  const cssStyle = document.createElement("style");
  cssStyle.textContent = ".cesium-animation-rectButton .cesium-animation-buttonGlow { filter: url(#animation_blurred); }.cesium-animation-rectButton .cesium-animation-buttonMain { fill: url(#animation_buttonNormal); }.cesium-animation-buttonToggled .cesium-animation-buttonMain { fill: url(#animation_buttonToggled); }.cesium-animation-rectButton:hover .cesium-animation-buttonMain { fill: url(#animation_buttonHovered); }.cesium-animation-buttonDisabled .cesium-animation-buttonMain { fill: url(#animation_buttonDisabled); }.cesium-animation-shuttleRingG .cesium-animation-shuttleRingSwoosh { fill: url(#animation_shuttleRingSwooshGradient); }.cesium-animation-shuttleRingG:hover .cesium-animation-shuttleRingSwoosh { fill: url(#animation_shuttleRingSwooshHovered); }.cesium-animation-shuttleRingPointer { fill: url(#animation_shuttleRingPointerGradient); }.cesium-animation-shuttleRingPausePointer { fill: url(#animation_shuttleRingPointerPaused); }.cesium-animation-knobOuter { fill: url(#animation_knobOuter); }.cesium-animation-knobInner { fill: url(#animation_knobInner); }";
  ownerDocument.head.insertBefore(cssStyle, ownerDocument.head.childNodes[0]);
  const themeEle = document.createElement("div");
  themeEle.className = "cesium-animation-theme";
  themeEle.innerHTML = '<div class="cesium-animation-themeNormal"></div><div class="cesium-animation-themeHover"></div><div class="cesium-animation-themeSelect"></div><div class="cesium-animation-themeDisabled"></div><div class="cesium-animation-themeKnob"></div><div class="cesium-animation-themePointer"></div><div class="cesium-animation-themeSwoosh"></div><div class="cesium-animation-themeSwooshHover"></div>';
  this._theme = themeEle;
  this._themeNormal = themeEle.childNodes[0];
  this._themeHover = themeEle.childNodes[1];
  this._themeSelect = themeEle.childNodes[2];
  this._themeDisabled = themeEle.childNodes[3];
  this._themeKnob = themeEle.childNodes[4];
  this._themePointer = themeEle.childNodes[5];
  this._themeSwoosh = themeEle.childNodes[6];
  this._themeSwooshHover = themeEle.childNodes[7];
  const svg2 = document.createElementNS(svgNS2, "svg:svg");
  this._svgNode = svg2;
  svg2.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xlink", xlinkNS);
  const topG = document.createElementNS(svgNS2, "g");
  this._topG = topG;
  this._realtimeSVG = new SvgButton(
    wingButton(3, 4, "animation_pathClock"),
    viewModel.playRealtimeViewModel
  );
  this._playReverseSVG = new SvgButton(
    rectButton(44, 99, "animation_pathPlayReverse"),
    viewModel.playReverseViewModel
  );
  this._playForwardSVG = new SvgButton(
    rectButton(124, 99, "animation_pathPlay"),
    viewModel.playForwardViewModel
  );
  this._pauseSVG = new SvgButton(
    rectButton(84, 99, "animation_pathPause"),
    viewModel.pauseViewModel
  );
  const buttonsG = document.createElementNS(svgNS2, "g");
  buttonsG.appendChild(this._realtimeSVG.svgElement);
  buttonsG.appendChild(this._playReverseSVG.svgElement);
  buttonsG.appendChild(this._playForwardSVG.svgElement);
  buttonsG.appendChild(this._pauseSVG.svgElement);
  const shuttleRingBackPanel = svgFromObject({
    tagName: "circle",
    class: "cesium-animation-shuttleRingBack",
    cx: 100,
    cy: 100,
    r: 99
  });
  this._shuttleRingBackPanel = shuttleRingBackPanel;
  const swooshIconInfo = svgIconsById["animation_pathSwooshFX"];
  const shuttleRingPointerIconInfo = svgIconsById["animation_pathPointer"];
  const shuttleRingSwooshG = svgFromObject({
    tagName: "g",
    class: "cesium-animation-shuttleRingSwoosh",
    children: [
      {
        tagName: swooshIconInfo.tagName,
        transform: "translate(100,97) scale(-1,1)",
        id: "animation_pathSwooshFX",
        d: swooshIconInfo.d
      },
      {
        tagName: swooshIconInfo.tagName,
        transform: "translate(100,97)",
        id: "animation_pathSwooshFX",
        d: swooshIconInfo.d
      },
      {
        tagName: "line",
        x1: 100,
        y1: 8,
        x2: 100,
        y2: 22
      }
    ]
  });
  this._shuttleRingSwooshG = shuttleRingSwooshG;
  this._shuttleRingPointer = svgFromObject({
    class: "cesium-animation-shuttleRingPointer",
    id: "animation_pathPointer",
    tagName: shuttleRingPointerIconInfo.tagName,
    d: shuttleRingPointerIconInfo.d
  });
  const knobG = svgFromObject({
    tagName: "g",
    transform: "translate(100,100)"
  });
  this._knobOuter = svgFromObject({
    tagName: "circle",
    class: "cesium-animation-knobOuter",
    cx: 0,
    cy: 0,
    r: 71
  });
  const knobInnerAndShieldSize = 61;
  const knobInner = svgFromObject({
    tagName: "circle",
    class: "cesium-animation-knobInner",
    cx: 0,
    cy: 0,
    r: knobInnerAndShieldSize
  });
  this._knobDate = svgText(0, -24, "");
  this._knobTime = svgText(0, -7, "");
  this._knobStatus = svgText(0, -41, "");
  const knobShield = svgFromObject({
    tagName: "circle",
    class: "cesium-animation-blank",
    cx: 0,
    cy: 0,
    r: knobInnerAndShieldSize
  });
  const shuttleRingBackG = document.createElementNS(svgNS2, "g");
  shuttleRingBackG.setAttribute("class", "cesium-animation-shuttleRingG");
  container.appendChild(themeEle);
  topG.appendChild(shuttleRingBackG);
  topG.appendChild(knobG);
  topG.appendChild(buttonsG);
  shuttleRingBackG.appendChild(shuttleRingBackPanel);
  shuttleRingBackG.appendChild(shuttleRingSwooshG);
  shuttleRingBackG.appendChild(this._shuttleRingPointer);
  knobG.appendChild(this._knobOuter);
  knobG.appendChild(knobInner);
  knobG.appendChild(this._knobDate);
  knobG.appendChild(this._knobTime);
  knobG.appendChild(this._knobStatus);
  knobG.appendChild(knobShield);
  svg2.appendChild(topG);
  container.appendChild(svg2);
  const that = this;
  function mouseCallback(e2) {
    setShuttleRingFromMouseOrTouch(that, e2);
  }
  this._mouseCallback = mouseCallback;
  shuttleRingBackPanel.addEventListener("mousedown", mouseCallback, true);
  shuttleRingBackPanel.addEventListener("touchstart", mouseCallback, true);
  shuttleRingSwooshG.addEventListener("mousedown", mouseCallback, true);
  shuttleRingSwooshG.addEventListener("touchstart", mouseCallback, true);
  ownerDocument.addEventListener("mousemove", mouseCallback, true);
  ownerDocument.addEventListener("touchmove", mouseCallback, true);
  ownerDocument.addEventListener("mouseup", mouseCallback, true);
  ownerDocument.addEventListener("touchend", mouseCallback, true);
  ownerDocument.addEventListener("touchcancel", mouseCallback, true);
  this._shuttleRingPointer.addEventListener("mousedown", mouseCallback, true);
  this._shuttleRingPointer.addEventListener("touchstart", mouseCallback, true);
  this._knobOuter.addEventListener("mousedown", mouseCallback, true);
  this._knobOuter.addEventListener("touchstart", mouseCallback, true);
  const timeNode = this._knobTime.childNodes[0];
  const dateNode = this._knobDate.childNodes[0];
  const statusNode = this._knobStatus.childNodes[0];
  let isPaused;
  this._subscriptions = [
    subscribeAndEvaluate_default(viewModel.pauseViewModel, "toggled", function(value) {
      if (isPaused !== value) {
        isPaused = value;
        if (isPaused) {
          that._shuttleRingPointer.setAttribute(
            "class",
            "cesium-animation-shuttleRingPausePointer"
          );
        } else {
          that._shuttleRingPointer.setAttribute(
            "class",
            "cesium-animation-shuttleRingPointer"
          );
        }
      }
    }),
    subscribeAndEvaluate_default(viewModel, "shuttleRingAngle", function(value) {
      setShuttleRingPointer(that._shuttleRingPointer, that._knobOuter, value);
    }),
    subscribeAndEvaluate_default(viewModel, "dateLabel", function(value) {
      if (dateNode.textContent !== value) {
        dateNode.textContent = value;
      }
    }),
    subscribeAndEvaluate_default(viewModel, "timeLabel", function(value) {
      if (timeNode.textContent !== value) {
        timeNode.textContent = value;
      }
    }),
    subscribeAndEvaluate_default(viewModel, "multiplierLabel", function(value) {
      if (statusNode.textContent !== value) {
        statusNode.textContent = value;
      }
    })
  ];
  this.applyThemeChanges();
  this.resize();
}
Object.defineProperties(Animation3.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
Animation3.prototype.isDestroyed = function() {
  return false;
};
Animation3.prototype.destroy = function() {
  if (defined_default(this._observer)) {
    this._observer.disconnect();
    this._observer = void 0;
  }
  const doc = this._container.ownerDocument;
  const mouseCallback = this._mouseCallback;
  this._shuttleRingBackPanel.removeEventListener(
    "mousedown",
    mouseCallback,
    true
  );
  this._shuttleRingBackPanel.removeEventListener(
    "touchstart",
    mouseCallback,
    true
  );
  this._shuttleRingSwooshG.removeEventListener(
    "mousedown",
    mouseCallback,
    true
  );
  this._shuttleRingSwooshG.removeEventListener(
    "touchstart",
    mouseCallback,
    true
  );
  doc.removeEventListener("mousemove", mouseCallback, true);
  doc.removeEventListener("touchmove", mouseCallback, true);
  doc.removeEventListener("mouseup", mouseCallback, true);
  doc.removeEventListener("touchend", mouseCallback, true);
  doc.removeEventListener("touchcancel", mouseCallback, true);
  this._shuttleRingPointer.removeEventListener(
    "mousedown",
    mouseCallback,
    true
  );
  this._shuttleRingPointer.removeEventListener(
    "touchstart",
    mouseCallback,
    true
  );
  this._knobOuter.removeEventListener("mousedown", mouseCallback, true);
  this._knobOuter.removeEventListener("touchstart", mouseCallback, true);
  this._container.removeChild(this._svgNode);
  this._container.removeChild(this._theme);
  this._realtimeSVG.destroy();
  this._playReverseSVG.destroy();
  this._playForwardSVG.destroy();
  this._pauseSVG.destroy();
  const subscriptions = this._subscriptions;
  for (let i2 = 0, len = subscriptions.length; i2 < len; i2++) {
    subscriptions[i2].dispose();
  }
  return destroyObject_default(this);
};
Animation3.prototype.resize = function() {
  const parentWidth = this._container.clientWidth;
  const parentHeight = this._container.clientHeight;
  if (parentWidth === this._lastWidth && parentHeight === this._lastHeight) {
    return;
  }
  const svg2 = this._svgNode;
  const baseWidth = 200;
  const baseHeight = 132;
  let width = parentWidth;
  let height = parentHeight;
  if (parentWidth === 0 && parentHeight === 0) {
    width = baseWidth;
    height = baseHeight;
  } else if (parentWidth === 0) {
    height = parentHeight;
    width = baseWidth * (parentHeight / baseHeight);
  } else if (parentHeight === 0) {
    width = parentWidth;
    height = baseHeight * (parentWidth / baseWidth);
  }
  const scaleX = width / baseWidth;
  const scaleY = height / baseHeight;
  svg2.style.cssText = `width: ${width}px; height: ${height}px; position: absolute; bottom: 0; left: 0; overflow: hidden;`;
  svg2.setAttribute("width", width);
  svg2.setAttribute("height", height);
  svg2.setAttribute("viewBox", `0 0 ${width} ${height}`);
  this._topG.setAttribute("transform", `scale(${scaleX},${scaleY})`);
  this._centerX = Math.max(1, 100 * scaleX);
  this._centerY = Math.max(1, 100 * scaleY);
  this._lastHeight = parentWidth;
  this._lastWidth = parentHeight;
};
Animation3.prototype.applyThemeChanges = function() {
  const doc = this._container.ownerDocument;
  if (!doc.body.contains(this._container)) {
    if (defined_default(this._observer)) {
      return;
    }
    const that = this;
    that._observer = new MutationObserver(function() {
      if (doc.body.contains(that._container)) {
        that._observer.disconnect();
        that._observer = void 0;
        that.applyThemeChanges();
      }
    });
    that._observer.observe(doc, { childList: true, subtree: true });
    return;
  }
  const buttonNormalBackColor = getElementColor(this._themeNormal);
  const buttonHoverBackColor = getElementColor(this._themeHover);
  const buttonToggledBackColor = getElementColor(this._themeSelect);
  const buttonDisabledBackColor = getElementColor(this._themeDisabled);
  const knobBackColor = getElementColor(this._themeKnob);
  const pointerColor = getElementColor(this._themePointer);
  const swooshColor = getElementColor(this._themeSwoosh);
  const swooshHoverColor = getElementColor(this._themeSwooshHover);
  const defsElement = svgFromObject({
    tagName: "defs",
    children: [
      {
        id: "animation_buttonNormal",
        tagName: "linearGradient",
        x1: "50%",
        y1: "0%",
        x2: "50%",
        y2: "100%",
        children: [
          {
            tagName: "stop",
            offset: "0%",
            "stop-color": makeColorString(
              buttonNormalBackColor,
              gradientEnabledColor0
            )
          },
          {
            tagName: "stop",
            offset: "12%",
            "stop-color": makeColorString(
              buttonNormalBackColor,
              gradientEnabledColor1
            )
          },
          {
            tagName: "stop",
            offset: "46%",
            "stop-color": makeColorString(
              buttonNormalBackColor,
              gradientEnabledColor2
            )
          },
          {
            tagName: "stop",
            offset: "81%",
            "stop-color": makeColorString(
              buttonNormalBackColor,
              gradientEnabledColor3
            )
          }
        ]
      },
      {
        id: "animation_buttonHovered",
        tagName: "linearGradient",
        x1: "50%",
        y1: "0%",
        x2: "50%",
        y2: "100%",
        children: [
          {
            tagName: "stop",
            offset: "0%",
            "stop-color": makeColorString(
              buttonHoverBackColor,
              gradientEnabledColor0
            )
          },
          {
            tagName: "stop",
            offset: "12%",
            "stop-color": makeColorString(
              buttonHoverBackColor,
              gradientEnabledColor1
            )
          },
          {
            tagName: "stop",
            offset: "46%",
            "stop-color": makeColorString(
              buttonHoverBackColor,
              gradientEnabledColor2
            )
          },
          {
            tagName: "stop",
            offset: "81%",
            "stop-color": makeColorString(
              buttonHoverBackColor,
              gradientEnabledColor3
            )
          }
        ]
      },
      {
        id: "animation_buttonToggled",
        tagName: "linearGradient",
        x1: "50%",
        y1: "0%",
        x2: "50%",
        y2: "100%",
        children: [
          {
            tagName: "stop",
            offset: "0%",
            "stop-color": makeColorString(
              buttonToggledBackColor,
              gradientEnabledColor0
            )
          },
          {
            tagName: "stop",
            offset: "12%",
            "stop-color": makeColorString(
              buttonToggledBackColor,
              gradientEnabledColor1
            )
          },
          {
            tagName: "stop",
            offset: "46%",
            "stop-color": makeColorString(
              buttonToggledBackColor,
              gradientEnabledColor2
            )
          },
          {
            tagName: "stop",
            offset: "81%",
            "stop-color": makeColorString(
              buttonToggledBackColor,
              gradientEnabledColor3
            )
          }
        ]
      },
      {
        id: "animation_buttonDisabled",
        tagName: "linearGradient",
        x1: "50%",
        y1: "0%",
        x2: "50%",
        y2: "100%",
        children: [
          {
            tagName: "stop",
            offset: "0%",
            "stop-color": makeColorString(
              buttonDisabledBackColor,
              gradientDisabledColor0
            )
          },
          {
            tagName: "stop",
            offset: "75%",
            "stop-color": makeColorString(
              buttonDisabledBackColor,
              gradientDisabledColor1
            )
          }
        ]
      },
      {
        id: "animation_blurred",
        tagName: "filter",
        width: "200%",
        height: "200%",
        x: "-50%",
        y: "-50%",
        children: [
          {
            tagName: "feGaussianBlur",
            stdDeviation: 4,
            in: "SourceGraphic"
          }
        ]
      },
      {
        id: "animation_shuttleRingSwooshGradient",
        tagName: "linearGradient",
        x1: "50%",
        y1: "0%",
        x2: "50%",
        y2: "100%",
        children: [
          {
            tagName: "stop",
            offset: "0%",
            "stop-opacity": 0.2,
            "stop-color": swooshColor.toCssColorString()
          },
          {
            tagName: "stop",
            offset: "85%",
            "stop-opacity": 0.85,
            "stop-color": swooshColor.toCssColorString()
          },
          {
            tagName: "stop",
            offset: "95%",
            "stop-opacity": 0.05,
            "stop-color": swooshColor.toCssColorString()
          }
        ]
      },
      {
        id: "animation_shuttleRingSwooshHovered",
        tagName: "linearGradient",
        x1: "50%",
        y1: "0%",
        x2: "50%",
        y2: "100%",
        children: [
          {
            tagName: "stop",
            offset: "0%",
            "stop-opacity": 0.2,
            "stop-color": swooshHoverColor.toCssColorString()
          },
          {
            tagName: "stop",
            offset: "85%",
            "stop-opacity": 0.85,
            "stop-color": swooshHoverColor.toCssColorString()
          },
          {
            tagName: "stop",
            offset: "95%",
            "stop-opacity": 0.05,
            "stop-color": swooshHoverColor.toCssColorString()
          }
        ]
      },
      {
        id: "animation_shuttleRingPointerGradient",
        tagName: "linearGradient",
        x1: "0%",
        y1: "50%",
        x2: "100%",
        y2: "50%",
        children: [
          {
            tagName: "stop",
            offset: "0%",
            "stop-color": pointerColor.toCssColorString()
          },
          {
            tagName: "stop",
            offset: "40%",
            "stop-color": pointerColor.toCssColorString()
          },
          {
            tagName: "stop",
            offset: "60%",
            "stop-color": makeColorString(pointerColor, gradientPointerColor)
          },
          {
            tagName: "stop",
            offset: "100%",
            "stop-color": makeColorString(pointerColor, gradientPointerColor)
          }
        ]
      },
      {
        id: "animation_shuttleRingPointerPaused",
        tagName: "linearGradient",
        x1: "0%",
        y1: "50%",
        x2: "100%",
        y2: "50%",
        children: [
          {
            tagName: "stop",
            offset: "0%",
            "stop-color": "#CCC"
          },
          {
            tagName: "stop",
            offset: "40%",
            "stop-color": "#CCC"
          },
          {
            tagName: "stop",
            offset: "60%",
            "stop-color": "#555"
          },
          {
            tagName: "stop",
            offset: "100%",
            "stop-color": "#555"
          }
        ]
      },
      {
        id: "animation_knobOuter",
        tagName: "linearGradient",
        x1: "20%",
        y1: "0%",
        x2: "90%",
        y2: "100%",
        children: [
          {
            tagName: "stop",
            offset: "5%",
            "stop-color": makeColorString(knobBackColor, gradientEnabledColor0)
          },
          {
            tagName: "stop",
            offset: "60%",
            "stop-color": makeColorString(knobBackColor, gradientKnobColor)
          },
          {
            tagName: "stop",
            offset: "85%",
            "stop-color": makeColorString(knobBackColor, gradientEnabledColor1)
          }
        ]
      },
      {
        id: "animation_knobInner",
        tagName: "linearGradient",
        x1: "20%",
        y1: "0%",
        x2: "90%",
        y2: "100%",
        children: [
          {
            tagName: "stop",
            offset: "5%",
            "stop-color": makeColorString(knobBackColor, gradientKnobColor)
          },
          {
            tagName: "stop",
            offset: "60%",
            "stop-color": makeColorString(knobBackColor, gradientEnabledColor0)
          },
          {
            tagName: "stop",
            offset: "85%",
            "stop-color": makeColorString(knobBackColor, gradientEnabledColor3)
          }
        ]
      }
    ]
  });
  if (!defined_default(this._defsElement)) {
    this._svgNode.appendChild(defsElement);
  } else {
    this._svgNode.replaceChild(defsElement, this._defsElement);
  }
  this._defsElement = defsElement;
};
var Animation_default = Animation3;

// node_modules/cesium/Source/Widgets/Animation/AnimationViewModel.js
var monthNames = [
  "Jan",
  "Feb",
  "Mar",
  "Apr",
  "May",
  "Jun",
  "Jul",
  "Aug",
  "Sep",
  "Oct",
  "Nov",
  "Dec"
];
var realtimeShuttleRingAngle = 15;
var maxShuttleRingAngle = 105;
function numberComparator(left, right) {
  return left - right;
}
function getTypicalMultiplierIndex(multiplier, shuttleRingTicks) {
  const index2 = binarySearch_default(shuttleRingTicks, multiplier, numberComparator);
  return index2 < 0 ? ~index2 : index2;
}
function angleToMultiplier(angle, shuttleRingTicks) {
  if (Math.abs(angle) <= realtimeShuttleRingAngle) {
    return angle / realtimeShuttleRingAngle;
  }
  const minp = realtimeShuttleRingAngle;
  const maxp = maxShuttleRingAngle;
  let maxv;
  const minv = 0;
  let scale;
  if (angle > 0) {
    maxv = Math.log(shuttleRingTicks[shuttleRingTicks.length - 1]);
    scale = (maxv - minv) / (maxp - minp);
    return Math.exp(minv + scale * (angle - minp));
  }
  maxv = Math.log(-shuttleRingTicks[0]);
  scale = (maxv - minv) / (maxp - minp);
  return -Math.exp(minv + scale * (Math.abs(angle) - minp));
}
function multiplierToAngle(multiplier, shuttleRingTicks, clockViewModel) {
  if (clockViewModel.clockStep === ClockStep_default.SYSTEM_CLOCK) {
    return realtimeShuttleRingAngle;
  }
  if (Math.abs(multiplier) <= 1) {
    return multiplier * realtimeShuttleRingAngle;
  }
  const fastedMultipler = shuttleRingTicks[shuttleRingTicks.length - 1];
  if (multiplier > fastedMultipler) {
    multiplier = fastedMultipler;
  } else if (multiplier < -fastedMultipler) {
    multiplier = -fastedMultipler;
  }
  const minp = realtimeShuttleRingAngle;
  const maxp = maxShuttleRingAngle;
  let maxv;
  const minv = 0;
  let scale;
  if (multiplier > 0) {
    maxv = Math.log(fastedMultipler);
    scale = (maxv - minv) / (maxp - minp);
    return (Math.log(multiplier) - minv) / scale + minp;
  }
  maxv = Math.log(-shuttleRingTicks[0]);
  scale = (maxv - minv) / (maxp - minp);
  return -((Math.log(Math.abs(multiplier)) - minv) / scale + minp);
}
function AnimationViewModel(clockViewModel) {
  if (!defined_default(clockViewModel)) {
    throw new DeveloperError_default("clockViewModel is required.");
  }
  const that = this;
  this._clockViewModel = clockViewModel;
  this._allShuttleRingTicks = [];
  this._dateFormatter = AnimationViewModel.defaultDateFormatter;
  this._timeFormatter = AnimationViewModel.defaultTimeFormatter;
  this.shuttleRingDragging = false;
  this.snapToTicks = false;
  knockout_default.track(this, [
    "_allShuttleRingTicks",
    "_dateFormatter",
    "_timeFormatter",
    "shuttleRingDragging",
    "snapToTicks"
  ]);
  this._sortedFilteredPositiveTicks = [];
  this.setShuttleRingTicks(AnimationViewModel.defaultTicks);
  this.timeLabel = void 0;
  knockout_default.defineProperty(this, "timeLabel", function() {
    return that._timeFormatter(that._clockViewModel.currentTime, that);
  });
  this.dateLabel = void 0;
  knockout_default.defineProperty(this, "dateLabel", function() {
    return that._dateFormatter(that._clockViewModel.currentTime, that);
  });
  this.multiplierLabel = void 0;
  knockout_default.defineProperty(this, "multiplierLabel", function() {
    const clockViewModel2 = that._clockViewModel;
    if (clockViewModel2.clockStep === ClockStep_default.SYSTEM_CLOCK) {
      return "Today";
    }
    const multiplier = clockViewModel2.multiplier;
    if (multiplier % 1 === 0) {
      return `${multiplier.toFixed(0)}x`;
    }
    return `${multiplier.toFixed(3).replace(/0{0,3}$/, "")}x`;
  });
  this.shuttleRingAngle = void 0;
  knockout_default.defineProperty(this, "shuttleRingAngle", {
    get: function() {
      return multiplierToAngle(
        clockViewModel.multiplier,
        that._allShuttleRingTicks,
        clockViewModel
      );
    },
    set: function(angle) {
      angle = Math.max(
        Math.min(angle, maxShuttleRingAngle),
        -maxShuttleRingAngle
      );
      const ticks = that._allShuttleRingTicks;
      const clockViewModel2 = that._clockViewModel;
      clockViewModel2.clockStep = ClockStep_default.SYSTEM_CLOCK_MULTIPLIER;
      if (Math.abs(angle) === maxShuttleRingAngle) {
        clockViewModel2.multiplier = angle > 0 ? ticks[ticks.length - 1] : ticks[0];
        return;
      }
      let multiplier = angleToMultiplier(angle, ticks);
      if (that.snapToTicks) {
        multiplier = ticks[getTypicalMultiplierIndex(multiplier, ticks)];
      } else if (multiplier !== 0) {
        const positiveMultiplier = Math.abs(multiplier);
        if (positiveMultiplier > 100) {
          const numDigits = positiveMultiplier.toFixed(0).length - 2;
          const divisor = Math.pow(10, numDigits);
          multiplier = Math.round(multiplier / divisor) * divisor | 0;
        } else if (positiveMultiplier > realtimeShuttleRingAngle) {
          multiplier = Math.round(multiplier);
        } else if (positiveMultiplier > 1) {
          multiplier = +multiplier.toFixed(1);
        } else if (positiveMultiplier > 0) {
          multiplier = +multiplier.toFixed(2);
        }
      }
      clockViewModel2.multiplier = multiplier;
    }
  });
  this._canAnimate = void 0;
  knockout_default.defineProperty(this, "_canAnimate", function() {
    const clockViewModel2 = that._clockViewModel;
    const clockRange = clockViewModel2.clockRange;
    if (that.shuttleRingDragging || clockRange === ClockRange_default.UNBOUNDED) {
      return true;
    }
    const multiplier = clockViewModel2.multiplier;
    const currentTime = clockViewModel2.currentTime;
    const startTime = clockViewModel2.startTime;
    let result = false;
    if (clockRange === ClockRange_default.LOOP_STOP) {
      result = JulianDate_default.greaterThan(currentTime, startTime) || currentTime.equals(startTime) && multiplier > 0;
    } else {
      const stopTime = clockViewModel2.stopTime;
      result = JulianDate_default.greaterThan(currentTime, startTime) && JulianDate_default.lessThan(currentTime, stopTime) || currentTime.equals(startTime) && multiplier > 0 || currentTime.equals(stopTime) && multiplier < 0;
    }
    if (!result) {
      clockViewModel2.shouldAnimate = false;
    }
    return result;
  });
  this._isSystemTimeAvailable = void 0;
  knockout_default.defineProperty(this, "_isSystemTimeAvailable", function() {
    const clockViewModel2 = that._clockViewModel;
    const clockRange = clockViewModel2.clockRange;
    if (clockRange === ClockRange_default.UNBOUNDED) {
      return true;
    }
    const systemTime = clockViewModel2.systemTime;
    return JulianDate_default.greaterThanOrEquals(systemTime, clockViewModel2.startTime) && JulianDate_default.lessThanOrEquals(systemTime, clockViewModel2.stopTime);
  });
  this._isAnimating = void 0;
  knockout_default.defineProperty(this, "_isAnimating", function() {
    return that._clockViewModel.shouldAnimate && (that._canAnimate || that.shuttleRingDragging);
  });
  const pauseCommand = createCommand_default(function() {
    const clockViewModel2 = that._clockViewModel;
    if (clockViewModel2.shouldAnimate) {
      clockViewModel2.shouldAnimate = false;
    } else if (that._canAnimate) {
      clockViewModel2.shouldAnimate = true;
    }
  });
  this._pauseViewModel = new ToggleButtonViewModel_default(pauseCommand, {
    toggled: knockout_default.computed(function() {
      return !that._isAnimating;
    }),
    tooltip: "Pause"
  });
  const playReverseCommand = createCommand_default(function() {
    const clockViewModel2 = that._clockViewModel;
    const multiplier = clockViewModel2.multiplier;
    if (multiplier > 0) {
      clockViewModel2.multiplier = -multiplier;
    }
    clockViewModel2.shouldAnimate = true;
  });
  this._playReverseViewModel = new ToggleButtonViewModel_default(playReverseCommand, {
    toggled: knockout_default.computed(function() {
      return that._isAnimating && clockViewModel.multiplier < 0;
    }),
    tooltip: "Play Reverse"
  });
  const playForwardCommand = createCommand_default(function() {
    const clockViewModel2 = that._clockViewModel;
    const multiplier = clockViewModel2.multiplier;
    if (multiplier < 0) {
      clockViewModel2.multiplier = -multiplier;
    }
    clockViewModel2.shouldAnimate = true;
  });
  this._playForwardViewModel = new ToggleButtonViewModel_default(playForwardCommand, {
    toggled: knockout_default.computed(function() {
      return that._isAnimating && clockViewModel.multiplier > 0 && clockViewModel.clockStep !== ClockStep_default.SYSTEM_CLOCK;
    }),
    tooltip: "Play Forward"
  });
  const playRealtimeCommand = createCommand_default(function() {
    that._clockViewModel.clockStep = ClockStep_default.SYSTEM_CLOCK;
  }, knockout_default.getObservable(this, "_isSystemTimeAvailable"));
  this._playRealtimeViewModel = new ToggleButtonViewModel_default(playRealtimeCommand, {
    toggled: knockout_default.computed(function() {
      return clockViewModel.clockStep === ClockStep_default.SYSTEM_CLOCK;
    }),
    tooltip: knockout_default.computed(function() {
      return that._isSystemTimeAvailable ? "Today (real-time)" : "Current time not in range";
    })
  });
  this._slower = createCommand_default(function() {
    const clockViewModel2 = that._clockViewModel;
    const shuttleRingTicks = that._allShuttleRingTicks;
    const multiplier = clockViewModel2.multiplier;
    const index2 = getTypicalMultiplierIndex(multiplier, shuttleRingTicks) - 1;
    if (index2 >= 0) {
      clockViewModel2.multiplier = shuttleRingTicks[index2];
    }
  });
  this._faster = createCommand_default(function() {
    const clockViewModel2 = that._clockViewModel;
    const shuttleRingTicks = that._allShuttleRingTicks;
    const multiplier = clockViewModel2.multiplier;
    const index2 = getTypicalMultiplierIndex(multiplier, shuttleRingTicks) + 1;
    if (index2 < shuttleRingTicks.length) {
      clockViewModel2.multiplier = shuttleRingTicks[index2];
    }
  });
}
AnimationViewModel.defaultDateFormatter = function(date, viewModel) {
  const gregorianDate = JulianDate_default.toGregorianDate(date);
  return `${monthNames[gregorianDate.month - 1]} ${gregorianDate.day} ${gregorianDate.year}`;
};
AnimationViewModel.defaultTicks = [
  1e-3,
  2e-3,
  5e-3,
  0.01,
  0.02,
  0.05,
  0.1,
  0.25,
  0.5,
  1,
  2,
  5,
  10,
  15,
  30,
  60,
  120,
  300,
  600,
  900,
  1800,
  3600,
  7200,
  14400,
  21600,
  43200,
  86400,
  172800,
  345600,
  604800
];
AnimationViewModel.defaultTimeFormatter = function(date, viewModel) {
  const gregorianDate = JulianDate_default.toGregorianDate(date);
  const millisecond = Math.round(gregorianDate.millisecond);
  if (Math.abs(viewModel._clockViewModel.multiplier) < 1) {
    return `${gregorianDate.hour.toString().padStart(2, "0")}:${gregorianDate.minute.toString().padStart(2, "0")}:${gregorianDate.second.toString().padStart(2, "0")}.${millisecond.toString().padStart(3, "0")}`;
  }
  return `${gregorianDate.hour.toString().padStart(2, "0")}:${gregorianDate.minute.toString().padStart(2, "0")}:${gregorianDate.second.toString().padStart(2, "0")} UTC`;
};
AnimationViewModel.prototype.getShuttleRingTicks = function() {
  return this._sortedFilteredPositiveTicks.slice(0);
};
AnimationViewModel.prototype.setShuttleRingTicks = function(positiveTicks) {
  if (!defined_default(positiveTicks)) {
    throw new DeveloperError_default("positiveTicks is required.");
  }
  let i2;
  let len;
  let tick;
  const hash2 = {};
  const sortedFilteredPositiveTicks = this._sortedFilteredPositiveTicks;
  sortedFilteredPositiveTicks.length = 0;
  for (i2 = 0, len = positiveTicks.length; i2 < len; ++i2) {
    tick = positiveTicks[i2];
    if (!hash2.hasOwnProperty(tick)) {
      hash2[tick] = true;
      sortedFilteredPositiveTicks.push(tick);
    }
  }
  sortedFilteredPositiveTicks.sort(numberComparator);
  const allTicks = [];
  for (len = sortedFilteredPositiveTicks.length, i2 = len - 1; i2 >= 0; --i2) {
    tick = sortedFilteredPositiveTicks[i2];
    if (tick !== 0) {
      allTicks.push(-tick);
    }
  }
  Array.prototype.push.apply(allTicks, sortedFilteredPositiveTicks);
  this._allShuttleRingTicks = allTicks;
};
Object.defineProperties(AnimationViewModel.prototype, {
  slower: {
    get: function() {
      return this._slower;
    }
  },
  faster: {
    get: function() {
      return this._faster;
    }
  },
  clockViewModel: {
    get: function() {
      return this._clockViewModel;
    }
  },
  pauseViewModel: {
    get: function() {
      return this._pauseViewModel;
    }
  },
  playReverseViewModel: {
    get: function() {
      return this._playReverseViewModel;
    }
  },
  playForwardViewModel: {
    get: function() {
      return this._playForwardViewModel;
    }
  },
  playRealtimeViewModel: {
    get: function() {
      return this._playRealtimeViewModel;
    }
  },
  dateFormatter: {
    get: function() {
      return this._dateFormatter;
    },
    set: function(dateFormatter) {
      if (typeof dateFormatter !== "function") {
        throw new DeveloperError_default("dateFormatter must be a function");
      }
      this._dateFormatter = dateFormatter;
    }
  },
  timeFormatter: {
    get: function() {
      return this._timeFormatter;
    },
    set: function(timeFormatter) {
      if (typeof timeFormatter !== "function") {
        throw new DeveloperError_default("timeFormatter must be a function");
      }
      this._timeFormatter = timeFormatter;
    }
  }
});
AnimationViewModel._maxShuttleRingAngle = maxShuttleRingAngle;
AnimationViewModel._realtimeShuttleRingAngle = realtimeShuttleRingAngle;
var AnimationViewModel_default = AnimationViewModel;

// node_modules/cesium/Source/Widgets/BaseLayerPicker/BaseLayerPickerViewModel.js
function BaseLayerPickerViewModel(options) {
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const globe = options.globe;
  const imageryProviderViewModels = defaultValue_default(
    options.imageryProviderViewModels,
    []
  );
  const terrainProviderViewModels = defaultValue_default(
    options.terrainProviderViewModels,
    []
  );
  if (!defined_default(globe)) {
    throw new DeveloperError_default("globe is required");
  }
  this._globe = globe;
  this.imageryProviderViewModels = imageryProviderViewModels.slice(0);
  this.terrainProviderViewModels = terrainProviderViewModels.slice(0);
  this.dropDownVisible = false;
  knockout_default.track(this, [
    "imageryProviderViewModels",
    "terrainProviderViewModels",
    "dropDownVisible"
  ]);
  const imageryObservable = knockout_default.getObservable(
    this,
    "imageryProviderViewModels"
  );
  const imageryProviders = knockout_default.pureComputed(function() {
    const providers = imageryObservable();
    const categories = {};
    let i2;
    for (i2 = 0; i2 < providers.length; i2++) {
      const provider = providers[i2];
      const category = provider.category;
      if (defined_default(categories[category])) {
        categories[category].push(provider);
      } else {
        categories[category] = [provider];
      }
    }
    const allCategoryNames = Object.keys(categories);
    const result = [];
    for (i2 = 0; i2 < allCategoryNames.length; i2++) {
      const name = allCategoryNames[i2];
      result.push({
        name,
        providers: categories[name]
      });
    }
    return result;
  });
  this._imageryProviders = imageryProviders;
  const terrainObservable = knockout_default.getObservable(
    this,
    "terrainProviderViewModels"
  );
  const terrainProviders = knockout_default.pureComputed(function() {
    const providers = terrainObservable();
    const categories = {};
    let i2;
    for (i2 = 0; i2 < providers.length; i2++) {
      const provider = providers[i2];
      const category = provider.category;
      if (defined_default(categories[category])) {
        categories[category].push(provider);
      } else {
        categories[category] = [provider];
      }
    }
    const allCategoryNames = Object.keys(categories);
    const result = [];
    for (i2 = 0; i2 < allCategoryNames.length; i2++) {
      const name = allCategoryNames[i2];
      result.push({
        name,
        providers: categories[name]
      });
    }
    return result;
  });
  this._terrainProviders = terrainProviders;
  this.buttonTooltip = void 0;
  knockout_default.defineProperty(this, "buttonTooltip", function() {
    const selectedImagery = this.selectedImagery;
    const selectedTerrain = this.selectedTerrain;
    const imageryTip = defined_default(selectedImagery) ? selectedImagery.name : void 0;
    const terrainTip = defined_default(selectedTerrain) ? selectedTerrain.name : void 0;
    if (defined_default(imageryTip) && defined_default(terrainTip)) {
      return `${imageryTip}
${terrainTip}`;
    } else if (defined_default(imageryTip)) {
      return imageryTip;
    }
    return terrainTip;
  });
  this.buttonImageUrl = void 0;
  knockout_default.defineProperty(this, "buttonImageUrl", function() {
    const selectedImagery = this.selectedImagery;
    if (defined_default(selectedImagery)) {
      return selectedImagery.iconUrl;
    }
  });
  this.selectedImagery = void 0;
  const selectedImageryViewModel = knockout_default.observable();
  this._currentImageryProviders = [];
  knockout_default.defineProperty(this, "selectedImagery", {
    get: function() {
      return selectedImageryViewModel();
    },
    set: function(value) {
      if (selectedImageryViewModel() === value) {
        this.dropDownVisible = false;
        return;
      }
      let i2;
      const currentImageryProviders = this._currentImageryProviders;
      const currentImageryProvidersLength = currentImageryProviders.length;
      const imageryLayers = this._globe.imageryLayers;
      let hadExistingBaseLayer = false;
      for (i2 = 0; i2 < currentImageryProvidersLength; i2++) {
        const layersLength = imageryLayers.length;
        for (let x = 0; x < layersLength; x++) {
          const layer = imageryLayers.get(x);
          if (layer.imageryProvider === currentImageryProviders[i2]) {
            imageryLayers.remove(layer);
            hadExistingBaseLayer = true;
            break;
          }
        }
      }
      if (defined_default(value)) {
        const newProviders = value.creationCommand();
        if (Array.isArray(newProviders)) {
          const newProvidersLength = newProviders.length;
          for (i2 = newProvidersLength - 1; i2 >= 0; i2--) {
            imageryLayers.addImageryProvider(newProviders[i2], 0);
          }
          this._currentImageryProviders = newProviders.slice(0);
        } else {
          this._currentImageryProviders = [newProviders];
          if (hadExistingBaseLayer) {
            imageryLayers.addImageryProvider(newProviders, 0);
          } else {
            const baseLayer = imageryLayers.get(0);
            if (defined_default(baseLayer)) {
              imageryLayers.remove(baseLayer);
            }
            imageryLayers.addImageryProvider(newProviders, 0);
          }
        }
      }
      selectedImageryViewModel(value);
      this.dropDownVisible = false;
    }
  });
  this.selectedTerrain = void 0;
  const selectedTerrainViewModel = knockout_default.observable();
  knockout_default.defineProperty(this, "selectedTerrain", {
    get: function() {
      return selectedTerrainViewModel();
    },
    set: function(value) {
      if (selectedTerrainViewModel() === value) {
        this.dropDownVisible = false;
        return;
      }
      let newProvider;
      if (defined_default(value)) {
        newProvider = value.creationCommand();
      }
      this._globe.depthTestAgainstTerrain = !(newProvider instanceof EllipsoidTerrainProvider_default);
      this._globe.terrainProvider = newProvider;
      selectedTerrainViewModel(value);
      this.dropDownVisible = false;
    }
  });
  const that = this;
  this._toggleDropDown = createCommand_default(function() {
    that.dropDownVisible = !that.dropDownVisible;
  });
  this.selectedImagery = defaultValue_default(
    options.selectedImageryProviderViewModel,
    imageryProviderViewModels[0]
  );
  this.selectedTerrain = defaultValue_default(
    options.selectedTerrainProviderViewModel,
    terrainProviderViewModels[0]
  );
}
Object.defineProperties(BaseLayerPickerViewModel.prototype, {
  toggleDropDown: {
    get: function() {
      return this._toggleDropDown;
    }
  },
  globe: {
    get: function() {
      return this._globe;
    }
  }
});
var BaseLayerPickerViewModel_default = BaseLayerPickerViewModel;

// node_modules/cesium/Source/Widgets/BaseLayerPicker/BaseLayerPicker.js
function BaseLayerPicker(container, options) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  container = getElement_default(container);
  const viewModel = new BaseLayerPickerViewModel_default(options);
  const element = document.createElement("button");
  element.type = "button";
  element.className = "cesium-button cesium-toolbar-button";
  element.setAttribute(
    "data-bind",
    "attr: { title: buttonTooltip },click: toggleDropDown"
  );
  container.appendChild(element);
  const imgElement = document.createElement("img");
  imgElement.setAttribute("draggable", "false");
  imgElement.className = "cesium-baseLayerPicker-selected";
  imgElement.setAttribute(
    "data-bind",
    "attr: { src: buttonImageUrl }, visible: !!buttonImageUrl"
  );
  element.appendChild(imgElement);
  const dropPanel = document.createElement("div");
  dropPanel.className = "cesium-baseLayerPicker-dropDown";
  dropPanel.setAttribute(
    "data-bind",
    'css: { "cesium-baseLayerPicker-dropDown-visible" : dropDownVisible }'
  );
  container.appendChild(dropPanel);
  const imageryTitle = document.createElement("div");
  imageryTitle.className = "cesium-baseLayerPicker-sectionTitle";
  imageryTitle.setAttribute(
    "data-bind",
    "visible: imageryProviderViewModels.length > 0"
  );
  imageryTitle.innerHTML = "Imagery";
  dropPanel.appendChild(imageryTitle);
  const imagerySection = document.createElement("div");
  imagerySection.className = "cesium-baseLayerPicker-section";
  imagerySection.setAttribute("data-bind", "foreach: _imageryProviders");
  dropPanel.appendChild(imagerySection);
  const imageryCategories = document.createElement("div");
  imageryCategories.className = "cesium-baseLayerPicker-category";
  imagerySection.appendChild(imageryCategories);
  const categoryTitle = document.createElement("div");
  categoryTitle.className = "cesium-baseLayerPicker-categoryTitle";
  categoryTitle.setAttribute("data-bind", "text: name");
  imageryCategories.appendChild(categoryTitle);
  const imageryChoices = document.createElement("div");
  imageryChoices.className = "cesium-baseLayerPicker-choices";
  imageryChoices.setAttribute("data-bind", "foreach: providers");
  imageryCategories.appendChild(imageryChoices);
  const imageryProvider = document.createElement("div");
  imageryProvider.className = "cesium-baseLayerPicker-item";
  imageryProvider.setAttribute(
    "data-bind",
    'css: { "cesium-baseLayerPicker-selectedItem" : $data === $parents[1].selectedImagery },attr: { title: tooltip },visible: creationCommand.canExecute,click: function($data) { $parents[1].selectedImagery = $data; }'
  );
  imageryChoices.appendChild(imageryProvider);
  const providerIcon = document.createElement("img");
  providerIcon.className = "cesium-baseLayerPicker-itemIcon";
  providerIcon.setAttribute("data-bind", "attr: { src: iconUrl }");
  providerIcon.setAttribute("draggable", "false");
  imageryProvider.appendChild(providerIcon);
  const providerLabel = document.createElement("div");
  providerLabel.className = "cesium-baseLayerPicker-itemLabel";
  providerLabel.setAttribute("data-bind", "text: name");
  imageryProvider.appendChild(providerLabel);
  const terrainTitle = document.createElement("div");
  terrainTitle.className = "cesium-baseLayerPicker-sectionTitle";
  terrainTitle.setAttribute(
    "data-bind",
    "visible: terrainProviderViewModels.length > 0"
  );
  terrainTitle.innerHTML = "Terrain";
  dropPanel.appendChild(terrainTitle);
  const terrainSection = document.createElement("div");
  terrainSection.className = "cesium-baseLayerPicker-section";
  terrainSection.setAttribute("data-bind", "foreach: _terrainProviders");
  dropPanel.appendChild(terrainSection);
  const terrainCategories = document.createElement("div");
  terrainCategories.className = "cesium-baseLayerPicker-category";
  terrainSection.appendChild(terrainCategories);
  const terrainCategoryTitle = document.createElement("div");
  terrainCategoryTitle.className = "cesium-baseLayerPicker-categoryTitle";
  terrainCategoryTitle.setAttribute("data-bind", "text: name");
  terrainCategories.appendChild(terrainCategoryTitle);
  const terrainChoices = document.createElement("div");
  terrainChoices.className = "cesium-baseLayerPicker-choices";
  terrainChoices.setAttribute("data-bind", "foreach: providers");
  terrainCategories.appendChild(terrainChoices);
  const terrainProvider = document.createElement("div");
  terrainProvider.className = "cesium-baseLayerPicker-item";
  terrainProvider.setAttribute(
    "data-bind",
    'css: { "cesium-baseLayerPicker-selectedItem" : $data === $parents[1].selectedTerrain },attr: { title: tooltip },visible: creationCommand.canExecute,click: function($data) { $parents[1].selectedTerrain = $data; }'
  );
  terrainChoices.appendChild(terrainProvider);
  const terrainProviderIcon = document.createElement("img");
  terrainProviderIcon.className = "cesium-baseLayerPicker-itemIcon";
  terrainProviderIcon.setAttribute("data-bind", "attr: { src: iconUrl }");
  terrainProviderIcon.setAttribute("draggable", "false");
  terrainProvider.appendChild(terrainProviderIcon);
  const terrainProviderLabel = document.createElement("div");
  terrainProviderLabel.className = "cesium-baseLayerPicker-itemLabel";
  terrainProviderLabel.setAttribute("data-bind", "text: name");
  terrainProvider.appendChild(terrainProviderLabel);
  knockout_default.applyBindings(viewModel, element);
  knockout_default.applyBindings(viewModel, dropPanel);
  this._viewModel = viewModel;
  this._container = container;
  this._element = element;
  this._dropPanel = dropPanel;
  this._closeDropDown = function(e2) {
    if (!(element.contains(e2.target) || dropPanel.contains(e2.target))) {
      viewModel.dropDownVisible = false;
    }
  };
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.addEventListener("pointerdown", this._closeDropDown, true);
  } else {
    document.addEventListener("mousedown", this._closeDropDown, true);
    document.addEventListener("touchstart", this._closeDropDown, true);
  }
}
Object.defineProperties(BaseLayerPicker.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
BaseLayerPicker.prototype.isDestroyed = function() {
  return false;
};
BaseLayerPicker.prototype.destroy = function() {
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.removeEventListener("pointerdown", this._closeDropDown, true);
  } else {
    document.removeEventListener("mousedown", this._closeDropDown, true);
    document.removeEventListener("touchstart", this._closeDropDown, true);
  }
  knockout_default.cleanNode(this._element);
  knockout_default.cleanNode(this._dropPanel);
  this._container.removeChild(this._element);
  this._container.removeChild(this._dropPanel);
  return destroyObject_default(this);
};
var BaseLayerPicker_default = BaseLayerPicker;

// node_modules/cesium/Source/Widgets/BaseLayerPicker/ProviderViewModel.js
function ProviderViewModel(options) {
  if (!defined_default(options.name)) {
    throw new DeveloperError_default("options.name is required.");
  }
  if (!defined_default(options.tooltip)) {
    throw new DeveloperError_default("options.tooltip is required.");
  }
  if (!defined_default(options.iconUrl)) {
    throw new DeveloperError_default("options.iconUrl is required.");
  }
  if (typeof options.creationFunction !== "function") {
    throw new DeveloperError_default("options.creationFunction is required.");
  }
  let creationCommand = options.creationFunction;
  if (!defined_default(creationCommand.canExecute)) {
    creationCommand = createCommand_default(creationCommand);
  }
  this._creationCommand = creationCommand;
  this.name = options.name;
  this.tooltip = options.tooltip;
  this.iconUrl = options.iconUrl;
  this._category = defaultValue_default(options.category, "");
  knockout_default.track(this, ["name", "tooltip", "iconUrl"]);
}
Object.defineProperties(ProviderViewModel.prototype, {
  creationCommand: {
    get: function() {
      return this._creationCommand;
    }
  },
  category: {
    get: function() {
      return this._category;
    }
  }
});
var ProviderViewModel_default = ProviderViewModel;

// node_modules/cesium/Source/Widgets/BaseLayerPicker/createDefaultImageryProviderViewModels.js
function createDefaultImageryProviderViewModels() {
  const providerViewModels = [];
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Bing Maps Aerial",
      iconUrl: buildModuleUrl_default("Widgets/Images/ImageryProviders/bingAerial.png"),
      tooltip: "Bing Maps aerial imagery, provided by Cesium ion",
      category: "Cesium ion",
      creationFunction: function() {
        return createWorldImagery_default({
          style: IonWorldImageryStyle_default.AERIAL
        });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Bing Maps Aerial with Labels",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/ImageryProviders/bingAerialLabels.png"
      ),
      tooltip: "Bing Maps aerial imagery with labels, provided by Cesium ion",
      category: "Cesium ion",
      creationFunction: function() {
        return createWorldImagery_default({
          style: IonWorldImageryStyle_default.AERIAL_WITH_LABELS
        });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Bing Maps Roads",
      iconUrl: buildModuleUrl_default("Widgets/Images/ImageryProviders/bingRoads.png"),
      tooltip: "Bing Maps standard road maps, provided by Cesium ion",
      category: "Cesium ion",
      creationFunction: function() {
        return createWorldImagery_default({
          style: IonWorldImageryStyle_default.ROAD
        });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "ESRI World Imagery",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/ImageryProviders/esriWorldImagery.png"
      ),
      tooltip: "World Imagery provides one meter or better satellite and aerial imagery in many parts of the world and lower resolution satellite imagery worldwide.  The map includes NASA Blue Marble: Next Generation 500m resolution imagery at small scales (above 1:1,000,000), i-cubed 15m eSAT imagery at medium-to-large scales (down to 1:70,000) for the world, and USGS 15m Landsat imagery for Antarctica. The map features 0.3m resolution imagery in the continental United States and 0.6m resolution imagery in parts of Western Europe from DigitalGlobe. In other parts of the world, 1 meter resolution imagery is available from GeoEye IKONOS, i-cubed Nationwide Prime, Getmapping, AeroGRID, IGN Spain, and IGP Portugal.  Additionally, imagery at different resolutions has been contributed by the GIS User Community.\nhttp://www.esri.com",
      category: "Other",
      creationFunction: function() {
        return new ArcGisMapServerImageryProvider_default({
          url: "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer",
          enablePickFeatures: false
        });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "ESRI World Street Map",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/ImageryProviders/esriWorldStreetMap.png"
      ),
      tooltip: "This worldwide street map presents highway-level data for the world. Street-level data includes the United States; much of Canada; Japan; most countries in Europe; Australia and New Zealand; India; parts of South America including Argentina, Brazil, Chile, Colombia, and Venezuela; Ghana; and parts of southern Africa including Botswana, Lesotho, Namibia, South Africa, and Swaziland.\nhttp://www.esri.com",
      category: "Other",
      creationFunction: function() {
        return new ArcGisMapServerImageryProvider_default({
          url: "https://services.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer",
          enablePickFeatures: false
        });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "ESRI National Geographic",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/ImageryProviders/esriNationalGeographic.png"
      ),
      tooltip: "This web map contains the National Geographic World Map service. This map service is designed to be used as a general reference map for informational and educational purposes as well as a basemap by GIS professionals and other users for creating web maps and web mapping applications.\nhttp://www.esri.com",
      category: "Other",
      creationFunction: function() {
        return new ArcGisMapServerImageryProvider_default({
          url: "https://services.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/",
          enablePickFeatures: false
        });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Open\xADStreet\xADMap",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/ImageryProviders/openStreetMap.png"
      ),
      tooltip: "OpenStreetMap (OSM) is a collaborative project to create a free editable map of the world.\nhttp://www.openstreetmap.org",
      category: "Other",
      creationFunction: function() {
        return new OpenStreetMapImageryProvider_default({
          url: "https://a.tile.openstreetmap.org/"
        });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Stamen Watercolor",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/ImageryProviders/stamenWatercolor.png"
      ),
      tooltip: "Reminiscent of hand drawn maps, Stamen watercolor maps apply raster effect area washes and organic edges over a paper texture to add warm pop to any map.\nhttp://maps.stamen.com",
      category: "Other",
      creationFunction: function() {
        return new OpenStreetMapImageryProvider_default({
          url: "https://stamen-tiles.a.ssl.fastly.net/watercolor/",
          credit: "Map tiles by Stamen Design, under CC BY 3.0. Data by OpenStreetMap, under CC BY SA."
        });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Stamen Toner",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/ImageryProviders/stamenToner.png"
      ),
      tooltip: "A high contrast black and white map.\nhttp://maps.stamen.com",
      category: "Other",
      creationFunction: function() {
        return new OpenStreetMapImageryProvider_default({
          url: "https://stamen-tiles.a.ssl.fastly.net/toner/",
          credit: "Map tiles by Stamen Design, under CC BY 3.0. Data by OpenStreetMap, under CC BY SA."
        });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Sentinel-2",
      iconUrl: buildModuleUrl_default("Widgets/Images/ImageryProviders/sentinel-2.png"),
      tooltip: "Sentinel-2 cloudless by EOX IT Services GmbH (Contains modified Copernicus Sentinel data 2016 and 2017).",
      category: "Cesium ion",
      creationFunction: function() {
        return new IonImageryProvider_default({ assetId: 3954 });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Blue Marble",
      iconUrl: buildModuleUrl_default("Widgets/Images/ImageryProviders/blueMarble.png"),
      tooltip: "Blue Marble Next Generation July, 2004 imagery from NASA.",
      category: "Cesium ion",
      creationFunction: function() {
        return new IonImageryProvider_default({ assetId: 3845 });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Earth at night",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/ImageryProviders/earthAtNight.png"
      ),
      tooltip: "The Earth at night, also known as The Black Marble, is a 500 meter resolution global composite imagery layer released by NASA.",
      category: "Cesium ion",
      creationFunction: function() {
        return new IonImageryProvider_default({ assetId: 3812 });
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Natural Earth\xA0II",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/ImageryProviders/naturalEarthII.png"
      ),
      tooltip: "Natural Earth II, darkened for contrast.\nhttp://www.naturalearthdata.com/",
      category: "Cesium ion",
      creationFunction: function() {
        return new TileMapServiceImageryProvider_default({
          url: buildModuleUrl_default("Assets/Textures/NaturalEarthII")
        });
      }
    })
  );
  return providerViewModels;
}
var createDefaultImageryProviderViewModels_default = createDefaultImageryProviderViewModels;

// node_modules/cesium/Source/Widgets/BaseLayerPicker/createDefaultTerrainProviderViewModels.js
function createDefaultTerrainProviderViewModels() {
  const providerViewModels = [];
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "WGS84 Ellipsoid",
      iconUrl: buildModuleUrl_default("Widgets/Images/TerrainProviders/Ellipsoid.png"),
      tooltip: "WGS84 standard ellipsoid, also known as EPSG:4326",
      category: "Cesium ion",
      creationFunction: function() {
        return new EllipsoidTerrainProvider_default();
      }
    })
  );
  providerViewModels.push(
    new ProviderViewModel_default({
      name: "Cesium World Terrain",
      iconUrl: buildModuleUrl_default(
        "Widgets/Images/TerrainProviders/CesiumWorldTerrain.png"
      ),
      tooltip: "High-resolution global terrain tileset curated from several datasources and hosted by Cesium ion",
      category: "Cesium ion",
      creationFunction: function() {
        return createWorldTerrain_default({
          requestWaterMask: true,
          requestVertexNormals: true
        });
      }
    })
  );
  return providerViewModels;
}
var createDefaultTerrainProviderViewModels_default = createDefaultTerrainProviderViewModels;

// node_modules/cesium/Source/Widgets/Cesium3DTilesInspector/Cesium3DTilesInspectorViewModel.js
function getPickTileset(viewModel) {
  return function(e2) {
    const pick = viewModel._scene.pick(e2.position);
    if (defined_default(pick) && pick.primitive instanceof Cesium3DTileset_default) {
      viewModel.tileset = pick.primitive;
    }
    viewModel.pickActive = false;
  };
}
function selectTilesetOnHover(viewModel, value) {
  if (value) {
    viewModel._eventHandler.setInputAction(function(e2) {
      const pick = viewModel._scene.pick(e2.endPosition);
      if (defined_default(pick) && pick.primitive instanceof Cesium3DTileset_default) {
        viewModel.tileset = pick.primitive;
      }
    }, ScreenSpaceEventType_default.MOUSE_MOVE);
  } else {
    viewModel._eventHandler.removeInputAction(ScreenSpaceEventType_default.MOUSE_MOVE);
    viewModel.picking = viewModel.picking;
  }
}
var stringOptions2 = {
  maximumFractionDigits: 3
};
function formatMemoryString2(memorySizeInBytes) {
  const memoryInMegabytes = memorySizeInBytes / 1048576;
  if (memoryInMegabytes < 1) {
    return memoryInMegabytes.toLocaleString(void 0, stringOptions2);
  }
  return Math.round(memoryInMegabytes).toLocaleString();
}
function getStatistics(tileset, isPick) {
  if (!defined_default(tileset)) {
    return "";
  }
  const statistics2 = isPick ? tileset._statisticsPerPass[Cesium3DTilePass_default.PICK] : tileset._statisticsPerPass[Cesium3DTilePass_default.RENDER];
  let s2 = '<ul class="cesium-cesiumInspector-statistics">';
  s2 += `<li><strong>Visited: </strong>${statistics2.visited.toLocaleString()}</li><li><strong>Selected: </strong>${statistics2.selected.toLocaleString()}</li><li><strong>Commands: </strong>${statistics2.numberOfCommands.toLocaleString()}</li>`;
  s2 += "</ul>";
  if (!isPick) {
    s2 += '<ul class="cesium-cesiumInspector-statistics">';
    s2 += `<li><strong>Requests: </strong>${statistics2.numberOfPendingRequests.toLocaleString()}</li><li><strong>Attempted: </strong>${statistics2.numberOfAttemptedRequests.toLocaleString()}</li><li><strong>Processing: </strong>${statistics2.numberOfTilesProcessing.toLocaleString()}</li><li><strong>Content Ready: </strong>${statistics2.numberOfTilesWithContentReady.toLocaleString()}</li><li><strong>Total: </strong>${statistics2.numberOfTilesTotal.toLocaleString()}</li>`;
    s2 += "</ul>";
    s2 += '<ul class="cesium-cesiumInspector-statistics">';
    s2 += `<li><strong>Features Selected: </strong>${statistics2.numberOfFeaturesSelected.toLocaleString()}</li><li><strong>Features Loaded: </strong>${statistics2.numberOfFeaturesLoaded.toLocaleString()}</li><li><strong>Points Selected: </strong>${statistics2.numberOfPointsSelected.toLocaleString()}</li><li><strong>Points Loaded: </strong>${statistics2.numberOfPointsLoaded.toLocaleString()}</li><li><strong>Triangles Selected: </strong>${statistics2.numberOfTrianglesSelected.toLocaleString()}</li>`;
    s2 += "</ul>";
    s2 += '<ul class="cesium-cesiumInspector-statistics">';
    s2 += `<li><strong>Tiles styled: </strong>${statistics2.numberOfTilesStyled.toLocaleString()}</li><li><strong>Features styled: </strong>${statistics2.numberOfFeaturesStyled.toLocaleString()}</li>`;
    s2 += "</ul>";
    s2 += '<ul class="cesium-cesiumInspector-statistics">';
    s2 += `<li><strong>Children Union Culled: </strong>${statistics2.numberOfTilesCulledWithChildrenUnion.toLocaleString()}</li>`;
    s2 += "</ul>";
    s2 += '<ul class="cesium-cesiumInspector-statistics">';
    s2 += `<li><strong>Geometry Memory (MB): </strong>${formatMemoryString2(
      statistics2.geometryByteLength
    )}</li><li><strong>Texture Memory (MB): </strong>${formatMemoryString2(
      statistics2.texturesByteLength
    )}</li><li><strong>Batch Table Memory (MB): </strong>${formatMemoryString2(
      statistics2.batchTableByteLength
    )}</li>`;
    s2 += "</ul>";
  }
  return s2;
}
var colorBlendModes = [
  {
    text: "Highlight",
    value: Cesium3DTileColorBlendMode_default.HIGHLIGHT
  },
  {
    text: "Replace",
    value: Cesium3DTileColorBlendMode_default.REPLACE
  },
  {
    text: "Mix",
    value: Cesium3DTileColorBlendMode_default.MIX
  }
];
var highlightColor2 = new Color_default(1, 1, 0, 0.4);
var scratchColor26 = new Color_default();
var oldColor = new Color_default();
function Cesium3DTilesInspectorViewModel(scene, performanceContainer) {
  Check_default.typeOf.object("scene", scene);
  Check_default.typeOf.object("performanceContainer", performanceContainer);
  const that = this;
  const canvas = scene.canvas;
  this._eventHandler = new ScreenSpaceEventHandler_default(canvas);
  this._scene = scene;
  this._performanceContainer = performanceContainer;
  this._canvas = canvas;
  this._performanceDisplay = new PerformanceDisplay_default({
    container: performanceContainer
  });
  this._statisticsText = "";
  this._pickStatisticsText = "";
  this._editorError = "";
  this.performance = false;
  this.showStatistics = true;
  this.showPickStatistics = true;
  this.inspectorVisible = true;
  this.tilesetVisible = false;
  this.displayVisible = false;
  this.updateVisible = false;
  this.loggingVisible = false;
  this.styleVisible = false;
  this.tileDebugLabelsVisible = false;
  this.optimizationVisible = false;
  this.styleString = "{}";
  this._tileset = void 0;
  this._feature = void 0;
  this._tile = void 0;
  knockout_default.track(this, [
    "performance",
    "inspectorVisible",
    "_statisticsText",
    "_pickStatisticsText",
    "_editorError",
    "showPickStatistics",
    "showStatistics",
    "tilesetVisible",
    "displayVisible",
    "updateVisible",
    "loggingVisible",
    "styleVisible",
    "optimizationVisible",
    "tileDebugLabelsVisible",
    "styleString",
    "_feature",
    "_tile"
  ]);
  this._properties = knockout_default.observable({});
  this.properties = [];
  knockout_default.defineProperty(this, "properties", function() {
    const names = [];
    const properties = that._properties();
    for (const prop in properties) {
      if (properties.hasOwnProperty(prop)) {
        names.push(prop);
      }
    }
    return names;
  });
  const dynamicScreenSpaceError = knockout_default.observable();
  knockout_default.defineProperty(this, "dynamicScreenSpaceError", {
    get: function() {
      return dynamicScreenSpaceError();
    },
    set: function(value) {
      dynamicScreenSpaceError(value);
      if (defined_default(that._tileset)) {
        that._tileset.dynamicScreenSpaceError = value;
      }
    }
  });
  this.dynamicScreenSpaceError = false;
  const colorBlendMode = knockout_default.observable();
  knockout_default.defineProperty(this, "colorBlendMode", {
    get: function() {
      return colorBlendMode();
    },
    set: function(value) {
      colorBlendMode(value);
      if (defined_default(that._tileset)) {
        that._tileset.colorBlendMode = value;
        that._scene.requestRender();
      }
    }
  });
  this.colorBlendMode = Cesium3DTileColorBlendMode_default.HIGHLIGHT;
  const showOnlyPickedTileDebugLabel = knockout_default.observable();
  const picking = knockout_default.observable();
  knockout_default.defineProperty(this, "picking", {
    get: function() {
      return picking();
    },
    set: function(value) {
      picking(value);
      if (value) {
        that._eventHandler.setInputAction(function(e2) {
          const picked = scene.pick(e2.endPosition);
          if (picked instanceof Cesium3DTileFeature_default) {
            that.feature = picked;
            that.tile = picked.content.tile;
          } else if (defined_default(picked) && defined_default(picked.content)) {
            that.feature = void 0;
            that.tile = picked.content.tile;
          } else {
            that.feature = void 0;
            that.tile = void 0;
          }
          if (!defined_default(that._tileset)) {
            return;
          }
          if (showOnlyPickedTileDebugLabel && defined_default(picked) && defined_default(picked.content)) {
            let position;
            if (scene.pickPositionSupported) {
              position = scene.pickPosition(e2.endPosition);
              if (defined_default(position)) {
                that._tileset.debugPickPosition = position;
              }
            }
            that._tileset.debugPickedTile = picked.content.tile;
          } else {
            that._tileset.debugPickedTile = void 0;
          }
          that._scene.requestRender();
        }, ScreenSpaceEventType_default.MOUSE_MOVE);
      } else {
        that.feature = void 0;
        that.tile = void 0;
        that._eventHandler.removeInputAction(ScreenSpaceEventType_default.MOUSE_MOVE);
      }
    }
  });
  this.picking = true;
  const colorize = knockout_default.observable();
  knockout_default.defineProperty(this, "colorize", {
    get: function() {
      return colorize();
    },
    set: function(value) {
      colorize(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugColorizeTiles = value;
        that._scene.requestRender();
      }
    }
  });
  this.colorize = false;
  const wireframe = knockout_default.observable();
  knockout_default.defineProperty(this, "wireframe", {
    get: function() {
      return wireframe();
    },
    set: function(value) {
      wireframe(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugWireframe = value;
        that._scene.requestRender();
      }
    }
  });
  this.wireframe = false;
  const showBoundingVolumes = knockout_default.observable();
  knockout_default.defineProperty(this, "showBoundingVolumes", {
    get: function() {
      return showBoundingVolumes();
    },
    set: function(value) {
      showBoundingVolumes(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugShowBoundingVolume = value;
        that._scene.requestRender();
      }
    }
  });
  this.showBoundingVolumes = false;
  const showContentBoundingVolumes = knockout_default.observable();
  knockout_default.defineProperty(this, "showContentBoundingVolumes", {
    get: function() {
      return showContentBoundingVolumes();
    },
    set: function(value) {
      showContentBoundingVolumes(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugShowContentBoundingVolume = value;
        that._scene.requestRender();
      }
    }
  });
  this.showContentBoundingVolumes = false;
  const showRequestVolumes = knockout_default.observable();
  knockout_default.defineProperty(this, "showRequestVolumes", {
    get: function() {
      return showRequestVolumes();
    },
    set: function(value) {
      showRequestVolumes(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugShowViewerRequestVolume = value;
        that._scene.requestRender();
      }
    }
  });
  this.showRequestVolumes = false;
  const freezeFrame = knockout_default.observable();
  knockout_default.defineProperty(this, "freezeFrame", {
    get: function() {
      return freezeFrame();
    },
    set: function(value) {
      freezeFrame(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugFreezeFrame = value;
        that._scene.debugShowFrustumPlanes = value;
        that._scene.requestRender();
      }
    }
  });
  this.freezeFrame = false;
  knockout_default.defineProperty(this, "showOnlyPickedTileDebugLabel", {
    get: function() {
      return showOnlyPickedTileDebugLabel();
    },
    set: function(value) {
      showOnlyPickedTileDebugLabel(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugPickedTileLabelOnly = value;
        that._scene.requestRender();
      }
    }
  });
  this.showOnlyPickedTileDebugLabel = false;
  const showGeometricError = knockout_default.observable();
  knockout_default.defineProperty(this, "showGeometricError", {
    get: function() {
      return showGeometricError();
    },
    set: function(value) {
      showGeometricError(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugShowGeometricError = value;
        that._scene.requestRender();
      }
    }
  });
  this.showGeometricError = false;
  const showRenderingStatistics = knockout_default.observable();
  knockout_default.defineProperty(this, "showRenderingStatistics", {
    get: function() {
      return showRenderingStatistics();
    },
    set: function(value) {
      showRenderingStatistics(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugShowRenderingStatistics = value;
        that._scene.requestRender();
      }
    }
  });
  this.showRenderingStatistics = false;
  const showMemoryUsage = knockout_default.observable();
  knockout_default.defineProperty(this, "showMemoryUsage", {
    get: function() {
      return showMemoryUsage();
    },
    set: function(value) {
      showMemoryUsage(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugShowMemoryUsage = value;
        that._scene.requestRender();
      }
    }
  });
  this.showMemoryUsage = false;
  const showUrl = knockout_default.observable();
  knockout_default.defineProperty(this, "showUrl", {
    get: function() {
      return showUrl();
    },
    set: function(value) {
      showUrl(value);
      if (defined_default(that._tileset)) {
        that._tileset.debugShowUrl = value;
        that._scene.requestRender();
      }
    }
  });
  this.showUrl = false;
  const maximumScreenSpaceError = knockout_default.observable();
  knockout_default.defineProperty(this, "maximumScreenSpaceError", {
    get: function() {
      return maximumScreenSpaceError();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        maximumScreenSpaceError(value);
        if (defined_default(that._tileset)) {
          that._tileset.maximumScreenSpaceError = value;
        }
      }
    }
  });
  this.maximumScreenSpaceError = 16;
  const dynamicScreenSpaceErrorDensity = knockout_default.observable();
  knockout_default.defineProperty(this, "dynamicScreenSpaceErrorDensity", {
    get: function() {
      return dynamicScreenSpaceErrorDensity();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        dynamicScreenSpaceErrorDensity(value);
        if (defined_default(that._tileset)) {
          that._tileset.dynamicScreenSpaceErrorDensity = value;
        }
      }
    }
  });
  this.dynamicScreenSpaceErrorDensity = 278e-5;
  this.dynamicScreenSpaceErrorDensitySliderValue = void 0;
  knockout_default.defineProperty(this, "dynamicScreenSpaceErrorDensitySliderValue", {
    get: function() {
      return Math.pow(dynamicScreenSpaceErrorDensity(), 1 / 6);
    },
    set: function(value) {
      dynamicScreenSpaceErrorDensity(Math.pow(value, 6));
    }
  });
  const dynamicScreenSpaceErrorFactor = knockout_default.observable();
  knockout_default.defineProperty(this, "dynamicScreenSpaceErrorFactor", {
    get: function() {
      return dynamicScreenSpaceErrorFactor();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        dynamicScreenSpaceErrorFactor(value);
        if (defined_default(that._tileset)) {
          that._tileset.dynamicScreenSpaceErrorFactor = value;
        }
      }
    }
  });
  this.dynamicScreenSpaceErrorFactor = 4;
  const pickTileset = getPickTileset(this);
  const pickActive = knockout_default.observable();
  knockout_default.defineProperty(this, "pickActive", {
    get: function() {
      return pickActive();
    },
    set: function(value) {
      pickActive(value);
      if (value) {
        that._eventHandler.setInputAction(
          pickTileset,
          ScreenSpaceEventType_default.LEFT_CLICK
        );
      } else {
        that._eventHandler.removeInputAction(ScreenSpaceEventType_default.LEFT_CLICK);
      }
    }
  });
  const pointCloudShading = knockout_default.observable();
  knockout_default.defineProperty(this, "pointCloudShading", {
    get: function() {
      return pointCloudShading();
    },
    set: function(value) {
      pointCloudShading(value);
      if (defined_default(that._tileset)) {
        that._tileset.pointCloudShading.attenuation = value;
      }
    }
  });
  this.pointCloudShading = false;
  const geometricErrorScale = knockout_default.observable();
  knockout_default.defineProperty(this, "geometricErrorScale", {
    get: function() {
      return geometricErrorScale();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        geometricErrorScale(value);
        if (defined_default(that._tileset)) {
          that._tileset.pointCloudShading.geometricErrorScale = value;
        }
      }
    }
  });
  this.geometricErrorScale = 1;
  const maximumAttenuation = knockout_default.observable();
  knockout_default.defineProperty(this, "maximumAttenuation", {
    get: function() {
      return maximumAttenuation();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        maximumAttenuation(value);
        if (defined_default(that._tileset)) {
          that._tileset.pointCloudShading.maximumAttenuation = value === 0 ? void 0 : value;
        }
      }
    }
  });
  this.maximumAttenuation = 0;
  const baseResolution = knockout_default.observable();
  knockout_default.defineProperty(this, "baseResolution", {
    get: function() {
      return baseResolution();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        baseResolution(value);
        if (defined_default(that._tileset)) {
          that._tileset.pointCloudShading.baseResolution = value === 0 ? void 0 : value;
        }
      }
    }
  });
  this.baseResolution = 0;
  const eyeDomeLighting = knockout_default.observable();
  knockout_default.defineProperty(this, "eyeDomeLighting", {
    get: function() {
      return eyeDomeLighting();
    },
    set: function(value) {
      eyeDomeLighting(value);
      if (defined_default(that._tileset)) {
        that._tileset.pointCloudShading.eyeDomeLighting = value;
      }
    }
  });
  this.eyeDomeLighting = false;
  const eyeDomeLightingStrength = knockout_default.observable();
  knockout_default.defineProperty(this, "eyeDomeLightingStrength", {
    get: function() {
      return eyeDomeLightingStrength();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        eyeDomeLightingStrength(value);
        if (defined_default(that._tileset)) {
          that._tileset.pointCloudShading.eyeDomeLightingStrength = value;
        }
      }
    }
  });
  this.eyeDomeLightingStrength = 1;
  const eyeDomeLightingRadius = knockout_default.observable();
  knockout_default.defineProperty(this, "eyeDomeLightingRadius", {
    get: function() {
      return eyeDomeLightingRadius();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        eyeDomeLightingRadius(value);
        if (defined_default(that._tileset)) {
          that._tileset.pointCloudShading.eyeDomeLightingRadius = value;
        }
      }
    }
  });
  this.eyeDomeLightingRadius = 1;
  this.pickActive = false;
  const skipLevelOfDetail2 = knockout_default.observable();
  knockout_default.defineProperty(this, "skipLevelOfDetail", {
    get: function() {
      return skipLevelOfDetail2();
    },
    set: function(value) {
      skipLevelOfDetail2(value);
      if (defined_default(that._tileset)) {
        that._tileset.skipLevelOfDetail = value;
      }
    }
  });
  this.skipLevelOfDetail = true;
  const skipScreenSpaceErrorFactor = knockout_default.observable();
  knockout_default.defineProperty(this, "skipScreenSpaceErrorFactor", {
    get: function() {
      return skipScreenSpaceErrorFactor();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        skipScreenSpaceErrorFactor(value);
        if (defined_default(that._tileset)) {
          that._tileset.skipScreenSpaceErrorFactor = value;
        }
      }
    }
  });
  this.skipScreenSpaceErrorFactor = 16;
  const baseScreenSpaceError = knockout_default.observable();
  knockout_default.defineProperty(this, "baseScreenSpaceError", {
    get: function() {
      return baseScreenSpaceError();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        baseScreenSpaceError(value);
        if (defined_default(that._tileset)) {
          that._tileset.baseScreenSpaceError = value;
        }
      }
    }
  });
  this.baseScreenSpaceError = 1024;
  const skipLevels = knockout_default.observable();
  knockout_default.defineProperty(this, "skipLevels", {
    get: function() {
      return skipLevels();
    },
    set: function(value) {
      value = Number(value);
      if (!isNaN(value)) {
        skipLevels(value);
        if (defined_default(that._tileset)) {
          that._tileset.skipLevels = value;
        }
      }
    }
  });
  this.skipLevels = 1;
  const immediatelyLoadDesiredLevelOfDetail = knockout_default.observable();
  knockout_default.defineProperty(this, "immediatelyLoadDesiredLevelOfDetail", {
    get: function() {
      return immediatelyLoadDesiredLevelOfDetail();
    },
    set: function(value) {
      immediatelyLoadDesiredLevelOfDetail(value);
      if (defined_default(that._tileset)) {
        that._tileset.immediatelyLoadDesiredLevelOfDetail = value;
      }
    }
  });
  this.immediatelyLoadDesiredLevelOfDetail = false;
  const loadSiblings = knockout_default.observable();
  knockout_default.defineProperty(this, "loadSiblings", {
    get: function() {
      return loadSiblings();
    },
    set: function(value) {
      loadSiblings(value);
      if (defined_default(that._tileset)) {
        that._tileset.loadSiblings = value;
      }
    }
  });
  this.loadSiblings = false;
  this._style = void 0;
  this._shouldStyle = false;
  this._definedProperties = [
    "properties",
    "dynamicScreenSpaceError",
    "colorBlendMode",
    "picking",
    "colorize",
    "wireframe",
    "showBoundingVolumes",
    "showContentBoundingVolumes",
    "showRequestVolumes",
    "freezeFrame",
    "maximumScreenSpaceError",
    "dynamicScreenSpaceErrorDensity",
    "baseScreenSpaceError",
    "skipScreenSpaceErrorFactor",
    "skipLevelOfDetail",
    "skipLevels",
    "immediatelyLoadDesiredLevelOfDetail",
    "loadSiblings",
    "dynamicScreenSpaceErrorDensitySliderValue",
    "dynamicScreenSpaceErrorFactor",
    "pickActive",
    "showOnlyPickedTileDebugLabel",
    "showGeometricError",
    "showRenderingStatistics",
    "showMemoryUsage",
    "showUrl",
    "pointCloudShading",
    "geometricErrorScale",
    "maximumAttenuation",
    "baseResolution",
    "eyeDomeLighting",
    "eyeDomeLightingStrength",
    "eyeDomeLightingRadius"
  ];
  this._removePostRenderEvent = scene.postRender.addEventListener(function() {
    that._update();
  });
  if (!defined_default(this._tileset)) {
    selectTilesetOnHover(this, true);
  }
}
Object.defineProperties(Cesium3DTilesInspectorViewModel.prototype, {
  scene: {
    get: function() {
      return this._scene;
    }
  },
  performanceContainer: {
    get: function() {
      return this._performanceContainer;
    }
  },
  statisticsText: {
    get: function() {
      return this._statisticsText;
    }
  },
  pickStatisticsText: {
    get: function() {
      return this._pickStatisticsText;
    }
  },
  colorBlendModes: {
    get: function() {
      return colorBlendModes;
    }
  },
  editorError: {
    get: function() {
      return this._editorError;
    }
  },
  tileset: {
    get: function() {
      return this._tileset;
    },
    set: function(tileset) {
      this._tileset = tileset;
      this._style = void 0;
      this.styleString = "{}";
      this.feature = void 0;
      this.tile = void 0;
      if (defined_default(tileset)) {
        const that = this;
        tileset.readyPromise.then(function(t) {
          if (!that.isDestroyed()) {
            that._properties(t.properties);
          }
        });
        const settings = [
          "colorize",
          "wireframe",
          "showBoundingVolumes",
          "showContentBoundingVolumes",
          "showRequestVolumes",
          "freezeFrame",
          "showOnlyPickedTileDebugLabel",
          "showGeometricError",
          "showRenderingStatistics",
          "showMemoryUsage",
          "showUrl"
        ];
        const length3 = settings.length;
        for (let i2 = 0; i2 < length3; ++i2) {
          const setting = settings[i2];
          this[setting] = this[setting];
        }
        this.maximumScreenSpaceError = tileset.maximumScreenSpaceError;
        this.dynamicScreenSpaceError = tileset.dynamicScreenSpaceError;
        this.dynamicScreenSpaceErrorDensity = tileset.dynamicScreenSpaceErrorDensity;
        this.dynamicScreenSpaceErrorFactor = tileset.dynamicScreenSpaceErrorFactor;
        this.colorBlendMode = tileset.colorBlendMode;
        this.skipLevelOfDetail = tileset.skipLevelOfDetail;
        this.skipScreenSpaceErrorFactor = tileset.skipScreenSpaceErrorFactor;
        this.baseScreenSpaceError = tileset.baseScreenSpaceError;
        this.skipLevels = tileset.skipLevels;
        this.immediatelyLoadDesiredLevelOfDetail = tileset.immediatelyLoadDesiredLevelOfDetail;
        this.loadSiblings = tileset.loadSiblings;
        const pointCloudShading = tileset.pointCloudShading;
        this.pointCloudShading = pointCloudShading.attenuation;
        this.geometricErrorScale = pointCloudShading.geometricErrorScale;
        this.maximumAttenuation = pointCloudShading.maximumAttenuation ? pointCloudShading.maximumAttenuation : 0;
        this.baseResolution = pointCloudShading.baseResolution ? pointCloudShading.baseResolution : 0;
        this.eyeDomeLighting = pointCloudShading.eyeDomeLighting;
        this.eyeDomeLightingStrength = pointCloudShading.eyeDomeLightingStrength;
        this.eyeDomeLightingRadius = pointCloudShading.eyeDomeLightingRadius;
        this._scene.requestRender();
      } else {
        this._properties({});
      }
      this._statisticsText = getStatistics(tileset, false);
      this._pickStatisticsText = getStatistics(tileset, true);
      selectTilesetOnHover(this, false);
    }
  },
  feature: {
    get: function() {
      return this._feature;
    },
    set: function(feature2) {
      if (this._feature === feature2) {
        return;
      }
      const currentFeature = this._feature;
      if (defined_default(currentFeature) && !currentFeature.content.isDestroyed()) {
        if (!this.colorize && defined_default(this._style)) {
          currentFeature.color = defined_default(this._style.color) ? this._style.color.evaluateColor(currentFeature, scratchColor26) : Color_default.WHITE;
        } else {
          currentFeature.color = oldColor;
        }
        this._scene.requestRender();
      }
      if (defined_default(feature2)) {
        Color_default.clone(feature2.color, oldColor);
        feature2.color = highlightColor2;
        this._scene.requestRender();
      }
      this._feature = feature2;
    }
  },
  tile: {
    get: function() {
      return this._tile;
    },
    set: function(tile) {
      if (this._tile === tile) {
        return;
      }
      const currentTile = this._tile;
      if (defined_default(currentTile) && !currentTile.isDestroyed() && !hasFeatures(currentTile.content)) {
        currentTile.color = oldColor;
        this._scene.requestRender();
      }
      if (defined_default(tile) && !hasFeatures(tile.content)) {
        Color_default.clone(tile.color, oldColor);
        tile.color = highlightColor2;
        this._scene.requestRender();
      }
      this._tile = tile;
    }
  }
});
function hasFeatures(content) {
  if (content.featuresLength > 0) {
    return true;
  }
  const innerContents = content.innerContents;
  if (defined_default(innerContents)) {
    const length3 = innerContents.length;
    for (let i2 = 0; i2 < length3; ++i2) {
      if (!hasFeatures(innerContents[i2])) {
        return false;
      }
    }
    return true;
  }
  return false;
}
Cesium3DTilesInspectorViewModel.prototype.togglePickTileset = function() {
  this.pickActive = !this.pickActive;
};
Cesium3DTilesInspectorViewModel.prototype.toggleInspector = function() {
  this.inspectorVisible = !this.inspectorVisible;
};
Cesium3DTilesInspectorViewModel.prototype.toggleTileset = function() {
  this.tilesetVisible = !this.tilesetVisible;
};
Cesium3DTilesInspectorViewModel.prototype.toggleDisplay = function() {
  this.displayVisible = !this.displayVisible;
};
Cesium3DTilesInspectorViewModel.prototype.toggleUpdate = function() {
  this.updateVisible = !this.updateVisible;
};
Cesium3DTilesInspectorViewModel.prototype.toggleLogging = function() {
  this.loggingVisible = !this.loggingVisible;
};
Cesium3DTilesInspectorViewModel.prototype.toggleStyle = function() {
  this.styleVisible = !this.styleVisible;
};
Cesium3DTilesInspectorViewModel.prototype.toggleTileDebugLabels = function() {
  this.tileDebugLabelsVisible = !this.tileDebugLabelsVisible;
};
Cesium3DTilesInspectorViewModel.prototype.toggleOptimization = function() {
  this.optimizationVisible = !this.optimizationVisible;
};
Cesium3DTilesInspectorViewModel.prototype.trimTilesCache = function() {
  if (defined_default(this._tileset)) {
    this._tileset.trimLoadedTiles();
  }
};
Cesium3DTilesInspectorViewModel.prototype.compileStyle = function() {
  const tileset = this._tileset;
  if (!defined_default(tileset) || this.styleString === JSON.stringify(tileset.style)) {
    return;
  }
  this._editorError = "";
  try {
    if (this.styleString.length === 0) {
      this.styleString = "{}";
    }
    this._style = new Cesium3DTileStyle_default(JSON.parse(this.styleString));
    this._shouldStyle = true;
    this._scene.requestRender();
  } catch (err) {
    this._editorError = err.toString();
  }
  this.feature = this._feature;
  this.tile = this._tile;
};
Cesium3DTilesInspectorViewModel.prototype.styleEditorKeyPress = function(sender, event) {
  if (event.keyCode === 9) {
    event.preventDefault();
    const textArea = event.target;
    const start = textArea.selectionStart;
    const end = textArea.selectionEnd;
    let newEnd = end;
    const selected = textArea.value.slice(start, end);
    const lines = selected.split("\n");
    const length3 = lines.length;
    let i2;
    if (!event.shiftKey) {
      for (i2 = 0; i2 < length3; ++i2) {
        lines[i2] = `  ${lines[i2]}`;
        newEnd += 2;
      }
    } else {
      for (i2 = 0; i2 < length3; ++i2) {
        if (lines[i2][0] === " ") {
          if (lines[i2][1] === " ") {
            lines[i2] = lines[i2].substr(2);
            newEnd -= 2;
          } else {
            lines[i2] = lines[i2].substr(1);
            newEnd -= 1;
          }
        }
      }
    }
    const newText = lines.join("\n");
    textArea.value = textArea.value.slice(0, start) + newText + textArea.value.slice(end);
    textArea.selectionStart = start !== end ? start : newEnd;
    textArea.selectionEnd = newEnd;
  } else if (event.ctrlKey && (event.keyCode === 10 || event.keyCode === 13)) {
    this.compileStyle();
  }
  return true;
};
Cesium3DTilesInspectorViewModel.prototype._update = function() {
  const tileset = this._tileset;
  if (this.performance) {
    this._performanceDisplay.update();
  }
  if (defined_default(tileset)) {
    if (tileset.isDestroyed()) {
      this.tile = void 0;
      this.feature = void 0;
      this.tileset = void 0;
      return;
    }
    const style = tileset.style;
    if (this._style !== tileset.style) {
      if (this._shouldStyle) {
        tileset.style = this._style;
        this._shouldStyle = false;
      } else {
        this._style = style;
        this.styleString = JSON.stringify(style.style, null, "  ");
      }
    }
  }
  if (this.showStatistics) {
    this._statisticsText = getStatistics(tileset, false);
    this._pickStatisticsText = getStatistics(tileset, true);
  }
};
Cesium3DTilesInspectorViewModel.prototype.isDestroyed = function() {
  return false;
};
Cesium3DTilesInspectorViewModel.prototype.destroy = function() {
  this._eventHandler.destroy();
  this._removePostRenderEvent();
  const that = this;
  this._definedProperties.forEach(function(property) {
    knockout_default.getObservable(that, property).dispose();
  });
  return destroyObject_default(this);
};
Cesium3DTilesInspectorViewModel.getStatistics = getStatistics;
var Cesium3DTilesInspectorViewModel_default = Cesium3DTilesInspectorViewModel;

// node_modules/cesium/Source/Widgets/Cesium3DTilesInspector/Cesium3DTilesInspector.js
function Cesium3DTilesInspector(container, scene) {
  Check_default.defined("container", container);
  Check_default.typeOf.object("scene", scene);
  container = getElement_default(container);
  const element = document.createElement("div");
  const performanceContainer = document.createElement("div");
  performanceContainer.setAttribute("data-bind", "visible: performance");
  const viewModel = new Cesium3DTilesInspectorViewModel_default(
    scene,
    performanceContainer
  );
  this._viewModel = viewModel;
  this._container = container;
  this._element = element;
  const text2 = document.createElement("div");
  text2.textContent = "3D Tiles Inspector";
  text2.className = "cesium-cesiumInspector-button";
  text2.setAttribute("data-bind", "click: toggleInspector");
  element.appendChild(text2);
  element.className = "cesium-cesiumInspector cesium-3DTilesInspector";
  element.setAttribute(
    "data-bind",
    'css: { "cesium-cesiumInspector-visible" : inspectorVisible, "cesium-cesiumInspector-hidden" : !inspectorVisible}'
  );
  container.appendChild(element);
  const panel = document.createElement("div");
  this._panel = panel;
  panel.className = "cesium-cesiumInspector-dropDown";
  element.appendChild(panel);
  const createSection = InspectorShared_default.createSection;
  const createCheckbox = InspectorShared_default.createCheckbox;
  const tilesetPanelContents = createSection(
    panel,
    "Tileset",
    "tilesetVisible",
    "toggleTileset"
  );
  const displayPanelContents = createSection(
    panel,
    "Display",
    "displayVisible",
    "toggleDisplay"
  );
  const updatePanelContents = createSection(
    panel,
    "Update",
    "updateVisible",
    "toggleUpdate"
  );
  const loggingPanelContents = createSection(
    panel,
    "Logging",
    "loggingVisible",
    "toggleLogging"
  );
  const tileDebugLabelsPanelContents = createSection(
    panel,
    "Tile Debug Labels",
    "tileDebugLabelsVisible",
    "toggleTileDebugLabels"
  );
  const stylePanelContents = createSection(
    panel,
    "Style",
    "styleVisible",
    "toggleStyle"
  );
  const optimizationPanelContents = createSection(
    panel,
    "Optimization",
    "optimizationVisible",
    "toggleOptimization"
  );
  const properties = document.createElement("div");
  properties.className = "field-group";
  const propertiesLabel = document.createElement("label");
  propertiesLabel.className = "field-label";
  propertiesLabel.appendChild(document.createTextNode("Properties: "));
  const propertiesField = document.createElement("div");
  propertiesField.setAttribute("data-bind", "text: properties");
  properties.appendChild(propertiesLabel);
  properties.appendChild(propertiesField);
  tilesetPanelContents.appendChild(properties);
  tilesetPanelContents.appendChild(
    makeButton("togglePickTileset", "Pick Tileset", "pickActive")
  );
  tilesetPanelContents.appendChild(
    makeButton("trimTilesCache", "Trim Tiles Cache")
  );
  tilesetPanelContents.appendChild(createCheckbox("Enable Picking", "picking"));
  displayPanelContents.appendChild(createCheckbox("Colorize", "colorize"));
  displayPanelContents.appendChild(createCheckbox("Wireframe", "wireframe"));
  displayPanelContents.appendChild(
    createCheckbox("Bounding Volumes", "showBoundingVolumes")
  );
  displayPanelContents.appendChild(
    createCheckbox("Content Volumes", "showContentBoundingVolumes")
  );
  displayPanelContents.appendChild(
    createCheckbox("Request Volumes", "showRequestVolumes")
  );
  displayPanelContents.appendChild(
    createCheckbox("Point Cloud Shading", "pointCloudShading")
  );
  const pointCloudShadingContainer = document.createElement("div");
  pointCloudShadingContainer.setAttribute(
    "data-bind",
    "visible: pointCloudShading"
  );
  pointCloudShadingContainer.appendChild(
    makeRangeInput("geometricErrorScale", 0, 2, 0.01, "Geometric Error Scale")
  );
  pointCloudShadingContainer.appendChild(
    makeRangeInput("maximumAttenuation", 0, 32, 1, "Maximum Attenuation")
  );
  pointCloudShadingContainer.appendChild(
    makeRangeInput("baseResolution", 0, 1, 0.01, "Base Resolution")
  );
  pointCloudShadingContainer.appendChild(
    createCheckbox("Eye Dome Lighting (EDL)", "eyeDomeLighting")
  );
  displayPanelContents.appendChild(pointCloudShadingContainer);
  const edlContainer = document.createElement("div");
  edlContainer.setAttribute("data-bind", "visible: eyeDomeLighting");
  edlContainer.appendChild(
    makeRangeInput("eyeDomeLightingStrength", 0, 2, 0.1, "EDL Strength")
  );
  edlContainer.appendChild(
    makeRangeInput("eyeDomeLightingRadius", 0, 4, 0.1, "EDL Radius")
  );
  pointCloudShadingContainer.appendChild(edlContainer);
  updatePanelContents.appendChild(
    createCheckbox("Freeze Frame", "freezeFrame")
  );
  updatePanelContents.appendChild(
    createCheckbox("Dynamic Screen Space Error", "dynamicScreenSpaceError")
  );
  const sseContainer = document.createElement("div");
  sseContainer.appendChild(
    makeRangeInput(
      "maximumScreenSpaceError",
      0,
      128,
      1,
      "Maximum Screen Space Error"
    )
  );
  updatePanelContents.appendChild(sseContainer);
  const dynamicScreenSpaceErrorContainer = document.createElement("div");
  dynamicScreenSpaceErrorContainer.setAttribute(
    "data-bind",
    "visible: dynamicScreenSpaceError"
  );
  dynamicScreenSpaceErrorContainer.appendChild(
    makeRangeInput(
      "dynamicScreenSpaceErrorDensitySliderValue",
      0,
      1,
      5e-3,
      "Screen Space Error Density",
      "dynamicScreenSpaceErrorDensity"
    )
  );
  dynamicScreenSpaceErrorContainer.appendChild(
    makeRangeInput(
      "dynamicScreenSpaceErrorFactor",
      1,
      10,
      0.1,
      "Screen Space Error Factor"
    )
  );
  updatePanelContents.appendChild(dynamicScreenSpaceErrorContainer);
  loggingPanelContents.appendChild(
    createCheckbox("Performance", "performance")
  );
  loggingPanelContents.appendChild(performanceContainer);
  loggingPanelContents.appendChild(
    createCheckbox("Statistics", "showStatistics")
  );
  const statistics2 = document.createElement("div");
  statistics2.className = "cesium-3dTilesInspector-statistics";
  statistics2.setAttribute(
    "data-bind",
    "html: statisticsText, visible: showStatistics"
  );
  loggingPanelContents.appendChild(statistics2);
  loggingPanelContents.appendChild(
    createCheckbox("Pick Statistics", "showPickStatistics")
  );
  const pickStatistics = document.createElement("div");
  pickStatistics.className = "cesium-3dTilesInspector-statistics";
  pickStatistics.setAttribute(
    "data-bind",
    "html: pickStatisticsText, visible: showPickStatistics"
  );
  loggingPanelContents.appendChild(pickStatistics);
  const stylePanelEditor = document.createElement("div");
  stylePanelContents.appendChild(stylePanelEditor);
  stylePanelEditor.appendChild(document.createTextNode("Color Blend Mode: "));
  const blendDropdown = document.createElement("select");
  blendDropdown.setAttribute(
    "data-bind",
    'options: colorBlendModes, optionsText: "text", optionsValue: "value", value: colorBlendMode'
  );
  stylePanelEditor.appendChild(blendDropdown);
  const styleEditor = document.createElement("textarea");
  styleEditor.setAttribute(
    "data-bind",
    "textInput: styleString, event: { keydown: styleEditorKeyPress }"
  );
  stylePanelEditor.className = "cesium-cesiumInspector-styleEditor";
  stylePanelEditor.appendChild(styleEditor);
  const closeStylesBtn = makeButton("compileStyle", "Compile (Ctrl+Enter)");
  stylePanelEditor.appendChild(closeStylesBtn);
  const errorBox = document.createElement("div");
  errorBox.className = "cesium-cesiumInspector-error";
  errorBox.setAttribute("data-bind", "text: editorError");
  stylePanelEditor.appendChild(errorBox);
  tileDebugLabelsPanelContents.appendChild(
    createCheckbox("Show Picked Only", "showOnlyPickedTileDebugLabel")
  );
  tileDebugLabelsPanelContents.appendChild(
    createCheckbox("Geometric Error", "showGeometricError")
  );
  tileDebugLabelsPanelContents.appendChild(
    createCheckbox("Rendering Statistics", "showRenderingStatistics")
  );
  tileDebugLabelsPanelContents.appendChild(
    createCheckbox("Memory Usage (MB)", "showMemoryUsage")
  );
  tileDebugLabelsPanelContents.appendChild(createCheckbox("Url", "showUrl"));
  optimizationPanelContents.appendChild(
    createCheckbox("Skip Tile LODs", "skipLevelOfDetail")
  );
  const skipScreenSpaceErrorFactorContainer = document.createElement("div");
  skipScreenSpaceErrorFactorContainer.appendChild(
    makeRangeInput("skipScreenSpaceErrorFactor", 1, 50, 1, "Skip SSE Factor")
  );
  optimizationPanelContents.appendChild(skipScreenSpaceErrorFactorContainer);
  const baseScreenSpaceError = document.createElement("div");
  baseScreenSpaceError.appendChild(
    makeRangeInput(
      "baseScreenSpaceError",
      0,
      4096,
      1,
      "SSE before skipping LOD"
    )
  );
  optimizationPanelContents.appendChild(baseScreenSpaceError);
  const skipLevelsContainer = document.createElement("div");
  skipLevelsContainer.appendChild(
    makeRangeInput("skipLevels", 0, 10, 1, "Min. levels to skip")
  );
  optimizationPanelContents.appendChild(skipLevelsContainer);
  optimizationPanelContents.appendChild(
    createCheckbox(
      "Load only tiles that meet the max SSE.",
      "immediatelyLoadDesiredLevelOfDetail"
    )
  );
  optimizationPanelContents.appendChild(
    createCheckbox("Load siblings of visible tiles", "loadSiblings")
  );
  knockout_default.applyBindings(viewModel, element);
}
Object.defineProperties(Cesium3DTilesInspector.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
Cesium3DTilesInspector.prototype.isDestroyed = function() {
  return false;
};
Cesium3DTilesInspector.prototype.destroy = function() {
  knockout_default.cleanNode(this._element);
  this._container.removeChild(this._element);
  this.viewModel.destroy();
  return destroyObject_default(this);
};
function makeRangeInput(property, min3, max3, step2, text2, displayProperty) {
  displayProperty = defaultValue_default(displayProperty, property);
  const input = document.createElement("input");
  input.setAttribute("data-bind", `value: ${displayProperty}`);
  input.type = "number";
  const slider = document.createElement("input");
  slider.type = "range";
  slider.min = min3;
  slider.max = max3;
  slider.step = step2;
  slider.setAttribute("data-bind", `valueUpdate: "input", value: ${property}`);
  const wrapper = document.createElement("div");
  wrapper.appendChild(slider);
  const container = document.createElement("div");
  container.className = "cesium-cesiumInspector-slider";
  container.appendChild(document.createTextNode(text2));
  container.appendChild(input);
  container.appendChild(wrapper);
  return container;
}
function makeButton(action, text2, active) {
  const button = document.createElement("button");
  button.type = "button";
  button.textContent = text2;
  button.className = "cesium-cesiumInspector-pickButton";
  let binding = `click: ${action}`;
  if (defined_default(active)) {
    binding += `, css: {"cesium-cesiumInspector-pickButtonHighlight" : ${active}}`;
  }
  button.setAttribute("data-bind", binding);
  return button;
}
var Cesium3DTilesInspector_default = Cesium3DTilesInspector;

// node_modules/cesium/Source/Widgets/CesiumInspector/CesiumInspectorViewModel.js
function frustumStatisticsToString(statistics2) {
  let str;
  if (defined_default(statistics2)) {
    str = "Command Statistics";
    const com = statistics2.commandsInFrustums;
    for (const n2 in com) {
      if (com.hasOwnProperty(n2)) {
        let num = parseInt(n2, 10);
        let s2;
        if (num === 7) {
          s2 = "1, 2 and 3";
        } else {
          const f2 = [];
          for (let i2 = 2; i2 >= 0; i2--) {
            const p2 = Math.pow(2, i2);
            if (num >= p2) {
              f2.push(i2 + 1);
              num -= p2;
            }
          }
          s2 = f2.reverse().join(" and ");
        }
        str += `<br>&nbsp;&nbsp;&nbsp;&nbsp;${com[n2]} in frustum ${s2}`;
      }
    }
    str += `<br>Total: ${statistics2.totalCommands}`;
  }
  return str;
}
function boundDepthFrustum(lower, upper, proposed) {
  let bounded = Math.min(proposed, upper);
  bounded = Math.max(bounded, lower);
  return bounded;
}
var scratchPickRay2 = new Ray_default();
var scratchPickCartesian3 = new Cartesian3_default();
function CesiumInspectorViewModel(scene, performanceContainer) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required");
  }
  if (!defined_default(performanceContainer)) {
    throw new DeveloperError_default("performanceContainer is required");
  }
  const that = this;
  const canvas = scene.canvas;
  const eventHandler = new ScreenSpaceEventHandler_default(canvas);
  this._eventHandler = eventHandler;
  this._scene = scene;
  this._canvas = canvas;
  this._primitive = void 0;
  this._tile = void 0;
  this._modelMatrixPrimitive = void 0;
  this._performanceDisplay = void 0;
  this._performanceContainer = performanceContainer;
  const globe = this._scene.globe;
  globe.depthTestAgainstTerrain = true;
  this.frustums = false;
  this.frustumPlanes = false;
  this.performance = false;
  this.shaderCacheText = "";
  this.primitiveBoundingSphere = false;
  this.primitiveReferenceFrame = false;
  this.filterPrimitive = false;
  this.tileBoundingSphere = false;
  this.filterTile = false;
  this.wireframe = false;
  this.depthFrustum = 1;
  this._numberOfFrustums = 1;
  this.suspendUpdates = false;
  this.tileCoordinates = false;
  this.frustumStatisticText = false;
  this.tileText = "";
  this.hasPickedPrimitive = false;
  this.hasPickedTile = false;
  this.pickPrimitiveActive = false;
  this.pickTileActive = false;
  this.dropDownVisible = true;
  this.generalVisible = true;
  this.primitivesVisible = false;
  this.terrainVisible = false;
  this.depthFrustumText = "";
  knockout_default.track(this, [
    "frustums",
    "frustumPlanes",
    "performance",
    "shaderCacheText",
    "primitiveBoundingSphere",
    "primitiveReferenceFrame",
    "filterPrimitive",
    "tileBoundingSphere",
    "filterTile",
    "wireframe",
    "depthFrustum",
    "suspendUpdates",
    "tileCoordinates",
    "frustumStatisticText",
    "tileText",
    "hasPickedPrimitive",
    "hasPickedTile",
    "pickPrimitiveActive",
    "pickTileActive",
    "dropDownVisible",
    "generalVisible",
    "primitivesVisible",
    "terrainVisible",
    "depthFrustumText"
  ]);
  this._toggleDropDown = createCommand_default(function() {
    that.dropDownVisible = !that.dropDownVisible;
  });
  this._toggleGeneral = createCommand_default(function() {
    that.generalVisible = !that.generalVisible;
  });
  this._togglePrimitives = createCommand_default(function() {
    that.primitivesVisible = !that.primitivesVisible;
  });
  this._toggleTerrain = createCommand_default(function() {
    that.terrainVisible = !that.terrainVisible;
  });
  this._frustumsSubscription = knockout_default.getObservable(this, "frustums").subscribe(function(val) {
    that._scene.debugShowFrustums = val;
    that._scene.requestRender();
  });
  this._frustumPlanesSubscription = knockout_default.getObservable(this, "frustumPlanes").subscribe(function(val) {
    that._scene.debugShowFrustumPlanes = val;
    that._scene.requestRender();
  });
  this._performanceSubscription = knockout_default.getObservable(this, "performance").subscribe(function(val) {
    if (val) {
      that._performanceDisplay = new PerformanceDisplay_default({
        container: that._performanceContainer
      });
    } else {
      that._performanceContainer.innerHTML = "";
    }
  });
  this._showPrimitiveBoundingSphere = createCommand_default(function() {
    that._primitive.debugShowBoundingVolume = that.primitiveBoundingSphere;
    that._scene.requestRender();
    return true;
  });
  this._primitiveBoundingSphereSubscription = knockout_default.getObservable(this, "primitiveBoundingSphere").subscribe(function() {
    that._showPrimitiveBoundingSphere();
  });
  this._showPrimitiveReferenceFrame = createCommand_default(function() {
    if (that.primitiveReferenceFrame) {
      const modelMatrix = that._primitive.modelMatrix;
      that._modelMatrixPrimitive = new DebugModelMatrixPrimitive_default({
        modelMatrix
      });
      that._scene.primitives.add(that._modelMatrixPrimitive);
    } else if (defined_default(that._modelMatrixPrimitive)) {
      that._scene.primitives.remove(that._modelMatrixPrimitive);
      that._modelMatrixPrimitive = void 0;
    }
    that._scene.requestRender();
    return true;
  });
  this._primitiveReferenceFrameSubscription = knockout_default.getObservable(this, "primitiveReferenceFrame").subscribe(function() {
    that._showPrimitiveReferenceFrame();
  });
  this._doFilterPrimitive = createCommand_default(function() {
    if (that.filterPrimitive) {
      that._scene.debugCommandFilter = function(command) {
        if (defined_default(that._modelMatrixPrimitive) && command.owner === that._modelMatrixPrimitive._primitive) {
          return true;
        } else if (defined_default(that._primitive)) {
          return command.owner === that._primitive || command.owner === that._primitive._billboardCollection || command.owner.primitive === that._primitive;
        }
        return false;
      };
    } else {
      that._scene.debugCommandFilter = void 0;
    }
    return true;
  });
  this._filterPrimitiveSubscription = knockout_default.getObservable(this, "filterPrimitive").subscribe(function() {
    that._doFilterPrimitive();
    that._scene.requestRender();
  });
  this._wireframeSubscription = knockout_default.getObservable(this, "wireframe").subscribe(function(val) {
    globe._surface.tileProvider._debug.wireframe = val;
    that._scene.requestRender();
  });
  this._depthFrustumSubscription = knockout_default.getObservable(this, "depthFrustum").subscribe(function(val) {
    that._scene.debugShowDepthFrustum = val;
    that._scene.requestRender();
  });
  this._incrementDepthFrustum = createCommand_default(function() {
    const next = that.depthFrustum + 1;
    that.depthFrustum = boundDepthFrustum(1, that._numberOfFrustums, next);
    that._scene.requestRender();
    return true;
  });
  this._decrementDepthFrustum = createCommand_default(function() {
    const next = that.depthFrustum - 1;
    that.depthFrustum = boundDepthFrustum(1, that._numberOfFrustums, next);
    that._scene.requestRender();
    return true;
  });
  this._suspendUpdatesSubscription = knockout_default.getObservable(this, "suspendUpdates").subscribe(function(val) {
    globe._surface._debug.suspendLodUpdate = val;
    if (!val) {
      that.filterTile = false;
    }
  });
  let tileBoundariesLayer;
  this._showTileCoordinates = createCommand_default(function() {
    if (that.tileCoordinates && !defined_default(tileBoundariesLayer)) {
      tileBoundariesLayer = scene.imageryLayers.addImageryProvider(
        new TileCoordinatesImageryProvider_default({
          tilingScheme: scene.terrainProvider.tilingScheme
        })
      );
    } else if (!that.tileCoordinates && defined_default(tileBoundariesLayer)) {
      scene.imageryLayers.remove(tileBoundariesLayer);
      tileBoundariesLayer = void 0;
    }
    return true;
  });
  this._tileCoordinatesSubscription = knockout_default.getObservable(this, "tileCoordinates").subscribe(function() {
    that._showTileCoordinates();
    that._scene.requestRender();
  });
  this._tileBoundingSphereSubscription = knockout_default.getObservable(this, "tileBoundingSphere").subscribe(function() {
    that._showTileBoundingSphere();
    that._scene.requestRender();
  });
  this._showTileBoundingSphere = createCommand_default(function() {
    if (that.tileBoundingSphere) {
      globe._surface.tileProvider._debug.boundingSphereTile = that._tile;
    } else {
      globe._surface.tileProvider._debug.boundingSphereTile = void 0;
    }
    that._scene.requestRender();
    return true;
  });
  this._doFilterTile = createCommand_default(function() {
    if (!that.filterTile) {
      that.suspendUpdates = false;
    } else {
      that.suspendUpdates = true;
      globe._surface._tilesToRender = [];
      if (defined_default(that._tile) && that._tile.renderable) {
        globe._surface._tilesToRender.push(that._tile);
      }
    }
    return true;
  });
  this._filterTileSubscription = knockout_default.getObservable(this, "filterTile").subscribe(function() {
    that.doFilterTile();
    that._scene.requestRender();
  });
  function pickPrimitive(e2) {
    const newPick = that._scene.pick({
      x: e2.position.x,
      y: e2.position.y
    });
    if (defined_default(newPick)) {
      that.primitive = defined_default(newPick.collection) ? newPick.collection : newPick.primitive;
    }
    that._scene.requestRender();
    that.pickPrimitiveActive = false;
  }
  this._pickPrimitive = createCommand_default(function() {
    that.pickPrimitiveActive = !that.pickPrimitiveActive;
  });
  this._pickPrimitiveActiveSubscription = knockout_default.getObservable(this, "pickPrimitiveActive").subscribe(function(val) {
    if (val) {
      eventHandler.setInputAction(
        pickPrimitive,
        ScreenSpaceEventType_default.LEFT_CLICK
      );
    } else {
      eventHandler.removeInputAction(ScreenSpaceEventType_default.LEFT_CLICK);
    }
  });
  function selectTile2(e2) {
    let selectedTile;
    const ellipsoid = globe.ellipsoid;
    const ray = that._scene.camera.getPickRay(e2.position, scratchPickRay2);
    const cartesian11 = globe.pick(ray, that._scene, scratchPickCartesian3);
    if (defined_default(cartesian11)) {
      const cartographic2 = ellipsoid.cartesianToCartographic(cartesian11);
      const tilesRendered = globe._surface.tileProvider._tilesToRenderByTextureCount;
      for (let textureCount = 0; !selectedTile && textureCount < tilesRendered.length; ++textureCount) {
        const tilesRenderedByTextureCount = tilesRendered[textureCount];
        if (!defined_default(tilesRenderedByTextureCount)) {
          continue;
        }
        for (let tileIndex = 0; !selectedTile && tileIndex < tilesRenderedByTextureCount.length; ++tileIndex) {
          const tile = tilesRenderedByTextureCount[tileIndex];
          if (Rectangle_default.contains(tile.rectangle, cartographic2)) {
            selectedTile = tile;
          }
        }
      }
    }
    that.tile = selectedTile;
    that.pickTileActive = false;
  }
  this._pickTile = createCommand_default(function() {
    that.pickTileActive = !that.pickTileActive;
  });
  this._pickTileActiveSubscription = knockout_default.getObservable(this, "pickTileActive").subscribe(function(val) {
    if (val) {
      eventHandler.setInputAction(
        selectTile2,
        ScreenSpaceEventType_default.LEFT_CLICK
      );
    } else {
      eventHandler.removeInputAction(ScreenSpaceEventType_default.LEFT_CLICK);
    }
  });
  this._removePostRenderEvent = scene.postRender.addEventListener(function() {
    that._update();
  });
}
Object.defineProperties(CesiumInspectorViewModel.prototype, {
  scene: {
    get: function() {
      return this._scene;
    }
  },
  performanceContainer: {
    get: function() {
      return this._performanceContainer;
    }
  },
  toggleDropDown: {
    get: function() {
      return this._toggleDropDown;
    }
  },
  showPrimitiveBoundingSphere: {
    get: function() {
      return this._showPrimitiveBoundingSphere;
    }
  },
  showPrimitiveReferenceFrame: {
    get: function() {
      return this._showPrimitiveReferenceFrame;
    }
  },
  doFilterPrimitive: {
    get: function() {
      return this._doFilterPrimitive;
    }
  },
  incrementDepthFrustum: {
    get: function() {
      return this._incrementDepthFrustum;
    }
  },
  decrementDepthFrustum: {
    get: function() {
      return this._decrementDepthFrustum;
    }
  },
  showTileCoordinates: {
    get: function() {
      return this._showTileCoordinates;
    }
  },
  showTileBoundingSphere: {
    get: function() {
      return this._showTileBoundingSphere;
    }
  },
  doFilterTile: {
    get: function() {
      return this._doFilterTile;
    }
  },
  toggleGeneral: {
    get: function() {
      return this._toggleGeneral;
    }
  },
  togglePrimitives: {
    get: function() {
      return this._togglePrimitives;
    }
  },
  toggleTerrain: {
    get: function() {
      return this._toggleTerrain;
    }
  },
  pickPrimitive: {
    get: function() {
      return this._pickPrimitive;
    }
  },
  pickTile: {
    get: function() {
      return this._pickTile;
    }
  },
  selectParent: {
    get: function() {
      const that = this;
      return createCommand_default(function() {
        that.tile = that.tile.parent;
      });
    }
  },
  selectNW: {
    get: function() {
      const that = this;
      return createCommand_default(function() {
        that.tile = that.tile.northwestChild;
      });
    }
  },
  selectNE: {
    get: function() {
      const that = this;
      return createCommand_default(function() {
        that.tile = that.tile.northeastChild;
      });
    }
  },
  selectSW: {
    get: function() {
      const that = this;
      return createCommand_default(function() {
        that.tile = that.tile.southwestChild;
      });
    }
  },
  selectSE: {
    get: function() {
      const that = this;
      return createCommand_default(function() {
        that.tile = that.tile.southeastChild;
      });
    }
  },
  primitive: {
    get: function() {
      return this._primitive;
    },
    set: function(newPrimitive) {
      const oldPrimitive = this._primitive;
      if (newPrimitive !== oldPrimitive) {
        this.hasPickedPrimitive = true;
        if (defined_default(oldPrimitive)) {
          oldPrimitive.debugShowBoundingVolume = false;
        }
        this._scene.debugCommandFilter = void 0;
        if (defined_default(this._modelMatrixPrimitive)) {
          this._scene.primitives.remove(this._modelMatrixPrimitive);
          this._modelMatrixPrimitive = void 0;
        }
        this._primitive = newPrimitive;
        newPrimitive.show = false;
        setTimeout(function() {
          newPrimitive.show = true;
        }, 50);
        this.showPrimitiveBoundingSphere();
        this.showPrimitiveReferenceFrame();
        this.doFilterPrimitive();
      }
    }
  },
  tile: {
    get: function() {
      return this._tile;
    },
    set: function(newTile) {
      if (defined_default(newTile)) {
        this.hasPickedTile = true;
        const oldTile = this._tile;
        if (newTile !== oldTile) {
          this.tileText = `L: ${newTile.level} X: ${newTile.x} Y: ${newTile.y}`;
          this.tileText += `<br>SW corner: ${newTile.rectangle.west}, ${newTile.rectangle.south}`;
          this.tileText += `<br>NE corner: ${newTile.rectangle.east}, ${newTile.rectangle.north}`;
          const data = newTile.data;
          if (defined_default(data) && defined_default(data.tileBoundingRegion)) {
            this.tileText += `<br>Min: ${data.tileBoundingRegion.minimumHeight} Max: ${data.tileBoundingRegion.maximumHeight}`;
          } else {
            this.tileText += "<br>(Tile is not loaded)";
          }
        }
        this._tile = newTile;
        this.showTileBoundingSphere();
        this.doFilterTile();
      } else {
        this.hasPickedTile = false;
        this._tile = void 0;
      }
    }
  }
});
CesiumInspectorViewModel.prototype._update = function() {
  if (this.frustums) {
    this.frustumStatisticText = frustumStatisticsToString(
      this._scene.debugFrustumStatistics
    );
  }
  const numberOfFrustums = this._scene.numberOfFrustums;
  this._numberOfFrustums = numberOfFrustums;
  this.depthFrustum = boundDepthFrustum(1, numberOfFrustums, this.depthFrustum);
  this.depthFrustumText = `${this.depthFrustum} of ${numberOfFrustums}`;
  if (this.performance) {
    this._performanceDisplay.update();
  }
  if (this.primitiveReferenceFrame) {
    this._modelMatrixPrimitive.modelMatrix = this._primitive.modelMatrix;
  }
  this.shaderCacheText = `Cached shaders: ${this._scene.context.shaderCache.numberOfShaders}`;
};
CesiumInspectorViewModel.prototype.isDestroyed = function() {
  return false;
};
CesiumInspectorViewModel.prototype.destroy = function() {
  this._eventHandler.destroy();
  this._removePostRenderEvent();
  this._frustumsSubscription.dispose();
  this._frustumPlanesSubscription.dispose();
  this._performanceSubscription.dispose();
  this._primitiveBoundingSphereSubscription.dispose();
  this._primitiveReferenceFrameSubscription.dispose();
  this._filterPrimitiveSubscription.dispose();
  this._wireframeSubscription.dispose();
  this._depthFrustumSubscription.dispose();
  this._suspendUpdatesSubscription.dispose();
  this._tileCoordinatesSubscription.dispose();
  this._tileBoundingSphereSubscription.dispose();
  this._filterTileSubscription.dispose();
  this._pickPrimitiveActiveSubscription.dispose();
  this._pickTileActiveSubscription.dispose();
  return destroyObject_default(this);
};
var CesiumInspectorViewModel_default = CesiumInspectorViewModel;

// node_modules/cesium/Source/Widgets/CesiumInspector/CesiumInspector.js
function CesiumInspector(container, scene) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  container = getElement_default(container);
  const performanceContainer = document.createElement("div");
  const viewModel = new CesiumInspectorViewModel_default(scene, performanceContainer);
  this._viewModel = viewModel;
  this._container = container;
  const element = document.createElement("div");
  this._element = element;
  const text2 = document.createElement("div");
  text2.textContent = "Cesium Inspector";
  text2.className = "cesium-cesiumInspector-button";
  text2.setAttribute("data-bind", "click: toggleDropDown");
  element.appendChild(text2);
  element.className = "cesium-cesiumInspector";
  element.setAttribute(
    "data-bind",
    'css: { "cesium-cesiumInspector-visible" : dropDownVisible, "cesium-cesiumInspector-hidden" : !dropDownVisible }'
  );
  container.appendChild(this._element);
  const panel = document.createElement("div");
  this._panel = panel;
  panel.className = "cesium-cesiumInspector-dropDown";
  element.appendChild(panel);
  const createSection = InspectorShared_default.createSection;
  const createCheckbox = InspectorShared_default.createCheckbox;
  const generalSection = createSection(
    panel,
    "General",
    "generalVisible",
    "toggleGeneral"
  );
  const debugShowFrustums = createCheckbox("Show Frustums", "frustums");
  const frustumStatistics = document.createElement("div");
  frustumStatistics.className = "cesium-cesiumInspector-frustumStatistics";
  frustumStatistics.setAttribute(
    "data-bind",
    "visible: frustums, html: frustumStatisticText"
  );
  debugShowFrustums.appendChild(frustumStatistics);
  generalSection.appendChild(debugShowFrustums);
  generalSection.appendChild(
    createCheckbox("Show Frustum Planes", "frustumPlanes")
  );
  generalSection.appendChild(
    createCheckbox("Performance Display", "performance")
  );
  performanceContainer.className = "cesium-cesiumInspector-performanceDisplay";
  generalSection.appendChild(performanceContainer);
  const shaderCacheDisplay = document.createElement("div");
  shaderCacheDisplay.className = "cesium-cesiumInspector-shaderCache";
  shaderCacheDisplay.setAttribute("data-bind", "html: shaderCacheText");
  generalSection.appendChild(shaderCacheDisplay);
  const depthFrustum = document.createElement("div");
  generalSection.appendChild(depthFrustum);
  const gLabel = document.createElement("span");
  gLabel.setAttribute(
    "data-bind",
    'html: "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Frustum:"'
  );
  depthFrustum.appendChild(gLabel);
  const gText = document.createElement("span");
  gText.setAttribute("data-bind", "text: depthFrustumText");
  depthFrustum.appendChild(gText);
  const gMinusButton = document.createElement("input");
  gMinusButton.type = "button";
  gMinusButton.value = "-";
  gMinusButton.className = "cesium-cesiumInspector-pickButton";
  gMinusButton.setAttribute("data-bind", "click: decrementDepthFrustum");
  depthFrustum.appendChild(gMinusButton);
  const gPlusButton = document.createElement("input");
  gPlusButton.type = "button";
  gPlusButton.value = "+";
  gPlusButton.className = "cesium-cesiumInspector-pickButton";
  gPlusButton.setAttribute("data-bind", "click: incrementDepthFrustum");
  depthFrustum.appendChild(gPlusButton);
  const primSection = createSection(
    panel,
    "Primitives",
    "primitivesVisible",
    "togglePrimitives"
  );
  const pickPrimRequired = document.createElement("div");
  pickPrimRequired.className = "cesium-cesiumInspector-pickSection";
  primSection.appendChild(pickPrimRequired);
  const pickPrimitiveButton = document.createElement("input");
  pickPrimitiveButton.type = "button";
  pickPrimitiveButton.value = "Pick a primitive";
  pickPrimitiveButton.className = "cesium-cesiumInspector-pickButton";
  pickPrimitiveButton.setAttribute(
    "data-bind",
    'css: {"cesium-cesiumInspector-pickButtonHighlight" : pickPrimitiveActive}, click: pickPrimitive'
  );
  let buttonWrap = document.createElement("div");
  buttonWrap.className = "cesium-cesiumInspector-center";
  buttonWrap.appendChild(pickPrimitiveButton);
  pickPrimRequired.appendChild(buttonWrap);
  pickPrimRequired.appendChild(
    createCheckbox(
      "Show bounding sphere",
      "primitiveBoundingSphere",
      "hasPickedPrimitive"
    )
  );
  pickPrimRequired.appendChild(
    createCheckbox(
      "Show reference frame",
      "primitiveReferenceFrame",
      "hasPickedPrimitive"
    )
  );
  this._primitiveOnly = createCheckbox(
    "Show only selected",
    "filterPrimitive",
    "hasPickedPrimitive"
  );
  pickPrimRequired.appendChild(this._primitiveOnly);
  const terrainSection = createSection(
    panel,
    "Terrain",
    "terrainVisible",
    "toggleTerrain"
  );
  const pickTileRequired = document.createElement("div");
  pickTileRequired.className = "cesium-cesiumInspector-pickSection";
  terrainSection.appendChild(pickTileRequired);
  const pickTileButton = document.createElement("input");
  pickTileButton.type = "button";
  pickTileButton.value = "Pick a tile";
  pickTileButton.className = "cesium-cesiumInspector-pickButton";
  pickTileButton.setAttribute(
    "data-bind",
    'css: {"cesium-cesiumInspector-pickButtonHighlight" : pickTileActive}, click: pickTile'
  );
  buttonWrap = document.createElement("div");
  buttonWrap.appendChild(pickTileButton);
  buttonWrap.className = "cesium-cesiumInspector-center";
  pickTileRequired.appendChild(buttonWrap);
  const tileInfo = document.createElement("div");
  pickTileRequired.appendChild(tileInfo);
  const parentTile = document.createElement("input");
  parentTile.type = "button";
  parentTile.value = "Parent";
  parentTile.className = "cesium-cesiumInspector-pickButton";
  parentTile.setAttribute("data-bind", "click: selectParent");
  const nwTile = document.createElement("input");
  nwTile.type = "button";
  nwTile.value = "NW";
  nwTile.className = "cesium-cesiumInspector-pickButton";
  nwTile.setAttribute("data-bind", "click: selectNW");
  const neTile = document.createElement("input");
  neTile.type = "button";
  neTile.value = "NE";
  neTile.className = "cesium-cesiumInspector-pickButton";
  neTile.setAttribute("data-bind", "click: selectNE");
  const swTile = document.createElement("input");
  swTile.type = "button";
  swTile.value = "SW";
  swTile.className = "cesium-cesiumInspector-pickButton";
  swTile.setAttribute("data-bind", "click: selectSW");
  const seTile = document.createElement("input");
  seTile.type = "button";
  seTile.value = "SE";
  seTile.className = "cesium-cesiumInspector-pickButton";
  seTile.setAttribute("data-bind", "click: selectSE");
  const tileText = document.createElement("div");
  tileText.className = "cesium-cesiumInspector-tileText";
  tileInfo.className = "cesium-cesiumInspector-frustumStatistics";
  tileInfo.appendChild(tileText);
  tileInfo.setAttribute("data-bind", "visible: hasPickedTile");
  tileText.setAttribute("data-bind", "html: tileText");
  const relativeText = document.createElement("div");
  relativeText.className = "cesium-cesiumInspector-relativeText";
  relativeText.textContent = "Select relative:";
  tileInfo.appendChild(relativeText);
  const table2 = document.createElement("table");
  const tr1 = document.createElement("tr");
  const tr2 = document.createElement("tr");
  const td1 = document.createElement("td");
  td1.appendChild(parentTile);
  const td2 = document.createElement("td");
  td2.appendChild(nwTile);
  const td3 = document.createElement("td");
  td3.appendChild(neTile);
  tr1.appendChild(td1);
  tr1.appendChild(td2);
  tr1.appendChild(td3);
  const td4 = document.createElement("td");
  const td5 = document.createElement("td");
  td5.appendChild(swTile);
  const td6 = document.createElement("td");
  td6.appendChild(seTile);
  tr2.appendChild(td4);
  tr2.appendChild(td5);
  tr2.appendChild(td6);
  table2.appendChild(tr1);
  table2.appendChild(tr2);
  tileInfo.appendChild(table2);
  pickTileRequired.appendChild(
    createCheckbox(
      "Show bounding volume",
      "tileBoundingSphere",
      "hasPickedTile"
    )
  );
  pickTileRequired.appendChild(
    createCheckbox("Show only selected", "filterTile", "hasPickedTile")
  );
  terrainSection.appendChild(createCheckbox("Wireframe", "wireframe"));
  terrainSection.appendChild(
    createCheckbox("Suspend LOD update", "suspendUpdates")
  );
  terrainSection.appendChild(
    createCheckbox("Show tile coordinates", "tileCoordinates")
  );
  knockout_default.applyBindings(viewModel, this._element);
}
Object.defineProperties(CesiumInspector.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
CesiumInspector.prototype.isDestroyed = function() {
  return false;
};
CesiumInspector.prototype.destroy = function() {
  knockout_default.cleanNode(this._element);
  this._container.removeChild(this._element);
  this.viewModel.destroy();
  return destroyObject_default(this);
};
var CesiumInspector_default = CesiumInspector;

// node_modules/cesium/Source/Widgets/CesiumWidget/CesiumWidget.js
function getDefaultSkyBoxUrl(suffix) {
  return buildModuleUrl_default(`Assets/Textures/SkyBox/tycho2t3_80_${suffix}.jpg`);
}
function startRenderLoop(widget) {
  widget._renderLoopRunning = true;
  let lastFrameTime = 0;
  function render2(frameTime) {
    if (widget.isDestroyed()) {
      return;
    }
    if (widget._useDefaultRenderLoop) {
      try {
        const targetFrameRate = widget._targetFrameRate;
        if (!defined_default(targetFrameRate)) {
          widget.resize();
          widget.render();
          requestAnimationFrame_default(render2);
        } else {
          const interval = 1e3 / targetFrameRate;
          const delta = frameTime - lastFrameTime;
          if (delta > interval) {
            widget.resize();
            widget.render();
            lastFrameTime = frameTime - delta % interval;
          }
          requestAnimationFrame_default(render2);
        }
      } catch (error) {
        widget._useDefaultRenderLoop = false;
        widget._renderLoopRunning = false;
        if (widget._showRenderLoopErrors) {
          const title = "An error occurred while rendering.  Rendering has stopped.";
          widget.showErrorPanel(title, void 0, error);
        }
      }
    } else {
      widget._renderLoopRunning = false;
    }
  }
  requestAnimationFrame_default(render2);
}
function configurePixelRatio(widget) {
  let pixelRatio = widget._useBrowserRecommendedResolution ? 1 : window.devicePixelRatio;
  pixelRatio *= widget._resolutionScale;
  if (defined_default(widget._scene)) {
    widget._scene.pixelRatio = pixelRatio;
  }
  return pixelRatio;
}
function configureCanvasSize(widget) {
  const canvas = widget._canvas;
  let width = canvas.clientWidth;
  let height = canvas.clientHeight;
  const pixelRatio = configurePixelRatio(widget);
  widget._canvasClientWidth = width;
  widget._canvasClientHeight = height;
  width *= pixelRatio;
  height *= pixelRatio;
  canvas.width = width;
  canvas.height = height;
  widget._canRender = width !== 0 && height !== 0;
  widget._lastDevicePixelRatio = window.devicePixelRatio;
}
function configureCameraFrustum(widget) {
  const canvas = widget._canvas;
  const width = canvas.width;
  const height = canvas.height;
  if (width !== 0 && height !== 0) {
    const frustum = widget._scene.camera.frustum;
    if (defined_default(frustum.aspectRatio)) {
      frustum.aspectRatio = width / height;
    } else {
      frustum.top = frustum.right * (height / width);
      frustum.bottom = -frustum.top;
    }
  }
}
function CesiumWidget(container, options) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  container = getElement_default(container);
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const element = document.createElement("div");
  element.className = "cesium-widget";
  container.appendChild(element);
  const canvas = document.createElement("canvas");
  const supportsImageRenderingPixelated2 = FeatureDetection_default.supportsImageRenderingPixelated();
  this._supportsImageRenderingPixelated = supportsImageRenderingPixelated2;
  if (supportsImageRenderingPixelated2) {
    canvas.style.imageRendering = FeatureDetection_default.imageRenderingValue();
  }
  canvas.oncontextmenu = function() {
    return false;
  };
  canvas.onselectstart = function() {
    return false;
  };
  function blurActiveElement() {
    if (canvas !== canvas.ownerDocument.activeElement) {
      canvas.ownerDocument.activeElement.blur();
    }
  }
  canvas.addEventListener("mousedown", blurActiveElement);
  canvas.addEventListener("pointerdown", blurActiveElement);
  element.appendChild(canvas);
  const innerCreditContainer = document.createElement("div");
  innerCreditContainer.className = "cesium-widget-credits";
  const creditContainer = defined_default(options.creditContainer) ? getElement_default(options.creditContainer) : element;
  creditContainer.appendChild(innerCreditContainer);
  const creditViewport = defined_default(options.creditViewport) ? getElement_default(options.creditViewport) : element;
  const showRenderLoopErrors = defaultValue_default(options.showRenderLoopErrors, true);
  const useBrowserRecommendedResolution = defaultValue_default(
    options.useBrowserRecommendedResolution,
    true
  );
  this._element = element;
  this._container = container;
  this._canvas = canvas;
  this._canvasClientWidth = 0;
  this._canvasClientHeight = 0;
  this._lastDevicePixelRatio = 0;
  this._creditViewport = creditViewport;
  this._creditContainer = creditContainer;
  this._innerCreditContainer = innerCreditContainer;
  this._canRender = false;
  this._renderLoopRunning = false;
  this._showRenderLoopErrors = showRenderLoopErrors;
  this._resolutionScale = 1;
  this._useBrowserRecommendedResolution = useBrowserRecommendedResolution;
  this._forceResize = false;
  this._clock = defined_default(options.clock) ? options.clock : new Clock_default();
  configureCanvasSize(this);
  try {
    const scene = new Scene_default({
      canvas,
      contextOptions: options.contextOptions,
      creditContainer: innerCreditContainer,
      creditViewport,
      mapProjection: options.mapProjection,
      orderIndependentTranslucency: options.orderIndependentTranslucency,
      scene3DOnly: defaultValue_default(options.scene3DOnly, false),
      shadows: options.shadows,
      mapMode2D: options.mapMode2D,
      requestRenderMode: options.requestRenderMode,
      maximumRenderTimeChange: options.maximumRenderTimeChange,
      depthPlaneEllipsoidOffset: options.depthPlaneEllipsoidOffset,
      msaaSamples: options.msaaSamples
    });
    this._scene = scene;
    scene.camera.constrainedAxis = Cartesian3_default.UNIT_Z;
    configurePixelRatio(this);
    configureCameraFrustum(this);
    const ellipsoid = defaultValue_default(
      scene.mapProjection.ellipsoid,
      Ellipsoid_default.WGS84
    );
    let globe = options.globe;
    if (!defined_default(globe)) {
      globe = new Globe_default(ellipsoid);
    }
    if (globe !== false) {
      scene.globe = globe;
      scene.globe.shadows = defaultValue_default(
        options.terrainShadows,
        ShadowMode_default.RECEIVE_ONLY
      );
    }
    let skyBox = options.skyBox;
    if (!defined_default(skyBox)) {
      skyBox = new SkyBox_default({
        sources: {
          positiveX: getDefaultSkyBoxUrl("px"),
          negativeX: getDefaultSkyBoxUrl("mx"),
          positiveY: getDefaultSkyBoxUrl("py"),
          negativeY: getDefaultSkyBoxUrl("my"),
          positiveZ: getDefaultSkyBoxUrl("pz"),
          negativeZ: getDefaultSkyBoxUrl("mz")
        }
      });
    }
    if (skyBox !== false) {
      scene.skyBox = skyBox;
      scene.sun = new Sun_default();
      scene.moon = new Moon_default();
    }
    let skyAtmosphere = options.skyAtmosphere;
    if (!defined_default(skyAtmosphere)) {
      skyAtmosphere = new SkyAtmosphere_default(ellipsoid);
    }
    if (skyAtmosphere !== false) {
      scene.skyAtmosphere = skyAtmosphere;
    }
    let imageryProvider = options.globe === false ? false : options.imageryProvider;
    if (!defined_default(imageryProvider)) {
      imageryProvider = createWorldImagery_default();
    }
    if (imageryProvider !== false) {
      scene.imageryLayers.addImageryProvider(imageryProvider);
    }
    if (defined_default(options.terrainProvider) && options.globe !== false) {
      scene.terrainProvider = options.terrainProvider;
    }
    this._screenSpaceEventHandler = new ScreenSpaceEventHandler_default(canvas);
    if (defined_default(options.sceneMode)) {
      if (options.sceneMode === SceneMode_default.SCENE2D) {
        this._scene.morphTo2D(0);
      }
      if (options.sceneMode === SceneMode_default.COLUMBUS_VIEW) {
        this._scene.morphToColumbusView(0);
      }
    }
    this._useDefaultRenderLoop = void 0;
    this.useDefaultRenderLoop = defaultValue_default(
      options.useDefaultRenderLoop,
      true
    );
    this._targetFrameRate = void 0;
    this.targetFrameRate = options.targetFrameRate;
    const that = this;
    this._onRenderError = function(scene2, error) {
      that._useDefaultRenderLoop = false;
      that._renderLoopRunning = false;
      if (that._showRenderLoopErrors) {
        const title = "An error occurred while rendering.  Rendering has stopped.";
        that.showErrorPanel(title, void 0, error);
      }
    };
    scene.renderError.addEventListener(this._onRenderError);
  } catch (error) {
    if (showRenderLoopErrors) {
      const title = "Error constructing CesiumWidget.";
      const message = 'Visit <a href="http://get.webgl.org">http://get.webgl.org</a> to verify that your web browser and hardware support WebGL.  Consider trying a different web browser or updating your video drivers.  Detailed error information is below:';
      this.showErrorPanel(title, message, error);
    }
    throw error;
  }
}
Object.defineProperties(CesiumWidget.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  canvas: {
    get: function() {
      return this._canvas;
    }
  },
  creditContainer: {
    get: function() {
      return this._creditContainer;
    }
  },
  creditViewport: {
    get: function() {
      return this._creditViewport;
    }
  },
  scene: {
    get: function() {
      return this._scene;
    }
  },
  imageryLayers: {
    get: function() {
      return this._scene.imageryLayers;
    }
  },
  terrainProvider: {
    get: function() {
      return this._scene.terrainProvider;
    },
    set: function(terrainProvider) {
      this._scene.terrainProvider = terrainProvider;
    }
  },
  camera: {
    get: function() {
      return this._scene.camera;
    }
  },
  clock: {
    get: function() {
      return this._clock;
    }
  },
  screenSpaceEventHandler: {
    get: function() {
      return this._screenSpaceEventHandler;
    }
  },
  targetFrameRate: {
    get: function() {
      return this._targetFrameRate;
    },
    set: function(value) {
      if (value <= 0) {
        throw new DeveloperError_default(
          "targetFrameRate must be greater than 0, or undefined."
        );
      }
      this._targetFrameRate = value;
    }
  },
  useDefaultRenderLoop: {
    get: function() {
      return this._useDefaultRenderLoop;
    },
    set: function(value) {
      if (this._useDefaultRenderLoop !== value) {
        this._useDefaultRenderLoop = value;
        if (value && !this._renderLoopRunning) {
          startRenderLoop(this);
        }
      }
    }
  },
  resolutionScale: {
    get: function() {
      return this._resolutionScale;
    },
    set: function(value) {
      if (value <= 0) {
        throw new DeveloperError_default("resolutionScale must be greater than 0.");
      }
      if (this._resolutionScale !== value) {
        this._resolutionScale = value;
        this._forceResize = true;
      }
    }
  },
  useBrowserRecommendedResolution: {
    get: function() {
      return this._useBrowserRecommendedResolution;
    },
    set: function(value) {
      if (this._useBrowserRecommendedResolution !== value) {
        this._useBrowserRecommendedResolution = value;
        this._forceResize = true;
      }
    }
  }
});
CesiumWidget.prototype.showErrorPanel = function(title, message, error) {
  const element = this._element;
  const overlay = document.createElement("div");
  overlay.className = "cesium-widget-errorPanel";
  const content = document.createElement("div");
  content.className = "cesium-widget-errorPanel-content";
  overlay.appendChild(content);
  const errorHeader = document.createElement("div");
  errorHeader.className = "cesium-widget-errorPanel-header";
  errorHeader.appendChild(document.createTextNode(title));
  content.appendChild(errorHeader);
  const errorPanelScroller = document.createElement("div");
  errorPanelScroller.className = "cesium-widget-errorPanel-scroll";
  content.appendChild(errorPanelScroller);
  function resizeCallback() {
    errorPanelScroller.style.maxHeight = `${Math.max(
      Math.round(element.clientHeight * 0.9 - 100),
      30
    )}px`;
  }
  resizeCallback();
  if (defined_default(window.addEventListener)) {
    window.addEventListener("resize", resizeCallback, false);
  }
  const hasMessage = defined_default(message);
  const hasError = defined_default(error);
  if (hasMessage || hasError) {
    const errorMessage = document.createElement("div");
    errorMessage.className = "cesium-widget-errorPanel-message";
    errorPanelScroller.appendChild(errorMessage);
    if (hasError) {
      let errorDetails = formatError_default(error);
      if (!hasMessage) {
        if (typeof error === "string") {
          error = new Error(error);
        }
        message = formatError_default({
          name: error.name,
          message: error.message
        });
        errorDetails = error.stack;
      }
      if (typeof console !== "undefined") {
        console.error(`${title}
${message}
${errorDetails}`);
      }
      const errorMessageDetails = document.createElement("div");
      errorMessageDetails.className = "cesium-widget-errorPanel-message-details collapsed";
      const moreDetails = document.createElement("span");
      moreDetails.className = "cesium-widget-errorPanel-more-details";
      moreDetails.appendChild(document.createTextNode("See more..."));
      errorMessageDetails.appendChild(moreDetails);
      errorMessageDetails.onclick = function(e2) {
        errorMessageDetails.removeChild(moreDetails);
        errorMessageDetails.appendChild(document.createTextNode(errorDetails));
        errorMessageDetails.className = "cesium-widget-errorPanel-message-details";
        content.className = "cesium-widget-errorPanel-content expanded";
        errorMessageDetails.onclick = void 0;
      };
      errorPanelScroller.appendChild(errorMessageDetails);
    }
    errorMessage.innerHTML = `<p>${message}</p>`;
  }
  const buttonPanel = document.createElement("div");
  buttonPanel.className = "cesium-widget-errorPanel-buttonPanel";
  content.appendChild(buttonPanel);
  const okButton = document.createElement("button");
  okButton.setAttribute("type", "button");
  okButton.className = "cesium-button";
  okButton.appendChild(document.createTextNode("OK"));
  okButton.onclick = function() {
    if (defined_default(resizeCallback) && defined_default(window.removeEventListener)) {
      window.removeEventListener("resize", resizeCallback, false);
    }
    element.removeChild(overlay);
  };
  buttonPanel.appendChild(okButton);
  element.appendChild(overlay);
};
CesiumWidget.prototype.isDestroyed = function() {
  return false;
};
CesiumWidget.prototype.destroy = function() {
  if (defined_default(this._scene)) {
    this._scene.renderError.removeEventListener(this._onRenderError);
    this._scene = this._scene.destroy();
  }
  this._container.removeChild(this._element);
  this._creditContainer.removeChild(this._innerCreditContainer);
  destroyObject_default(this);
};
CesiumWidget.prototype.resize = function() {
  const canvas = this._canvas;
  if (!this._forceResize && this._canvasClientWidth === canvas.clientWidth && this._canvasClientHeight === canvas.clientHeight && this._lastDevicePixelRatio === window.devicePixelRatio) {
    return;
  }
  this._forceResize = false;
  configureCanvasSize(this);
  configureCameraFrustum(this);
  this._scene.requestRender();
};
CesiumWidget.prototype.render = function() {
  if (this._canRender) {
    this._scene.initializeFrame();
    const currentTime = this._clock.tick();
    this._scene.render(currentTime);
  } else {
    this._clock.tick();
  }
};
var CesiumWidget_default = CesiumWidget;

// node_modules/cesium/Source/Widgets/FullscreenButton/FullscreenButtonViewModel.js
function FullscreenButtonViewModel(fullscreenElement, container) {
  if (!defined_default(container)) {
    container = document.body;
  }
  container = getElement_default(container);
  const that = this;
  const tmpIsFullscreen = knockout_default.observable(Fullscreen_default.fullscreen);
  const tmpIsEnabled = knockout_default.observable(Fullscreen_default.enabled);
  const ownerDocument = container.ownerDocument;
  this.isFullscreen = void 0;
  knockout_default.defineProperty(this, "isFullscreen", {
    get: function() {
      return tmpIsFullscreen();
    }
  });
  this.isFullscreenEnabled = void 0;
  knockout_default.defineProperty(this, "isFullscreenEnabled", {
    get: function() {
      return tmpIsEnabled();
    },
    set: function(value) {
      tmpIsEnabled(value && Fullscreen_default.enabled);
    }
  });
  this.tooltip = void 0;
  knockout_default.defineProperty(this, "tooltip", function() {
    if (!this.isFullscreenEnabled) {
      return "Full screen unavailable";
    }
    return tmpIsFullscreen() ? "Exit full screen" : "Full screen";
  });
  this._command = createCommand_default(function() {
    if (Fullscreen_default.fullscreen) {
      Fullscreen_default.exitFullscreen();
    } else {
      Fullscreen_default.requestFullscreen(that._fullscreenElement);
    }
  }, knockout_default.getObservable(this, "isFullscreenEnabled"));
  this._fullscreenElement = defaultValue_default(
    getElement_default(fullscreenElement),
    ownerDocument.body
  );
  this._callback = function() {
    tmpIsFullscreen(Fullscreen_default.fullscreen);
  };
  ownerDocument.addEventListener(Fullscreen_default.changeEventName, this._callback);
}
Object.defineProperties(FullscreenButtonViewModel.prototype, {
  fullscreenElement: {
    get: function() {
      return this._fullscreenElement;
    },
    set: function(value) {
      if (!(value instanceof Element)) {
        throw new DeveloperError_default("value must be a valid Element.");
      }
      this._fullscreenElement = value;
    }
  },
  command: {
    get: function() {
      return this._command;
    }
  }
});
FullscreenButtonViewModel.prototype.isDestroyed = function() {
  return false;
};
FullscreenButtonViewModel.prototype.destroy = function() {
  document.removeEventListener(Fullscreen_default.changeEventName, this._callback);
  destroyObject_default(this);
};
var FullscreenButtonViewModel_default = FullscreenButtonViewModel;

// node_modules/cesium/Source/Widgets/FullscreenButton/FullscreenButton.js
var enterFullScreenPath = "M 83.96875 17.5625 L 83.96875 17.59375 L 76.65625 24.875 L 97.09375 24.96875 L 76.09375 45.96875 L 81.9375 51.8125 L 102.78125 30.9375 L 102.875 51.15625 L 110.15625 43.875 L 110.1875 17.59375 L 83.96875 17.5625 z M 44.125 17.59375 L 17.90625 17.625 L 17.9375 43.90625 L 25.21875 51.1875 L 25.3125 30.96875 L 46.15625 51.8125 L 52 45.96875 L 31 25 L 51.4375 24.90625 L 44.125 17.59375 z M 46.0625 76.03125 L 25.1875 96.875 L 25.09375 76.65625 L 17.8125 83.9375 L 17.8125 110.21875 L 44 110.25 L 51.3125 102.9375 L 30.90625 102.84375 L 51.875 81.875 L 46.0625 76.03125 z M 82 76.15625 L 76.15625 82 L 97.15625 103 L 76.71875 103.0625 L 84.03125 110.375 L 110.25 110.34375 L 110.21875 84.0625 L 102.9375 76.8125 L 102.84375 97 L 82 76.15625 z";
var exitFullScreenPath = "M 104.34375 17.5625 L 83.5 38.4375 L 83.40625 18.21875 L 76.125 25.5 L 76.09375 51.78125 L 102.3125 51.8125 L 102.3125 51.78125 L 109.625 44.5 L 89.1875 44.40625 L 110.1875 23.40625 L 104.34375 17.5625 z M 23.75 17.59375 L 17.90625 23.4375 L 38.90625 44.4375 L 18.5 44.53125 L 25.78125 51.8125 L 52 51.78125 L 51.96875 25.53125 L 44.6875 18.25 L 44.625 38.46875 L 23.75 17.59375 z M 25.6875 76.03125 L 18.375 83.3125 L 38.78125 83.40625 L 17.8125 104.40625 L 23.625 110.25 L 44.5 89.375 L 44.59375 109.59375 L 51.875 102.3125 L 51.875 76.0625 L 25.6875 76.03125 z M 102.375 76.15625 L 76.15625 76.1875 L 76.1875 102.4375 L 83.46875 109.71875 L 83.5625 89.53125 L 104.40625 110.375 L 110.25 104.53125 L 89.25 83.53125 L 109.6875 83.46875 L 102.375 76.15625 z";
function FullscreenButton(container, fullscreenElement) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  container = getElement_default(container);
  const viewModel = new FullscreenButtonViewModel_default(fullscreenElement, container);
  viewModel._exitFullScreenPath = exitFullScreenPath;
  viewModel._enterFullScreenPath = enterFullScreenPath;
  const element = document.createElement("button");
  element.type = "button";
  element.className = "cesium-button cesium-fullscreenButton";
  element.setAttribute(
    "data-bind",
    "attr: { title: tooltip },click: command,enable: isFullscreenEnabled,cesiumSvgPath: { path: isFullscreen ? _exitFullScreenPath : _enterFullScreenPath, width: 128, height: 128 }"
  );
  container.appendChild(element);
  knockout_default.applyBindings(viewModel, element);
  this._container = container;
  this._viewModel = viewModel;
  this._element = element;
}
Object.defineProperties(FullscreenButton.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
FullscreenButton.prototype.isDestroyed = function() {
  return false;
};
FullscreenButton.prototype.destroy = function() {
  this._viewModel.destroy();
  knockout_default.cleanNode(this._element);
  this._container.removeChild(this._element);
  return destroyObject_default(this);
};
var FullscreenButton_default = FullscreenButton;

// node_modules/cesium/Source/Widgets/Geocoder/GeocoderViewModel.js
var DEFAULT_HEIGHT = 1e3;
function GeocoderViewModel(options) {
  if (!defined_default(options) || !defined_default(options.scene)) {
    throw new DeveloperError_default("options.scene is required.");
  }
  if (defined_default(options.geocoderServices)) {
    this._geocoderServices = options.geocoderServices;
  } else {
    this._geocoderServices = [
      new CartographicGeocoderService_default(),
      new IonGeocoderService_default({ scene: options.scene })
    ];
  }
  this._viewContainer = options.container;
  this._scene = options.scene;
  this._flightDuration = options.flightDuration;
  this._searchText = "";
  this._isSearchInProgress = false;
  this._geocodePromise = void 0;
  this._complete = new Event_default();
  this._suggestions = [];
  this._selectedSuggestion = void 0;
  this._showSuggestions = true;
  this._handleArrowDown = handleArrowDown;
  this._handleArrowUp = handleArrowUp;
  const that = this;
  this._suggestionsVisible = knockout_default.pureComputed(function() {
    const suggestions = knockout_default.getObservable(that, "_suggestions");
    const suggestionsNotEmpty = suggestions().length > 0;
    const showSuggestions = knockout_default.getObservable(that, "_showSuggestions")();
    return suggestionsNotEmpty && showSuggestions;
  });
  this._searchCommand = createCommand_default(function(geocodeType) {
    geocodeType = defaultValue_default(geocodeType, GeocodeType_default.SEARCH);
    that._focusTextbox = false;
    if (defined_default(that._selectedSuggestion)) {
      that.activateSuggestion(that._selectedSuggestion);
      return false;
    }
    that.hideSuggestions();
    if (that.isSearchInProgress) {
      cancelGeocode(that);
    } else {
      geocode(that, that._geocoderServices, geocodeType);
    }
  });
  this.deselectSuggestion = function() {
    that._selectedSuggestion = void 0;
  };
  this.handleKeyDown = function(data, event) {
    const downKey = event.key === "ArrowDown" || event.key === "Down" || event.keyCode === 40;
    const upKey = event.key === "ArrowUp" || event.key === "Up" || event.keyCode === 38;
    if (downKey || upKey) {
      event.preventDefault();
    }
    return true;
  };
  this.handleKeyUp = function(data, event) {
    const downKey = event.key === "ArrowDown" || event.key === "Down" || event.keyCode === 40;
    const upKey = event.key === "ArrowUp" || event.key === "Up" || event.keyCode === 38;
    const enterKey = event.key === "Enter" || event.keyCode === 13;
    if (upKey) {
      handleArrowUp(that);
    } else if (downKey) {
      handleArrowDown(that);
    } else if (enterKey) {
      that._searchCommand();
    }
    return true;
  };
  this.activateSuggestion = function(data) {
    that.hideSuggestions();
    that._searchText = data.displayName;
    const destination = data.destination;
    clearSuggestions(that);
    that.destinationFound(that, destination);
  };
  this.hideSuggestions = function() {
    that._showSuggestions = false;
    that._selectedSuggestion = void 0;
  };
  this.showSuggestions = function() {
    that._showSuggestions = true;
  };
  this.handleMouseover = function(data, event) {
    if (data !== that._selectedSuggestion) {
      that._selectedSuggestion = data;
    }
  };
  this.keepExpanded = false;
  this.autoComplete = defaultValue_default(options.autocomplete, true);
  this.destinationFound = defaultValue_default(
    options.destinationFound,
    GeocoderViewModel.flyToDestination
  );
  this._focusTextbox = false;
  knockout_default.track(this, [
    "_searchText",
    "_isSearchInProgress",
    "keepExpanded",
    "_suggestions",
    "_selectedSuggestion",
    "_showSuggestions",
    "_focusTextbox"
  ]);
  const searchTextObservable = knockout_default.getObservable(this, "_searchText");
  searchTextObservable.extend({ rateLimit: { timeout: 500 } });
  this._suggestionSubscription = searchTextObservable.subscribe(function() {
    GeocoderViewModel._updateSearchSuggestions(that);
  });
  this.isSearchInProgress = void 0;
  knockout_default.defineProperty(this, "isSearchInProgress", {
    get: function() {
      return this._isSearchInProgress;
    }
  });
  this.searchText = void 0;
  knockout_default.defineProperty(this, "searchText", {
    get: function() {
      if (this.isSearchInProgress) {
        return "Searching...";
      }
      return this._searchText;
    },
    set: function(value) {
      if (typeof value !== "string") {
        throw new DeveloperError_default("value must be a valid string.");
      }
      this._searchText = value;
    }
  });
  this.flightDuration = void 0;
  knockout_default.defineProperty(this, "flightDuration", {
    get: function() {
      return this._flightDuration;
    },
    set: function(value) {
      if (defined_default(value) && value < 0) {
        throw new DeveloperError_default("value must be positive.");
      }
      this._flightDuration = value;
    }
  });
}
Object.defineProperties(GeocoderViewModel.prototype, {
  complete: {
    get: function() {
      return this._complete;
    }
  },
  scene: {
    get: function() {
      return this._scene;
    }
  },
  search: {
    get: function() {
      return this._searchCommand;
    }
  },
  selectedSuggestion: {
    get: function() {
      return this._selectedSuggestion;
    }
  },
  suggestions: {
    get: function() {
      return this._suggestions;
    }
  }
});
GeocoderViewModel.prototype.destroy = function() {
  this._suggestionSubscription.dispose();
};
function handleArrowUp(viewModel) {
  if (viewModel._suggestions.length === 0) {
    return;
  }
  const currentIndex = viewModel._suggestions.indexOf(
    viewModel._selectedSuggestion
  );
  if (currentIndex === -1 || currentIndex === 0) {
    viewModel._selectedSuggestion = void 0;
    return;
  }
  const next = currentIndex - 1;
  viewModel._selectedSuggestion = viewModel._suggestions[next];
  GeocoderViewModel._adjustSuggestionsScroll(viewModel, next);
}
function handleArrowDown(viewModel) {
  if (viewModel._suggestions.length === 0) {
    return;
  }
  const numberOfSuggestions = viewModel._suggestions.length;
  const currentIndex = viewModel._suggestions.indexOf(
    viewModel._selectedSuggestion
  );
  const next = (currentIndex + 1) % numberOfSuggestions;
  viewModel._selectedSuggestion = viewModel._suggestions[next];
  GeocoderViewModel._adjustSuggestionsScroll(viewModel, next);
}
function computeFlyToLocationForCartographic(cartographic2, terrainProvider) {
  const availability = defined_default(terrainProvider) ? terrainProvider.availability : void 0;
  if (!defined_default(availability)) {
    cartographic2.height += DEFAULT_HEIGHT;
    return Promise.resolve(cartographic2);
  }
  return sampleTerrainMostDetailed_default(terrainProvider, [cartographic2]).then(
    function(positionOnTerrain) {
      cartographic2 = positionOnTerrain[0];
      cartographic2.height += DEFAULT_HEIGHT;
      return cartographic2;
    }
  );
}
function flyToDestination(viewModel, destination) {
  const scene = viewModel._scene;
  const mapProjection = scene.mapProjection;
  const ellipsoid = mapProjection.ellipsoid;
  const camera = scene.camera;
  const terrainProvider = scene.terrainProvider;
  let finalDestination = destination;
  let promise;
  if (destination instanceof Rectangle_default) {
    if (Math_default.equalsEpsilon(
      destination.south,
      destination.north,
      Math_default.EPSILON7
    ) && Math_default.equalsEpsilon(
      destination.east,
      destination.west,
      Math_default.EPSILON7
    )) {
      destination = Rectangle_default.center(destination);
    } else {
      promise = computeFlyToLocationForRectangle_default(destination, scene);
    }
  } else {
    destination = ellipsoid.cartesianToCartographic(destination);
  }
  if (!defined_default(promise)) {
    promise = computeFlyToLocationForCartographic(destination, terrainProvider);
  }
  return promise.then(function(result) {
    finalDestination = ellipsoid.cartographicToCartesian(result);
  }).finally(function() {
    camera.flyTo({
      destination: finalDestination,
      complete: function() {
        viewModel._complete.raiseEvent();
      },
      duration: viewModel._flightDuration,
      endTransform: Matrix4_default.IDENTITY
    });
  });
}
function chainPromise(promise, geocoderService, query, geocodeType) {
  return promise.then(function(result) {
    if (defined_default(result) && result.state === "fulfilled" && result.value.length > 0) {
      return result;
    }
    const nextPromise = geocoderService.geocode(query, geocodeType).then(function(result2) {
      return { state: "fulfilled", value: result2 };
    }).catch(function(err) {
      return { state: "rejected", reason: err };
    });
    return nextPromise;
  });
}
function geocode(viewModel, geocoderServices, geocodeType) {
  const query = viewModel._searchText;
  if (hasOnlyWhitespace(query)) {
    viewModel.showSuggestions();
    return;
  }
  viewModel._isSearchInProgress = true;
  let promise = Promise.resolve();
  for (let i2 = 0; i2 < geocoderServices.length; i2++) {
    promise = chainPromise(promise, geocoderServices[i2], query, geocodeType);
  }
  viewModel._geocodePromise = promise;
  promise.then(function(result) {
    if (promise.cancel) {
      return;
    }
    viewModel._isSearchInProgress = false;
    const geocoderResults = result.value;
    if (result.state === "fulfilled" && defined_default(geocoderResults) && geocoderResults.length > 0) {
      viewModel._searchText = geocoderResults[0].displayName;
      viewModel.destinationFound(viewModel, geocoderResults[0].destination);
      return;
    }
    viewModel._searchText = `${query} (not found)`;
  });
}
function adjustSuggestionsScroll(viewModel, focusedItemIndex) {
  const container = getElement_default(viewModel._viewContainer);
  const searchResults = container.getElementsByClassName("search-results")[0];
  const listItems = container.getElementsByTagName("li");
  const element = listItems[focusedItemIndex];
  if (focusedItemIndex === 0) {
    searchResults.scrollTop = 0;
    return;
  }
  const offsetTop = element.offsetTop;
  if (offsetTop + element.clientHeight > searchResults.clientHeight) {
    searchResults.scrollTop = offsetTop + element.clientHeight;
  } else if (offsetTop < searchResults.scrollTop) {
    searchResults.scrollTop = offsetTop;
  }
}
function cancelGeocode(viewModel) {
  viewModel._isSearchInProgress = false;
  if (defined_default(viewModel._geocodePromise)) {
    viewModel._geocodePromise.cancel = true;
    viewModel._geocodePromise = void 0;
  }
}
function hasOnlyWhitespace(string) {
  return /^\s*$/.test(string);
}
function clearSuggestions(viewModel) {
  knockout_default.getObservable(viewModel, "_suggestions").removeAll();
}
function updateSearchSuggestions(viewModel) {
  if (!viewModel.autoComplete) {
    return;
  }
  const query = viewModel._searchText;
  clearSuggestions(viewModel);
  if (hasOnlyWhitespace(query)) {
    return;
  }
  let promise = Promise.resolve([]);
  viewModel._geocoderServices.forEach(function(service) {
    promise = promise.then(function(results) {
      if (results.length >= 5) {
        return results;
      }
      return service.geocode(query, GeocodeType_default.AUTOCOMPLETE).then(function(newResults) {
        results = results.concat(newResults);
        return results;
      });
    });
  });
  return promise.then(function(results) {
    const suggestions = viewModel._suggestions;
    for (let i2 = 0; i2 < results.length; i2++) {
      suggestions.push(results[i2]);
    }
  });
}
GeocoderViewModel.flyToDestination = flyToDestination;
GeocoderViewModel._updateSearchSuggestions = updateSearchSuggestions;
GeocoderViewModel._adjustSuggestionsScroll = adjustSuggestionsScroll;
var GeocoderViewModel_default = GeocoderViewModel;

// node_modules/cesium/Source/Widgets/Geocoder/Geocoder.js
var startSearchPath = "M29.772,26.433l-7.126-7.126c0.96-1.583,1.523-3.435,1.524-5.421C24.169,8.093,19.478,3.401,13.688,3.399C7.897,3.401,3.204,8.093,3.204,13.885c0,5.789,4.693,10.481,10.484,10.481c1.987,0,3.839-0.563,5.422-1.523l7.128,7.127L29.772,26.433zM7.203,13.885c0.006-3.582,2.903-6.478,6.484-6.486c3.579,0.008,6.478,2.904,6.484,6.486c-0.007,3.58-2.905,6.476-6.484,6.484C10.106,20.361,7.209,17.465,7.203,13.885z";
var stopSearchPath = "M24.778,21.419 19.276,15.917 24.777,10.415 21.949,7.585 16.447,13.087 10.945,7.585 8.117,10.415 13.618,15.917 8.116,21.419 10.946,24.248 16.447,18.746 21.948,24.248z";
function Geocoder(options) {
  if (!defined_default(options) || !defined_default(options.container)) {
    throw new DeveloperError_default("options.container is required.");
  }
  if (!defined_default(options.scene)) {
    throw new DeveloperError_default("options.scene is required.");
  }
  const container = getElement_default(options.container);
  const viewModel = new GeocoderViewModel_default(options);
  viewModel._startSearchPath = startSearchPath;
  viewModel._stopSearchPath = stopSearchPath;
  const form = document.createElement("form");
  form.setAttribute("data-bind", "submit: search");
  const textBox = document.createElement("input");
  textBox.type = "search";
  textBox.className = "cesium-geocoder-input";
  textBox.setAttribute("placeholder", "Enter an address or landmark...");
  textBox.setAttribute(
    "data-bind",
    'textInput: searchText,disable: isSearchInProgress,event: { keyup: handleKeyUp, keydown: handleKeyDown, mouseover: deselectSuggestion },css: { "cesium-geocoder-input-wide" : keepExpanded || searchText.length > 0 },hasFocus: _focusTextbox'
  );
  this._onTextBoxFocus = function() {
    setTimeout(function() {
      textBox.select();
    }, 0);
  };
  textBox.addEventListener("focus", this._onTextBoxFocus, false);
  form.appendChild(textBox);
  this._textBox = textBox;
  const searchButton = document.createElement("span");
  searchButton.className = "cesium-geocoder-searchButton";
  searchButton.setAttribute(
    "data-bind",
    "click: search,cesiumSvgPath: { path: isSearchInProgress ? _stopSearchPath : _startSearchPath, width: 32, height: 32 }"
  );
  form.appendChild(searchButton);
  container.appendChild(form);
  const searchSuggestionsContainer = document.createElement("div");
  searchSuggestionsContainer.className = "search-results";
  searchSuggestionsContainer.setAttribute(
    "data-bind",
    "visible: _suggestionsVisible"
  );
  const suggestionsList = document.createElement("ul");
  suggestionsList.setAttribute("data-bind", "foreach: _suggestions");
  const suggestions = document.createElement("li");
  suggestionsList.appendChild(suggestions);
  suggestions.setAttribute(
    "data-bind",
    "text: $data.displayName, click: $parent.activateSuggestion, event: { mouseover: $parent.handleMouseover}, css: { active: $data === $parent._selectedSuggestion }"
  );
  searchSuggestionsContainer.appendChild(suggestionsList);
  container.appendChild(searchSuggestionsContainer);
  knockout_default.applyBindings(viewModel, form);
  knockout_default.applyBindings(viewModel, searchSuggestionsContainer);
  this._container = container;
  this._searchSuggestionsContainer = searchSuggestionsContainer;
  this._viewModel = viewModel;
  this._form = form;
  this._onInputBegin = function(e2) {
    let target = e2.target;
    if (typeof e2.composedPath === "function") {
      target = e2.composedPath()[0];
    }
    if (!container.contains(target)) {
      viewModel._focusTextbox = false;
      viewModel.hideSuggestions();
    }
  };
  this._onInputEnd = function(e2) {
    viewModel._focusTextbox = true;
    viewModel.showSuggestions();
  };
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.addEventListener("pointerdown", this._onInputBegin, true);
    container.addEventListener("pointerup", this._onInputEnd, true);
    container.addEventListener("pointercancel", this._onInputEnd, true);
  } else {
    document.addEventListener("mousedown", this._onInputBegin, true);
    container.addEventListener("mouseup", this._onInputEnd, true);
    document.addEventListener("touchstart", this._onInputBegin, true);
    container.addEventListener("touchend", this._onInputEnd, true);
    container.addEventListener("touchcancel", this._onInputEnd, true);
  }
}
Object.defineProperties(Geocoder.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  searchSuggestionsContainer: {
    get: function() {
      return this._searchSuggestionsContainer;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
Geocoder.prototype.isDestroyed = function() {
  return false;
};
Geocoder.prototype.destroy = function() {
  const container = this._container;
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.removeEventListener("pointerdown", this._onInputBegin, true);
    container.removeEventListener("pointerup", this._onInputEnd, true);
  } else {
    document.removeEventListener("mousedown", this._onInputBegin, true);
    container.removeEventListener("mouseup", this._onInputEnd, true);
    document.removeEventListener("touchstart", this._onInputBegin, true);
    container.removeEventListener("touchend", this._onInputEnd, true);
  }
  this._viewModel.destroy();
  knockout_default.cleanNode(this._form);
  knockout_default.cleanNode(this._searchSuggestionsContainer);
  container.removeChild(this._form);
  container.removeChild(this._searchSuggestionsContainer);
  this._textBox.removeEventListener("focus", this._onTextBoxFocus, false);
  return destroyObject_default(this);
};
var Geocoder_default = Geocoder;

// node_modules/cesium/Source/Widgets/HomeButton/HomeButtonViewModel.js
function HomeButtonViewModel(scene, duration) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  this._scene = scene;
  this._duration = duration;
  const that = this;
  this._command = createCommand_default(function() {
    that._scene.camera.flyHome(that._duration);
  });
  this.tooltip = "View Home";
  knockout_default.track(this, ["tooltip"]);
}
Object.defineProperties(HomeButtonViewModel.prototype, {
  scene: {
    get: function() {
      return this._scene;
    }
  },
  command: {
    get: function() {
      return this._command;
    }
  },
  duration: {
    get: function() {
      return this._duration;
    },
    set: function(value) {
      if (defined_default(value) && value < 0) {
        throw new DeveloperError_default("value must be positive.");
      }
      this._duration = value;
    }
  }
});
var HomeButtonViewModel_default = HomeButtonViewModel;

// node_modules/cesium/Source/Widgets/HomeButton/HomeButton.js
function HomeButton(container, scene, duration) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  container = getElement_default(container);
  const viewModel = new HomeButtonViewModel_default(scene, duration);
  viewModel._svgPath = "M14,4l-10,8.75h20l-4.25-3.7188v-4.6562h-2.812v2.1875l-2.938-2.5625zm-7.0938,9.906v10.094h14.094v-10.094h-14.094zm2.1876,2.313h3.3122v4.25h-3.3122v-4.25zm5.8442,1.281h3.406v6.438h-3.406v-6.438z";
  const element = document.createElement("button");
  element.type = "button";
  element.className = "cesium-button cesium-toolbar-button cesium-home-button";
  element.setAttribute(
    "data-bind",
    "attr: { title: tooltip },click: command,cesiumSvgPath: { path: _svgPath, width: 28, height: 28 }"
  );
  container.appendChild(element);
  knockout_default.applyBindings(viewModel, element);
  this._container = container;
  this._viewModel = viewModel;
  this._element = element;
}
Object.defineProperties(HomeButton.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
HomeButton.prototype.isDestroyed = function() {
  return false;
};
HomeButton.prototype.destroy = function() {
  knockout_default.cleanNode(this._element);
  this._container.removeChild(this._element);
  return destroyObject_default(this);
};
var HomeButton_default = HomeButton;

// node_modules/cesium/Source/Widgets/InfoBox/InfoBoxViewModel.js
var cameraEnabledPath = "M 13.84375 7.03125 C 11.412798 7.03125 9.46875 8.975298 9.46875 11.40625 L 9.46875 11.59375 L 2.53125 7.21875 L 2.53125 24.0625 L 9.46875 19.6875 C 9.4853444 22.104033 11.423165 24.0625 13.84375 24.0625 L 25.875 24.0625 C 28.305952 24.0625 30.28125 22.087202 30.28125 19.65625 L 30.28125 11.40625 C 30.28125 8.975298 28.305952 7.03125 25.875 7.03125 L 13.84375 7.03125 z";
var cameraDisabledPath = "M 27.34375 1.65625 L 5.28125 27.9375 L 8.09375 30.3125 L 30.15625 4.03125 L 27.34375 1.65625 z M 13.84375 7.03125 C 11.412798 7.03125 9.46875 8.975298 9.46875 11.40625 L 9.46875 11.59375 L 2.53125 7.21875 L 2.53125 24.0625 L 9.46875 19.6875 C 9.4724893 20.232036 9.5676108 20.7379 9.75 21.21875 L 21.65625 7.03125 L 13.84375 7.03125 z M 28.21875 7.71875 L 14.53125 24.0625 L 25.875 24.0625 C 28.305952 24.0625 30.28125 22.087202 30.28125 19.65625 L 30.28125 11.40625 C 30.28125 9.8371439 29.456025 8.4902779 28.21875 7.71875 z";
function InfoBoxViewModel() {
  this._cameraClicked = new Event_default();
  this._closeClicked = new Event_default();
  this.maxHeight = 500;
  this.enableCamera = false;
  this.isCameraTracking = false;
  this.showInfo = false;
  this.titleText = "";
  this.description = "";
  knockout_default.track(this, [
    "showInfo",
    "titleText",
    "description",
    "maxHeight",
    "enableCamera",
    "isCameraTracking"
  ]);
  this._loadingIndicatorHtml = '<div class="cesium-infoBox-loadingContainer"><span class="cesium-infoBox-loading"></span></div>';
  this.cameraIconPath = void 0;
  knockout_default.defineProperty(this, "cameraIconPath", {
    get: function() {
      return !this.enableCamera || this.isCameraTracking ? cameraDisabledPath : cameraEnabledPath;
    }
  });
  knockout_default.defineProperty(this, "_bodyless", {
    get: function() {
      return !defined_default(this.description) || this.description.length === 0;
    }
  });
}
InfoBoxViewModel.prototype.maxHeightOffset = function(offset2) {
  return `${this.maxHeight - offset2}px`;
};
Object.defineProperties(InfoBoxViewModel.prototype, {
  cameraClicked: {
    get: function() {
      return this._cameraClicked;
    }
  },
  closeClicked: {
    get: function() {
      return this._closeClicked;
    }
  }
});
var InfoBoxViewModel_default = InfoBoxViewModel;

// node_modules/cesium/Source/Widgets/InfoBox/InfoBox.js
function InfoBox(container) {
  Check_default.defined("container", container);
  container = getElement_default(container);
  const infoElement = document.createElement("div");
  infoElement.className = "cesium-infoBox";
  infoElement.setAttribute(
    "data-bind",
    'css: { "cesium-infoBox-visible" : showInfo, "cesium-infoBox-bodyless" : _bodyless }'
  );
  container.appendChild(infoElement);
  const titleElement = document.createElement("div");
  titleElement.className = "cesium-infoBox-title";
  titleElement.setAttribute("data-bind", "text: titleText");
  infoElement.appendChild(titleElement);
  const cameraElement = document.createElement("button");
  cameraElement.type = "button";
  cameraElement.className = "cesium-button cesium-infoBox-camera";
  cameraElement.setAttribute(
    "data-bind",
    'attr: { title: "Focus camera on object" },click: function () { cameraClicked.raiseEvent(this); },enable: enableCamera,cesiumSvgPath: { path: cameraIconPath, width: 32, height: 32 }'
  );
  infoElement.appendChild(cameraElement);
  const closeElement = document.createElement("button");
  closeElement.type = "button";
  closeElement.className = "cesium-infoBox-close";
  closeElement.setAttribute(
    "data-bind",
    "click: function () { closeClicked.raiseEvent(this); }"
  );
  closeElement.innerHTML = "&times;";
  infoElement.appendChild(closeElement);
  const frame = document.createElement("iframe");
  frame.className = "cesium-infoBox-iframe";
  frame.setAttribute("sandbox", "allow-same-origin allow-popups allow-forms");
  frame.setAttribute(
    "data-bind",
    "style : { maxHeight : maxHeightOffset(40) }"
  );
  frame.setAttribute("allowfullscreen", true);
  infoElement.appendChild(frame);
  const viewModel = new InfoBoxViewModel_default();
  knockout_default.applyBindings(viewModel, infoElement);
  this._container = container;
  this._element = infoElement;
  this._frame = frame;
  this._viewModel = viewModel;
  this._descriptionSubscription = void 0;
  const that = this;
  frame.addEventListener("load", function() {
    const frameDocument = frame.contentDocument;
    const cssLink = frameDocument.createElement("link");
    cssLink.href = buildModuleUrl_default("Widgets/InfoBox/InfoBoxDescription.css");
    cssLink.rel = "stylesheet";
    cssLink.type = "text/css";
    const frameContent = frameDocument.createElement("div");
    frameContent.className = "cesium-infoBox-description";
    frameDocument.head.appendChild(cssLink);
    frameDocument.body.appendChild(frameContent);
    that._descriptionSubscription = subscribeAndEvaluate_default(
      viewModel,
      "description",
      function(value) {
        frame.style.height = "5px";
        frameContent.innerHTML = value;
        let background = null;
        const firstElementChild = frameContent.firstElementChild;
        if (firstElementChild !== null && frameContent.childNodes.length === 1) {
          const style = window.getComputedStyle(firstElementChild);
          if (style !== null) {
            const backgroundColor = style["background-color"];
            const color = Color_default.fromCssColorString(backgroundColor);
            if (defined_default(color) && color.alpha !== 0) {
              background = style["background-color"];
            }
          }
        }
        infoElement.style["background-color"] = background;
        const height = frameContent.getBoundingClientRect().height;
        frame.style.height = `${height}px`;
      }
    );
  });
  frame.setAttribute("src", "about:blank");
}
Object.defineProperties(InfoBox.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  },
  frame: {
    get: function() {
      return this._frame;
    }
  }
});
InfoBox.prototype.isDestroyed = function() {
  return false;
};
InfoBox.prototype.destroy = function() {
  const container = this._container;
  knockout_default.cleanNode(this._element);
  container.removeChild(this._element);
  if (defined_default(this._descriptionSubscription)) {
    this._descriptionSubscription.dispose();
  }
  return destroyObject_default(this);
};
var InfoBox_default = InfoBox;

// node_modules/cesium/Source/Widgets/NavigationHelpButton/NavigationHelpButtonViewModel.js
function NavigationHelpButtonViewModel() {
  this.showInstructions = false;
  const that = this;
  this._command = createCommand_default(function() {
    that.showInstructions = !that.showInstructions;
  });
  this._showClick = createCommand_default(function() {
    that._touch = false;
  });
  this._showTouch = createCommand_default(function() {
    that._touch = true;
  });
  this._touch = false;
  this.tooltip = "Navigation Instructions";
  knockout_default.track(this, ["tooltip", "showInstructions", "_touch"]);
}
Object.defineProperties(NavigationHelpButtonViewModel.prototype, {
  command: {
    get: function() {
      return this._command;
    }
  },
  showClick: {
    get: function() {
      return this._showClick;
    }
  },
  showTouch: {
    get: function() {
      return this._showTouch;
    }
  }
});
var NavigationHelpButtonViewModel_default = NavigationHelpButtonViewModel;

// node_modules/cesium/Source/Widgets/NavigationHelpButton/NavigationHelpButton.js
function NavigationHelpButton(options) {
  if (!defined_default(options) || !defined_default(options.container)) {
    throw new DeveloperError_default("options.container is required.");
  }
  const container = getElement_default(options.container);
  const viewModel = new NavigationHelpButtonViewModel_default();
  const showInsructionsDefault = defaultValue_default(
    options.instructionsInitiallyVisible,
    false
  );
  viewModel.showInstructions = showInsructionsDefault;
  viewModel._svgPath = "M16,1.466C7.973,1.466,1.466,7.973,1.466,16c0,8.027,6.507,14.534,14.534,14.534c8.027,0,14.534-6.507,14.534-14.534C30.534,7.973,24.027,1.466,16,1.466z M17.328,24.371h-2.707v-2.596h2.707V24.371zM17.328,19.003v0.858h-2.707v-1.057c0-3.19,3.63-3.696,3.63-5.963c0-1.034-0.924-1.826-2.134-1.826c-1.254,0-2.354,0.924-2.354,0.924l-1.541-1.915c0,0,1.519-1.584,4.137-1.584c2.487,0,4.796,1.54,4.796,4.136C21.156,16.208,17.328,16.627,17.328,19.003z";
  const wrapper = document.createElement("span");
  wrapper.className = "cesium-navigationHelpButton-wrapper";
  container.appendChild(wrapper);
  const button = document.createElement("button");
  button.type = "button";
  button.className = "cesium-button cesium-toolbar-button cesium-navigation-help-button";
  button.setAttribute(
    "data-bind",
    "attr: { title: tooltip },click: command,cesiumSvgPath: { path: _svgPath, width: 32, height: 32 }"
  );
  wrapper.appendChild(button);
  const instructionContainer = document.createElement("div");
  instructionContainer.className = "cesium-navigation-help";
  instructionContainer.setAttribute(
    "data-bind",
    'css: { "cesium-navigation-help-visible" : showInstructions}'
  );
  wrapper.appendChild(instructionContainer);
  const mouseButton = document.createElement("button");
  mouseButton.type = "button";
  mouseButton.className = "cesium-navigation-button cesium-navigation-button-left";
  mouseButton.setAttribute(
    "data-bind",
    'click: showClick, css: {"cesium-navigation-button-selected": !_touch, "cesium-navigation-button-unselected": _touch}'
  );
  const mouseIcon = document.createElement("img");
  mouseIcon.src = buildModuleUrl_default("Widgets/Images/NavigationHelp/Mouse.svg");
  mouseIcon.className = "cesium-navigation-button-icon";
  mouseIcon.style.width = "25px";
  mouseIcon.style.height = "25px";
  mouseButton.appendChild(mouseIcon);
  mouseButton.appendChild(document.createTextNode("Mouse"));
  const touchButton = document.createElement("button");
  touchButton.type = "button";
  touchButton.className = "cesium-navigation-button cesium-navigation-button-right";
  touchButton.setAttribute(
    "data-bind",
    'click: showTouch, css: {"cesium-navigation-button-selected": _touch, "cesium-navigation-button-unselected": !_touch}'
  );
  const touchIcon = document.createElement("img");
  touchIcon.src = buildModuleUrl_default("Widgets/Images/NavigationHelp/Touch.svg");
  touchIcon.className = "cesium-navigation-button-icon";
  touchIcon.style.width = "25px";
  touchIcon.style.height = "25px";
  touchButton.appendChild(touchIcon);
  touchButton.appendChild(document.createTextNode("Touch"));
  instructionContainer.appendChild(mouseButton);
  instructionContainer.appendChild(touchButton);
  const clickInstructions = document.createElement("div");
  clickInstructions.className = "cesium-click-navigation-help cesium-navigation-help-instructions";
  clickInstructions.setAttribute(
    "data-bind",
    'css: { "cesium-click-navigation-help-visible" : !_touch}'
  );
  clickInstructions.innerHTML = `            <table>                <tr>                    <td><img src="${buildModuleUrl_default(
    "Widgets/Images/NavigationHelp/MouseLeft.svg"
  )}" width="48" height="48" /></td>                    <td>                        <div class="cesium-navigation-help-pan">Pan view</div>                        <div class="cesium-navigation-help-details">Left click + drag</div>                    </td>                </tr>                <tr>                    <td><img src="${buildModuleUrl_default(
    "Widgets/Images/NavigationHelp/MouseRight.svg"
  )}" width="48" height="48" /></td>                    <td>                        <div class="cesium-navigation-help-zoom">Zoom view</div>                        <div class="cesium-navigation-help-details">Right click + drag, or</div>                        <div class="cesium-navigation-help-details">Mouse wheel scroll</div>                    </td>                </tr>                <tr>                    <td><img src="${buildModuleUrl_default(
    "Widgets/Images/NavigationHelp/MouseMiddle.svg"
  )}" width="48" height="48" /></td>                    <td>                        <div class="cesium-navigation-help-rotate">Rotate view</div>                        <div class="cesium-navigation-help-details">Middle click + drag, or</div>                        <div class="cesium-navigation-help-details">CTRL + Left/Right click + drag</div>                    </td>                </tr>            </table>`;
  instructionContainer.appendChild(clickInstructions);
  const touchInstructions = document.createElement("div");
  touchInstructions.className = "cesium-touch-navigation-help cesium-navigation-help-instructions";
  touchInstructions.setAttribute(
    "data-bind",
    'css: { "cesium-touch-navigation-help-visible" : _touch}'
  );
  touchInstructions.innerHTML = `            <table>                <tr>                    <td><img src="${buildModuleUrl_default(
    "Widgets/Images/NavigationHelp/TouchDrag.svg"
  )}" width="70" height="48" /></td>                    <td>                        <div class="cesium-navigation-help-pan">Pan view</div>                        <div class="cesium-navigation-help-details">One finger drag</div>                    </td>                </tr>                <tr>                    <td><img src="${buildModuleUrl_default(
    "Widgets/Images/NavigationHelp/TouchZoom.svg"
  )}" width="70" height="48" /></td>                    <td>                        <div class="cesium-navigation-help-zoom">Zoom view</div>                        <div class="cesium-navigation-help-details">Two finger pinch</div>                    </td>                </tr>                <tr>                    <td><img src="${buildModuleUrl_default(
    "Widgets/Images/NavigationHelp/TouchTilt.svg"
  )}" width="70" height="48" /></td>                    <td>                        <div class="cesium-navigation-help-rotate">Tilt view</div>                        <div class="cesium-navigation-help-details">Two finger drag, same direction</div>                    </td>                </tr>                <tr>                    <td><img src="${buildModuleUrl_default(
    "Widgets/Images/NavigationHelp/TouchRotate.svg"
  )}" width="70" height="48" /></td>                    <td>                        <div class="cesium-navigation-help-tilt">Rotate view</div>                        <div class="cesium-navigation-help-details">Two finger drag, opposite direction</div>                    </td>                </tr>            </table>`;
  instructionContainer.appendChild(touchInstructions);
  knockout_default.applyBindings(viewModel, wrapper);
  this._container = container;
  this._viewModel = viewModel;
  this._wrapper = wrapper;
  this._closeInstructions = function(e2) {
    if (!wrapper.contains(e2.target)) {
      viewModel.showInstructions = false;
    }
  };
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.addEventListener("pointerdown", this._closeInstructions, true);
  } else {
    document.addEventListener("mousedown", this._closeInstructions, true);
    document.addEventListener("touchstart", this._closeInstructions, true);
  }
}
Object.defineProperties(NavigationHelpButton.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
NavigationHelpButton.prototype.isDestroyed = function() {
  return false;
};
NavigationHelpButton.prototype.destroy = function() {
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.removeEventListener("pointerdown", this._closeInstructions, true);
  } else {
    document.removeEventListener("mousedown", this._closeInstructions, true);
    document.removeEventListener("touchstart", this._closeInstructions, true);
  }
  knockout_default.cleanNode(this._wrapper);
  this._container.removeChild(this._wrapper);
  return destroyObject_default(this);
};
var NavigationHelpButton_default = NavigationHelpButton;

// node_modules/cesium/Source/Widgets/PerformanceWatchdog/PerformanceWatchdogViewModel.js
function PerformanceWatchdogViewModel(options) {
  if (!defined_default(options) || !defined_default(options.scene)) {
    throw new DeveloperError_default("options.scene is required.");
  }
  this._scene = options.scene;
  this.lowFrameRateMessage = defaultValue_default(
    options.lowFrameRateMessage,
    "This application appears to be performing poorly on your system.  Please try using a different web browser or updating your video drivers."
  );
  this.lowFrameRateMessageDismissed = false;
  this.showingLowFrameRateMessage = false;
  knockout_default.track(this, [
    "lowFrameRateMessage",
    "lowFrameRateMessageDismissed",
    "showingLowFrameRateMessage"
  ]);
  const that = this;
  this._dismissMessage = createCommand_default(function() {
    that.showingLowFrameRateMessage = false;
    that.lowFrameRateMessageDismissed = true;
  });
  const monitor = FrameRateMonitor_default.fromScene(options.scene);
  this._unsubscribeLowFrameRate = monitor.lowFrameRate.addEventListener(
    function() {
      if (!that.lowFrameRateMessageDismissed) {
        that.showingLowFrameRateMessage = true;
      }
    }
  );
  this._unsubscribeNominalFrameRate = monitor.nominalFrameRate.addEventListener(
    function() {
      that.showingLowFrameRateMessage = false;
    }
  );
}
Object.defineProperties(PerformanceWatchdogViewModel.prototype, {
  scene: {
    get: function() {
      return this._scene;
    }
  },
  dismissMessage: {
    get: function() {
      return this._dismissMessage;
    }
  }
});
PerformanceWatchdogViewModel.prototype.destroy = function() {
  this._unsubscribeLowFrameRate();
  this._unsubscribeNominalFrameRate();
  return destroyObject_default(this);
};
var PerformanceWatchdogViewModel_default = PerformanceWatchdogViewModel;

// node_modules/cesium/Source/Widgets/PerformanceWatchdog/PerformanceWatchdog.js
function PerformanceWatchdog(options) {
  if (!defined_default(options) || !defined_default(options.container)) {
    throw new DeveloperError_default("options.container is required.");
  }
  if (!defined_default(options.scene)) {
    throw new DeveloperError_default("options.scene is required.");
  }
  const container = getElement_default(options.container);
  const viewModel = new PerformanceWatchdogViewModel_default(options);
  const element = document.createElement("div");
  element.className = "cesium-performance-watchdog-message-area";
  element.setAttribute("data-bind", "visible: showingLowFrameRateMessage");
  const dismissButton = document.createElement("button");
  dismissButton.setAttribute("type", "button");
  dismissButton.className = "cesium-performance-watchdog-message-dismiss";
  dismissButton.innerHTML = "&times;";
  dismissButton.setAttribute("data-bind", "click: dismissMessage");
  element.appendChild(dismissButton);
  const message = document.createElement("div");
  message.className = "cesium-performance-watchdog-message";
  message.setAttribute("data-bind", "html: lowFrameRateMessage");
  element.appendChild(message);
  container.appendChild(element);
  knockout_default.applyBindings(viewModel, element);
  this._container = container;
  this._viewModel = viewModel;
  this._element = element;
}
Object.defineProperties(PerformanceWatchdog.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
PerformanceWatchdog.prototype.isDestroyed = function() {
  return false;
};
PerformanceWatchdog.prototype.destroy = function() {
  this._viewModel.destroy();
  knockout_default.cleanNode(this._element);
  this._container.removeChild(this._element);
  return destroyObject_default(this);
};
var PerformanceWatchdog_default = PerformanceWatchdog;

// node_modules/cesium/Source/Widgets/ProjectionPicker/ProjectionPickerViewModel.js
function ProjectionPickerViewModel(scene) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  this._scene = scene;
  this._orthographic = scene.camera.frustum instanceof OrthographicFrustum_default;
  this._flightInProgress = false;
  this.dropDownVisible = false;
  this.tooltipPerspective = "Perspective Projection";
  this.tooltipOrthographic = "Orthographic Projection";
  this.selectedTooltip = void 0;
  this.sceneMode = scene.mode;
  knockout_default.track(this, [
    "_orthographic",
    "_flightInProgress",
    "sceneMode",
    "dropDownVisible",
    "tooltipPerspective",
    "tooltipOrthographic"
  ]);
  const that = this;
  knockout_default.defineProperty(this, "selectedTooltip", function() {
    if (that._orthographic) {
      return that.tooltipOrthographic;
    }
    return that.tooltipPerspective;
  });
  this._toggleDropDown = createCommand_default(function() {
    if (that.sceneMode === SceneMode_default.SCENE2D || that._flightInProgress) {
      return;
    }
    that.dropDownVisible = !that.dropDownVisible;
  });
  this._eventHelper = new EventHelper_default();
  this._eventHelper.add(scene.morphComplete, function(transitioner, oldMode, newMode, isMorphing) {
    that.sceneMode = newMode;
    that._orthographic = newMode === SceneMode_default.SCENE2D || that._scene.camera.frustum instanceof OrthographicFrustum_default;
  });
  this._eventHelper.add(scene.preRender, function() {
    that._flightInProgress = defined_default(scene.camera._currentFlight);
  });
  this._switchToPerspective = createCommand_default(function() {
    if (that.sceneMode === SceneMode_default.SCENE2D) {
      return;
    }
    that._scene.camera.switchToPerspectiveFrustum();
    that._orthographic = false;
    that.dropDownVisible = false;
  });
  this._switchToOrthographic = createCommand_default(function() {
    if (that.sceneMode === SceneMode_default.SCENE2D) {
      return;
    }
    that._scene.camera.switchToOrthographicFrustum();
    that._orthographic = true;
    that.dropDownVisible = false;
  });
  this._sceneMode = SceneMode_default;
}
Object.defineProperties(ProjectionPickerViewModel.prototype, {
  scene: {
    get: function() {
      return this._scene;
    }
  },
  toggleDropDown: {
    get: function() {
      return this._toggleDropDown;
    }
  },
  switchToPerspective: {
    get: function() {
      return this._switchToPerspective;
    }
  },
  switchToOrthographic: {
    get: function() {
      return this._switchToOrthographic;
    }
  },
  isOrthographicProjection: {
    get: function() {
      return this._orthographic;
    }
  }
});
ProjectionPickerViewModel.prototype.isDestroyed = function() {
  return false;
};
ProjectionPickerViewModel.prototype.destroy = function() {
  this._eventHelper.removeAll();
  destroyObject_default(this);
};
var ProjectionPickerViewModel_default = ProjectionPickerViewModel;

// node_modules/cesium/Source/Widgets/ProjectionPicker/ProjectionPicker.js
var perspectivePath = "M 28.15625,10.4375 9.125,13.21875 13.75,43.25 41.75,55.09375 50.8125,37 54.5,11.9375 z m 0.125,3 19.976451,0.394265 L 43.03125,16.875 22.6875,14.28125 z M 50.971746,15.705477 47.90625,36.03125 42.53125,46 44.84375,19.3125 z M 12.625,16.03125 l 29.15625,3.6875 -2.65625,31 L 16.4375,41.125 z";
var orthographicPath = "m 31.560594,6.5254438 -20.75,12.4687502 0.1875,24.5625 22.28125,11.8125 19.5,-12 0.65625,-0.375 0,-0.75 0.0312,-23.21875 z m 0.0625,3.125 16.65625,9.5000002 -16.125,10.28125 -17.34375,-9.71875 z m 18.96875,11.1875002 0.15625,20.65625 -17.46875,10.59375 0.15625,-20.28125 z m -37.0625,1.25 17.21875,9.625 -0.15625,19.21875 -16.9375,-9 z";
function ProjectionPicker(container, scene) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  container = getElement_default(container);
  const viewModel = new ProjectionPickerViewModel_default(scene);
  viewModel._perspectivePath = perspectivePath;
  viewModel._orthographicPath = orthographicPath;
  const wrapper = document.createElement("span");
  wrapper.className = "cesium-projectionPicker-wrapper cesium-toolbar-button";
  container.appendChild(wrapper);
  const button = document.createElement("button");
  button.type = "button";
  button.className = "cesium-button cesium-toolbar-button";
  button.setAttribute(
    "data-bind",
    'css: { "cesium-projectionPicker-buttonPerspective": !_orthographic,       "cesium-projectionPicker-buttonOrthographic": _orthographic,       "cesium-button-disabled" : sceneMode === _sceneMode.SCENE2D || _flightInProgress,        "cesium-projectionPicker-selected": dropDownVisible },attr: { title: selectedTooltip },click: toggleDropDown'
  );
  button.innerHTML = '<!-- ko cesiumSvgPath: { path: _perspectivePath, width: 64, height: 64, css: "cesium-projectionPicker-iconPerspective" } --><!-- /ko --><!-- ko cesiumSvgPath: { path: _orthographicPath, width: 64, height: 64, css: "cesium-projectionPicker-iconOrthographic" } --><!-- /ko -->';
  wrapper.appendChild(button);
  const perspectiveButton = document.createElement("button");
  perspectiveButton.type = "button";
  perspectiveButton.className = "cesium-button cesium-toolbar-button cesium-projectionPicker-dropDown-icon";
  perspectiveButton.setAttribute(
    "data-bind",
    'css: { "cesium-projectionPicker-visible" : (dropDownVisible && _orthographic),       "cesium-projectionPicker-none" : !_orthographic,       "cesium-projectionPicker-hidden" : !dropDownVisible },attr: { title: tooltipPerspective },click: switchToPerspective,cesiumSvgPath: { path: _perspectivePath, width: 64, height: 64 }'
  );
  wrapper.appendChild(perspectiveButton);
  const orthographicButton = document.createElement("button");
  orthographicButton.type = "button";
  orthographicButton.className = "cesium-button cesium-toolbar-button cesium-projectionPicker-dropDown-icon";
  orthographicButton.setAttribute(
    "data-bind",
    'css: { "cesium-projectionPicker-visible" : (dropDownVisible && !_orthographic),       "cesium-projectionPicker-none" : _orthographic,       "cesium-projectionPicker-hidden" : !dropDownVisible},attr: { title: tooltipOrthographic },click: switchToOrthographic,cesiumSvgPath: { path: _orthographicPath, width: 64, height: 64 }'
  );
  wrapper.appendChild(orthographicButton);
  knockout_default.applyBindings(viewModel, wrapper);
  this._viewModel = viewModel;
  this._container = container;
  this._wrapper = wrapper;
  this._closeDropDown = function(e2) {
    if (!wrapper.contains(e2.target)) {
      viewModel.dropDownVisible = false;
    }
  };
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.addEventListener("pointerdown", this._closeDropDown, true);
  } else {
    document.addEventListener("mousedown", this._closeDropDown, true);
    document.addEventListener("touchstart", this._closeDropDown, true);
  }
}
Object.defineProperties(ProjectionPicker.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
ProjectionPicker.prototype.isDestroyed = function() {
  return false;
};
ProjectionPicker.prototype.destroy = function() {
  this._viewModel.destroy();
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.removeEventListener("pointerdown", this._closeDropDown, true);
  } else {
    document.removeEventListener("mousedown", this._closeDropDown, true);
    document.removeEventListener("touchstart", this._closeDropDown, true);
  }
  knockout_default.cleanNode(this._wrapper);
  this._container.removeChild(this._wrapper);
  return destroyObject_default(this);
};
var ProjectionPicker_default = ProjectionPicker;

// node_modules/cesium/Source/Widgets/SceneModePicker/SceneModePickerViewModel.js
function SceneModePickerViewModel(scene, duration) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  this._scene = scene;
  const that = this;
  const morphStart = function(transitioner, oldMode, newMode, isMorphing) {
    that.sceneMode = newMode;
    that.dropDownVisible = false;
  };
  this._eventHelper = new EventHelper_default();
  this._eventHelper.add(scene.morphStart, morphStart);
  this._duration = defaultValue_default(duration, 2);
  this.sceneMode = scene.mode;
  this.dropDownVisible = false;
  this.tooltip2D = "2D";
  this.tooltip3D = "3D";
  this.tooltipColumbusView = "Columbus View";
  knockout_default.track(this, [
    "sceneMode",
    "dropDownVisible",
    "tooltip2D",
    "tooltip3D",
    "tooltipColumbusView"
  ]);
  this.selectedTooltip = void 0;
  knockout_default.defineProperty(this, "selectedTooltip", function() {
    const mode2 = that.sceneMode;
    if (mode2 === SceneMode_default.SCENE2D) {
      return that.tooltip2D;
    }
    if (mode2 === SceneMode_default.SCENE3D) {
      return that.tooltip3D;
    }
    return that.tooltipColumbusView;
  });
  this._toggleDropDown = createCommand_default(function() {
    that.dropDownVisible = !that.dropDownVisible;
  });
  this._morphTo2D = createCommand_default(function() {
    scene.morphTo2D(that._duration);
  });
  this._morphTo3D = createCommand_default(function() {
    scene.morphTo3D(that._duration);
  });
  this._morphToColumbusView = createCommand_default(function() {
    scene.morphToColumbusView(that._duration);
  });
  this._sceneMode = SceneMode_default;
}
Object.defineProperties(SceneModePickerViewModel.prototype, {
  scene: {
    get: function() {
      return this._scene;
    }
  },
  duration: {
    get: function() {
      return this._duration;
    },
    set: function(value) {
      if (value < 0) {
        throw new DeveloperError_default("duration value must be positive.");
      }
      this._duration = value;
    }
  },
  toggleDropDown: {
    get: function() {
      return this._toggleDropDown;
    }
  },
  morphTo2D: {
    get: function() {
      return this._morphTo2D;
    }
  },
  morphTo3D: {
    get: function() {
      return this._morphTo3D;
    }
  },
  morphToColumbusView: {
    get: function() {
      return this._morphToColumbusView;
    }
  }
});
SceneModePickerViewModel.prototype.isDestroyed = function() {
  return false;
};
SceneModePickerViewModel.prototype.destroy = function() {
  this._eventHelper.removeAll();
  destroyObject_default(this);
};
var SceneModePickerViewModel_default = SceneModePickerViewModel;

// node_modules/cesium/Source/Widgets/SceneModePicker/SceneModePicker.js
var globePath = "m 32.401392,4.9330437 c -7.087603,0 -14.096095,2.884602 -19.10793,7.8946843 -5.0118352,5.010083 -7.9296167,11.987468 -7.9296167,19.072999 0,7.085531 2.9177815,14.097848 7.9296167,19.107931 4.837653,4.835961 11.541408,7.631372 18.374354,7.82482 0.05712,0.01231 0.454119,0.139729 0.454119,0.139729 l 0.03493,-0.104797 c 0.08246,7.84e-4 0.162033,0.03493 0.244525,0.03493 0.08304,0 0.161515,-0.03414 0.244526,-0.03493 l 0.03493,0.104797 c 0,0 0.309474,-0.129487 0.349323,-0.139729 6.867765,-0.168094 13.582903,-2.965206 18.444218,-7.82482 2.558195,-2.5573 4.551081,-5.638134 5.903547,-8.977584 1.297191,-3.202966 2.02607,-6.661489 2.02607,-10.130347 0,-6.237309 -2.366261,-12.31219 -6.322734,-17.116794 -0.0034,-0.02316 0.0049,-0.04488 0,-0.06986 -0.01733,-0.08745 -0.104529,-0.278855 -0.104797,-0.279458 -5.31e-4,-0.0012 -0.522988,-0.628147 -0.523984,-0.62878         -3.47e-4,-2.2e-4 -0.133444,-0.03532 -0.244525,-0.06987 C 51.944299,13.447603 51.751076,13.104317 51.474391,12.827728 46.462556,7.8176457 39.488996,4.9330437 32.401392,4.9330437 z m -2.130866,3.5281554 0.104797,9.6762289 c -4.111695,-0.08361 -7.109829,-0.423664 -9.257041,-0.943171 1.198093,-2.269271 2.524531,-4.124404 3.91241,-5.414496 2.167498,-2.0147811 3.950145,-2.8540169 5.239834,-3.3185619 z m 2.794579,0 c 1.280302,0.4754953 3.022186,1.3285948 5.065173,3.2486979 1.424667,1.338973 2.788862,3.303645 3.982275,5.728886 -2.29082,0.403367 -5.381258,0.621049 -8.942651,0.698645 L 33.065105,8.4611991 z m 5.728886,0.2445256 c 4.004072,1.1230822 7.793098,3.1481363 10.724195,6.0782083 0.03468,0.03466 0.07033,0.06991 0.104797,0.104797 -0.45375,0.313891 -0.923054,0.663002 -1.956205,1.082899 -0.647388,0.263114 -1.906242,0.477396 -2.829511,0.733577 -1.382296,-2.988132         -3.027146,-5.368585 -4.785716,-7.0213781 -0.422866,-0.397432 -0.835818,-0.6453247 -1.25756,-0.9781032 z m -15.33525,0.7685092 c -0.106753,0.09503 -0.207753,0.145402 -0.31439,0.244526 -1.684973,1.5662541 -3.298068,3.8232211 -4.680919,6.5672591 -0.343797,-0.14942 -1.035052,-0.273198 -1.292493,-0.419186 -0.956528,-0.542427 -1.362964,-1.022024 -1.537018,-1.292493 -0.0241,-0.03745 -0.01868,-0.0401 -0.03493,-0.06986 2.250095,-2.163342 4.948824,-3.869984 7.859752,-5.0302421 z m -9.641296,7.0912431 c 0.464973,0.571618 0.937729,1.169056 1.956205,1.746612 0.349907,0.198425 1.107143,0.335404 1.537018,0.523983 -1.20166,3.172984 -1.998037,7.051901 -2.165798,11.772162 C 14.256557,30.361384 12.934823,30.161483 12.280427,29.90959 10.644437,29.279855 9.6888882,28.674891 9.1714586,28.267775 8.6540289,27.860658 8.6474751,27.778724 8.6474751,27.778724 l -0.069864,0.03493 C 9.3100294,23.691285         11.163248,19.798527 13.817445,16.565477 z m 37.552149,0.523984 c 2.548924,3.289983 4.265057,7.202594 4.890513,11.318043 -0.650428,0.410896 -1.756876,1.001936 -3.563088,1.606882 -1.171552,0.392383 -3.163859,0.759153 -4.960377,1.117832 -0.04367,-4.752703 -0.784809,-8.591423 -1.88634,-11.807094 0.917574,-0.263678 2.170552,-0.486495 2.864443,-0.76851 1.274693,-0.518066 2.003942,-1.001558 2.654849,-1.467153 z m -31.439008,2.619917 c 2.487341,0.672766 5.775813,1.137775 10.479669,1.222628 l 0.104797,10.689263 0,0.03493 0,0.733577 c -5.435005,-0.09059 -9.512219,-0.519044 -12.610536,-1.117831 0.106127,-4.776683 0.879334,-8.55791 2.02607,-11.562569 z m 23.264866,0.31439 c 1.073459,3.067541 1.833795,6.821314 1.816476,11.702298 -3.054474,0.423245 -7.062018,0.648559 -11.702298,0.698644 l 0,-0.838373 -0.104796,-10.654331 c 4.082416,-0.0864 7.404468,-0.403886 9.990618,-0.908238 z         M 8.2632205,30.922625 c 0.7558676,0.510548 1.5529563,1.013339 3.0041715,1.57195 0.937518,0.360875 2.612202,0.647642 3.91241,0.978102 0.112814,3.85566 0.703989,7.107756 1.606883,9.920754 -1.147172,-0.324262 -2.644553,-0.640648 -3.423359,-0.978102 -1.516688,-0.657177 -2.386627,-1.287332 -2.864443,-1.71168 -0.477816,-0.424347 -0.489051,-0.489051 -0.489051,-0.489051 L 9.8002387,40.319395 C 8.791691,37.621767 8.1584238,34.769583 8.1584238,31.900727 c 0,-0.330153 0.090589,-0.648169 0.1047967,-0.978102 z m 48.2763445,0.419186 c 0.0047,0.188973 0.06986,0.36991 0.06986,0.558916 0,2.938869 -0.620228,5.873558 -1.676747,8.628261 -0.07435,0.07583 -0.06552,0.07411 -0.454119,0.349323 -0.606965,0.429857 -1.631665,1.042044 -3.318562,1.676747 -1.208528,0.454713 -3.204964,0.850894 -5.135038,1.25756 0.84593,-2.765726 1.41808,-6.005357 1.606883,-9.815957 2.232369,-0.413371 4.483758,-0.840201         5.938479,-1.327425 1.410632,-0.472457 2.153108,-0.89469 2.96924,-1.327425 z m -38.530252,2.864443 c 3.208141,0.56697 7.372279,0.898588 12.575603,0.978103 l 0.174662,9.885821 c -4.392517,-0.06139 -8.106722,-0.320566 -10.863925,-0.803441 -1.051954,-2.664695 -1.692909,-6.043794 -1.88634,-10.060483 z m 26.793022,0.31439 c -0.246298,3.923551 -0.877762,7.263679 -1.816476,9.885822 -2.561957,0.361954 -5.766249,0.560708 -9.431703,0.62878 l -0.174661,-9.815957 c 4.491734,-0.04969 8.334769,-0.293032 11.42284,-0.698645 z M 12.035901,44.860585 c 0.09977,0.04523 0.105535,0.09465 0.209594,0.139729 1.337656,0.579602 3.441099,1.058072 5.589157,1.537018 1.545042,3.399208 3.548524,5.969402 5.589157,7.789888 -3.034411,-1.215537 -5.871615,-3.007978 -8.174142,-5.309699 -1.245911,-1.245475 -2.271794,-2.662961 -3.213766,-4.156936 z m 40.69605,0 c -0.941972,1.493975 -1.967855,2.911461         -3.213765,4.156936 -2.74253,2.741571 -6.244106,4.696717 -9.955686,5.868615 0.261347,-0.241079 0.507495,-0.394491 0.768509,-0.663713 1.674841,-1.727516 3.320792,-4.181056 4.645987,-7.265904 2.962447,-0.503021 5.408965,-1.122293 7.161107,-1.781544 0.284034,-0.106865 0.337297,-0.207323 0.593848,-0.31439 z m -31.404076,2.305527 c 2.645807,0.376448 5.701178,0.649995 9.466635,0.698645 l 0.139729,7.789888 c -1.38739,-0.480844 -3.316218,-1.29837 -5.659022,-3.388427 -1.388822,-1.238993 -2.743668,-3.0113 -3.947342,-5.100106 z m 20.365491,0.104797 c -1.04872,2.041937 -2.174337,3.779068 -3.353494,4.995309 -1.853177,1.911459 -3.425515,2.82679 -4.611055,3.353494 l -0.139729,-7.789887 c 3.13091,-0.05714 5.728238,-0.278725 8.104278,-0.558916 z";
var flatMapPath = "m 2.9825053,17.550598 0,1.368113 0,26.267766 0,1.368113 1.36811,0 54.9981397,0 1.36811,0 0,-1.368113 0,-26.267766 0,-1.368113 -1.36811,0 -54.9981397,0 -1.36811,0 z m 2.73623,2.736226 10.3292497,0 0,10.466063 -10.3292497,0 0,-10.466063 z m 13.0654697,0 11.69737,0 0,10.466063 -11.69737,0 0,-10.466063 z m 14.43359,0 11.69737,0 0,10.466063 -11.69737,0 0,-10.466063 z m 14.43359,0 10.32926,0 0,10.466063 -10.32926,0 0,-10.466063 z m -41.9326497,13.202288 10.3292497,0 0,10.329252 -10.3292497,0 0,-10.329252 z m 13.0654697,0 11.69737,0 0,10.329252 -11.69737,0 0,-10.329252 z m 14.43359,0 11.69737,0 0,10.329252 -11.69737,0 0,-10.329252 z m 14.43359,0 10.32926,0 0,10.329252 -10.32926,0 0,-10.329252 z";
var columbusViewPath = "m 14.723969,17.675598 -0.340489,0.817175 -11.1680536,26.183638 -0.817175,1.872692 2.076986,0 54.7506996,0 2.07698,0 -0.81717,-1.872692 -11.16805,-26.183638 -0.34049,-0.817175 -0.91933,0 -32.414586,0 -0.919322,0 z m 1.838643,2.723916 6.196908,0 -2.928209,10.418977 -7.729111,0 4.460412,-10.418977 z m 9.02297,0 4.903049,0 0,10.418977 -7.831258,0 2.928209,-10.418977 z m 7.626964,0 5.584031,0 2.62176,10.418977 -8.205791,0 0,-10.418977 z m 8.410081,0 5.51593,0 4.46042,10.418977 -7.38863,0 -2.58772,-10.418977 z m -30.678091,13.142892 8.103649,0 -2.89416,10.282782 -9.6018026,0 4.3923136,-10.282782 z m 10.929711,0 8.614384,0 0,10.282782 -11.508544,0 2.89416,-10.282782 z m 11.338299,0 8.852721,0 2.58772,10.282782 -11.440441,0 0,-10.282782 z m 11.678781,0 7.86531,0 4.39231,10.282782 -9.6699,0 -2.58772,-10.282782 z";
function SceneModePicker(container, scene, duration) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  container = getElement_default(container);
  const viewModel = new SceneModePickerViewModel_default(scene, duration);
  viewModel._globePath = globePath;
  viewModel._flatMapPath = flatMapPath;
  viewModel._columbusViewPath = columbusViewPath;
  const wrapper = document.createElement("span");
  wrapper.className = "cesium-sceneModePicker-wrapper cesium-toolbar-button";
  container.appendChild(wrapper);
  const button = document.createElement("button");
  button.type = "button";
  button.className = "cesium-button cesium-toolbar-button";
  button.setAttribute(
    "data-bind",
    'css: { "cesium-sceneModePicker-button2D": sceneMode === _sceneMode.SCENE2D,       "cesium-sceneModePicker-button3D": sceneMode === _sceneMode.SCENE3D,       "cesium-sceneModePicker-buttonColumbusView": sceneMode === _sceneMode.COLUMBUS_VIEW,       "cesium-sceneModePicker-selected": dropDownVisible },attr: { title: selectedTooltip },click: toggleDropDown'
  );
  button.innerHTML = '<!-- ko cesiumSvgPath: { path: _globePath, width: 64, height: 64, css: "cesium-sceneModePicker-slide-svg cesium-sceneModePicker-icon3D" } --><!-- /ko --><!-- ko cesiumSvgPath: { path: _flatMapPath, width: 64, height: 64, css: "cesium-sceneModePicker-slide-svg cesium-sceneModePicker-icon2D" } --><!-- /ko --><!-- ko cesiumSvgPath: { path: _columbusViewPath, width: 64, height: 64, css: "cesium-sceneModePicker-slide-svg cesium-sceneModePicker-iconColumbusView" } --><!-- /ko -->';
  wrapper.appendChild(button);
  const morphTo3DButton = document.createElement("button");
  morphTo3DButton.type = "button";
  morphTo3DButton.className = "cesium-button cesium-toolbar-button cesium-sceneModePicker-dropDown-icon";
  morphTo3DButton.setAttribute(
    "data-bind",
    'css: { "cesium-sceneModePicker-visible" : (dropDownVisible && (sceneMode !== _sceneMode.SCENE3D)) || (!dropDownVisible && (sceneMode === _sceneMode.SCENE3D)),       "cesium-sceneModePicker-none" : sceneMode === _sceneMode.SCENE3D,       "cesium-sceneModePicker-hidden" : !dropDownVisible },attr: { title: tooltip3D },click: morphTo3D,cesiumSvgPath: { path: _globePath, width: 64, height: 64 }'
  );
  wrapper.appendChild(morphTo3DButton);
  const morphTo2DButton = document.createElement("button");
  morphTo2DButton.type = "button";
  morphTo2DButton.className = "cesium-button cesium-toolbar-button cesium-sceneModePicker-dropDown-icon";
  morphTo2DButton.setAttribute(
    "data-bind",
    'css: { "cesium-sceneModePicker-visible" : (dropDownVisible && (sceneMode !== _sceneMode.SCENE2D)),       "cesium-sceneModePicker-none" : sceneMode === _sceneMode.SCENE2D,       "cesium-sceneModePicker-hidden" : !dropDownVisible },attr: { title: tooltip2D },click: morphTo2D,cesiumSvgPath: { path: _flatMapPath, width: 64, height: 64 }'
  );
  wrapper.appendChild(morphTo2DButton);
  const morphToCVButton = document.createElement("button");
  morphToCVButton.type = "button";
  morphToCVButton.className = "cesium-button cesium-toolbar-button cesium-sceneModePicker-dropDown-icon";
  morphToCVButton.setAttribute(
    "data-bind",
    'css: { "cesium-sceneModePicker-visible" : (dropDownVisible && (sceneMode !== _sceneMode.COLUMBUS_VIEW)) || (!dropDownVisible && (sceneMode === _sceneMode.COLUMBUS_VIEW)),       "cesium-sceneModePicker-none" : sceneMode === _sceneMode.COLUMBUS_VIEW,       "cesium-sceneModePicker-hidden" : !dropDownVisible},attr: { title: tooltipColumbusView },click: morphToColumbusView,cesiumSvgPath: { path: _columbusViewPath, width: 64, height: 64 }'
  );
  wrapper.appendChild(morphToCVButton);
  knockout_default.applyBindings(viewModel, wrapper);
  this._viewModel = viewModel;
  this._container = container;
  this._wrapper = wrapper;
  this._closeDropDown = function(e2) {
    if (!wrapper.contains(e2.target)) {
      viewModel.dropDownVisible = false;
    }
  };
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.addEventListener("pointerdown", this._closeDropDown, true);
  } else {
    document.addEventListener("mousedown", this._closeDropDown, true);
    document.addEventListener("touchstart", this._closeDropDown, true);
  }
}
Object.defineProperties(SceneModePicker.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
SceneModePicker.prototype.isDestroyed = function() {
  return false;
};
SceneModePicker.prototype.destroy = function() {
  this._viewModel.destroy();
  if (FeatureDetection_default.supportsPointerEvents()) {
    document.removeEventListener("pointerdown", this._closeDropDown, true);
  } else {
    document.removeEventListener("mousedown", this._closeDropDown, true);
    document.removeEventListener("touchstart", this._closeDropDown, true);
  }
  knockout_default.cleanNode(this._wrapper);
  this._container.removeChild(this._wrapper);
  return destroyObject_default(this);
};
var SceneModePicker_default = SceneModePicker;

// node_modules/cesium/Source/Widgets/SelectionIndicator/SelectionIndicatorViewModel.js
var screenSpacePos = new Cartesian2_default();
var offScreen = "-1000px";
function SelectionIndicatorViewModel(scene, selectionIndicatorElement, container) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  if (!defined_default(selectionIndicatorElement)) {
    throw new DeveloperError_default("selectionIndicatorElement is required.");
  }
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  this._scene = scene;
  this._screenPositionX = offScreen;
  this._screenPositionY = offScreen;
  this._tweens = scene.tweens;
  this._container = defaultValue_default(container, document.body);
  this._selectionIndicatorElement = selectionIndicatorElement;
  this._scale = 1;
  this.position = void 0;
  this.showSelection = false;
  knockout_default.track(this, [
    "position",
    "_screenPositionX",
    "_screenPositionY",
    "_scale",
    "showSelection"
  ]);
  this.isVisible = void 0;
  knockout_default.defineProperty(this, "isVisible", {
    get: function() {
      return this.showSelection && defined_default(this.position);
    }
  });
  knockout_default.defineProperty(this, "_transform", {
    get: function() {
      return `scale(${this._scale})`;
    }
  });
  this.computeScreenSpacePosition = function(position, result) {
    return SceneTransforms_default.wgs84ToWindowCoordinates(scene, position, result);
  };
}
SelectionIndicatorViewModel.prototype.update = function() {
  if (this.showSelection && defined_default(this.position)) {
    const screenPosition = this.computeScreenSpacePosition(
      this.position,
      screenSpacePos
    );
    if (!defined_default(screenPosition)) {
      this._screenPositionX = offScreen;
      this._screenPositionY = offScreen;
    } else {
      const container = this._container;
      const containerWidth = container.parentNode.clientWidth;
      const containerHeight = container.parentNode.clientHeight;
      const indicatorSize = this._selectionIndicatorElement.clientWidth;
      const halfSize = indicatorSize * 0.5;
      screenPosition.x = Math.min(
        Math.max(screenPosition.x, -indicatorSize),
        containerWidth + indicatorSize
      ) - halfSize;
      screenPosition.y = Math.min(
        Math.max(screenPosition.y, -indicatorSize),
        containerHeight + indicatorSize
      ) - halfSize;
      this._screenPositionX = `${Math.floor(screenPosition.x + 0.25)}px`;
      this._screenPositionY = `${Math.floor(screenPosition.y + 0.25)}px`;
    }
  }
};
SelectionIndicatorViewModel.prototype.animateAppear = function() {
  this._tweens.addProperty({
    object: this,
    property: "_scale",
    startValue: 2,
    stopValue: 1,
    duration: 0.8,
    easingFunction: EasingFunction_default.EXPONENTIAL_OUT
  });
};
SelectionIndicatorViewModel.prototype.animateDepart = function() {
  this._tweens.addProperty({
    object: this,
    property: "_scale",
    startValue: this._scale,
    stopValue: 1.5,
    duration: 0.8,
    easingFunction: EasingFunction_default.EXPONENTIAL_OUT
  });
};
Object.defineProperties(SelectionIndicatorViewModel.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  selectionIndicatorElement: {
    get: function() {
      return this._selectionIndicatorElement;
    }
  },
  scene: {
    get: function() {
      return this._scene;
    }
  }
});
var SelectionIndicatorViewModel_default = SelectionIndicatorViewModel;

// node_modules/cesium/Source/Widgets/SelectionIndicator/SelectionIndicator.js
function SelectionIndicator(container, scene) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  container = getElement_default(container);
  this._container = container;
  const el = document.createElement("div");
  el.className = "cesium-selection-wrapper";
  el.setAttribute(
    "data-bind",
    'style: { "top" : _screenPositionY, "left" : _screenPositionX },css: { "cesium-selection-wrapper-visible" : isVisible }'
  );
  container.appendChild(el);
  this._element = el;
  const svgNS3 = "http://www.w3.org/2000/svg";
  const path = "M -34 -34 L -34 -11.25 L -30 -15.25 L -30 -30 L -15.25 -30 L -11.25 -34 L -34 -34 z M 11.25 -34 L 15.25 -30 L 30 -30 L 30 -15.25 L 34 -11.25 L 34 -34 L 11.25 -34 z M -34 11.25 L -34 34 L -11.25 34 L -15.25 30 L -30 30 L -30 15.25 L -34 11.25 z M 34 11.25 L 30 15.25 L 30 30 L 15.25 30 L 11.25 34 L 34 34 L 34 11.25 z";
  const svg2 = document.createElementNS(svgNS3, "svg:svg");
  svg2.setAttribute("width", 160);
  svg2.setAttribute("height", 160);
  svg2.setAttribute("viewBox", "0 0 160 160");
  const group = document.createElementNS(svgNS3, "g");
  group.setAttribute("transform", "translate(80,80)");
  svg2.appendChild(group);
  const pathElement = document.createElementNS(svgNS3, "path");
  pathElement.setAttribute("data-bind", "attr: { transform: _transform }");
  pathElement.setAttribute("d", path);
  group.appendChild(pathElement);
  el.appendChild(svg2);
  const viewModel = new SelectionIndicatorViewModel_default(
    scene,
    this._element,
    this._container
  );
  this._viewModel = viewModel;
  knockout_default.applyBindings(this._viewModel, this._element);
}
Object.defineProperties(SelectionIndicator.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
SelectionIndicator.prototype.isDestroyed = function() {
  return false;
};
SelectionIndicator.prototype.destroy = function() {
  const container = this._container;
  knockout_default.cleanNode(this._element);
  container.removeChild(this._element);
  return destroyObject_default(this);
};
var SelectionIndicator_default = SelectionIndicator;

// node_modules/cesium/Source/Widgets/Timeline/TimelineHighlightRange.js
function TimelineHighlightRange(color, heightInPx, base) {
  this._color = color;
  this._height = heightInPx;
  this._base = defaultValue_default(base, 0);
}
TimelineHighlightRange.prototype.getHeight = function() {
  return this._height;
};
TimelineHighlightRange.prototype.getBase = function() {
  return this._base;
};
TimelineHighlightRange.prototype.getStartTime = function() {
  return this._start;
};
TimelineHighlightRange.prototype.getStopTime = function() {
  return this._stop;
};
TimelineHighlightRange.prototype.setRange = function(start, stop2) {
  this._start = start;
  this._stop = stop2;
};
TimelineHighlightRange.prototype.render = function(renderState) {
  let range2 = "";
  if (this._start && this._stop && this._color) {
    const highlightStart = JulianDate_default.secondsDifference(
      this._start,
      renderState.epochJulian
    );
    let highlightLeft = Math.round(
      renderState.timeBarWidth * renderState.getAlpha(highlightStart)
    );
    const highlightStop = JulianDate_default.secondsDifference(
      this._stop,
      renderState.epochJulian
    );
    let highlightWidth = Math.round(
      renderState.timeBarWidth * renderState.getAlpha(highlightStop)
    ) - highlightLeft;
    if (highlightLeft < 0) {
      highlightWidth += highlightLeft;
      highlightLeft = 0;
    }
    if (highlightLeft + highlightWidth > renderState.timeBarWidth) {
      highlightWidth = renderState.timeBarWidth - highlightLeft;
    }
    if (highlightWidth > 0) {
      range2 = `<span class="cesium-timeline-highlight" style="left: ${highlightLeft.toString()}px; width: ${highlightWidth.toString()}px; bottom: ${this._base.toString()}px; height: ${this._height}px; background-color: ${this._color};"></span>`;
    }
  }
  return range2;
};
var TimelineHighlightRange_default = TimelineHighlightRange;

// node_modules/cesium/Source/Widgets/Timeline/TimelineTrack.js
function TimelineTrack(interval, pixelHeight, color, backgroundColor) {
  this.interval = interval;
  this.height = pixelHeight;
  this.color = color || new Color_default(0.5, 0.5, 0.5, 1);
  this.backgroundColor = backgroundColor || new Color_default(0, 0, 0, 0);
}
TimelineTrack.prototype.render = function(context, renderState) {
  const startInterval = this.interval.start;
  const stopInterval = this.interval.stop;
  const spanStart = renderState.startJulian;
  const spanStop = JulianDate_default.addSeconds(
    renderState.startJulian,
    renderState.duration,
    new JulianDate_default()
  );
  if (JulianDate_default.lessThan(startInterval, spanStart) && JulianDate_default.greaterThan(stopInterval, spanStop)) {
    context.fillStyle = this.color.toCssColorString();
    context.fillRect(0, renderState.y, renderState.timeBarWidth, this.height);
  } else if (JulianDate_default.lessThanOrEquals(startInterval, spanStop) && JulianDate_default.greaterThanOrEquals(stopInterval, spanStart)) {
    let x;
    let start, stop2;
    for (x = 0; x < renderState.timeBarWidth; ++x) {
      const currentTime = JulianDate_default.addSeconds(
        renderState.startJulian,
        x / renderState.timeBarWidth * renderState.duration,
        new JulianDate_default()
      );
      if (!defined_default(start) && JulianDate_default.greaterThanOrEquals(currentTime, startInterval)) {
        start = x;
      } else if (!defined_default(stop2) && JulianDate_default.greaterThanOrEquals(currentTime, stopInterval)) {
        stop2 = x;
      }
    }
    context.fillStyle = this.backgroundColor.toCssColorString();
    context.fillRect(0, renderState.y, renderState.timeBarWidth, this.height);
    if (defined_default(start)) {
      if (!defined_default(stop2)) {
        stop2 = renderState.timeBarWidth;
      }
      context.fillStyle = this.color.toCssColorString();
      context.fillRect(
        start,
        renderState.y,
        Math.max(stop2 - start, 1),
        this.height
      );
    }
  }
};
var TimelineTrack_default = TimelineTrack;

// node_modules/cesium/Source/Widgets/Timeline/Timeline.js
var timelineWheelDelta = 1e12;
var timelineMouseMode = {
  none: 0,
  scrub: 1,
  slide: 2,
  zoom: 3,
  touchOnly: 4
};
var timelineTouchMode = {
  none: 0,
  scrub: 1,
  slideZoom: 2,
  singleTap: 3,
  ignore: 4
};
var timelineTicScales = [
  1e-3,
  2e-3,
  5e-3,
  0.01,
  0.02,
  0.05,
  0.1,
  0.25,
  0.5,
  1,
  2,
  5,
  10,
  15,
  30,
  60,
  120,
  300,
  600,
  900,
  1800,
  3600,
  7200,
  14400,
  21600,
  43200,
  86400,
  172800,
  345600,
  604800,
  1296e3,
  2592e3,
  5184e3,
  7776e3,
  15552e3,
  31536e3,
  63072e3,
  126144e3,
  15768e4,
  31536e4,
  63072e4,
  126144e4,
  15768e5,
  31536e5,
  63072e5,
  126144e5,
  15768e6,
  31536e6
];
var timelineMonthNames = [
  "Jan",
  "Feb",
  "Mar",
  "Apr",
  "May",
  "Jun",
  "Jul",
  "Aug",
  "Sep",
  "Oct",
  "Nov",
  "Dec"
];
function Timeline(container, clock) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  if (!defined_default(clock)) {
    throw new DeveloperError_default("clock is required.");
  }
  container = getElement_default(container);
  const ownerDocument = container.ownerDocument;
  this.container = container;
  const topDiv = ownerDocument.createElement("div");
  topDiv.className = "cesium-timeline-main";
  container.appendChild(topDiv);
  this._topDiv = topDiv;
  this._endJulian = void 0;
  this._epochJulian = void 0;
  this._lastXPos = void 0;
  this._scrubElement = void 0;
  this._startJulian = void 0;
  this._timeBarSecondsSpan = void 0;
  this._clock = clock;
  this._scrubJulian = clock.currentTime;
  this._mainTicSpan = -1;
  this._mouseMode = timelineMouseMode.none;
  this._touchMode = timelineTouchMode.none;
  this._touchState = {
    centerX: 0,
    spanX: 0
  };
  this._mouseX = 0;
  this._timelineDrag = 0;
  this._timelineDragLocation = void 0;
  this._lastHeight = void 0;
  this._lastWidth = void 0;
  this._topDiv.innerHTML = '<div class="cesium-timeline-bar"></div><div class="cesium-timeline-trackContainer"><canvas class="cesium-timeline-tracks" width="10" height="1"></canvas></div><div class="cesium-timeline-needle"></div><span class="cesium-timeline-ruler"></span>';
  this._timeBarEle = this._topDiv.childNodes[0];
  this._trackContainer = this._topDiv.childNodes[1];
  this._trackListEle = this._topDiv.childNodes[1].childNodes[0];
  this._needleEle = this._topDiv.childNodes[2];
  this._rulerEle = this._topDiv.childNodes[3];
  this._context = this._trackListEle.getContext("2d");
  this._trackList = [];
  this._highlightRanges = [];
  this.zoomTo(clock.startTime, clock.stopTime);
  this._onMouseDown = createMouseDownCallback(this);
  this._onMouseUp = createMouseUpCallback(this);
  this._onMouseMove = createMouseMoveCallback(this);
  this._onMouseWheel = createMouseWheelCallback(this);
  this._onTouchStart = createTouchStartCallback(this);
  this._onTouchMove = createTouchMoveCallback(this);
  this._onTouchEnd = createTouchEndCallback(this);
  const timeBarEle = this._timeBarEle;
  ownerDocument.addEventListener("mouseup", this._onMouseUp, false);
  ownerDocument.addEventListener("mousemove", this._onMouseMove, false);
  timeBarEle.addEventListener("mousedown", this._onMouseDown, false);
  timeBarEle.addEventListener("DOMMouseScroll", this._onMouseWheel, false);
  timeBarEle.addEventListener("mousewheel", this._onMouseWheel, false);
  timeBarEle.addEventListener("touchstart", this._onTouchStart, false);
  timeBarEle.addEventListener("touchmove", this._onTouchMove, false);
  timeBarEle.addEventListener("touchend", this._onTouchEnd, false);
  timeBarEle.addEventListener("touchcancel", this._onTouchEnd, false);
  this._topDiv.oncontextmenu = function() {
    return false;
  };
  clock.onTick.addEventListener(this.updateFromClock, this);
  this.updateFromClock();
}
Timeline.prototype.addEventListener = function(type, listener, useCapture) {
  this._topDiv.addEventListener(type, listener, useCapture);
};
Timeline.prototype.removeEventListener = function(type, listener, useCapture) {
  this._topDiv.removeEventListener(type, listener, useCapture);
};
Timeline.prototype.isDestroyed = function() {
  return false;
};
Timeline.prototype.destroy = function() {
  this._clock.onTick.removeEventListener(this.updateFromClock, this);
  const doc = this.container.ownerDocument;
  doc.removeEventListener("mouseup", this._onMouseUp, false);
  doc.removeEventListener("mousemove", this._onMouseMove, false);
  const timeBarEle = this._timeBarEle;
  timeBarEle.removeEventListener("mousedown", this._onMouseDown, false);
  timeBarEle.removeEventListener("DOMMouseScroll", this._onMouseWheel, false);
  timeBarEle.removeEventListener("mousewheel", this._onMouseWheel, false);
  timeBarEle.removeEventListener("touchstart", this._onTouchStart, false);
  timeBarEle.removeEventListener("touchmove", this._onTouchMove, false);
  timeBarEle.removeEventListener("touchend", this._onTouchEnd, false);
  timeBarEle.removeEventListener("touchcancel", this._onTouchEnd, false);
  this.container.removeChild(this._topDiv);
  destroyObject_default(this);
};
Timeline.prototype.addHighlightRange = function(color, heightInPx, base) {
  const newHighlightRange = new TimelineHighlightRange_default(color, heightInPx, base);
  this._highlightRanges.push(newHighlightRange);
  this.resize();
  return newHighlightRange;
};
Timeline.prototype.addTrack = function(interval, heightInPx, color, backgroundColor) {
  const newTrack = new TimelineTrack_default(
    interval,
    heightInPx,
    color,
    backgroundColor
  );
  this._trackList.push(newTrack);
  this._lastHeight = void 0;
  this.resize();
  return newTrack;
};
Timeline.prototype.zoomTo = function(startTime, stopTime) {
  if (!defined_default(startTime)) {
    throw new DeveloperError_default("startTime is required.");
  }
  if (!defined_default(stopTime)) {
    throw new DeveloperError_default("stopTime is required");
  }
  if (JulianDate_default.lessThanOrEquals(stopTime, startTime)) {
    throw new DeveloperError_default("Start time must come before end time.");
  }
  this._startJulian = startTime;
  this._endJulian = stopTime;
  this._timeBarSecondsSpan = JulianDate_default.secondsDifference(stopTime, startTime);
  if (this._clock && this._clock.clockRange !== ClockRange_default.UNBOUNDED) {
    const clockStart = this._clock.startTime;
    const clockEnd = this._clock.stopTime;
    const clockSpan = JulianDate_default.secondsDifference(clockEnd, clockStart);
    const startOffset = JulianDate_default.secondsDifference(
      clockStart,
      this._startJulian
    );
    const endOffset = JulianDate_default.secondsDifference(clockEnd, this._endJulian);
    if (this._timeBarSecondsSpan >= clockSpan) {
      this._timeBarSecondsSpan = clockSpan;
      this._startJulian = this._clock.startTime;
      this._endJulian = this._clock.stopTime;
    } else if (startOffset > 0) {
      this._endJulian = JulianDate_default.addSeconds(
        this._endJulian,
        startOffset,
        new JulianDate_default()
      );
      this._startJulian = clockStart;
      this._timeBarSecondsSpan = JulianDate_default.secondsDifference(
        this._endJulian,
        this._startJulian
      );
    } else if (endOffset < 0) {
      this._startJulian = JulianDate_default.addSeconds(
        this._startJulian,
        endOffset,
        new JulianDate_default()
      );
      this._endJulian = clockEnd;
      this._timeBarSecondsSpan = JulianDate_default.secondsDifference(
        this._endJulian,
        this._startJulian
      );
    }
  }
  this._makeTics();
  const evt = document.createEvent("Event");
  evt.initEvent("setzoom", true, true);
  evt.startJulian = this._startJulian;
  evt.endJulian = this._endJulian;
  evt.epochJulian = this._epochJulian;
  evt.totalSpan = this._timeBarSecondsSpan;
  evt.mainTicSpan = this._mainTicSpan;
  this._topDiv.dispatchEvent(evt);
};
Timeline.prototype.zoomFrom = function(amount) {
  let centerSec = JulianDate_default.secondsDifference(
    this._scrubJulian,
    this._startJulian
  );
  if (amount > 1 || centerSec < 0 || centerSec > this._timeBarSecondsSpan) {
    centerSec = this._timeBarSecondsSpan * 0.5;
  } else {
    centerSec += centerSec - this._timeBarSecondsSpan * 0.5;
  }
  const centerSecFlip = this._timeBarSecondsSpan - centerSec;
  this.zoomTo(
    JulianDate_default.addSeconds(
      this._startJulian,
      centerSec - centerSec * amount,
      new JulianDate_default()
    ),
    JulianDate_default.addSeconds(
      this._endJulian,
      centerSecFlip * amount - centerSecFlip,
      new JulianDate_default()
    )
  );
};
function twoDigits(num) {
  return num < 10 ? `0${num.toString()}` : num.toString();
}
Timeline.prototype.makeLabel = function(time) {
  const gregorian = JulianDate_default.toGregorianDate(time);
  const millisecond = gregorian.millisecond;
  let millisecondString = " UTC";
  if (millisecond > 0 && this._timeBarSecondsSpan < 3600) {
    millisecondString = Math.floor(millisecond).toString();
    while (millisecondString.length < 3) {
      millisecondString = `0${millisecondString}`;
    }
    millisecondString = `.${millisecondString}`;
  }
  return `${timelineMonthNames[gregorian.month - 1]} ${gregorian.day} ${gregorian.year} ${twoDigits(gregorian.hour)}:${twoDigits(gregorian.minute)}:${twoDigits(
    gregorian.second
  )}${millisecondString}`;
};
Timeline.prototype.smallestTicInPixels = 7;
Timeline.prototype._makeTics = function() {
  const timeBar = this._timeBarEle;
  const seconds = JulianDate_default.secondsDifference(
    this._scrubJulian,
    this._startJulian
  );
  const xPos = Math.round(
    seconds * this._topDiv.clientWidth / this._timeBarSecondsSpan
  );
  const scrubX = xPos - 8;
  let tic;
  const widget = this;
  this._needleEle.style.left = `${xPos.toString()}px`;
  let tics = "";
  const minimumDuration = 0.01;
  const maximumDuration = 31536e6;
  const epsilon = 1e-10;
  let minSize = 0;
  let duration = this._timeBarSecondsSpan;
  if (duration < minimumDuration) {
    duration = minimumDuration;
    this._timeBarSecondsSpan = minimumDuration;
    this._endJulian = JulianDate_default.addSeconds(
      this._startJulian,
      minimumDuration,
      new JulianDate_default()
    );
  } else if (duration > maximumDuration) {
    duration = maximumDuration;
    this._timeBarSecondsSpan = maximumDuration;
    this._endJulian = JulianDate_default.addSeconds(
      this._startJulian,
      maximumDuration,
      new JulianDate_default()
    );
  }
  let timeBarWidth = this._timeBarEle.clientWidth;
  if (timeBarWidth < 10) {
    timeBarWidth = 10;
  }
  const startJulian = this._startJulian;
  const epsilonTime = Math.min(duration / timeBarWidth * 1e-5, 0.4);
  let epochJulian;
  const gregorianDate = JulianDate_default.toGregorianDate(startJulian);
  if (duration > 31536e4) {
    epochJulian = JulianDate_default.fromDate(
      new Date(Date.UTC(Math.floor(gregorianDate.year / 100) * 100, 0))
    );
  } else if (duration > 31536e3) {
    epochJulian = JulianDate_default.fromDate(
      new Date(Date.UTC(Math.floor(gregorianDate.year / 10) * 10, 0))
    );
  } else if (duration > 86400) {
    epochJulian = JulianDate_default.fromDate(
      new Date(Date.UTC(gregorianDate.year, 0))
    );
  } else {
    epochJulian = JulianDate_default.fromDate(
      new Date(
        Date.UTC(gregorianDate.year, gregorianDate.month, gregorianDate.day)
      )
    );
  }
  const startTime = JulianDate_default.secondsDifference(
    this._startJulian,
    JulianDate_default.addSeconds(epochJulian, epsilonTime, new JulianDate_default())
  );
  let endTime = startTime + duration;
  this._epochJulian = epochJulian;
  function getStartTic(ticScale) {
    return Math.floor(startTime / ticScale) * ticScale;
  }
  function getNextTic(tic2, ticScale) {
    return Math.ceil(tic2 / ticScale + 0.5) * ticScale;
  }
  function getAlpha(time) {
    return (time - startTime) / duration;
  }
  function remainder(x, y) {
    return x - y * Math.round(x / y);
  }
  this._rulerEle.innerHTML = this.makeLabel(
    JulianDate_default.addSeconds(this._endJulian, -minimumDuration, new JulianDate_default())
  );
  let sampleWidth = this._rulerEle.offsetWidth + 20;
  if (sampleWidth < 30) {
    sampleWidth = 180;
  }
  const origMinSize = minSize;
  minSize -= epsilon;
  const renderState = {
    startTime,
    startJulian,
    epochJulian,
    duration,
    timeBarWidth,
    getAlpha
  };
  this._highlightRanges.forEach(function(highlightRange) {
    tics += highlightRange.render(renderState);
  });
  let mainTic = 0, subTic = 0, tinyTic = 0;
  let idealTic = sampleWidth / timeBarWidth;
  if (idealTic > 1) {
    idealTic = 1;
  }
  idealTic *= this._timeBarSecondsSpan;
  let ticIndex = -1, smallestIndex = -1;
  const ticScaleLen = timelineTicScales.length;
  let i2;
  for (i2 = 0; i2 < ticScaleLen; ++i2) {
    const sc = timelineTicScales[i2];
    ++ticIndex;
    mainTic = sc;
    if (sc > idealTic && sc > minSize) {
      break;
    }
    if (smallestIndex < 0 && timeBarWidth * (sc / this._timeBarSecondsSpan) >= this.smallestTicInPixels) {
      smallestIndex = ticIndex;
    }
  }
  if (ticIndex > 0) {
    while (ticIndex > 0) {
      --ticIndex;
      if (Math.abs(remainder(mainTic, timelineTicScales[ticIndex])) < 1e-5) {
        if (timelineTicScales[ticIndex] >= minSize) {
          subTic = timelineTicScales[ticIndex];
        }
        break;
      }
    }
    if (smallestIndex >= 0) {
      while (smallestIndex < ticIndex) {
        if (Math.abs(remainder(subTic, timelineTicScales[smallestIndex])) < 1e-5 && timelineTicScales[smallestIndex] >= minSize) {
          tinyTic = timelineTicScales[smallestIndex];
          break;
        }
        ++smallestIndex;
      }
    }
  }
  minSize = origMinSize;
  if (minSize > epsilon && tinyTic < 1e-5 && Math.abs(minSize - mainTic) > epsilon) {
    tinyTic = minSize;
    if (minSize <= mainTic + epsilon) {
      subTic = 0;
    }
  }
  let lastTextLeft = -999999, textWidth;
  if (timeBarWidth * (tinyTic / this._timeBarSecondsSpan) >= 3) {
    for (tic = getStartTic(tinyTic); tic <= endTime; tic = getNextTic(tic, tinyTic)) {
      tics += `<span class="cesium-timeline-ticTiny" style="left: ${Math.round(
        timeBarWidth * getAlpha(tic)
      ).toString()}px;"></span>`;
    }
  }
  if (timeBarWidth * (subTic / this._timeBarSecondsSpan) >= 3) {
    for (tic = getStartTic(subTic); tic <= endTime; tic = getNextTic(tic, subTic)) {
      tics += `<span class="cesium-timeline-ticSub" style="left: ${Math.round(
        timeBarWidth * getAlpha(tic)
      ).toString()}px;"></span>`;
    }
  }
  if (timeBarWidth * (mainTic / this._timeBarSecondsSpan) >= 2) {
    this._mainTicSpan = mainTic;
    endTime += mainTic;
    tic = getStartTic(mainTic);
    const leapSecond = JulianDate_default.computeTaiMinusUtc(epochJulian);
    while (tic <= endTime) {
      let ticTime = JulianDate_default.addSeconds(
        startJulian,
        tic - startTime,
        new JulianDate_default()
      );
      if (mainTic > 2.1) {
        const ticLeap = JulianDate_default.computeTaiMinusUtc(ticTime);
        if (Math.abs(ticLeap - leapSecond) > 0.1) {
          tic += ticLeap - leapSecond;
          ticTime = JulianDate_default.addSeconds(
            startJulian,
            tic - startTime,
            new JulianDate_default()
          );
        }
      }
      const ticLeft = Math.round(timeBarWidth * getAlpha(tic));
      const ticLabel = this.makeLabel(ticTime);
      this._rulerEle.innerHTML = ticLabel;
      textWidth = this._rulerEle.offsetWidth;
      if (textWidth < 10) {
        textWidth = sampleWidth;
      }
      const labelLeft = ticLeft - (textWidth / 2 - 1);
      if (labelLeft > lastTextLeft) {
        lastTextLeft = labelLeft + textWidth + 5;
        tics += `<span class="cesium-timeline-ticMain" style="left: ${ticLeft.toString()}px;"></span><span class="cesium-timeline-ticLabel" style="left: ${labelLeft.toString()}px;">${ticLabel}</span>`;
      } else {
        tics += `<span class="cesium-timeline-ticSub" style="left: ${ticLeft.toString()}px;"></span>`;
      }
      tic = getNextTic(tic, mainTic);
    }
  } else {
    this._mainTicSpan = -1;
  }
  tics += `<span class="cesium-timeline-icon16" style="left:${scrubX}px;bottom:0;background-position: 0 0;"></span>`;
  timeBar.innerHTML = tics;
  this._scrubElement = timeBar.lastChild;
  this._context.clearRect(
    0,
    0,
    this._trackListEle.width,
    this._trackListEle.height
  );
  renderState.y = 0;
  this._trackList.forEach(function(track2) {
    track2.render(widget._context, renderState);
    renderState.y += track2.height;
  });
};
Timeline.prototype.updateFromClock = function() {
  this._scrubJulian = this._clock.currentTime;
  const scrubElement = this._scrubElement;
  if (defined_default(this._scrubElement)) {
    const seconds = JulianDate_default.secondsDifference(
      this._scrubJulian,
      this._startJulian
    );
    const xPos = Math.round(
      seconds * this._topDiv.clientWidth / this._timeBarSecondsSpan
    );
    if (this._lastXPos !== xPos) {
      this._lastXPos = xPos;
      scrubElement.style.left = `${xPos - 8}px`;
      this._needleEle.style.left = `${xPos}px`;
    }
  }
  if (defined_default(this._timelineDragLocation)) {
    this._setTimeBarTime(
      this._timelineDragLocation,
      this._timelineDragLocation * this._timeBarSecondsSpan / this._topDiv.clientWidth
    );
    this.zoomTo(
      JulianDate_default.addSeconds(
        this._startJulian,
        this._timelineDrag,
        new JulianDate_default()
      ),
      JulianDate_default.addSeconds(
        this._endJulian,
        this._timelineDrag,
        new JulianDate_default()
      )
    );
  }
};
Timeline.prototype._setTimeBarTime = function(xPos, seconds) {
  xPos = Math.round(xPos);
  this._scrubJulian = JulianDate_default.addSeconds(
    this._startJulian,
    seconds,
    new JulianDate_default()
  );
  if (this._scrubElement) {
    const scrubX = xPos - 8;
    this._scrubElement.style.left = `${scrubX.toString()}px`;
    this._needleEle.style.left = `${xPos.toString()}px`;
  }
  const evt = document.createEvent("Event");
  evt.initEvent("settime", true, true);
  evt.clientX = xPos;
  evt.timeSeconds = seconds;
  evt.timeJulian = this._scrubJulian;
  evt.clock = this._clock;
  this._topDiv.dispatchEvent(evt);
};
function createMouseDownCallback(timeline) {
  return function(e2) {
    if (timeline._mouseMode !== timelineMouseMode.touchOnly) {
      if (e2.button === 0) {
        timeline._mouseMode = timelineMouseMode.scrub;
        if (timeline._scrubElement) {
          timeline._scrubElement.style.backgroundPosition = "-16px 0";
        }
        timeline._onMouseMove(e2);
      } else {
        timeline._mouseX = e2.clientX;
        if (e2.button === 2) {
          timeline._mouseMode = timelineMouseMode.zoom;
        } else {
          timeline._mouseMode = timelineMouseMode.slide;
        }
      }
    }
    e2.preventDefault();
  };
}
function createMouseUpCallback(timeline) {
  return function(e2) {
    timeline._mouseMode = timelineMouseMode.none;
    if (timeline._scrubElement) {
      timeline._scrubElement.style.backgroundPosition = "0 0";
    }
    timeline._timelineDrag = 0;
    timeline._timelineDragLocation = void 0;
  };
}
function createMouseMoveCallback(timeline) {
  return function(e2) {
    let dx;
    if (timeline._mouseMode === timelineMouseMode.scrub) {
      e2.preventDefault();
      const x = e2.clientX - timeline._topDiv.getBoundingClientRect().left;
      if (x < 0) {
        timeline._timelineDragLocation = 0;
        timeline._timelineDrag = -0.01 * timeline._timeBarSecondsSpan;
      } else if (x > timeline._topDiv.clientWidth) {
        timeline._timelineDragLocation = timeline._topDiv.clientWidth;
        timeline._timelineDrag = 0.01 * timeline._timeBarSecondsSpan;
      } else {
        timeline._timelineDragLocation = void 0;
        timeline._setTimeBarTime(
          x,
          x * timeline._timeBarSecondsSpan / timeline._topDiv.clientWidth
        );
      }
    } else if (timeline._mouseMode === timelineMouseMode.slide) {
      dx = timeline._mouseX - e2.clientX;
      timeline._mouseX = e2.clientX;
      if (dx !== 0) {
        const dsec = dx * timeline._timeBarSecondsSpan / timeline._topDiv.clientWidth;
        timeline.zoomTo(
          JulianDate_default.addSeconds(timeline._startJulian, dsec, new JulianDate_default()),
          JulianDate_default.addSeconds(timeline._endJulian, dsec, new JulianDate_default())
        );
      }
    } else if (timeline._mouseMode === timelineMouseMode.zoom) {
      dx = timeline._mouseX - e2.clientX;
      timeline._mouseX = e2.clientX;
      if (dx !== 0) {
        timeline.zoomFrom(Math.pow(1.01, dx));
      }
    }
  };
}
function createMouseWheelCallback(timeline) {
  return function(e2) {
    let dy = e2.wheelDeltaY || e2.wheelDelta || -e2.detail;
    timelineWheelDelta = Math.max(
      Math.min(Math.abs(dy), timelineWheelDelta),
      1
    );
    dy /= timelineWheelDelta;
    timeline.zoomFrom(Math.pow(1.05, -dy));
  };
}
function createTouchStartCallback(timeline) {
  return function(e2) {
    const len = e2.touches.length;
    let seconds, xPos;
    const leftX = timeline._topDiv.getBoundingClientRect().left;
    e2.preventDefault();
    timeline._mouseMode = timelineMouseMode.touchOnly;
    if (len === 1) {
      seconds = JulianDate_default.secondsDifference(
        timeline._scrubJulian,
        timeline._startJulian
      );
      xPos = Math.round(
        seconds * timeline._topDiv.clientWidth / timeline._timeBarSecondsSpan + leftX
      );
      if (Math.abs(e2.touches[0].clientX - xPos) < 50) {
        timeline._touchMode = timelineTouchMode.scrub;
        if (timeline._scrubElement) {
          timeline._scrubElement.style.backgroundPosition = len === 1 ? "-16px 0" : "0 0";
        }
      } else {
        timeline._touchMode = timelineTouchMode.singleTap;
        timeline._touchState.centerX = e2.touches[0].clientX - leftX;
      }
    } else if (len === 2) {
      timeline._touchMode = timelineTouchMode.slideZoom;
      timeline._touchState.centerX = (e2.touches[0].clientX + e2.touches[1].clientX) * 0.5 - leftX;
      timeline._touchState.spanX = Math.abs(
        e2.touches[0].clientX - e2.touches[1].clientX
      );
    } else {
      timeline._touchMode = timelineTouchMode.ignore;
    }
  };
}
function createTouchEndCallback(timeline) {
  return function(e2) {
    const len = e2.touches.length, leftX = timeline._topDiv.getBoundingClientRect().left;
    if (timeline._touchMode === timelineTouchMode.singleTap) {
      timeline._touchMode = timelineTouchMode.scrub;
      timeline._onTouchMove(e2);
    } else if (timeline._touchMode === timelineTouchMode.scrub) {
      timeline._onTouchMove(e2);
    }
    timeline._mouseMode = timelineMouseMode.touchOnly;
    if (len !== 1) {
      timeline._touchMode = len > 0 ? timelineTouchMode.ignore : timelineTouchMode.none;
    } else if (timeline._touchMode === timelineTouchMode.slideZoom) {
      timeline._touchState.centerX = e2.touches[0].clientX - leftX;
    }
    if (timeline._scrubElement) {
      timeline._scrubElement.style.backgroundPosition = "0 0";
    }
  };
}
function createTouchMoveCallback(timeline) {
  return function(e2) {
    let dx, x, len, newCenter, newSpan, newStartTime, zoom = 1;
    const leftX = timeline._topDiv.getBoundingClientRect().left;
    if (timeline._touchMode === timelineTouchMode.singleTap) {
      timeline._touchMode = timelineTouchMode.slideZoom;
    }
    timeline._mouseMode = timelineMouseMode.touchOnly;
    if (timeline._touchMode === timelineTouchMode.scrub) {
      e2.preventDefault();
      if (e2.changedTouches.length === 1) {
        x = e2.changedTouches[0].clientX - leftX;
        if (x >= 0 && x <= timeline._topDiv.clientWidth) {
          timeline._setTimeBarTime(
            x,
            x * timeline._timeBarSecondsSpan / timeline._topDiv.clientWidth
          );
        }
      }
    } else if (timeline._touchMode === timelineTouchMode.slideZoom) {
      len = e2.touches.length;
      if (len === 2) {
        newCenter = (e2.touches[0].clientX + e2.touches[1].clientX) * 0.5 - leftX;
        newSpan = Math.abs(e2.touches[0].clientX - e2.touches[1].clientX);
      } else if (len === 1) {
        newCenter = e2.touches[0].clientX - leftX;
        newSpan = 0;
      }
      if (defined_default(newCenter)) {
        if (newSpan > 0 && timeline._touchState.spanX > 0) {
          zoom = timeline._touchState.spanX / newSpan;
          newStartTime = JulianDate_default.addSeconds(
            timeline._startJulian,
            (timeline._touchState.centerX * timeline._timeBarSecondsSpan - newCenter * timeline._timeBarSecondsSpan * zoom) / timeline._topDiv.clientWidth,
            new JulianDate_default()
          );
        } else {
          dx = timeline._touchState.centerX - newCenter;
          newStartTime = JulianDate_default.addSeconds(
            timeline._startJulian,
            dx * timeline._timeBarSecondsSpan / timeline._topDiv.clientWidth,
            new JulianDate_default()
          );
        }
        timeline.zoomTo(
          newStartTime,
          JulianDate_default.addSeconds(
            newStartTime,
            timeline._timeBarSecondsSpan * zoom,
            new JulianDate_default()
          )
        );
        timeline._touchState.centerX = newCenter;
        timeline._touchState.spanX = newSpan;
      }
    }
  };
}
Timeline.prototype.resize = function() {
  const width = this.container.clientWidth;
  const height = this.container.clientHeight;
  if (width === this._lastWidth && height === this._lastHeight) {
    return;
  }
  this._trackContainer.style.height = `${height}px`;
  let trackListHeight = 1;
  this._trackList.forEach(function(track2) {
    trackListHeight += track2.height;
  });
  this._trackListEle.style.height = `${trackListHeight.toString()}px`;
  this._trackListEle.width = this._trackListEle.clientWidth;
  this._trackListEle.height = trackListHeight;
  this._makeTics();
  this._lastXPos = void 0;
  this._lastWidth = width;
  this._lastHeight = height;
};
var Timeline_default = Timeline;

// node_modules/cesium/Source/Widgets/VRButton/VRButtonViewModel.js
function lockScreen(orientation) {
  let locked = false;
  const screen = window.screen;
  if (defined_default(screen)) {
    if (defined_default(screen.lockOrientation)) {
      locked = screen.lockOrientation(orientation);
    } else if (defined_default(screen.mozLockOrientation)) {
      locked = screen.mozLockOrientation(orientation);
    } else if (defined_default(screen.msLockOrientation)) {
      locked = screen.msLockOrientation(orientation);
    } else if (defined_default(screen.orientation && screen.orientation.lock)) {
      locked = screen.orientation.lock(orientation);
    }
  }
  return locked;
}
function unlockScreen() {
  const screen = window.screen;
  if (defined_default(screen)) {
    if (defined_default(screen.unlockOrientation)) {
      screen.unlockOrientation();
    } else if (defined_default(screen.mozUnlockOrientation)) {
      screen.mozUnlockOrientation();
    } else if (defined_default(screen.msUnlockOrientation)) {
      screen.msUnlockOrientation();
    } else if (defined_default(screen.orientation && screen.orientation.unlock)) {
      screen.orientation.unlock();
    }
  }
}
function toggleVR(viewModel, scene, isVRMode, isOrthographic) {
  if (isOrthographic()) {
    return;
  }
  if (isVRMode()) {
    scene.useWebVR = false;
    if (viewModel._locked) {
      unlockScreen();
      viewModel._locked = false;
    }
    viewModel._noSleep.disable();
    Fullscreen_default.exitFullscreen();
    isVRMode(false);
  } else {
    if (!Fullscreen_default.fullscreen) {
      Fullscreen_default.requestFullscreen(viewModel._vrElement);
    }
    viewModel._noSleep.enable();
    if (!viewModel._locked) {
      viewModel._locked = lockScreen("landscape");
    }
    scene.useWebVR = true;
    isVRMode(true);
  }
}
function VRButtonViewModel(scene, vrElement) {
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  const that = this;
  const isEnabled = knockout_default.observable(Fullscreen_default.enabled);
  const isVRMode = knockout_default.observable(false);
  this.isVRMode = void 0;
  knockout_default.defineProperty(this, "isVRMode", {
    get: function() {
      return isVRMode();
    }
  });
  this.isVREnabled = void 0;
  knockout_default.defineProperty(this, "isVREnabled", {
    get: function() {
      return isEnabled();
    },
    set: function(value) {
      isEnabled(value && Fullscreen_default.enabled);
    }
  });
  this.tooltip = void 0;
  knockout_default.defineProperty(this, "tooltip", function() {
    if (!isEnabled()) {
      return "VR mode is unavailable";
    }
    return isVRMode() ? "Exit VR mode" : "Enter VR mode";
  });
  const isOrthographic = knockout_default.observable(false);
  this._isOrthographic = void 0;
  knockout_default.defineProperty(this, "_isOrthographic", {
    get: function() {
      return isOrthographic();
    }
  });
  this._eventHelper = new EventHelper_default();
  this._eventHelper.add(scene.preRender, function() {
    isOrthographic(scene.camera.frustum instanceof OrthographicFrustum_default);
  });
  this._locked = false;
  this._noSleep = new src();
  this._command = createCommand_default(function() {
    toggleVR(that, scene, isVRMode, isOrthographic);
  }, knockout_default.getObservable(this, "isVREnabled"));
  this._vrElement = defaultValue_default(getElement_default(vrElement), document.body);
  this._callback = function() {
    if (!Fullscreen_default.fullscreen && isVRMode()) {
      scene.useWebVR = false;
      if (that._locked) {
        unlockScreen();
        that._locked = false;
      }
      that._noSleep.disable();
      isVRMode(false);
    }
  };
  document.addEventListener(Fullscreen_default.changeEventName, this._callback);
}
Object.defineProperties(VRButtonViewModel.prototype, {
  vrElement: {
    get: function() {
      return this._vrElement;
    },
    set: function(value) {
      if (!(value instanceof Element)) {
        throw new DeveloperError_default("value must be a valid Element.");
      }
      this._vrElement = value;
    }
  },
  command: {
    get: function() {
      return this._command;
    }
  }
});
VRButtonViewModel.prototype.isDestroyed = function() {
  return false;
};
VRButtonViewModel.prototype.destroy = function() {
  this._eventHelper.removeAll();
  document.removeEventListener(Fullscreen_default.changeEventName, this._callback);
  destroyObject_default(this);
};
var VRButtonViewModel_default = VRButtonViewModel;

// node_modules/cesium/Source/Widgets/VRButton/VRButton.js
var enterVRPath = "M 5.3125 6.375 C 4.008126 6.375 2.96875 7.4141499 2.96875 8.71875 L 2.96875 19.5 C 2.96875 20.8043 4.008126 21.875 5.3125 21.875 L 13.65625 21.875 C 13.71832 20.0547 14.845166 18.59375 16.21875 18.59375 C 17.592088 18.59375 18.71881 20.0552 18.78125 21.875 L 27.09375 21.875 C 28.398125 21.875 29.4375 20.8043 29.4375 19.5 L 29.4375 8.71875 C 29.4375 7.4141499 28.398125 6.375 27.09375 6.375 L 5.3125 6.375 z M 9.625 10.4375 C 11.55989 10.4375 13.125 12.03385 13.125 13.96875 C 13.125 15.90365 11.55989 17.46875 9.625 17.46875 C 7.69011 17.46875 6.125 15.90365 6.125 13.96875 C 6.125 12.03385 7.69011 10.4375 9.625 10.4375 z M 22.46875 10.4375 C 24.40364 10.4375 25.96875 12.03385 25.96875 13.96875 C 25.96875 15.90365 24.40364 17.46875 22.46875 17.46875 C 20.53386 17.46875 18.96875 15.90365 18.96875 13.96875 C 18.96875 12.03385 20.53386 10.4375 22.46875 10.4375 z";
var exitVRPath = "M 25.770585,2.4552065 C 15.72282,13.962707 10.699956,19.704407 8.1768352,22.580207 c -1.261561,1.4379 -1.902282,2.1427 -2.21875,2.5 -0.141624,0.1599 -0.208984,0.2355 -0.25,0.2813 l 0.6875,0.75 c 10e-5,-10e-5 0.679191,0.727 0.6875,0.7187 0.01662,-0.016 0.02451,-0.024 0.03125,-0.031 0.01348,-0.014 0.04013,-0.038 0.0625,-0.062 0.04474,-0.05 0.120921,-0.1315 0.28125,-0.3126 0.320657,-0.3619 0.956139,-1.0921 2.2187499,-2.5312 2.5252219,-2.8781 7.5454589,-8.6169 17.5937499,-20.1250005 l -1.5,-1.3125 z m -20.5624998,3.9063 c -1.304375,0 -2.34375,1.0391 -2.34375,2.3437 l 0,10.8125005 c 0,1.3043 1.039375,2.375 2.34375,2.375 l 2.25,0 c 1.9518039,-2.2246 7.4710958,-8.5584 13.5624998,-15.5312005 l -15.8124998,0 z m 21.1249998,0 c -1.855467,2.1245 -2.114296,2.4005 -3.59375,4.0936995 1.767282,0.1815 3.15625,1.685301 3.15625,3.500001 0,1.9349 -1.56511,3.5 -3.5,3.5 -1.658043,0 -3.043426,-1.1411 -3.40625,-2.6875 -1.089617,1.2461 -2.647139,2.9988 -3.46875,3.9375 0.191501,-0.062 0.388502,-0.094 0.59375,-0.094 1.373338,0 2.50006,1.4614 2.5625,3.2812 l 8.3125,0 c 1.304375,0 2.34375,-1.0707 2.34375,-2.375 l 0,-10.8125005 c 0,-1.3046 -1.039375,-2.3437 -2.34375,-2.3437 l -0.65625,0 z M 9.5518351,10.423906 c 1.9348899,0 3.4999999,1.596401 3.4999999,3.531301 0,1.9349 -1.56511,3.5 -3.4999999,3.5 -1.9348899,0 -3.4999999,-1.5651 -3.4999999,-3.5 0,-1.9349 1.56511,-3.531301 3.4999999,-3.531301 z m 4.2187499,10.312601 c -0.206517,0.2356 -0.844218,0.9428 -1.03125,1.1562 l 0.8125,0 c 0.01392,-0.4081 0.107026,-0.7968 0.21875,-1.1562 z";
function VRButton(container, scene, vrElement) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  if (!defined_default(scene)) {
    throw new DeveloperError_default("scene is required.");
  }
  container = getElement_default(container);
  const viewModel = new VRButtonViewModel_default(scene, vrElement);
  viewModel._exitVRPath = exitVRPath;
  viewModel._enterVRPath = enterVRPath;
  const element = document.createElement("button");
  element.type = "button";
  element.className = "cesium-button cesium-vrButton";
  element.setAttribute(
    "data-bind",
    'css: { "cesium-button-disabled" : _isOrthographic }, attr: { title: tooltip },click: command,enable: isVREnabled,cesiumSvgPath: { path: isVRMode ? _exitVRPath : _enterVRPath, width: 32, height: 32 }'
  );
  container.appendChild(element);
  knockout_default.applyBindings(viewModel, element);
  this._container = container;
  this._viewModel = viewModel;
  this._element = element;
}
Object.defineProperties(VRButton.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  viewModel: {
    get: function() {
      return this._viewModel;
    }
  }
});
VRButton.prototype.isDestroyed = function() {
  return false;
};
VRButton.prototype.destroy = function() {
  this._viewModel.destroy();
  knockout_default.cleanNode(this._element);
  this._container.removeChild(this._element);
  return destroyObject_default(this);
};
var VRButton_default = VRButton;

// node_modules/cesium/Source/Widgets/Viewer/Viewer.js
var boundingSphereScratch4 = new BoundingSphere_default();
function onTimelineScrubfunction(e2) {
  const clock = e2.clock;
  clock.currentTime = e2.timeJulian;
  clock.shouldAnimate = false;
}
function getCesium3DTileFeatureDescription(feature2) {
  const propertyNames = feature2.getPropertyNames();
  let html2 = "";
  propertyNames.forEach(function(propertyName) {
    const value = feature2.getProperty(propertyName);
    if (defined_default(value)) {
      html2 += `<tr><th>${propertyName}</th><td>${value}</td></tr>`;
    }
  });
  if (html2.length > 0) {
    html2 = `<table class="cesium-infoBox-defaultTable"><tbody>${html2}</tbody></table>`;
  }
  return html2;
}
function getCesium3DTileFeatureName(feature2) {
  let i2;
  const possibleNames = [];
  const propertyNames = feature2.getPropertyNames();
  for (i2 = 0; i2 < propertyNames.length; i2++) {
    const propertyName = propertyNames[i2];
    if (/^name$/i.test(propertyName)) {
      possibleNames[0] = feature2.getProperty(propertyName);
    } else if (/name/i.test(propertyName)) {
      possibleNames[1] = feature2.getProperty(propertyName);
    } else if (/^title$/i.test(propertyName)) {
      possibleNames[2] = feature2.getProperty(propertyName);
    } else if (/^(id|identifier)$/i.test(propertyName)) {
      possibleNames[3] = feature2.getProperty(propertyName);
    } else if (/element/i.test(propertyName)) {
      possibleNames[4] = feature2.getProperty(propertyName);
    } else if (/(id|identifier)$/i.test(propertyName)) {
      possibleNames[5] = feature2.getProperty(propertyName);
    }
  }
  const length3 = possibleNames.length;
  for (i2 = 0; i2 < length3; i2++) {
    const item = possibleNames[i2];
    if (defined_default(item) && item !== "") {
      return item;
    }
  }
  return "Unnamed Feature";
}
function pickEntity(viewer, e2) {
  const picked = viewer.scene.pick(e2.position);
  if (defined_default(picked)) {
    const id = defaultValue_default(picked.id, picked.primitive.id);
    if (id instanceof Entity_default) {
      return id;
    }
    if (picked instanceof Cesium3DTileFeature_default) {
      return new Entity_default({
        name: getCesium3DTileFeatureName(picked),
        description: getCesium3DTileFeatureDescription(picked),
        feature: picked
      });
    }
  }
  if (defined_default(viewer.scene.globe)) {
    return pickImageryLayerFeature(viewer, e2.position);
  }
}
var scratchStopTime = new JulianDate_default();
function trackDataSourceClock(timeline, clock, dataSource) {
  if (defined_default(dataSource)) {
    const dataSourceClock = dataSource.clock;
    if (defined_default(dataSourceClock)) {
      dataSourceClock.getValue(clock);
      if (defined_default(timeline)) {
        const startTime = dataSourceClock.startTime;
        let stopTime = dataSourceClock.stopTime;
        if (JulianDate_default.equals(startTime, stopTime)) {
          stopTime = JulianDate_default.addSeconds(
            startTime,
            Math_default.EPSILON2,
            scratchStopTime
          );
        }
        timeline.updateFromClock();
        timeline.zoomTo(startTime, stopTime);
      }
    }
  }
}
var cartesian3Scratch8 = new Cartesian3_default();
function pickImageryLayerFeature(viewer, windowPosition) {
  const scene = viewer.scene;
  const pickRay = scene.camera.getPickRay(windowPosition);
  const imageryLayerFeaturePromise = scene.imageryLayers.pickImageryLayerFeatures(
    pickRay,
    scene
  );
  if (!defined_default(imageryLayerFeaturePromise)) {
    return;
  }
  const loadingMessage = new Entity_default({
    id: "Loading...",
    description: "Loading feature information..."
  });
  imageryLayerFeaturePromise.then(
    function(features) {
      if (viewer.selectedEntity !== loadingMessage) {
        return;
      }
      if (!defined_default(features) || features.length === 0) {
        viewer.selectedEntity = createNoFeaturesEntity();
        return;
      }
      const feature2 = features[0];
      const entity = new Entity_default({
        id: feature2.name,
        description: feature2.description
      });
      if (defined_default(feature2.position)) {
        const ecfPosition = viewer.scene.globe.ellipsoid.cartographicToCartesian(
          feature2.position,
          cartesian3Scratch8
        );
        entity.position = new ConstantPositionProperty_default(ecfPosition);
      }
      viewer.selectedEntity = entity;
    },
    function() {
      if (viewer.selectedEntity !== loadingMessage) {
        return;
      }
      viewer.selectedEntity = createNoFeaturesEntity();
    }
  );
  return loadingMessage;
}
function createNoFeaturesEntity() {
  return new Entity_default({
    id: "None",
    description: "No features found."
  });
}
function enableVRUI(viewer, enabled) {
  const geocoder = viewer._geocoder;
  const homeButton = viewer._homeButton;
  const sceneModePicker = viewer._sceneModePicker;
  const projectionPicker = viewer._projectionPicker;
  const baseLayerPicker = viewer._baseLayerPicker;
  const animation = viewer._animation;
  const timeline = viewer._timeline;
  const fullscreenButton = viewer._fullscreenButton;
  const infoBox = viewer._infoBox;
  const selectionIndicator = viewer._selectionIndicator;
  const visibility = enabled ? "hidden" : "visible";
  if (defined_default(geocoder)) {
    geocoder.container.style.visibility = visibility;
  }
  if (defined_default(homeButton)) {
    homeButton.container.style.visibility = visibility;
  }
  if (defined_default(sceneModePicker)) {
    sceneModePicker.container.style.visibility = visibility;
  }
  if (defined_default(projectionPicker)) {
    projectionPicker.container.style.visibility = visibility;
  }
  if (defined_default(baseLayerPicker)) {
    baseLayerPicker.container.style.visibility = visibility;
  }
  if (defined_default(animation)) {
    animation.container.style.visibility = visibility;
  }
  if (defined_default(timeline)) {
    timeline.container.style.visibility = visibility;
  }
  if (defined_default(fullscreenButton) && fullscreenButton.viewModel.isFullscreenEnabled) {
    fullscreenButton.container.style.visibility = visibility;
  }
  if (defined_default(infoBox)) {
    infoBox.container.style.visibility = visibility;
  }
  if (defined_default(selectionIndicator)) {
    selectionIndicator.container.style.visibility = visibility;
  }
  if (viewer._container) {
    const right = enabled || !defined_default(fullscreenButton) ? 0 : fullscreenButton.container.clientWidth;
    viewer._vrButton.container.style.right = `${right}px`;
    viewer.forceResize();
  }
}
function Viewer(container, options) {
  if (!defined_default(container)) {
    throw new DeveloperError_default("container is required.");
  }
  container = getElement_default(container);
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const createBaseLayerPicker = (!defined_default(options.globe) || options.globe !== false) && (!defined_default(options.baseLayerPicker) || options.baseLayerPicker !== false);
  if (!createBaseLayerPicker && defined_default(options.selectedImageryProviderViewModel)) {
    throw new DeveloperError_default(
      "options.selectedImageryProviderViewModel is not available when not using the BaseLayerPicker widget. Either specify options.imageryProvider instead or set options.baseLayerPicker to true."
    );
  }
  if (!createBaseLayerPicker && defined_default(options.selectedTerrainProviderViewModel)) {
    throw new DeveloperError_default(
      "options.selectedTerrainProviderViewModel is not available when not using the BaseLayerPicker widget. Either specify options.terrainProvider instead or set options.baseLayerPicker to true."
    );
  }
  const that = this;
  const viewerContainer = document.createElement("div");
  viewerContainer.className = "cesium-viewer";
  container.appendChild(viewerContainer);
  const cesiumWidgetContainer = document.createElement("div");
  cesiumWidgetContainer.className = "cesium-viewer-cesiumWidgetContainer";
  viewerContainer.appendChild(cesiumWidgetContainer);
  const bottomContainer = document.createElement("div");
  bottomContainer.className = "cesium-viewer-bottom";
  viewerContainer.appendChild(bottomContainer);
  const scene3DOnly = defaultValue_default(options.scene3DOnly, false);
  let clock;
  let clockViewModel;
  let destroyClockViewModel = false;
  if (defined_default(options.clockViewModel)) {
    clockViewModel = options.clockViewModel;
    clock = clockViewModel.clock;
  } else {
    clock = new Clock_default();
    clockViewModel = new ClockViewModel_default(clock);
    destroyClockViewModel = true;
  }
  if (defined_default(options.shouldAnimate)) {
    clock.shouldAnimate = options.shouldAnimate;
  }
  const cesiumWidget = new CesiumWidget_default(cesiumWidgetContainer, {
    imageryProvider: createBaseLayerPicker || defined_default(options.imageryProvider) ? false : void 0,
    clock,
    skyBox: options.skyBox,
    skyAtmosphere: options.skyAtmosphere,
    sceneMode: options.sceneMode,
    mapProjection: options.mapProjection,
    globe: options.globe,
    orderIndependentTranslucency: options.orderIndependentTranslucency,
    contextOptions: options.contextOptions,
    useDefaultRenderLoop: options.useDefaultRenderLoop,
    targetFrameRate: options.targetFrameRate,
    showRenderLoopErrors: options.showRenderLoopErrors,
    useBrowserRecommendedResolution: options.useBrowserRecommendedResolution,
    creditContainer: defined_default(options.creditContainer) ? options.creditContainer : bottomContainer,
    creditViewport: options.creditViewport,
    scene3DOnly,
    shadows: options.shadows,
    terrainShadows: options.terrainShadows,
    mapMode2D: options.mapMode2D,
    requestRenderMode: options.requestRenderMode,
    maximumRenderTimeChange: options.maximumRenderTimeChange,
    depthPlaneEllipsoidOffset: options.depthPlaneEllipsoidOffset,
    msaaSamples: options.msaaSamples
  });
  let dataSourceCollection = options.dataSources;
  let destroyDataSourceCollection = false;
  if (!defined_default(dataSourceCollection)) {
    dataSourceCollection = new DataSourceCollection_default();
    destroyDataSourceCollection = true;
  }
  const scene = cesiumWidget.scene;
  const dataSourceDisplay = new DataSourceDisplay_default({
    scene,
    dataSourceCollection
  });
  const eventHelper = new EventHelper_default();
  eventHelper.add(clock.onTick, Viewer.prototype._onTick, this);
  eventHelper.add(scene.morphStart, Viewer.prototype._clearTrackedObject, this);
  let selectionIndicator;
  if (!defined_default(options.selectionIndicator) || options.selectionIndicator !== false) {
    const selectionIndicatorContainer = document.createElement("div");
    selectionIndicatorContainer.className = "cesium-viewer-selectionIndicatorContainer";
    viewerContainer.appendChild(selectionIndicatorContainer);
    selectionIndicator = new SelectionIndicator_default(
      selectionIndicatorContainer,
      scene
    );
  }
  let infoBox;
  if (!defined_default(options.infoBox) || options.infoBox !== false) {
    const infoBoxContainer = document.createElement("div");
    infoBoxContainer.className = "cesium-viewer-infoBoxContainer";
    viewerContainer.appendChild(infoBoxContainer);
    infoBox = new InfoBox_default(infoBoxContainer);
    const infoBoxViewModel = infoBox.viewModel;
    eventHelper.add(
      infoBoxViewModel.cameraClicked,
      Viewer.prototype._onInfoBoxCameraClicked,
      this
    );
    eventHelper.add(
      infoBoxViewModel.closeClicked,
      Viewer.prototype._onInfoBoxClockClicked,
      this
    );
  }
  const toolbar = document.createElement("div");
  toolbar.className = "cesium-viewer-toolbar";
  viewerContainer.appendChild(toolbar);
  let geocoder;
  if (!defined_default(options.geocoder) || options.geocoder !== false) {
    const geocoderContainer = document.createElement("div");
    geocoderContainer.className = "cesium-viewer-geocoderContainer";
    toolbar.appendChild(geocoderContainer);
    let geocoderService;
    if (defined_default(options.geocoder) && typeof options.geocoder !== "boolean") {
      geocoderService = Array.isArray(options.geocoder) ? options.geocoder : [options.geocoder];
    }
    geocoder = new Geocoder_default({
      container: geocoderContainer,
      geocoderServices: geocoderService,
      scene
    });
    eventHelper.add(
      geocoder.viewModel.search.beforeExecute,
      Viewer.prototype._clearObjects,
      this
    );
  }
  let homeButton;
  if (!defined_default(options.homeButton) || options.homeButton !== false) {
    homeButton = new HomeButton_default(toolbar, scene);
    if (defined_default(geocoder)) {
      eventHelper.add(homeButton.viewModel.command.afterExecute, function() {
        const viewModel = geocoder.viewModel;
        viewModel.searchText = "";
        if (viewModel.isSearchInProgress) {
          viewModel.search();
        }
      });
    }
    eventHelper.add(
      homeButton.viewModel.command.beforeExecute,
      Viewer.prototype._clearTrackedObject,
      this
    );
  }
  if (options.sceneModePicker === true && scene3DOnly) {
    throw new DeveloperError_default(
      "options.sceneModePicker is not available when options.scene3DOnly is set to true."
    );
  }
  let sceneModePicker;
  if (!scene3DOnly && (!defined_default(options.sceneModePicker) || options.sceneModePicker !== false)) {
    sceneModePicker = new SceneModePicker_default(toolbar, scene);
  }
  let projectionPicker;
  if (options.projectionPicker) {
    projectionPicker = new ProjectionPicker_default(toolbar, scene);
  }
  let baseLayerPicker;
  let baseLayerPickerDropDown;
  if (createBaseLayerPicker) {
    const imageryProviderViewModels = defaultValue_default(
      options.imageryProviderViewModels,
      createDefaultImageryProviderViewModels_default()
    );
    const terrainProviderViewModels = defaultValue_default(
      options.terrainProviderViewModels,
      createDefaultTerrainProviderViewModels_default()
    );
    baseLayerPicker = new BaseLayerPicker_default(toolbar, {
      globe: scene.globe,
      imageryProviderViewModels,
      selectedImageryProviderViewModel: options.selectedImageryProviderViewModel,
      terrainProviderViewModels,
      selectedTerrainProviderViewModel: options.selectedTerrainProviderViewModel
    });
    const elements = toolbar.getElementsByClassName(
      "cesium-baseLayerPicker-dropDown"
    );
    baseLayerPickerDropDown = elements[0];
  }
  if (defined_default(options.imageryProvider) && options.imageryProvider !== false) {
    if (createBaseLayerPicker) {
      baseLayerPicker.viewModel.selectedImagery = void 0;
    }
    scene.imageryLayers.removeAll();
    scene.imageryLayers.addImageryProvider(options.imageryProvider);
  }
  if (defined_default(options.terrainProvider)) {
    if (createBaseLayerPicker) {
      baseLayerPicker.viewModel.selectedTerrain = void 0;
    }
    scene.terrainProvider = options.terrainProvider;
  }
  let navigationHelpButton;
  if (!defined_default(options.navigationHelpButton) || options.navigationHelpButton !== false) {
    let showNavHelp = true;
    try {
      if (defined_default(window.localStorage)) {
        const hasSeenNavHelp = window.localStorage.getItem(
          "cesium-hasSeenNavHelp"
        );
        if (defined_default(hasSeenNavHelp) && Boolean(hasSeenNavHelp)) {
          showNavHelp = false;
        } else {
          window.localStorage.setItem("cesium-hasSeenNavHelp", "true");
        }
      }
    } catch (e2) {
    }
    navigationHelpButton = new NavigationHelpButton_default({
      container: toolbar,
      instructionsInitiallyVisible: defaultValue_default(
        options.navigationInstructionsInitiallyVisible,
        showNavHelp
      )
    });
  }
  let animation;
  if (!defined_default(options.animation) || options.animation !== false) {
    const animationContainer = document.createElement("div");
    animationContainer.className = "cesium-viewer-animationContainer";
    viewerContainer.appendChild(animationContainer);
    animation = new Animation_default(
      animationContainer,
      new AnimationViewModel_default(clockViewModel)
    );
  }
  let timeline;
  if (!defined_default(options.timeline) || options.timeline !== false) {
    const timelineContainer = document.createElement("div");
    timelineContainer.className = "cesium-viewer-timelineContainer";
    viewerContainer.appendChild(timelineContainer);
    timeline = new Timeline_default(timelineContainer, clock);
    timeline.addEventListener("settime", onTimelineScrubfunction, false);
    timeline.zoomTo(clock.startTime, clock.stopTime);
  }
  let fullscreenButton;
  let fullscreenSubscription;
  let fullscreenContainer;
  if (!defined_default(options.fullscreenButton) || options.fullscreenButton !== false) {
    fullscreenContainer = document.createElement("div");
    fullscreenContainer.className = "cesium-viewer-fullscreenContainer";
    viewerContainer.appendChild(fullscreenContainer);
    fullscreenButton = new FullscreenButton_default(
      fullscreenContainer,
      options.fullscreenElement
    );
    fullscreenSubscription = subscribeAndEvaluate_default(
      fullscreenButton.viewModel,
      "isFullscreenEnabled",
      function(isFullscreenEnabled) {
        fullscreenContainer.style.display = isFullscreenEnabled ? "block" : "none";
        if (defined_default(timeline)) {
          timeline.container.style.right = `${fullscreenContainer.clientWidth}px`;
          timeline.resize();
        }
      }
    );
  }
  let vrButton;
  let vrSubscription;
  let vrModeSubscription;
  if (options.vrButton) {
    const vrContainer = document.createElement("div");
    vrContainer.className = "cesium-viewer-vrContainer";
    viewerContainer.appendChild(vrContainer);
    vrButton = new VRButton_default(vrContainer, scene, options.fullScreenElement);
    vrSubscription = subscribeAndEvaluate_default(
      vrButton.viewModel,
      "isVREnabled",
      function(isVREnabled) {
        vrContainer.style.display = isVREnabled ? "block" : "none";
        if (defined_default(fullscreenButton)) {
          vrContainer.style.right = `${fullscreenContainer.clientWidth}px`;
        }
        if (defined_default(timeline)) {
          timeline.container.style.right = `${vrContainer.clientWidth}px`;
          timeline.resize();
        }
      }
    );
    vrModeSubscription = subscribeAndEvaluate_default(
      vrButton.viewModel,
      "isVRMode",
      function(isVRMode) {
        enableVRUI(that, isVRMode);
      }
    );
  }
  this._baseLayerPickerDropDown = baseLayerPickerDropDown;
  this._fullscreenSubscription = fullscreenSubscription;
  this._vrSubscription = vrSubscription;
  this._vrModeSubscription = vrModeSubscription;
  this._dataSourceChangedListeners = {};
  this._automaticallyTrackDataSourceClocks = defaultValue_default(
    options.automaticallyTrackDataSourceClocks,
    true
  );
  this._container = container;
  this._bottomContainer = bottomContainer;
  this._element = viewerContainer;
  this._cesiumWidget = cesiumWidget;
  this._selectionIndicator = selectionIndicator;
  this._infoBox = infoBox;
  this._dataSourceCollection = dataSourceCollection;
  this._destroyDataSourceCollection = destroyDataSourceCollection;
  this._dataSourceDisplay = dataSourceDisplay;
  this._clockViewModel = clockViewModel;
  this._destroyClockViewModel = destroyClockViewModel;
  this._toolbar = toolbar;
  this._homeButton = homeButton;
  this._sceneModePicker = sceneModePicker;
  this._projectionPicker = projectionPicker;
  this._baseLayerPicker = baseLayerPicker;
  this._navigationHelpButton = navigationHelpButton;
  this._animation = animation;
  this._timeline = timeline;
  this._fullscreenButton = fullscreenButton;
  this._vrButton = vrButton;
  this._geocoder = geocoder;
  this._eventHelper = eventHelper;
  this._lastWidth = 0;
  this._lastHeight = 0;
  this._allowDataSourcesToSuspendAnimation = true;
  this._entityView = void 0;
  this._enableInfoOrSelection = defined_default(infoBox) || defined_default(selectionIndicator);
  this._clockTrackedDataSource = void 0;
  this._trackedEntity = void 0;
  this._needTrackedEntityUpdate = false;
  this._selectedEntity = void 0;
  this._zoomIsFlight = false;
  this._zoomTarget = void 0;
  this._zoomPromise = void 0;
  this._zoomOptions = void 0;
  this._selectedEntityChanged = new Event_default();
  this._trackedEntityChanged = new Event_default();
  knockout_default.track(this, [
    "_trackedEntity",
    "_selectedEntity",
    "_clockTrackedDataSource"
  ]);
  eventHelper.add(
    dataSourceCollection.dataSourceAdded,
    Viewer.prototype._onDataSourceAdded,
    this
  );
  eventHelper.add(
    dataSourceCollection.dataSourceRemoved,
    Viewer.prototype._onDataSourceRemoved,
    this
  );
  eventHelper.add(scene.postUpdate, Viewer.prototype.resize, this);
  eventHelper.add(scene.postRender, Viewer.prototype._postRender, this);
  const dataSourceLength = dataSourceCollection.length;
  for (let i2 = 0; i2 < dataSourceLength; i2++) {
    this._dataSourceAdded(dataSourceCollection, dataSourceCollection.get(i2));
  }
  this._dataSourceAdded(void 0, dataSourceDisplay.defaultDataSource);
  eventHelper.add(
    dataSourceCollection.dataSourceAdded,
    Viewer.prototype._dataSourceAdded,
    this
  );
  eventHelper.add(
    dataSourceCollection.dataSourceRemoved,
    Viewer.prototype._dataSourceRemoved,
    this
  );
  function pickAndTrackObject(e2) {
    const entity = pickEntity(that, e2);
    if (defined_default(entity)) {
      if (Property_default.getValueOrUndefined(entity.position, that.clock.currentTime)) {
        that.trackedEntity = entity;
      } else {
        that.zoomTo(entity);
      }
    } else if (defined_default(that.trackedEntity)) {
      that.trackedEntity = void 0;
    }
  }
  function pickAndSelectObject(e2) {
    that.selectedEntity = pickEntity(that, e2);
  }
  cesiumWidget.screenSpaceEventHandler.setInputAction(
    pickAndSelectObject,
    ScreenSpaceEventType_default.LEFT_CLICK
  );
  cesiumWidget.screenSpaceEventHandler.setInputAction(
    pickAndTrackObject,
    ScreenSpaceEventType_default.LEFT_DOUBLE_CLICK
  );
}
Object.defineProperties(Viewer.prototype, {
  container: {
    get: function() {
      return this._container;
    }
  },
  bottomContainer: {
    get: function() {
      return this._bottomContainer;
    }
  },
  cesiumWidget: {
    get: function() {
      return this._cesiumWidget;
    }
  },
  selectionIndicator: {
    get: function() {
      return this._selectionIndicator;
    }
  },
  infoBox: {
    get: function() {
      return this._infoBox;
    }
  },
  geocoder: {
    get: function() {
      return this._geocoder;
    }
  },
  homeButton: {
    get: function() {
      return this._homeButton;
    }
  },
  sceneModePicker: {
    get: function() {
      return this._sceneModePicker;
    }
  },
  projectionPicker: {
    get: function() {
      return this._projectionPicker;
    }
  },
  baseLayerPicker: {
    get: function() {
      return this._baseLayerPicker;
    }
  },
  navigationHelpButton: {
    get: function() {
      return this._navigationHelpButton;
    }
  },
  animation: {
    get: function() {
      return this._animation;
    }
  },
  timeline: {
    get: function() {
      return this._timeline;
    }
  },
  fullscreenButton: {
    get: function() {
      return this._fullscreenButton;
    }
  },
  vrButton: {
    get: function() {
      return this._vrButton;
    }
  },
  dataSourceDisplay: {
    get: function() {
      return this._dataSourceDisplay;
    }
  },
  entities: {
    get: function() {
      return this._dataSourceDisplay.defaultDataSource.entities;
    }
  },
  dataSources: {
    get: function() {
      return this._dataSourceCollection;
    }
  },
  canvas: {
    get: function() {
      return this._cesiumWidget.canvas;
    }
  },
  scene: {
    get: function() {
      return this._cesiumWidget.scene;
    }
  },
  shadows: {
    get: function() {
      return this.scene.shadowMap.enabled;
    },
    set: function(value) {
      this.scene.shadowMap.enabled = value;
    }
  },
  terrainShadows: {
    get: function() {
      return this.scene.globe.shadows;
    },
    set: function(value) {
      this.scene.globe.shadows = value;
    }
  },
  shadowMap: {
    get: function() {
      return this.scene.shadowMap;
    }
  },
  imageryLayers: {
    get: function() {
      return this.scene.imageryLayers;
    }
  },
  terrainProvider: {
    get: function() {
      return this.scene.terrainProvider;
    },
    set: function(terrainProvider) {
      this.scene.terrainProvider = terrainProvider;
    }
  },
  camera: {
    get: function() {
      return this.scene.camera;
    }
  },
  postProcessStages: {
    get: function() {
      return this.scene.postProcessStages;
    }
  },
  clock: {
    get: function() {
      return this._clockViewModel.clock;
    }
  },
  clockViewModel: {
    get: function() {
      return this._clockViewModel;
    }
  },
  screenSpaceEventHandler: {
    get: function() {
      return this._cesiumWidget.screenSpaceEventHandler;
    }
  },
  targetFrameRate: {
    get: function() {
      return this._cesiumWidget.targetFrameRate;
    },
    set: function(value) {
      this._cesiumWidget.targetFrameRate = value;
    }
  },
  useDefaultRenderLoop: {
    get: function() {
      return this._cesiumWidget.useDefaultRenderLoop;
    },
    set: function(value) {
      this._cesiumWidget.useDefaultRenderLoop = value;
    }
  },
  resolutionScale: {
    get: function() {
      return this._cesiumWidget.resolutionScale;
    },
    set: function(value) {
      this._cesiumWidget.resolutionScale = value;
    }
  },
  useBrowserRecommendedResolution: {
    get: function() {
      return this._cesiumWidget.useBrowserRecommendedResolution;
    },
    set: function(value) {
      this._cesiumWidget.useBrowserRecommendedResolution = value;
    }
  },
  allowDataSourcesToSuspendAnimation: {
    get: function() {
      return this._allowDataSourcesToSuspendAnimation;
    },
    set: function(value) {
      this._allowDataSourcesToSuspendAnimation = value;
    }
  },
  trackedEntity: {
    get: function() {
      return this._trackedEntity;
    },
    set: function(value) {
      if (this._trackedEntity !== value) {
        this._trackedEntity = value;
        cancelZoom(this);
        const scene = this.scene;
        const sceneMode = scene.mode;
        if (!defined_default(value) || !defined_default(value.position)) {
          this._needTrackedEntityUpdate = false;
          if (sceneMode === SceneMode_default.COLUMBUS_VIEW || sceneMode === SceneMode_default.SCENE2D) {
            scene.screenSpaceCameraController.enableTranslate = true;
          }
          if (sceneMode === SceneMode_default.COLUMBUS_VIEW || sceneMode === SceneMode_default.SCENE3D) {
            scene.screenSpaceCameraController.enableTilt = true;
          }
          this._entityView = void 0;
          this.camera.lookAtTransform(Matrix4_default.IDENTITY);
        } else {
          this._needTrackedEntityUpdate = true;
        }
        this._trackedEntityChanged.raiseEvent(value);
        this.scene.requestRender();
      }
    }
  },
  selectedEntity: {
    get: function() {
      return this._selectedEntity;
    },
    set: function(value) {
      if (this._selectedEntity !== value) {
        this._selectedEntity = value;
        const selectionIndicatorViewModel = defined_default(this._selectionIndicator) ? this._selectionIndicator.viewModel : void 0;
        if (defined_default(value)) {
          if (defined_default(selectionIndicatorViewModel)) {
            selectionIndicatorViewModel.animateAppear();
          }
        } else if (defined_default(selectionIndicatorViewModel)) {
          selectionIndicatorViewModel.animateDepart();
        }
        this._selectedEntityChanged.raiseEvent(value);
      }
    }
  },
  selectedEntityChanged: {
    get: function() {
      return this._selectedEntityChanged;
    }
  },
  trackedEntityChanged: {
    get: function() {
      return this._trackedEntityChanged;
    }
  },
  clockTrackedDataSource: {
    get: function() {
      return this._clockTrackedDataSource;
    },
    set: function(value) {
      if (this._clockTrackedDataSource !== value) {
        this._clockTrackedDataSource = value;
        trackDataSourceClock(this._timeline, this.clock, value);
      }
    }
  }
});
Viewer.prototype.extend = function(mixin, options) {
  if (!defined_default(mixin)) {
    throw new DeveloperError_default("mixin is required.");
  }
  mixin(this, options);
};
Viewer.prototype.resize = function() {
  const cesiumWidget = this._cesiumWidget;
  const container = this._container;
  const width = container.clientWidth;
  const height = container.clientHeight;
  const animationExists = defined_default(this._animation);
  const timelineExists = defined_default(this._timeline);
  cesiumWidget.resize();
  if (width === this._lastWidth && height === this._lastHeight) {
    return;
  }
  const panelMaxHeight = height - 125;
  const baseLayerPickerDropDown = this._baseLayerPickerDropDown;
  if (defined_default(baseLayerPickerDropDown)) {
    baseLayerPickerDropDown.style.maxHeight = `${panelMaxHeight}px`;
  }
  if (defined_default(this._geocoder)) {
    const geocoderSuggestions = this._geocoder.searchSuggestionsContainer;
    geocoderSuggestions.style.maxHeight = `${panelMaxHeight}px`;
  }
  if (defined_default(this._infoBox)) {
    this._infoBox.viewModel.maxHeight = panelMaxHeight;
  }
  const timeline = this._timeline;
  let animationContainer;
  let animationWidth = 0;
  let creditLeft = 0;
  let creditBottom = 0;
  if (animationExists && window.getComputedStyle(this._animation.container).visibility !== "hidden") {
    const lastWidth = this._lastWidth;
    animationContainer = this._animation.container;
    if (width > 900) {
      animationWidth = 169;
      if (lastWidth <= 900) {
        animationContainer.style.width = "169px";
        animationContainer.style.height = "112px";
        this._animation.resize();
      }
    } else if (width >= 600) {
      animationWidth = 136;
      if (lastWidth < 600 || lastWidth > 900) {
        animationContainer.style.width = "136px";
        animationContainer.style.height = "90px";
        this._animation.resize();
      }
    } else {
      animationWidth = 106;
      if (lastWidth > 600 || lastWidth === 0) {
        animationContainer.style.width = "106px";
        animationContainer.style.height = "70px";
        this._animation.resize();
      }
    }
    creditLeft = animationWidth + 5;
  }
  if (timelineExists && window.getComputedStyle(this._timeline.container).visibility !== "hidden") {
    const fullscreenButton = this._fullscreenButton;
    const vrButton = this._vrButton;
    const timelineContainer = timeline.container;
    const timelineStyle = timelineContainer.style;
    creditBottom = timelineContainer.clientHeight + 3;
    timelineStyle.left = `${animationWidth}px`;
    let pixels = 0;
    if (defined_default(fullscreenButton)) {
      pixels += fullscreenButton.container.clientWidth;
    }
    if (defined_default(vrButton)) {
      pixels += vrButton.container.clientWidth;
    }
    timelineStyle.right = `${pixels}px`;
    timeline.resize();
  }
  this._bottomContainer.style.left = `${creditLeft}px`;
  this._bottomContainer.style.bottom = `${creditBottom}px`;
  this._lastWidth = width;
  this._lastHeight = height;
};
Viewer.prototype.forceResize = function() {
  this._lastWidth = 0;
  this.resize();
};
Viewer.prototype.render = function() {
  this._cesiumWidget.render();
};
Viewer.prototype.isDestroyed = function() {
  return false;
};
Viewer.prototype.destroy = function() {
  let i2;
  this.screenSpaceEventHandler.removeInputAction(
    ScreenSpaceEventType_default.LEFT_CLICK
  );
  this.screenSpaceEventHandler.removeInputAction(
    ScreenSpaceEventType_default.LEFT_DOUBLE_CLICK
  );
  const dataSources = this.dataSources;
  const dataSourceLength = dataSources.length;
  for (i2 = 0; i2 < dataSourceLength; i2++) {
    this._dataSourceRemoved(dataSources, dataSources.get(i2));
  }
  this._dataSourceRemoved(void 0, this._dataSourceDisplay.defaultDataSource);
  this._container.removeChild(this._element);
  this._element.removeChild(this._toolbar);
  this._eventHelper.removeAll();
  if (defined_default(this._geocoder)) {
    this._geocoder = this._geocoder.destroy();
  }
  if (defined_default(this._homeButton)) {
    this._homeButton = this._homeButton.destroy();
  }
  if (defined_default(this._sceneModePicker)) {
    this._sceneModePicker = this._sceneModePicker.destroy();
  }
  if (defined_default(this._projectionPicker)) {
    this._projectionPicker = this._projectionPicker.destroy();
  }
  if (defined_default(this._baseLayerPicker)) {
    this._baseLayerPicker = this._baseLayerPicker.destroy();
  }
  if (defined_default(this._animation)) {
    this._element.removeChild(this._animation.container);
    this._animation = this._animation.destroy();
  }
  if (defined_default(this._timeline)) {
    this._timeline.removeEventListener(
      "settime",
      onTimelineScrubfunction,
      false
    );
    this._element.removeChild(this._timeline.container);
    this._timeline = this._timeline.destroy();
  }
  if (defined_default(this._fullscreenButton)) {
    this._fullscreenSubscription.dispose();
    this._element.removeChild(this._fullscreenButton.container);
    this._fullscreenButton = this._fullscreenButton.destroy();
  }
  if (defined_default(this._vrButton)) {
    this._vrSubscription.dispose();
    this._vrModeSubscription.dispose();
    this._element.removeChild(this._vrButton.container);
    this._vrButton = this._vrButton.destroy();
  }
  if (defined_default(this._infoBox)) {
    this._element.removeChild(this._infoBox.container);
    this._infoBox = this._infoBox.destroy();
  }
  if (defined_default(this._selectionIndicator)) {
    this._element.removeChild(this._selectionIndicator.container);
    this._selectionIndicator = this._selectionIndicator.destroy();
  }
  if (this._destroyClockViewModel) {
    this._clockViewModel = this._clockViewModel.destroy();
  }
  this._dataSourceDisplay = this._dataSourceDisplay.destroy();
  this._cesiumWidget = this._cesiumWidget.destroy();
  if (this._destroyDataSourceCollection) {
    this._dataSourceCollection = this._dataSourceCollection.destroy();
  }
  return destroyObject_default(this);
};
Viewer.prototype._dataSourceAdded = function(dataSourceCollection, dataSource) {
  const entityCollection = dataSource.entities;
  entityCollection.collectionChanged.addEventListener(
    Viewer.prototype._onEntityCollectionChanged,
    this
  );
};
Viewer.prototype._dataSourceRemoved = function(dataSourceCollection, dataSource) {
  const entityCollection = dataSource.entities;
  entityCollection.collectionChanged.removeEventListener(
    Viewer.prototype._onEntityCollectionChanged,
    this
  );
  if (defined_default(this.trackedEntity)) {
    if (entityCollection.getById(this.trackedEntity.id) === this.trackedEntity) {
      this.trackedEntity = void 0;
    }
  }
  if (defined_default(this.selectedEntity)) {
    if (entityCollection.getById(this.selectedEntity.id) === this.selectedEntity) {
      this.selectedEntity = void 0;
    }
  }
};
Viewer.prototype._onTick = function(clock) {
  const time = clock.currentTime;
  const isUpdated = this._dataSourceDisplay.update(time);
  if (this._allowDataSourcesToSuspendAnimation) {
    this._clockViewModel.canAnimate = isUpdated;
  }
  const entityView = this._entityView;
  if (defined_default(entityView)) {
    const trackedEntity = this._trackedEntity;
    const trackedState = this._dataSourceDisplay.getBoundingSphere(
      trackedEntity,
      false,
      boundingSphereScratch4
    );
    if (trackedState === BoundingSphereState_default.DONE) {
      entityView.update(time, boundingSphereScratch4);
    }
  }
  let position;
  let enableCamera = false;
  const selectedEntity = this.selectedEntity;
  const showSelection = defined_default(selectedEntity) && this._enableInfoOrSelection;
  if (showSelection && selectedEntity.isShowing && selectedEntity.isAvailable(time)) {
    const state = this._dataSourceDisplay.getBoundingSphere(
      selectedEntity,
      true,
      boundingSphereScratch4
    );
    if (state !== BoundingSphereState_default.FAILED) {
      position = boundingSphereScratch4.center;
    } else if (defined_default(selectedEntity.position)) {
      position = selectedEntity.position.getValue(time, position);
    }
    enableCamera = defined_default(position);
  }
  const selectionIndicatorViewModel = defined_default(this._selectionIndicator) ? this._selectionIndicator.viewModel : void 0;
  if (defined_default(selectionIndicatorViewModel)) {
    selectionIndicatorViewModel.position = Cartesian3_default.clone(
      position,
      selectionIndicatorViewModel.position
    );
    selectionIndicatorViewModel.showSelection = showSelection && enableCamera;
    selectionIndicatorViewModel.update();
  }
  const infoBoxViewModel = defined_default(this._infoBox) ? this._infoBox.viewModel : void 0;
  if (defined_default(infoBoxViewModel)) {
    infoBoxViewModel.showInfo = showSelection;
    infoBoxViewModel.enableCamera = enableCamera;
    infoBoxViewModel.isCameraTracking = this.trackedEntity === this.selectedEntity;
    if (showSelection) {
      infoBoxViewModel.titleText = defaultValue_default(
        selectedEntity.name,
        selectedEntity.id
      );
      infoBoxViewModel.description = Property_default.getValueOrDefault(
        selectedEntity.description,
        time,
        ""
      );
    } else {
      infoBoxViewModel.titleText = "";
      infoBoxViewModel.description = "";
    }
  }
};
Viewer.prototype._onEntityCollectionChanged = function(collection, added, removed) {
  const length3 = removed.length;
  for (let i2 = 0; i2 < length3; i2++) {
    const removedObject = removed[i2];
    if (this.trackedEntity === removedObject) {
      this.trackedEntity = void 0;
    }
    if (this.selectedEntity === removedObject) {
      this.selectedEntity = void 0;
    }
  }
};
Viewer.prototype._onInfoBoxCameraClicked = function(infoBoxViewModel) {
  if (infoBoxViewModel.isCameraTracking && this.trackedEntity === this.selectedEntity) {
    this.trackedEntity = void 0;
  } else {
    const selectedEntity = this.selectedEntity;
    const position = selectedEntity.position;
    if (defined_default(position)) {
      this.trackedEntity = this.selectedEntity;
    } else {
      this.zoomTo(this.selectedEntity);
    }
  }
};
Viewer.prototype._clearTrackedObject = function() {
  this.trackedEntity = void 0;
};
Viewer.prototype._onInfoBoxClockClicked = function(infoBoxViewModel) {
  this.selectedEntity = void 0;
};
Viewer.prototype._clearObjects = function() {
  this.trackedEntity = void 0;
  this.selectedEntity = void 0;
};
Viewer.prototype._onDataSourceChanged = function(dataSource) {
  if (this.clockTrackedDataSource === dataSource) {
    trackDataSourceClock(this.timeline, this.clock, dataSource);
  }
};
Viewer.prototype._onDataSourceAdded = function(dataSourceCollection, dataSource) {
  if (this._automaticallyTrackDataSourceClocks) {
    this.clockTrackedDataSource = dataSource;
  }
  const id = dataSource.entities.id;
  const removalFunc = this._eventHelper.add(
    dataSource.changedEvent,
    Viewer.prototype._onDataSourceChanged,
    this
  );
  this._dataSourceChangedListeners[id] = removalFunc;
};
Viewer.prototype._onDataSourceRemoved = function(dataSourceCollection, dataSource) {
  const resetClock = this.clockTrackedDataSource === dataSource;
  const id = dataSource.entities.id;
  this._dataSourceChangedListeners[id]();
  this._dataSourceChangedListeners[id] = void 0;
  if (resetClock) {
    const numDataSources = dataSourceCollection.length;
    if (this._automaticallyTrackDataSourceClocks && numDataSources > 0) {
      this.clockTrackedDataSource = dataSourceCollection.get(
        numDataSources - 1
      );
    } else {
      this.clockTrackedDataSource = void 0;
    }
  }
};
Viewer.prototype.zoomTo = function(target, offset2) {
  const options = {
    offset: offset2
  };
  return zoomToOrFly(this, target, options, false);
};
Viewer.prototype.flyTo = function(target, options) {
  return zoomToOrFly(this, target, options, true);
};
function zoomToOrFly(that, zoomTarget, options, isFlight) {
  if (!defined_default(zoomTarget)) {
    throw new DeveloperError_default("zoomTarget is required.");
  }
  cancelZoom(that);
  const zoomPromise = defer_default();
  that._zoomPromise = zoomPromise;
  that._zoomIsFlight = isFlight;
  that._zoomOptions = options;
  Promise.resolve(zoomTarget).then(function(zoomTarget2) {
    if (that._zoomPromise !== zoomPromise) {
      return;
    }
    if (zoomTarget2 instanceof ImageryLayer_default) {
      zoomTarget2.getViewableRectangle().then(function(rectangle) {
        return computeFlyToLocationForRectangle_default(rectangle, that.scene);
      }).then(function(position) {
        if (that._zoomPromise === zoomPromise) {
          that._zoomTarget = position;
        }
      });
      return;
    }
    if (zoomTarget2 instanceof Cesium3DTileset_default) {
      that._zoomTarget = zoomTarget2;
      return;
    }
    if (zoomTarget2 instanceof TimeDynamicPointCloud_default) {
      that._zoomTarget = zoomTarget2;
      return;
    }
    if (zoomTarget2.isLoading && defined_default(zoomTarget2.loadingEvent)) {
      const removeEvent = zoomTarget2.loadingEvent.addEventListener(function() {
        removeEvent();
        if (that._zoomPromise === zoomPromise) {
          that._zoomTarget = zoomTarget2.entities.values.slice(0);
        }
      });
      return;
    }
    if (Array.isArray(zoomTarget2)) {
      that._zoomTarget = zoomTarget2.slice(0);
      return;
    }
    zoomTarget2 = defaultValue_default(zoomTarget2.values, zoomTarget2);
    if (defined_default(zoomTarget2.entities)) {
      zoomTarget2 = zoomTarget2.entities.values;
    }
    if (Array.isArray(zoomTarget2)) {
      that._zoomTarget = zoomTarget2.slice(0);
    } else {
      that._zoomTarget = [zoomTarget2];
    }
  });
  that.scene.requestRender();
  return zoomPromise.promise;
}
function clearZoom(viewer) {
  viewer._zoomPromise = void 0;
  viewer._zoomTarget = void 0;
  viewer._zoomOptions = void 0;
}
function cancelZoom(viewer) {
  const zoomPromise = viewer._zoomPromise;
  if (defined_default(zoomPromise)) {
    clearZoom(viewer);
    zoomPromise.resolve(false);
  }
}
Viewer.prototype._postRender = function() {
  updateZoomTarget(this);
  updateTrackedEntity(this);
};
function updateZoomTarget(viewer) {
  const target = viewer._zoomTarget;
  if (!defined_default(target) || viewer.scene.mode === SceneMode_default.MORPHING) {
    return;
  }
  const scene = viewer.scene;
  const camera = scene.camera;
  const zoomPromise = viewer._zoomPromise;
  const zoomOptions = defaultValue_default(viewer._zoomOptions, {});
  let options;
  if (target instanceof Cesium3DTileset_default) {
    return target.readyPromise.then(function() {
      const boundingSphere2 = target.boundingSphere;
      if (!defined_default(zoomOptions.offset)) {
        zoomOptions.offset = new HeadingPitchRange_default(
          0,
          -0.5,
          boundingSphere2.radius
        );
      }
      options = {
        offset: zoomOptions.offset,
        duration: zoomOptions.duration,
        maximumHeight: zoomOptions.maximumHeight,
        complete: function() {
          zoomPromise.resolve(true);
        },
        cancel: function() {
          zoomPromise.resolve(false);
        }
      };
      if (viewer._zoomIsFlight) {
        camera.flyToBoundingSphere(target.boundingSphere, options);
      } else {
        camera.viewBoundingSphere(boundingSphere2, zoomOptions.offset);
        camera.lookAtTransform(Matrix4_default.IDENTITY);
        zoomPromise.resolve(true);
      }
      clearZoom(viewer);
    });
  }
  if (target instanceof TimeDynamicPointCloud_default) {
    return target.readyPromise.then(function() {
      const boundingSphere2 = target.boundingSphere;
      if (!defined_default(zoomOptions.offset)) {
        zoomOptions.offset = new HeadingPitchRange_default(
          0,
          -0.5,
          boundingSphere2.radius
        );
      }
      options = {
        offset: zoomOptions.offset,
        duration: zoomOptions.duration,
        maximumHeight: zoomOptions.maximumHeight,
        complete: function() {
          zoomPromise.resolve(true);
        },
        cancel: function() {
          zoomPromise.resolve(false);
        }
      };
      if (viewer._zoomIsFlight) {
        camera.flyToBoundingSphere(boundingSphere2, options);
      } else {
        camera.viewBoundingSphere(boundingSphere2, zoomOptions.offset);
        camera.lookAtTransform(Matrix4_default.IDENTITY);
        zoomPromise.resolve(true);
      }
      clearZoom(viewer);
    });
  }
  if (target instanceof Cartographic_default) {
    options = {
      destination: scene.mapProjection.ellipsoid.cartographicToCartesian(
        target
      ),
      duration: zoomOptions.duration,
      maximumHeight: zoomOptions.maximumHeight,
      complete: function() {
        zoomPromise.resolve(true);
      },
      cancel: function() {
        zoomPromise.resolve(false);
      }
    };
    if (viewer._zoomIsFlight) {
      camera.flyTo(options);
    } else {
      camera.setView(options);
      zoomPromise.resolve(true);
    }
    clearZoom(viewer);
    return;
  }
  const entities = target;
  const boundingSpheres = [];
  for (let i2 = 0, len = entities.length; i2 < len; i2++) {
    const state = viewer._dataSourceDisplay.getBoundingSphere(
      entities[i2],
      false,
      boundingSphereScratch4
    );
    if (state === BoundingSphereState_default.PENDING) {
      return;
    } else if (state !== BoundingSphereState_default.FAILED) {
      boundingSpheres.push(BoundingSphere_default.clone(boundingSphereScratch4));
    }
  }
  if (boundingSpheres.length === 0) {
    cancelZoom(viewer);
    return;
  }
  viewer.trackedEntity = void 0;
  const boundingSphere = BoundingSphere_default.fromBoundingSpheres(boundingSpheres);
  if (!viewer._zoomIsFlight) {
    camera.viewBoundingSphere(boundingSphere, zoomOptions.offset);
    camera.lookAtTransform(Matrix4_default.IDENTITY);
    clearZoom(viewer);
    zoomPromise.resolve(true);
  } else {
    clearZoom(viewer);
    camera.flyToBoundingSphere(boundingSphere, {
      duration: zoomOptions.duration,
      maximumHeight: zoomOptions.maximumHeight,
      complete: function() {
        zoomPromise.resolve(true);
      },
      cancel: function() {
        zoomPromise.resolve(false);
      },
      offset: zoomOptions.offset
    });
  }
}
function updateTrackedEntity(viewer) {
  if (!viewer._needTrackedEntityUpdate) {
    return;
  }
  const trackedEntity = viewer._trackedEntity;
  const currentTime = viewer.clock.currentTime;
  const currentPosition = Property_default.getValueOrUndefined(
    trackedEntity.position,
    currentTime
  );
  if (!defined_default(currentPosition)) {
    return;
  }
  const scene = viewer.scene;
  const state = viewer._dataSourceDisplay.getBoundingSphere(
    trackedEntity,
    false,
    boundingSphereScratch4
  );
  if (state === BoundingSphereState_default.PENDING) {
    return;
  }
  const sceneMode = scene.mode;
  if (sceneMode === SceneMode_default.COLUMBUS_VIEW || sceneMode === SceneMode_default.SCENE2D) {
    scene.screenSpaceCameraController.enableTranslate = false;
  }
  if (sceneMode === SceneMode_default.COLUMBUS_VIEW || sceneMode === SceneMode_default.SCENE3D) {
    scene.screenSpaceCameraController.enableTilt = false;
  }
  const bs = state !== BoundingSphereState_default.FAILED ? boundingSphereScratch4 : void 0;
  viewer._entityView = new EntityView_default(
    trackedEntity,
    scene,
    scene.mapProjection.ellipsoid
  );
  viewer._entityView.update(currentTime, bs);
  viewer._needTrackedEntityUpdate = false;
}
var Viewer_default = Viewer;

// node_modules/cesium/Source/Widgets/Viewer/viewerCesium3DTilesInspectorMixin.js
function viewerCesium3DTilesInspectorMixin(viewer) {
  Check_default.typeOf.object("viewer", viewer);
  const container = document.createElement("div");
  container.className = "cesium-viewer-cesium3DTilesInspectorContainer";
  viewer.container.appendChild(container);
  const cesium3DTilesInspector = new Cesium3DTilesInspector_default(
    container,
    viewer.scene
  );
  Object.defineProperties(viewer, {
    cesium3DTilesInspector: {
      get: function() {
        return cesium3DTilesInspector;
      }
    }
  });
}
var viewerCesium3DTilesInspectorMixin_default = viewerCesium3DTilesInspectorMixin;

// node_modules/cesium/Source/Widgets/Viewer/viewerCesiumInspectorMixin.js
function viewerCesiumInspectorMixin(viewer) {
  if (!defined_default(viewer)) {
    throw new DeveloperError_default("viewer is required.");
  }
  const cesiumInspectorContainer = document.createElement("div");
  cesiumInspectorContainer.className = "cesium-viewer-cesiumInspectorContainer";
  viewer.container.appendChild(cesiumInspectorContainer);
  const cesiumInspector = new CesiumInspector_default(
    cesiumInspectorContainer,
    viewer.scene
  );
  Object.defineProperties(viewer, {
    cesiumInspector: {
      get: function() {
        return cesiumInspector;
      }
    }
  });
}
var viewerCesiumInspectorMixin_default = viewerCesiumInspectorMixin;

// node_modules/cesium/Source/Widgets/Viewer/viewerDragDropMixin.js
function viewerDragDropMixin(viewer, options) {
  if (!defined_default(viewer)) {
    throw new DeveloperError_default("viewer is required.");
  }
  if (viewer.hasOwnProperty("dropTarget")) {
    throw new DeveloperError_default("dropTarget is already defined by another mixin.");
  }
  if (viewer.hasOwnProperty("dropEnabled")) {
    throw new DeveloperError_default(
      "dropEnabled is already defined by another mixin."
    );
  }
  if (viewer.hasOwnProperty("dropError")) {
    throw new DeveloperError_default("dropError is already defined by another mixin.");
  }
  if (viewer.hasOwnProperty("clearOnDrop")) {
    throw new DeveloperError_default(
      "clearOnDrop is already defined by another mixin."
    );
  }
  if (viewer.hasOwnProperty("flyToOnDrop")) {
    throw new DeveloperError_default(
      "flyToOnDrop is already defined by another mixin."
    );
  }
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  let dropEnabled = true;
  let flyToOnDrop = defaultValue_default(options.flyToOnDrop, true);
  const dropError = new Event_default();
  let clearOnDrop = defaultValue_default(options.clearOnDrop, true);
  let dropTarget = defaultValue_default(options.dropTarget, viewer.container);
  let clampToGround = defaultValue_default(options.clampToGround, true);
  let proxy = options.proxy;
  dropTarget = getElement_default(dropTarget);
  Object.defineProperties(viewer, {
    dropTarget: {
      get: function() {
        return dropTarget;
      },
      set: function(value) {
        if (!defined_default(value)) {
          throw new DeveloperError_default("value is required.");
        }
        unsubscribe(dropTarget, handleDrop);
        dropTarget = value;
        subscribe(dropTarget, handleDrop);
      }
    },
    dropEnabled: {
      get: function() {
        return dropEnabled;
      },
      set: function(value) {
        if (value !== dropEnabled) {
          if (value) {
            subscribe(dropTarget, handleDrop);
          } else {
            unsubscribe(dropTarget, handleDrop);
          }
          dropEnabled = value;
        }
      }
    },
    dropError: {
      get: function() {
        return dropError;
      }
    },
    clearOnDrop: {
      get: function() {
        return clearOnDrop;
      },
      set: function(value) {
        clearOnDrop = value;
      }
    },
    flyToOnDrop: {
      get: function() {
        return flyToOnDrop;
      },
      set: function(value) {
        flyToOnDrop = value;
      }
    },
    proxy: {
      get: function() {
        return proxy;
      },
      set: function(value) {
        proxy = value;
      }
    },
    clampToGround: {
      get: function() {
        return clampToGround;
      },
      set: function(value) {
        clampToGround = value;
      }
    }
  });
  function handleDrop(event) {
    stop(event);
    if (clearOnDrop) {
      viewer.entities.removeAll();
      viewer.dataSources.removeAll();
    }
    const files = event.dataTransfer.files;
    const length3 = files.length;
    for (let i2 = 0; i2 < length3; i2++) {
      const file = files[i2];
      const reader = new FileReader();
      reader.onload = createOnLoadCallback(viewer, file, proxy, clampToGround);
      reader.onerror = createDropErrorCallback(viewer, file);
      reader.readAsText(file);
    }
  }
  subscribe(dropTarget, handleDrop);
  viewer.destroy = wrapFunction_default(viewer, viewer.destroy, function() {
    viewer.dropEnabled = false;
  });
  viewer._handleDrop = handleDrop;
}
function stop(event) {
  event.stopPropagation();
  event.preventDefault();
}
function unsubscribe(dropTarget, handleDrop) {
  const currentTarget = dropTarget;
  if (defined_default(currentTarget)) {
    currentTarget.removeEventListener("drop", handleDrop, false);
    currentTarget.removeEventListener("dragenter", stop, false);
    currentTarget.removeEventListener("dragover", stop, false);
    currentTarget.removeEventListener("dragexit", stop, false);
  }
}
function subscribe(dropTarget, handleDrop) {
  dropTarget.addEventListener("drop", handleDrop, false);
  dropTarget.addEventListener("dragenter", stop, false);
  dropTarget.addEventListener("dragover", stop, false);
  dropTarget.addEventListener("dragexit", stop, false);
}
function createOnLoadCallback(viewer, file, proxy, clampToGround) {
  const scene = viewer.scene;
  return function(evt) {
    const fileName = file.name;
    try {
      let loadPromise;
      if (/\.czml$/i.test(fileName)) {
        loadPromise = CzmlDataSource_default.load(JSON.parse(evt.target.result), {
          sourceUri: fileName
        });
      } else if (/\.geojson$/i.test(fileName) || /\.json$/i.test(fileName) || /\.topojson$/i.test(fileName)) {
        loadPromise = GeoJsonDataSource_default.load(JSON.parse(evt.target.result), {
          sourceUri: fileName,
          clampToGround
        });
      } else if (/\.(kml|kmz)$/i.test(fileName)) {
        loadPromise = KmlDataSource_default.load(file, {
          sourceUri: fileName,
          proxy,
          camera: scene.camera,
          canvas: scene.canvas,
          clampToGround,
          screenOverlayContainer: viewer.container
        });
      } else if (/\.gpx$/i.test(fileName)) {
        loadPromise = GpxDataSource_default.load(file, {
          sourceUri: fileName,
          proxy
        });
      } else {
        viewer.dropError.raiseEvent(
          viewer,
          fileName,
          `Unrecognized file: ${fileName}`
        );
        return;
      }
      if (defined_default(loadPromise)) {
        viewer.dataSources.add(loadPromise).then(function(dataSource) {
          if (viewer.flyToOnDrop) {
            viewer.flyTo(dataSource);
          }
        }).catch(function(error) {
          viewer.dropError.raiseEvent(viewer, fileName, error);
        });
      }
    } catch (error) {
      viewer.dropError.raiseEvent(viewer, fileName, error);
    }
  };
}
function createDropErrorCallback(viewer, file) {
  return function(evt) {
    viewer.dropError.raiseEvent(viewer, file.name, evt.target.error);
  };
}
var viewerDragDropMixin_default = viewerDragDropMixin;

// node_modules/cesium/Source/Widgets/Viewer/viewerPerformanceWatchdogMixin.js
function viewerPerformanceWatchdogMixin(viewer, options) {
  if (!defined_default(viewer)) {
    throw new DeveloperError_default("viewer is required.");
  }
  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
  const performanceWatchdog = new PerformanceWatchdog_default({
    scene: viewer.scene,
    container: viewer.bottomContainer,
    lowFrameRateMessage: options.lowFrameRateMessage
  });
  Object.defineProperties(viewer, {
    performanceWatchdog: {
      get: function() {
        return performanceWatchdog;
      }
    }
  });
}
var viewerPerformanceWatchdogMixin_default = viewerPerformanceWatchdogMixin;

// node_modules/cesium/Source/WorkersES6/createTaskProcessorWorker.js
function callAndWrap(workerFunction, parameters, transferableObjects) {
  let resultOrPromise;
  try {
    resultOrPromise = workerFunction(parameters, transferableObjects);
    return resultOrPromise;
  } catch (e2) {
    return Promise.reject(e2);
  }
}
function createTaskProcessorWorker(workerFunction) {
  let postMessage;
  return function(event) {
    const data = event.data;
    const transferableObjects = [];
    const responseMessage = {
      id: data.id,
      result: void 0,
      error: void 0
    };
    return Promise.resolve(
      callAndWrap(workerFunction, data.parameters, transferableObjects)
    ).then(function(result) {
      responseMessage.result = result;
    }).catch(function(e2) {
      if (e2 instanceof Error) {
        responseMessage.error = {
          name: e2.name,
          message: e2.message,
          stack: e2.stack
        };
      } else {
        responseMessage.error = e2;
      }
    }).finally(function() {
      if (!defined_default(postMessage)) {
        postMessage = defaultValue_default(self.webkitPostMessage, self.postMessage);
      }
      if (!data.canTransferArrayBuffer) {
        transferableObjects.length = 0;
      }
      try {
        postMessage(responseMessage, transferableObjects);
      } catch (e2) {
        responseMessage.result = void 0;
        responseMessage.error = `postMessage failed with error: ${formatError_default(
          e2
        )}
  with responseMessage: ${JSON.stringify(responseMessage)}`;
        postMessage(responseMessage);
      }
    });
  };
}
var createTaskProcessorWorker_default = createTaskProcessorWorker;

// node_modules/cesium/Source/Cesium.js
var VERSION = "1.93";
export {
  AlphaMode_default as AlphaMode,
  AlphaPipelineStage_default as AlphaPipelineStage,
  Animation_default as Animation,
  AnimationViewModel_default as AnimationViewModel,
  Appearance_default as Appearance,
  ApproximateTerrainHeights_default as ApproximateTerrainHeights,
  ArcGISTiledElevationTerrainProvider_default as ArcGISTiledElevationTerrainProvider,
  ArcGisMapServerImageryProvider_default as ArcGisMapServerImageryProvider,
  ArcType_default as ArcType,
  AssociativeArray_default as AssociativeArray,
  AttributeCompression_default as AttributeCompression,
  AttributeType_default as AttributeType,
  AutoExposure_default as AutoExposure,
  Autolinker,
  AutomaticUniforms_default as AutomaticUniforms,
  Axis_default as Axis,
  AxisAlignedBoundingBox_default as AxisAlignedBoundingBox,
  B3dmLoader_default as B3dmLoader,
  B3dmParser_default as B3dmParser,
  BaseLayerPicker_default as BaseLayerPicker,
  BaseLayerPickerViewModel_default as BaseLayerPickerViewModel,
  BatchTable_default as BatchTable,
  BatchTableHierarchy,
  BatchTexture,
  BatchTexturePipelineStage_default as BatchTexturePipelineStage,
  Batched3DModel3DTileContent_default as Batched3DModel3DTileContent,
  Billboard_default as Billboard,
  BillboardCollection_default as BillboardCollection,
  BillboardGraphics_default as BillboardGraphics,
  BillboardVisualizer_default as BillboardVisualizer,
  BingMapsGeocoderService_default as BingMapsGeocoderService,
  BingMapsImageryProvider_default as BingMapsImageryProvider,
  BingMapsStyle_default as BingMapsStyle,
  BlendEquation_default as BlendEquation,
  BlendFunction_default as BlendFunction,
  BlendOption_default as BlendOption,
  BlendingState_default as BlendingState,
  BoundingRectangle_default as BoundingRectangle,
  BoundingSphere_default as BoundingSphere,
  BoundingSphereState_default as BoundingSphereState,
  BoxEmitter_default as BoxEmitter,
  BoxGeometry_default as BoxGeometry,
  BoxGeometryUpdater_default as BoxGeometryUpdater,
  BoxGraphics_default as BoxGraphics,
  BoxOutlineGeometry_default as BoxOutlineGeometry,
  BrdfLutGenerator_default as BrdfLutGenerator,
  Buffer_default as Buffer,
  BufferLoader,
  BufferUsage_default as BufferUsage,
  CPUStylingPipelineStage_default as CPUStylingPipelineStage,
  CallbackProperty_default as CallbackProperty,
  Camera_default as Camera,
  CameraEventAggregator_default as CameraEventAggregator,
  CameraEventType_default as CameraEventType,
  CameraFlightPath_default as CameraFlightPath,
  Cartesian2_default as Cartesian2,
  Cartesian3_default as Cartesian3,
  Cartesian4_default as Cartesian4,
  Cartographic_default as Cartographic,
  CartographicGeocoderService_default as CartographicGeocoderService,
  CatmullRomSpline_default as CatmullRomSpline,
  Cesium3DContentGroup,
  Cesium3DTile_default as Cesium3DTile,
  Cesium3DTileBatchTable_default as Cesium3DTileBatchTable,
  Cesium3DTileColorBlendMode_default as Cesium3DTileColorBlendMode,
  Cesium3DTileContent_default as Cesium3DTileContent,
  Cesium3DTileContentFactory_default as Cesium3DTileContentFactory,
  Cesium3DTileContentState_default as Cesium3DTileContentState,
  Cesium3DTileContentType_default as Cesium3DTileContentType,
  Cesium3DTileFeature_default as Cesium3DTileFeature,
  Cesium3DTileFeatureTable_default as Cesium3DTileFeatureTable,
  Cesium3DTileOptimizationHint_default as Cesium3DTileOptimizationHint,
  Cesium3DTileOptimizations_default as Cesium3DTileOptimizations,
  Cesium3DTilePass_default as Cesium3DTilePass,
  Cesium3DTilePassState_default as Cesium3DTilePassState,
  Cesium3DTilePointFeature_default as Cesium3DTilePointFeature,
  Cesium3DTileRefine_default as Cesium3DTileRefine,
  Cesium3DTileStyle_default as Cesium3DTileStyle,
  Cesium3DTileStyleEngine_default as Cesium3DTileStyleEngine,
  Cesium3DTilesInspector_default as Cesium3DTilesInspector,
  Cesium3DTilesInspectorViewModel_default as Cesium3DTilesInspectorViewModel,
  Cesium3DTileset_default as Cesium3DTileset,
  Cesium3DTilesetCache_default as Cesium3DTilesetCache,
  Cesium3DTilesetGraphics_default as Cesium3DTilesetGraphics,
  Cesium3DTilesetHeatmap_default as Cesium3DTilesetHeatmap,
  Cesium3DTilesetMetadata_default as Cesium3DTilesetMetadata,
  Cesium3DTilesetMostDetailedTraversal_default as Cesium3DTilesetMostDetailedTraversal,
  Cesium3DTilesetStatistics_default as Cesium3DTilesetStatistics,
  Cesium3DTilesetTraversal_default as Cesium3DTilesetTraversal,
  Cesium3DTilesetVisualizer_default as Cesium3DTilesetVisualizer,
  CesiumInspector_default as CesiumInspector,
  CesiumInspectorViewModel_default as CesiumInspectorViewModel,
  CesiumTerrainProvider_default as CesiumTerrainProvider,
  CesiumWidget_default as CesiumWidget,
  Check_default as Check,
  CheckerboardMaterialProperty_default as CheckerboardMaterialProperty,
  CircleEmitter_default as CircleEmitter,
  CircleGeometry_default as CircleGeometry,
  CircleOutlineGeometry_default as CircleOutlineGeometry,
  ClassificationModel_default as ClassificationModel,
  ClassificationPrimitive_default as ClassificationPrimitive,
  ClassificationType_default as ClassificationType,
  ClearCommand_default as ClearCommand,
  ClippingPlane_default as ClippingPlane,
  ClippingPlaneCollection_default as ClippingPlaneCollection,
  Clock_default as Clock,
  ClockRange_default as ClockRange,
  ClockStep_default as ClockStep,
  ClockViewModel_default as ClockViewModel,
  CloudCollection_default as CloudCollection,
  CloudType_default as CloudType,
  Color_default as Color,
  ColorBlendMode_default as ColorBlendMode,
  ColorGeometryInstanceAttribute_default as ColorGeometryInstanceAttribute,
  ColorMaterialProperty_default as ColorMaterialProperty,
  Command_default as Command,
  ComponentDatatype_default as ComponentDatatype,
  Composite3DTileContent_default as Composite3DTileContent,
  CompositeEntityCollection_default as CompositeEntityCollection,
  CompositeMaterialProperty_default as CompositeMaterialProperty,
  CompositePositionProperty_default as CompositePositionProperty,
  CompositeProperty_default as CompositeProperty,
  CompressedTextureBuffer_default as CompressedTextureBuffer,
  ComputeCommand_default as ComputeCommand,
  ComputeEngine_default as ComputeEngine,
  ConditionsExpression_default as ConditionsExpression,
  ConeEmitter_default as ConeEmitter,
  ConstantPositionProperty_default as ConstantPositionProperty,
  ConstantProperty_default as ConstantProperty,
  ConstantSpline_default as ConstantSpline,
  ContentMetadata,
  Context_default as Context,
  ContextLimits_default as ContextLimits,
  CoplanarPolygonGeometry_default as CoplanarPolygonGeometry,
  CoplanarPolygonGeometryLibrary_default as CoplanarPolygonGeometryLibrary,
  CoplanarPolygonOutlineGeometry_default as CoplanarPolygonOutlineGeometry,
  CornerType_default as CornerType,
  CorridorGeometry_default as CorridorGeometry,
  CorridorGeometryLibrary_default as CorridorGeometryLibrary,
  CorridorGeometryUpdater_default as CorridorGeometryUpdater,
  CorridorGraphics_default as CorridorGraphics,
  CorridorOutlineGeometry_default as CorridorOutlineGeometry,
  Credit_default as Credit,
  CreditDisplay_default as CreditDisplay,
  CubeMap_default as CubeMap,
  CubeMapFace_default as CubeMapFace,
  CubicRealPolynomial_default as CubicRealPolynomial,
  CullFace_default as CullFace,
  CullingVolume_default as CullingVolume,
  CumulusCloud_default as CumulusCloud,
  CustomDataSource_default as CustomDataSource,
  CustomHeightmapTerrainProvider_default as CustomHeightmapTerrainProvider,
  CustomShader,
  CustomShaderMode_default as CustomShaderMode,
  CustomShaderPipelineStage_default as CustomShaderPipelineStage,
  CylinderGeometry_default as CylinderGeometry,
  CylinderGeometryLibrary_default as CylinderGeometryLibrary,
  CylinderGeometryUpdater_default as CylinderGeometryUpdater,
  CylinderGraphics_default as CylinderGraphics,
  CylinderOutlineGeometry_default as CylinderOutlineGeometry,
  CzmlDataSource_default as CzmlDataSource,
  DataSource_default as DataSource,
  DataSourceClock_default as DataSourceClock,
  DataSourceCollection_default as DataSourceCollection,
  DataSourceDisplay_default as DataSourceDisplay,
  DebugAppearance_default as DebugAppearance,
  DebugCameraPrimitive_default as DebugCameraPrimitive,
  DebugInspector_default as DebugInspector,
  DebugModelMatrixPrimitive_default as DebugModelMatrixPrimitive,
  DefaultProxy_default as DefaultProxy,
  DepthFunction_default as DepthFunction,
  DepthPlane_default as DepthPlane,
  DequantizationPipelineStage_default as DequantizationPipelineStage,
  DerivedCommand_default as DerivedCommand,
  DeveloperError_default as DeveloperError,
  DeviceOrientationCameraController_default as DeviceOrientationCameraController,
  DirectionalLight_default as DirectionalLight,
  DiscardEmptyTileImagePolicy_default as DiscardEmptyTileImagePolicy,
  DiscardMissingTileImagePolicy_default as DiscardMissingTileImagePolicy,
  DistanceDisplayCondition_default as DistanceDisplayCondition,
  DistanceDisplayConditionGeometryInstanceAttribute_default as DistanceDisplayConditionGeometryInstanceAttribute,
  DoubleEndedPriorityQueue_default as DoubleEndedPriorityQueue,
  DoublyLinkedList_default as DoublyLinkedList,
  DracoLoader_default as DracoLoader,
  DrawCommand_default as DrawCommand,
  DynamicGeometryBatch_default as DynamicGeometryBatch,
  DynamicGeometryUpdater_default as DynamicGeometryUpdater,
  EarthOrientationParameters_default as EarthOrientationParameters,
  EarthOrientationParametersSample_default as EarthOrientationParametersSample,
  EasingFunction_default as EasingFunction,
  EllipseGeometry_default as EllipseGeometry,
  EllipseGeometryLibrary_default as EllipseGeometryLibrary,
  EllipseGeometryUpdater_default as EllipseGeometryUpdater,
  EllipseGraphics_default as EllipseGraphics,
  EllipseOutlineGeometry_default as EllipseOutlineGeometry,
  Ellipsoid_default as Ellipsoid,
  EllipsoidGeodesic_default as EllipsoidGeodesic,
  EllipsoidGeometry_default as EllipsoidGeometry,
  EllipsoidGeometryUpdater_default as EllipsoidGeometryUpdater,
  EllipsoidGraphics_default as EllipsoidGraphics,
  EllipsoidOutlineGeometry_default as EllipsoidOutlineGeometry,
  EllipsoidPrimitive_default as EllipsoidPrimitive,
  EllipsoidRhumbLine_default as EllipsoidRhumbLine,
  EllipsoidSurfaceAppearance_default as EllipsoidSurfaceAppearance,
  EllipsoidTangentPlane_default as EllipsoidTangentPlane,
  EllipsoidTerrainProvider_default as EllipsoidTerrainProvider,
  EllipsoidalOccluder_default as EllipsoidalOccluder,
  Empty3DTileContent_default as Empty3DTileContent,
  EncodedCartesian3_default as EncodedCartesian3,
  Entity_default as Entity,
  EntityCluster_default as EntityCluster,
  EntityCollection_default as EntityCollection,
  EntityView_default as EntityView,
  Event_default as Event,
  EventHelper_default as EventHelper,
  ExperimentalFeatures_default as ExperimentalFeatures,
  Expression_default as Expression,
  ExpressionNodeType_default as ExpressionNodeType,
  ExtrapolationType_default as ExtrapolationType,
  FeatureDetection_default as FeatureDetection,
  FeatureIdPipelineStage_default as FeatureIdPipelineStage,
  Fog_default as Fog,
  ForEach_default as ForEach,
  FrameRateMonitor_default as FrameRateMonitor,
  FrameState_default as FrameState,
  Framebuffer_default as Framebuffer,
  FramebufferManager_default as FramebufferManager,
  FrustumCommands_default as FrustumCommands,
  FrustumGeometry_default as FrustumGeometry,
  FrustumOutlineGeometry_default as FrustumOutlineGeometry,
  Fullscreen_default as Fullscreen,
  FullscreenButton_default as FullscreenButton,
  FullscreenButtonViewModel_default as FullscreenButtonViewModel,
  GeoJsonDataSource_default as GeoJsonDataSource,
  GeocodeType_default as GeocodeType,
  Geocoder_default as Geocoder,
  GeocoderService_default as GeocoderService,
  GeocoderViewModel_default as GeocoderViewModel,
  GeographicProjection_default as GeographicProjection,
  GeographicTilingScheme_default as GeographicTilingScheme,
  Geometry_default as Geometry,
  Geometry3DTileContent_default as Geometry3DTileContent,
  GeometryAttribute_default as GeometryAttribute,
  GeometryAttributes_default as GeometryAttributes,
  GeometryFactory_default as GeometryFactory,
  GeometryInstance_default as GeometryInstance,
  GeometryInstanceAttribute_default as GeometryInstanceAttribute,
  GeometryOffsetAttribute_default as GeometryOffsetAttribute,
  GeometryPipeline_default as GeometryPipeline,
  GeometryPipelineStage_default as GeometryPipelineStage,
  GeometryType_default as GeometryType,
  GeometryUpdater_default as GeometryUpdater,
  GeometryVisualizer_default as GeometryVisualizer,
  GetFeatureInfoFormat_default as GetFeatureInfoFormat,
  Globe_default as Globe,
  GlobeDepth_default as GlobeDepth,
  GlobeSurfaceShaderSet_default as GlobeSurfaceShaderSet,
  GlobeSurfaceTile_default as GlobeSurfaceTile,
  GlobeSurfaceTileProvider_default as GlobeSurfaceTileProvider,
  GlobeTranslucency_default as GlobeTranslucency,
  GlobeTranslucencyFramebuffer_default as GlobeTranslucencyFramebuffer,
  GlobeTranslucencyState_default as GlobeTranslucencyState,
  GltfBufferViewLoader,
  GltfDracoLoader,
  GltfImageLoader,
  GltfIndexBufferLoader,
  GltfJsonLoader,
  GltfLoader,
  GltfLoaderUtil_default as GltfLoaderUtil,
  GltfStructuralMetadataLoader,
  GltfTextureLoader,
  GltfVertexBufferLoader,
  GoogleEarthEnterpriseImageryProvider_default as GoogleEarthEnterpriseImageryProvider,
  GoogleEarthEnterpriseMapsProvider_default as GoogleEarthEnterpriseMapsProvider,
  GoogleEarthEnterpriseMetadata_default as GoogleEarthEnterpriseMetadata,
  GoogleEarthEnterpriseTerrainData_default as GoogleEarthEnterpriseTerrainData,
  GoogleEarthEnterpriseTerrainProvider_default as GoogleEarthEnterpriseTerrainProvider,
  GoogleEarthEnterpriseTileInformation_default as GoogleEarthEnterpriseTileInformation,
  GpxDataSource_default as GpxDataSource,
  GregorianDate_default as GregorianDate,
  GridImageryProvider_default as GridImageryProvider,
  GridMaterialProperty_default as GridMaterialProperty,
  GroundGeometryUpdater_default as GroundGeometryUpdater,
  GroundPolylineGeometry_default as GroundPolylineGeometry,
  GroundPolylinePrimitive_default as GroundPolylinePrimitive,
  GroundPrimitive_default as GroundPrimitive,
  GroupMetadata_default as GroupMetadata,
  HeadingPitchRange_default as HeadingPitchRange,
  HeadingPitchRoll_default as HeadingPitchRoll,
  Heap_default as Heap,
  HeightReference_default as HeightReference,
  HeightmapEncoding_default as HeightmapEncoding,
  HeightmapTerrainData_default as HeightmapTerrainData,
  HeightmapTessellator_default as HeightmapTessellator,
  HermitePolynomialApproximation_default as HermitePolynomialApproximation,
  HermiteSpline_default as HermiteSpline,
  HilbertOrder_default as HilbertOrder,
  HomeButton_default as HomeButton,
  HomeButtonViewModel_default as HomeButtonViewModel,
  HorizontalOrigin_default as HorizontalOrigin,
  I3dmLoader_default as I3dmLoader,
  I3dmParser_default as I3dmParser,
  Iau2000Orientation_default as Iau2000Orientation,
  Iau2006XysData_default as Iau2006XysData,
  Iau2006XysSample_default as Iau2006XysSample,
  IauOrientationAxes_default as IauOrientationAxes,
  IauOrientationParameters_default as IauOrientationParameters,
  ImageBasedLighting,
  ImageBasedLightingPipelineStage_default as ImageBasedLightingPipelineStage,
  ImageMaterialProperty_default as ImageMaterialProperty,
  Imagery_default as Imagery,
  ImageryLayer_default as ImageryLayer,
  ImageryLayerCollection_default as ImageryLayerCollection,
  ImageryLayerFeatureInfo_default as ImageryLayerFeatureInfo,
  ImageryProvider_default as ImageryProvider,
  ImagerySplitDirection_default as ImagerySplitDirection,
  ImageryState_default as ImageryState,
  Implicit3DTileContent,
  ImplicitAvailabilityBitstream,
  ImplicitMetadataView,
  ImplicitSubdivisionScheme_default as ImplicitSubdivisionScheme,
  ImplicitSubtree,
  ImplicitSubtreeMetadata_default as ImplicitSubtreeMetadata,
  ImplicitTileCoordinates,
  ImplicitTileset,
  IndexDatatype_default as IndexDatatype,
  InfoBox_default as InfoBox,
  InfoBoxViewModel_default as InfoBoxViewModel,
  InspectorShared_default as InspectorShared,
  InstanceAttributeSemantic_default as InstanceAttributeSemantic,
  Instanced3DModel3DTileContent_default as Instanced3DModel3DTileContent,
  InstancingPipelineStage_default as InstancingPipelineStage,
  InterpolationAlgorithm_default as InterpolationAlgorithm,
  InterpolationType_default as InterpolationType,
  Intersect_default as Intersect,
  IntersectionTests_default as IntersectionTests,
  Intersections2D_default as Intersections2D,
  Interval_default as Interval,
  InvertClassification_default as InvertClassification,
  Ion_default as Ion,
  IonGeocoderService_default as IonGeocoderService,
  IonImageryProvider_default as IonImageryProvider,
  IonResource_default as IonResource,
  IonWorldImageryStyle_default as IonWorldImageryStyle,
  Iso8601_default as Iso8601,
  JobScheduler_default as JobScheduler,
  JobType_default as JobType,
  JsonMetadataTable,
  JulianDate_default as JulianDate,
  KTX2Transcoder_default as KTX2Transcoder,
  KeyboardEventModifier_default as KeyboardEventModifier,
  KmlCamera_default as KmlCamera,
  KmlDataSource_default as KmlDataSource,
  KmlLookAt_default as KmlLookAt,
  KmlTour_default as KmlTour,
  KmlTourFlyTo_default as KmlTourFlyTo,
  KmlTourWait_default as KmlTourWait,
  Label_default as Label,
  LabelCollection_default as LabelCollection,
  LabelGraphics_default as LabelGraphics,
  LabelStyle_default as LabelStyle,
  LabelVisualizer_default as LabelVisualizer,
  LagrangePolynomialApproximation_default as LagrangePolynomialApproximation,
  LeapSecond_default as LeapSecond,
  Light_default as Light,
  LightingModel_default as LightingModel,
  LightingPipelineStage_default as LightingPipelineStage,
  LinearApproximation_default as LinearApproximation,
  LinearSpline_default as LinearSpline,
  ManagedArray_default as ManagedArray,
  MapMode2D_default as MapMode2D,
  MapProjection_default as MapProjection,
  MapboxImageryProvider_default as MapboxImageryProvider,
  MapboxStyleImageryProvider_default as MapboxStyleImageryProvider,
  Material_default as Material,
  MaterialAppearance_default as MaterialAppearance,
  MaterialPipelineStage_default as MaterialPipelineStage,
  MaterialProperty_default as MaterialProperty,
  Math_default as Math,
  Matrix2_default as Matrix2,
  Matrix3_default as Matrix3,
  Matrix4_default as Matrix4,
  MetadataClass_default as MetadataClass,
  MetadataClassProperty_default as MetadataClassProperty,
  MetadataComponentType_default as MetadataComponentType,
  MetadataEntity_default as MetadataEntity,
  MetadataEnum_default as MetadataEnum,
  MetadataEnumValue_default as MetadataEnumValue,
  MetadataPipelineStage_default as MetadataPipelineStage,
  MetadataSchema_default as MetadataSchema,
  MetadataSchemaLoader,
  MetadataSemantic_default as MetadataSemantic,
  MetadataTable_default as MetadataTable,
  MetadataTableProperty_default as MetadataTableProperty,
  MetadataType_default as MetadataType,
  MipmapHint_default as MipmapHint,
  Model_default as Model,
  ModelAlphaOptions,
  ModelAnimation_default as ModelAnimation,
  ModelAnimationCache_default as ModelAnimationCache,
  ModelAnimationCollection_default as ModelAnimationCollection,
  ModelAnimationLoop_default as ModelAnimationLoop,
  ModelAnimationState_default as ModelAnimationState,
  ModelClippingPlanesPipelineStage_default as ModelClippingPlanesPipelineStage,
  ModelColorPipelineStage_default as ModelColorPipelineStage,
  ModelComponents_default as ModelComponents,
  ModelExperimental,
  ModelExperimental3DTileContent,
  ModelExperimentalAnimation_default as ModelExperimentalAnimation,
  ModelExperimentalAnimationChannel_default as ModelExperimentalAnimationChannel,
  ModelExperimentalAnimationCollection_default as ModelExperimentalAnimationCollection,
  ModelExperimentalNode,
  ModelExperimentalPrimitive,
  ModelExperimentalSceneGraph,
  ModelExperimentalSkin,
  ModelExperimentalType_default as ModelExperimentalType,
  ModelExperimentalUtility,
  ModelFeature,
  ModelFeatureTable,
  ModelGraphics_default as ModelGraphics,
  ModelInstance_default as ModelInstance,
  ModelInstanceCollection_default as ModelInstanceCollection,
  ModelLightingOptions,
  ModelLoadResources_default as ModelLoadResources,
  ModelMaterial_default as ModelMaterial,
  ModelMatrixUpdateStage_default as ModelMatrixUpdateStage,
  ModelMesh_default as ModelMesh,
  ModelNode_default as ModelNode,
  ModelOutlineLoader_default as ModelOutlineLoader,
  ModelRenderResources,
  ModelSplitterPipelineStage_default as ModelSplitterPipelineStage,
  ModelUtility_default as ModelUtility,
  ModelVisualizer_default as ModelVisualizer,
  Moon_default as Moon,
  MorphTargetsPipelineStage_default as MorphTargetsPipelineStage,
  MorphWeightSpline_default as MorphWeightSpline,
  MortonOrder_default as MortonOrder,
  Multiple3DTileContent,
  MultisampleFramebuffer_default as MultisampleFramebuffer,
  NavigationHelpButton_default as NavigationHelpButton,
  NavigationHelpButtonViewModel_default as NavigationHelpButtonViewModel,
  NearFarScalar_default as NearFarScalar,
  NeverTileDiscardPolicy_default as NeverTileDiscardPolicy,
  NodeRenderResources,
  NodeTransformationProperty_default as NodeTransformationProperty,
  OIT_default as OIT,
  Occluder_default as Occluder,
  OctahedralProjectedCubeMap_default as OctahedralProjectedCubeMap,
  OffsetGeometryInstanceAttribute_default as OffsetGeometryInstanceAttribute,
  OpenCageGeocoderService_default as OpenCageGeocoderService,
  OpenStreetMapImageryProvider_default as OpenStreetMapImageryProvider,
  OrderedGroundPrimitiveCollection_default as OrderedGroundPrimitiveCollection,
  OrientedBoundingBox_default as OrientedBoundingBox,
  OrthographicFrustum_default as OrthographicFrustum,
  OrthographicOffCenterFrustum_default as OrthographicOffCenterFrustum,
  Packable_default as Packable,
  PackableForInterpolation_default as PackableForInterpolation,
  Particle_default as Particle,
  ParticleBurst_default as ParticleBurst,
  ParticleEmitter_default as ParticleEmitter,
  ParticleSystem_default as ParticleSystem,
  Pass_default as Pass,
  PassState_default as PassState,
  PathGraphics_default as PathGraphics,
  PathVisualizer_default as PathVisualizer,
  PeliasGeocoderService_default as PeliasGeocoderService,
  PerInstanceColorAppearance_default as PerInstanceColorAppearance,
  PerformanceDisplay_default as PerformanceDisplay,
  PerformanceWatchdog_default as PerformanceWatchdog,
  PerformanceWatchdogViewModel_default as PerformanceWatchdogViewModel,
  PerspectiveFrustum_default as PerspectiveFrustum,
  PerspectiveOffCenterFrustum_default as PerspectiveOffCenterFrustum,
  PickDepth_default as PickDepth,
  PickDepthFramebuffer_default as PickDepthFramebuffer,
  PickFramebuffer_default as PickFramebuffer,
  Picking_default as Picking,
  PickingPipelineStage_default as PickingPipelineStage,
  PinBuilder_default as PinBuilder,
  PixelDatatype_default as PixelDatatype,
  PixelFormat_default as PixelFormat,
  Plane_default as Plane,
  PlaneGeometry_default as PlaneGeometry,
  PlaneGeometryUpdater_default as PlaneGeometryUpdater,
  PlaneGraphics_default as PlaneGraphics,
  PlaneOutlineGeometry_default as PlaneOutlineGeometry,
  PntsLoader,
  PntsParser_default as PntsParser,
  PointCloud_default as PointCloud,
  PointCloud3DTileContent_default as PointCloud3DTileContent,
  PointCloudAttenuationPipelineStage_default as PointCloudAttenuationPipelineStage,
  PointCloudEyeDomeLighting_default2 as PointCloudEyeDomeLighting,
  PointCloudShading_default as PointCloudShading,
  PointGraphics_default as PointGraphics,
  PointPrimitive_default as PointPrimitive,
  PointPrimitiveCollection_default as PointPrimitiveCollection,
  PointVisualizer_default as PointVisualizer,
  PolygonGeometry_default as PolygonGeometry,
  PolygonGeometryLibrary_default as PolygonGeometryLibrary,
  PolygonGeometryUpdater_default as PolygonGeometryUpdater,
  PolygonGraphics_default as PolygonGraphics,
  PolygonHierarchy_default as PolygonHierarchy,
  PolygonOutlineGeometry_default as PolygonOutlineGeometry,
  PolygonPipeline_default as PolygonPipeline,
  Polyline_default as Polyline,
  PolylineArrowMaterialProperty_default as PolylineArrowMaterialProperty,
  PolylineCollection_default as PolylineCollection,
  PolylineColorAppearance_default as PolylineColorAppearance,
  PolylineDashMaterialProperty_default as PolylineDashMaterialProperty,
  PolylineGeometry_default as PolylineGeometry,
  PolylineGeometryUpdater_default as PolylineGeometryUpdater,
  PolylineGlowMaterialProperty_default as PolylineGlowMaterialProperty,
  PolylineGraphics_default as PolylineGraphics,
  PolylineMaterialAppearance_default as PolylineMaterialAppearance,
  PolylineOutlineMaterialProperty_default as PolylineOutlineMaterialProperty,
  PolylinePipeline_default as PolylinePipeline,
  PolylineVisualizer_default as PolylineVisualizer,
  PolylineVolumeGeometry_default as PolylineVolumeGeometry,
  PolylineVolumeGeometryLibrary_default as PolylineVolumeGeometryLibrary,
  PolylineVolumeGeometryUpdater_default as PolylineVolumeGeometryUpdater,
  PolylineVolumeGraphics_default as PolylineVolumeGraphics,
  PolylineVolumeOutlineGeometry_default as PolylineVolumeOutlineGeometry,
  PositionProperty_default as PositionProperty,
  PositionPropertyArray_default as PositionPropertyArray,
  PostProcessStage_default as PostProcessStage,
  PostProcessStageCollection_default as PostProcessStageCollection,
  PostProcessStageComposite_default as PostProcessStageComposite,
  PostProcessStageLibrary_default as PostProcessStageLibrary,
  PostProcessStageSampleMode_default as PostProcessStageSampleMode,
  PostProcessStageTextureCache_default as PostProcessStageTextureCache,
  Primitive_default as Primitive,
  PrimitiveCollection_default as PrimitiveCollection,
  PrimitivePipeline_default as PrimitivePipeline,
  PrimitiveRenderResources,
  PrimitiveState_default as PrimitiveState,
  PrimitiveType_default as PrimitiveType,
  ProjectionPicker_default as ProjectionPicker,
  ProjectionPickerViewModel_default as ProjectionPickerViewModel,
  Property_default as Property,
  PropertyArray_default as PropertyArray,
  PropertyAttribute,
  PropertyAttributeProperty,
  PropertyBag_default as PropertyBag,
  PropertyTable_default as PropertyTable,
  PropertyTexture_default as PropertyTexture,
  PropertyTextureProperty_default as PropertyTextureProperty,
  ProviderViewModel_default as ProviderViewModel,
  Proxy_default as Proxy,
  QuadraticRealPolynomial_default as QuadraticRealPolynomial,
  QuadtreeOccluders_default as QuadtreeOccluders,
  QuadtreePrimitive_default as QuadtreePrimitive,
  QuadtreeTile_default as QuadtreeTile,
  QuadtreeTileLoadState_default as QuadtreeTileLoadState,
  QuadtreeTileProvider_default as QuadtreeTileProvider,
  QuantizedMeshTerrainData_default as QuantizedMeshTerrainData,
  QuarticRealPolynomial_default as QuarticRealPolynomial,
  Quaternion_default as Quaternion,
  QuaternionSpline_default as QuaternionSpline,
  Queue_default as Queue,
  Ray_default as Ray,
  Rectangle_default as Rectangle,
  RectangleCollisionChecker_default as RectangleCollisionChecker,
  RectangleGeometry_default as RectangleGeometry,
  RectangleGeometryLibrary_default as RectangleGeometryLibrary,
  RectangleGeometryUpdater_default as RectangleGeometryUpdater,
  RectangleGraphics_default as RectangleGraphics,
  RectangleOutlineGeometry_default as RectangleOutlineGeometry,
  ReferenceFrame_default as ReferenceFrame,
  ReferenceProperty_default as ReferenceProperty,
  RenderState_default as RenderState,
  Renderbuffer_default as Renderbuffer,
  RenderbufferFormat_default as RenderbufferFormat,
  Request_default as Request,
  RequestErrorEvent_default as RequestErrorEvent,
  RequestScheduler_default as RequestScheduler,
  RequestState_default as RequestState,
  RequestType_default as RequestType,
  Resource_default as Resource,
  ResourceCache_default as ResourceCache,
  ResourceCacheKey_default as ResourceCacheKey,
  ResourceLoader,
  ResourceLoaderState_default as ResourceLoaderState,
  Rotation_default as Rotation,
  RuntimeError_default as RuntimeError,
  S2Cell_default as S2Cell,
  SDFSettings_default as SDFSettings,
  SampledPositionProperty_default as SampledPositionProperty,
  SampledProperty_default as SampledProperty,
  Sampler_default as Sampler,
  ScaledPositionProperty_default as ScaledPositionProperty,
  Scene_default as Scene,
  SceneFramebuffer_default as SceneFramebuffer,
  SceneMode_default as SceneMode,
  SceneModePicker_default as SceneModePicker,
  SceneModePickerViewModel_default as SceneModePickerViewModel,
  SceneTransforms_default as SceneTransforms,
  SceneTransitioner_default as SceneTransitioner,
  ScreenSpaceCameraController_default as ScreenSpaceCameraController,
  ScreenSpaceEventHandler_default as ScreenSpaceEventHandler,
  ScreenSpaceEventType_default as ScreenSpaceEventType,
  SelectedFeatureIdPipelineStage_default as SelectedFeatureIdPipelineStage,
  SelectionIndicator_default as SelectionIndicator,
  SelectionIndicatorViewModel_default as SelectionIndicatorViewModel,
  ShaderBuilder,
  ShaderCache_default as ShaderCache,
  ShaderDestination_default as ShaderDestination,
  ShaderFunction,
  ShaderProgram_default as ShaderProgram,
  ShaderSource_default as ShaderSource,
  ShaderStruct,
  ShadowMap_default as ShadowMap,
  ShadowMapShader_default as ShadowMapShader,
  ShadowMode_default as ShadowMode,
  ShadowVolumeAppearance_default as ShadowVolumeAppearance,
  ShowGeometryInstanceAttribute_default as ShowGeometryInstanceAttribute,
  Simon1994PlanetaryPositions_default as Simon1994PlanetaryPositions,
  SimplePolylineGeometry_default as SimplePolylineGeometry,
  SingleTileImageryProvider_default as SingleTileImageryProvider,
  SkinningPipelineStage_default as SkinningPipelineStage,
  SkyAtmosphere_default as SkyAtmosphere,
  SkyBox_default as SkyBox,
  SphereEmitter_default as SphereEmitter,
  SphereGeometry_default as SphereGeometry,
  SphereOutlineGeometry_default as SphereOutlineGeometry,
  Spherical_default as Spherical,
  Spline_default as Spline,
  SplitDirection_default as SplitDirection,
  Splitter_default as Splitter,
  StaticGeometryColorBatch_default as StaticGeometryColorBatch,
  StaticGeometryPerMaterialBatch_default as StaticGeometryPerMaterialBatch,
  StaticGroundGeometryColorBatch_default as StaticGroundGeometryColorBatch,
  StaticGroundGeometryPerMaterialBatch_default as StaticGroundGeometryPerMaterialBatch,
  StaticGroundPolylinePerMaterialBatch_default as StaticGroundPolylinePerMaterialBatch,
  StaticOutlineGeometryBatch_default as StaticOutlineGeometryBatch,
  StencilConstants_default as StencilConstants,
  StencilFunction_default as StencilFunction,
  StencilOperation_default as StencilOperation,
  SteppedSpline_default as SteppedSpline,
  StripeMaterialProperty_default as StripeMaterialProperty,
  StripeOrientation_default as StripeOrientation,
  StructuralMetadata_default as StructuralMetadata,
  StyleCommandsNeeded_default as StyleCommandsNeeded,
  StyleExpression_default as StyleExpression,
  Sun_default as Sun,
  SunLight_default as SunLight,
  SunPostProcess_default as SunPostProcess,
  SupportedImageFormats,
  SvgPathBindingHandler_default as SvgPathBindingHandler,
  TaskProcessor_default as TaskProcessor,
  TerrainData_default as TerrainData,
  TerrainEncoding_default as TerrainEncoding,
  TerrainExaggeration_default as TerrainExaggeration,
  TerrainFillMesh_default as TerrainFillMesh,
  TerrainMesh_default as TerrainMesh,
  TerrainOffsetProperty_default as TerrainOffsetProperty,
  TerrainProvider_default as TerrainProvider,
  TerrainQuantization_default as TerrainQuantization,
  TerrainState_default as TerrainState,
  Texture_default as Texture,
  TextureAtlas_default as TextureAtlas,
  TextureCache_default as TextureCache,
  TextureMagnificationFilter_default as TextureMagnificationFilter,
  TextureManager,
  TextureMinificationFilter_default as TextureMinificationFilter,
  TextureUniform,
  TextureWrap_default as TextureWrap,
  TileAvailability_default as TileAvailability,
  TileBoundingRegion_default as TileBoundingRegion,
  TileBoundingS2Cell_default as TileBoundingS2Cell,
  TileBoundingSphere_default as TileBoundingSphere,
  TileBoundingVolume_default as TileBoundingVolume,
  TileCoordinatesImageryProvider_default as TileCoordinatesImageryProvider,
  TileDiscardPolicy_default as TileDiscardPolicy,
  TileEdge_default as TileEdge,
  TileImagery_default as TileImagery,
  TileMapServiceImageryProvider_default as TileMapServiceImageryProvider,
  TileMetadata,
  TileOrientedBoundingBox_default as TileOrientedBoundingBox,
  TileProviderError_default as TileProviderError,
  TileReplacementQueue_default as TileReplacementQueue,
  TileSelectionResult_default as TileSelectionResult,
  TileState_default as TileState,
  Tileset3DTileContent_default as Tileset3DTileContent,
  TilesetMetadata_default as TilesetMetadata,
  TilingScheme_default as TilingScheme,
  TimeConstants_default as TimeConstants,
  TimeDynamicImagery_default as TimeDynamicImagery,
  TimeDynamicPointCloud_default as TimeDynamicPointCloud,
  TimeInterval_default as TimeInterval,
  TimeIntervalCollection_default as TimeIntervalCollection,
  TimeIntervalCollectionPositionProperty_default as TimeIntervalCollectionPositionProperty,
  TimeIntervalCollectionProperty_default as TimeIntervalCollectionProperty,
  TimeStandard_default as TimeStandard,
  Timeline_default as Timeline,
  TimelineHighlightRange_default as TimelineHighlightRange,
  TimelineTrack_default as TimelineTrack,
  Tipsify_default as Tipsify,
  ToggleButtonViewModel_default as ToggleButtonViewModel,
  Tonemapper_default as Tonemapper,
  Transforms_default as Transforms,
  TranslationRotationScale_default as TranslationRotationScale,
  TranslucentTileClassification_default as TranslucentTileClassification,
  TridiagonalSystemSolver_default as TridiagonalSystemSolver,
  TrustedServers_default as TrustedServers,
  Tween,
  TweenCollection_default as TweenCollection,
  UniformState_default as UniformState,
  UniformType_default as UniformType,
  URI as Uri,
  UrlTemplateImageryProvider_default as UrlTemplateImageryProvider,
  VERSION,
  VRButton_default as VRButton,
  VRButtonViewModel_default as VRButtonViewModel,
  VRTheWorldTerrainProvider_default as VRTheWorldTerrainProvider,
  VaryingType_default as VaryingType,
  Vector3DTileBatch_default as Vector3DTileBatch,
  Vector3DTileClampedPolylines_default as Vector3DTileClampedPolylines,
  Vector3DTileContent_default as Vector3DTileContent,
  Vector3DTileGeometry_default as Vector3DTileGeometry,
  Vector3DTilePoints_default as Vector3DTilePoints,
  Vector3DTilePolygons_default as Vector3DTilePolygons,
  Vector3DTilePolylines_default as Vector3DTilePolylines,
  Vector3DTilePrimitive_default as Vector3DTilePrimitive,
  VelocityOrientationProperty_default as VelocityOrientationProperty,
  VelocityVectorProperty_default as VelocityVectorProperty,
  VertexArray_default as VertexArray,
  VertexArrayFacade_default as VertexArrayFacade,
  VertexAttributeSemantic_default as VertexAttributeSemantic,
  VertexFormat_default as VertexFormat,
  VerticalOrigin_default as VerticalOrigin,
  VideoSynchronizer_default as VideoSynchronizer,
  View_default as View,
  Viewer_default as Viewer,
  ViewportQuad_default as ViewportQuad,
  Visibility_default as Visibility,
  Visualizer_default as Visualizer,
  VulkanConstants_default as VulkanConstants,
  WallGeometry_default as WallGeometry,
  WallGeometryLibrary_default as WallGeometryLibrary,
  WallGeometryUpdater_default as WallGeometryUpdater,
  WallGraphics_default as WallGraphics,
  WallOutlineGeometry_default as WallOutlineGeometry,
  WebGLConstants_default as WebGLConstants,
  WebMapServiceImageryProvider_default as WebMapServiceImageryProvider,
  WebMapTileServiceImageryProvider_default as WebMapTileServiceImageryProvider,
  WebMercatorProjection_default as WebMercatorProjection,
  WebMercatorTilingScheme_default as WebMercatorTilingScheme,
  WindingOrder_default as WindingOrder,
  WireframeIndexGenerator_default as WireframeIndexGenerator,
  AcesTonemappingStage_default as _shadersAcesTonemappingStage,
  AdditiveBlend_default as _shadersAdditiveBlend,
  AdjustTranslucentFS_default as _shadersAdjustTranslucentFS,
  AllMaterialAppearanceFS_default as _shadersAllMaterialAppearanceFS,
  AllMaterialAppearanceVS_default as _shadersAllMaterialAppearanceVS,
  AmbientOcclusionGenerate_default as _shadersAmbientOcclusionGenerate,
  AmbientOcclusionModulate_default as _shadersAmbientOcclusionModulate,
  AspectRampMaterial_default as _shadersAspectRampMaterial,
  AtmosphereCommon_default as _shadersAtmosphereCommon,
  BasicMaterialAppearanceFS_default as _shadersBasicMaterialAppearanceFS,
  BasicMaterialAppearanceVS_default as _shadersBasicMaterialAppearanceVS,
  BillboardCollectionFS_default as _shadersBillboardCollectionFS,
  BillboardCollectionVS_default as _shadersBillboardCollectionVS,
  BlackAndWhite_default as _shadersBlackAndWhite,
  BloomComposite_default as _shadersBloomComposite,
  BrdfLutGeneratorFS_default as _shadersBrdfLutGeneratorFS,
  BrightPass_default as _shadersBrightPass,
  Brightness_default as _shadersBrightness,
  BumpMapMaterial_default as _shadersBumpMapMaterial,
  CPUStylingStageFS_default as _shadersCPUStylingStageFS,
  CPUStylingStageVS_default as _shadersCPUStylingStageVS,
  CheckerboardMaterial_default as _shadersCheckerboardMaterial,
  CloudCollectionFS_default as _shadersCloudCollectionFS,
  CloudCollectionVS_default as _shadersCloudCollectionVS,
  CloudNoiseFS_default as _shadersCloudNoiseFS,
  CloudNoiseVS_default as _shadersCloudNoiseVS,
  CompareAndPackTranslucentDepth_default as _shadersCompareAndPackTranslucentDepth,
  CompositeOITFS_default as _shadersCompositeOITFS,
  CompositeTranslucentClassification_default as _shadersCompositeTranslucentClassification,
  ContrastBias_default as _shadersContrastBias,
  CustomShaderStageFS_default as _shadersCustomShaderStageFS,
  CustomShaderStageVS_default as _shadersCustomShaderStageVS,
  CzmBuiltins_default as _shadersCzmBuiltins,
  DepthOfField_default as _shadersDepthOfField,
  DepthPlaneFS_default as _shadersDepthPlaneFS,
  DepthPlaneVS_default as _shadersDepthPlaneVS,
  DepthView_default as _shadersDepthView,
  DepthViewPacked_default as _shadersDepthViewPacked,
  DotMaterial_default as _shadersDotMaterial,
  EdgeDetection_default as _shadersEdgeDetection,
  ElevationBandMaterial_default as _shadersElevationBandMaterial,
  ElevationContourMaterial_default as _shadersElevationContourMaterial,
  ElevationRampMaterial_default as _shadersElevationRampMaterial,
  EllipsoidFS_default as _shadersEllipsoidFS,
  EllipsoidSurfaceAppearanceFS_default as _shadersEllipsoidSurfaceAppearanceFS,
  EllipsoidSurfaceAppearanceVS_default as _shadersEllipsoidSurfaceAppearanceVS,
  EllipsoidVS_default as _shadersEllipsoidVS,
  FXAA_default as _shadersFXAA,
  FXAA3_11_default as _shadersFXAA3_11,
  FadeMaterial_default as _shadersFadeMaterial,
  FeatureIdStageFS_default as _shadersFeatureIdStageFS,
  FeatureIdStageVS_default as _shadersFeatureIdStageVS,
  FilmicTonemapping_default as _shadersFilmicTonemapping,
  GaussianBlur1D_default as _shadersGaussianBlur1D,
  GeometryStageFS_default as _shadersGeometryStageFS,
  GeometryStageVS_default as _shadersGeometryStageVS,
  GlobeFS_default as _shadersGlobeFS,
  GlobeVS_default as _shadersGlobeVS,
  GridMaterial_default as _shadersGridMaterial,
  GroundAtmosphere_default as _shadersGroundAtmosphere,
  HSBToRGB_default as _shadersHSBToRGB,
  HSLToRGB_default as _shadersHSLToRGB,
  ImageBasedLightingStageFS_default as _shadersImageBasedLightingStageFS,
  InstancingStageCommon_default as _shadersInstancingStageCommon,
  InstancingStageVS_default as _shadersInstancingStageVS,
  LegacyInstancingStageVS_default as _shadersLegacyInstancingStageVS,
  LensFlare_default as _shadersLensFlare,
  LightingStageFS_default as _shadersLightingStageFS,
  MaterialStageFS_default as _shadersMaterialStageFS,
  MetadataStageFS_default as _shadersMetadataStageFS,
  MetadataStageVS_default as _shadersMetadataStageVS,
  ModelClippingPlanesStageFS_default as _shadersModelClippingPlanesStageFS,
  ModelColorStageFS_default as _shadersModelColorStageFS,
  ModelExperimentalFS_default as _shadersModelExperimentalFS,
  ModelExperimentalVS_default as _shadersModelExperimentalVS,
  ModelSplitterStageFS_default as _shadersModelSplitterStageFS,
  ModifiedReinhardTonemapping_default as _shadersModifiedReinhardTonemapping,
  MorphTargetsStageVS_default as _shadersMorphTargetsStageVS,
  NightVision_default as _shadersNightVision,
  NormalMapMaterial_default as _shadersNormalMapMaterial,
  OctahedralProjectionAtlasFS_default as _shadersOctahedralProjectionAtlasFS,
  OctahedralProjectionFS_default as _shadersOctahedralProjectionFS,
  OctahedralProjectionVS_default as _shadersOctahedralProjectionVS,
  PassThrough_default as _shadersPassThrough,
  PassThroughDepth_default as _shadersPassThroughDepth,
  PerInstanceColorAppearanceFS_default as _shadersPerInstanceColorAppearanceFS,
  PerInstanceColorAppearanceVS_default as _shadersPerInstanceColorAppearanceVS,
  PerInstanceFlatColorAppearanceFS_default as _shadersPerInstanceFlatColorAppearanceFS,
  PerInstanceFlatColorAppearanceVS_default as _shadersPerInstanceFlatColorAppearanceVS,
  PointCloudAttenuationStageVS_default as _shadersPointCloudAttenuationStageVS,
  PointCloudEyeDomeLighting_default as _shadersPointCloudEyeDomeLighting,
  PointPrimitiveCollectionFS_default as _shadersPointPrimitiveCollectionFS,
  PointPrimitiveCollectionVS_default as _shadersPointPrimitiveCollectionVS,
  PolylineArrowMaterial_default as _shadersPolylineArrowMaterial,
  PolylineColorAppearanceVS_default as _shadersPolylineColorAppearanceVS,
  PolylineCommon_default as _shadersPolylineCommon,
  PolylineDashMaterial_default as _shadersPolylineDashMaterial,
  PolylineFS_default as _shadersPolylineFS,
  PolylineGlowMaterial_default as _shadersPolylineGlowMaterial,
  PolylineMaterialAppearanceVS_default as _shadersPolylineMaterialAppearanceVS,
  PolylineOutlineMaterial_default as _shadersPolylineOutlineMaterial,
  PolylineShadowVolumeFS_default as _shadersPolylineShadowVolumeFS,
  PolylineShadowVolumeMorphFS_default as _shadersPolylineShadowVolumeMorphFS,
  PolylineShadowVolumeMorphVS_default as _shadersPolylineShadowVolumeMorphVS,
  PolylineShadowVolumeVS_default as _shadersPolylineShadowVolumeVS,
  PolylineVS_default as _shadersPolylineVS,
  RGBToHSB_default as _shadersRGBToHSB,
  RGBToHSL_default as _shadersRGBToHSL,
  RGBToXYZ_default as _shadersRGBToXYZ,
  ReinhardTonemapping_default as _shadersReinhardTonemapping,
  ReprojectWebMercatorFS_default as _shadersReprojectWebMercatorFS,
  ReprojectWebMercatorVS_default as _shadersReprojectWebMercatorVS,
  RimLightingMaterial_default as _shadersRimLightingMaterial,
  SelectedFeatureIdStageCommon_default as _shadersSelectedFeatureIdStageCommon,
  ShadowVolumeAppearanceFS_default as _shadersShadowVolumeAppearanceFS,
  ShadowVolumeAppearanceVS_default as _shadersShadowVolumeAppearanceVS,
  ShadowVolumeFS_default as _shadersShadowVolumeFS,
  Silhouette_default as _shadersSilhouette,
  SkinningStageVS_default as _shadersSkinningStageVS,
  SkyAtmosphereCommon_default as _shadersSkyAtmosphereCommon,
  SkyAtmosphereFS_default as _shadersSkyAtmosphereFS,
  SkyAtmosphereVS_default as _shadersSkyAtmosphereVS,
  SkyBoxFS_default as _shadersSkyBoxFS,
  SkyBoxVS_default as _shadersSkyBoxVS,
  SlopeRampMaterial_default as _shadersSlopeRampMaterial,
  StripeMaterial_default as _shadersStripeMaterial,
  SunFS_default as _shadersSunFS,
  SunTextureFS_default as _shadersSunTextureFS,
  SunVS_default as _shadersSunVS,
  TexturedMaterialAppearanceFS_default as _shadersTexturedMaterialAppearanceFS,
  TexturedMaterialAppearanceVS_default as _shadersTexturedMaterialAppearanceVS,
  Vector3DTileClampedPolylinesFS_default as _shadersVector3DTileClampedPolylinesFS,
  Vector3DTileClampedPolylinesVS_default as _shadersVector3DTileClampedPolylinesVS,
  Vector3DTilePolylinesVS_default as _shadersVector3DTilePolylinesVS,
  VectorTileVS_default as _shadersVectorTileVS,
  ViewportQuadFS_default as _shadersViewportQuadFS,
  ViewportQuadVS_default as _shadersViewportQuadVS,
  Water_default as _shadersWater,
  XYZToRGB_default as _shadersXYZToRGB,
  acesTonemapping_default as _shadersacesTonemapping,
  alphaWeight_default as _shadersalphaWeight,
  antialias_default as _shadersantialias,
  approximateSphericalCoordinates_default as _shadersapproximateSphericalCoordinates,
  backFacing_default as _shadersbackFacing,
  branchFreeTernary_default as _shadersbranchFreeTernary,
  cascadeColor_default as _shaderscascadeColor,
  cascadeDistance_default as _shaderscascadeDistance,
  cascadeMatrix_default as _shaderscascadeMatrix,
  cascadeWeights_default as _shaderscascadeWeights,
  columbusViewMorph_default as _shaderscolumbusViewMorph,
  computePosition_default as _shaderscomputePosition,
  cosineAndSine_default as _shaderscosineAndSine,
  decompressTextureCoordinates_default as _shadersdecompressTextureCoordinates,
  defaultPbrMaterial_default as _shadersdefaultPbrMaterial,
  degreesPerRadian_default as _shadersdegreesPerRadian,
  depthClamp_default as _shadersdepthClamp,
  depthRange_default as _shadersdepthRange,
  depthRangeStruct_default as _shadersdepthRangeStruct,
  eastNorthUpToEyeCoordinates_default as _shaderseastNorthUpToEyeCoordinates,
  ellipsoidContainsPoint_default as _shadersellipsoidContainsPoint,
  ellipsoidWgs84TextureCoordinates_default as _shadersellipsoidWgs84TextureCoordinates,
  epsilon1_default as _shadersepsilon1,
  epsilon2_default as _shadersepsilon2,
  epsilon3_default as _shadersepsilon3,
  epsilon4_default as _shadersepsilon4,
  epsilon5_default as _shadersepsilon5,
  epsilon6_default as _shadersepsilon6,
  epsilon7_default as _shadersepsilon7,
  equalsEpsilon_default as _shadersequalsEpsilon,
  eyeOffset_default as _shaderseyeOffset,
  eyeToWindowCoordinates_default as _shaderseyeToWindowCoordinates,
  fastApproximateAtan_default as _shadersfastApproximateAtan,
  fog_default as _shadersfog,
  gammaCorrect_default as _shadersgammaCorrect,
  geodeticSurfaceNormal_default as _shadersgeodeticSurfaceNormal,
  getDefaultMaterial_default as _shadersgetDefaultMaterial,
  getLambertDiffuse_default as _shadersgetLambertDiffuse,
  getSpecular_default as _shadersgetSpecular,
  getWaterNoise_default as _shadersgetWaterNoise,
  hue_default as _shadershue,
  infinity_default as _shadersinfinity,
  inverseGamma_default as _shadersinverseGamma,
  isEmpty_default as _shadersisEmpty,
  isFull_default as _shadersisFull,
  latitudeToWebMercatorFraction_default as _shaderslatitudeToWebMercatorFraction,
  lineDistance_default as _shaderslineDistance,
  linearToSrgb_default as _shaderslinearToSrgb,
  luminance_default as _shadersluminance,
  material_default as _shadersmaterial,
  materialInput_default as _shadersmaterialInput,
  metersPerPixel_default as _shadersmetersPerPixel,
  modelMaterial_default as _shadersmodelMaterial,
  modelToWindowCoordinates_default as _shadersmodelToWindowCoordinates,
  modelVertexOutput_default as _shadersmodelVertexOutput,
  multiplyWithColorBalance_default as _shadersmultiplyWithColorBalance,
  nearFarScalar_default as _shadersnearFarScalar,
  octDecode_default as _shadersoctDecode,
  oneOverPi_default as _shadersoneOverPi,
  oneOverTwoPi_default as _shadersoneOverTwoPi,
  packDepth_default as _shaderspackDepth,
  passCesium3DTile_default as _shaderspassCesium3DTile,
  passCesium3DTileClassification_default as _shaderspassCesium3DTileClassification,
  passCesium3DTileClassificationIgnoreShow_default as _shaderspassCesium3DTileClassificationIgnoreShow,
  passClassification_default as _shaderspassClassification,
  passCompute_default as _shaderspassCompute,
  passEnvironment_default as _shaderspassEnvironment,
  passGlobe_default as _shaderspassGlobe,
  passOpaque_default as _shaderspassOpaque,
  passOverlay_default as _shaderspassOverlay,
  passTerrainClassification_default as _shaderspassTerrainClassification,
  passTranslucent_default as _shaderspassTranslucent,
  pbrLighting_default as _shaderspbrLighting,
  pbrMetallicRoughnessMaterial_default as _shaderspbrMetallicRoughnessMaterial,
  pbrParameters_default as _shaderspbrParameters,
  pbrSpecularGlossinessMaterial_default as _shaderspbrSpecularGlossinessMaterial,
  phong_default as _shadersphong,
  pi_default as _shaderspi,
  piOverFour_default as _shaderspiOverFour,
  piOverSix_default as _shaderspiOverSix,
  piOverThree_default as _shaderspiOverThree,
  piOverTwo_default as _shaderspiOverTwo,
  planeDistance_default as _shadersplaneDistance,
  pointAlongRay_default as _shaderspointAlongRay,
  radiansPerDegree_default as _shadersradiansPerDegree,
  ray_default as _shadersray,
  rayEllipsoidIntersectionInterval_default as _shadersrayEllipsoidIntersectionInterval,
  raySegment_default as _shadersraySegment,
  raySphereIntersectionInterval_default as _shadersraySphereIntersectionInterval,
  readDepth_default as _shadersreadDepth,
  readNonPerspective_default as _shadersreadNonPerspective,
  reverseLogDepth_default as _shadersreverseLogDepth,
  round_default as _shadersround,
  sampleOctahedralProjection_default as _shaderssampleOctahedralProjection,
  saturation_default as _shaderssaturation,
  sceneMode2D_default as _shaderssceneMode2D,
  sceneMode3D_default as _shaderssceneMode3D,
  sceneModeColumbusView_default as _shaderssceneModeColumbusView,
  sceneModeMorphing_default as _shaderssceneModeMorphing,
  shadowDepthCompare_default as _shadersshadowDepthCompare,
  shadowParameters_default as _shadersshadowParameters,
  shadowVisibility_default as _shadersshadowVisibility,
  signNotZero_default as _shaderssignNotZero,
  solarRadius_default as _shaderssolarRadius,
  sphericalHarmonics_default as _shaderssphericalHarmonics,
  srgbToLinear_default as _shaderssrgbToLinear,
  tangentToEyeSpaceMatrix_default as _shaderstangentToEyeSpaceMatrix,
  threePiOver2_default as _shadersthreePiOver2,
  transformPlane_default as _shaderstransformPlane,
  translateRelativeToEye_default as _shaderstranslateRelativeToEye,
  translucentPhong_default as _shaderstranslucentPhong,
  transpose_default as _shaderstranspose,
  twoPi_default as _shaderstwoPi,
  unpackDepth_default as _shadersunpackDepth,
  unpackFloat_default as _shadersunpackFloat,
  unpackUint_default as _shadersunpackUint,
  valueTransform_default as _shadersvalueTransform,
  vertexLogDepth_default as _shadersvertexLogDepth,
  webMercatorMaxLatitude_default as _shaderswebMercatorMaxLatitude,
  windowToEyeCoordinates_default as _shaderswindowToEyeCoordinates,
  writeDepthClamp_default as _shaderswriteDepthClamp,
  writeLogDepth_default as _shaderswriteLogDepth,
  writeNonPerspective_default as _shaderswriteNonPerspective,
  addBuffer_default as addBuffer,
  addDefaults_default as addDefaults,
  addExtensionsRequired_default as addExtensionsRequired,
  addExtensionsUsed_default as addExtensionsUsed,
  addPipelineExtras_default as addPipelineExtras,
  addToArray_default as addToArray,
  appendForwardSlash_default as appendForwardSlash,
  arrayFill_default as arrayFill,
  arrayRemoveDuplicates_default as arrayRemoveDuplicates,
  arraySlice_default as arraySlice,
  barycentricCoordinates_default as barycentricCoordinates,
  binarySearch_default as binarySearch,
  bitmapSdf as bitmap_sdf,
  buildDrawCommands,
  buildModuleUrl_default as buildModuleUrl,
  cancelAnimationFrame_default as cancelAnimationFrame,
  clone_default as clone,
  combine_default as combine,
  computeFlyToLocationForRectangle_default as computeFlyToLocationForRectangle,
  createBillboardPointCallback_default as createBillboardPointCallback,
  createCommand_default as createCommand,
  createDefaultImageryProviderViewModels_default as createDefaultImageryProviderViewModels,
  createDefaultTerrainProviderViewModels_default as createDefaultTerrainProviderViewModels,
  createElevationBandMaterial_default as createElevationBandMaterial,
  createGuid_default as createGuid,
  createMaterialPropertyDescriptor_default as createMaterialPropertyDescriptor,
  createOsmBuildings_default as createOsmBuildings,
  createPropertyDescriptor_default as createPropertyDescriptor,
  createRawPropertyDescriptor_default as createRawPropertyDescriptor,
  createTangentSpaceDebugPrimitive_default as createTangentSpaceDebugPrimitive,
  createTaskProcessorWorker_default as createTaskProcessorWorker,
  createUniform_default as createUniform,
  createUniformArray_default as createUniformArray,
  createWorldImagery_default as createWorldImagery,
  createWorldTerrain_default as createWorldTerrain,
  decodeGoogleEarthEnterpriseData_default as decodeGoogleEarthEnterpriseData,
  decodeVectorPolylinePositions_default as decodeVectorPolylinePositions,
  defaultValue_default as defaultValue,
  defer_default as defer,
  defined_default as defined,
  deprecationWarning_default as deprecationWarning,
  destroyObject_default as destroyObject,
  purify as dompurify,
  earcut_1 as earcut,
  exportKml_default as exportKml,
  findAccessorMinMax_default as findAccessorMinMax,
  findContentMetadata,
  findGroupMetadata,
  findTileMetadata,
  forEachTextureInMaterial_default as forEachTextureInMaterial,
  formatError_default as formatError,
  freezeRenderState_default as freezeRenderState,
  getAbsoluteUri_default as getAbsoluteUri,
  getAccessorByteStride_default as getAccessorByteStride,
  getBaseUri_default as getBaseUri,
  getBinaryAccessor_default as getBinaryAccessor,
  getClipAndStyleCode_default as getClipAndStyleCode,
  getClippingFunction_default as getClippingFunction,
  getComponentReader_default as getComponentReader,
  getElement_default as getElement,
  getExtensionFromUri_default as getExtensionFromUri,
  getFilenameFromUri_default as getFilenameFromUri,
  getImagePixels_default as getImagePixels,
  getJsonFromTypedArray_default as getJsonFromTypedArray,
  getMagic_default as getMagic,
  getStringFromTypedArray_default as getStringFromTypedArray,
  getTimestamp_default as getTimestamp,
  graphemeSplitter as grapheme_splitter,
  hasExtension,
  heightReferenceOnEntityPropertyChanged_default as heightReferenceOnEntityPropertyChanged,
  isBitSet_default as isBitSet,
  isBlobUri_default as isBlobUri,
  isCrossOriginUrl_default as isCrossOriginUrl,
  isDataUri_default as isDataUri,
  isLeapYear_default as isLeapYear,
  jsep,
  KDBush as kdbush,
  knockout_default as knockout,
  knockout_3_5_1_default as knockout_3_5_1,
  knockout_es5_default as knockout_es5,
  p as ktx_parse,
  LercDecode as lerc,
  loadAndExecuteScript_default as loadAndExecuteScript,
  loadCubeMap_default as loadCubeMap,
  loadImageFromTypedArray_default as loadImageFromTypedArray,
  loadKTX2_default as loadKTX2,
  mergeSort_default as mergeSort,
  mersenneTwister as mersenne_twister,
  MeshoptDecoder as meshoptimizer,
  modernizeShader_default as modernizeShader,
  moveTechniqueRenderStates_default as moveTechniqueRenderStates,
  moveTechniquesToExtension_default as moveTechniquesToExtension,
  src as nosleep,
  numberOfComponentsForType_default as numberOfComponentsForType,
  objectToQuery_default as objectToQuery,
  oneTimeWarning_default as oneTimeWarning,
  inflate_1 as pako,
  parseBatchTable,
  parseBoundingVolumeSemantics,
  parseFeatureMetadataLegacy,
  parseGlb_default as parseGlb,
  parseResponseHeaders_default as parseResponseHeaders,
  parseStructuralMetadata,
  pointInsideTriangle_default as pointInsideTriangle,
  preprocess3DTileContent,
  processModelMaterialsCommon_default as processModelMaterialsCommon,
  processPbrMaterials_default as processPbrMaterials,
  protobuf$1 as protobufjs,
  queryToObject_default as queryToObject,
  RBush as rbush,
  readAccessorPacked_default as readAccessorPacked,
  removeExtensionsRequired_default as removeExtensionsRequired,
  removeExtensionsUsed_default as removeExtensionsUsed,
  removePipelineExtras_default as removePipelineExtras,
  removeUnusedElements_default as removeUnusedElements,
  requestAnimationFrame_default as requestAnimationFrame,
  sampleTerrain_default as sampleTerrain,
  sampleTerrainMostDetailed_default as sampleTerrainMostDetailed,
  scaleToGeodeticSurface_default as scaleToGeodeticSurface,
  subdivideArray_default as subdivideArray,
  subscribeAndEvaluate_default as subscribeAndEvaluate,
  index as topojson,
  updateAccessorComponentTypes_default as updateAccessorComponentTypes,
  updateVersion_default as updateVersion,
  usesExtension_default as usesExtension,
  viewerCesium3DTilesInspectorMixin_default as viewerCesium3DTilesInspectorMixin,
  viewerCesiumInspectorMixin_default as viewerCesiumInspectorMixin,
  viewerDragDropMixin_default as viewerDragDropMixin,
  viewerPerformanceWatchdogMixin_default as viewerPerformanceWatchdogMixin,
  webGLConstantToGlslType_default as webGLConstantToGlslType,
  wrapFunction_default as wrapFunction,
  writeTextToCanvas_default as writeTextToCanvas,
  zipNoWorker as zip
};
/* Copyright 2015-2018 Esri. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 @preserve */
/*!
 * Knockout JavaScript library v3.5.1
 * (c) The Knockout.js team - http://knockoutjs.com/
 * License: MIT (http://www.opensource.org/licenses/mit-license.php)
 */
/*!
 * URI.js - Mutating URLs
 *
 * Version: 1.19.11
 *
 * Author: Rodney Rehm
 * Web: http://medialize.github.io/URI.js/
 *
 * Licensed under
 *   MIT License http://www.opensource.org/licenses/mit-license
 *
 */
/*!
 * URI.js - Mutating URLs
 * IPv6 Support
 *
 * Version: 1.19.11
 *
 * Author: Rodney Rehm
 * Web: http://medialize.github.io/URI.js/
 *
 * Licensed under
 *   MIT License http://www.opensource.org/licenses/mit-license
 *
 */
/*!
 * URI.js - Mutating URLs
 * Second Level Domain (SLD) Support
 *
 * Version: 1.19.11
 *
 * Author: Rodney Rehm
 * Web: http://medialize.github.io/URI.js/
 *
 * Licensed under
 *   MIT License http://www.opensource.org/licenses/mit-license
 *
 */
/*!
 * protobuf.js v6.7.0 (c) 2016, Daniel Wirtz
 * Compiled Sun, 02 Apr 2017 11:28:29 UTC
 * Licensed under the BSD-3-Clause License
 * see: https://github.com/dcodeIO/protobuf.js for details
 */
/*! @license DOMPurify 2.3.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.3.6/LICENSE */
/*! https://mths.be/punycode v1.3.2 by @mathias */
/**
 * @license
 * Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *  * Neither the name of NVIDIA CORPORATION nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/**
 * @license
 * Knockout ES5 plugin - https://github.com/SteveSanderson/knockout-es5
 * Copyright (c) Steve Sanderson
 * MIT license
 */
//# sourceMappingURL=cesium.js.map